@overdeck/desktop 0.47.1 → 0.48.0

package/server/{issue-service-singleton-F3A5VP6M.js → issue-service-singleton-BPNEXczv.js}

@@ -1,11 +1,11 @@
 import { n as __esmMin, r as __exportAll } from "./rolldown-runtime-DNCzzKnI.js";
-import { Gn as init_projects, ar as resolveProjectFromIssueSync, f as loadConfigSync, t as init_config_yaml } from "./config-yaml-CxdwhAIA.js";
-import { n as openDatabase, t as init_driver } from "./driver-CKVGi51s.js";
-import { g as loadReviewStatusesForIssues, p as init_review_status } from "./review-status-CwhA9wmd.js";
-import { a as init_tracker_config, n as getLinearApiKey, o as validateRallyConfig, r as getRallyConfig, t as getGitHubConfig } from "./tracker-config-CHbrjg6m.js";
-import { n as init_dist_src, t as Octokit } from "./dist-src-B-AlGWSl.js";
-import { n as mapGitHubStateToCanonical, t as init_state_mapping } from "./state-mapping-BEONzr8P.js";
-import { o as init_io, p as readWorkspacePlan, r as findPlan } from "./io-C0NV7y6C.js";
+import { Sn as resolveProjectFromIssueSync, cn as init_projects, f as loadConfigSync, t as init_config_yaml } from "./config-yaml-BSCqwmX0.js";
+import { n as openDatabase, t as init_driver } from "./driver-CmsY2RLl.js";
+import { g as loadReviewStatusesForIssues, p as init_review_status } from "./review-status-CKLk5aZ-.js";
+import { a as init_tracker_config, n as getLinearApiKey, o as validateRallyConfig, r as getRallyConfig, t as getGitHubConfig } from "./tracker-config-4DaKVTfc.js";
+import { n as init_dist_src, t as Octokit } from "./dist-src-C-Vk2jNk.js";
+import { n as mapGitHubStateToCanonical, t as init_state_mapping } from "./state-mapping-DlM7OYRW.js";
+import { m as readWorkspacePlan, r as findPlan, s as init_io } from "./io-mxOWMZ7I.js";
 import { Effect } from "effect";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -865,7 +865,7 @@ var init_issue_data_service = __esmMin((() => {
 		async ensureShadowStateLoaded() {
 			if (this.shadowStateModule) return;
 			try {
-				this.shadowStateModule = await import("./shadow-state-C0Af4clN.js");
+				this.shadowStateModule = await import("./shadow-state-Bzj_AZCV.js");
 				await this.refreshShadowStatesCache();
 			} catch {}
 		}
@@ -1408,8 +1408,8 @@ var init_issue_data_service = __esmMin((() => {
 			}
 			if (!this.cache.isStale("rally", "issues") && this.trackers.rally.lastFetchedIssues.length > 0) return;
 			try {
-				const { RallyTracker } = await import("./rally-x6ztTQo4.js");
-				const { findProjectsByRallyProject } = await import("./projects-_n3Zui6K.js");
+				const { RallyTracker } = await import("./rally-O_st_X7n.js");
+				const { findProjectsByRallyProject } = await import("./projects-WqMWCdpa.js");
 				const rallyProjects = findProjectsByRallyProject();
 				let allFormatted = [];
 				if (rallyProjects.length > 0) {
@@ -1504,4 +1504,4 @@ var init_issue_service_singleton = __esmMin((() => {
 //#endregion
 export { CacheService as a, startSharedIssueService as i, init_issue_service_singleton as n, init_cache_service as o, issue_service_singleton_exports as r, parseIntegerHeader as s, getSharedIssueService as t };
 
-//# sourceMappingURL=issue-service-singleton-F3A5VP6M.js.map
+//# sourceMappingURL=issue-service-singleton-BPNEXczv.js.map

package/server/{issue-service-singleton-lwFJ4dHk.js → issue-service-singleton-CcaHjKPR.js}

@@ -1,3 +1,3 @@
-import { i as startSharedIssueService, n as init_issue_service_singleton, t as getSharedIssueService } from "./issue-service-singleton-F3A5VP6M.js";
+import { i as startSharedIssueService, n as init_issue_service_singleton, t as getSharedIssueService } from "./issue-service-singleton-BPNEXczv.js";
 init_issue_service_singleton();
 export { getSharedIssueService, startSharedIssueService };

package/server/{issues-DA-U_MpR.js → issues-AX-YBeAQ.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { _ as integer, a as EventBus, c as Records, f as init_infra, h as text, m as sqliteTable, p as init_sqlite_core, r as Db, v as init_drizzle_orm, x as eq } from "./infra-BDQDRopn.js";
+import { _ as integer, a as EventBus, c as Records, f as init_infra, h as text, m as sqliteTable, p as init_sqlite_core, r as Db, v as init_drizzle_orm, x as eq } from "./infra-CTrmVqc_.js";
 import { Context, Effect, Layer, Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 //#region ../../lib/overdeck/issues.ts
@@ -350,4 +350,4 @@ var init_issues = __esmMin((() => {
 //#endregion
 export { init_issues as n, IssueId as t };
 
-//# sourceMappingURL=issues-DA-U_MpR.js.map
+//# sourceMappingURL=issues-AX-YBeAQ.js.map

package/server/{jsonl-parser-BXiGANOh.js → jsonl-parser-CgYWQ20q.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Fr as init_errors, li as init_paths, ti as encodeClaudeProjectDir } from "./config-yaml-CxdwhAIA.js";
-import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-Aat8HfO_.js";
+import { Vr as init_errors, hi as init_paths, si as encodeClaudeProjectDir } from "./config-yaml-BSCqwmX0.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-CpFDrJUS.js";
 import "effect";
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { basename, join } from "path";
@@ -93,6 +93,10 @@ function normalizeModelName(model) {
 		provider: "custom",
 		model
 	};
+	if (model.startsWith("ql-")) return {
+		provider: "custom",
+		model
+	};
 	return {
 		provider: "anthropic",
 		model: "claude-sonnet-4"
@@ -243,4 +247,4 @@ var init_jsonl_parser = __esmMin((() => {
 //#endregion
 export { init_jsonl_parser as a, getSessionFilesSync as i, getAllSessionFilesSync as n, normalizeModelName as o, getProjectDirsSync as r, parseClaudeSessionSync as s, getActiveSessionModelSync as t };
 
-//# sourceMappingURL=jsonl-parser-BXiGANOh.js.map
+//# sourceMappingURL=jsonl-parser-CgYWQ20q.js.map

package/server/kimi-code-BYbme0aV.js

@@ -0,0 +1,579 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { hi as init_paths, mi as getOverdeckHome } from "./config-yaml-BSCqwmX0.js";
+import { n as init_fs_lock, r as isPidDead } from "./fs-lock-D_GeJtXl.js";
+import { c as getRuntimeBehavior } from "./src-BYdwL_n-.js";
+import { Gr as writePtyToken, Kr as init_pty_supervisor_locate, Pr as saveAgentStateSync, Wr as init_pty_token, Zt as init_delivery, br as getAgentStateSync, n as init_queries, qr as resolvePtySupervisorScriptPath, qt as deliverAgentMessage, r as listAgentStates, xr as init_agent_state } from "./queries-DVpl1vsU.js";
+import { t as init_behavior } from "./behavior-DIMQMRzs.js";
+import { C as generateLauncherScriptSync, w as init_launcher_generator } from "./auto-spawn-consent-lXqRJ1Dr.js";
+import { _ as tmuxKillSession, g as tmuxCreateSession, h as init_tmux_cli, v as tmuxSessionExists } from "./codex-CjkD1PJu.js";
+import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-BHxWf_sX.js";
+import { n as parseKimiSessionSync, t as init_kimi_parser } from "./kimi-parser-B-JBg3Pv.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 as stat$1, writeFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+//#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$1(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$1(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$1(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$1(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_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 overdeck 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 overdeck 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-BYbme0aV.js.map

package/server/kimi-code-D_Ppt82c.js

@@ -0,0 +1,3 @@
+import { d as kimiSessionsRoot, g as writeKimiSessionId, h as withKimiSessionCaptureLock, l as init_kimi_code, m as waitForNewKimiSessionAsync, o as findKimiWirePathAsync } from "./kimi-code-BYbme0aV.js";
+init_kimi_code();
+export { findKimiWirePathAsync, kimiSessionsRoot, waitForNewKimiSessionAsync, withKimiSessionCaptureLock, writeKimiSessionId };