feat(frontend): add schedule workflows

frontend/.env.example

@@ -1,2 +1,14 @@
-# Android emulator: 10.0.2.2 reaches the host machine.
-EXPO_PUBLIC_API_URL=http://10.0.2.2:8000/api/v1
+# Baidu Maps browser-side AK with JavaScript API enabled.
+# Allow localhost for web development and https://timeflow.local/* for the native WebView.
+EXPO_PUBLIC_BAIDU_MAP_AK=replace-with-your-baidu-map-ak
+
+# Real backend WebSocket URL (required for release / production builds).
+# The client appends its persisted device_id query parameter automatically.
+# Local device example: ws://192.168.1.10:8000/ws
+# Production example: wss://api.example.com/ws
+EXPO_PUBLIC_WS_URL=
+
+# Use in-process FakeWsServer when EXPO_PUBLIC_WS_URL is empty.
+# In __DEV__, Fake is allowed by default if this is unset.
+# Release builds always ignore this flag and fail fast without a URL.
+# EXPO_PUBLIC_USE_FAKE_WS=true

frontend/__tests__/app/overlay/OverlayProvider.test.tsx

@@ -0,0 +1,61 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import { fireEvent, render, screen } from '@testing-library/react-native';
+import { StrictMode } from 'react';
+import { Pressable, Text, View } from 'react-native';
+
+import { OverlayProvider, useOverlay, type OverlayKind } from '@/app/overlay/OverlayProvider';
+
+function Harness({ onClose }: { onClose: () => void }) {
+  const { pop, popKind, push, stack } = useOverlay();
+
+  const add = (kind: OverlayKind) => {
+    push({ kind, onClose });
+  };
+
+  return (
+    <>
+      <Text>{stack.map((entry) => entry.kind).join(',')}</Text>
+      <View>
+        <Pressable accessibilityLabel="push-standard" onPress={() => add('standardCreate')} />
+        <Pressable accessibilityLabel="push-assistant" onPress={() => add('assistant')} />
+        <Pressable accessibilityLabel="pop" onPress={pop} />
+        <Pressable accessibilityLabel="pop-standard" onPress={() => popKind('standardCreate')} />
+      </View>
+    </>
+  );
+}
+
+function renderHarness(onClose: () => void) {
+  return render(
+    <StrictMode>
+      <OverlayProvider>
+        <Harness onClose={onClose} />
+      </OverlayProvider>
+    </StrictMode>,
+  );
+}
+
+describe('OverlayProvider', () => {
+  it('invokes onClose once when the top overlay is popped', () => {
+    const onClose = jest.fn();
+    renderHarness(onClose);
+
+    fireEvent.press(screen.getByLabelText('push-standard'));
+    fireEvent.press(screen.getByLabelText('pop'));
+
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('removes and closes only the latest matching overlay', () => {
+    const onClose = jest.fn();
+    renderHarness(onClose);
+
+    fireEvent.press(screen.getByLabelText('push-standard'));
+    fireEvent.press(screen.getByLabelText('push-assistant'));
+    fireEvent.press(screen.getByLabelText('push-standard'));
+    fireEvent.press(screen.getByLabelText('pop-standard'));
+
+    expect(onClose).toHaveBeenCalledTimes(1);
+    expect(screen.getByText('standardCreate,assistant')).toBeTruthy();
+  });
+});

frontend/__tests__/app/session/sessionEndpoint.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from '@jest/globals';
+
+import { buildSessionWebSocketUrl, resolveSessionUserId } from '@/app/session/sessionEndpoint';
+
+describe('session endpoint compatibility', () => {
+  it('adds the persisted device id to the backend WebSocket URL', () => {
+    expect(buildSessionWebSocketUrl('ws://127.0.0.1:8000/ws', 'device 1')).toBe(
+      'ws://127.0.0.1:8000/ws?device_id=device+1',
+    );
+  });
+
+  it('replaces a stale device id while preserving other query parameters', () => {
+    expect(
+      buildSessionWebSocketUrl('wss://api.example.com/ws?token=test&device_id=stale', 'current'),
+    ).toBe('wss://api.example.com/ws?token=test&device_id=current');
+  });
+
+  it('rejects non-WebSocket URLs', () => {
+    expect(() => buildSessionWebSocketUrl('http://127.0.0.1:8000/ws', 'device_1')).toThrow(
+      '必须使用 ws:// 或 wss://',
+    );
+  });
+
+  it('uses the MVP backend user when session.ready omits user_id', () => {
+    expect(resolveSessionUserId(undefined)).toBe('default_user');
+    expect(resolveSessionUserId(' user_1 ')).toBe('user_1');
+  });
+});

frontend/__tests__/dev/fakes/schedule/scheduleConflicts.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from '@jest/globals';
+
+import type { Schedule, ScheduleUpsertCommand } from '@/contracts';
+
+import { upsertSchedule } from '@/dev/fakes/schedule/scheduleConflicts';
+
+function makeSchedule(overrides: Partial<Schedule> = {}): Schedule {
+  return {
+    id: 'schedule_existing',
+    user_id: 'default_user',
+    source_mode: 'manual',
+    schedule_type: 'time',
+    status: 'scheduled',
+    title: '已有日程',
+    notes: null,
+    start_time: new Date(2026, 6, 29, 9, 0).toISOString(),
+    end_time: new Date(2026, 6, 29, 10, 0).toISOString(),
+    timezone: 'Asia/Shanghai',
+    location_name: null,
+    location_address: null,
+    latitude: null,
+    longitude: null,
+    geofence_radius_meters: 100,
+    geofence_armed: false,
+    time_remind_offset_minutes: 15,
+    time_triggered_at: null,
+    geo_triggered_at: null,
+    system_schedule_ref_id: null,
+    system_alarm_ref_id: null,
+    created_at: new Date(2026, 6, 20, 10, 0).toISOString(),
+    updated_at: new Date(2026, 6, 20, 10, 0).toISOString(),
+    ...overrides,
+  };
+}
+
+function makeCommand(startHour: number, endHour: number | null): ScheduleUpsertCommand {
+  return {
+    type: 'schedule.upsert.command',
+    request_id: 'req_test',
+    payload: {
+      source_mode: 'manual',
+      schedule_type: 'time',
+      title: '新日程',
+      start_time: new Date(2026, 6, 29, startHour, 0).toISOString(),
+      end_time: endHour === null ? null : new Date(2026, 6, 29, endHour, 0).toISOString(),
+    },
+  };
+}
+
+describe('upsertSchedule conflict detection', () => {
+  const existing = [makeSchedule()];
+
+  it('flags a schedule that overlaps an existing one', () => {
+    const result = upsertSchedule(makeCommand(9, 10), existing, 'schedule_new');
+    expect(result.payload.conflicts.map((conflict) => conflict.schedule_id)).toEqual([
+      'schedule_existing',
+    ]);
+  });
+
+  it('flags a partial overlap', () => {
+    const result = upsertSchedule(makeCommand(9, 11), existing, 'schedule_new');
+    expect(result.payload.conflicts).toHaveLength(1);
+  });
+
+  it('treats touching boundaries as a conflict', () => {
+    const result = upsertSchedule(makeCommand(10, 11), existing, 'schedule_new');
+    expect(result.payload.conflicts).toHaveLength(1);
+  });
+
+  it('reports nothing for a non-overlapping slot', () => {
+    const result = upsertSchedule(makeCommand(11, 12), existing, 'schedule_new');
+    expect(result.payload.conflicts).toHaveLength(0);
+  });
+
+  it('does not conflict a schedule with itself while editing', () => {
+    const result = upsertSchedule(makeCommand(9, 10), existing, 'schedule_existing');
+    expect(result.payload.conflicts).toHaveLength(0);
+  });
+
+  it('ignores deleted schedules', () => {
+    const deleted = [makeSchedule({ status: 'deleted' })];
+    const result = upsertSchedule(makeCommand(9, 10), deleted, 'schedule_new');
+    expect(result.payload.conflicts).toHaveLength(0);
+  });
+
+  it('reports nothing when the new schedule has no start time', () => {
+    const command: ScheduleUpsertCommand = {
+      type: 'schedule.upsert.command',
+      request_id: 'req_test',
+      payload: {
+        source_mode: 'manual',
+        schedule_type: 'location',
+        title: '地点日程',
+        start_time: null,
+      },
+    };
+    const result = upsertSchedule(command, existing, 'schedule_new');
+    expect(result.payload.conflicts).toHaveLength(0);
+  });
+
+  it('echoes the request id and schedule id back', () => {
+    const result = upsertSchedule(makeCommand(14, 15), existing, 'schedule_new');
+    expect(result.request_id).toBe('req_test');
+    expect(result.payload.schedule_id).toBe('schedule_new');
+  });
+
+  it('ignores unparseable start times on the new command', () => {
+    const command: ScheduleUpsertCommand = {
+      type: 'schedule.upsert.command',
+      request_id: 'req_test',
+      payload: {
+        source_mode: 'manual',
+        schedule_type: 'time',
+        title: '坏时间',
+        start_time: 'not-a-date',
+        end_time: null,
+      },
+    };
+    expect(upsertSchedule(command, existing, 'schedule_new').payload.conflicts).toHaveLength(0);
+  });
+
+  it('ignores existing items whose times do not parse', () => {
+    const broken = [makeSchedule({ id: 'broken', start_time: 'bad', end_time: 'also-bad' })];
+    expect(
+      upsertSchedule(makeCommand(9, 10), broken, 'schedule_new').payload.conflicts,
+    ).toHaveLength(0);
+  });
+
+  it('inherits geofence_armed from the existing schedule when omitted', () => {
+    const armed = [makeSchedule({ id: 'schedule_existing', geofence_armed: true })];
+    const command = makeCommand(14, 15);
+    delete (command.payload as { geofence_armed?: boolean }).geofence_armed;
+    expect(upsertSchedule(command, armed, 'schedule_existing').payload.geofence_armed).toBe(true);
+  });
+});