@cjhyy/code-shell-web 0.8.0

package/README.md

@@ -0,0 +1,42 @@
+# @cjhyy/code-shell-web
+
+Browser-only state and UI helpers for CodeShell's remote client. The package
+contains no Electron code and imports CodeShell core contracts as types only.
+
+## Public surface
+
+The root entry exports:
+
+- the reconnecting WebSocket hook and remote-app state machine;
+- protocol stream reducers and message mappers;
+- pairing, device-credential, attachment, risk and storage helpers;
+- the mobile i18n namespace and translation helpers.
+
+```ts
+import { useRemoteApp, useRemoteSocket, classifyRisk, translate } from "@cjhyy/code-shell-web";
+```
+
+The reusable browser logic is emitted to `dist/`. The package also ships the
+standalone Vite application in `dist-app/`; `@cjhyy/code-shell-server/serve`
+uses those assets for the ready-made headless web host.
+
+## Commands
+
+```bash
+bun run --cwd packages/web build
+bun run --cwd packages/web build:app
+bun run --cwd packages/web dev:app
+```
+
+`build` cleans both output directories before compiling the library and
+building the application, so published assets cannot contain stale files.
+
+## Boundary
+
+This package may use browser APIs and type-only core protocol imports. It must
+not import Electron, Desktop preload globals, Node-only runtime modules or core
+runtime implementations.
+
+## License
+
+MIT.

package/dist/hooks/remoteAppSync.d.ts

@@ -0,0 +1,21 @@
+export interface SessionReplayEntry {
+    seq: number;
+    event: unknown;
+}
+export interface SessionReplaySelection {
+    events: unknown[];
+    cursor: number;
+}
+export declare function selectSessionReplayEntries(entries: SessionReplayEntry[], appliedSeq: number): SessionReplaySelection;
+export declare function rawApprovalResolvedRequestId(raw: unknown): string | null;
+export declare function removeResolvedApproval<T extends {
+    requestId: string;
+}>(approvals: T[], requestId: string): T[];
+export declare function roomMessageSeq(msg: unknown): number | undefined;
+export declare function markRoomSeqApplied(appliedSeqs: Map<string, Set<number>>, roomId: string, seq: number): void;
+export declare function filterNewRoomMessages(roomId: string, messages: unknown[], appliedSeqs: Map<string, Set<number>>): unknown[];
+export declare function maxRoomSeq(current: number, messages: unknown[], latestSeq?: number): number;
+export declare function noteSessionSeq(latestSeqs: Map<string, number>, sessionId: string, seq: number): boolean;
+export declare function markSessionUnread(unreadSessionIds: Set<string>, sessionId: string, activeSessionId?: string): Set<string>;
+export declare function clearUnreadSession(unreadSessionIds: Set<string>, sessionId?: string): Set<string>;
+export declare function pruneUnreadSessions(unreadSessionIds: Set<string>, sessionIds: Iterable<string>): Set<string>;

package/dist/hooks/remoteAppSync.js

@@ -0,0 +1,102 @@
+export function selectSessionReplayEntries(entries, appliedSeq) {
+    let cursor = appliedSeq;
+    const events = [];
+    for (const entry of entries) {
+        if (entry.seq > appliedSeq) {
+            events.push(entry.event);
+            if (entry.seq > cursor)
+                cursor = entry.seq;
+        }
+    }
+    return { events, cursor };
+}
+export function rawApprovalResolvedRequestId(raw) {
+    const obj = raw;
+    if (!obj || obj.method !== "agent/approvalResolved")
+        return null;
+    const params = obj.params;
+    const requestId = params?.requestId;
+    return typeof requestId === "string" && requestId ? requestId : null;
+}
+export function removeResolvedApproval(approvals, requestId) {
+    return approvals.filter((approval) => approval.requestId !== requestId);
+}
+export function roomMessageSeq(msg) {
+    const seq = msg?.seq;
+    return typeof seq === "number" && Number.isFinite(seq) ? seq : undefined;
+}
+export function markRoomSeqApplied(appliedSeqs, roomId, seq) {
+    let set = appliedSeqs.get(roomId);
+    if (!set) {
+        set = new Set();
+        appliedSeqs.set(roomId, set);
+    }
+    set.add(seq);
+    if (set.size > 1000) {
+        const sorted = [...set].sort((a, b) => a - b);
+        for (const old of sorted.slice(0, set.size - 1000))
+            set.delete(old);
+    }
+}
+export function filterNewRoomMessages(roomId, messages, appliedSeqs) {
+    const seen = appliedSeqs.get(roomId);
+    const next = [];
+    for (const msg of messages) {
+        const seq = roomMessageSeq(msg);
+        if (seq !== undefined && seen?.has(seq))
+            continue;
+        next.push(msg);
+    }
+    return next;
+}
+export function maxRoomSeq(current, messages, latestSeq) {
+    let next = typeof latestSeq === "number" && Number.isFinite(latestSeq) ? latestSeq : current;
+    for (const msg of messages) {
+        const seq = roomMessageSeq(msg);
+        if (seq !== undefined && seq > next)
+            next = seq;
+    }
+    return next;
+}
+export function noteSessionSeq(latestSeqs, sessionId, seq) {
+    if (!Number.isFinite(seq))
+        return false;
+    const current = latestSeqs.get(sessionId) ?? 0;
+    if (seq <= current)
+        return false;
+    latestSeqs.set(sessionId, seq);
+    return true;
+}
+export function markSessionUnread(unreadSessionIds, sessionId, activeSessionId) {
+    if (!sessionId || sessionId === activeSessionId || unreadSessionIds.has(sessionId)) {
+        return unreadSessionIds;
+    }
+    const next = new Set(unreadSessionIds);
+    next.add(sessionId);
+    return next;
+}
+export function clearUnreadSession(unreadSessionIds, sessionId) {
+    if (!sessionId || !unreadSessionIds.has(sessionId))
+        return unreadSessionIds;
+    const next = new Set(unreadSessionIds);
+    next.delete(sessionId);
+    return next;
+}
+export function pruneUnreadSessions(unreadSessionIds, sessionIds) {
+    const known = new Set(sessionIds);
+    let changed = false;
+    for (const id of unreadSessionIds) {
+        if (!known.has(id)) {
+            changed = true;
+            break;
+        }
+    }
+    if (!changed)
+        return unreadSessionIds;
+    const next = new Set();
+    for (const id of unreadSessionIds) {
+        if (known.has(id))
+            next.add(id);
+    }
+    return next;
+}

