@overdeck/desktop 0.50.0 → 0.50.3

package/server/kimi-code-CNYRA8Dd.js

@@ -1,581 +0,0 @@
-import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Ri as getOverdeckHome, zi as init_paths } from "./config-yaml-D60AnTIu.js";
-import { n as init_fs_lock, r as isPidDead } from "./fs-lock-DQ_gUxfq.js";
-import { C as init_tmux, v as getManagedTmuxSocketName } from "./tmux-wnT_hg-s.js";
-import { c as getRuntimeBehavior } from "./src-CdwN6WY6.js";
-import { t as init_behavior } from "./behavior-DCg8CIWC.js";
-import { A as saveAgentStateSync, Di as writePtyToken, Ei as init_pty_token, Oi as init_pty_supervisor_locate, _ as init_agent_state, _n as listAgentStates, ar as deliverAgentMessage, g as getAgentStateSync, gn as init_queries, ki as resolvePtySupervisorScriptPath, lr as init_delivery } from "./agent-state-FABw8neJ.js";
-import { C as generateLauncherScriptSync, w as init_launcher_generator } from "./auto-spawn-consent-BesWchEi.js";
-import { _ as tmuxKillSession, g as tmuxCreateSession, h as init_tmux_cli, v as tmuxSessionExists } from "./codex-DYyZL8JD.js";
-import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-DChiynaB.js";
-import { n as parseKimiSessionSync, t as init_kimi_parser } from "./kimi-parser-OcWwmOqF.js";
-import { basename, dirname, join } from "node:path";
-import { homedir } from "node:os";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-//#region ../../lib/runtimes/kimi-code.ts
-/**
-* Kimi Code CLI runtime adapter (PAN-1837).
-*
-* Native TUI — not ACP. Kimi writes its own session tree at
-* `<kimiHome>/sessions/<workDirKey>/<sessionId>/agents/main/wire.jsonl`,
-* where `workDirKey = wd_<basename(workDir)>_<sha256(workDir).hex[:12]>`
-* (verified empirically against installed kimi 0.29.2, wi-fixture/D2 — Kimi
-* does not expose this derivation directly). Kimi generates its own session
-* id; it cannot be preset via a launch flag (D2/erratum E1: no --session, no
-* --work-dir). The id is captured post-launch as the session directory that
-* newly appears under the workspace's bucket, then persisted at
-* `~/.overdeck/agents/<id>/kimi-session-id` (mirrors codex's thread-id file)
-* so later introspection calls avoid re-walking the bucket.
-*
-* Delivery: PTY supervisor is primary (KIMI_CODE_BEHAVIOR.supportsPtySupervisor
-* is true, same as claude-code). sendMessage delegates to the existing generic
-* deliverAgentMessage() cascade (supervisor -> channels -> async tmux paste)
-* rather than re-implementing that tiering here — deliverAgentMessage already
-* dispatches on socket existence, not a hardcoded harness list, so kimi-code
-* flows through it for free once its PTY supervisor socket exists.
-*
-* getTokenUsage/getSessionCost delegate to wi8b's parseKimiSessionSync,
-* which sums every usage.record in the wire.jsonl — Kimi's own server-side
-* context cache accounting.
-*/
-/**
-* Compute Kimi's on-disk workDirKey bucket name for a working directory.
-* Verified against `wd_kimi-fixture-scratch_ef33f89ad7cf` (workDir
-* `/tmp/kimi-fixture-scratch`) and several pre-existing real sessions on the
-* machine that produced the wi-fixture capture (e.g.
-* `wd_overdeck_b289e7acb782`, `wd_feature-pan-2858_1dc66dc5021d`).
-*/
-function kimiWorkDirKey(workDir) {
-	const hash = createHash("sha256").update(workDir).digest("hex").slice(0, 12);
-	return `wd_${basename(workDir)}_${hash}`;
-}
-/** Absolute path to the session bucket Kimi writes for a working directory. */
-function kimiSessionsRoot(kimiHome, workDir) {
-	return join(kimiHome, "sessions", kimiWorkDirKey(workDir));
-}
-/**
-* Locate wire.jsonl for a specific captured session id under the workspace's
-* bucket. Falls back to the newest session directory when the captured id's
-* wire.jsonl is missing (e.g. never captured, or the id file is stale).
-*/
-function findKimiWirePath(kimiHome, workspace, sessionId) {
-	if (sessionId) {
-		const candidate = join(kimiSessionsRoot(kimiHome, workspace), sessionId, "agents", "main", "wire.jsonl");
-		if (existsSync(candidate)) return candidate;
-	}
-	return findLatestKimiSession(kimiHome, workspace);
-}
-/** Fallback: the newest session directory by wire.jsonl mtime under the workspace's bucket. */
-function findLatestKimiSession(kimiHome, workspace) {
-	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
-	let entries;
-	try {
-		entries = readdirSync(bucketDir);
-	} catch {
-		return null;
-	}
-	let newest = null;
-	for (const entry of entries) {
-		const wirePath = join(bucketDir, entry, "agents", "main", "wire.jsonl");
-		let mtimeMs;
-		try {
-			mtimeMs = statSync(wirePath).mtimeMs;
-		} catch {
-			continue;
-		}
-		if (!newest || mtimeMs > newest.mtimeMs) newest = {
-			path: wirePath,
-			mtimeMs
-		};
-	}
-	return newest?.path ?? null;
-}
-/**
-* Async twin of {@link findKimiWirePath} (PAN-1837 review fix, P2). The
-* dashboard's transcript resolver runs on the event loop and Command Deck
-* polling re-resolves the same session repeatedly, so the sync
-* readdirSync/statSync walk here would block the loop on every poll as a
-* session's history grows. Runtime-side sync callers (kill/spawn lifecycle)
-* keep using the sync versions above — this pair exists only for dashboard
-* routes, per the runtime's own documented sync contract.
-*/
-async function findKimiWirePathAsync(kimiHome, workspace, sessionId) {
-	if (sessionId) {
-		const candidate = join(kimiSessionsRoot(kimiHome, workspace), sessionId, "agents", "main", "wire.jsonl");
-		try {
-			await stat(candidate);
-			return candidate;
-		} catch {}
-	}
-	return findLatestKimiSessionAsync(kimiHome, workspace);
-}
-/** Async twin of {@link findLatestKimiSession} — see {@link findKimiWirePathAsync}. */
-async function findLatestKimiSessionAsync(kimiHome, workspace) {
-	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
-	let entries;
-	try {
-		entries = await readdir(bucketDir);
-	} catch {
-		return null;
-	}
-	let newest = null;
-	for (const entry of entries) {
-		const wirePath = join(bucketDir, entry, "agents", "main", "wire.jsonl");
-		let mtimeMs;
-		try {
-			mtimeMs = (await stat(wirePath)).mtimeMs;
-		} catch {
-			continue;
-		}
-		if (!newest || mtimeMs > newest.mtimeMs) newest = {
-			path: wirePath,
-			mtimeMs
-		};
-	}
-	return newest?.path ?? null;
-}
-function kimiHomeDefault() {
-	return join(homedir(), ".kimi-code");
-}
-/**
-* Poll a workspace's Kimi session bucket for a directory that did not exist
-* in `existingBefore`, returning the newest such directory's name (the
-* session id) once one appears. Standalone so both KimiCodeRuntimeSync.spawnAgent
-* and the production `pan start` spawn path (spawn-prep.ts, which builds its
-* own launcher/tmux session rather than delegating to this class) can capture
-* the session id the same way — mirroring codex's standalone
-* waitForCodexRollout/extractThreadIdFromRollout pair.
-*/
-async function waitForNewKimiSession(kimiHome, workspace, existingBefore, timeoutMs = SPAWN_READY_TIMEOUT_MS) {
-	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		let entries = [];
-		try {
-			entries = readdirSync(bucketDir);
-		} catch {
-			entries = [];
-		}
-		const fresh = entries.filter((entry) => !existingBefore.has(entry));
-		if (fresh.length > 0) {
-			let newest = null;
-			for (const name of fresh) {
-				let mtimeMs;
-				try {
-					mtimeMs = statSync(join(bucketDir, name)).mtimeMs;
-				} catch {
-					continue;
-				}
-				if (!newest || mtimeMs > newest.mtimeMs) newest = {
-					name,
-					mtimeMs
-				};
-			}
-			if (newest) return newest.name;
-		}
-		await delay(POLL_INTERVAL_MS);
-	}
-	return null;
-}
-/**
-* Async twin of {@link waitForNewKimiSession} (PAN-1837 review fix, P2). The
-* conversation-spawn capture task runs on the dashboard event loop, so its
-* 250ms poll loop must not block on readdirSync/statSync — runtime-side sync
-* callers (kill/spawn lifecycle) keep the sync version above.
-*/
-async function waitForNewKimiSessionAsync(kimiHome, workspace, existingBefore, timeoutMs = SPAWN_READY_TIMEOUT_MS) {
-	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		let entries = [];
-		try {
-			entries = await readdir(bucketDir);
-		} catch {
-			entries = [];
-		}
-		const fresh = entries.filter((entry) => !existingBefore.has(entry));
-		if (fresh.length > 0) {
-			let newest = null;
-			for (const name of fresh) {
-				let mtimeMs;
-				try {
-					mtimeMs = (await stat(join(bucketDir, name))).mtimeMs;
-				} catch {
-					continue;
-				}
-				if (!newest || mtimeMs > newest.mtimeMs) newest = {
-					name,
-					mtimeMs
-				};
-			}
-			if (newest) return newest.name;
-		}
-		await delay(POLL_INTERVAL_MS);
-	}
-	return null;
-}
-/** Persist the captured session id to `<overdeckHome>/agents/<id>/kimi-session-id` (mirrors codex's thread-id file). */
-function writeKimiSessionId(agentId, sessionId, overdeckHome = getOverdeckHome()) {
-	writeFileSync(join(overdeckHome, "agents", agentId, "kimi-session-id"), sessionId, "utf-8");
-}
-/** Deterministic, filesystem-safe lock path for a Kimi session bucket. */
-function kimiCaptureLockPath(bucketKey) {
-	const hash = createHash("sha256").update(bucketKey).digest("hex").slice(0, 24);
-	return join(getOverdeckHome(), "locks", "kimi-capture", `${hash}.lock`);
-}
-async function readKimiCaptureLockOwner(lockPath) {
-	try {
-		const parsed = JSON.parse(await readFile(join(lockPath, "owner.json"), "utf8"));
-		if (typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return {};
-		return parsed;
-	} catch {
-		return {};
-	}
-}
-/**
-* True once the lock directory itself (not owner.json) is older than the
-* stale-age bound. mkdir sets this directory's mtime at creation, and it is
-* never touched again once owner.json (a fresh directory entry) — if ever
-* written — settles, so this is trustworthy even when owner.json itself
-* never made it to disk.
-*/
-async function isKimiCaptureLockDirStale(lockPath) {
-	try {
-		const dirStat = await stat(lockPath);
-		return Date.now() - dirStat.mtimeMs > KIMI_CAPTURE_LOCK_STALE_AGE_MS;
-	} catch {
-		return true;
-	}
-}
-async function acquireKimiCaptureLock(lockPath) {
-	await mkdir(dirname(lockPath), {
-		recursive: true,
-		mode: 448
-	});
-	const deadline = Date.now() + KIMI_CAPTURE_LOCK_MAX_WAIT_MS;
-	for (;;) {
-		try {
-			await mkdir(lockPath, { mode: 448 });
-			const owner = {
-				pid: process.pid,
-				acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			const tmpPath = join(lockPath, `owner.${process.pid}.${Date.now()}.tmp`);
-			try {
-				await writeFile(tmpPath, JSON.stringify(owner, null, 2), "utf8");
-				await rename(tmpPath, join(lockPath, "owner.json"));
-			} catch (error) {
-				try {
-					await rm(tmpPath, { force: true });
-				} catch {}
-				try {
-					await rm(lockPath, {
-						recursive: true,
-						force: true
-					});
-				} catch {}
-				throw error;
-			}
-			return;
-		} catch (error) {
-			if (error.code !== "EEXIST") throw error;
-			const owner = await readKimiCaptureLockOwner(lockPath);
-			if (owner.pid !== void 0) {
-				if (isPidDead(owner.pid)) {
-					await rm(lockPath, {
-						recursive: true,
-						force: true
-					});
-					continue;
-				}
-			} else if (await isKimiCaptureLockDirStale(lockPath)) {
-				await rm(lockPath, {
-					recursive: true,
-					force: true
-				});
-				continue;
-			}
-		}
-		if (Date.now() >= deadline) throw new KimiCaptureLockTimeoutError(lockPath, KIMI_CAPTURE_LOCK_MAX_WAIT_MS);
-		await delay(KIMI_CAPTURE_LOCK_POLL_MS);
-	}
-}
-async function releaseKimiCaptureLock(lockPath) {
-	await rm(lockPath, {
-		recursive: true,
-		force: true
-	});
-}
-async function withKimiSessionCaptureLock(kimiHome, workspace, fn) {
-	const lockPath = kimiCaptureLockPath(kimiSessionsRoot(kimiHome, workspace));
-	await acquireKimiCaptureLock(lockPath);
-	try {
-		return await fn();
-	} finally {
-		await releaseKimiCaptureLock(lockPath);
-	}
-}
-function delay(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function shellQuote(value) {
-	return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-async function pollUntilSessionGone(agentId, timeoutMs) {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if (!await tmuxSessionExists(agentId)) return true;
-		await delay(POLL_INTERVAL_MS);
-	}
-	return false;
-}
-function createKimiCodeRuntimeSync(options = {}) {
-	return new KimiCodeRuntimeSync(options);
-}
-var execAsync, SPAWN_READY_TIMEOUT_MS, POLL_INTERVAL_MS, KimiCodeSpawnTimeout, KIMI_CAPTURE_LOCK_POLL_MS, KIMI_CAPTURE_LOCK_MAX_WAIT_MS, KIMI_CAPTURE_LOCK_STALE_AGE_MS, KimiCaptureLockTimeoutError, KimiCodeRuntimeSync;
-var init_kimi_code = __esmMin((() => {
-	init_tmux();
-	init_agent_state();
-	init_queries();
-	init_delivery();
-	init_pty_supervisor_locate();
-	init_pty_token();
-	init_launcher_generator();
-	init_harness_binary();
-	init_kimi_parser();
-	init_paths();
-	init_fs_lock();
-	init_behavior();
-	init_tmux_cli();
-	execAsync = promisify(exec);
-	SPAWN_READY_TIMEOUT_MS = 6e4;
-	POLL_INTERVAL_MS = 250;
-	KimiCodeSpawnTimeout = class extends Error {
-		code = "KIMI_CODE_SPAWN_TIMEOUT";
-		constructor(agentId) {
-			super(`Kimi Code agent ${agentId} did not write a new session under its workDirKey bucket within ${SPAWN_READY_TIMEOUT_MS}ms`);
-			this.name = "KimiCodeSpawnTimeout";
-		}
-	};
-	KIMI_CAPTURE_LOCK_POLL_MS = 250;
-	KIMI_CAPTURE_LOCK_MAX_WAIT_MS = 9e4;
-	KIMI_CAPTURE_LOCK_STALE_AGE_MS = 75e3;
-	KimiCaptureLockTimeoutError = class extends Error {
-		constructor(lockPath, waitedMs) {
-			super(`Timed out after ${waitedMs}ms waiting for the Kimi session-capture lock at ${lockPath} — another process is still holding it.`);
-			this.name = "KimiCaptureLockTimeoutError";
-		}
-	};
-	KimiCodeRuntimeSync = class {
-		name = "kimi-code";
-		overdeckHomeOverride;
-		kimiHomeOverride;
-		execCommand;
-		prepareLaunch;
-		resolveAgentStates;
-		deliverMessage;
-		resolveSupervisorScriptPath;
-		writePtyTokenFor;
-		constructor(options = {}) {
-			this.overdeckHomeOverride = options.overdeckHome;
-			this.kimiHomeOverride = options.kimiHome;
-			this.execCommand = options.execCommand ?? (async (command) => execAsync(command));
-			this.prepareLaunch = options.prepareLaunch ?? (() => prepareHarnessLaunch("kimi-code"));
-			this.resolveAgentStates = options.listAgentStates ?? (() => listAgentStates());
-			this.deliverMessage = options.deliverMessage ?? ((agentId, message) => deliverAgentMessage(agentId, message, "runtime:kimi-code"));
-			this.resolveSupervisorScriptPath = options.resolveSupervisorScriptPath ?? resolvePtySupervisorScriptPath;
-			this.writePtyTokenFor = options.writePtyTokenFor ?? writePtyToken;
-		}
-		getHarnessBehavior() {
-			return getRuntimeBehavior("kimi-code");
-		}
-		getSessionPath(agentId) {
-			const workspace = this.workspaceFor(agentId);
-			if (!workspace) return null;
-			return findKimiWirePath(this.kimiHome(), workspace, this.readSessionId(agentId));
-		}
-		getLastActivity(agentId) {
-			const path = this.getSessionPath(agentId);
-			if (!path) return null;
-			try {
-				return statSync(path).mtime;
-			} catch {
-				return null;
-			}
-		}
-		getHeartbeat(agentId) {
-			const lastActivity = this.getLastActivity(agentId);
-			if (!lastActivity) return null;
-			return {
-				timestamp: lastActivity,
-				agentId,
-				source: "jsonl",
-				confidence: "medium"
-			};
-		}
-		getTokenUsage(agentId) {
-			const path = this.getSessionPath(agentId);
-			if (!path) return null;
-			return parseKimiSessionSync(path)?.usage ?? null;
-		}
-		getSessionCost(agentId) {
-			const path = this.getSessionPath(agentId);
-			if (!path) return null;
-			const parsed = parseKimiSessionSync(path);
-			if (!parsed) return null;
-			return {
-				inputCost: 0,
-				outputCost: 0,
-				cacheReadCost: 0,
-				cacheWriteCost: 0,
-				totalCost: parsed.cost_v2 ?? parsed.cost ?? 0,
-				currency: "USD"
-			};
-		}
-		async sendMessage(agentId, message) {
-			const result = await this.deliverMessage(agentId, message);
-			if (!result.ok) throw new Error(`Kimi Code agent ${agentId}: message delivery failed${result.failure ? ` (${result.failure})` : ""}`);
-		}
-		async killAgent(agentId) {
-			try {
-				await this.execCommand(`tmux -L ${shellQuote(getManagedTmuxSocketName())} send-keys -t ${shellQuote(agentId)} C-c 2>/dev/null || true`);
-			} catch {}
-			if (await pollUntilSessionGone(agentId, 2e3)) return;
-			let panePid = null;
-			try {
-				const { stdout } = await this.execCommand(`tmux -L ${shellQuote(getManagedTmuxSocketName())} list-panes -t ${shellQuote(agentId)} -F '#{pane_pid}' 2>/dev/null`);
-				panePid = stdout.trim() || null;
-				if (panePid) await this.execCommand(`kill -TERM -- -${panePid} 2>/dev/null || kill -TERM ${panePid} 2>/dev/null || true`);
-			} catch {}
-			if (await pollUntilSessionGone(agentId, 5e3)) return;
-			if (panePid) try {
-				await this.execCommand(`kill -KILL -- -${panePid} 2>/dev/null || kill -KILL ${panePid} 2>/dev/null || true`);
-			} catch {}
-			if (await tmuxSessionExists(agentId)) await tmuxKillSession(agentId);
-		}
-		async spawnAgent(config) {
-			const { pathExport } = await this.prepareLaunch();
-			const model = config.model ?? "";
-			const bucketDir = kimiSessionsRoot(this.kimiHome(), config.workspace);
-			let existingBefore = /* @__PURE__ */ new Set();
-			try {
-				existingBefore = new Set(readdirSync(bucketDir));
-			} catch {}
-			mkdirSync(join(this.home(), "agents", config.agentId), { recursive: true });
-			const supervisorScriptPath = this.resolveSupervisorScriptPath();
-			await this.writePtyTokenFor(config.agentId);
-			const launcherContent = generateLauncherScriptSync({
-				role: "work",
-				workingDir: config.workspace,
-				harness: "kimi-code",
-				kimiCodeModel: model,
-				kimiCodeYolo: true,
-				extraEnvExports: [pathExport],
-				overdeckEnv: { agentId: config.agentId },
-				setTerminalEnv: true,
-				useSupervisor: true,
-				supervisorScriptPath,
-				unsetProviderEnv: true
-			});
-			const launcherScript = this.agentPath(config.agentId, "launcher.sh");
-			writeFileSync(launcherScript, launcherContent, { mode: 493 });
-			await tmuxCreateSession(config.agentId, config.workspace, `bash ${shellQuote(launcherScript)}`, config.env ?? {});
-			try {
-				const sessionId = await this.waitForNewSessionId(config.workspace, existingBefore);
-				if (!sessionId) throw new KimiCodeSpawnTimeout(config.agentId);
-				this.writeSessionId(config.agentId, sessionId);
-				this.markSupervisorEnabled(config.agentId);
-				if (config.prompt) await this.sendMessage(config.agentId, config.prompt);
-				return {
-					id: config.agentId,
-					sessionId,
-					runtime: "kimi-code",
-					model,
-					workspace: config.workspace,
-					startedAt: /* @__PURE__ */ new Date()
-				};
-			} catch (error) {
-				if (await tmuxSessionExists(config.agentId)) await tmuxKillSession(config.agentId);
-				throw error;
-			}
-		}
-		listSessions(workspace) {
-			const sessions = [];
-			for (const state of this.resolveAgentStates()) {
-				if (state.harness !== "kimi-code") continue;
-				if (workspace && state.workspace !== workspace) continue;
-				const sessionId = this.readSessionId(state.id);
-				if (!sessionId) continue;
-				const sessionPath = findKimiWirePath(this.kimiHome(), state.workspace, sessionId);
-				let lastActivity;
-				try {
-					lastActivity = statSync(sessionPath ?? "").mtime;
-				} catch {
-					continue;
-				}
-				sessions.push({
-					id: sessionId,
-					agentId: state.id,
-					workspace: state.workspace,
-					model: state.model ?? "",
-					startedAt: new Date(state.startedAt),
-					lastActivity,
-					tokenUsage: {
-						inputTokens: 0,
-						outputTokens: 0
-					}
-				});
-			}
-			return sessions;
-		}
-		async isRunning(agentId) {
-			return tmuxSessionExists(agentId);
-		}
-		home() {
-			return this.overdeckHomeOverride ?? getOverdeckHome();
-		}
-		kimiHome() {
-			return this.kimiHomeOverride ?? kimiHomeDefault();
-		}
-		agentPath(agentId, file) {
-			return join(this.home(), "agents", agentId, file);
-		}
-		workspaceFor(agentId) {
-			return getAgentStateSync(agentId)?.workspace ?? null;
-		}
-		readSessionId(agentId) {
-			try {
-				return readFileSync(this.agentPath(agentId, "kimi-session-id"), "utf-8").trim() || null;
-			} catch {
-				return null;
-			}
-		}
-		writeSessionId(agentId, sessionId) {
-			writeKimiSessionId(agentId, sessionId, this.home());
-		}
-		/**
-		* Best-effort: mark the persisted agent state as supervisor-enabled so
-		* prepareSupervisorForRelaunch (supervisor-channels.ts) re-supervises this
-		* agent on relaunch instead of falling back to useSupervisor:false. A
-		* no-op when no state has been saved for this agent yet (some callers of
-		* this adapter's spawnAgent create state afterward).
-		*/
-		markSupervisorEnabled(agentId) {
-			const state = getAgentStateSync(agentId);
-			if (!state) return;
-			state.supervisorEnabled = true;
-			saveAgentStateSync(state);
-		}
-		async waitForNewSessionId(workspace, existingBefore) {
-			return waitForNewKimiSession(this.kimiHome(), workspace, existingBefore);
-		}
-	};
-}));
-//#endregion
-export { findKimiWirePath as a, findLatestKimiSessionAsync as c, kimiSessionsRoot as d, kimiWorkDirKey as f, writeKimiSessionId as g, withKimiSessionCaptureLock as h, createKimiCodeRuntimeSync as i, init_kimi_code as l, waitForNewKimiSessionAsync as m, KimiCodeRuntimeSync as n, findKimiWirePathAsync as o, waitForNewKimiSession as p, KimiCodeSpawnTimeout as r, findLatestKimiSession as s, KimiCaptureLockTimeoutError as t, kimiCaptureLockPath as u };
-
-//# sourceMappingURL=kimi-code-CNYRA8Dd.js.map

package/server/merge-ops-Cf02szJ5.js

@@ -1,2 +0,0 @@
-import { l as triggerMerge } from "./workspaces-C7LAuZfe.js";
-export { triggerMerge };

package/server/merge-rebase-Bj7eJAG4.js

@@ -1,2 +0,0 @@
-import { t as rebaseFeatureBranch } from "./merge-rebase-KBw4rdh3.js";
-export { rebaseFeatureBranch };

package/server/messaging-Dfbhgjd6.js

@@ -1,3 +0,0 @@
-import { Ht as init_messaging, Ut as messageAgent } from "./agent-state-FABw8neJ.js";
-init_messaging();
-export { messageAgent };