@cjhyy/code-shell-core 0.6.0-rc.12 → 0.6.0-rc.13

package/dist/session/session-manager.js

@@ -1,13 +1,14 @@
 /**
  * Session lifecycle manager.
  */
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { closeSync, existsSync, mkdirSync, lstatSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { nanoid } from "nanoid";
 import { Transcript } from "./transcript.js";
 import { SessionError } from "../exceptions.js";
 import { normalizeCumulativeUsageCounters } from "../engine/session-usage.js";
+import { branchExists, isGitWorktreeRoot } from "../git/worktree.js";
 /**
  * Validate a session ID before it is joined into a filesystem path.
  *
@@ -55,6 +56,44 @@ export function assertSafeSessionId(sessionId) {
 export function codeShellHome() {
     return process.env.CODE_SHELL_HOME || join(homedir(), ".code-shell");
 }
+function isSessionWorkspace(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const ws = value;
+    if (typeof ws.root !== "string" || ws.root.length === 0)
+        return false;
+    if (ws.kind !== "main" && ws.kind !== "worktree")
+        return false;
+    if (ws.kind === "main")
+        return ws.worktree === undefined;
+    const wt = ws.worktree;
+    return (!!wt &&
+        typeof wt.path === "string" &&
+        wt.path.length > 0 &&
+        typeof wt.branch === "string" &&
+        wt.branch.length > 0 &&
+        typeof wt.baseRef === "string" &&
+        wt.baseRef.length > 0 &&
+        wt.createdBy === "codeshell");
+}
+function validateResumeWorktreeRoot(root) {
+    if (!existsSync(root))
+        return "no longer exists";
+    let stat;
+    try {
+        stat = lstatSync(root);
+    }
+    catch {
+        return "no longer exists";
+    }
+    if (stat.isSymbolicLink())
+        return "is not a valid git worktree (symbolic link)";
+    if (!stat.isDirectory())
+        return "is not a valid git worktree (not a directory)";
+    if (!isGitWorktreeRoot(root))
+        return "is not a valid git worktree";
+    return null;
+}
 export class SessionManager {
     sessionsDir;
     constructor(storageDir) {
@@ -76,10 +115,19 @@ export class SessionManager {
             assertSafeSessionId(explicitSessionId);
         const sessionId = explicitSessionId ?? nanoid(16);
         const sessionDir = join(this.sessionsDir, sessionId);
-        mkdirSync(sessionDir, { recursive: true });
+        try {
+            mkdirSync(sessionDir);
+        }
+        catch (err) {
+            if (err.code === "EEXIST") {
+                throw new SessionError(`Session already exists: ${sessionId}`);
+            }
+            throw err;
+        }
         const state = {
             sessionId,
             cwd,
+            workspace: { root: cwd, kind: "main" },
             startedAt: Date.now(),
             model,
             provider,
@@ -158,6 +206,143 @@ export class SessionManager {
             return undefined;
         }
     }
+    /**
+     * Disk-only workspace pointer reader. Legacy sessions written before
+     * `workspace` existed are treated as main-workspace sessions rooted at
+     * `state.cwd`; the read is intentionally non-mutating.
+     */
+    getSessionWorkspace(sessionId) {
+        try {
+            assertSafeSessionId(sessionId);
+        }
+        catch {
+            return undefined;
+        }
+        const stateFile = join(this.sessionsDir, sessionId, "state.json");
+        if (!existsSync(stateFile))
+            return undefined;
+        try {
+            const state = JSON.parse(readFileSync(stateFile, "utf-8"));
+            if (isSessionWorkspace(state.workspace))
+                return state.workspace;
+            return typeof state.cwd === "string" && state.cwd.length > 0
+                ? { root: state.cwd, kind: "main" }
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Persist the current session workspace pointer without changing legacy
+     * `cwd`. P1 will teach ToolContext to resolve cwd from this field; for P0 it
+     * is a safety pointer and resume breadcrumb.
+     */
+    setSessionWorkspace(sessionId, workspace) {
+        assertSafeSessionId(sessionId);
+        if (!isSessionWorkspace(workspace)) {
+            throw new SessionError(`invalid workspace for session ${sessionId}`);
+        }
+        const stateFile = join(this.sessionsDir, sessionId, "state.json");
+        if (!existsSync(stateFile)) {
+            throw new SessionError(`Session state file not found: ${sessionId}`);
+        }
+        let state;
+        try {
+            state = JSON.parse(readFileSync(stateFile, "utf-8"));
+        }
+        catch (err) {
+            throw new SessionError(`Session state is corrupt for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        state.workspace = workspace;
+        this.saveState(state);
+    }
+    recordWorkspaceHandoff(sessionId, from, to) {
+        assertSafeSessionId(sessionId);
+        const transcriptFile = join(this.sessionsDir, sessionId, "transcript.jsonl");
+        if (!existsSync(transcriptFile))
+            return;
+        try {
+            const transcript = new Transcript(transcriptFile);
+            transcript.append("session_meta", {
+                sessionId,
+                cwd: to.root,
+                workspace: to,
+                handoffFrom: from?.root,
+                handoffAt: Date.now(),
+            });
+        }
+        catch {
+            // Transcript handoff metadata is best-effort; state.workspace is the
+            // authoritative switch pointer.
+        }
+    }
+    /**
+     * Resolve the cwd a resumed session must run in from its persisted workspace
+     * pointer. A missing worktree directory is never silently treated as the main
+     * repo: if the branch still exists callers get a blocking recreate message;
+     * if the branch is gone the workspace pointer is reset to main and a warning
+     * message is returned for the host to surface before continuing.
+     */
+    resolveSessionWorkspaceForResume(sessionId) {
+        assertSafeSessionId(sessionId);
+        const stateFile = join(this.sessionsDir, sessionId, "state.json");
+        if (!existsSync(stateFile)) {
+            throw new SessionError(`Session state file not found: ${sessionId}`);
+        }
+        let state;
+        try {
+            state = JSON.parse(readFileSync(stateFile, "utf-8"));
+        }
+        catch (err) {
+            throw new SessionError(`Session state is corrupt for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const legacyMain = typeof state.cwd === "string" && state.cwd.length > 0
+            ? { root: state.cwd, kind: "main" }
+            : undefined;
+        const workspace = isSessionWorkspace(state.workspace) ? state.workspace : legacyMain;
+        if (!workspace) {
+            throw new SessionError(`Session ${sessionId} has no recoverable cwd`);
+        }
+        if (workspace.kind === "main") {
+            return {
+                ok: true,
+                cwd: workspace.root,
+                workspace,
+                reason: isSessionWorkspace(state.workspace) ? "main" : "legacy",
+            };
+        }
+        const invalidWorktreeReason = validateResumeWorktreeRoot(workspace.root);
+        if (!invalidWorktreeReason) {
+            return { ok: true, cwd: workspace.root, workspace, reason: "worktree" };
+        }
+        const branch = workspace.worktree?.branch;
+        const mainRoot = typeof state.cwd === "string" && state.cwd.length > 0 ? state.cwd : workspace.root;
+        if (branch && existsSync(mainRoot) && branchExists(mainRoot, branch)) {
+            return {
+                ok: false,
+                cwd: mainRoot,
+                workspace,
+                reason: "worktree_missing_branch_exists",
+                message: `Session ${sessionId} is bound to worktree ${workspace.root}, but that directory ` +
+                    `${invalidWorktreeReason}. Branch ${branch} still exists; recreate the worktree at ` +
+                    `${workspace.worktree?.path ?? workspace.root} before resuming, or switch this session ` +
+                    `back to main explicitly.`,
+            };
+        }
+        const fallback = { root: mainRoot, kind: "main" };
+        state.workspace = fallback;
+        this.saveState(state);
+        return {
+            ok: true,
+            cwd: mainRoot,
+            workspace: fallback,
+            reason: "worktree_missing_branch_gone",
+            message: `Session ${sessionId} was bound to worktree ${workspace.root}, but that directory ` +
+                `${invalidWorktreeReason}${branch ? ` and branch ${branch} is gone` : ""}; fell back to main ` +
+                `${mainRoot}. Re-run the request if you want to continue there.`,
+        };
+    }
     /**
      * Cheap "does this session have a persisted goal?" probe — reads only
      * state.json, NOT the transcript (like readCwd). A persistent goal lives ONLY
@@ -436,6 +621,8 @@ function parseUserPreview(line) {
         return undefined;
     if (event.data?.role !== "user")
         return undefined;
+    if (event.data.injected === true)
+        return undefined;
     const content = event.data.content;
     const text = typeof content === "string"
         ? content

package/dist/settings/manager.d.ts

@@ -18,6 +18,7 @@ export declare function userHome(): string;
  * ("permissions.defaultMode", "env.FOO") are caught too.
  */
 export declare function isProtectedSettingKey(key: string): boolean;
+export declare function setDottedSetting(target: Record<string, unknown>, key: string, value: unknown): void;
 /**
  * The fixed cwd used for "no-repo" pure-chat conversations (a chat not bound to
  * any code project). Same location as desktop's `resolveNoRepoCwd`

package/dist/settings/manager.js

@@ -50,6 +50,45 @@ export function isProtectedSettingKey(key) {
     const root = key.split(".")[0] ?? "";
     return PROTECTED_SETTING_ROOTS.has(root);
 }
+const FORBIDDEN_SETTING_KEY_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
+function parseDottedSettingKey(key) {
+    const parts = key.split(".");
+    if (parts.length === 0 ||
+        parts.some((seg) => seg.length === 0 || FORBIDDEN_SETTING_KEY_SEGMENTS.has(seg))) {
+        throw new Error(`invalid setting key: ${key}`);
+    }
+    return parts;
+}
+function isOwnPlainObject(parent, key) {
+    if (!Object.prototype.hasOwnProperty.call(parent, key))
+        return false;
+    const value = parent[key];
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function descendForSettingWrite(target, key, fullKey) {
+    if (!Object.prototype.hasOwnProperty.call(target, key)) {
+        const inherited = target[key];
+        if (inherited && typeof inherited === "object") {
+            throw new Error(`invalid setting key: ${fullKey} (refusing to descend through inherited object segment: ${key})`);
+        }
+        target[key] = {};
+    }
+    else if (!isOwnPlainObject(target, key)) {
+        target[key] = {};
+    }
+    return target[key];
+}
+export function setDottedSetting(target, key, value) {
+    const parts = parseDottedSettingKey(key);
+    let current = target;
+    for (let i = 0; i < parts.length - 1; i++) {
+        current = descendForSettingWrite(current, parts[i], key);
+    }
+    current[parts[parts.length - 1]] = value;
+}
 /**
  * The fixed cwd used for "no-repo" pure-chat conversations (a chat not bound to
  * any code project). Same location as desktop's `resolveNoRepoCwd`
@@ -286,17 +325,7 @@ export class SettingsManager {
                 // Corrupt file — overwrite rather than crash.
             }
         }
-        const parts = key.split(".");
-        let target = current;
-        for (let i = 0; i < parts.length - 1; i++) {
-            const seg = parts[i];
-            const next = target[seg];
-            if (!next || typeof next !== "object" || Array.isArray(next)) {
-                target[seg] = {};
-            }
-            target = target[seg];
-        }
-        target[parts[parts.length - 1]] = value;
+        setDottedSetting(current, key, value);
         mkdirSync(dirname(path), { recursive: true });
         // Atomic write: stage to .tmp, then rename, so a concurrent read can't
         // catch a half-written file. mode 0o600 — settings.json can hold plaintext
@@ -323,17 +352,7 @@ export class SettingsManager {
         if (!existsSync(cwd))
             return;
         const current = this.readJsonObject(path);
-        const parts = key.split(".");
-        let target = current;
-        for (let i = 0; i < parts.length - 1; i++) {
-            const seg = parts[i];
-            const next = target[seg];
-            if (!next || typeof next !== "object" || Array.isArray(next)) {
-                target[seg] = {};
-            }
-            target = target[seg];
-        }
-        target[parts[parts.length - 1]] = value;
+        setDottedSetting(current, key, value);
         this.atomicWriteJson(path, current);
         this.invalidate();
     }
@@ -353,13 +372,13 @@ export class SettingsManager {
         if (!resolveConfigPath(path))
             return;
         const current = this.readJsonObject(path);
-        const parts = key.split(".");
+        const parts = parseDottedSettingKey(key);
         let target = current;
         for (let i = 0; i < parts.length - 1; i++) {
-            const next = target?.[parts[i]];
-            if (!next || typeof next !== "object" || Array.isArray(next))
+            const seg = parts[i];
+            if (!target || !isOwnPlainObject(target, seg))
                 return;
-            target = next;
+            target = target[seg];
         }
         if (target)
             delete target[parts[parts.length - 1]];

package/dist/settings/schema-export.d.ts

@@ -7,9 +7,8 @@
  *
  * This module is side-effect free: it only EXPOSES the generator and a writer.
  * `manager.load()` deliberately does NOT call these — emitting a file during
- * load would pollute test HOMEs and add disk I/O to every boot. A host that
- * wants the file on disk should call `writeSettingsSchemaFile()` explicitly
- * (wiring TBD — see the task return note).
+ * load would pollute test HOMEs and add disk I/O to every settings read. Hosts
+ * write it explicitly during startup as a best-effort editor aid.
  */
 /**
  * Generate the JSON Schema for the settings object. The `name` option makes

package/dist/settings/schema-export.js

@@ -7,9 +7,8 @@
  *
  * This module is side-effect free: it only EXPOSES the generator and a writer.
  * `manager.load()` deliberately does NOT call these — emitting a file during
- * load would pollute test HOMEs and add disk I/O to every boot. A host that
- * wants the file on disk should call `writeSettingsSchemaFile()` explicitly
- * (wiring TBD — see the task return note).
+ * load would pollute test HOMEs and add disk I/O to every settings read. Hosts
+ * write it explicitly during startup as a best-effort editor aid.
  */
 import { mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";

package/dist/tool-system/builtin/background-jobs.d.ts

@@ -40,6 +40,8 @@ export interface BackgroundJobEntry {
     ccSessionId?: string;
     /** Files the external agent changed (parsed from its transcript, #6). */
     changedFiles?: string[];
+    /** Working directory for jobs that operate on the filesystem, e.g. DriveAgent. */
+    cwd?: string;
 }
 /** Outcome passed to finish() to record how a job ended. */
 export interface BackgroundJobOutcome {
@@ -48,11 +50,14 @@ export interface BackgroundJobOutcome {
     ccSessionId?: string;
     changedFiles?: string[];
 }
+export interface BackgroundJobStartOptions {
+    cwd?: string;
+}
 declare class BackgroundJobRegistry {
     private jobs;
     private listeners;
     /** Register a running job. Invalid sessionId is ignored (cannot be waited on). */
-    start(jobId: string, sessionId: string, description?: string): void;
+    start(jobId: string, sessionId: string, description?: string, options?: BackgroundJobStartOptions): void;
     /** Mark a job terminal (retained, not deleted). Unknown id is a no-op (no
      *  notify) so a double-finish or a finish after reset stays quiet. */
     finish(jobId: string, outcome?: BackgroundJobOutcome): void;
@@ -60,6 +65,8 @@ declare class BackgroundJobRegistry {
     hasRunningForSession(sessionId: string): boolean;
     /** Running jobs spawned by `sessionId`. Feeds the goal judge's task list. */
     listRunningForSession(sessionId: string): BackgroundJobEntry[];
+    /** Running jobs, across all sessions, that are operating in the same cwd. */
+    listRunningByCwd(cwd: string): BackgroundJobEntry[];
     /** All jobs (running + retained terminal) for `sessionId`. Feeds the panel. */
     listForSession(sessionId: string): BackgroundJobEntry[];
     /** Drop every job of a session — called when the session is deleted/closed. */

package/dist/tool-system/builtin/background-jobs.js

@@ -20,6 +20,7 @@
  * loops run in the main engine process, so start/finish and the engine's wait
  * loop observe the same instance.
  */
+import { normalizeCwdPath } from "../../cc-orchestrator/cwd-normalize.js";
 function isValidSessionId(sid) {
     return typeof sid === "string" && sid.length > 0;
 }
@@ -30,7 +31,7 @@ class BackgroundJobRegistry {
     jobs = new Map(); // jobId -> entry (insertion-ordered)
     listeners = new Set();
     /** Register a running job. Invalid sessionId is ignored (cannot be waited on). */
-    start(jobId, sessionId, description = "") {
+    start(jobId, sessionId, description = "", options) {
         if (!isValidSessionId(sessionId))
             return;
         this.jobs.set(jobId, {
@@ -39,6 +40,7 @@ class BackgroundJobRegistry {
             description,
             status: "running",
             startedAt: Date.now(),
+            ...(options?.cwd ? { cwd: normalizeCwdPath(options.cwd) } : {}),
         });
         this.notify();
     }
@@ -71,6 +73,11 @@ class BackgroundJobRegistry {
     listRunningForSession(sessionId) {
         return [...this.jobs.values()].filter((e) => e.sessionId === sessionId && e.status === "running");
     }
+    /** Running jobs, across all sessions, that are operating in the same cwd. */
+    listRunningByCwd(cwd) {
+        const normalized = normalizeCwdPath(cwd);
+        return [...this.jobs.values()].filter((e) => e.status === "running" && e.cwd === normalized);
+    }
     /** All jobs (running + retained terminal) for `sessionId`. Feeds the panel. */
     listForSession(sessionId) {
         return [...this.jobs.values()].filter((e) => e.sessionId === sessionId);

package/dist/tool-system/builtin/config.d.ts

@@ -2,5 +2,6 @@
  * ConfigTool — read or update project settings.
  */
 import type { ToolDefinition } from "../../types.js";
+import type { ToolContext } from "../context.js";
 export declare const configToolDef: ToolDefinition;
-export declare function configTool(args: Record<string, unknown>): Promise<string>;
+export declare function configTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/config.js

@@ -3,6 +3,8 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { setDottedSetting } from "../../settings/manager.js";
+import { enforcePathPolicyWithApproval } from "../path-policy.js";
 export const configToolDef = {
     name: "Config",
     description: "Read or update the project's .code-shell/settings.json configuration. " +
@@ -26,11 +28,14 @@ export const configToolDef = {
         required: ["action"],
     },
 };
-export async function configTool(args) {
+export async function configTool(args, ctx) {
     const action = args.action;
-    const cwd = args.__cwd ?? process.cwd();
+    const cwd = ctx?.cwd ?? process.cwd();
     const configPath = join(cwd, ".code-shell", "settings.json");
     if (action === "read") {
+        const blocked = await enforcePathPolicyWithApproval(configPath, "read", ctx);
+        if (blocked)
+            return blocked;
         if (!existsSync(configPath)) {
             return "No project settings found. Use /init to create one.";
         }
@@ -38,6 +43,9 @@ export async function configTool(args) {
         return content;
     }
     if (action === "write") {
+        const blocked = await enforcePathPolicyWithApproval(configPath, "write", ctx);
+        if (blocked)
+            return blocked;
         const key = args.key;
         const value = args.value;
         if (!key)
@@ -49,16 +57,13 @@ export async function configTool(args) {
         if (existsSync(configPath)) {
             settings = JSON.parse(readFileSync(configPath, "utf-8"));
         }
-        // Set nested key
-        const parts = key.split(".");
-        let obj = settings;
-        for (let i = 0; i < parts.length - 1; i++) {
-            if (typeof obj[parts[i]] !== "object" || obj[parts[i]] === null) {
-                obj[parts[i]] = {};
-            }
-            obj = obj[parts[i]];
+        try {
+            setDottedSetting(settings, key, value);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return `Error: ${message}`;
         }
-        obj[parts[parts.length - 1]] = value;
         // Never resurrect a deleted project root: a recursive mkdir of
         // <cwd>/.code-shell would recreate `cwd` itself as an empty shell when the
         // directory has been deleted (e.g. a stale session pointing at a removed

package/dist/tool-system/builtin/drive-claude-code.d.ts

@@ -1,7 +1,10 @@
 import type { ToolDefinition } from "../../types.js";
 import type { AgentRunResult } from "../../cc-orchestrator/external-agent-driver.js";
 import type { ToolContext } from "../context.js";
+import { type ExternalAgentSessionBinding, type ExternalAgentSessionRecord } from "../../cc-orchestrator/external-agent-session-store.js";
 export type DriveCli = "claude" | "codex";
+export declare const DRIVE_AGENT_FOREGROUND_HANDOFF_MS = 110000;
+export declare const DRIVE_AGENT_TOOL_TIMEOUT_MS = 1800000;
 export declare const driveAgentToolDef: ToolDefinition;
 type PermMode = "default" | "acceptEdits" | "bypassPermissions";
 type Runner = (opts: {
@@ -10,10 +13,19 @@ type Runner = (opts: {
     resumeSessionId?: string;
     cwd: string;
     permissionMode?: PermMode;
+    signal?: AbortSignal;
 }) => Promise<AgentRunResult>;
+type SessionStore = {
+    get(cli: DriveCli, sessionId: string): ExternalAgentSessionBinding | undefined;
+    record(binding: ExternalAgentSessionRecord): void;
+};
+export interface DriveAgentToolOptions {
+    foregroundHandoffMs?: number;
+    sessionStore?: SessionStore;
+}
 /** Factory so tests can inject a fake runner. `fixedCli` (back-compat) forces a
  *  cli and hides the `cli` arg — that's how DriveClaudeCode stays a thin alias. */
-export declare function makeDriveAgentTool(runner?: Runner, fixedCli?: DriveCli): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export declare function makeDriveAgentTool(runner?: Runner, fixedCli?: DriveCli, options?: DriveAgentToolOptions): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
 export declare const driveAgentTool: (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
 export declare const driveClaudeCodeToolDef: ToolDefinition;
 /** Back-compat factory: a DriveAgent pinned to cli:"claude" with the `cli` arg
@@ -24,7 +36,8 @@ type LegacyRunner = (opts: {
     resumeSessionId?: string;
     cwd: string;
     permissionMode?: PermMode;
+    signal?: AbortSignal;
 }) => Promise<AgentRunResult>;
-export declare function makeDriveClaudeCodeTool(runner?: LegacyRunner): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export declare function makeDriveClaudeCodeTool(runner?: LegacyRunner, options?: DriveAgentToolOptions): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
 export declare const driveClaudeCodeTool: (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
 export {};