@cjhyy/code-shell-server 0.9.8 → 0.9.10

package/dist/mobile-remote/remote-host-manager.js

@@ -39,6 +39,7 @@ export class RemoteHostManager extends EventEmitter {
     wss;
     started;
     starting;
+    stopping;
     pairing = new PairingTokenManager();
     /** ws → authenticated device id. A socket absent here is unauthenticated. */
     authed = new WeakMap();
@@ -91,6 +92,10 @@ export class RemoteHostManager extends EventEmitter {
         }
     }
     async start(options) {
+        // A prior close owns the shared HTTP facade/upload services until every
+        // cleanup step settles. A restart must not reopen them underneath it.
+        if (this.stopping)
+            await this.stopping;
         if (this.started)
             return this.started;
         if (this.starting)
@@ -109,6 +114,7 @@ export class RemoteHostManager extends EventEmitter {
         const tunnel = options.mode === "tunnel";
         this.passcode = tunnel ? options.passcode : undefined;
         const gate = this.passcode;
+        this.opts.webApi?.start();
         const server = createServer((req, res) => {
             // Tunnel mode: a passcode gate sits in front of EVERY route. The gate
             // either allows (returns true) or writes its own 401/403 challenge.
@@ -119,6 +125,29 @@ export class RemoteHostManager extends EventEmitter {
                 res.end(JSON.stringify({ ok: true }));
                 return;
             }
+            if (req.url?.startsWith("/api/v1/") && this.opts.webApi) {
+                const baseUrl = this.publicBaseUrl ?? this.started?.url;
+                if (!baseUrl) {
+                    res.writeHead(503);
+                    res.end("remote host is starting");
+                    return;
+                }
+                void this.opts.webApi
+                    .handle(req, res, { baseUrl })
+                    .then((handled) => {
+                    if (!handled && !res.writableEnded) {
+                        res.writeHead(404);
+                        res.end("not found");
+                    }
+                })
+                    .catch(() => {
+                    if (!res.headersSent)
+                        res.writeHead(500);
+                    if (!res.writableEnded)
+                        res.end("remote request failed");
+                });
+                return;
+            }
             const uploadPath = req.url
                 ? new URL(req.url, "http://localhost").pathname.match(/^\/api\/mobile\/uploads\/([A-Za-z0-9_-]+)$/)
                 : null;
@@ -179,6 +208,13 @@ export class RemoteHostManager extends EventEmitter {
         this.wss.on("connection", (ws) => {
             const viewerId = `viewer-${this.nextViewerId++}`;
             this.viewers.set(ws, viewerId);
+            ws.on("error", (error) => {
+                // ws emits parser/size-limit failures on the individual socket. An
+                // unhandled error here would terminate the entire Node/Electron host.
+                this.releaseSocket(ws);
+                ws.terminate();
+                this.emit("host-error", error);
+            });
             ws.on("message", (raw) => {
                 let parsed;
                 try {
@@ -205,15 +241,11 @@ export class RemoteHostManager extends EventEmitter {
                     return;
                 }
                 if (event.type === "auth.device" && reply?.type === "auth.ok") {
-                    if (!this.authed.has(ws))
-                        this.markOnline(reply.device.id);
-                    this.authed.set(ws, reply.device.id);
+                    this.bindSocketDevice(ws, reply.device.id);
                 }
                 // Pairing also yields a live, identified socket → count it online.
                 if (event.type === "pair.complete" && reply?.type === "pair.ok") {
-                    if (!this.authed.has(ws))
-                        this.markOnline(reply.device.id);
-                    this.authed.set(ws, reply.device.id);
+                    this.bindSocketDevice(ws, reply.device.id);
                 }
                 if (reply) {
                     ws.send(JSON.stringify(reply));
@@ -277,6 +309,7 @@ export class RemoteHostManager extends EventEmitter {
                 this.server = undefined;
             this.wss = undefined;
             this.passcode = undefined;
+            await this.opts.webApi?.close();
             throw error;
         }
         const addr = server.address();
@@ -395,7 +428,42 @@ export class RemoteHostManager extends EventEmitter {
         }
         this.markOffline(deviceId);
     }
-    async stop() {
+    bindSocketDevice(ws, deviceId) {
+        const previous = this.authed.get(ws);
+        if (previous === deviceId)
+            return;
+        if (previous) {
+            // One socket can authenticate/pair again. Retire its old viewer before
+            // switching owners so subscriptions and grants cannot cross identities.
+            this.releaseSocket(ws);
+            this.viewers.set(ws, `viewer-${this.nextViewerId++}`);
+        }
+        this.authed.set(ws, deviceId);
+        this.markOnline(deviceId);
+    }
+    /** Call after revoking/removing a trusted device to release both transports immediately. */
+    revokeDevice(deviceId) {
+        this.opts.webApi?.revokeDevice(deviceId);
+        for (const client of this.wss?.clients ?? []) {
+            if (this.authed.get(client) !== deviceId)
+                continue;
+            this.releaseSocket(client);
+            client.terminate();
+        }
+    }
+    stop() {
+        if (this.stopping)
+            return this.stopping;
+        const attempt = Promise.resolve()
+            .then(() => this.stopOnce())
+            .finally(() => {
+            if (this.stopping === attempt)
+                this.stopping = undefined;
+        });
+        this.stopping = attempt;
+        return attempt;
+    }
+    async stopOnce() {
         if (this.starting)
             await this.starting.catch(() => undefined);
         const server = this.server;
@@ -419,14 +487,21 @@ export class RemoteHostManager extends EventEmitter {
         for (const deviceId of this.onlineCounts.keys())
             this.emit("device-offline", deviceId);
         this.onlineCounts.clear();
-        await this.opts.uploads?.cancelActiveTransfers();
-        if (!server)
-            return;
-        // server.close() only stops accepting new connections and waits for live
-        // ones to end — a lingering upgraded/keep-alive socket keeps its callback
-        // from ever firing. Destroy any remaining connections so close() resolves.
-        server.closeAllConnections?.();
-        await new Promise((resolve) => server.close(() => resolve()));
+        // A failed service cleanup must not strand an unreachable HTTP listener or
+        // prevent another service from releasing its uploads/resources.
+        const cleanup = await Promise.allSettled([
+            Promise.resolve().then(() => this.opts.webApi?.close()),
+            Promise.resolve().then(() => this.opts.uploads?.cancelActiveTransfers()),
+        ]);
+        if (server) {
+            // server.close() waits for live connections. Drop any lingering HTTP
+            // keep-alive sockets after services have cancelled their active work.
+            server.closeAllConnections?.();
+            await new Promise((resolve) => server.close(() => resolve()));
+        }
+        const failure = cleanup.find((result) => result.status === "rejected");
+        if (failure?.status === "rejected")
+            throw failure.reason;
     }
     status() {
         return this.started;

package/dist/mobile-remote/room-manager.js

@@ -84,9 +84,7 @@ function parseRoomMeta(value, expectedId) {
         permissionMode: raw.permissionMode,
         createdAt: raw.createdAt,
         lastActiveAt: raw.lastActiveAt,
-        ...(typeof raw.claudeSessionId === "string"
-            ? { claudeSessionId: raw.claudeSessionId }
-            : {}),
+        ...(typeof raw.claudeSessionId === "string" ? { claudeSessionId: raw.claudeSessionId } : {}),
         ...(raw.linkedSessionMode === "observe-only"
             ? { linkedSessionMode: raw.linkedSessionMode }
             : {}),
@@ -114,7 +112,8 @@ function parseRoomMessage(value) {
     }
     if (raw.isError !== undefined && typeof raw.isError !== "boolean")
         return undefined;
-    if (raw.args !== undefined && (!raw.args || typeof raw.args !== "object" || Array.isArray(raw.args))) {
+    if (raw.args !== undefined &&
+        (!raw.args || typeof raw.args !== "object" || Array.isArray(raw.args))) {
         return undefined;
     }
     if (raw.attachments !== undefined && !Array.isArray(raw.attachments))
@@ -780,6 +779,12 @@ export class RoomManager {
         const hasOriginalInput = this.pendingApprovalInputs.has(askKey);
         const originalInput = this.pendingApprovalInputs.get(askKey);
         this.pendingApprovalInputs.delete(askKey);
+        // A control response consumes exactly one server-observed request. The
+        // bridge can settle multiple waiters when a duplicate control ID arrives;
+        // only the first settlement may reach the resident process. This also
+        // rejects unsolicited and late replies after a room has been closed.
+        if (!hasPendingAsk && !hasOriginalInput)
+            return false;
         const agent = this.agents.get(roomId);
         if (!agent?.respondControl)
             return false;
@@ -821,7 +826,14 @@ export class RoomManager {
         if (meta.linkedSessionMode === "observe-only")
             return { status: "observing" };
         if (!this.agents.has(id)) {
-            const agent = this.opts.createAgent(meta, (event) => this.onAgentEvent(id, event));
+            let agent = undefined;
+            agent = this.opts.createAgent(meta, (event) => {
+                // stop() sends a signal; an old process can still drain output or emit
+                // exit after the room has reopened. Only the current process owns its
+                // transcript, pending approvals, and terminal lifecycle transition.
+                if (agent && this.agents.get(id) === agent)
+                    this.onAgentEvent(id, event);
+            });
             this.agents.set(id, agent);
             try {
                 agent.start();

package/dist/panels/agent-task-host.d.ts

@@ -0,0 +1,32 @@
+import { type PanelAgentTaskModelCatalog } from "./agent-task-models.js";
+export interface PanelAgentTaskScope {
+    instanceId: string;
+    ownerId: string;
+    appId: string;
+    appTitle: string;
+    projectPath: string;
+    cwd: string;
+    permissions: readonly string[];
+    availableSkills: readonly string[];
+    isAuthorized: () => Promise<boolean>;
+    emit: (event: string, payload: unknown) => void;
+}
+export interface PanelAgentTaskHostOptions {
+    workerEntryPath?: string;
+    execPath?: string;
+    buildEnv?: () => NodeJS.ProcessEnv;
+    models?: (cwd: string) => PanelAgentTaskModelCatalog | Promise<PanelAgentTaskModelCatalog>;
+    /** The host implements panel discovery and callbacks, scoped to this one installed app. */
+    onPanelAction?: (scope: PanelAgentTaskScope, input: Record<string, unknown>) => Promise<unknown>;
+    maxConcurrentTasks?: number;
+    authorizationPollMs?: number;
+    runTimeoutMs?: number;
+}
+/** Real independent Core workers shared by Desktop Web and standalone Hub. */
+export declare function createPanelAgentTaskHost(options?: PanelAgentTaskHostOptions): {
+    call(scope: PanelAgentTaskScope, method: string, params?: unknown): Promise<unknown>;
+    revokeInstance: (instanceId: string) => void;
+    close(): void;
+    activeTaskCount: () => number;
+};
+export type PanelAgentTaskHost = ReturnType<typeof createPanelAgentTaskHost>;