@cjhyy/code-shell-server 0.9.51 → 0.10.1

package/dist/headless-worker-env.js

@@ -0,0 +1,15 @@
+/** Desktop host clients that have no IPC peer in a headless worker. */
+const HEADLESS_WORKER_HOST_ENV_KEYS = [
+    "CODE_SHELL_REMOTE_LINK_CLIENT_SECRET",
+    "CODE_SHELL_OPERATION_BATCH_ACCESS",
+    "CODE_SHELL_MODEL_REQUEST_SIGNING",
+    "CODE_SHELL_WORKSPACE_ACCESS",
+    "CODE_SHELL_HOST_MCP_SERVERS",
+];
+/** Preserve the caller's environment while disabling Desktop-only host access. */
+export function headlessWorkerEnv(base, extra = {}) {
+    const env = { ...base };
+    for (const key of HEADLESS_WORKER_HOST_ENV_KEYS)
+        env[key] = undefined;
+    return { ...env, CODE_SHELL_CREDENTIAL_ACCESS: "local", ...extra };
+}

package/dist/hub/approval-lease.js

@@ -9,8 +9,13 @@ export class ApprovalLeases {
         this.now = now;
     }
     add(approval) {
-        if (this.entries.has(approval.requestId))
+        const existing = this.entries.get(approval.requestId);
+        if (existing) {
+            // A republished request (the user kept a question open) replaces its
+            // payload for later snapshots; the holder lease is unchanged.
+            existing.approval = approval;
             return;
+        }
         if (this.entries.size >= 256)
             throw new Error("too many pending approvals");
         this.entries.set(approval.requestId, {

package/dist/hub/configuration.d.ts

@@ -31,6 +31,10 @@ export declare function createHubConfiguration(options: HubConfigurationOptions)
             text?: string | undefined;
         };
         connections: {
+            paramValues?: {
+                [k: string]: string | number | boolean;
+            } | undefined;
+            unavailableParameters?: string[] | undefined;
             id: string;
             revision: string;
             catalogId: string;
@@ -46,6 +50,13 @@ export declare function createHubConfiguration(options: HubConfigurationOptions)
             adapterKind: string;
             defaultBaseUrl: string;
             needsKey: boolean;
+            modelPresets: {
+                parameters: import("./model-parameter-metadata.js").PublicModelParameter[];
+                supportsVision?: boolean | undefined;
+                maxContextTokens?: number | undefined;
+                value: string;
+                label: string;
+            }[];
         }[];
         skills: {
             disabledReason?: string | undefined;

package/dist/hub/configuration.js

@@ -4,6 +4,7 @@ import { SettingsManager, invalidateSkillCache, mergePluginMcpServers, scanSkill
 import { computeEffectiveDisabledLists, getMergedCatalog } from "@cjhyy/code-shell-core/internal";
 import { withModelTraceContext } from "@cjhyy/code-shell-core/internal";
 import { probeConfiguredModel } from "@cjhyy/code-shell-host";
+import { publicModelPresets, publicParameterValues, validateParameterPatch, unavailableParameters, } from "./model-parameter-metadata.js";
 const ROOT = "/api/v1/configuration";
 const MAX_BODY_BYTES = 64 * 1024;
 const MAX_SKILL_BYTES = 2 * 1024 * 1024;
@@ -69,6 +70,7 @@ export function createHubConfiguration(options) {
                 protocol: template?.protocol,
                 adapterKind: template?.adapterKind,
                 defaultBaseUrl: template?.defaultBaseUrl,
+                modelPresets: template?.modelPresets,
             },
         }))
             .digest("hex");
@@ -131,6 +133,12 @@ export function createHubConfiguration(options) {
                     baseUrl: displayUrl(connection.baseUrl ?? credential?.baseUrl ?? template?.defaultBaseUrl),
                     hasApiKey: Boolean(credential?.apiKey),
                     needsKey: template?.needsKey !== false,
+                    ...(connection.tag === "text"
+                        ? {
+                            paramValues: publicParameterValues(template?.modelPresets?.find((preset) => preset.value === connection.model), connection.paramValues),
+                            unavailableParameters: unavailableParameters(template?.modelPresets?.find((preset) => preset.value === connection.model), connection.paramValues),
+                        }
+                        : {}),
                 };
             }),
             catalog: catalog
