stim 1.13.0 → 1.15.0

package/dist/workspace-state-CL2V2Ons.mjs

@@ -0,0 +1,371 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { join as join$1, resolve as resolve$1 } from "path";
+import { buildCacheRoot as sharedBuildCache, withDirLock as withDirLock$1, workspaceId, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
+import { WORKSPACE_AGENT_KEY, emulatorLogFile, readJsonObject, readWorkspaceState, readWorkspaceState as readWorkspaceState$1, sharedCcache, sharedCompilationCache, supervisorLogFile, supervisorPidFile, workspaceDerivedData, workspaceLastUsed, workspaceLogErrorIndex, workspaceLogsDir, workspaceMetadataFile, workspaceStateFile, workspaceStateLock } from "@stim-cli/core/state";
+import { homedir } from "node:os";
+import { readFile, readdir } from "node:fs/promises";
+//#region src/workspace/paths.ts
+function ensureWorkspaceStorage(projectRoot) {
+	const canonicalRoot = resolve$1(projectRoot);
+	const dir = workspaceDir(canonicalRoot);
+	const file = workspaceMetadataFile(canonicalRoot);
+	mkdirSync(dir, { recursive: true });
+	return withDirLock$1(join$1(dir, "metadata.lock"), () => {
+		if (!existsSync(file)) {
+			const metadata = {
+				projectRoot: canonicalRoot,
+				workspace: workspaceName$1(canonicalRoot),
+				version: 1
+			};
+			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
+			try {
+				renameSync(tmp, file);
+			} catch (error) {
+				rmSync(tmp, { force: true });
+				throw error;
+			}
+			return dir;
+		}
+		if (readJsonObject(file)?.projectRoot === canonicalRoot) return dir;
+		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
+		error.code = "STIM_WORKSPACE_COLLISION";
+		throw error;
+	});
+}
+//#endregion
+//#region src/agent-sessions.ts
+const TITLE_MAX_LENGTH = 120;
+const SESSION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+const CODEX_ACTIVE_MS = 18e5;
+const CODEX_QUERY_TIMEOUT_MS = 5e3;
+const COMMAND_ATTRIBUTION_MS = 18e5;
+/**
+* Claude desktop opens a Claude Code session with `claude://code/continue?session=<id>`, and accepts only its own
+* `local_` session ids there, which a session file carries as `hostSessionId` when the desktop app hosts the session.
+*/
+const CLAUDE_DESKTOP_SESSION = /^local_[A-Za-z0-9-]{1,64}$/;
+/**
+* Claude Code writes a Remote Control session's claude.ai id to its session file as `bridgeSessionId`, and prints
+* `https://claude.ai/code/<id>` as the session URL, which the Claude mobile app also opens as a universal link.
+*/
+const CLAUDE_REMOTE_SESSION = /^session_[A-Za-z0-9]{1,64}$/;
+function shortTitle(value) {
+	if (typeof value !== "string") return void 0;
+	const title = value.replace(/\p{Cc}+/gu, " ").replace(/\s+/g, " ").trim();
+	if (!title) return void 0;
+	return title.length > TITLE_MAX_LENGTH ? `${title.slice(0, 117)}...` : title;
+}
+function isoFromMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? new Date(value).toISOString() : void 0;
+}
+function withOptional(session, fields) {
+	for (const [key, value] of Object.entries(fields)) if (value !== void 0) Object.assign(session, { [key]: value });
+	return session;
+}
+/** The agent session a shell's environment names, from `CLAUDE_CODE_SESSION_ID` or `CODEX_THREAD_ID`. */
+function agentFromEnv(env) {
+	const claude = env.CLAUDE_CODE_SESSION_ID?.trim();
+	if (claude && SESSION_ID.test(claude)) return {
+		tool: "claude-code",
+		sessionId: claude
+	};
+	const codex = env.CODEX_THREAD_ID?.trim();
+	if (codex && SESSION_ID.test(codex)) return {
+		tool: "codex",
+		sessionId: codex
+	};
+	return null;
+}
+/**
+* A Claude Code session from one `~/.claude/sessions/<pid>.json` file, or null when the entry lacks a pid, session id
+* or absolute cwd. The format is Claude Code's own and undocumented, so every other field is optional.
+*/
+function parseClaudeSession(entry, apps) {
+	if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+	const raw = entry;
+	if (!Number.isSafeInteger(raw.pid) || raw.pid <= 0) return null;
+	if (typeof raw.sessionId !== "string" || !SESSION_ID.test(raw.sessionId)) return null;
+	if (typeof raw.cwd !== "string" || !isAbsolute(raw.cwd)) return null;
+	const host = raw.hostSessionId;
+	const bridge = raw.bridgeSessionId;
+	return withOptional({
+		tool: "claude-code",
+		sessionId: raw.sessionId,
+		cwd: raw.cwd
+	}, {
+		title: shortTitle(raw.name),
+		startedAt: isoFromMs(raw.startedAt),
+		lastActiveAt: isoFromMs(raw.updatedAt),
+		pid: raw.pid,
+		openUrl: apps.claude && typeof host === "string" && CLAUDE_DESKTOP_SESSION.test(host) ? `claude://code/continue?session=${host}` : void 0,
+		webUrl: typeof bridge === "string" && CLAUDE_REMOTE_SESSION.test(bridge) ? `https://claude.ai/code/${bridge}` : void 0
+	});
+}
+function isSubagentSource(source) {
+	if (typeof source !== "string" || !source.startsWith("{")) return false;
+	try {
+		const parsed = JSON.parse(source);
+		return Boolean(parsed && typeof parsed === "object" && "subagent" in parsed);
+	} catch {
+		return false;
+	}
+}
+/**
+* Codex threads from rows of its `threads` table. `name` is the thread's short name; `title` there is the first
+* prompt, so it is never read. Subagent threads, which Codex spawns inside a thread, are left out.
+*/
+function parseCodexThreads(rows, apps) {
+	if (!Array.isArray(rows)) return [];
+	return rows.flatMap((row) => {
+		if (!row || typeof row !== "object") return [];
+		const raw = row;
+		if (typeof raw.id !== "string" || !SESSION_ID.test(raw.id)) return [];
+		if (typeof raw.cwd !== "string" || !isAbsolute(raw.cwd) || isSubagentSource(raw.source)) return [];
+		return [withOptional({
+			tool: "codex",
+			sessionId: raw.id,
+			cwd: raw.cwd
+		}, {
+			title: shortTitle(raw.name),
+			startedAt: isoFromMs(raw.created_at_ms),
+			lastActiveAt: isoFromMs(raw.updated_at_ms),
+			openUrl: apps.codex ? `codex://threads/${raw.id}` : void 0
+		})];
+	});
+}
+function codexStateDatabase(names) {
+	let best = null;
+	for (const name of names) {
+		const version = Number(/^state_(\d+)\.sqlite$/.exec(name)?.[1]);
+		if (Number.isFinite(version) && (!best || version > best.version)) best = {
+			name,
+			version
+		};
+	}
+	return best?.name ?? null;
+}
+const APP_BUNDLES = {
+	claude: {
+		names: ["Claude"],
+		bundleId: "com.anthropic.claudefordesktop"
+	},
+	codex: {
+		names: ["ChatGPT", "Codex"],
+		bundleId: "com.openai.codex"
+	}
+};
+function bundleInstalled(home, { names, bundleId }) {
+	for (const folder of ["/Applications", join(home, "Applications")]) for (const name of names) try {
+		if (readFileSync(join(folder, `${name}.app`, "Contents", "Info.plist"), "latin1").includes(bundleId)) return true;
+	} catch {}
+	return false;
+}
+function installedAgentApps(home = homedir()) {
+	if (process.platform !== "darwin") return {
+		claude: false,
+		codex: false
+	};
+	return {
+		claude: bundleInstalled(home, APP_BUNDLES.claude),
+		codex: bundleInstalled(home, APP_BUNDLES.codex)
+	};
+}
+function canonical(session) {
+	try {
+		return {
+			...session,
+			cwd: realpathSync(session.cwd)
+		};
+	} catch {
+		return null;
+	}
+}
+function sessionProcessRuns(session) {
+	const start = (0, process_identity_exports.inspectProcessStart)(session.pid);
+	if (start.status === "gone") return false;
+	if (start.status === "unknown" || !session.startedAt) return true;
+	return start.startedAtMs <= Date.parse(session.startedAt) + 2e3;
+}
+async function claudeSessions(home, apps) {
+	const directory = join(home, ".claude", "sessions");
+	let names;
+	try {
+		names = (await readdir(directory)).filter((name) => name.endsWith(".json"));
+	} catch {
+		return [];
+	}
+	return (await Promise.all(names.map(async (name) => {
+		try {
+			const session = parseClaudeSession(JSON.parse(await readFile(join(directory, name), "utf8")), apps);
+			return session && sessionProcessRuns(session) ? canonical(session) : null;
+		} catch {
+			return null;
+		}
+	}))).filter((session) => session !== null);
+}
+const CODEX_QUERY = `const { DatabaseSync } = require('node:sqlite');
+const db = new DatabaseSync(process.argv[1], { readOnly: true });
+const rows = db.prepare('SELECT id, cwd, name, source, created_at_ms, updated_at_ms FROM threads WHERE archived = 0 AND updated_at_ms >= ? AND source NOT LIKE ? ORDER BY updated_at_ms DESC LIMIT 50').all(Number(process.argv[2]), '%"subagent"%');
+db.close();
+process.stdout.write(JSON.stringify(rows));`;
+async function codexSessions(codexHome, apps, now) {
+	let database;
+	try {
+		database = codexStateDatabase(await readdir(codexHome));
+	} catch {
+		return [];
+	}
+	if (!database) return [];
+	try {
+		const out = await getExecutor().runFileAsync(process.execPath, [
+			"--no-warnings",
+			"--experimental-sqlite",
+			"-e",
+			CODEX_QUERY,
+			join(codexHome, database),
+			String(now - CODEX_ACTIVE_MS)
+		], { timeoutMs: CODEX_QUERY_TIMEOUT_MS });
+		return parseCodexThreads(JSON.parse(out), apps).map(canonical).filter((session) => session !== null);
+	} catch {
+		return [];
+	}
+}
+/**
+* The Claude Code sessions whose process runs and the Codex threads updated in the last 30 minutes, with canonical
+* working directories. Every source is optional: a missing, unreadable or changed format yields no sessions from it.
+*/
+async function discoverAgentSessions({ home = homedir(), codexHome = process.env.CODEX_HOME || join(home, ".codex"), apps = installedAgentApps(home), now = Date.now() } = {}) {
+	const [claude, codex] = await Promise.all([claudeSessions(home, apps), codexSessions(codexHome, apps, now)]);
+	return [...claude, ...codex];
+}
+function within(directory, candidate) {
+	const path = relative(directory, candidate);
+	return path === "" || !path.startsWith("..") && !isAbsolute(path);
+}
+function agentKey(session) {
+	return `${session.tool}:${session.sessionId}`;
+}
+function activeAt(session) {
+	const at = Date.parse(session.lastActiveAt ?? "");
+	return Number.isFinite(at) ? at : -Infinity;
+}
+/**
+* The sessions working in each workspace, most recently active first. A session belongs to the deepest workspace
+* whose path holds its cwd, and to every workspace whose git worktree root is its cwd. A workspace's recorded session
+* is added with the discovered session's details when it is running, or on its own for `COMMAND_ATTRIBUTION_MS`
+* after the command.
+*/
+function attributeAgentSessions(workspaces, sessions, now) {
+	const found = workspaces.map(() => /* @__PURE__ */ new Map());
+	for (const session of sessions) {
+		const holders = workspaces.flatMap((workspace, i) => within(workspace.path, session.cwd) ? [i] : []);
+		const deepest = Math.max(-1, ...holders.map((i) => workspaces[i].path.length));
+		workspaces.forEach((workspace, i) => {
+			if (holders.includes(i) && workspace.path.length === deepest || workspace.root === session.cwd) found[i].set(agentKey(session), session);
+		});
+	}
+	workspaces.forEach(({ recorded }, i) => {
+		if (!recorded) return;
+		const running = found[i].get(agentKey(recorded)) ?? sessions.find((session) => agentKey(session) === agentKey(recorded));
+		if (running) {
+			const newer = activeAt(recorded) > activeAt(running);
+			found[i].set(agentKey(recorded), newer ? {
+				...running,
+				lastActiveAt: recorded.lastActiveAt
+			} : running);
+		} else if (now - activeAt(recorded) <= COMMAND_ATTRIBUTION_MS) found[i].set(agentKey(recorded), recorded);
+	});
+	return found.map((map) => [...map.values()].toSorted((a, b) => activeAt(b) - activeAt(a)));
+}
+//#endregion
+//#region src/workspace/workspace-state.ts
+function withWorkspaceStateLock(root, fn) {
+	const file = workspaceStateFile(root);
+	return withDirLock$1(workspaceStateLock(root), fn, { ensureParent: () => {
+		ensureWorkspaceStorage(root);
+		mkdirSync(dirname(file), { recursive: true });
+	} });
+}
+function writeWorkspaceState(root, patch) {
+	return updateWorkspaceState(root, (state) => ({
+		...state,
+		...patch
+	}));
+}
+function updateWorkspaceState(root, update) {
+	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, update(readWorkspaceState(root) ?? {})));
+}
+function replaceWorkspaceState(root, state) {
+	const file = workspaceStateFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = `${file}.tmp-${process.pid}`;
+	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+	renameSync(tmp, file);
+	return state;
+}
+function clearWorkspaceStateKeys(root, keys) {
+	if (!existsSync(workspaceStateFile(root))) return;
+	withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		const file = workspaceStateFile(root);
+		if (!state) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return;
+		}
+		let changed = false;
+		for (const key of keys) {
+			if (!(key in state)) continue;
+			delete state[key];
+			changed = true;
+		}
+		if (!changed) return;
+		if (Object.keys(state).length === 0) {
+			rmSync(file, { force: true });
+			return;
+		}
+		replaceWorkspaceState(root, state);
+	});
+}
+function clearWorkspaceStateKey(root, key, shouldClear) {
+	return withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		if (!state || !(key in state)) return true;
+		if (!shouldClear(state[key])) return false;
+		delete state[key];
+		const file = workspaceStateFile(root);
+		if (Object.keys(state).length === 0) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return true;
+		}
+		replaceWorkspaceState(root, state);
+		return true;
+	});
+}
+/** Records a command's use of the workspace, and the agent session whose shell ran it when there is one. */
+function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date(), env = process.env) {
+	const agent = agentFromEnv(env);
+	let cwd = process.cwd();
+	try {
+		cwd = realpathSync(cwd);
+	} catch {}
+	try {
+		writeWorkspaceState(root, {
+			lastUsedAt: now.toISOString(),
+			...agent ? { [WORKSPACE_AGENT_KEY]: {
+				...agent,
+				cwd,
+				lastActiveAt: now.toISOString()
+			} } : {}
+		});
+	} catch {}
+}
+//#endregion
+export { workspaceLogsDir as C, withDirLock$1 as E, workspaceLogErrorIndex as S, workspaceStateFile as T, supervisorLogFile as _, updateWorkspaceState as a, workspaceDir as b, writeWorkspaceState as c, discoverAgentSessions as d, emulatorLogFile as f, sharedCompilationCache as g, sharedCcache as h, recordWorkspaceUse as i, agentKey as l, sharedBuildCache as m, clearWorkspaceStateKeys as n, withWorkspaceStateLock as o, ensureWorkspaceStorage as p, readWorkspaceState$1 as r, workspaceLastUsed as s, clearWorkspaceStateKey as t, attributeAgentSessions as u, supervisorPidFile as v, workspaceName$1 as w, workspaceId as x, workspaceDerivedData as y };

package/dist/worktree-BT_uULFx.mjs

@@ -0,0 +1,2 @@
+import { a as porcelainPath, c as registerWarm, d as removalRemedy, f as removeWorktreeTarget, i as matchWorktreeEntry, l as removalBlockers, m as worktreeCommand, n as excludePodChurn, o as reclaimKeys, p as warmedWorkspace, r as excludeWatchmanCookies, s as registerRemove, t as dependencyInstallCommand, u as removalPath } from "./worktree-qXKzADSC.mjs";
+export { worktreeCommand as default, dependencyInstallCommand, excludePodChurn, excludeWatchmanCookies, matchWorktreeEntry, porcelainPath, reclaimKeys, registerRemove, registerWarm, removalBlockers, removalPath, removalRemedy, removeWorktreeTarget, warmedWorkspace };