@cjhyy/code-shell-server 0.9.46 → 0.9.47

package/dist/mobile-remote/codex-room-agent.d.ts

@@ -76,12 +76,6 @@ export declare class CodexRoomAgent implements RoomAgent {
     private child?;
     private threadId?;
     private started;
-    /** True once the CURRENT turn emitted a sealing event (turn_end via
-     *  turn.completed, or an error). Reset at the start of each send(). */
-    private turnSealed;
-    /** True while stop() is tearing the room down, so the exit handler doesn't
-     *  mistake an intentional SIGTERM for a crash. */
-    private stopping;
     constructor(opts: CodexRoomAgentOptions);
     /** No persistent process to launch; a turn's process is spawned on send(). */
     start(): void;

package/dist/mobile-remote/codex-room-agent.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { stopRoomProcess } from "./room-process-stop.js";
 import { createInterface } from "node:readline";
 import { pathWithCommonBins } from "./path-bins.js";
 import { parseCodexJsonLine, extractThreadId } from "./codex-parse.js";
@@ -86,12 +87,6 @@ export class CodexRoomAgent {
     child;
     threadId;
     started = false;
-    /** True once the CURRENT turn emitted a sealing event (turn_end via
-     *  turn.completed, or an error). Reset at the start of each send(). */
-    turnSealed = false;
-    /** True while stop() is tearing the room down, so the exit handler doesn't
-     *  mistake an intentional SIGTERM for a crash. */
-    stopping = false;
     constructor(opts) {
         this.opts = opts;
         this.threadId = opts.resumeThreadId;
@@ -105,7 +100,7 @@ export class CodexRoomAgent {
             return false;
         if (this.child)
             return false; // a turn is already running; one turn at a time
-        this.turnSealed = false; // fresh turn — not yet sealed
+        let turnSealed = false; // This child owns only its own turn and callbacks.
         const args = codexArgsForTurn({ mode: this.opts.permissionMode, threadId: this.threadId });
         const child = spawn(this.opts.command, args, {
             cwd: this.opts.cwd,
@@ -114,11 +109,11 @@ export class CodexRoomAgent {
             stdio: ["pipe", "pipe", "pipe"],
         });
         this.child = child;
-        // Feed the user's prompt over stdin (codex exec reads it because argv ends `-`).
-        child.stdin?.end(text);
         if (child.stdout) {
             const rl = createInterface({ input: child.stdout });
             rl.on("line", (line) => {
+                if (this.child !== child)
+                    return;
                 // Capture the thread id (parseCodexJsonLine intentionally drops
                 // thread.started — it's resume-control info, not a render event) so we
                 // can resume on the next turn and persist it across restarts.
@@ -131,7 +126,7 @@ export class CodexRoomAgent {
                     // turn_end / error are the reducer's sealing events — once one fires
                     // for this turn, the exit handler need not synthesize a fallback.
                     if (ev.type === "turn_end" || ev.type === "error")
-                        this.turnSealed = true;
+                        turnSealed = true;
                     this.opts.onEvent(ev);
                 }
             });
@@ -146,17 +141,32 @@ export class CodexRoomAgent {
             errRl.on("line", (line) => stderrLines.push(line));
         }
         child.on("error", (err) => {
+            if (this.child !== child)
+                return;
+            this.child = undefined;
             const isMissing = err.code === "ENOENT";
-            this.turnSealed = true; // this error seals the run in the reducer
+            turnSealed = true; // this error seals the run in the reducer
             this.opts.onEvent({
                 type: "error",
                 error: isMissing
                     ? `未找到命令 "${this.opts.command}"。请先安装 Codex CLI 并确保它在 PATH 中。`
                     : err.message,
             });
+        });
+        child.stdin?.on("error", (error) => {
+            if (this.child !== child)
+                return;
             this.child = undefined;
+            stopRoomProcess(child);
+            this.opts.onEvent({
+                type: "error",
+                error: `Codex input pipe closed${error.code ? ` (${error.code})` : ""}`,
+            });
         });
-        child.on("exit", (code, signal) => {
+        child.on("close", (code, signal) => {
+            if (this.child !== child)
+                return;
+            this.child = undefined;
             // The turn's process is done; the room stays "running" (ready for the next
             // turn). We do NOT emit `exit` here — that would tear the room down in the
             // UI after every turn. turn.completed already produced a `turn_end`.
@@ -164,7 +174,7 @@ export class CodexRoomAgent {
             // is surfaced now so the room shows *why* it failed.
             const stderrErr = codexStderrError(stderrLines, code);
             if (stderrErr) {
-                this.turnSealed = true;
+                turnSealed = true;
                 this.opts.onEvent({ type: "error", error: stderrErr });
             }
             // FALLBACK SEAL (#6): if the process died without ever sealing the turn
@@ -174,14 +184,16 @@ export class CodexRoomAgent {
             const seal = sealEventOnExit({
                 code,
                 signal,
-                turnSealed: this.turnSealed,
-                stopping: this.stopping,
+                turnSealed,
+                stopping: false,
                 hasStderrError: stderrErr != null,
             });
             if (seal)
                 this.opts.onEvent(seal);
-            this.child = undefined;
         });
+        // Register stdin's error owner before writing: early CLI exits fail writes
+        // asynchronously even when end() itself returns successfully.
+        child.stdin?.end(text);
         return true;
     }
     /** The room is "running" once started — independent of whether a turn's
@@ -191,23 +203,9 @@ export class CodexRoomAgent {
     }
     stop() {
         this.started = false;
-        this.stopping = true; // the upcoming SIGTERM exit is intentional, not a crash
         const child = this.child;
         this.child = undefined;
-        if (!child?.pid || child.pid <= 1) {
-            child?.kill("SIGTERM");
-            return;
-        }
-        try {
-            process.kill(-child.pid, "SIGTERM");
-        }
-        catch {
-            try {
-                child.kill("SIGTERM");
-            }
-            catch {
-                /* already gone */
-            }
-        }
+        if (child)
+            stopRoomProcess(child);
     }
 }

package/dist/mobile-remote/mobile-client-event-validator.js

@@ -52,6 +52,14 @@ export function parseMobileClientEvent(value) {
         case "session.recovery.cancel":
             valid = true;
             break;
+        case "session.legacyBase":
+            valid =
+                boundedString(event.sessionId, 128) &&
+                    boundedString(event.recoveryId, 128) &&
+                    boundedString(event.requestId, 128) &&
+                    ((boundedString(event.throughEventId, 512) && event.cursor === undefined) ||
+                        (boundedString(event.cursor, 2048) && event.throughEventId === undefined));
+            break;
         case "session.outputJournal":
             valid =
                 boundedString(event.sessionId, 128) &&

package/dist/mobile-remote/remote-host-manager.d.ts

@@ -37,6 +37,8 @@ export interface RemoteHostStarted {
 export interface RemoteHostManagerOptions {
     devices: TrustedDeviceStore;
     outputJournal?: boolean;
+    /** Enable only when the attached selected-session host implements legacy base pages. */
+    legacyBasePages?: boolean;
     onClientEvent: (event: unknown, ws: WebSocket) => void | Promise<void>;
     /**
      * Absolute path to the built mobile app (out/mobile). Defaults to the

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

@@ -126,6 +126,16 @@ export class RemoteHostManager extends EventEmitter {
         const gate = this.passcode;
         this.opts.webApi?.start();
         const server = createServer((req, res) => {
+            let pathname;
+            try {
+                pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+            }
+            catch {
+                res.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
+                res.end("invalid request target");
+                req.resume();
+                return;
+            }
             // Tunnel mode: a passcode gate sits in front of EVERY route. The gate
             // either allows (returns true) or writes its own 401/403 challenge.
             if (gate && !gate.gate(req, res))
@@ -158,9 +168,7 @@ export class RemoteHostManager extends EventEmitter {
                 });
                 return;
             }
-            const uploadPath = req.url
-                ? new URL(req.url, "http://localhost").pathname.match(/^\/api\/mobile\/uploads\/([A-Za-z0-9_-]+)$/)
-                : null;
+            const uploadPath = pathname.match(/^\/api\/mobile\/uploads\/([A-Za-z0-9_-]+)$/);
             if (uploadPath && this.opts.uploads) {
                 void this.opts.uploads.acceptPut(uploadPath[1], req, res);
                 return;
@@ -411,7 +419,14 @@ export class RemoteHostManager extends EventEmitter {
             return {
                 type: "pair.ok",
                 device,
-                ...(this.opts.outputJournal ? { capabilities: { outputJournal: 1 } } : {}),
+                ...(this.opts.outputJournal
+                    ? {
+                        capabilities: {
+                            outputJournal: 1,
+                            ...(this.opts.legacyBasePages ? { legacyBasePages: 1 } : {}),
+                        },
+                    }
+                    : {}),
             };
         }
         if (event.type === "auth.device") {
@@ -427,7 +442,14 @@ export class RemoteHostManager extends EventEmitter {
             return {
                 type: "auth.ok",
                 device,
-                ...(this.opts.outputJournal ? { capabilities: { outputJournal: 1 } } : {}),
+                ...(this.opts.outputJournal
+                    ? {
+                        capabilities: {
+                            outputJournal: 1,
+                            ...(this.opts.legacyBasePages ? { legacyBasePages: 1 } : {}),
+                        },
+                    }
+                    : {}),
             };
         }
         return undefined;

package/dist/mobile-remote/resident-agent.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { stopRoomProcess } from "./room-process-stop.js";
 import { createInterface } from "node:readline";
 import { pathWithCommonBins } from "./path-bins.js";
 /**
@@ -151,11 +152,15 @@ export class ResidentAgentProcess {
         if (child.stdout) {
             const rl = createInterface({ input: child.stdout });
             rl.on("line", (line) => {
+                if (this.child !== child)
+                    return;
                 for (const ev of parseStreamJsonLine(line))
                     this.opts.onEvent(ev);
             });
         }
         child.stderr?.on("data", (chunk) => {
+            if (this.child !== child)
+                return;
             // claude prints non-fatal warnings to stderr; surface as error events
             // only if they look like real errors (cheap heuristic).
             const text = String(chunk);
@@ -167,11 +172,14 @@ export class ResidentAgentProcess {
             if (exited)
                 return;
             exited = true;
-            if (this.child === child)
-                this.child = undefined;
+            if (this.child !== child)
+                return;
+            this.child = undefined;
             this.opts.onEvent({ type: "exit", code, signal });
         };
         child.on("error", (err) => {
+            if (this.child !== child)
+                return;
             const isMissing = err.code === "ENOENT";
             this.opts.onEvent({
                 type: "error",
@@ -184,7 +192,19 @@ export class ResidentAgentProcess {
             if (child.pid === undefined)
                 finish(null, null);
         });
-        child.on("exit", (code, signal) => finish(code, signal));
+        child.stdin?.on("error", (error) => {
+            if (this.child !== child)
+                return;
+            // Pipe errors are emitted by stdin, separately from ChildProcess.error.
+            // Retire this room immediately; its eventual exit must not close a retry.
+            stopRoomProcess(child);
+            this.opts.onEvent({
+                type: "error",
+                error: `Claude Code input pipe closed${error.code ? ` (${error.code})` : ""}`,
+            });
+            finish(null, null);
+        });
+        child.on("close", (code, signal) => finish(code, signal));
     }
     /** Feed one user turn. Returns false if the process isn't running. */
     send(text) {
@@ -206,24 +226,7 @@ export class ResidentAgentProcess {
     stop() {
         const child = this.child;
         this.child = undefined;
-        // Guard pid > 1: process.kill(-1) would SIGTERM every process the user can
-        // reach, and -0 the caller's own group. `!child?.pid` already catches
-        // undefined/0; the `> 1` also rules out the (theoretical) pid-1 case so this
-        // negative-pid group kill is consistent with killProcessGroup's guard.
-        if (!child?.pid || child.pid <= 1) {
-            child?.kill("SIGTERM");
-            return;
-        }
-        try {
-            process.kill(-child.pid, "SIGTERM");
-        }
-        catch {
-            try {
-                child.kill("SIGTERM");
-            }
-            catch {
-                /* already gone */
-            }
-        }
+        if (child)
+            stopRoomProcess(child);
     }
 }

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

@@ -890,8 +890,10 @@ export class RoomManager {
         catch {
             throw new Error("linked session transcript is unavailable");
         }
-        if (!resolvedTarget ||
-            typeof resolvedTarget.externalSessionId !== "string" ||
+        if (!resolvedTarget) {
+            throw new Error("linked session transcript was not found for the requested session");
+        }
+        if (typeof resolvedTarget.externalSessionId !== "string" ||
             typeof resolvedTarget.cwd !== "string" ||
             resolvedTarget.externalSessionId !== target.externalSessionId ||
             resolvedTarget.kind !== target.kind ||

package/dist/mobile-remote/room-process-stop.d.ts

@@ -0,0 +1,3 @@
+import type { ChildProcess } from "node:child_process";
+/** Retire an unusable room transport without leaving an unresponsive CLI alive. */
+export declare function stopRoomProcess(child: ChildProcess): void;

package/dist/mobile-remote/room-process-stop.js

@@ -0,0 +1,28 @@
+/** Retire an unusable room transport without leaving an unresponsive CLI alive. */
+export function stopRoomProcess(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const signal = (value) => {
+        if (child.pid && child.pid > 1 && process.platform !== "win32") {
+            try {
+                process.kill(-child.pid, value);
+                return;
+            }
+            catch {
+                /* A failed spawn or an exited group falls back to the exact child. */
+            }
+        }
+        try {
+            child.kill(value);
+        }
+        catch {
+            /* already gone */
+        }
+    };
+    signal("SIGTERM");
+    if (!child.pid)
+        return;
+    const timer = setTimeout(() => signal("SIGKILL"), 1_000);
+    timer.unref();
+    child.once("exit", () => clearTimeout(timer));
+}

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

@@ -96,7 +96,8 @@ export declare class PanelAppAgentTaskService {
     get(owner: PanelAgentTaskOwner, id: unknown): PanelAgentTaskView;
     cancel(owner: PanelAgentTaskOwner, id: unknown): Promise<PanelAgentTaskView>;
     rebind(owner: PanelAgentTaskOwner): void;
-    cancelApp(appId: string): void;
+    /** `projects` limits cancellation to tasks bound to those (canonical) projects. */
+    cancelApp(appId: string, projects?: ReadonlySet<string>): void;
     private execute;
     private scopedTask;
     private emit;

package/dist/panels/agent-task-service.js

@@ -1,4 +1,4 @@
-import { panelExecutionGate } from "./execution-gate.js";
+import { panelExecutionGate, panelExecutionProject } from "./execution-gate.js";
 import { randomUUID } from "node:crypto";
 const MAX_TASKS = 200;
 const MAX_PROMPT_CHARS = 20_000;
@@ -131,7 +131,11 @@ export class PanelAppAgentTaskService {
             cancelRequested: false,
             activity: [],
         };
-        const release = panelExecutionGate.enter(owner);
+        const release = panelExecutionGate.enter({
+            appId: owner.appId,
+            projectPath: owner.projectPath,
+            holder: { kind: "agent-task", guestId: owner.guestId },
+        });
         this.tasks.set(task.id, task);
         this.trimHistory();
         this.emit(task);
@@ -174,10 +178,13 @@ export class PanelAppAgentTaskService {
             this.runtime.rebind(task.sessionId, task.owner);
         }
     }
-    cancelApp(appId) {
+    /** `projects` limits cancellation to tasks bound to those (canonical) projects. */
+    cancelApp(appId, projects) {
         for (const task of this.tasks.values()) {
             if (task.owner.appId !== appId || TERMINAL_STATUSES.has(task.status))
                 continue;
+            if (projects && !projects.has(panelExecutionProject(task.owner.projectPath)))
+                continue;
             task.cancelRequested = true;
             task.status = "cancelling";
             task.updatedAt = this.now();

package/dist/panels/execution-gate.d.ts

@@ -1,13 +1,29 @@
+/** What holds an execution, so a refused change can name it. Host-assigned only. */
+export interface PanelExecutionHolder {
+    kind: "panel-call" | "agent-tool" | "process" | "agent-task" | "tool-job" | "automation";
+    /** Desktop WebContents id of the Panel instance that owns this execution. */
+    guestId?: number;
+    /** Trusted Host description, such as a native tool entry name. */
+    label?: string;
+}
 export interface PanelExecutionScope {
     appId: string;
     /** Host-verified binding project, never a directory supplied by the guest. */
     projectPath: string;
+    holder?: PanelExecutionHolder;
+}
+export interface PanelExecutionBlocker extends PanelExecutionScope {
+    count: number;
 }
 /** Existing path aliases must not create separate admission domains. */
 export declare function panelExecutionProject(path: string): string;
 export declare class PanelExecutionBusyError extends Error {
+    /** Present when executions block a change; empty while another change runs. */
+    readonly blockers: PanelExecutionBlocker[];
     readonly status = 409;
-    constructor(message: string);
+    constructor(message: string, 
+    /** Present when executions block a change; empty while another change runs. */
+    blockers?: PanelExecutionBlocker[]);
 }
 /** One process owns admission for every Panel runtime sharing its installed catalog.
  * Acquire synchronously before authorization/IO; release after real execution cleanup,
@@ -21,6 +37,8 @@ export declare class PanelExecutionGate {
     run<T>(scope: PanelExecutionScope, work: () => Promise<T>): Promise<T>;
     /** Durable queues remain occupied even while paused and between process attempts. */
     register(source: () => Iterable<PanelExecutionScope>): () => void;
+    /** Executions that a change matching `matches` would wait for, grouped by holder. */
+    blockers(matches: (scope: PanelExecutionScope) => boolean): PanelExecutionBlocker[];
     mutate<T>(matches: (scope: PanelExecutionScope) => boolean, work: () => Promise<T>): Promise<T>;
 }
 export declare const panelExecutionGate: PanelExecutionGate;

package/dist/panels/execution-gate.js

@@ -10,9 +10,13 @@ export function panelExecutionProject(path) {
     }
 }
 export class PanelExecutionBusyError extends Error {
+    blockers;
     status = 409;
-    constructor(message) {
+    constructor(message, 
+    /** Present when executions block a change; empty while another change runs. */
+    blockers = []) {
         super(message);
+        this.blockers = blockers;
         this.name = "PanelExecutionBusyError";
     }
 }
@@ -25,7 +29,11 @@ export class PanelExecutionGate {
     sources = new Set();
     mutations = new Set();
     enter(scope) {
-        const held = { appId: scope.appId, projectPath: panelExecutionProject(scope.projectPath) };
+        const held = {
+            appId: scope.appId,
+            projectPath: panelExecutionProject(scope.projectPath),
+            ...(scope.holder ? { holder: { ...scope.holder } } : {}),
+        };
         if ([...this.mutations].some((matches) => matches(held)))
             throw new PanelExecutionBusyError("面板正在更新，请完成后重试。");
         this.executions.add(held);
@@ -49,13 +57,33 @@ export class PanelExecutionGate {
             this.sources.delete(source);
         };
     }
+    /** Executions that a change matching `matches` would wait for, grouped by holder. */
+    blockers(matches) {
+        const grouped = new Map();
+        const scopes = [...this.executions, ...[...this.sources].flatMap((source) => [...source()])];
+        for (const scope of scopes) {
+            if (!matches(scope))
+                continue;
+            const blocker = {
+                appId: scope.appId,
+                projectPath: scope.projectPath,
+                ...(scope.holder ? { holder: { ...scope.holder } } : {}),
+            };
+            const key = JSON.stringify(blocker), existing = grouped.get(key);
+            if (existing)
+                existing.count++;
+            else
+                grouped.set(key, { ...blocker, count: 1 });
+        }
+        return [...grouped.values()];
+    }
     async mutate(matches, work) {
         if (this.mutations.size)
             throw new PanelExecutionBusyError("另一个面板修改正在进行，请稍后重试。");
         // No await between the snapshot and installing the admission barrier.
-        if ([...this.executions].some(matches) ||
-            [...this.sources].some((source) => [...source()].some(matches)))
-            throw new PanelExecutionBusyError("面板还有正在提交、排队或运行的任务，请结束后再修改。");
+        const blockers = this.blockers(matches);
+        if (blockers.length)
+            throw new PanelExecutionBusyError("面板还有正在提交、排队或运行的任务，请结束后再修改。", blockers);
         this.mutations.add(matches);
         try {
             return await work();

package/dist/panels/hub-automations.js

@@ -98,6 +98,7 @@ export function createHubPanelAutomationHost(options) {
                 releaseExecution = panelExecutionGate.enter({
                     appId: job.panelSource.appId,
                     projectPath: options.bindingCwd ?? cwd,
+                    holder: { kind: "automation" },
                 });
             }
             try {

package/dist/panels/resources/uploads.js

@@ -214,12 +214,21 @@ export class ResourceUploadIngest {
     }
     async cleanupExpired() {
         await this.initialize();
-        for (const record of [...this.records.values()])
-            if (record.expiresAt <= this.options.now()) {
-                const key = this.key(record.scope, record.sessionId);
-                this.finishes.get(key)?.abort();
-                await this.locked(key, () => this.remove(record));
-            }
+        for (const key of [...this.records.keys()]) {
+            // Another upload may have renewed while cleanup waited on an earlier
+            // entry. Only the current expired record can cancel a running finish.
+            const record = this.records.get(key);
+            if (!record || record.expiresAt > this.options.now())
+                continue;
+            this.finishes.get(key)?.abort();
+            await this.locked(key, async () => {
+                // A write already holding this lock may acknowledge a chunk and renew
+                // the lease before cleanup enters. Never delete that renewed upload.
+                const current = this.records.get(key);
+                if (current && current.expiresAt <= this.options.now())
+                    await this.remove(current);
+            });
+        }
     }
     async begin(scope, raw) {
         await this.authorize(scope);

package/dist/panels/runtime.js

@@ -553,6 +553,7 @@ export function createPanelRuntime(options) {
         acquireExecution: (owner) => panelExecutionGate.enter({
             appId: owner.appId,
             projectPath: options.bindingCwd ?? options.cwd,
+            holder: { kind: "process" },
         }),
         approvalScope: "guest",
         resolvePackageEntry: async (owner, name) => {
@@ -941,7 +942,11 @@ export function createPanelRuntime(options) {
         };
     }
     async function onPanelAction(scope, input) {
-        return panelExecutionGate.run({ appId: scope.appId, projectPath: options.bindingCwd ?? options.cwd }, () => onPanelActionAdmitted(scope, input));
+        return panelExecutionGate.run({
+            appId: scope.appId,
+            projectPath: options.bindingCwd ?? options.cwd,
+            holder: { kind: "panel-call" },
+        }, () => onPanelActionAdmitted(scope, input));
     }
     async function onPanelActionAdmitted(scope, input) {
         const grant = grants.get(scope.instanceId);
@@ -980,6 +985,7 @@ export function createPanelRuntime(options) {
         const releaseExecution = panelExecutionGate.enter({
             appId: grant.app.id,
             projectPath: options.bindingCwd ?? options.cwd,
+            holder: { kind: "agent-tool" },
         });
         const requestId = randomBytes(18).toString("base64url");
         const value = await new Promise((done) => {
@@ -1309,7 +1315,11 @@ export function createPanelRuntime(options) {
         }
     }
     async function call(grant, input) {
-        return panelExecutionGate.run({ appId: grant.app.id, projectPath: options.bindingCwd ?? options.cwd }, () => callAdmitted(grant, input));
+        return panelExecutionGate.run({
+            appId: grant.app.id,
+            projectPath: options.bindingCwd ?? options.cwd,
+            holder: { kind: "panel-call" },
+        }, () => callAdmitted(grant, input));
     }
     async function callAdmitted(grant, input) {
         if (!(await authorized(grant)))

package/dist/panels/task-cookies.js

@@ -1,7 +1,7 @@
 import { createHmac, timingSafeEqual } from "node:crypto";
 import { chmod, lstat, mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
-import { formatNetscapeCookies, parseCookieJar, } from "@cjhyy/code-shell-core";
+import { formatNetscapeCookies, normalizeCookieDomain, cookieAppliesToHost, parseCookieJar, } from "@cjhyy/code-shell-core";
 function targetUrl(raw) {
     if (typeof raw !== "string" || raw.length > 2048)
         throw new Error("Cookie selection requires an HTTPS URL");
@@ -16,16 +16,6 @@ function targetUrl(raw) {
         throw new Error("Cookie selection requires an HTTPS URL");
     return url;
 }
-function domain(raw) {
-    if (typeof raw !== "string")
-        return;
-    const value = raw.toLowerCase().replace(/^\./, "");
-    if (value.length > 253 ||
-        !value.includes(".") ||
-        !value.split(".").every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label)))
-        return;
-    return value;
-}
 function beneath(host, root) {
     return host === root || host.endsWith(`.${root}`);
 }
@@ -86,7 +76,7 @@ export class PanelTaskCookieService {
         ]))
             .digest("hex");
     }
-    cookies(credential, root) {
+    cookies(credential, host) {
         const now = (this.options.now?.() ?? Date.now()) / 1000;
         if (typeof credential.secret !== "string" ||
             Buffer.byteLength(credential.secret) > 4 * 1024 * 1024)
@@ -106,8 +96,10 @@ export class PanelTaskCookieService {
                         !cookie.path.startsWith("/") ||
                         /[\x00-\x1f\x7f]/.test(cookie.path))))
                 return false;
-            const cookieDomain = domain(cookie.domain);
-            if (!cookieDomain || !beneath(cookieDomain, root))
+            // Account eligibility and actual Cookie scope are different fences:
+            // a login captured on www.example.com can carry .example.com cookies,
+            // but must not export host-only cookies from a sibling login host.
+            if (!cookieAppliesToHost(cookie, host))
                 return false;
             if (cookie.expirationDate !== undefined &&
                 (typeof cookie.expirationDate !== "number" ||
@@ -120,10 +112,10 @@ export class PanelTaskCookieService {
     async snapshot(scope, url) {
         await this.options.authorize(scope);
         const result = (await this.options.credentials(scope)).flatMap((credential) => {
-            const root = domain(credential.meta?.domain);
+            const root = normalizeCookieDomain(credential.meta?.domain);
             if (credential.type !== "cookie" || !root || !beneath(url.hostname.toLowerCase(), root))
                 return [];
-            const cookies = this.cookies(credential, root);
+            const cookies = this.cookies(credential, url.hostname);
             if (!cookies.length)
                 return [];
             return [

package/dist/panels/tool-jobs.js

@@ -179,11 +179,16 @@ export class PanelToolJobService {
         };
     }
     executionScopes() {
+        const held = (scope, label) => ({
+            appId: scope.appId,
+            projectPath: scope.projectPath,
+            holder: { kind: "tool-job", ...(label ? { label } : {}) },
+        });
         return [
-            ...[...this.preparing.values()].map((item) => item.scope),
+            ...[...this.preparing.values()].map((item) => held(item.scope)),
             ...[...this.jobs.values()]
                 .filter((job) => !TERMINAL.has(job.status) || this.active.has(job.id))
-                .map((job) => job.scope),
+                .map((job) => held(job.scope, job.entry.name)),
         ];
     }
     activeCount(projectPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-server",
-  "version": "0.9.46",
+  "version": "0.9.47",
   "description": "CodeShell server transport layer — mobile remote HTTP/WS host, pairing, passcode gate, tunnel, rooms, uploads, and session/attachment services. Electron-free; precursor of the auth gateway.",
   "type": "module",
   "main": "./dist/index.js",
@@ -62,14 +62,14 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-capability-coding": "0.9.46",
-    "@cjhyy/code-shell-core": "0.9.46",
-    "@cjhyy/code-shell-web": "0.9.46",
+    "@cjhyy/code-shell-capability-coding": "0.9.47",
+    "@cjhyy/code-shell-core": "0.9.47",
+    "@cjhyy/code-shell-web": "0.9.47",
     "@modelcontextprotocol/sdk": "^1.31.0",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0",
-    "@cjhyy/code-shell-link": "0.9.46",
-    "@cjhyy/code-shell-host": "0.9.46"
+    "@cjhyy/code-shell-link": "0.9.47",
+    "@cjhyy/code-shell-host": "0.9.47"
   },
   "engines": {
     "node": ">=20.10"