@@ -141,6 +149,7 @@ export function createHubConfiguration(options) {
                 adapterKind: entry.adapterKind,
                 defaultBaseUrl: displayUrl(entry.defaultBaseUrl),
                 needsKey: entry.needsKey !== false,
+                modelPresets: publicModelPresets(entry),
             })),
             skills: allSkills.map((skill) => ({
                 name: skill.name,
@@ -200,7 +209,15 @@ export function createHubConfiguration(options) {
         });
     }
     function updateConnection(input) {
-        knownFields(input, ["id", "catalogId", "model", "baseUrl", "apiKey", "expectedRevision"]);
+        knownFields(input, [
+            "id",
+            "catalogId",
+            "model",
+            "baseUrl",
+            "apiKey",
+            "expectedRevision",
+            "paramValues",
+        ]);
         const id = boundedString(input.id, "id", 128);
         const catalogId = boundedString(input.catalogId, "catalogId", 128);
         const model = boundedString(input.model, "model", 256);
@@ -213,6 +230,21 @@ export function createHubConfiguration(options) {
             const effective = settingsManager().get();
             checkConnectionRevision(input, id, effective);
             const existing = effective.modelConnections.find((entry) => entry.id === id);
+            if (input.paramValues !== undefined &&
+                (existing ? typeof input.expectedRevision !== "string" : input.expectedRevision !== null))
+                throw new HubConfigurationError(409, "请载入最新连接后再保存模型参数。");
+            const parameters = input.paramValues === undefined
+                ? undefined
+                : validateParameterPatch(template.modelPresets?.find((preset) => preset.value === model), input.paramValues);
+            if (input.paramValues !== undefined && parameters === undefined)
+                throw new HubConfigurationError(400, "模型参数不受支持或超出允许范围，请刷新后检查。");
+            const mergedParameters = { ...existing?.paramValues };
+            for (const [key, value] of Object.entries(parameters ?? {})) {
+                if (value === null)
+                    delete mergedParameters[key];
+                else
+                    mergedParameters[key] = value;
+            }
             if (existing && (existing.tag !== "text" || existing.catalogId !== catalogId)) {
                 throw new HubConfigurationError(400, "existing connection provider cannot be changed");
             }
@@ -246,6 +278,7 @@ export function createHubConfiguration(options) {
                 model,
                 ...(credentialId ? { credentialId } : {}),
                 ...(baseUrl !== undefined ? { baseUrl: baseUrl || template.defaultBaseUrl } : {}),
+                ...(parameters !== undefined ? { paramValues: mergedParameters } : {}),
             };
             current.modelConnections = [
                 ...effective.modelConnections.filter((entry) => entry.id !== id),

package/dist/hub/model-parameter-metadata.d.ts

@@ -0,0 +1,26 @@
+import type { getMergedCatalog } from "@cjhyy/code-shell-core/internal";
+type Catalog = ReturnType<typeof getMergedCatalog>[number];
+type Preset = NonNullable<Catalog["modelPresets"]>[number];
+export interface PublicModelParameter {
+    name: string;
+    label: string;
+    control: "enum" | "number" | "toggle";
+    options?: string[];
+    min?: number;
+    max?: number;
+    default?: string | number | boolean;
+}
+export declare function modelParameters(preset?: Preset): PublicModelParameter[];
+export declare function publicParameterValues(preset: Preset | undefined, values: unknown): {
+    [k: string]: string | number | boolean;
+};
+export declare function unavailableParameters(preset: Preset | undefined, values: unknown): string[];
+export declare function validateParameterPatch(preset: Preset | undefined, input: unknown): Record<string, string | number | boolean | null> | undefined;
+export declare function publicModelPresets(entry: Catalog): {
+    parameters: PublicModelParameter[];
+    supportsVision?: boolean | undefined;
+    maxContextTokens?: number | undefined;
+    value: string;
+    label: string;
+}[];
+export {};

package/dist/hub/model-parameter-metadata.js

@@ -0,0 +1,92 @@
+/** Deliberately limited to text-generation controls; credential, endpoint,
+ * header, arbitrary text and wire-path declarations never reach the browser. */
+const NAMES = new Set([
+    "reasoning",
+    "reasoning_effort",
+    "thinking_type",
+    "temperature",
+    "top_p",
+    "max_tokens",
+]);
+const FIELDS = {
+    reasoning: [
+        "reasoning",
+        "reasoning_effort",
+        "reasoning.effort",
+        "thinking.budget_tokens",
+        "thinking.type",
+    ],
+    reasoning_effort: ["reasoning_effort"],
+    thinking_type: ["thinking_type", "thinking.type"],
+    temperature: ["temperature"],
+    top_p: ["top_p"],
+    max_tokens: ["max_tokens"],
+};
+export function modelParameters(preset) {
+    return (preset?.params ?? []).flatMap((spec) => {
+        if (!NAMES.has(spec.name) ||
+            preset.params.filter((candidate) => candidate.name === spec.name).length !== 1 ||
+            (spec.control !== "enum" && spec.control !== "number" && spec.control !== "toggle") ||
+            !FIELDS[spec.name]?.includes(spec.wire?.field ?? spec.name))
+            return [];
+        const result = {
+            name: spec.name,
+            label: spec.label ?? spec.name,
+            control: spec.control,
+            ...(spec.control === "enum" ? { options: [...(spec.options ?? [])] } : {}),
+            ...(spec.control === "number" ? { min: spec.min ?? 0, max: spec.max ?? 1_000_000_000 } : {}),
+        };
+        if (validParameter(result, spec.default))
+            result.default = spec.default;
+        return [result];
+    });
+}
+function validParameter(spec, value) {
+    if (spec.control === "enum")
+        return typeof value === "string" && value.length <= 256 && !!spec.options?.includes(value);
+    if (spec.control === "toggle")
+        return typeof value === "boolean";
+    if (spec.control !== "number")
+        return false;
+    return (typeof value === "number" &&
+        Number.isFinite(value) &&
+        value >= (spec.min ?? 0) &&
+        value <= (spec.max ?? 1_000_000_000));
+}
+export function publicParameterValues(preset, values) {
+    const source = values && typeof values === "object" && !Array.isArray(values) ? values : {};
+    return Object.fromEntries(modelParameters(preset).flatMap((spec) => {
+        const value = source[spec.name];
+        return validParameter(spec, value) ? [[spec.name, value]] : [];
+    }));
+}
+export function unavailableParameters(preset, values) {
+    const source = values && typeof values === "object" && !Array.isArray(values) ? values : {};
+    return modelParameters(preset)
+        .filter((spec) => Object.hasOwn(source, spec.name) &&
+        !validParameter(spec, source[spec.name]))
+        .map((spec) => spec.name);
+}
+export function validateParameterPatch(preset, input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return undefined;
+    const specs = modelParameters(preset);
+    const patch = Object.entries(input);
+    if (patch.length > NAMES.size)
+        return undefined;
+    if (patch.some(([key, value]) => {
+        const spec = specs.find((candidate) => candidate.name === key);
+        return !spec || (value !== null && !validParameter(spec, value));
+    }))
+        return undefined;
+    return input;
+}
+export function publicModelPresets(entry) {
+    return (entry.modelPresets ?? []).map((preset) => ({
+        value: preset.value,
+        label: preset.label ?? preset.value,
+        ...(preset.maxContextTokens !== undefined ? { maxContextTokens: preset.maxContextTokens } : {}),
+        ...(preset.supportsVision !== undefined ? { supportsVision: preset.supportsVision } : {}),
+        parameters: modelParameters(preset),
+    }));
+}

package/dist/hub/run-replay.js

@@ -1,4 +1,4 @@
-import { OutputCoverage } from "@cjhyy/code-shell-web";
+import { OutputCoverage } from "@cjhyy/code-shell-web/output-coverage";
 import { randomUUID } from "node:crypto";
 /**
  * A refresh can happen before the worker persists its current assistant text.

package/dist/hub/session-management.js

@@ -2,7 +2,7 @@ import { SessionFileError, readSessionFileSync, sessionListStorage, } from "@cjh
 import { listSessionEntries } from "@cjhyy/code-shell-core/internal";
 import { join, resolve } from "node:path";
 import { SessionManager } from "@cjhyy/code-shell-core";
-import { replayTranscript, transcriptUserDisplay } from "@cjhyy/code-shell-web";
+import { replayTranscript, transcriptUserDisplay } from "@cjhyy/code-shell-web/transcript-replay";
 import { createSessionTitlesStore, SessionTitleConflictError } from "../session-titles-store.js";
 import { hubJson } from "./uploads.js";
 const ROOT = "/api/v1/sessions";

package/dist/index.account.d.ts

@@ -0,0 +1,12 @@
+/** Optional native account authority. No Electron or renderer dependencies. */
+export * from "./account/types.js";
+export * from "./account/manager.js";
+export * from "./account/http.js";
+export * from "./account/store.js";
+export * from "./account/links.js";
+export * from "./account/profile.js";
+export * from "./account/cloud-contract.js";
+export * from "./account/cloud-types.js";
+export * from "./account/feature-service.js";
+export * from "./account/native-store.js";
+export * from "./account/cli.js";

package/dist/index.account.js

@@ -0,0 +1,12 @@
+/** Optional native account authority. No Electron or renderer dependencies. */
+export * from "./account/types.js";
+export * from "./account/manager.js";
+export * from "./account/http.js";
+export * from "./account/store.js";
+export * from "./account/links.js";
+export * from "./account/profile.js";
+export * from "./account/cloud-contract.js";
+export * from "./account/cloud-types.js";
+export * from "./account/feature-service.js";
+export * from "./account/native-store.js";
+export * from "./account/cli.js";

package/dist/index.mobile-remote.d.ts

@@ -1,5 +1,6 @@
 /** Mobile HTTP/WebSocket transport, rooms, uploads, pairing, and tunnels. */
 export * from "./mobile-remote/access-passcode.js";
+export type { AccountRelayAccessProvider, AccountRelayBinding, AccountRelayProject, } from "./mobile-remote/account-relay-access.js";
 export * from "./mobile-remote/cloudflared-binary.js";
 export * from "./mobile-remote/codex-parse.js";
 export * from "./mobile-remote/codex-room-agent.js";
@@ -17,5 +18,6 @@ export * from "./mobile-remote/resident-agent.js";
 export * from "./mobile-remote/room-manager.js";
 export * from "./mobile-remote/trusted-device-store.js";
 export * from "./mobile-remote/tunnel-manager.js";
+export * from "./mobile-remote/turn-queue.js";
 export * from "./mobile-remote/types.js";
 export * from "./mobile-remote/viewer-identity.js";

package/dist/index.mobile-remote.js

@@ -17,5 +17,6 @@ export * from "./mobile-remote/resident-agent.js";
 export * from "./mobile-remote/room-manager.js";
 export * from "./mobile-remote/trusted-device-store.js";
 export * from "./mobile-remote/tunnel-manager.js";
+export * from "./mobile-remote/turn-queue.js";
 export * from "./mobile-remote/types.js";
 export * from "./mobile-remote/viewer-identity.js";

package/dist/index.worker.d.ts

@@ -1,2 +1,3 @@
 /** Transport-agnostic stdio worker bridge for Node hosts. */
 export * from "./worker-bridge-core.js";
+export { headlessWorkerEnv } from "./headless-worker-env.js";

package/dist/index.worker.js

@@ -1,2 +1,3 @@
 /** Transport-agnostic stdio worker bridge for Node hosts. */
 export * from "./worker-bridge-core.js";
+export { headlessWorkerEnv } from "./headless-worker-env.js";

package/dist/mobile-remote/account-relay-access.d.ts

@@ -0,0 +1,59 @@
+import type { IncomingMessage } from "node:http";
+import type { TrustedDeviceStore } from "./trusted-device-store.js";
+export interface AccountRelayBinding {
+    authorizationId: string;
+    accountId: string;
+    rootSessionId: string;
+    hostId: string;
+    environmentId: string;
+    leaseId: string;
+    expiresAt: number;
+}
+export interface AccountRelayProject {
+    id: string;
+    name: string;
+    path: string;
+}
+/** Main owns device credentials and redeems only against its configured directory. */
+export interface AccountRelayAccessProvider {
+    hostId: string;
+    environmentId: string;
+    accountId?: string;
+    redeem: (handoff: string) => Promise<AccountRelayBinding>;
+    listProjects: () => Promise<AccountRelayProject[]>;
+}
+export interface CapturedAccountRelayAccess {
+    deviceId: string;
+    isAuthorized: () => boolean;
+}
+/** Independent entrance gate; an account credential is never a Host credential. */
+export declare class AccountRelayAccessGate {
+    private readonly devices;
+    private readonly onRevoke;
+    private provider?;
+    private readonly grants;
+    private readonly consumed;
+    private readonly pending;
+    private generation;
+    constructor(devices: TrustedDeviceStore, onRevoke: (deviceId: string) => void);
+    setProvider(provider?: AccountRelayAccessProvider): void;
+    get available(): boolean;
+    clear(): void;
+    revokeDevice(deviceId: string): boolean;
+    private retire;
+    exchange(handoff: string): Promise<{
+        hostAccessToken: string;
+        deviceId: string;
+        secretHash: string;
+        expiresAt: number;
+        hostId: string;
+        environmentId: string;
+    }>;
+    capture(request: IncomingMessage): CapturedAccountRelayAccess | undefined;
+    projects(access: CapturedAccountRelayAccess): Promise<{
+        hostId: string;
+        environmentId: string;
+        projects: AccountRelayProject[];
+    }>;
+}
+export declare function readRelayHandoff(request: IncomingMessage): Promise<string>;

package/dist/mobile-remote/account-relay-access.js

@@ -0,0 +1,174 @@
+import { createHash, randomBytes } from "node:crypto";
+/** Independent entrance gate; an account credential is never a Host credential. */
+export class AccountRelayAccessGate {
+    devices;
+    onRevoke;
+    provider;
+    grants = new Map();
+    consumed = new Map();
+    pending = new Set();
+    generation = 0;
+    constructor(devices, onRevoke) {
+        this.devices = devices;
+        this.onRevoke = onRevoke;
+    }
+    setProvider(provider) {
+        this.clear();
+        this.provider = provider;
+    }
+    get available() {
+        return !!this.provider;
+    }
+    clear() {
+        this.generation++;
+        for (const token of this.grants.keys())
+            this.retire(token);
+        this.consumed.clear();
+        this.pending.clear();
+    }
+    revokeDevice(deviceId) {
+        let revoked = false;
+        for (const [token, grant] of this.grants)
+            if (grant.deviceId === deviceId) {
+                this.retire(token);
+                revoked = true;
+            }
+        return revoked;
+    }
+    retire(token) {
+        const grant = this.grants.get(token);
+        if (!grant)
+            return;
+        this.grants.delete(token);
+        clearTimeout(grant.timer);
+        this.devices.removeEphemeralDevice(grant.deviceId);
+        this.onRevoke(grant.deviceId);
+    }
+    async exchange(handoff) {
+        const provider = this.provider;
+        const generation = this.generation;
+        const digest = createHash("sha256").update(handoff).digest("hex");
+        for (const [key, expiresAt] of this.consumed)
+            if (expiresAt <= Date.now())
+                this.consumed.delete(key);
+        if (!provider ||
+            this.grants.size + this.pending.size >= 128 ||
+            this.pending.has(digest) ||
+            this.consumed.has(digest))
+            throw new Error("Account relay handoff is unavailable");
+        this.pending.add(digest);
+        try {
+            const binding = await provider.redeem(handoff);
+            const now = Date.now();
+            if (this.provider !== provider ||
+                this.generation !== generation ||
+                !binding ||
+                typeof binding !== "object" ||
+                ![
+                    binding.authorizationId,
+                    binding.accountId,
+                    binding.rootSessionId,
+                    binding.hostId,
+                    binding.environmentId,
+                    binding.leaseId,
+                ].every((value) => typeof value === "string" &&
+                    value.length > 0 &&
+                    value.length <= 512 &&
+                    !value.includes("\0")) ||
+                binding.hostId !== provider.hostId ||
+                binding.environmentId !== provider.environmentId ||
+                (provider.accountId !== undefined && binding.accountId !== provider.accountId) ||
+                !Number.isSafeInteger(binding.expiresAt) ||
+                binding.expiresAt <= now ||
+                binding.expiresAt > now + 10 * 60_000)
+                throw new Error("Account relay handoff target is invalid");
+            this.consumed.set(digest, binding.expiresAt);
+            const hostAccessToken = randomBytes(32).toString("base64url");
+            const secretHash = randomBytes(32).toString("base64url");
+            const device = this.devices.addEphemeralDevice({
+                name: "Account device session",
+                secretHash,
+                expiresAt: binding.expiresAt,
+            });
+            const timer = setTimeout(() => this.retire(hostAccessToken), binding.expiresAt - now);
+            timer.unref();
+            this.grants.set(hostAccessToken, {
+                provider,
+                deviceId: device.id,
+                expiresAt: binding.expiresAt,
+                timer,
+            });
+            return {
+                hostAccessToken,
+                deviceId: device.id,
+                secretHash,
+                expiresAt: binding.expiresAt,
+                hostId: binding.hostId,
+                environmentId: binding.environmentId,
+            };
+        }
+        finally {
+            // A retired generation cannot release a newer redemption of the same handoff.
+            if (this.generation === generation)
+                this.pending.delete(digest);
+        }
+    }
+    capture(request) {
+        const token = request.headers["x-codeshell-host-access"];
+        if (typeof token !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(token))
+            return;
+        const grant = this.grants.get(token);
+        if (!grant)
+            return;
+        const isAuthorized = () => this.provider === grant.provider &&
+            this.grants.get(token) === grant &&
+            this.devices.isEphemeralDevice(grant.deviceId) &&
+            grant.expiresAt > Date.now();
+        if (!isAuthorized()) {
+            this.retire(token);
+            return;
+        }
+        return { deviceId: grant.deviceId, isAuthorized };
+    }
+    async projects(access) {
+        const provider = this.provider;
+        if (!provider || !access.isAuthorized())
+            throw new Error("Account relay access expired");
+        const projects = await provider.listProjects();
+        if (this.provider !== provider || !access.isAuthorized())
+            throw new Error("Account relay access expired");
+        return { hostId: provider.hostId, environmentId: provider.environmentId, projects };
+    }
+}
+export async function readRelayHandoff(request) {
+    if (request.headers["content-type"]?.split(";", 1)[0]?.trim() !== "application/json")
+        throw new Error("Invalid relay handoff");
+    const declared = Number(request.headers["content-length"] ?? 0);
+    if (!Number.isFinite(declared) || declared > 8192)
+        throw new Error("Invalid relay handoff");
+    const chunks = [];
+    let bytes = 0;
+    const timeout = setTimeout(() => request.destroy(), 10_000);
+    timeout.unref();
+    try {
+        for await (const chunk of request) {
+            bytes += Buffer.byteLength(chunk);
+            if (bytes > 8192)
+                throw new Error("Invalid relay handoff");
+            chunks.push(Buffer.from(chunk));
+        }
+        const input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (!input ||
+            typeof input !== "object" ||
+            Array.isArray(input) ||
+            Object.keys(input).length !== 1 ||
+            !("handoff" in input) ||
+            typeof input.handoff !== "string" ||
+            !/^[A-Za-z0-9_-]{32,4096}$/.test(input.handoff))
+            throw new Error("Invalid relay handoff");
+        return input.handoff;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/mobile-remote/approval-clock.d.ts

@@ -0,0 +1,3 @@
+/** Timestamp at delivery, including reconnect replay, so a phone never compares
+ * a worker deadline directly with its own potentially skewed wall clock. */
+export declare function stampApprovalClock(line: string, now?: number): string;

package/dist/mobile-remote/approval-clock.js

@@ -0,0 +1,15 @@
+/** Timestamp at delivery, including reconnect replay, so a phone never compares
+ * a worker deadline directly with its own potentially skewed wall clock. */
+export function stampApprovalClock(line, now = Date.now()) {
+    if (!line.includes("agent/approvalRequest"))
+        return line;
+    try {
+        const message = JSON.parse(line);
+        if (message?.method !== "agent/approvalRequest" || !Number.isFinite(message.params?.expiresAt))
+            return line;
+        return JSON.stringify({ ...message, serverTime: now });
+    }
+    catch {
+        return line;
+    }
+}

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

@@ -74,6 +74,8 @@ export interface CodexRoomAgentOptions {
 export declare class CodexRoomAgent implements RoomAgent {
     private readonly opts;
     private child?;
+    /** Last turn process, kept so stopAndWait() can prove it exited. */
+    private lastChild?;
     private threadId?;
     private started;
     constructor(opts: CodexRoomAgentOptions);
@@ -84,5 +86,9 @@ export declare class CodexRoomAgent implements RoomAgent {
      *  process is currently alive (turns are ephemeral). */
     isRunning(): boolean;
     stop(): void;
+    /** A turn's `codex exec` child may still be alive after turn_end was parsed. */
+    isBusy(): boolean;
+    /** Stop, then resolve true only once the last turn process has exited. */
+    stopAndWait(timeoutMs: number): Promise<boolean>;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { releaseStdioAfterExit, stopRoomProcess } from "./room-process-stop.js";
+import { releaseStdioAfterExit, stopRoomProcess, stopRoomProcessAndWait, } from "./room-process-stop.js";
 import { createInterface } from "node:readline";
 import { pathWithCommonBins } from "./path-bins.js";
 import { parseCodexJsonLine, extractThreadId } from "./codex-parse.js";
@@ -85,6 +85,8 @@ export function sealEventOnExit(opts) {
 export class CodexRoomAgent {
     opts;
     child;
+    /** Last turn process, kept so stopAndWait() can prove it exited. */
+    lastChild;
     threadId;
     started = false;
     constructor(opts) {
@@ -109,6 +111,7 @@ export class CodexRoomAgent {
             stdio: ["pipe", "pipe", "pipe"],
         });
         this.child = child;
+        this.lastChild = child;
         // Settle on `close` so trailing output is read, without waiting on grandchildren.
         releaseStdioAfterExit(child);
         if (child.stdout) {
@@ -210,4 +213,17 @@ export class CodexRoomAgent {
         if (child)
             stopRoomProcess(child);
     }
+    /** A turn's `codex exec` child may still be alive after turn_end was parsed. */
+    isBusy() {
+        return Boolean(this.child);
+    }
+    /** Stop, then resolve true only once the last turn process has exited. */
+    stopAndWait(timeoutMs) {
+        this.started = false;
+        const child = this.child ?? this.lastChild;
+        this.child = undefined;
+        if (!child)
+            return Promise.resolve(true);
+        return stopRoomProcessAndWait(child, timeoutMs);
+    }
 }

package/dist/mobile-remote/mobile-chat-turn.d.ts

@@ -14,6 +14,10 @@ export interface DispatchMobileChatTurnInput {
     attachments?: MobileImageAttachment[];
     clientMessageId?: string;
     modelTraceSource?: string;
+    /** Host-resolved per-run model pool key; never a global model setting. */
+    model?: string;
+    configuredModel?: import("@cjhyy/code-shell-core/internal").ConfiguredTextModelIntent;
+    workspaceProfile?: string;
     permissionMode?: PermissionMode;
     runId: string;
     bridge: MobileRunBridge;