@dashup/connector 0.1.18 → 0.1.19

package/dist/index.js

@@ -42,7 +42,7 @@ var require_XMLHttpRequest = __commonJS({
     "use strict";
     var fs = __require("fs");
     var Url = __require("url");
-    var spawn7 = __require("child_process").spawn;
+    var spawn8 = __require("child_process").spawn;
     module.exports = XMLHttpRequest3;
     XMLHttpRequest3.XMLHttpRequest = XMLHttpRequest3;
     function XMLHttpRequest3(opts) {
@@ -338,7 +338,7 @@ var require_XMLHttpRequest = __commonJS({
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
           fs.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-          var syncProc = spawn7(process.argv[0], ["-e", execString]);
+          var syncProc = spawn8(process.argv[0], ["-e", execString]);
           var statusText;
           while (fs.existsSync(syncFile)) {
           }
@@ -2746,7 +2746,7 @@ var HARNESSES = {
   opencode: "OpenCode",
   other: "Agent"
 };
-var isStartHarness = (harness) => harness !== "other" && harness !== "kimi";
+var isStartHarness = (harness) => harness !== "other";
 
 // ../../node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/utils.js
 function isBytes(a) {
@@ -3648,12 +3648,12 @@ function loadConfig() {
     localSecret: ""
   };
 }
-function saveConfig(config2) {
+function saveConfig(config3) {
   const path = configPath();
   mkdirSync(dirname(path), { recursive: true, mode: 448 });
   const file = openSync(path + ".tmp", "w", 384);
   try {
-    writeFileSync(file, JSON.stringify(config2, null, 2));
+    writeFileSync(file, JSON.stringify(config3, null, 2));
     fsyncSync(file);
   } finally {
     closeSync(file);
@@ -3668,13 +3668,13 @@ function saveConfig(config2) {
     }
   }
 }
-async function api(config2, path, body2, method = body2 ? "POST" : "GET") {
+async function api(config3, path, body2, method = body2 ? "POST" : "GET") {
   const bytes = body2 instanceof Uint8Array;
-  const response = await fetch(`${config2.api}/v1${path}`, {
+  const response = await fetch(`${config3.api}/v1${path}`, {
     method,
     headers: {
       "Content-Type": bytes ? "application/octet-stream" : "application/json",
-      Authorization: `Bearer ${config2.secret}`
+      Authorization: `Bearer ${config3.secret}`
     },
     body: bytes ? new Uint8Array(body2) : body2 ? JSON.stringify(body2) : void 0
   });
@@ -3683,8 +3683,8 @@ async function api(config2, path, body2, method = body2 ? "POST" : "GET") {
     throw new Error(value2.error ?? `Dashup request failed (${response.status})`);
   return value2.result;
 }
-function activePair(config2, pair) {
-  return Boolean(!pair.revokedAt && config2.pairs[pair.id] && pair.device === config2.device?.id);
+function activePair(config3, pair) {
+  return Boolean(!pair.revokedAt && config3.pairs[pair.id] && pair.device === config3.device?.id);
 }
 
 // src/acp.ts
@@ -3868,15 +3868,15 @@ function attachAcp(socket, onEvent) {
     }
   });
 }
-async function proxyAcp(config2, executable, args2) {
-  if (!config2.localSecret) throw new Error("Start dashup watch before using the ACP proxy");
+async function proxyAcp(config3, executable, args2) {
+  if (!config3.localSecret) throw new Error("Start dashup watch before using the ACP proxy");
   const socket = await new Promise((resolve3, reject) => {
     const connect3 = request({
       hostname: "127.0.0.1",
       port: connectorPort(),
       method: "CONNECT",
       path: "/acp",
-      headers: { Authorization: `Bearer ${config2.localSecret}` }
+      headers: { Authorization: `Bearer ${config3.localSecret}` }
     });
     connect3.on("connect", (response, stream) => response.statusCode === 200 ? resolve3(stream) : reject(new Error("Dashup ACP connection was rejected")));
     connect3.on("error", reject);
@@ -4048,7 +4048,7 @@ import * as ui from "@clack/prompts";
 import { z } from "zod";
 
 // package.json
-var version = "0.1.18";
+var version = "0.1.19";
 
 // src/pair.ts
 var Invitation = z.object({
@@ -4058,11 +4058,11 @@ var Invitation = z.object({
 }).strict();
 var interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
 var intro2 = () => ui.intro(`Dashup ${version}`);
-function invitation(config2, secret = config2.secret) {
+function invitation(config3, secret = config3.secret) {
   const code = randomBytes2(8).toString("hex");
   const key = newSecret(randomBytes2);
   const computer = createHash2("sha256").update(secret).digest("hex");
-  return { code, key, text: formatPairingCode({ api: config2.api, computer, code, key }) };
+  return { code, key, text: formatPairingCode({ api: config3.api, computer, code, key }) };
 }
 var SCAN = "Scan this in the Dashup app under Pair a computer. It expires in 5 minutes.";
 var BROWSER = {
@@ -4099,7 +4099,7 @@ async function show(text3) {
 `);
   return () => server.close();
 }
-async function scanned(config2, { code, text: text3 }, done, secret = config2.secret) {
+async function scanned(config3, { code, text: text3 }, done, secret = config3.secret) {
   if (interactive) {
     const qr = await QRCode.toString(text3, {
       type: "terminal",
@@ -4118,7 +4118,7 @@ async function scanned(config2, { code, text: text3 }, done, secret = config2.se
   try {
     for (const deadline = Date.now() + PAIRING_TTL_MS; Date.now() < deadline; ) {
       await new Promise((resolve3) => setTimeout(resolve3, 1e3));
-      const response = await fetch(`${config2.api}/v1/dashup/pairings?code=${code}`, {
+      const response = await fetch(`${config3.api}/v1/dashup/pairings?code=${code}`, {
         headers: { Authorization: `Bearer ${secret}` }
       });
       if (response.status === 401 || response.status === 404) continue;
@@ -4140,16 +4140,16 @@ async function scanned(config2, { code, text: text3 }, done, secret = config2.se
   }
 }
 var reported = (error) => error?.reported === true;
-async function link(config2, account) {
+async function link(config3, account) {
   const secret = newSecret(randomBytes2);
-  const invite = invitation(config2, secret);
+  const invite = invitation(config3, secret);
   const { pairing, email } = await scanned(
-    config2,
+    config3,
     invite,
     (account2) => `Scanned by ${account2}`,
     secret
   );
-  const linked = { ...config2, secret };
+  const linked = { ...config3, secret };
   const platform = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux";
   const { device } = await api(linked, "/dashup/devices", {
     id: pairing.device,
@@ -4166,7 +4166,7 @@ async function link(config2, account) {
     );
     return false;
   }
-  Object.assign(config2, {
+  Object.assign(config3, {
     secret,
     device,
     pairs: { [pairing.id]: { key: invite.key, sequence: 0, received: 0 } },
@@ -4174,7 +4174,7 @@ async function link(config2, account) {
     queued: {},
     unconfirmed: {}
   });
-  saveConfig(config2);
+  saveConfig(config3);
   return true;
 }
 
@@ -4188,6 +4188,7 @@ import { watch, existsSync as existsSync3, readdirSync as readdirSync2, readFile
 
 // src/harness/history.ts
 import { homedir as homedir2 } from "node:os";
+import { createHash as createHash3 } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 import { join as join2, dirname as dirname2, resolve as resolve2, isAbsolute } from "node:path";
 import { closeSync as closeSync2, existsSync as existsSync2, openSync as openSync2, readSync, realpathSync, readdirSync, statSync } from "node:fs";
@@ -4435,7 +4436,7 @@ function attachments(id, content) {
     const source = object(part?.source);
     if (source?.type === "base64" && typeof source.data === "string")
       return [attached(key, String(source.media_type), source.data, name)];
-    const url2 = String(part?.image_url ?? part?.url ?? "");
+    const url2 = String(object(part?.image_url)?.url ?? part?.image_url ?? part?.url ?? "");
     const data = DATA_URL.exec(url2);
     return data ? [attached(key, data[1], url2.slice(data[0].length), name)] : [];
   });
@@ -4782,6 +4783,89 @@ function codex(root, scan) {
     }
   }
 }
+var kimiHome = () => process.env.DASHUP_KIMI_HOME ?? join2(homedir2(), ".kimi");
+var KIMI_FAILED = /^<system>ERROR/;
+function kimiMessages(directory2) {
+  const path = join2(directory2, "context.jsonl");
+  const rows = journal(path, true);
+  const results = /* @__PURE__ */ new Map();
+  for (const row of rows) if (row.role === "tool") results.set(row.tool_call_id, row);
+  const messages5 = rows.flatMap((row, index) => {
+    const id = String(index);
+    if (row.role === "user") return injected(row.content) ? [] : prose(id, "user", row.content);
+    if (row.role !== "assistant") return [];
+    return [
+      ...prose(id, "assistant", row.content),
+      ...list(row.tool_calls).map((call, position) => {
+        const result = results.get(call?.id);
+        const output = result && text(result.content);
+        return step(
+          String(call?.id ?? `${id}:${position}`),
+          call?.function?.name,
+          parse(String(call?.function?.arguments ?? "")) ?? call?.function?.arguments,
+          result && {
+            text: output,
+            status: KIMI_FAILED.test(output) ? "error" : "ok",
+            attachments: attachments(String(call?.id), result.content)
+          }
+        );
+      })
+    ];
+  });
+  const shown = windowed(path, messages5);
+  return existsSync2(join2(directory2, "context_1.jsonl")) && shown[0] !== EARLIER ? [EARLIER, ...shown] : shown;
+}
+function kimiSettings(directory2) {
+  const state = existsSync2(join2(directory2, "state.json")) ? jsonFile(join2(directory2, "state.json")) : void 0;
+  return typeof state?.plan_mode === "boolean" ? { plan: state.plan_mode } : {};
+}
+function kimi(root, scan) {
+  const listed = existsSync2(join2(root, "kimi.json")) ? jsonFile(join2(root, "kimi.json")) : void 0;
+  if (listed) scan.paths.add(root);
+  for (const entry of list(listed?.work_dirs)) {
+    const cwd = canonical(entry?.path);
+    if (!cwd) continue;
+    const folder = join2(root, "sessions", createHash3("md5").update(entry.path).digest("hex"));
+    if (!existsSync2(folder)) continue;
+    scan.paths.add(folder);
+    for (const id of readdirSync(folder)) {
+      const directory2 = join2(folder, id);
+      const context = join2(directory2, "context.jsonl");
+      const wire = join2(directory2, "wire.jsonl");
+      if (!existsSync2(context)) continue;
+      scan.paths.add(directory2);
+      try {
+        const state = existsSync2(join2(directory2, "state.json")) ? jsonFile(join2(directory2, "state.json")) : void 0;
+        if (state?.archived === true) continue;
+        const asked = described(
+          context,
+          (row) => row.role === "user",
+          (rows) => text(rows.find((row) => row.role === "user" && !injected(row.content))?.content)
+        );
+        const updated = existsSync2(wire) ? described(
+          wire,
+          (row) => typeof row.timestamp === "number",
+          (rows) => [...rows].reverse().find((row) => typeof row.timestamp === "number")?.timestamp
+        ) : void 0;
+        scan.sessions.push({
+          id,
+          cwd,
+          harness: "kimi",
+          title: title(state?.custom_title || asked, "Kimi thread"),
+          updatedAt: date(
+            typeof updated === "number" ? updated * 1e3 : void 0,
+            statSync(context).mtimeMs
+          ),
+          files: [context, ...existsSync2(wire) ? [wire] : []],
+          read: () => kimiMessages(directory2),
+          settings: () => kimiSettings(directory2)
+        });
+      } catch {
+        scan.warnings.push(`Cannot read Kimi session: ${directory2}`);
+      }
+    }
+  }
+}
 function openCodeChange(state) {
   const metadata2 = object(state.metadata);
   const input = object(state.input);
@@ -4847,8 +4931,8 @@ function databaseMessages(path, session) {
   }
 }
 function codexSubagent(row) {
-  const spawn7 = object(object(parse(String(row.source ?? "")))?.subagent)?.thread_spawn;
-  const task = typeof spawn7?.agent_path === "string" ? spawn7.agent_path.split("/").pop() : "";
+  const spawn8 = object(object(parse(String(row.source ?? "")))?.subagent)?.thread_spawn;
+  const task = typeof spawn8?.agent_path === "string" ? spawn8.agent_path.split("/").pop() : "";
   return [row.agent_nickname, task?.replace(/_/g, " ")].filter(Boolean).join(" \xB7 ");
 }
 var codexState;
@@ -4975,6 +5059,7 @@ function scanHistories() {
   const scan = { sessions: [], paths: /* @__PURE__ */ new Set(), warnings: [] };
   claude(claudeHome(), scan);
   codex(process.env.CODEX_HOME ?? join2(home, ".codex"), scan);
+  kimi(kimiHome(), scan);
   const opencode = join2(process.env.XDG_DATA_HOME ?? join2(home, ".local/share"), "opencode");
   openCodeDatabase(process.env.OPENCODE_DB ?? join2(opencode, "opencode.db"), scan);
   openCodeLegacy(join2(opencode, "storage"), scan);
@@ -5019,6 +5104,7 @@ function vscodeHost(authority) {
     return host;
   }
 }
+var zedData = () => process.env.DASHUP_ZED_DATA ?? dataPaths().zed;
 function dataPaths() {
   const home = homedir3();
   if (process.platform === "darwin")
@@ -5112,7 +5198,7 @@ var Discovery = class {
     this.paths.clear();
     this.warnings.length = 0;
     const defaults = dataPaths();
-    this.zed(process.env.DASHUP_ZED_DATA ?? defaults.zed);
+    this.zed(zedData());
     this.vscode(process.env.DASHUP_VSCODE_DATA ?? defaults.code);
     const history = scanHistories();
     for (const path of history.paths) this.paths.add(path);
@@ -5391,7 +5477,7 @@ var Discovery = class {
 
 // src/connector.ts
 import { z as z2 } from "zod";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { mkdir as mkdir2 } from "node:fs/promises";
 import { randomBytes as randomBytes4 } from "node:crypto";
 
@@ -15427,16 +15513,16 @@ var SocketTransport = class extends import_index2.default {
   helloReady = Promise.resolve();
   /** The token the server validated at the last resolved hello. */
   confirmedHelloToken = null;
-  constructor(config2) {
+  constructor(config3) {
     super();
-    this.url = config2.url;
-    this.version = config2.version ?? "v1";
-    this.getToken = config2.getToken;
-    this.handshakeTimeout = config2.handshakeTimeout ?? DEFAULT_TIMEOUT;
-    const socketPath = config2.path ?? "/ws";
-    const transports2 = config2.transports ?? ["websocket"];
-    const extraHeaders = config2.extraHeaders;
-    const autoConnect = config2.autoConnect ?? true;
+    this.url = config3.url;
+    this.version = config3.version ?? "v1";
+    this.getToken = config3.getToken;
+    this.handshakeTimeout = config3.handshakeTimeout ?? DEFAULT_TIMEOUT;
+    const socketPath = config3.path ?? "/ws";
+    const transports2 = config3.transports ?? ["websocket"];
+    const extraHeaders = config3.extraHeaders;
+    const autoConnect = config3.autoConnect ?? true;
     this.socket = lookup(this.url, {
       path: socketPath,
       transports: transports2,
@@ -15870,14 +15956,14 @@ var SocketTransport = class extends import_index2.default {
     this.connection.disconnected();
   }
 };
-function createClient(config2) {
+function createClient(config3) {
   const transport = new SocketTransport({
-    url: config2.url,
-    version: config2.version ?? "v1",
-    getToken: config2.getToken,
-    transports: config2.transports,
-    extraHeaders: config2.extraHeaders,
-    autoConnect: config2.autoConnect
+    url: config3.url,
+    version: config3.version ?? "v1",
+    getToken: config3.getToken,
+    transports: config3.transports,
+    extraHeaders: config3.extraHeaders,
+    autoConnect: config3.autoConnect
   });
   const adapter = new FrontendAdapter(transport);
   const client = {
@@ -16392,20 +16478,20 @@ function changes(copy2, messages5) {
     return true;
   });
 }
-async function upload(config2, batch) {
+async function upload(config3, batch) {
   if (batch.records.length > HISTORY_BATCH_ITEMS || Buffer.byteLength(JSON.stringify(batch)) > HISTORY_BATCH_BYTES)
     throw new Error("The encrypted history upload exceeds the batch limit");
   try {
-    return await api(config2, HISTORY_PATH, batch);
+    return await api(config3, HISTORY_PATH, batch);
   } catch {
-    return api(config2, HISTORY_PATH, batch);
+    return api(config3, HISTORY_PATH, batch);
   }
 }
-async function publishHistory(config2, pair, project, thread, messages5) {
-  if (!activePair(config2, pair)) throw new Error("Pairing is no longer available");
-  const local = config2.pairs[pair.id];
+async function publishHistory(config3, pair, project, thread, messages5) {
+  if (!activePair(config3, pair)) throw new Error("Pairing is no longer available");
+  const local = config3.pairs[pair.id];
   const generation = ++local.sequence;
-  saveConfig(config2);
+  saveConfig(config3);
   const all = historyMessages(local.key, project, thread.id, messages5);
   let start2 = Math.max(0, all.length - HISTORY_KEPT);
   while (start2 < all.length && (all[start2].part ?? 0) > 0) start2++;
@@ -16439,15 +16525,15 @@ async function publishHistory(config2, pair, project, thread, messages5) {
     );
     const size = Buffer.byteLength(JSON.stringify(record));
     if (batch.records.length && (batch.records.length === HISTORY_BATCH_ITEMS || bytes + size + 1 > HISTORY_BATCH_BYTES)) {
-      await upload(config2, batch);
+      await upload(config3, batch);
       batch.records = [];
       bytes = overhead;
     }
     bytes += size + (batch.records.length ? 1 : 0);
     batch.records.push(record);
   }
-  if (batch.records.length) await upload(config2, batch);
-  const published = await upload(config2, { ...batch, records: [], complete: true });
+  if (batch.records.length) await upload(config3, batch);
+  const published = await upload(config3, { ...batch, records: [], complete: true });
   if (published.generation !== generation || published.total !== summary.total)
     throw new Error("The encrypted history snapshot was not published");
   return summary;
@@ -16484,9 +16570,9 @@ var named = (key, project, thread, attachment) => ({
   ...attachment.name ? { name: attachment.name } : {}
 });
 var readable = (attachment) => "read" in attachment;
-async function shareAttachment(config2, pair, project, thread, messages5, id) {
-  if (!activePair(config2, pair)) throw new Error("Pairing is no longer available");
-  const key = config2.pairs[pair.id].key;
+async function shareAttachment(config3, pair, project, thread, messages5, id) {
+  if (!activePair(config3, pair)) throw new Error("Pairing is no longer available");
+  const key = config3.pairs[pair.id].key;
   const found = messages5.flatMap((message) => {
     const { full, attachments: attachments2 = [] } = kept(message);
     return full ? [full, ...attachments2] : attachments2;
@@ -16495,12 +16581,12 @@ async function shareAttachment(config2, pair, project, thread, messages5, id) {
   if (found.bytes > MAX_ATTACHMENT_BYTES)
     throw new Error("This attachment is too large to open on your phone");
   const sealed = sealAttachment(key, pair.id, id, found.read(), randomBytes3);
-  await api(config2, `${ATTACHMENTS_PATH}/${pair.id}/${id}`, sealed);
+  await api(config3, `${ATTACHMENTS_PATH}/${pair.id}/${id}`, sealed);
 }
 
 // src/harness/live.ts
-import { promisify as promisify5 } from "node:util";
-import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify6 } from "node:util";
+import { execFile as execFile6 } from "node:child_process";
 
 // src/harness/headless.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -17595,16 +17681,362 @@ var Codex = class {
   }
 };
 
+// src/harness/kimi.ts
+import { join as join6 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { createInterface as createInterface4 } from "node:readline";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync3 } from "node:fs";
+import { execFile as execFile3, spawn as spawn4 } from "node:child_process";
+var run = promisify3(execFile3);
+var MAX_REQUESTS3 = 1e3;
+var NOTIFY_MS2 = 100;
+var CHOICES = [
+  { id: "approve", label: "Allow once" },
+  { id: "approve_for_session", label: "Allow for this session" },
+  { id: "reject", label: "Reject", text: true }
+];
+async function kimiCommand() {
+  const shell = process.platform === "win32";
+  if (await run("kimi", ["--version"], { timeout: 1e4, shell }).then(
+    () => true,
+    () => false
+  ))
+    return "kimi";
+  const registry2 = join6(zedData(), "external_agents/registry/kimi");
+  return (existsSync4(registry2) ? readdirSync3(registry2) : []).map((version2) => join6(registry2, version2, shell ? "kimi.exe" : "kimi")).filter((path) => existsSync4(path)).sort((left, right) => statSync3(right).mtimeMs - statSync3(left).mtimeMs)[0];
+}
+function config() {
+  let text3 = "";
+  try {
+    text3 = readFileSync5(join6(kimiHome(), "config.toml"), "utf8");
+  } catch {
+  }
+  const found = { models: [] };
+  let section = "";
+  let model;
+  for (const line of text3.split("\n")) {
+    const header = /^\s*\[(.+)\]\s*$/.exec(line)?.[1];
+    if (header !== void 0) {
+      section = header;
+      const named2 = /^models\."(.+)"$/.exec(header)?.[1];
+      model = named2 ? { value: named2, name: named2, thinking: false } : void 0;
+      if (model) found.models.push(model);
+      continue;
+    }
+    const [, key, value2 = ""] = /^\s*(\w+)\s*=\s*(.+?)\s*$/.exec(line) ?? [];
+    if (model && key === "display_name") model.name = JSON.parse(value2);
+    else if (model && key === "capabilities") model.thinking = value2.includes('"thinking"');
+    else if (!section && key === "default_model") found.model = JSON.parse(value2);
+    else if (!section && key === "default_thinking") found.thinking = value2 === "true";
+  }
+  return found;
+}
+function kimiOptions(recorded) {
+  const { models: models2 } = config();
+  const model = typeof recorded.model === "string" ? recorded.model : void 0;
+  const current = models2.find((item) => item.value === model);
+  const choices = models2.map(({ value: value2, name }) => ({ value: value2, name }));
+  if (model && !current) choices.push({ value: model, name: model });
+  return [
+    ...model ? [{ id: "model", name: "Model", value: model, choices }] : [],
+    ...model && current?.thinking !== false && typeof recorded.thinking === "boolean" ? [{ id: "thinking", name: "Thinking", value: recorded.thinking }] : [],
+    ...typeof recorded.plan === "boolean" ? [{ id: "plan", name: "Plan", value: recorded.plan }] : []
+  ];
+}
+var Session2 = class {
+  constructor(id, cwd, title2, changed) {
+    this.id = id;
+    this.cwd = cwd;
+    this.title = title2;
+    this.changed = changed;
+  }
+  id;
+  cwd;
+  title;
+  changed;
+  messages = [];
+  status = "idle";
+  updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  turn;
+  sequence = 0;
+  // The reply Kimi is writing, as far as it has streamed.
+  typing = "";
+  begun;
+  calls = /* @__PURE__ */ new Map();
+  approvals = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  chosen = {};
+  write(value2) {
+    this.turn?.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", ...value2 })}
+`);
+  }
+  call(method, params) {
+    const id = `dashup-${++this.sequence}`;
+    return new Promise((resolve3, reject) => {
+      this.calls.set(id, { resolve: resolve3, reject });
+      this.write({ id, method, ...params ? { params } : {} });
+    });
+  }
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= MAX_REQUESTS3)
+      throw new Error("Kimi command history is full; restart Dashup before sending");
+    const result = action();
+    this.requests.set(id, result);
+    return result;
+  }
+  // What the session starts with: the person's choice, else Kimi's defaults.
+  launch() {
+    const defaults = config();
+    const model = this.chosen.model ?? defaults.model;
+    const thinking = this.chosen.thinking ?? defaults.thinking;
+    return {
+      ...model === void 0 ? {} : { model },
+      ...thinking === void 0 ? {} : { thinking }
+    };
+  }
+  // Resolves once Kimi begins the turn, or says why it could not. A message while a turn runs is
+  // steered into it.
+  async say(text3) {
+    this.messages.push({ id: randomUUID5(), role: "user", text: text3 });
+    this.typing = "";
+    this.status = "working";
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (this.turn) {
+      await this.call("steer", { user_input: text3 });
+      this.changed();
+      return;
+    }
+    const command2 = await kimiCommand();
+    if (!command2) throw new Error("Kimi is not installed on this computer");
+    const { model, thinking } = this.launch();
+    const turn = this.turn = spawn4(
+      command2,
+      [
+        "--wire",
+        "--work-dir",
+        this.cwd,
+        "--session",
+        this.id,
+        ...typeof model === "string" ? ["--model", model] : [],
+        ...typeof thinking === "boolean" ? [thinking ? "--thinking" : "--no-thinking"] : []
+      ],
+      { cwd: this.cwd, stdio: "pipe", shell: process.platform === "win32" }
+    );
+    let errors = "";
+    turn.stdin.on("error", () => {
+    });
+    turn.stderr.on("data", (chunk) => {
+      errors = (errors + String(chunk)).slice(-2e3);
+    });
+    createInterface4({ input: turn.stdout }).on("line", (line) => this.receive(line));
+    const begun = new Promise((resolve3, reject) => {
+      this.begun = { resolve: resolve3, reject };
+      const end = (reason) => {
+        reject(new Error(reason));
+        if (this.turn !== turn) return;
+        this.turn = void 0;
+        for (const pending of this.calls.values()) pending.reject(new Error(reason));
+        this.calls.clear();
+        this.approvals.clear();
+        this.status = "idle";
+        this.changed();
+      };
+      turn.once("error", () => end("Kimi is not installed on this computer"));
+      turn.once("exit", () => end(errors.trim() || "Kimi stopped before starting"));
+    });
+    await this.call("initialize", {
+      protocol_version: "1.10",
+      client: { name: "dashup", version },
+      capabilities: { supports_question: true, supports_plan_mode: true }
+    });
+    if (typeof this.chosen.plan === "boolean")
+      await this.call("set_plan_mode", { enabled: this.chosen.plan });
+    void this.call("prompt", { user_input: text3 }).catch((error) => {
+      this.begun?.reject(error);
+      this.messages.push({ id: randomUUID5(), role: "system", text: error.message });
+    }).finally(() => turn.stdin.end());
+    this.changed();
+    return begun;
+  }
+  // Handles one line of Kimi's output: the answer to a call, an event, or a request to answer.
+  receive(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (message.id !== void 0 && !message.method) {
+      const pending = this.calls.get(String(message.id));
+      this.calls.delete(String(message.id));
+      if (message.error) pending?.reject(new Error(String(message.error.message ?? "Kimi failed")));
+      else pending?.resolve(message.result ?? {});
+      return;
+    }
+    const type = message.params?.type;
+    const payload = message.params?.payload ?? {};
+    if (message.method === "event") {
+      if (type === "TurnBegin") this.begun?.resolve();
+      else if (type === "ContentPart" && payload.type === "text") {
+        this.typing += String(payload.text ?? "");
+      } else if (type === "TurnEnd") {
+        if (this.typing)
+          this.messages.push({ id: randomUUID5(), role: "assistant", text: this.typing });
+        this.typing = "";
+        this.status = this.approvals.size ? "attention" : "idle";
+      } else return;
+    } else if (message.method === "request" && type === "ApprovalRequest") {
+      const id = randomUUID5();
+      let detail = [payload.description, payload.sender].filter(Boolean).join("\n\n");
+      if (Buffer.byteLength(detail) > MAX_PREVIEW)
+        detail = Buffer.from(detail).subarray(0, MAX_PREVIEW).toString("utf8");
+      this.approvals.set(id, {
+        rpc: message.id,
+        request: payload.id,
+        approval: {
+          id,
+          title: `Allow ${String(payload.action ?? "this")}?`,
+          detail,
+          choices: CHOICES.map((choice) => ({ ...choice }))
+        }
+      });
+      this.status = "attention";
+    } else if (message.method === "request" && type === "QuestionRequest") {
+      const id = randomUUID5();
+      const questions = Array.isArray(payload.questions) ? payload.questions : [];
+      this.approvals.set(id, {
+        rpc: message.id,
+        request: payload.id,
+        questions,
+        approval: questionApproval(id, questions, (item) => item.multi_select === true)
+      });
+      this.status = "attention";
+    } else return;
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.changed();
+  }
+  live() {
+    return {
+      id: this.id,
+      cwd: this.cwd,
+      title: this.title,
+      harness: "kimi",
+      updatedAt: this.updatedAt,
+      status: this.status,
+      messages: [...this.messages],
+      typing: this.typing,
+      approvals: [...this.approvals.values()].map((pending) => pending.approval),
+      send: (requestId, text3) => this.once(requestId, () => this.say(text3)),
+      now: true,
+      stop: this.turn ? (requestId) => this.once(requestId, async () => {
+        await this.call("cancel");
+      }) : void 0,
+      approve: this.approvals.size ? (requestId, approvalId, reply) => this.once(requestId, async () => {
+        const pending = this.approvals.get(approvalId);
+        const choice = "choice" in reply ? reply.choice : void 0;
+        if (!pending || !this.turn) throw new Error("Kimi is no longer asking");
+        if (pending.questions)
+          this.write({
+            id: pending.rpc,
+            result: {
+              request_id: pending.request,
+              answers: Object.fromEntries(
+                "answers" in reply ? pending.questions.map((item, index) => [
+                  item.question,
+                  (reply.answers[index] ?? []).join(", ")
+                ]) : []
+              )
+            }
+          });
+        else if (CHOICES.some((value2) => value2.id === choice))
+          this.write({
+            id: pending.rpc,
+            result: {
+              request_id: pending.request,
+              response: choice,
+              ..."text" in reply && reply.text ? { feedback: reply.text } : {}
+            }
+          });
+        else throw new Error("Kimi is no longer asking");
+        this.approvals.delete(approvalId);
+        if (!this.approvals.size) this.status = "working";
+        this.changed();
+      }) : void 0,
+      options: (recorded) => kimiOptions({ ...recorded, ...this.launch() }),
+      // Plan mode applies to the turn under way; the model and thinking apply as the next starts.
+      configure: (requestId, option2, value2) => this.once(requestId, async () => {
+        this.chosen[option2] = value2;
+        if (option2 === "plan" && this.turn) await this.call("set_plan_mode", { enabled: value2 });
+        this.changed();
+      })
+    };
+  }
+  end() {
+    this.turn?.kill();
+  }
+};
+var Kimi = class {
+  constructor(changed) {
+    this.changed = changed;
+  }
+  changed;
+  sessions = /* @__PURE__ */ new Map();
+  notify;
+  soon = () => {
+    if (this.notify) return;
+    this.notify = setTimeout(() => {
+      this.notify = void 0;
+      this.changed();
+    }, NOTIFY_MS2);
+    this.notify.unref();
+  };
+  // Starts a session in `cwd` with its first message, and resolves with the session's id.
+  async start(cwd, text3) {
+    const title2 = text3.trim().split("\n")[0].slice(0, 80);
+    const session = new Session2(randomUUID5(), cwd, title2, this.soon);
+    this.sessions.set(session.id, session);
+    try {
+      await session.say(text3);
+    } catch (error) {
+      this.sessions.delete(session.id);
+      throw error;
+    }
+    return session.id;
+  }
+  // Continues a saved session with a message; Kimi resumes it from its own session folder.
+  async resume(id, cwd, text3) {
+    const known = this.sessions.get(id);
+    const session = known ?? new Session2(id, cwd, void 0, this.soon);
+    this.sessions.set(id, session);
+    try {
+      await session.say(text3);
+    } catch (error) {
+      if (!known) this.sessions.delete(id);
+      throw error;
+    }
+  }
+  async refresh() {
+    return [...this.sessions.values()].map((session) => session.live());
+  }
+  stop() {
+    clearTimeout(this.notify);
+    for (const session of this.sessions.values()) session.end();
+  }
+};
+
 // src/harness/vscode.ts
 import Socket3 from "ws";
 import { homedir as homedir6 } from "node:os";
 import { connect as connect2 } from "node:net";
-import { promisify as promisify3 } from "node:util";
+import { promisify as promisify4 } from "node:util";
 import { fileURLToPath } from "node:url";
-import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash3, randomUUID as randomUUID5 } from "node:crypto";
+import { execFile as execFile4 } from "node:child_process";
+import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
 import { stat as stat2, readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
-import { join as join6, dirname as dirname5, basename as basename3, isAbsolute as isAbsolute3 } from "node:path";
+import { join as join7, dirname as dirname5, basename as basename3, isAbsolute as isAbsolute3 } from "node:path";
 import { WebSocketTransport } from "@microsoft/agent-host-protocol/ws";
 import { AhpClient } from "@microsoft/agent-host-protocol/client";
 import { chatReducer, sessionReducer, SUPPORTED_PROTOCOL_VERSIONS } from "@microsoft/agent-host-protocol";
@@ -17614,7 +18046,7 @@ var MAX_METADATA = 64 * 1024;
 var MAX_HOSTS = 16;
 var MAX_SESSIONS3 = 100;
 var ROOT_CHANNEL = "ahp-root://";
-var run = promisify3(execFile3);
+var run2 = promisify4(execFile4);
 var CONFIRMATION_CHOICES = [
   { id: "approve", label: "Allow once", kind: "approve" },
   { id: "deny", label: "Reject", kind: "deny" }
@@ -17624,8 +18056,8 @@ function roots() {
   if (override !== void 0)
     return override ? [basename3(override) === "User" ? dirname5(override) : override] : [];
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
-  const base = process.platform === "darwin" ? join6(homedir6(), "Library/Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join6(homedir6(), "AppData/Roaming") : process.env.XDG_CONFIG_HOME ?? join6(homedir6(), ".config");
-  return ["Code", "Code - Insiders"].map((name) => join6(base, name));
+  const base = process.platform === "darwin" ? join7(homedir6(), "Library/Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join7(homedir6(), "AppData/Roaming") : process.env.XDG_CONFIG_HOME ?? join7(homedir6(), ".config");
+  return ["Code", "Code - Insiders"].map((name) => join7(base, name));
 }
 async function privateFile(path, limit) {
   const file = await stat2(path).catch(() => void 0);
@@ -17634,7 +18066,7 @@ async function privateFile(path, limit) {
     const encodedPath = Buffer.from(path).toString("base64");
     const script = `$p=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedPath}')); $a=Get-Acl -LiteralPath $p -ErrorAction Stop; $sid=[Security.Principal.SecurityIdentifier]; $me=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value; $ok=$a.GetOwner($sid).Value -eq $me; foreach($r in $a.Access){if($r.AccessControlType -eq 'Allow' -and $r.IdentityReference.Translate($sid).Value -notin @($me,'S-1-5-18','S-1-5-32-544')){$ok=$false}}; $ok`;
     try {
-      const { stdout } = await run(
+      const { stdout } = await run2(
         "powershell.exe",
         [
           "-NoProfile",
@@ -17654,11 +18086,11 @@ async function privateFile(path, limit) {
 async function entries() {
   const result = /* @__PURE__ */ new Map();
   for (const root of roots()) {
-    const registry2 = join6(root, "agent-host/local-endpoint");
-    const files2 = (await readdir3(join6(registry2, "entries")).catch(() => [])).filter((name) => name.endsWith(".json")).slice(0, MAX_HOSTS);
+    const registry2 = join7(root, "agent-host/local-endpoint");
+    const files2 = (await readdir3(join7(registry2, "entries")).catch(() => [])).filter((name) => name.endsWith(".json")).slice(0, MAX_HOSTS);
     const sources = [
-      ...files2.map((name) => join6(registry2, "entries", name)),
-      join6(registry2, "metadata.json")
+      ...files2.map((name) => join7(registry2, "entries", name)),
+      join7(registry2, "metadata.json")
     ];
     for (const path of sources) {
       try {
@@ -17668,7 +18100,7 @@ async function entries() {
         for (const row of rows.slice(0, MAX_HOSTS)) {
           if (row?.schemaVersion !== 2 || !["editor", "standalone"].includes(row.type) || !Number.isSafeInteger(row.pid) || row.pid <= 0 || typeof row.instanceId !== "string" || !row.instanceId || typeof row.connectionToken !== "string" || !row.connectionToken || row.connectionToken.length > 1024 || row.endpoint?.type !== "socket" || typeof row.endpoint.path !== "string" || !isAbsolute3(row.endpoint.path))
             continue;
-          const identity2 = createHash3("sha256").update(`${row.type}\0${row.pid}\0${row.instanceId}`).digest("hex");
+          const identity2 = createHash4("sha256").update(`${row.type}\0${row.pid}\0${row.instanceId}`).digest("hex");
           if (basename3(path) !== "metadata.json" && basename3(path) !== `${identity2}.json`) continue;
           try {
             process.kill(row.pid, 0);
@@ -17795,7 +18227,7 @@ var Host = class {
   client;
   connecting;
   stopped = false;
-  clientId = `dashup-${randomUUID5()}`;
+  clientId = `dashup-${randomUUID6()}`;
   resources = /* @__PURE__ */ new Map();
   subscriptions = /* @__PURE__ */ new Set();
   receipts = /* @__PURE__ */ new Map();
@@ -17984,7 +18416,7 @@ var Host = class {
               choices: preview3.choices.map(({ id: id2, label }) => ({ id: id2, label }))
             });
           }
-          const id = `vscode-ahp:${createHash3("sha256").update(this.entry.root).digest("hex").slice(0, 16)}:${item.resource}`;
+          const id = `vscode-ahp:${createHash4("sha256").update(this.entry.root).digest("hex").slice(0, 16)}:${item.resource}`;
           result.push({
             id,
             cwd,
@@ -18095,12 +18527,12 @@ var VSCode = class {
 };
 
 // src/harness/opencode.ts
-import { join as join7 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-import { createHash as createHash4 } from "node:crypto";
-import { execFile as execFile4, spawn as spawn4 } from "node:child_process";
+import { join as join8 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+import { createHash as createHash5 } from "node:crypto";
+import { execFile as execFile5, spawn as spawn5 } from "node:child_process";
 import { stat as stat3, readlink as readlink2, readdir as readdir4, readFile as readFile4 } from "node:fs/promises";
-var run2 = promisify4(execFile4);
+var run3 = promisify5(execFile5);
 var REQUEST_MS3 = 4e3;
 var MAX_BYTES3 = 8 * 1024 * 1024;
 var MAX_SESSIONS4 = 100;
@@ -18145,16 +18577,16 @@ async function linuxEndpoints() {
       const directory2 = `/proc/${pid}`;
       const owner = await stat3(directory2);
       if (process.getuid && owner.uid !== process.getuid()) continue;
-      const command2 = (await readFile4(join7(directory2, "cmdline"), "utf8")).slice(0, 4096);
+      const command2 = (await readFile4(join8(directory2, "cmdline"), "utf8")).slice(0, 4096);
       if (!/(?:^|[\/\0 ])opencode(?:[\0 .]|$)/.test(command2)) continue;
       const environment = Object.fromEntries(
-        (await readFile4(join7(directory2, "environ"), "utf8")).split("\0").map((entry) => {
+        (await readFile4(join8(directory2, "environ"), "utf8")).split("\0").map((entry) => {
           const split = entry.indexOf("=");
           return [entry.slice(0, split), entry.slice(split + 1)];
         })
       );
-      for (const fd of (await readdir4(join7(directory2, "fd"))).slice(0, 1024)) {
-        const target = await readlink2(join7(directory2, "fd", fd)).catch(() => "");
+      for (const fd of (await readdir4(join8(directory2, "fd"))).slice(0, 1024)) {
+        const target = await readlink2(join8(directory2, "fd", fd)).catch(() => "");
         const inode = /^socket:\[(\d+)\]$/.exec(target)?.[1];
         const url2 = inode ? listeners.get(inode) : void 0;
         if (url2) result.push({ url: url2, authorization: authorization(environment) });
@@ -18180,7 +18612,7 @@ async function endpoints() {
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
   if (process.platform === "linux") return linuxEndpoints();
   if (process.platform === "darwin") {
-    const { stdout } = await run2(
+    const { stdout } = await run3(
       "lsof",
       ["-nP", "-a", "-c", "opencode", "-iTCP", "-sTCP:LISTEN", "-Fn"],
       { timeout: REQUEST_MS3, maxBuffer: MAX_BYTES3 }
@@ -18197,7 +18629,7 @@ async function endpoints() {
   }
   if (process.platform === "win32") {
     const script = "$ids = @(Get-Process opencode -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id); Get-NetTCPConnection -State Listen -ErrorAction SilentlyContinue | Where-Object { $ids -contains $_.OwningProcess } | Select-Object -ExpandProperty LocalPort";
-    const { stdout } = await run2(
+    const { stdout } = await run3(
       "powershell.exe",
       ["-NoProfile", "-NonInteractive", "-Command", script],
       { timeout: REQUEST_MS3, maxBuffer: MAX_BYTES3 }
@@ -18478,7 +18910,7 @@ var Server = class {
             if (this.stopped) throw new Error("OpenCode is disconnected");
             if (!text3.trim() || Buffer.byteLength(text3) > MAX_BYTES3 / 2)
               throw new Error("Message is empty or too large");
-            const messageID = `msg_${createHash4("sha256").update(requestId).digest("hex").slice(0, 32)}`;
+            const messageID = `msg_${createHash5("sha256").update(requestId).digest("hex").slice(0, 32)}`;
             const existing = await this.request(
               `/session/${encodeURIComponent(id)}/message?limit=200`,
               cwd
@@ -18622,7 +19054,7 @@ var Server = class {
   }
 };
 function serve(cwd) {
-  const child = spawn4("opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0"], {
+  const child = spawn5("opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0"], {
     cwd,
     stdio: ["ignore", "pipe", "ignore"],
     shell: process.platform === "win32"
@@ -18710,6 +19142,7 @@ var LiveHarnesses = class {
   listeners = /* @__PURE__ */ new Set();
   codex = new Codex(() => this.changed());
   headless = new Headless(() => this.changed());
+  kimi = new Kimi(() => this.changed());
   claude = new Claude(() => this.changed());
   vscode = new VSCode(() => this.changed());
   opencode = new OpenCode(() => this.changed());
@@ -18725,6 +19158,7 @@ var LiveHarnesses = class {
     this.refreshing = (async () => {
       const results = await Promise.allSettled([
         this.headless.refresh(),
+        this.kimi.refresh(),
         this.opencode.refresh(),
         this.codex.refresh(),
         this.claude.refresh(),
@@ -18747,14 +19181,16 @@ var LiveHarnesses = class {
   recorded(harness, settings) {
     const changed = () => this.changed();
     if (harness === "claude") return claudeOptions(claudeModels(changed), settings);
+    if (harness === "kimi") return kimiOptions(settings);
     return harness === "codex" ? codexOptions(settings) : [];
   }
   // The agents whose own command runs on this computer. Claude Code is asked its models again.
   async agents() {
     const harnesses = ["claude", "codex", "opencode"];
+    const kimi2 = kimiCommand();
     forgetModels();
     const runs = await Promise.all(
-      harnesses.map((harness) => promisify5(execFile5)(harness, ["--version"], {
+      harnesses.map((harness) => promisify6(execFile6)(harness, ["--version"], {
         timeout: 1e4,
         shell: process.platform === "win32"
       }).then(
@@ -18762,22 +19198,22 @@ var LiveHarnesses = class {
         () => false
       ))
     );
-    return harnesses.filter((_, index) => runs[index]);
+    return [
+      ...harnesses.filter((_, index) => runs[index]),
+      ...await kimi2 ? ["kimi"] : []
+    ];
+  }
+  // The harness that starts and resumes each agent's sessions.
+  host(harness) {
+    return { claude: this.headless, codex: this.codex, kimi: this.kimi, opencode: this.opencode }[harness];
   }
   // Starts a session in `cwd` with its first message, and resolves with the session's native id.
   start(harness, cwd, text3) {
-    return { claude: this.headless, codex: this.codex, opencode: this.opencode }[harness].start(
-      cwd,
-      text3
-    );
+    return this.host(harness).start(cwd, text3);
   }
   // Continues a saved session with a message, and resolves once its agent takes it.
   resume(harness, id, cwd, text3) {
-    return { claude: this.headless, codex: this.codex, opencode: this.opencode }[harness].resume(
-      id,
-      cwd,
-      text3
-    );
+    return this.host(harness).resume(id, cwd, text3);
   }
   watch(onChange) {
     this.listeners.add(onChange);
@@ -18802,6 +19238,7 @@ var LiveHarnesses = class {
     clearInterval(this.timer);
     this.listeners.clear();
     this.headless.stop();
+    this.kimi.stop();
     this.opencode.stop();
     this.codex.stop();
     this.claude.stop();
@@ -18810,11 +19247,11 @@ var LiveHarnesses = class {
 };
 
 // src/harness/queue.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { spawn as spawn5 } from "node:child_process";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { spawn as spawn6 } from "node:child_process";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
-import { join as join8, dirname as dirname6, basename as basename4 } from "node:path";
-import { statSync as statSync3, existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
+import { join as join9, dirname as dirname6, basename as basename4 } from "node:path";
+import { statSync as statSync4, existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
 var CODEX_VERSION = "0.160.1";
 var REQUEST_MS4 = 1e4;
 var MAX_BYTES4 = 1024 * 1024;
@@ -18823,7 +19260,7 @@ var MAX_FILES = 4096;
 var THREAD_ID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
 function identity(path) {
   const canonical2 = realpathSync2.native(path);
-  const file = statSync3(canonical2);
+  const file = statSync4(canonical2);
   if (!file.isFile() || process.getuid && file.uid !== process.getuid())
     throw new Error("Native queue files are not owned by this user");
   return { path: canonical2, device: file.dev, inode: file.ino };
@@ -18834,25 +19271,25 @@ function sameFile(left, right) {
 function packageVersion(executable) {
   let directory2 = dirname6(executable);
   for (let depth = 0; depth < 8; depth++, directory2 = dirname6(directory2)) {
-    const path = join8(directory2, "package.json");
-    if (!existsSync4(path)) continue;
-    const value2 = JSON.parse(readFileSync5(path, "utf8"));
+    const path = join9(directory2, "package.json");
+    if (!existsSync5(path)) continue;
+    const value2 = JSON.parse(readFileSync6(path, "utf8"));
     if (value2.name?.startsWith("@openai/codex-")) return value2.version;
   }
   return void 0;
 }
 function processOwners(pid) {
   const root = `/proc/${pid}`;
-  if (process.getuid && statSync3(root).uid !== process.getuid()) return [];
-  const executable = realpathSync2.native(join8(root, "exe"));
+  if (process.getuid && statSync4(root).uid !== process.getuid()) return [];
+  const executable = realpathSync2.native(join9(root, "exe"));
   if (basename4(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
-  const status2 = readFileSync5(join8(root, "stat"), "utf8");
+  const status2 = readFileSync6(join9(root, "stat"), "utf8");
   const start2 = status2.slice(status2.lastIndexOf(")") + 2).split(" ")[19];
   if (!start2 || !/^\d+$/.test(start2)) return [];
-  const fds = readdirSync3(join8(root, "fd")).slice(0, MAX_FILES);
+  const fds = readdirSync4(join9(root, "fd")).slice(0, MAX_FILES);
   const files2 = fds.flatMap((fd) => {
     try {
-      return [{ fd, path: readlinkSync(join8(root, "fd", fd)) }];
+      return [{ fd, path: readlinkSync(join9(root, "fd", fd)) }];
     } catch {
       return [];
     }
@@ -18862,22 +19299,22 @@ function processOwners(pid) {
     const thread = basename4(path, ".lock");
     if (!THREAD_ID.test(thread)) return [];
     try {
-      const lock = readFileSync5(join8(root, "fdinfo", fd), "utf8");
+      const lock = readFileSync6(join9(root, "fdinfo", fd), "utf8");
       if (!/FLOCK\s+ADVISORY\s+WRITE/.test(lock)) return [];
       const home = realpathSync2.native(dirname6(dirname6(path)));
-      const directory2 = statSync3(home);
+      const directory2 = statSync4(home);
       if (process.getuid && directory2.uid !== process.getuid()) return [];
-      const queue = identity(join8(home, "queue_1.sqlite"));
+      const queue = identity(join9(home, "queue_1.sqlite"));
       if (!files2.some((file) => {
         try {
-          return sameFile(identity(join8(root, "fd", file.fd)), queue);
+          return sameFile(identity(join9(root, "fd", file.fd)), queue);
         } catch {
           return false;
         }
       }))
         return [];
       const rollout = files2.find(
-        (file) => file.path.startsWith(join8(home, "sessions") + "/") && file.path.endsWith(`-${thread}.jsonl`)
+        (file) => file.path.startsWith(join9(home, "sessions") + "/") && file.path.endsWith(`-${thread}.jsonl`)
       );
       if (!rollout) return [];
       return [
@@ -18889,7 +19326,7 @@ function processOwners(pid) {
           thread,
           queue,
           version: CODEX_VERSION,
-          cwd: realpathSync2.native(join8(root, "cwd")),
+          cwd: realpathSync2.native(join9(root, "cwd")),
           rollout: identity(rollout.path)
         }
       ];
@@ -18901,7 +19338,7 @@ function processOwners(pid) {
 function queueOwners() {
   if (process.platform !== "linux" || process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
   try {
-    return readdirSync3("/proc").filter((value2) => /^\d+$/.test(value2)).slice(0, MAX_PROCESSES3).flatMap((value2) => {
+    return readdirSync4("/proc").filter((value2) => /^\d+$/.test(value2)).slice(0, MAX_PROCESSES3).flatMap((value2) => {
       try {
         return processOwners(Number(value2));
       } catch {
@@ -18933,10 +19370,10 @@ function validateOwner(owner) {
     throw new Error("The original native conversation owner is no longer available");
 }
 function validateEvidence(owner) {
-  if (realpathSync2.native(owner.home) !== owner.home || process.getuid && statSync3(owner.home).uid !== process.getuid() || !sameFile(identity(owner.queue.path), owner.queue) || !sameFile(identity(owner.rollout.path), owner.rollout))
+  if (realpathSync2.native(owner.home) !== owner.home || process.getuid && statSync4(owner.home).uid !== process.getuid() || !sameFile(identity(owner.queue.path), owner.queue) || !sameFile(identity(owner.rollout.path), owner.rollout))
     throw new Error("The original native history storage changed");
-  const path = join8(owner.home, "thread_history_1.sqlite");
-  if (existsSync4(path) && identity(path).path !== path)
+  const path = join9(owner.home, "thread_history_1.sqlite");
+  if (existsSync5(path) && identity(path).path !== path)
     throw new Error("Native history is outside the original home");
 }
 function nativeReceipt(owner, clientId) {
@@ -18952,8 +19389,8 @@ function nativeReceipt(owner, clientId) {
   } finally {
     queue.close();
   }
-  const path = join8(owner.home, "thread_history_1.sqlite");
-  if (!existsSync4(path)) return { queueId };
+  const path = join9(owner.home, "thread_history_1.sqlite");
+  if (!existsSync5(path)) return { queueId };
   const history = new DatabaseSync3(path, { readOnly: true });
   try {
     const rows = history.prepare(
@@ -19008,7 +19445,7 @@ var Writer = class {
   tail = "";
   pending = /* @__PURE__ */ new Map();
   constructor(owner) {
-    this.process = spawn5(owner.executable, ["app-server", "--listen", "stdio://"], {
+    this.process = spawn6(owner.executable, ["app-server", "--listen", "stdio://"], {
       cwd: owner.cwd,
       env: { ...process.env, CODEX_HOME: owner.home },
       stdio: ["pipe", "pipe", "ignore"]
@@ -19095,7 +19532,7 @@ var NativeQueue = class {
     if (existing) return existing;
     if (this.stopped) throw new Error("The connector is stopping");
     validateOwner(scope2.owner);
-    const clientUserMessageId = randomUUID6();
+    const clientUserMessageId = randomUUID7();
     const request2 = { ...scope2, receipt: { state: "unknown", clientUserMessageId } };
     let writer;
     try {
@@ -19203,32 +19640,32 @@ var Command = z2.object({
     z2.object({ kind: z2.literal("attachment.read"), id: z2.string().regex(/^[a-f0-9]{64}$/) }).strict(),
     z2.object({
       kind: z2.literal("session.start"),
-      harness: z2.enum(["claude", "codex", "opencode"]),
+      harness: z2.enum(["claude", "codex", "kimi", "opencode"]),
       text: z2.string().min(1).max(1e5),
       folder: z2.object({ parent: z2.string().min(1), name: z2.string().min(1).max(255) }).strict().optional()
     }).strict()
   ])
 }).strict();
 var Connector = class {
-  constructor(config2) {
-    this.config = config2;
-    config2.unconfirmed ??= {};
-    config2.queued ??= {};
+  constructor(config3) {
+    this.config = config3;
+    config3.unconfirmed ??= {};
+    config3.queued ??= {};
     this.nativeQueue = new NativeQueue(
-      config2.queued,
-      () => saveConfig(config2),
+      config3.queued,
+      () => saveConfig(config3),
       (request2) => this.isActive(request2.pairing)
     );
-    if (!config2.device || !config2.secret) throw new Error("Pair this computer with dashup pair first");
+    if (!config3.device || !config3.secret) throw new Error("Pair this computer with dashup pair first");
     this.client = createClient({
-      url: config2.api,
-      getToken: async () => config2.secret,
+      url: config3.api,
+      getToken: async () => config3.secret,
       autoConnect: false
     });
     provideClient(() => this.client);
-    this.discovery = new Discovery(config2.device.id, config2.localSecret);
-    this.pairings = createLiveQuery(() => this.client.bind(Pairing).where({ device: config2.device.id }).whereNull("revokedAt").clearLimit());
-    this.relays = createLiveQuery(() => this.client.bind(Relay).where({ recipient: config2.device.id }).orderBy("createdAt", "desc").orderBy("id", "desc").clearLimit());
+    this.discovery = new Discovery(config3.device.id, config3.localSecret);
+    this.pairings = createLiveQuery(() => this.client.bind(Pairing).where({ device: config3.device.id }).whereNull("revokedAt").clearLimit());
+    this.relays = createLiveQuery(() => this.client.bind(Relay).where({ recipient: config3.device.id }).orderBy("createdAt", "desc").orderBy("id", "desc").clearLimit());
   }
   config;
   client;
@@ -19426,7 +19863,7 @@ var Connector = class {
     saveConfig(this.config);
   }
   flush() {
-    const run4 = this.drain.catch(() => {
+    const run5 = this.drain.catch(() => {
     }).then(async () => {
       this.discardLegacySnapshots();
       while (this.config.outbox.length && this.client.isConnected) {
@@ -19436,8 +19873,8 @@ var Connector = class {
         saveConfig(this.config);
       }
     });
-    this.drain = run4;
-    return run4.catch((error) => {
+    this.drain = run5;
+    return run5.catch((error) => {
       this.report(error);
       clearTimeout(this.retry);
       this.retry = setTimeout(() => {
@@ -19511,13 +19948,13 @@ var Connector = class {
   // transcript costs one rescan rather than one each.
   queueChange() {
     if (this.pendingChange) return this.pendingChange;
-    const run4 = this.work.then(() => {
+    const run5 = this.work.then(() => {
       this.pendingChange = void 0;
       return this.changed();
     });
-    this.pendingChange = run4;
-    this.work = run4.catch((error) => this.report(error));
-    return run4;
+    this.pendingChange = run5;
+    this.work = run5.catch((error) => this.report(error));
+    return run5;
   }
   async changed() {
     if (this.stopped) return;
@@ -20001,7 +20438,7 @@ var Connector = class {
         throw new Error("That folder is no longer offered for new projects");
       if (!name || name === "." || name === ".." || /[\\/:*?"<>|\x00-\x1f]/.test(name))
         throw new Error("Name the folder without slashes or special characters");
-      cwd = join9(folder.parent, name);
+      cwd = join10(folder.parent, name);
       await mkdir2(cwd).catch((error) => {
         throw new Error(error.code === "EEXIST" ? `${name} already exists` : `Couldn't create ${name}`);
       });
@@ -20027,32 +20464,32 @@ var Connector = class {
 };
 
 // src/install.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { homedir as homedir7, userInfo } from "node:os";
-import { promisify as promisify6 } from "node:util";
+import { promisify as promisify7 } from "node:util";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { execFile as execFile6, spawn as spawn6 } from "node:child_process";
+import { execFile as execFile7, spawn as spawn7 } from "node:child_process";
 import { cp, mkdir as mkdir3, rm as rm2, writeFile } from "node:fs/promises";
-import { dirname as dirname7, join as join10, relative, sep } from "node:path";
-var run3 = promisify6(execFile6);
+import { dirname as dirname7, join as join11, relative, sep } from "node:path";
+var run4 = promisify7(execFile7);
 var xml = (value2) => value2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var NODE_FLAGS = ["--disable-warning=ExperimentalWarning"];
-var systemctl = (...args2) => run3("systemctl", ["--user", ...args2], {
+var systemctl = (...args2) => run4("systemctl", ["--user", ...args2], {
   env: { ...process.env, XDG_RUNTIME_DIR: process.env.XDG_RUNTIME_DIR ?? `/run/user/${userInfo().uid}` }
 });
-var serviceFile = () => process.platform === "darwin" ? join10(homedir7(), "Library/LaunchAgents/com.dashup.connector.plist") : process.platform === "win32" ? join10(
-  process.env.APPDATA ?? join10(homedir7(), "AppData/Roaming"),
+var serviceFile = () => process.platform === "darwin" ? join11(homedir7(), "Library/LaunchAgents/com.dashup.connector.plist") : process.platform === "win32" ? join11(
+  process.env.APPDATA ?? join11(homedir7(), "AppData/Roaming"),
   "Microsoft/Windows/Start Menu/Programs/Startup/Dashup.vbs"
-) : join10(homedir7(), ".config/systemd/user/dashup.service");
-var startupInstalled = () => existsSync5(serviceFile());
-function service(platform, node, entry, config2) {
+) : join11(homedir7(), ".config/systemd/user/dashup.service");
+var startupInstalled = () => existsSync6(serviceFile());
+function service(platform, node, entry, config3) {
   const command2 = [node, ...NODE_FLAGS, entry];
   if (platform === "darwin")
-    return `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>Label</key><string>com.dashup.connector</string><key>EnvironmentVariables</key><dict><key>DASHUP_CONFIG</key><string>${xml(config2)}</string></dict><key>ProgramArguments</key><array>${[...command2, "watch"].map((value2) => `<string>${xml(value2)}</string>`).join("")}</array><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict></dict></plist>`;
+    return `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>Label</key><string>com.dashup.connector</string><key>EnvironmentVariables</key><dict><key>DASHUP_CONFIG</key><string>${xml(config3)}</string></dict><key>ProgramArguments</key><array>${[...command2, "watch"].map((value2) => `<string>${xml(value2)}</string>`).join("")}</array><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict></dict></plist>`;
   if (platform === "win32") {
     const quote2 = (value2) => '""' + value2.replaceAll('"', '""') + '""';
     return `Set shell = CreateObject("WScript.Shell")\r
-shell.Environment("Process")("DASHUP_CONFIG") = "${config2.replaceAll('"', '""')}"\r
+shell.Environment("Process")("DASHUP_CONFIG") = "${config3.replaceAll('"', '""')}"\r
 shell.Run "${command2.map(quote2).join(" ")} watch", 0, False\r
 `;
   }
@@ -20062,7 +20499,7 @@ Description=Dashup desktop connector
 After=network-online.target
 
 [Service]
-Environment=${quote(`DASHUP_CONFIG=${config2}`)}
+Environment=${quote(`DASHUP_CONFIG=${config3}`)}
 ExecStart=${command2.map(quote).join(" ")} watch
 Restart=on-failure
 RestartSec=5
@@ -20079,19 +20516,19 @@ async function durableEntry() {
     );
   if (!["_npx", "dlx"].some((cache2) => entry.includes(`${sep}${cache2}${sep}`))) return entry;
   const root = entry.slice(0, entry.indexOf(`${sep}node_modules${sep}`));
-  const app = join10(dirname7(configPath()), "app");
+  const app = join11(dirname7(configPath()), "app");
   await rm2(app, { recursive: true, force: true });
-  await cp(join10(root, "node_modules"), join10(app, "node_modules"), {
+  await cp(join11(root, "node_modules"), join11(app, "node_modules"), {
     recursive: true,
     verbatimSymlinks: true
   });
-  return join10(app, relative(root, entry));
+  return join11(app, relative(root, entry));
 }
-var claude2 = (...args2) => run3("claude", ["plugin", ...args2], { timeout: 6e4 });
+var claude2 = (...args2) => run4("claude", ["plugin", ...args2], { timeout: 6e4 });
 async function installClaude(entry) {
   if (process.platform === "win32") return false;
   try {
-    await claude2("marketplace", "add", join10(dirname7(entry), "..", "claude"));
+    await claude2("marketplace", "add", join11(dirname7(entry), "..", "claude"));
     await claude2("install", "dashup@dashup", "--scope", "user");
     return true;
   } catch {
@@ -20108,13 +20545,13 @@ async function installStartup() {
 }
 async function start(path) {
   if (process.platform === "darwin") {
-    await run3("launchctl", ["unload", path]).catch(() => {
+    await run4("launchctl", ["unload", path]).catch(() => {
     });
-    await run3("launchctl", ["load", path]);
+    await run4("launchctl", ["load", path]);
   } else if (process.platform === "win32") {
-    spawn6("wscript.exe", [path], { detached: true, stdio: "ignore" }).unref();
+    spawn7("wscript.exe", [path], { detached: true, stdio: "ignore" }).unref();
   } else {
-    const note = process.env.DISPLAY || process.env.WAYLAND_DISPLAY ? void 0 : await run3("loginctl", ["enable-linger"]).then(
+    const note = process.env.DISPLAY || process.env.WAYLAND_DISPLAY ? void 0 : await run4("loginctl", ["enable-linger"]).then(
       () => void 0,
       () => `It stops when you log out. To keep it running, run sudo loginctl enable-linger ${userInfo().username}.`
     );
@@ -20130,17 +20567,17 @@ async function uninstallStartup() {
   });
   await claude2("marketplace", "remove", "dashup").catch(() => {
   });
-  if (process.platform === "darwin") await run3("launchctl", ["unload", path]).catch(() => {
+  if (process.platform === "darwin") await run4("launchctl", ["unload", path]).catch(() => {
   });
   else if (process.platform !== "win32")
     await systemctl("disable", "dashup.service").catch(() => {
     });
   await rm2(path, { force: true });
-  await rm2(join10(dirname7(configPath()), "app"), { recursive: true, force: true });
+  await rm2(join11(dirname7(configPath()), "app"), { recursive: true, force: true });
 }
 
 // src/index.ts
-var config = loadConfig();
+var config2 = loadConfig();
 var args = process.argv.slice(2);
 var command = args[0] ?? "watch";
 var option = (name) => {
@@ -20149,7 +20586,7 @@ var option = (name) => {
 };
 var running = (path, init) => fetch(`http://127.0.0.1:${connectorPort()}${path}`, {
   ...init,
-  headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.localSecret}` }
+  headers: { "Content-Type": "application/json", Authorization: `Bearer ${config2.localSecret}` }
 });
 var refused = (error) => {
   if (error.cause?.code === "ECONNREFUSED") return null;
@@ -20192,7 +20629,7 @@ async function background() {
   return false;
 }
 var authorized = (request2) => {
-  const expected = Buffer.from(`Bearer ${config.localSecret}`);
+  const expected = Buffer.from(`Bearer ${config2.localSecret}`);
   const actual = Buffer.from(request2.headers.authorization ?? "");
   return expected.length === actual.length && timingSafeEqual(expected, actual);
 };
@@ -20210,15 +20647,15 @@ async function main() {
       throw new Error("Use an HTTPS API origin");
     if (url2.username || url2.password || url2.search || url2.hash || url2.pathname !== "/")
       throw new Error("Use the API origin without a path");
-    if (config.secret && config.api !== url2.origin)
+    if (config2.secret && config2.api !== url2.origin)
       throw new Error("Use a separate DASHUP_CONFIG file to connect a different server");
-    config.api = url2.origin;
+    config2.api = url2.origin;
   }
   const account = option("--account");
   if (account !== void 0 && !/^[^\s@]+@[^\s@]+$/.test(account))
     throw new Error("Use --account with the email you sign in to the Dashup app with");
   if (command === "install") {
-    if (!config.secret) throw new Error("Pair this computer first: run dashup pair.");
+    if (!config2.secret) throw new Error("Pair this computer first: run dashup pair.");
     if (!await background()) process.exitCode = 1;
     return;
   }
@@ -20240,10 +20677,10 @@ async function main() {
     const [executable, ...agentArgs] = native;
     if (!executable)
       throw new Error("Usage: dashup acp -- <original-agent-command> [arguments...]");
-    return proxyAcp(config, executable, agentArgs);
+    return proxyAcp(config2, executable, agentArgs);
   }
   if (command === "doctor" || command === "projects") {
-    const discovery = new Discovery(config.device?.id ?? "local", config.localSecret);
+    const discovery = new Discovery(config2.device?.id ?? "local", config2.localSecret);
     discovery.scan();
     const live = new LiveHarnesses();
     try {
@@ -20256,7 +20693,7 @@ async function main() {
       JSON.stringify(
         command === "doctor" ? {
           node: process.version,
-          paired: Boolean(config.secret),
+          paired: Boolean(config2.secret),
           platform: process.platform,
           projectCount: projects.length,
           harnesses: Object.fromEntries(
@@ -20276,7 +20713,7 @@ async function main() {
     return;
   }
   if (command === "alert") {
-    if (!config.localSecret) throw new Error("Start dashup watch on this computer first");
+    if (!config2.localSecret) throw new Error("Start dashup watch on this computer first");
     const input = Attention.parse({
       projectId: option("--project"),
       threadId: option("--thread") ?? "",
@@ -20295,7 +20732,7 @@ async function main() {
     );
     return;
   }
-  const pairPhone = (invite) => scanned(config, invite, (email) => `Paired a phone signed in as ${email}`);
+  const pairPhone = (invite) => scanned(config2, invite, (email) => `Paired a phone signed in as ${email}`);
   const keepRunning = async (stopHere) => {
     const answer = startupInstalled() || interactive && await ui2.confirm({ message: BACKGROUND }) === true;
     if (answer) {
@@ -20334,7 +20771,7 @@ async function main() {
     if (interactive) ui2.outro(DONE2);
     process.exit();
   }
-  if (!config.secret && !interactive && !account)
+  if (!config2.secret && !interactive && !account)
     throw new Error(
       "To pair this computer, run dashup pair in a terminal, or add --account with your Dashup email."
     );
@@ -20398,10 +20835,10 @@ async function main() {
     server.once("error", reject);
     server.listen(connectorPort(), "127.0.0.1", resolve3);
   });
-  const selectedApi = config.api;
-  Object.assign(config, loadConfig(), { api: selectedApi });
-  config.localSecret ||= newSecret(randomBytes5);
-  saveConfig(config);
+  const selectedApi = config2.api;
+  Object.assign(config2, loadConfig(), { api: selectedApi });
+  config2.localSecret ||= newSecret(randomBytes5);
+  saveConfig(config2);
   for (const signal of ["SIGINT", "SIGTERM"])
     process.once(signal, () => {
       connector?.stop();
@@ -20409,13 +20846,13 @@ async function main() {
       process.exit(0);
     });
   try {
-    const linking = !config.secret;
+    const linking = !config2.secret;
     if (linking) {
       intro2();
-      if (!await link(config, account)) process.exit(1);
+      if (!await link(config2, account)) process.exit(1);
       await keepRunning(() => server.close());
     }
-    connector = new Connector(config);
+    connector = new Connector(config2);
     await connector.start();
     if (command === "pair" && !linking) {
       if (interactive) intro2();