package/dist/hooks/useRemoteApp.d.ts

@@ -0,0 +1,89 @@
+import type { MobileSessionMeta, MobileProjectMeta, RoomPublic, MobileRemotePermissionMode as PermissionMode, ApprovalScope, ApprovalPathScope, CcDiscoveredSession } from "@cjhyy/code-shell-core";
+import { type ChatState } from "../lib/streamReducer.js";
+import { type Risk } from "../lib/riskClassify.js";
+import { type ConnStatus } from "./useRemoteSocket.js";
+import { type MobileComposerAttachment } from "../lib/mobileAttachments.js";
+/** Which external coding-CLI the CC pane drives. Mirrors desktop CCRoomView. */
+export type CcCliKind = "claude-code" | "codex";
+export interface PendingApproval {
+    requestId: string;
+    sessionId?: string;
+    /** Set for cc-room (external claude CLI) approvals — routes the response via
+     *  respondCcApproval(roomId, …) instead of the session approval path. */
+    roomId?: string;
+    toolName: string;
+    description: string;
+    summary: string;
+    risk: Risk;
+    /** AskUser options, when this is an AskUser approval. */
+    options?: string[];
+    /** When true, the user must pick an option (no free text). */
+    optionsOnly?: boolean;
+    /** True for path-scoped tools (Read/Edit/Write/…) → show file/dir scope. */
+    pathScoped: boolean;
+}
+export interface RemoteApp {
+    status: ConnStatus;
+    deviceName: string;
+    chat: ChatState;
+    sessions: MobileSessionMeta[];
+    unreadSessionIds: ReadonlySet<string>;
+    activeSessionId?: string;
+    activeCwd?: string | null;
+    projects: MobileProjectMeta[];
+    /** The bound room — for the user this is always an external CC (Claude Code)
+     *  session. The room is internal transport; there is no user-facing room list. */
+    activeRoom?: RoomPublic;
+    approvals: PendingApproval[];
+    permissionMode: PermissionMode;
+    loading: {
+        sessions: boolean;
+        sessionHistory: boolean;
+        /** Internal: the room.list fetch that resolves `activeRoom`'s metadata for a
+         *  bound CC session. No user-facing room list consumes this. */
+        rooms: boolean;
+        projects: boolean;
+        roomHistory: boolean;
+        ccSessions: boolean;
+    };
+    notice?: string;
+    logout: () => void;
+    sendChat: (input: {
+        text: string;
+        attachments: MobileComposerAttachment[];
+    }) => Promise<boolean>;
+    stopRun: () => void;
+    selectSession: (id: string) => void;
+    newSession: (cwd?: string | null, name?: string) => void;
+    refreshSessions: () => void;
+    respondApproval: (requestId: string, decision: "approve" | "reject", opts?: {
+        reason?: string;
+        answer?: string;
+        scope?: ApprovalScope;
+        pathScope?: ApprovalPathScope;
+    }) => void;
+    setPermissionMode: (mode: PermissionMode) => void;
+    extendGoal: (sessionId: string) => void;
+    clearGoal: (sessionId: string) => void;
+    /** Leave the bound CC session (drops the room binding, clears the feed). */
+    leaveRoom: () => void;
+    activeProjectCwd: string | null;
+    selectProject: (cwd: string) => void;
+    ccSessions: CcDiscoveredSession[];
+    ccProbe: {
+        available: boolean;
+        reason?: string;
+    } | null;
+    /** Selected CC CLI (Claude Code / Codex). Switching re-probes + re-lists. */
+    ccCliKind: CcCliKind;
+    setCcCliKind: (kind: CcCliKind) => void;
+    openCcSession: (sessionId: string, cwd: string, mode: PermissionMode) => void;
+    respondCcApproval: (roomId: string, requestId: string, decision: {
+        behavior: "allow";
+        updatedInput?: unknown;
+    } | {
+        behavior: "deny";
+        message: string;
+    }) => void;
+}
+export declare function useRemoteApp(): RemoteApp;