@cjhyy/code-shell-web 0.8.0

package/dist/lib/storage.d.ts

@@ -0,0 +1,10 @@
+export declare const deviceStore: {
+    readonly getId: () => string;
+    readonly setId: (v: string) => void;
+    readonly clearId: () => void;
+    /** Get the stable per-browser secret, minting+persisting one on first use.
+     *  Mirrors the old getSecret() so existing devices keep the same secret. */
+    readonly getOrCreateSecret: (mint: () => string) => string;
+    /** Device display name, defaulting to a platform-derived label on first use. */
+    readonly getOrCreateName: () => string;
+};

package/dist/lib/storage.js

@@ -0,0 +1,53 @@
+/**
+ * Thin typed wrapper over localStorage for the mobile remote's persisted
+ * device identity. Keys keep the historical `cs.*` names so an already-paired
+ * phone (paired against the old inline UI) keeps working after the rebuild.
+ */
+import { translate } from "../i18n/translate.js";
+import { loadUILanguage } from "./uiLanguage.js";
+const K = {
+    deviceId: "cs.deviceId",
+    deviceSecret: "cs.deviceSecret",
+    deviceName: "cs.deviceName",
+};
+/**
+ * Best-effort localStorage write. On a quota-constrained mobile browser
+ * (iOS/Android default ~5MB) setItem throws QuotaExceededError; since these
+ * calls run synchronously inside ws.onopen (the auth handshake), an uncaught
+ * throw aborts onopen mid-flight → handshake never sent → blank app, no retry.
+ * Swallow the write failure and let the caller proceed with the in-memory value;
+ * losing persistence only means a fresh secret/name next session.
+ */
+function safeSet(key, value) {
+    try {
+        localStorage.setItem(key, value);
+    }
+    catch {
+        /* quota / disabled storage — best-effort, value still returned to caller */
+    }
+}
+export const deviceStore = {
+    getId: () => localStorage.getItem(K.deviceId) ?? "",
+    setId: (v) => safeSet(K.deviceId, v),
+    clearId: () => localStorage.removeItem(K.deviceId),
+    /** Get the stable per-browser secret, minting+persisting one on first use.
+     *  Mirrors the old getSecret() so existing devices keep the same secret. */
+    getOrCreateSecret: (mint) => {
+        let s = localStorage.getItem(K.deviceSecret);
+        if (!s) {
+            s = mint();
+            safeSet(K.deviceSecret, s);
+        }
+        return s;
+    },
+    /** Device display name, defaulting to a platform-derived label on first use. */
+    getOrCreateName: () => {
+        let n = localStorage.getItem(K.deviceName);
+        if (!n) {
+            const platform = (typeof navigator !== "undefined" && navigator.platform) || "Phone";
+            n = translate(loadUILanguage(), "mobile.storage.browserDevice", { platform });
+            safeSet(K.deviceName, n);
+        }
+        return n;
+    },
+};

package/dist/lib/streamReducer.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Mobile chat reducer: folds the worker→renderer JSON-RPC stream (the SAME
+ * lines the desktop renderer receives, mirrored via RemoteHostManager.
+ * broadcastRaw) into a flat list of view items. It also consumes `session.
+ * history` replay, which emits the identical `agent/streamEvent` envelopes, so
+ * one reducer serves both live and replay (design §4).
+ *
+ * Event names mirror core's StreamEvent union (packages/core/src/types.ts):
+ *   stream_request_start | text_delta | thinking_delta | tool_use_start |
+ *   tool_use_args_delta | tool_result | tool_summary | assistant_message |
+ *   turn_complete | goal_progress | task_update | agent_start | agent_end |
+ *   error | session_title …
+ *
+ * Subagent events carry an optional `agentId`. We tag items with it so a future
+ * UI can scope subagent rows (see commit fbe6f68 — task_update must be isolated
+ * by agentId so a subagent never clobbers the main list).
+ */
+export type RunState = "idle" | "running" | "waiting" | "completed" | "error";
+export interface UserAttachmentSummary {
+    name: string;
+    mime?: string;
+    size: number;
+}
+export type ChatItem = {
+    kind: "user";
+    id: string;
+    text: string;
+    attachments?: UserAttachmentSummary[];
+} | {
+    kind: "assistant";
+    id: string;
+    text: string;
+    reasoning: string;
+    done: boolean;
+    agentId?: string;
+} | {
+    kind: "tool";
+    id: string;
+    name: string;
+    args?: Record<string, unknown>;
+    result?: string;
+    error?: boolean;
+    summary?: string;
+    done: boolean;
+    agentId?: string;
+} | {
+    kind: "subagent";
+    id: string;
+    agentId: string;
+    label: string;
+    status: string;
+} | {
+    kind: "system_error";
+    id: string;
+    text: string;
+};
+export interface ChatState {
+    items: ChatItem[];
+    run: RunState;
+    /** Latest goal-progress status line, if any (display-only). */
+    goal?: string;
+    /** Identity of the active goal banner; absent for legacy events. */
+    goalId?: string;
+    /** Whether the active goal is paused. */
+    goalPaused?: boolean;
+    /** Monotonic Goal edit generation used to fence late events. */
+    goalRevision?: number;
+    sessionId?: string;
+    /** Per-session title pushed via session_title. */
+    title?: string;
+    /** Internal: id of the assistant item currently accumulating text/thinking
+     *  deltas, keyed by agentId ("" = the main agent). Keying by agent keeps a
+     *  concurrently-streaming subagent's text out of the main bubble (and vice
+     *  versa) — mirrors the renderer's per-agent message routing. */
+    liveByAgent: Record<string, string>;
+    /** Internal: monotonic counter for fresh ids (replaces Date.now/random,
+     *  which would make replay non-deterministic). */
+    seq: number;
+    /** Internal: tool_result events that arrived BEFORE their tool_use_start
+     *  (WebSocket reordering / buffering). Keyed by tool id; applied when the
+     *  matching tool_use_start lands so the result isn't silently lost. */
+    orphanResults?: Record<string, {
+        result: string;
+        error: boolean;
+    }>;
+}
+export declare function initialChatState(): ChatState;
+export declare function reduceStream(state: ChatState, raw: unknown): ChatState;
+/** Append a local user echo (the phone shows its own message immediately). */
+export declare function appendUserMessage(state: ChatState, text: string, attachments?: UserAttachmentSummary[]): ChatState;