@linxin666/dsh-remote-web-ui 0.3.5 → 0.3.9

package/lib/types/paired-model-catalog.js

@@ -1,311 +0,0 @@
-import { z } from 'zod';
-import { readCookie } from "./gate.js";
-import { readBoundedJson, writeJson } from "./http.js";
-import { isTrustedApiRequest, publicHostOf } from "./routes.js";
-const MAX_BODY_BYTES = 16 * 1024;
-const MAX_IDENTIFIER_LENGTH = 160;
-const MAX_DISPLAY_NAME_LENGTH = 240;
-const MAX_TOKEN_LIMIT = 10_000_000;
-const REASONING_EFFORTS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
-const stringField = (max) => z.string().trim().min(1).max(max).refine(value => !/[\r\n\0]/.test(value), 'must not contain a newline or NUL');
-const providerSchema = z.object({ provider: stringField(MAX_IDENTIFIER_LENGTH) }).strict();
-const modelSchema = z.object({
-    id: stringField(MAX_IDENTIFIER_LENGTH),
-    name: stringField(MAX_DISPLAY_NAME_LENGTH).optional(),
-    contextWindow: z.number().int().safe().positive().max(MAX_TOKEN_LIMIT).optional(),
-    maxTokens: z.number().int().safe().positive().max(MAX_TOKEN_LIMIT).optional(),
-    reasoningEfforts: z.array(z.enum(REASONING_EFFORTS)).min(1).refine(efforts => efforts.every((effort, index) => index === 0 || REASONING_EFFORTS.indexOf(efforts[index - 1]) < REASONING_EFFORTS.indexOf(effort)), 'reasoning efforts must be unique and in canonical order').optional(),
-}).strict();
-const upsertSchema = z.object({ provider: stringField(MAX_IDENTIFIER_LENGTH), model: modelSchema }).strict();
-export const PAIRED_MODEL_CATALOG_PATHS = {
-    catalog: '/api/pair/model-catalog',
-    discover: '/api/pair/model-catalog/discover',
-    upsert: '/api/pair/model-catalog/upsert',
-};
-let rpcSequence = 0;
-function request(payload) {
-    rpcSequence += 1;
-    return { rpcId: `paired-model-catalog-${Date.now().toString(36)}-${rpcSequence.toString(36)}`, payload };
-}
-function isRecord(value) { return typeof value === 'object' && value !== null && !Array.isArray(value); }
-function valueOf(response) { return response.result.ok ? response.result.value : undefined; }
-function errorCode(response) { return response.result.ok ? undefined : response.result.error.code; }
-function reject(res, status, error) { writeJson(res, status, { error }); }
-function publicProviderId(value) {
-    const normalized = value.replace(/[\r\n\0]/g, ' ').trim().slice(0, MAX_IDENTIFIER_LENGTH);
-    return normalized === '' ? 'unknown' : normalized;
-}
-function publicCatalog(value) {
-    return {
-        groups: value.groups.map(group => ({ id: group.id, name: group.name, models: group.models.map(model => ({
-                id: model.id, name: model.name,
-                ...model.description === undefined ? {} : { description: model.description },
-                ...model.reasoning === undefined ? {} : { reasoning: model.reasoning },
-            })) })),
-        failures: value.failures.map(failure => ({
-            id: failure.id,
-            name: failure.name,
-            message: `model catalog unavailable for provider ${publicProviderId(failure.id)}`,
-        })),
-    };
-}
-function publicCandidates(models) {
-    return models.map(model => ({ id: model.id,
-        ...model.name === undefined ? {} : { name: model.name },
-        ...model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow },
-        ...model.maxTokens === undefined ? {} : { maxTokens: model.maxTokens },
-    }));
-}
-function fieldsOf(model, includeId) {
-    const fields = {
-        ...includeId ? { id: model.id } : {},
-        ...model.name === undefined ? {} : { name: model.name },
-        ...model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow },
-        ...model.maxTokens === undefined ? {} : { maxTokens: model.maxTokens },
-    };
-    if (model.reasoningEfforts !== undefined)
-        fields.reasoningEfforts = Object.fromEntries(model.reasoningEfforts.map(effort => [effort, effort === 'off' ? null : effort]));
-    return fields;
-}
-function groupFor(catalog, provider) {
-    if (catalog.failures.some(failure => failure.id === provider))
-        return undefined;
-    return catalog.groups.find(group => group.id === provider);
-}
-async function readCatalog(apiProxy) {
-    try {
-        return valueOf(await apiProxy.llm.models(request({})));
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Resolve one exact active llm-pi-ai provider address, never an input-supplied path. */
-async function eligibleProvider(apiProxy, requested) {
-    let providersResponse;
-    let settingsResponse;
-    try {
-        providersResponse = await apiProxy.llm.providers(request({}));
-        settingsResponse = await apiProxy.settings.describe(request({}));
-    }
-    catch {
-        return { status: 502, error: 'model catalog capability is unavailable' };
-    }
-    const providers = valueOf(providersResponse);
-    const settings = valueOf(settingsResponse);
-    if (providers === undefined || settings === undefined)
-        return { status: 502, error: 'model catalog capability is unavailable' };
-    const route = providers.providers.find(candidate => candidate.provider === requested);
-    if (route === undefined)
-        return { status: 404, error: `unknown provider ${requested}` };
-    if (!settings.writable || !route.active || route.settingsNs !== 'llm-pi-ai' || route.settingsPath.length !== 2
-        || route.settingsPath[0] !== 'providers' || route.settingsPath[1] !== requested)
-        return { status: 403, error: `provider ${requested} is not eligible for the paired model catalog` };
-    const namespace = settings.namespaces.find(candidate => candidate.ns === 'llm-pi-ai');
-    const root = namespace !== undefined && isRecord(namespace.value) ? namespace.value : undefined;
-    const providersValue = root !== undefined && isRecord(root.providers) ? root.providers : undefined;
-    const profile = providersValue !== undefined && isRecord(providersValue[requested]) ? providersValue[requested] : undefined;
-    if (namespace === undefined || profile === undefined)
-        return { status: 403, error: `provider ${requested} is not eligible for the paired model catalog` };
-    return { provider: { provider: requested, displayName: route.displayName, namespace, profile } };
-}
-function validIdentifier(value) {
-    const parsed = stringField(MAX_IDENTIFIER_LENGTH).safeParse(value);
-    return parsed.success && parsed.data === value;
-}
-function configuredModels(profile) {
-    if (!Object.hasOwn(profile, 'models'))
-        return { inherited: true };
-    if (!Array.isArray(profile.models))
-        return undefined;
-    if (profile.models.length === 0)
-        return { inherited: true };
-    const values = [];
-    for (const entry of profile.models) {
-        if (!isRecord(entry) || !validIdentifier(entry.id))
-            return undefined;
-        values.push({ ...entry });
-    }
-    return { inherited: false, values };
-}
-function configuredOverrides(profile) {
-    if (!Object.hasOwn(profile, 'modelOverrides'))
-        return { present: false, values: new Map() };
-    if (!isRecord(profile.modelOverrides))
-        return undefined;
-    const values = new Map();
-    for (const [id, value] of Object.entries(profile.modelOverrides)) {
-        if (!validIdentifier(id) || !isRecord(value))
-            return undefined;
-        values.set(id, { ...value });
-    }
-    return { present: true, values };
-}
-function updatedModels(existing, model) {
-    const next = existing.map(entry => ({ ...entry }));
-    const index = next.findIndex(entry => entry.id === model.id);
-    const patch = fieldsOf(model, true);
-    if (index >= 0)
-        next[index] = { ...next[index], ...patch };
-    else
-        next.push(patch);
-    return next;
-}
-function mutationPlan(profile, provider, model, catalog) {
-    const configured = configuredModels(profile);
-    const overrides = configuredOverrides(profile);
-    if (configured === undefined || overrides === undefined)
-        return undefined;
-    const modelsPath = ['providers', provider, 'models'];
-    const overridesPath = ['providers', provider, 'modelOverrides'];
-    if (!configured.inherited) {
-        if (overrides.values.size > 0)
-            return undefined;
-        const ops = [{ op: 'set', path: modelsPath, value: updatedModels(configured.values, model) }];
-        if (overrides.present)
-            ops.push({ op: 'unset', path: overridesPath });
-        return { ops };
-    }
-    const group = groupFor(catalog, provider);
-    if (group?.models.some(entry => entry.id === model.id) === true) {
-        const existing = overrides.values.get(model.id) ?? {};
-        return { ops: [{ op: 'set', path: [...overridesPath, model.id], value: { ...existing, ...fieldsOf(model, false) } }] };
-    }
-    if (group === undefined)
-        return undefined;
-    const materialized = [];
-    const materializedIds = new Set();
-    for (const installed of group.models) {
-        materialized.push({ ...overrides.values.get(installed.id), id: installed.id });
-        materializedIds.add(installed.id);
-    }
-    for (const [id, override] of overrides.values) {
-        if (!materializedIds.has(id))
-            materialized.push({ ...override, id });
-    }
-    const ops = [{ op: 'set', path: modelsPath, value: updatedModels(materialized, model) }];
-    if (overrides.present)
-        ops.push({ op: 'unset', path: overridesPath });
-    return { ops };
-}
-function paired(req, service) {
-    const deviceId = readCookie(req.headers.cookie, service.config.cookieName);
-    return deviceId !== undefined && service.touchDevice(deviceId);
-}
-async function bodyOf(req, schema) {
-    try {
-        return schema.parse(await readBoundedJson(req, MAX_BODY_BYTES));
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Build the narrow paired-device model catalog routes. */
-export function makePairedModelCatalogRoutes(deps) {
-    const { service, apiProxy, lanAddresses } = deps;
-    /** Same fence as the /api/pair family: loopback, the advertised LAN literals, or the configured public host. */
-    const fence = (req) => {
-        const publicHost = publicHostOf(service.publicBaseUrl);
-        return isTrustedApiRequest(req, publicHost === undefined ? lanAddresses : [...lanAddresses, publicHost]);
-    };
-    const gate = (req, res) => {
-        if (!fence(req)) {
-            req.resume();
-            reject(res, 403, 'paired model catalog is not reachable for this origin');
-            return false;
-        }
-        if (!paired(req, service)) {
-            req.resume();
-            reject(res, 403, 'paired model catalog requires a live paired device');
-            return false;
-        }
-        return true;
-    };
-    const catalog = async (req, res) => {
-        if (!gate(req, res))
-            return;
-        if (req.method !== 'GET')
-            return reject(res, 405, 'method not allowed');
-        let providersResponse;
-        let settingsResponse;
-        try {
-            providersResponse = await apiProxy.llm.providers(request({}));
-            settingsResponse = await apiProxy.settings.describe(request({}));
-        }
-        catch {
-            return reject(res, 502, 'model catalog capability is unavailable');
-        }
-        const providers = valueOf(providersResponse);
-        const settings = valueOf(settingsResponse);
-        if (providers === undefined || settings === undefined)
-            return reject(res, 502, 'model catalog capability is unavailable');
-        const namespace = settings.namespaces.find(candidate => candidate.ns === 'llm-pi-ai');
-        const providerMap = namespace !== undefined && isRecord(namespace.value) && isRecord(namespace.value.providers) ? namespace.value.providers : undefined;
-        const eligible = settings.writable && providerMap !== undefined ? providers.providers.filter(candidate => candidate.active && candidate.settingsNs === 'llm-pi-ai'
-            && candidate.settingsPath.length === 2 && candidate.settingsPath[0] === 'providers' && candidate.settingsPath[1] === candidate.provider && isRecord(providerMap[candidate.provider]))
-            .map(candidate => ({ provider: candidate.provider, displayName: candidate.displayName })) : [];
-        writeJson(res, 200, { capability: 'paired-model-catalog', providers: eligible });
-    };
-    const discover = async (req, res) => {
-        if (!gate(req, res))
-            return;
-        if (req.method !== 'POST')
-            return reject(res, 405, 'method not allowed');
-        const body = await bodyOf(req, providerSchema);
-        if (body === undefined)
-            return reject(res, 400, 'invalid model catalog request');
-        const eligible = await eligibleProvider(apiProxy, body.provider);
-        if (eligible.provider === undefined)
-            return reject(res, eligible.status ?? 502, eligible.error ?? 'model catalog capability is unavailable');
-        try {
-            const result = valueOf(await apiProxy.llm.discoverModels(request({ settingsNs: 'llm-pi-ai', provider: eligible.provider.provider })));
-            if (result === undefined)
-                return reject(res, 502, `model discovery failed for provider ${eligible.provider.provider}`);
-            writeJson(res, 200, { models: publicCandidates(result.models) });
-        }
-        catch {
-            reject(res, 502, `model discovery failed for provider ${eligible.provider.provider}`);
-        }
-    };
-    const upsert = async (req, res) => {
-        if (!gate(req, res))
-            return;
-        if (req.method !== 'POST')
-            return reject(res, 405, 'method not allowed');
-        const body = await bodyOf(req, upsertSchema);
-        if (body === undefined)
-            return reject(res, 400, 'invalid model catalog request');
-        const eligible = await eligibleProvider(apiProxy, body.provider);
-        if (eligible.provider === undefined)
-            return reject(res, eligible.status ?? 502, eligible.error ?? 'model catalog capability is unavailable');
-        const before = await readCatalog(apiProxy);
-        if (before === undefined)
-            return reject(res, 502, `model catalog is unavailable for provider ${body.provider}`);
-        const plan = mutationPlan(eligible.provider.profile, body.provider, body.model, before);
-        if (plan === undefined)
-            return reject(res, 502, `model catalog is unavailable for provider ${body.provider}`);
-        let mutation;
-        try {
-            mutation = await apiProxy.settings.mutate(request({ ns: 'llm-pi-ai', expectedRevision: eligible.provider.namespace.revision, ops: plan.ops }));
-        }
-        catch {
-            return reject(res, 502, `model update failed for provider ${body.provider}`);
-        }
-        const code = errorCode(mutation);
-        if (code === 'settings-conflict')
-            return reject(res, 409, `model update conflicted for provider ${body.provider}`);
-        if (code === 'settings-rejected')
-            return reject(res, 422, `model update was rejected for provider ${body.provider}`);
-        if (code !== undefined)
-            return reject(res, 502, `model update failed for provider ${body.provider}`);
-        const after = await readCatalog(apiProxy);
-        if (after === undefined)
-            return reject(res, 502, `model catalog is unavailable for provider ${body.provider}`);
-        writeJson(res, 200, publicCatalog(after));
-    };
-    return [
-        { kind: 'exact', path: PAIRED_MODEL_CATALOG_PATHS.catalog, handler: catalog },
-        { kind: 'exact', path: PAIRED_MODEL_CATALOG_PATHS.discover, handler: discover },
-        { kind: 'exact', path: PAIRED_MODEL_CATALOG_PATHS.upsert, handler: upsert },
-    ];
-}

package/src/mobile/PairRequiredView.test.tsx

@@ -1,28 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
-import { PairRequiredView } from './PairRequiredView.tsx'
-
-afterEach(() => {
-  cleanup()
-  vi.unstubAllGlobals()
-})
-
-describe('PairRequiredView', () => {
-  it('accepts a pasted link in the installed app context', async () => {
-    const fetch = vi.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }))
-    vi.stubGlobal('fetch', fetch)
-    const onPaired = vi.fn()
-    render(<PairRequiredView onPaired={onPaired} />)
-
-    fireEvent.change(screen.getByLabelText('配对链接'), { target: { value: 'https://phone.example/m/?pair=tok-1&workspace=ws-7' } })
-    fireEvent.click(screen.getByRole('button', { name: '配对' }))
-
-    await waitFor(() => expect(onPaired).toHaveBeenCalledWith('/m/?workspace=ws-7'))
-  })
-
-  it('shows an initial QR failure without starting the mobile data channel', () => {
-    render(<PairRequiredView initialError="配对链接已被使用。" onPaired={vi.fn()} />)
-    expect(screen.getByRole('alert').textContent).toContain('配对链接已被使用。')
-  })
-})

package/src/mobile/PairRequiredView.tsx

@@ -1,58 +0,0 @@
-/** Device-pairing gate for installed mobile web-app contexts with isolated storage. */
-import { type FormEvent, useState } from 'react'
-import { acceptMobilePair, mobilePairPath, parseMobilePairInput } from './pairing.ts'
-
-export interface PairRequiredViewProps {
-  initialError?: string
-  onPaired(path: string): void
-}
-
-/** Collect a fresh desktop-issued pairing link when this client has no paired cookie. */
-export function PairRequiredView({ initialError, onPaired }: PairRequiredViewProps) {
-  const [value, setValue] = useState('')
-  const [error, setError] = useState<string | undefined>(initialError)
-  const [submitting, setSubmitting] = useState(false)
-
-  const submit = async (event: FormEvent<HTMLFormElement>): Promise<void> => {
-    event.preventDefault()
-    const input = parseMobilePairInput(value)
-    if (input === undefined) {
-      setError('请输入有效的配对链接。')
-      return
-    }
-
-    setSubmitting(true)
-    setError(undefined)
-    const result = await acceptMobilePair(input.token)
-    setSubmitting(false)
-    if (!result.ok) {
-      setError(result.message)
-      return
-    }
-
-    onPaired(mobilePairPath(input.workspaceId))
-  }
-
-  return (
-    <main className="mobile mobile-pair" aria-labelledby="mobile-pair-title">
-      <form className="mobile-pairCard" onSubmit={(event) => { void submit(event) }}>
-        <h1 id="mobile-pair-title" className="mobile-title">设备配对</h1>
-        <p className="mobile-muted">粘贴桌面端复制的配对链接以连接此设备。</p>
-        <label className="mobile-pairLabel" htmlFor="mobile-pair-link">配对链接</label>
-        <input
-          id="mobile-pair-link"
-          className="mobile-pairInput"
-          value={value}
-          onChange={(event) => { setValue(event.target.value) }}
-          autoComplete="off"
-          autoCapitalize="off"
-          spellCheck={false}
-        />
-        {error === undefined ? null : <p className="mobile-error" role="alert">{error}</p>}
-        <button className="mobile-new mobile-pairSubmit" type="submit" disabled={submitting}>
-          {submitting ? '正在配对' : '配对'}
-        </button>
-      </form>
-    </main>
-  )
-}

package/src/mobile/api.ts

@@ -1,229 +0,0 @@
-/**
- * Mobile-surface business API: the handful of host RPC methods the
- * simplified surface needs. Types come from the harness apiproxy contract
- * (type-only imports; the wire schemas stay in the bundle only through the
- * rpc/mux layers).
- */
-
-import type { WorkspaceView } from '@deepseek-ai/dsh-host-apiproxy/api/workspace'
-import type { AgentPresetEntry } from '@deepseek-ai/dsh-host-apiproxy/api/agent-presets'
-import type { SessionSummary, SessionModels, SessionProjectionsBlock } from '@deepseek-ai/dsh-host-apiproxy/api/sessions'
-import { callUnary } from './rpc.ts'
-
-/** One session.list page. */
-export interface SessionPage {
-  items: SessionSummary[]
-  /** Continuation cursor; undefined once the tail is reached. */
-  nextCursor?: string
-  hasMore: boolean
-}
-
-/** The session.create result (the id is the commit the caller navigates to). */
-export interface CreatedSession {
-  sessionId: string
-  /** The composition the new session runs (echoed so the caller can label it). */
-  agentPreset?: string
-}
-
-/** Agent presets available when composing a new session. */
-export interface AgentPresetRoster {
-  presets: readonly AgentPresetEntry[]
-  authorable: boolean
-  hasDocument: boolean
-}
-
-/** One history page (already bounded to whole messages by the host). */
-export interface HistoryPage {
-  events: import('@deepseek-ai/dsh-host-apiproxy/api/sessions').HistoryEntry[]
-  hasMore: boolean
-  /**
-   * Projection baseline riding the tail page (permissions select etc.);
-   * absent when the deployment mounts no projection registry.
-   */
-  projections?: SessionProjectionsBlock
-}
-
-/** Read-only display preferences the plugin answers locally on `/m/api`. */
-export interface MobilePreferences {
-  /** Plain Enter sends the drafted prompt (false: Enter inserts a newline). */
-  mobileEnterToSend: boolean
-}
-
-/** The workspace roster (session ids come back per workspace). */
-export async function listWorkspaces(): Promise<WorkspaceView[]> {
-  const { items } = await callUnary<{ items: WorkspaceView[] }>('workspace.list', {})
-  return items
-}
-
-/** Read-only mobile display preferences (answered by the plugin, not the host proxy). */
-export async function fetchMobilePreferences(): Promise<MobilePreferences> {
-  return await callUnary<MobilePreferences>('mobile.preferences', {})
-}
-
-/** One session.list page; omit the cursor for the first page. */
-export async function listSessions(cursor?: string): Promise<SessionPage> {
-  return await callUnary<SessionPage>('session.list', cursor === undefined ? {} : { cursor })
-}
-
-/** Read the available agent compositions for a new session. */
-export async function listAgentPresets(): Promise<AgentPresetRoster> {
-  return await callUnary<AgentPresetRoster>('agentPreset.list', {})
-}
-
-/**
- * Create a blank session (entity birth precedes the first message). Name a
- * workspace to attach it there, or a cwd; omitting both uses the host cwd.
- */
-export async function createSession(
-  options: { workspaceId?: string; cwd?: string; agentPreset?: string } = {},
-): Promise<CreatedSession> {
-  return await callUnary<CreatedSession>('session.create', options)
-}
-
-/** One history window; omit beforeSeq for the tail page, pass a signal to abort. */
-export async function history(
-  sessionId: string,
-  beforeSeq?: number,
-  maxMessages = 30,
-  signal?: AbortSignal,
-): Promise<HistoryPage> {
-  return await callUnary<HistoryPage>('session.history', {
-    sessionId,
-    maxMessages,
-    ...(beforeSeq !== undefined ? { beforeSeq } : {}),
-  }, signal)
-}
-
-/** Send one text prompt (queued: the agent picks it up in order). */
-export async function prompt(sessionId: string, text: string): Promise<void> {
-  await callUnary<{ accepted: true }>('session.prompt', {
-    sessionId,
-    mode: 'queue',
-    content: [{ type: 'text', text }],
-  })
-}
-
-/** Send one slash command line (e.g. `/permission workspace-write`). */
-export async function sendCommand(sessionId: string, line: string): Promise<unknown> {
-  return await callUnary<unknown>('mobile.command', {
-    sessionId,
-    line,
-  })
-}
-
-/**
- * Stop the session's active turn (the mobile stop button). Pending queued
- * work is preserved and resumes in FIFO order once cancellation settles.
- */
-export async function cancelSession(sessionId: string): Promise<{ accepted: true }> {
-  return await callUnary<{ accepted: true }>('session.cancel', { sessionId })
-}
-
-/** Fresh advisory model directory for one session (current + groups + failures). */
-export async function models(sessionId: string): Promise<SessionModels> {
-  return await callUnary<SessionModels>('session.models', { sessionId })
-}
-
-/** Select the complete model selection (provider/model/reasoning effort) for a session. */
-export async function selectModel(
-  sessionId: string,
-  selection: { provider: string; model: string; reasoningEffort?: string },
-): Promise<{ selected: { provider: string; model: string; reasoningEffort?: string } }> {
-  return await callUnary<{ selected: { provider: string; model: string; reasoningEffort?: string } }>('session.selectModel', {
-    sessionId,
-    provider: selection.provider,
-    model: selection.model,
-    ...(selection.reasoningEffort !== undefined ? { reasoningEffort: selection.reasoningEffort } : {}),
-  })
-}
-
-/* ── pending approvals / questions (#1025) ───────────────────────────── */
-
-/** One pending tool approval awaiting the user's decision. */
-export interface PendingApproval {
-  approvalId: string
-  toolName: string
-  callId?: string
-  reason?: string
-}
-
-/** One pending question group awaiting the user's answer. */
-export interface PendingQuestionItem {
-  id: string
-  question: string
-  detail?: string
-  header?: string
-  options?: Array<{ label: string; description?: string }>
-  multiSelect?: boolean
-}
-
-/** The pending state for one session. */
-export interface PendingState {
-  approvals: PendingApproval[]
-  questions: PendingQuestionItem[]
-}
-
-/** Fetch pending approvals and questions for one session (polling fallback data source). */
-export async function fetchPending(sessionId: string): Promise<PendingState> {
-  return await callUnary<PendingState>('mobile.pending', { sessionId })
-}
-
-/** Submit an approval decision (allowed-once or rejected). */
-export async function respondApproval(
-  sessionId: string,
-  approvalId: string,
-  outcome: 'allowed-once' | 'rejected',
-): Promise<void> {
-  await callUnary<unknown>('mobile.respond', {
-    sessionId,
-    type: 'approval',
-    approvalId,
-    outcome,
-  })
-}
-
-/** Submit answers to a question group. */
-export async function respondQuestion(
-  sessionId: string,
-  answers: Array<{ id: string; selected: string[]; custom?: string }>,
-): Promise<void> {
-  await callUnary<unknown>('mobile.respond', {
-    sessionId,
-    type: 'question',
-    answers,
-  })
-}
-
-/* ── directory browsing / workspace creation (#977) ──────────────────── */
-
-/** One entry in a directory listing. */
-export interface DirectoryEntry {
-  name: string
-  path: string
-  hidden: boolean
-}
-
-/** The host directory listing result (one level, with ancestor breadcrumbs). */
-export interface DirectoryListing {
-  path: string
-  home: string
-  crumbs: DirectoryEntry[]
-  entries: DirectoryEntry[]
-  truncated: boolean
-}
-
-/** The result of creating a workspace from an existing directory. */
-export interface WorkspaceCreateResult {
-  workspace: WorkspaceView
-  created: boolean
-}
-
-/** Browse one directory level on the host (defaults to home directory). */
-export async function listDirectory(path?: string): Promise<DirectoryListing> {
-  return await callUnary<DirectoryListing>('host.listDirectory', path === undefined ? {} : { path })
-}
-
-/** Create a workspace from an existing host directory (does not mkdir). */
-export async function createWorkspace(path: string): Promise<WorkspaceCreateResult> {
-  return await callUnary<WorkspaceCreateResult>('workspace.create', { path })
-}

package/src/mobile/index.tsx

@@ -1,41 +0,0 @@
-/**
- * Mobile surface entry: the standalone phone UI served at /m. Boots its own
- * React tree (no main-UI module loader), talks to the host over the shared
- * /api transport with the paired-device cookie, and renders a deliberately
- * thin three-level surface:
- *   workspaces (landing, no new-session homepage) → sessions (paged) →
- *   chat (history paged on demand + live mux stream + prompt input).
- */
-
-import { createRoot } from 'react-dom/client'
-import { App } from './views/App.tsx'
-import { mobileCss } from './mobile-styles.ts'
-import { initMobileTheme } from './mobile-theme.ts'
-import { registerMobilePwa } from '../mobile-pwa.ts'
-import { consumeMobilePairUrl } from './pairing.ts'
-
-// Apply the persisted (or default light) theme before first paint, so the
-// page never flashes the wrong palette.
-initMobileTheme()
-
-// Inject the standalone stylesheet (the page has no shell to load it for us).
-const style = document.createElement('style')
-style.dataset.plugin = 'remote-web-ui/mobile'
-style.textContent = mobileCss
-document.head.appendChild(style)
-
-const root = document.getElementById('root')
-if (root === null) throw new Error('mobile: #root missing')
-void bootMobile(root)
-
-async function bootMobile(mount: HTMLElement): Promise<void> {
-  const pair = await consumeMobilePairUrl(window.location.href)
-  if (pair.kind === 'accepted') {
-    window.location.replace(pair.path)
-    return
-  }
-  if (pair.kind === 'failed') window.history.replaceState(null, '', pair.path)
-
-  void registerMobilePwa()
-  createRoot(mount).render(<App initialPairError={pair.kind === 'failed' ? pair.message : undefined} />)
-}