@sayknow-cli/coding-agent 0.5.1 → 0.5.6

package/src/skc-runtime/launch-worktree.ts

@@ -19,6 +19,9 @@ export interface SkcLaunchWorktreePlan {
 	detached: boolean;
 	baseRef: string;
 	branchName: string | null;
+	sourceCheckoutRoot: string;
+	relativeCwd: string;
+	relativeDependencyRoot: string | null;
 }
 
 export interface SkcLaunchWorktreeResult extends SkcLaunchWorktreePlan {
@@ -207,11 +210,49 @@ export function parseLaunchWorktreeMode(args: string[]): ParsedLaunchWorktreeMod
 	return { mode, remainingArgs };
 }
 
+function repoRelativePath(checkoutRoot: string, targetPath: string): string {
+	const relative = path.relative(checkoutRoot, targetPath);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+		throw new Error(`worktree_cwd_outside_checkout:${targetPath}`);
+	}
+	return relative;
+}
+
+function hasPackageLockMetadata(directory: string): boolean {
+	return (
+		fs.existsSync(path.join(directory, "bun.lock")) ||
+		fs.existsSync(path.join(directory, "bun.lockb")) ||
+		fs.existsSync(path.join(directory, "pnpm-lock.yaml")) ||
+		fs.existsSync(path.join(directory, "pnpm-workspace.yaml")) ||
+		fs.existsSync(path.join(directory, "package-lock.json")) ||
+		fs.existsSync(path.join(directory, "npm-shrinkwrap.json"))
+	);
+}
+
+function resolveSourceDependencyRoot(checkoutRoot: string, cwd: string): string | null {
+	let current = path.resolve(cwd);
+	let nearestPackageRoot: string | null = null;
+	while (true) {
+		if (!nearestPackageRoot && fs.existsSync(path.join(current, "package.json"))) nearestPackageRoot = current;
+		if (hasPackageLockMetadata(current)) return current;
+		if (current === checkoutRoot) return nearestPackageRoot;
+		const parent = path.dirname(current);
+		if (parent === current) return nearestPackageRoot;
+		current = parent;
+	}
+}
+
 export function planLaunchWorktree(
 	cwd: string,
 	mode: SkcLaunchWorktreeMode,
 ): SkcLaunchWorktreePlan | { enabled: false } {
 	if (!mode.enabled) return { enabled: false };
+	const sourceCheckoutRoot = fs.realpathSync.native(path.resolve(runGit(cwd, ["rev-parse", "--show-toplevel"])));
+	const sourceCwd = fs.realpathSync.native(path.resolve(cwd));
+	const relativeCwd = repoRelativePath(sourceCheckoutRoot, sourceCwd);
+	const sourceDependencyRoot = resolveSourceDependencyRoot(sourceCheckoutRoot, sourceCwd);
+	const relativeDependencyRoot =
+		sourceDependencyRoot === null ? null : repoRelativePath(sourceCheckoutRoot, sourceDependencyRoot);
 	const repoRoot = resolveCanonicalRepoRoot(cwd);
 	const baseRef = runGit(repoRoot, ["rev-parse", "HEAD"]);
 	const branchName = mode.detached ? null : mode.name;
@@ -219,7 +260,17 @@ export function planLaunchWorktree(
 	const bucket = `${path.basename(repoRoot)}.sayknow-cli-worktrees`;
 	const worktreeSlug = mode.detached ? resolveSourceBranchSlug(repoRoot, baseRef) : sanitizePathToken(mode.name);
 	const worktreePath = path.join(path.dirname(repoRoot), bucket, worktreeSlug);
-	return { enabled: true, repoRoot, worktreePath, detached: mode.detached, baseRef, branchName };
+	return {
+		enabled: true,
+		repoRoot,
+		worktreePath,
+		detached: mode.detached,
+		baseRef,
+		branchName,
+		sourceCheckoutRoot,
+		relativeCwd,
+		relativeDependencyRoot,
+	};
 }
 
 export function ensureLaunchWorktree(
@@ -290,8 +341,216 @@ export function ensureLaunchWorktree(
 	};
 }
 
-export function ensureReusableNodeModules(sourceRoot: string, worktreePath: string): "symlink" | "present" | "missing" {
+interface WorktreePackageManifest {
+	packageManager?: unknown;
+}
+
+type WorktreePackageManager = "bun" | "npm" | "pnpm";
+
+interface ResolvedWorktreePackageManager {
+	name: WorktreePackageManager;
+	version: string | null;
+}
+
+interface WorktreeDependencyProbes {
+	isExecutableAvailable?: (name: Exclude<WorktreePackageManager, "bun">) => boolean;
+	version?: (name: WorktreePackageManager) => string;
+	spawnInstall?: (command: readonly string[], cwd: string) => { exitCode: number; stderr: string };
+}
+
+function fileSystemErrorCode(error: unknown): string | undefined {
+	return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+		? error.code
+		: undefined;
+}
+
+function readWorktreePackageManifest(worktreePath: string): WorktreePackageManifest | null {
+	try {
+		return JSON.parse(fs.readFileSync(path.join(worktreePath, "package.json"), "utf8")) as WorktreePackageManifest;
+	} catch (error) {
+		if (fileSystemErrorCode(error) === "ENOENT") return null;
+		throw error;
+	}
+}
+
+function hasWorktreePackageMetadata(worktreePath: string, manifest: WorktreePackageManifest | null): boolean {
+	return (
+		manifest !== null ||
+		fs.existsSync(path.join(worktreePath, "bun.lock")) ||
+		fs.existsSync(path.join(worktreePath, "bun.lockb")) ||
+		fs.existsSync(path.join(worktreePath, "pnpm-lock.yaml")) ||
+		fs.existsSync(path.join(worktreePath, "pnpm-workspace.yaml")) ||
+		fs.existsSync(path.join(worktreePath, "package-lock.json")) ||
+		fs.existsSync(path.join(worktreePath, "npm-shrinkwrap.json"))
+	);
+}
+
+function declaredPackageManager(
+	manifest: WorktreePackageManifest | null,
+): { name: string; version: string | null } | null {
+	if (typeof manifest?.packageManager !== "string") return null;
+	const separator = manifest.packageManager.indexOf("@");
+	const name = (separator < 0 ? manifest.packageManager : manifest.packageManager.slice(0, separator)).trim();
+	if (!name) return null;
+	const version = separator < 0 ? null : manifest.packageManager.slice(separator + 1).trim() || null;
+	return { name, version };
+}
+
+function worktreeLockfiles(worktreePath: string): Array<{ manager: WorktreePackageManager; file: string }> {
+	const candidates: Array<{ manager: WorktreePackageManager; file: string }> = [
+		{ manager: "bun", file: "bun.lock" },
+		{ manager: "bun", file: "bun.lockb" },
+		{ manager: "pnpm", file: "pnpm-lock.yaml" },
+		{ manager: "npm", file: "package-lock.json" },
+		{ manager: "npm", file: "npm-shrinkwrap.json" },
+	];
+	return candidates.filter(candidate => fs.existsSync(path.join(worktreePath, candidate.file)));
+}
+
+function isWorktreePackageManager(value: string): value is WorktreePackageManager {
+	return value === "bun" || value === "npm" || value === "pnpm";
+}
+
+function resolveWorktreePackageManager(
+	worktreePath: string,
+	manifest: WorktreePackageManifest | null,
+): ResolvedWorktreePackageManager {
+	const declared = declaredPackageManager(manifest);
+	const declaredManager = declared && isWorktreePackageManager(declared.name) ? declared.name : null;
+	if (declared && !declaredManager) {
+		throw new Error(`worktree_dependency_manager_unsupported:${declared.name}`);
+	}
+
+	const lockfiles = worktreeLockfiles(worktreePath);
+	if (lockfiles.length === 0) throw new Error("worktree_dependency_lockfile_missing");
+	if (lockfiles.length > 1) {
+		throw new Error(`worktree_dependency_lockfile_ambiguous:${lockfiles.map(lockfile => lockfile.file).join(",")}`);
+	}
+	const lockfileManager = lockfiles[0]!.manager;
+	if (declaredManager && declaredManager !== lockfileManager) {
+		throw new Error(`worktree_dependency_manager_mismatch:${declaredManager}:${lockfileManager}`);
+	}
+	return { name: declaredManager ?? lockfileManager, version: declared?.version ?? null };
+}
+
+function removeLegacySourceNodeModulesLink(sourceRoot: string, worktreePath: string): void {
+	const target = path.join(worktreePath, "node_modules");
+	let targetStat: fs.Stats;
+	try {
+		targetStat = fs.lstatSync(target);
+	} catch (error) {
+		if (fileSystemErrorCode(error) === "ENOENT") return;
+		throw error;
+	}
+	if (!targetStat.isSymbolicLink()) return;
+
+	const sourceModules = path.join(sourceRoot, "node_modules");
+	const linkTarget = path.resolve(path.dirname(target), fs.readlinkSync(target));
+	let linksToSource = linkTarget === path.resolve(sourceModules);
+	try {
+		linksToSource = linksToSource || fs.realpathSync(target) === fs.realpathSync(sourceModules);
+	} catch (error) {
+		if (fileSystemErrorCode(error) !== "ENOENT") throw error;
+	}
+	if (!linksToSource) throw new Error(`worktree_node_modules_not_local:${target}`);
+	fs.unlinkSync(target);
+}
+
+function installedPackageManagerVersion(
+	name: WorktreePackageManager,
+	cwd: string,
+	probes: WorktreeDependencyProbes,
+): string {
+	const testVersion = probes.version?.(name);
+	if (testVersion !== undefined) return testVersion;
+	if (name === "bun") return Bun.version;
+	const result = Bun.spawnSync([name, "--version"], { cwd, stdout: "pipe", stderr: "ignore", timeout: 10_000 });
+	if (result.exitCode !== 0) throw new Error(`worktree_dependency_manager_unavailable:${name}`);
+	return result.stdout?.toString().trim() ?? "";
+}
+
+function worktreeInstallCommand(
+	manager: ResolvedWorktreePackageManager,
+	cwd: string,
+	probes: WorktreeDependencyProbes,
+): string[] {
+	const args = manager.name === "npm" ? ["ci"] : ["install", "--frozen-lockfile"];
+	if (manager.name !== "bun" && !(probes.isExecutableAvailable?.(manager.name) ?? Bun.which(manager.name) !== null)) {
+		throw new Error(`worktree_dependency_manager_unavailable:${manager.name}`);
+	}
+	if (manager.version) {
+		const installedVersion = installedPackageManagerVersion(manager.name, cwd, probes);
+		if (installedVersion !== manager.version) {
+			throw new Error(
+				`worktree_dependency_manager_version_mismatch:${manager.name}:${manager.version}:${installedVersion || "unknown"}`,
+			);
+		}
+	}
+	return [manager.name, ...args];
+}
+
+function boundedInstallFailure(stderr: string, exitCode: number): string {
+	const detail = stderr.trim().replace(/\s+/g, " ");
+	if (!detail) return `exit_${exitCode}`;
+	return detail.length <= 2048 ? detail : `${detail.slice(0, 2045)}...`;
+}
+
+function installWorktreeDependencies(
+	sourceRoot: string,
+	worktreePath: string,
+	manifest: WorktreePackageManifest | null,
+	probes: WorktreeDependencyProbes,
+): void {
+	removeLegacySourceNodeModulesLink(sourceRoot, worktreePath);
+	const manager = resolveWorktreePackageManager(worktreePath, manifest);
+	const command = worktreeInstallCommand(manager, worktreePath, probes);
+	let result: { exitCode: number; stderr: string };
+	try {
+		if (probes.spawnInstall) {
+			result = probes.spawnInstall(command, worktreePath);
+		} else {
+			const spawned = Bun.spawnSync(command, {
+				cwd: worktreePath,
+				stdout: "ignore",
+				stderr: "pipe",
+				timeout: 120_000,
+				maxBuffer: 64 * 1024,
+			});
+			result = { exitCode: spawned.exitCode, stderr: spawned.stderr?.toString() ?? "" };
+		}
+	} catch (error) {
+		const detail = error instanceof Error && error.message ? error.message : "spawn_failed";
+		throw new Error(`worktree_dependency_install_failed:${manager.name}:${detail.slice(0, 2048)}`);
+	}
+	if (result.exitCode !== 0) {
+		throw new Error(
+			`worktree_dependency_install_failed:${manager.name}:${boundedInstallFailure(result.stderr, result.exitCode)}`,
+		);
+	}
+
+	try {
+		const installed = fs.lstatSync(path.join(worktreePath, "node_modules"));
+		if (!installed.isDirectory() || installed.isSymbolicLink()) {
+			throw new Error("worktree_dependency_install_not_local");
+		}
+	} catch (error) {
+		if (fileSystemErrorCode(error) !== "ENOENT") throw error;
+	}
+}
+
+/** Package worktrees own their complete lockfile-resolved dependency graph. */
+
+export function ensureReusableNodeModules(
+	sourceRoot: string,
+	worktreePath: string,
+	probes: WorktreeDependencyProbes = {},
+): "symlink" | "present" | "missing" {
 	const target = path.join(worktreePath, "node_modules");
+	const manifest = readWorktreePackageManifest(worktreePath);
+	if (hasWorktreePackageMetadata(worktreePath, manifest)) {
+		installWorktreeDependencies(sourceRoot, worktreePath, manifest, probes);
+		return "present";
+	}
 	if (fs.existsSync(target)) return "present";
 	const source = path.join(sourceRoot, "node_modules");
 	if (!fs.existsSync(source)) return "missing";
@@ -299,6 +558,20 @@ export function ensureReusableNodeModules(sourceRoot: string, worktreePath: stri
 	return "symlink";
 }
 
+export function launchWorktreeCwd(plan: SkcLaunchWorktreePlan): string {
+	return path.resolve(plan.worktreePath, plan.relativeCwd);
+}
+
+export function ensureLaunchWorktreeDependencies(plan: SkcLaunchWorktreePlan): "symlink" | "present" | "missing" {
+	if (plan.relativeDependencyRoot === null) {
+		return ensureReusableNodeModules(plan.repoRoot, plan.worktreePath);
+	}
+	return ensureReusableNodeModules(
+		path.resolve(plan.sourceCheckoutRoot, plan.relativeDependencyRoot),
+		path.resolve(plan.worktreePath, plan.relativeDependencyRoot),
+	);
+}
+
 /** Result of {@link prepareLaunchWorktree}: the effective working directory, remaining args, and resolved worktree plan. */
 export interface PreparedLaunchWorktree {
 	cwd: string;
@@ -311,6 +584,6 @@ export function prepareLaunchWorktree(cwd: string, args: string[]): PreparedLaun
 	const planned = planLaunchWorktree(cwd, parsed.mode);
 	const ensured = ensureLaunchWorktree(planned);
 	if (!ensured.enabled) return { cwd, args: parsed.remainingArgs, worktree: ensured };
-	ensureReusableNodeModules(ensured.repoRoot, ensured.worktreePath);
-	return { cwd: ensured.worktreePath, args: parsed.remainingArgs, worktree: ensured };
+	ensureLaunchWorktreeDependencies(ensured);
+	return { cwd: launchWorktreeCwd(ensured), args: parsed.remainingArgs, worktree: ensured };
 }

package/src/skc-runtime/session-restore-runtime.ts

@@ -0,0 +1,120 @@
+// Live-system bindings for restore eligibility.
+//
+// `session-restore.ts` stays pure and injectable so its fail-closed decision
+// table can be tested without a filesystem or a tmux server. This module is the
+// thin adapter that supplies the real readings.
+
+import * as fsSync from "node:fs";
+import type { BootGeneration } from "./boot-generation";
+import {
+	type RestoreCandidateDeps,
+	type RestorePointer,
+	type RestoreSidecarFacts,
+	readTranscriptSessionId,
+} from "./session-restore";
+import { SKC_COORDINATOR_SESSION_ID_ENV, SKC_COORDINATOR_SESSION_STATE_FILE_ENV } from "./session-state-sidecar";
+import { resolveSkcTmuxBinary } from "./tmux-common";
+import { createSkcTmuxSession, listSkcTmuxSessions } from "./tmux-sessions";
+
+const TERMINAL_SIDECAR_STATES = new Set(["completed", "errored"]);
+
+/**
+ * Strict re-read of the sidecar a pointer names.
+ *
+ * Returns null for missing, unreadable, or malformed content: restore must never
+ * infer a session's identity from the pointer alone.
+ */
+export function readSidecarFacts(pointer: RestorePointer): RestoreSidecarFacts | null {
+	let parsed: Record<string, unknown>;
+	try {
+		parsed = JSON.parse(fsSync.readFileSync(pointer.state_file, "utf8")) as Record<string, unknown>;
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const sessionId = typeof parsed.session_id === "string" ? parsed.session_id : null;
+	if (!sessionId) return null;
+	return {
+		sessionId,
+		stateFile: pointer.state_file,
+		sessionFile: typeof parsed.session_file === "string" ? parsed.session_file : null,
+		cwd: typeof parsed.cwd === "string" ? parsed.cwd : null,
+		terminal: typeof parsed.state === "string" && TERMINAL_SIDECAR_STATES.has(parsed.state),
+	};
+}
+
+/**
+ * True when a tmux session already carries this exact coordinator identity.
+ *
+ * An unreadable tmux is reported as a collision on purpose: not being able to
+ * see the server is not evidence that the identity is free.
+ */
+export function hasLiveIdentity(pointer: RestorePointer, env: NodeJS.ProcessEnv = process.env): boolean {
+	try {
+		return listSkcTmuxSessions(env).some(
+			session =>
+				session.sessionId === pointer.coordinator_session_id && session.sessionStateFile === pointer.state_file,
+		);
+	} catch {
+		return true;
+	}
+}
+
+/** psmux exposes no immutable native session identity, so restore cannot prove ownership there. */
+export function ownerProofAvailable(env: NodeJS.ProcessEnv = process.env): boolean {
+	try {
+		return !resolveSkcTmuxBinary({ env }).isPsmux;
+	} catch {
+		return false;
+	}
+}
+
+export function buildRestoreCandidateDeps(
+	currentBoot: BootGeneration,
+	env: NodeJS.ProcessEnv = process.env,
+): RestoreCandidateDeps {
+	return {
+		currentBoot,
+		readSidecar: readSidecarFacts,
+		pathExists: target => fsSync.existsSync(target),
+		hasLiveIdentity: pointer => hasLiveIdentity(pointer, env),
+		readTranscriptSessionId: pointer => readTranscriptSessionId(pointer.session_file),
+		ownerProofAvailable: () => ownerProofAvailable(env),
+	};
+}
+
+export type RestoreOutcome =
+	| { ok: true; pointer: RestorePointer; tmuxSession: string }
+	| { ok: false; pointer: RestorePointer; code: string; detail: string };
+
+/**
+ * Restores exactly one eligible candidate.
+ *
+ * Deliberately goes through the ordinary fenced creator rather than spawning
+ * tmux directly: restore must inherit the same identity fence, owner-isolation
+ * proof, and exact cleanup as every other producer. The only differences are the
+ * working directory and the `--resume` argv handed to the child.
+ *
+ * Never cleans up another owner's session. A fence refusal is reported and the
+ * candidate is skipped.
+ */
+export function restoreSession(pointer: RestorePointer, env: NodeJS.ProcessEnv = process.env): RestoreOutcome {
+	// The child must adopt the recorded identity, not this process's.
+	const childEnv: NodeJS.ProcessEnv = {
+		...env,
+		[SKC_COORDINATOR_SESSION_ID_ENV]: pointer.coordinator_session_id,
+		[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]: pointer.state_file,
+		SKC_SESSION_ID: pointer.skc_session_id,
+	};
+	try {
+		const session = createSkcTmuxSession(childEnv, {
+			cwd: pointer.cwd,
+			childArgs: ["--resume", pointer.skc_session_id],
+		});
+		return { ok: true, pointer, tmuxSession: session.name };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const [code = "restore_failed"] = message.split(":");
+		return { ok: false, pointer, code, detail: message };
+	}
+}