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

package/dist/cc-orchestrator/cwd-normalize.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeCwdPath(cwd: string): string;
+export declare function isExistingDirectory(cwd: string): boolean;

package/dist/cc-orchestrator/cwd-normalize.js

@@ -0,0 +1,19 @@
+import { realpathSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+export function normalizeCwdPath(cwd) {
+    const resolved = resolve(cwd);
+    try {
+        return realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export function isExistingDirectory(cwd) {
+    try {
+        return statSync(cwd).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cc-orchestrator/external-agent-bindings.d.ts

@@ -0,0 +1,27 @@
+export type ExternalAgentCli = "claude" | "codex";
+export interface ExternalAgentRunBinding {
+    cli: ExternalAgentCli;
+    externalSessionId: string;
+    codeShellSessionId: string;
+    cwd: string;
+    worktreePath?: string;
+    worktreeBranch?: string;
+    createdAt: number;
+    lastUsedAt: number;
+}
+export declare function externalAgentBindingsPath(home?: string): string;
+export declare class ExternalAgentBindingStore {
+    private readonly filePath?;
+    constructor(filePath?: string | undefined);
+    get(externalSessionId: string): ExternalAgentRunBinding | undefined;
+    upsert(next: Omit<ExternalAgentRunBinding, "createdAt" | "lastUsedAt">): ExternalAgentRunBinding;
+    private read;
+    private write;
+    private file;
+}
+export declare function detectExternalAgentWorktree(cwd: string): {
+    worktreePath?: string;
+    worktreeBranch?: string;
+};
+export declare function externalAgentResumeCwdError(binding: ExternalAgentRunBinding): string | undefined;
+export declare const externalAgentBindingStore: ExternalAgentBindingStore;

package/dist/cc-orchestrator/external-agent-bindings.js

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import { codeShellHome, SessionManager } from "../session/session-manager.js";
+export function externalAgentBindingsPath(home = codeShellHome()) {
+    return join(home, "external-agents", "bindings.json");
+}
+export class ExternalAgentBindingStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    get(externalSessionId) {
+        return this.read({ failOnCorrupt: true }).bindings[externalSessionId];
+    }
+    upsert(next) {
+        const data = this.read({ failOnCorrupt: false });
+        const existing = data.bindings[next.externalSessionId];
+        const now = Date.now();
+        const binding = {
+            ...next,
+            codeShellSessionId: next.codeShellSessionId || existing?.codeShellSessionId || "",
+            createdAt: existing?.createdAt ?? now,
+            lastUsedAt: now,
+        };
+        data.bindings[next.externalSessionId] = binding;
+        this.write(data);
+        return binding;
+    }
+    read(opts) {
+        const file = this.file();
+        if (!existsSync(file))
+            return { bindings: {} };
+        try {
+            const parsed = JSON.parse(readFileSync(file, "utf-8"));
+            if (parsed && typeof parsed.bindings === "object" && parsed.bindings) {
+                return { bindings: parsed.bindings };
+            }
+            if (opts.failOnCorrupt) {
+                throw new Error(`external agent bindings file is corrupt: expected object with bindings`);
+            }
+            return { bindings: {} };
+        }
+        catch (err) {
+            if (opts.failOnCorrupt) {
+                throw new Error(`external agent bindings file is corrupt or unreadable: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return { bindings: {} };
+        }
+    }
+    write(data) {
+        const file = this.file();
+        mkdirSync(dirname(file), { recursive: true });
+        const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+        renameSync(tmp, file);
+    }
+    file() {
+        return this.filePath ?? externalAgentBindingsPath();
+    }
+}
+export function detectExternalAgentWorktree(cwd) {
+    if (!existsSync(cwd))
+        return {};
+    try {
+        const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+        const branch = git(root, ["branch", "--show-current"]);
+        const entries = parseWorktreeList(git(root, ["worktree", "list", "--porcelain"]));
+        const current = entries.find((entry) => resolve(entry.path) === resolve(root));
+        const main = entries[0];
+        if (!current || !branch || !main || resolve(current.path) === resolve(main.path))
+            return {};
+        return { worktreePath: root, worktreeBranch: branch };
+    }
+    catch {
+        return {};
+    }
+}
+export function externalAgentResumeCwdError(binding) {
+    if (existsSync(binding.cwd))
+        return undefined;
+    const branch = binding.worktreeBranch;
+    if (branch && branchExistsForBinding(binding)) {
+        return (`Error: external ${binding.cli} session ${binding.externalSessionId} is bound to cwd ` +
+            `${binding.cwd}, but that directory no longer exists. Worktree branch ${branch} still ` +
+            `exists; recreate the worktree at ${binding.worktreePath ?? binding.cwd} before resuming.`);
+    }
+    return (`Error: external ${binding.cli} session ${binding.externalSessionId} is bound to cwd ` +
+        `${binding.cwd}, but the workspace deleted${branch ? ` and branch ${branch} is gone` : ""}. ` +
+        `Start a new external session.`);
+}
+function branchExistsForBinding(binding) {
+    if (!binding.worktreeBranch)
+        return false;
+    for (const cwd of candidateGitCwds(binding)) {
+        if (!cwd || !existsSync(cwd))
+            continue;
+        try {
+            const out = git(cwd, ["branch", "--list", binding.worktreeBranch]);
+            if (out.length > 0)
+                return true;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return false;
+}
+function candidateGitCwds(binding) {
+    const candidates = new Set();
+    if (existsSync(binding.cwd))
+        candidates.add(binding.cwd);
+    if (binding.codeShellSessionId) {
+        const sessionCwd = new SessionManager().readCwd(binding.codeShellSessionId);
+        if (sessionCwd)
+            candidates.add(sessionCwd);
+    }
+    candidates.add(process.cwd());
+    candidates.add(dirname(binding.cwd));
+    candidates.add(dirname(dirname(binding.cwd)));
+    return [...candidates];
+}
+function parseWorktreeList(raw) {
+    if (!raw.trim())
+        return [];
+    const entries = [];
+    let current = { path: "", branch: "" };
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            if (current.path)
+                entries.push(current);
+            current = { path: line.slice(9), branch: "" };
+        }
+        else if (line.startsWith("branch ")) {
+            current.branch = line.slice(7).replace("refs/heads/", "");
+        }
+    }
+    if (current.path)
+        entries.push(current);
+    return entries;
+}
+function git(cwd, args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf-8",
+        timeout: 10000,
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+export const externalAgentBindingStore = new ExternalAgentBindingStore();

package/dist/cc-orchestrator/external-agent-session-store.d.ts

@@ -0,0 +1,23 @@
+export type ExternalAgentCli = "claude" | "codex";
+export interface ExternalAgentSessionBinding {
+    cli: ExternalAgentCli;
+    sessionId: string;
+    cwd: string;
+    worktreePath?: string;
+    worktreeBranch?: string;
+    updatedAt: number;
+}
+export type ExternalAgentSessionRecord = Omit<ExternalAgentSessionBinding, "updatedAt"> & {
+    updatedAt?: number;
+};
+export declare function defaultExternalAgentSessionStorePath(): string;
+export declare class ExternalAgentSessionStore {
+    private readonly file;
+    constructor(file?: string);
+    get(cli: ExternalAgentCli, sessionId: string): ExternalAgentSessionBinding | undefined;
+    record(binding: ExternalAgentSessionRecord): void;
+    private load;
+    private save;
+    private withLock;
+}
+export declare const externalAgentSessionStore: ExternalAgentSessionStore;

package/dist/cc-orchestrator/external-agent-session-store.js

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { codeShellHome } from "../session/session-manager.js";
+import { logger } from "../logging/logger.js";
+import { normalizeCwdPath } from "./cwd-normalize.js";
+const LOCK_WAIT_MS = 5_000;
+const LOCK_STALE_MS = 30_000;
+const LOCK_POLL_MS = 10;
+export function defaultExternalAgentSessionStorePath() {
+    return join(codeShellHome(), "external-agent-sessions.json");
+}
+export class ExternalAgentSessionStore {
+    file;
+    constructor(file = defaultExternalAgentSessionStorePath()) {
+        this.file = file;
+    }
+    get(cli, sessionId) {
+        if (!sessionId)
+            return undefined;
+        return this.load().find((s) => s.cli === cli && s.sessionId === sessionId);
+    }
+    record(binding) {
+        if (!binding.sessionId || !binding.cwd)
+            return;
+        const next = {
+            cli: binding.cli,
+            sessionId: binding.sessionId,
+            cwd: normalizeCwdPath(binding.cwd),
+            ...(binding.worktreePath ? { worktreePath: binding.worktreePath } : {}),
+            ...(binding.worktreeBranch ? { worktreeBranch: binding.worktreeBranch } : {}),
+            updatedAt: binding.updatedAt ?? Date.now(),
+        };
+        this.withLock(() => {
+            const sessions = this.load().filter((s) => !(s.cli === binding.cli && s.sessionId === binding.sessionId));
+            sessions.push(next);
+            this.save(sessions);
+        });
+    }
+    load() {
+        if (!existsSync(this.file))
+            return [];
+        try {
+            const raw = readFileSync(this.file, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!parsed || !Array.isArray(parsed.sessions))
+                return [];
+            return parsed.sessions.filter(isBinding).map(normalizeBinding);
+        }
+        catch (err) {
+            logger.warn("external_agent_session_store.load_failed", {
+                cat: "cc",
+                file: this.file,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return [];
+        }
+    }
+    save(sessions) {
+        const dir = dirname(this.file);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const snapshot = { version: 1, sessions };
+        const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+        try {
+            writeFileSync(tmp, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+            renameSync(tmp, this.file);
+        }
+        catch (err) {
+            rmSync(tmp, { force: true });
+            throw err;
+        }
+    }
+    withLock(fn) {
+        const dir = dirname(this.file);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        // TODO: move this sync polling lock to an async write queue; callers can
+        // otherwise block the event loop for up to LOCK_WAIT_MS under contention.
+        const lockDir = `${this.file}.lock`;
+        const deadline = Date.now() + LOCK_WAIT_MS;
+        while (true) {
+            try {
+                mkdirSync(lockDir);
+                break;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== "EEXIST")
+                    throw err;
+                if (removeStaleLock(lockDir))
+                    continue;
+                if (Date.now() >= deadline) {
+                    throw new Error(`timed out waiting for external agent session store lock: ${lockDir}`);
+                }
+                sleepSync(LOCK_POLL_MS);
+            }
+        }
+        try {
+            return fn();
+        }
+        finally {
+            rmSync(lockDir, { recursive: true, force: true });
+        }
+    }
+}
+function normalizeBinding(binding) {
+    return { ...binding, cwd: normalizeCwdPath(binding.cwd) };
+}
+function removeStaleLock(lockDir) {
+    try {
+        if (Date.now() - statSync(lockDir).mtimeMs <= LOCK_STALE_MS)
+            return false;
+        rmSync(lockDir, { recursive: true, force: true });
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return true;
+        return false;
+    }
+}
+function sleepSync(ms) {
+    try {
+        const view = new Int32Array(new SharedArrayBuffer(4));
+        Atomics.wait(view, 0, 0, ms);
+    }
+    catch {
+        const until = Date.now() + ms;
+        while (Date.now() < until) {
+            // fallback for runtimes where Atomics.wait is unavailable
+        }
+    }
+}
+function isBinding(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    return ((v.cli === "claude" || v.cli === "codex") &&
+        typeof v.sessionId === "string" &&
+        v.sessionId.length > 0 &&
+        typeof v.cwd === "string" &&
+        v.cwd.length > 0);
+}
+export const externalAgentSessionStore = new ExternalAgentSessionStore();

package/dist/context/manager.d.ts

@@ -48,6 +48,8 @@ export declare class ContextManager {
     private lastActualTokens;
     /** Message count at the time lastActualTokens was recorded. */
     private lastActualAtMessageCount;
+    /** Heuristic token estimate for the same messages as lastActualTokens. */
+    private lastActualAnchorEstimate;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     private transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -65,7 +67,7 @@ export declare class ContextManager {
      * Record actual token usage from API response.
      * Used for hybrid estimation: actual + estimate for new messages.
      */
-    recordActualUsage(inputTokens: number, messageCount: number): void;
+    recordActualUsage(inputTokens: number, messageCount: number, messages?: Message[]): void;
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.

package/dist/context/manager.js

@@ -48,6 +48,8 @@ export class ContextManager {
     lastActualTokens;
     /** Message count at the time lastActualTokens was recorded. */
     lastActualAtMessageCount;
+    /** Heuristic token estimate for the same messages as lastActualTokens. */
+    lastActualAnchorEstimate;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -69,23 +71,29 @@ export class ContextManager {
      * Record actual token usage from API response.
      * Used for hybrid estimation: actual + estimate for new messages.
      */
-    recordActualUsage(inputTokens, messageCount) {
+    recordActualUsage(inputTokens, messageCount, messages) {
         this.lastActualTokens = inputTokens;
         this.lastActualAtMessageCount = messageCount;
+        this.lastActualAnchorEstimate = messages ? estimateTokens(messages) : undefined;
     }
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.
      */
     estimateTokensHybrid(messages) {
+        const currentEstimate = estimateTokens(messages);
         if (this.lastActualTokens !== undefined &&
-            this.lastActualAtMessageCount !== undefined &&
-            this.lastActualAtMessageCount < messages.length) {
-            const newMessages = messages.slice(this.lastActualAtMessageCount);
-            const newTokens = estimateTokens(newMessages);
-            return this.lastActualTokens + newTokens;
+            this.lastActualAtMessageCount !== undefined) {
+            if (this.lastActualAtMessageCount < messages.length) {
+                const newMessages = messages.slice(this.lastActualAtMessageCount);
+                const newTokens = estimateTokens(newMessages);
+                return this.lastActualTokens + newTokens;
+            }
+            if (this.lastActualAnchorEstimate !== undefined && this.lastActualAnchorEstimate > 0) {
+                return Math.round(this.lastActualTokens * (currentEstimate / this.lastActualAnchorEstimate));
+            }
         }
-        return estimateTokens(messages);
+        return currentEstimate;
     }
     /**
      * Set the summarize function (injected by Engine).
@@ -119,7 +127,7 @@ export class ContextManager {
                 return { messages, tokens: before, compacted: false, noProgress: true };
             }
             const compacted = applySummaryCompaction(messages, summary, keepRecentN, this.transcriptPath);
-            const after = estimateTokens(compacted);
+            const after = this.estimateTokensHybrid(compacted);
             if (after >= before) {
                 this.consecutiveSummaryFailures++;
                 logger.warn("context.summary_no_progress", {
@@ -342,6 +350,9 @@ export class ContextManager {
             ratio >= this.config.microcompactFloorRatio &&
             ratio < this.config.compactAtRatio;
         const shouldEscalateNoOpMicro = noOpMicroSpinBand && !this.suppressNoOpMicroSummaryUntilCompact;
+        const snipGate = this.config.maxTokens * this.config.compactAtRatio;
+        const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
+        const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
         // Tier 2: LLM summary if approaching limit, or if micro was the only tier
         // available in the 0.70-0.85 band and it freed nothing.
         if (ratio >= this.config.compactAtRatio || shouldEscalateNoOpMicro) {
@@ -350,7 +361,8 @@ export class ContextManager {
             tokens = summarized.tokens;
             if (summarized.compacted) {
                 this.suppressNoOpMicroSummaryUntilCompact = false;
-                return result;
+                if (tokens <= snipGate)
+                    return result;
             }
             if (shouldEscalateNoOpMicro && summarized.noProgress) {
                 this.suppressNoOpMicroSummaryUntilCompact = true;
@@ -362,13 +374,10 @@ export class ContextManager {
                 });
             }
         }
-        // Reuse the `tokens` we already computed above. We only get here if no
-        // summary compacted the prompt (no summarizeFn, too many failures, a
-        // thrown error, or a generated summary that did not shrink anything).
+        // Reuse the `tokens` we already computed above. We get here if no summary
+        // compacted the prompt, or if summary helped but the hybrid estimate is
+        // still above the fallback gate.
         let live = tokens;
-        const snipGate = this.config.maxTokens * this.config.compactAtRatio;
-        const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
-        const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
         // Tier 2 fallback: snip first (cheapest sync option)
         if (live > snipGate) {
             const before = live;

package/dist/credentials/types.d.ts

@@ -39,8 +39,8 @@ export interface Credential {
     /**
      * link: 业务方 app 注册地址;cookie: 拓取所用平台与主域 + 抓取范围 + 切换策略。
      * - scope="all" 表示该 jar 是整分区全量抓的(切换时整包导回);缺省/"domain" = 仅该域。
-     * - switchMode 决定「切换」时怎么写回浏览器:"clear"(默认)先清空整分区再注入(干净换号);
-     *   "merge" 只覆盖同名 cookie、保留分区里其他站(不踢掉别的登录态)。
+     * - switchMode 决定「切换」时怎么写回浏览器:"merge"(默认)只覆盖同名 cookie、保留
+     *   分区里其他站(不踢掉别的登录态);"clear" 先清空整分区再注入(干净换号,需显式选)。
      */
     meta?: {
         appUrl?: string;

package/dist/engine/engine.d.ts

@@ -12,6 +12,7 @@ import type { AskUserFn } from "../tool-system/builtin/ask-user.js";
 import type { CapabilityOverride } from "../settings/schema.js";
 import { type FeatureFlagName } from "../settings/feature-flags.js";
 import type { ToolContext } from "../tool-system/context.js";
+import { type SandboxBackend } from "../tool-system/sandbox/index.js";
 import { ModelPool, type ModelEntry } from "../llm/model-pool.js";
 import { AgentDefinitionRegistry } from "../agent/agent-definition-registry.js";
 import { EngineRuntime } from "./runtime.js";
@@ -53,7 +54,7 @@ export declare function resolveChildLlm(modelKey: string | undefined, pool: Mode
  * Names in `disabledAgents` are filtered out so the LLM never sees them.
  */
 /**
- * Resolve the working directory for a run. Precedence:
+ * Resolve the working directory for a run. Precedence for legacy sessions:
  *   options.cwd  >  resumed session's state.cwd  >  config.cwd  >  process.cwd()
  *
  * The session-cwd tier is what stops a project-bound session from being
@@ -570,6 +571,7 @@ export declare class Engine {
      * by tests that want a ToolContext without a full run() cycle.
      */
     private resolveSandboxWithoutRuntime;
+    private resolveSandboxConfigForCwd;
     /**
      * Build the shell env layered onto the Bash tool / background shells (see
      * mergeShellEnv). Three user-configured sources, merged lowest → highest:
@@ -622,6 +624,8 @@ export declare class Engine {
         linux?: string;
         windows?: string;
     } | undefined;
+    resolveWorktreeSetupSandbox(cwd: string): Promise<SandboxBackend | undefined>;
+    readWorktreeSetupShellEnv(cwd?: string): Record<string, string> | undefined;
     buildToolContext(): ToolContext;
     /**
      * Read settings.disabledSkills + settings.disabledPlugins in a single