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

package/dist/git/worktree/git-exec.js

@@ -0,0 +1,51 @@
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveExecutable } from "../../utils/exec.js";
+// git resolved via PATH×PATHEXT on Windows (.cmd/.exe shim); no-op on POSIX.
+export const GIT_BIN = resolveExecutable("git");
+const execFileAsync = promisify(execFile);
+export async function execGit(cwd, args, timeout = 10000) {
+    const { stdout } = await execFileAsync(GIT_BIN, args, {
+        cwd,
+        encoding: "utf-8",
+        timeout,
+    });
+    return stdout;
+}
+export function execGitSync(cwd, args, timeout = 10000) {
+    return execFileSync(GIT_BIN, args, {
+        cwd,
+        encoding: "utf-8",
+        timeout,
+    });
+}
+export async function gitOutput(cwd, args, timeout = 10000) {
+    try {
+        return await execGit(cwd, args, timeout);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function gitOutputSync(cwd, args, timeout = 10000) {
+    try {
+        return execGitSync(cwd, args, timeout);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function gitErrorMessage(err) {
+    const stderr = err.stderr;
+    if (Buffer.isBuffer(stderr)) {
+        const msg = stderr.toString("utf-8").trim();
+        if (msg)
+            return msg;
+    }
+    if (typeof stderr === "string" && stderr.trim())
+        return stderr.trim();
+    return err instanceof Error ? err.message : String(err);
+}
+export function normalizeBranchName(branch) {
+    return branch.replace(/^refs\/heads\//, "");
+}

package/dist/git/worktree/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./git-exec.js";
+export * from "./slug.js";
+export * from "./diff.js";
+export * from "./query.js";
+export * from "./crud.js";

package/dist/git/worktree/index.js

@@ -0,0 +1,5 @@
+export * from "./git-exec.js";
+export * from "./slug.js";
+export * from "./diff.js";
+export * from "./query.js";
+export * from "./crud.js";

package/dist/git/worktree/query.d.ts

@@ -0,0 +1,42 @@
+import type { SessionWorkspace } from "../../types.js";
+import { type WorktreeDiffSummary } from "./diff.js";
+export interface WorktreeWorkspaceOwner {
+    sessionId: string;
+    workspace?: SessionWorkspace;
+}
+export interface ListWorktreesFastOptions {
+    currentSessionId?: string;
+    workspaceOwners?: WorktreeWorkspaceOwner[];
+    owners?: WorktreeWorkspaceOwner[];
+    prefix?: string;
+}
+export interface ListWorktreesOptions extends ListWorktreesFastOptions {
+    includeDiffSummary?: boolean;
+}
+export interface WorktreeInfo {
+    path: string;
+    branch: string;
+    head: string;
+    isMain?: boolean;
+    isManaged?: boolean;
+    diff?: WorktreeDiffSummary;
+    occupiedBySessionIds?: string[];
+    occupiedByOtherSession?: boolean;
+}
+/**
+ * Find the canonical git root (resolves worktree -> main repo).
+ */
+export declare function findGitRoot(cwd: string): Promise<string>;
+export declare function findMainWorktreeRoot(cwd: string): Promise<string>;
+export declare function findWorktreeForBranch(cwd: string, branch: string): Promise<string | undefined>;
+export declare function assertBranchNotCheckedOut(cwd: string, branch: string): Promise<void>;
+export declare function branchExists(cwd: string, branch: string): Promise<boolean>;
+export declare function isGitWorktreeRoot(cwd: string): Promise<boolean>;
+export declare function currentBranch(cwd: string): Promise<string | undefined>;
+export declare function listWorktreesFast(cwd: string, opts?: ListWorktreesFastOptions): Promise<WorktreeInfo[]>;
+/**
+ * List active worktrees. Kept for internal/test compatibility; use
+ * listWorktreesFast for UI lists that should not block on diff work.
+ */
+export declare function listWorktrees(cwd: string, opts?: ListWorktreesOptions): Promise<WorktreeInfo[]>;
+export declare function ownersForWorktree(path: string, owners: WorktreeWorkspaceOwner[]): string[];

package/dist/git/worktree/query.js

@@ -0,0 +1,121 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { getWorktreeDiff } from "./diff.js";
+import { execGit, gitOutput, normalizeBranchName } from "./git-exec.js";
+import { isManagedWorktreeBranch } from "./slug.js";
+/**
+ * Find the canonical git root (resolves worktree -> main repo).
+ */
+export async function findGitRoot(cwd) {
+    return await findMainWorktreeRoot(cwd);
+}
+export async function findMainWorktreeRoot(cwd) {
+    const commonDir = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"], 5000)).trim();
+    return dirname(commonDir);
+}
+export async function findWorktreeForBranch(cwd, branch) {
+    const normalized = normalizeBranchName(branch);
+    return (await listWorktreesFast(cwd)).find((entry) => entry.branch === normalized)?.path;
+}
+export async function assertBranchNotCheckedOut(cwd, branch) {
+    const existingPath = await findWorktreeForBranch(cwd, branch);
+    if (existingPath) {
+        throw new Error(`branch ${normalizeBranchName(branch)} already checked out at ${existingPath}`);
+    }
+}
+export async function branchExists(cwd, branch) {
+    const out = await gitOutput(cwd, ["branch", "--list", normalizeBranchName(branch)], 10000);
+    return (out?.trim().length ?? 0) > 0;
+}
+export async function isGitWorktreeRoot(cwd) {
+    if (!existsSync(join(cwd, ".git")))
+        return false;
+    try {
+        const inside = (await execGit(cwd, ["rev-parse", "--is-inside-work-tree"], 5000)).trim();
+        if (inside !== "true")
+            return false;
+        const topLevel = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel"], 5000)).trim();
+        return resolve(topLevel) === resolve(cwd);
+    }
+    catch {
+        return false;
+    }
+}
+export async function currentBranch(cwd) {
+    const branch = (await gitOutput(cwd, ["branch", "--show-current"], 5000))?.trim();
+    return branch || undefined;
+}
+export async function listWorktreesFast(cwd, opts = {}) {
+    let raw;
+    try {
+        raw = (await execGit(cwd, ["worktree", "list", "--porcelain"], 10000)).trim();
+    }
+    catch {
+        return [];
+    }
+    if (!raw)
+        return [];
+    const entries = [];
+    let current = { path: "", branch: "", head: "" };
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            if (current.path)
+                entries.push(current);
+            current = { path: line.slice(9), branch: "", head: "" };
+        }
+        else if (line.startsWith("HEAD ")) {
+            current.head = line.slice(5, 13);
+        }
+        else if (line.startsWith("branch ")) {
+            current.branch = normalizeBranchName(line.slice(7));
+        }
+    }
+    if (current.path)
+        entries.push(current);
+    let mainRoot = "";
+    try {
+        mainRoot = await findMainWorktreeRoot(cwd);
+    }
+    catch {
+        mainRoot = entries[0]?.path ?? "";
+    }
+    const owners = opts.workspaceOwners ?? opts.owners ?? [];
+    return entries.map((entry) => {
+        const ownerIds = ownersForWorktree(entry.path, owners);
+        return {
+            ...entry,
+            ...(mainRoot ? { isMain: resolve(entry.path) === resolve(mainRoot) } : {}),
+            isManaged: Boolean(entry.branch) && isManagedWorktreeBranch(entry.branch, opts.prefix),
+            ...(ownerIds.length > 0
+                ? {
+                    occupiedBySessionIds: ownerIds,
+                    occupiedByOtherSession: ownerIds.some((id) => id !== opts.currentSessionId),
+                }
+                : {}),
+        };
+    });
+}
+/**
+ * List active worktrees. Kept for internal/test compatibility; use
+ * listWorktreesFast for UI lists that should not block on diff work.
+ */
+export async function listWorktrees(cwd, opts = {}) {
+    const entries = await listWorktreesFast(cwd, opts);
+    if (!opts.includeDiffSummary)
+        return entries;
+    return Promise.all(entries.map(async (entry) => ({
+        ...entry,
+        diff: await getWorktreeDiff(entry.path),
+    })));
+}
+export function ownersForWorktree(path, owners) {
+    const target = resolve(path);
+    return owners
+        .filter((owner) => {
+        const workspace = owner.workspace;
+        if (!workspace)
+            return false;
+        return resolve(workspace.root) === target;
+    })
+        .map((owner) => owner.sessionId);
+}

package/dist/git/worktree/slug.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_WORKTREE_BRANCH_PREFIX = "worktree/";
+export declare const HISTORICAL_WORKTREE_BRANCH_PREFIX = "worktree/";
+/**
+ * Validate worktree slug to prevent path traversal attacks.
+ */
+export declare function validateWorktreeSlug(slug: string): void;
+export declare function normalizeWorktreeBranchPrefix(prefix?: string | undefined): string;
+export declare function isValidWorktreeBranchPrefix(prefix: string): boolean;
+export declare function applyPrefix(prefix: string | undefined, slug: string, sessionId: string): string;
+export declare function managedBranchPrefixes(prefix?: string): string[];
+export declare function isManagedWorktreeBranch(branch: string, prefix?: string): boolean;

package/dist/git/worktree/slug.js

@@ -0,0 +1,58 @@
+export const DEFAULT_WORKTREE_BRANCH_PREFIX = "worktree/";
+export const HISTORICAL_WORKTREE_BRANCH_PREFIX = "worktree/";
+/**
+ * Validate worktree slug to prevent path traversal attacks.
+ */
+export function validateWorktreeSlug(slug) {
+    if (slug.trim().length === 0)
+        throw new Error("Worktree slug cannot be empty");
+    if (slug.length > 64)
+        throw new Error("Worktree slug too long (max 64 chars)");
+    if (/[^a-zA-Z0-9._-]/.test(slug))
+        throw new Error("Worktree slug contains invalid characters");
+    if (slug.startsWith(".") || slug.includes(".."))
+        throw new Error("Worktree slug cannot start with '.' or contain '..'");
+}
+export function normalizeWorktreeBranchPrefix(prefix = DEFAULT_WORKTREE_BRANCH_PREFIX) {
+    const raw = (prefix ?? DEFAULT_WORKTREE_BRANCH_PREFIX).trim();
+    if (!isValidWorktreeBranchPrefix(raw)) {
+        throw new Error(`Invalid worktree branch prefix: ${prefix ?? ""}`);
+    }
+    return raw.endsWith("/") ? raw : `${raw}/`;
+}
+export function isValidWorktreeBranchPrefix(prefix) {
+    const raw = prefix.trim();
+    if (!raw)
+        return false;
+    if (raw.startsWith("/") || raw.includes("//"))
+        return false;
+    if (raw.includes("..") || raw.includes("@{"))
+        return false;
+    if (/[\x00-\x20~^:?*[\]\\]/.test(raw))
+        return false;
+    const withoutTrailingSlash = raw.endsWith("/") ? raw.slice(0, -1) : raw;
+    if (!withoutTrailingSlash)
+        return false;
+    return withoutTrailingSlash.split("/").every((part) => {
+        if (!part)
+            return false;
+        if (part.startsWith(".") || part.endsWith("."))
+            return false;
+        if (part.endsWith(".lock"))
+            return false;
+        return true;
+    });
+}
+export function applyPrefix(prefix, slug, sessionId) {
+    validateWorktreeSlug(slug);
+    return `${normalizeWorktreeBranchPrefix(prefix)}${slug}-${sessionId.slice(0, 8)}`;
+}
+export function managedBranchPrefixes(prefix) {
+    const configured = normalizeWorktreeBranchPrefix(prefix);
+    return configured === HISTORICAL_WORKTREE_BRANCH_PREFIX
+        ? [configured]
+        : [configured, HISTORICAL_WORKTREE_BRANCH_PREFIX];
+}
+export function isManagedWorktreeBranch(branch, prefix) {
+    return managedBranchPrefixes(prefix).some((candidate) => branch.startsWith(candidate));
+}

package/dist/git/worktree.d.ts

@@ -1,127 +1 @@
-/**
- * Git worktree management — create/remove isolated worktrees for agents.
- */
-import type { SandboxBackend } from "../tool-system/sandbox/index.js";
-import type { SessionWorkspace } from "../types.js";
-export interface WorktreeSession {
-    originalCwd: string;
-    worktreePath: string;
-    worktreeName: string;
-    worktreeBranch: string;
-    originalBranch?: string;
-    sessionId: string;
-    createdAt: number;
-}
-/** Per-platform setup/cleanup scripts (a project's localEnvironment). */
-export interface PlatformScripts {
-    default?: string;
-    macos?: string;
-    linux?: string;
-    windows?: string;
-}
-/**
- * Pick the setup/cleanup script for the running platform, falling back to
- * `default`. Empty/whitespace-only scripts are treated as absent so a project
- * can leave a platform key blank without spawning an empty shell. `platform`
- * defaults to `process.platform` so callers usually omit it; tests pass a
- * fixed value.
- */
-export declare function selectPlatformScript(scripts: PlatformScripts | undefined, platform?: NodeJS.Platform): string | undefined;
-/**
- * Validate worktree slug to prevent path traversal attacks.
- */
-export declare function validateWorktreeSlug(slug: string): void;
-/**
- * Find the canonical git root (resolves worktree → main repo).
- */
-export declare function findGitRoot(cwd: string): string;
-export declare function findMainWorktreeRoot(cwd: string): string;
-export declare function findWorktreeForBranch(cwd: string, branch: string): string | undefined;
-export declare function assertBranchNotCheckedOut(cwd: string, branch: string): void;
-export declare function branchExists(cwd: string, branch: string): boolean;
-export declare function isGitWorktreeRoot(cwd: string): boolean;
-export declare function currentBranch(cwd: string): string | undefined;
-/**
- * Create an isolated git worktree for an agent session.
- */
-export declare function createWorktree(cwd: string, slug: string, sessionId: string): WorktreeSession;
-export interface WorktreeSetupResult {
-    /** True if no setup script was configured for this platform (nothing ran). */
-    skipped: boolean;
-    /** True if a script ran and exited 0. */
-    ok: boolean;
-    /** Combined stdout/stderr, for surfacing to the user on failure. */
-    output: string;
-    /** Exit code when a script ran; undefined when skipped. */
-    exitCode?: number | null;
-}
-/**
- * Run a project's `localEnvironment.setupScripts` once, in the freshly-created
- * worktree's root, right after `git worktree add`. This mirrors Codex's
- * local-environment semantics: setup belongs to the *worktree* lifecycle, not
- * the conversation — it runs when the isolated copy is born so e.g. `bun
- * install` or `cp .env.example .env` happens before the agent works there.
- *
- * Failure is non-fatal by design (Beta decision 2026-06-08, "警告但继续"): a
- * broken setup script shouldn't strand the agent outside a worktree it already
- * created. The caller surfaces `output` as a warning and proceeds. cleanup
- * scripts are intentionally NOT auto-run on exit (same decision).
- *
- * Reuses the same sandbox + env primitives as the Bash tool so the setup
- * command sees the project's `localEnvironment.env` and runs under the same
- * isolation the agent's later commands will.
- */
-export declare function runWorktreeSetup(worktreePath: string, script: string | undefined, opts?: {
-    sandbox?: SandboxBackend;
-    shellEnv?: Record<string, string>;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}): Promise<WorktreeSetupResult>;
-export interface RemoveWorktreeResult {
-    /** True once `git worktree remove` completed and the directory is gone. */
-    dirRemoved: boolean;
-    /** The branch targeted for deletion when removeBranch=true. */
-    branch?: string;
-    /** True when removeBranch=true and branch deletion completed. */
-    branchDeleted?: boolean;
-    /** Non-empty when the worktree directory is gone but branch deletion failed. */
-    branchError?: string;
-}
-/**
- * Remove a worktree and optionally its branch.
- */
-export declare function removeWorktree(worktreePath: string, removeBranch?: boolean): RemoveWorktreeResult;
-export declare function worktreeHasUncommittedChanges(worktreePath: string): boolean;
-export declare function worktreeHasUncommittedOrAheadChanges(worktreePath: string, baseRef?: string): boolean;
-export interface WorktreeDiffSummary {
-    /** Best-effort base used for the branch comparison, usually main/master. */
-    baseRef?: string;
-    /** Unique files changed either by commits ahead of base or by uncommitted changes. */
-    changedFiles: number;
-    /** Commits reachable from HEAD but not from baseRef. */
-    aheadCommits: number;
-    /** True when `git status --porcelain` reports local changes. */
-    hasUncommittedChanges: boolean;
-}
-export interface WorktreeWorkspaceOwner {
-    sessionId: string;
-    workspace?: SessionWorkspace;
-}
-export interface ListWorktreesOptions {
-    includeDiffSummary?: boolean;
-    currentSessionId?: string;
-    workspaceOwners?: WorktreeWorkspaceOwner[];
-}
-export interface WorktreeInfo {
-    path: string;
-    branch: string;
-    head: string;
-    isMain?: boolean;
-    diff?: WorktreeDiffSummary;
-    occupiedBySessionIds?: string[];
-    occupiedByOtherSession?: boolean;
-}
-/**
- * List active worktrees.
- */
-export declare function listWorktrees(cwd: string, opts?: ListWorktreesOptions): WorktreeInfo[];
+export * from "./worktree/index.js";