@dashup/connector 0.1.3 → 0.1.5

package/dist/index.js

@@ -42,7 +42,7 @@ var require_XMLHttpRequest = __commonJS({
     "use strict";
     var fs = __require("fs");
     var Url = __require("url");
-    var spawn5 = __require("child_process").spawn;
+    var spawn7 = __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 = spawn5(process.argv[0], ["-e", execString]);
+          var syncProc = spawn7(process.argv[0], ["-e", execString]);
           var statusText;
           while (fs.existsSync(syncFile)) {
           }
@@ -2706,7 +2706,7 @@ var require_pluralize = __commonJS({
 
 // src/index.ts
 import { randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
-import { createServer } from "node:http";
+import { createServer as createServer2 } from "node:http";
 import * as ui2 from "@clack/prompts";
 import { z as z3 } from "zod";
 
@@ -2714,10 +2714,14 @@ import { z as z3 } from "zod";
 var PRODUCT = {
   name: "Dashup",
   shorthand: "-up",
+  app: "com.dashup.mobile",
+  site: "https://dashup.com",
   api: "https://api.dashup.com",
+  support: "support@dashup.com",
   currency: "USD",
   trialDays: 14,
-  monthlyPrice: 10
+  monthlyPrice: 10,
+  storeProduct: "dashup.monthly"
 };
 var PAIRING_TTL_MS = 5 * 6e4;
 var PROTOCOL_VERSION = 1;
@@ -3767,7 +3771,7 @@ function bridgeAcp(socket, onUpdate) {
     if (session && direction === "agent" && message.method === methods.client.session.requestPermission) {
       const tool = message.params.toolCall ?? {};
       const diff = (tool.content ?? []).find((part) => part.type === "diff");
-      const approval2 = {
+      const approval3 = {
         id: randomUUID(),
         title: String(message.params.title ?? tool.title ?? "Agent needs approval"),
         detail: String(message.params.description ?? ""),
@@ -3785,10 +3789,10 @@ ${String(diff.newText).split("\n").map((line) => "+" + line).join("\n")}`
           }
         } : {}
       };
-      session.approvals.set(String(message.id), approval2);
+      session.approvals.set(String(message.id), approval3);
       permissions.set(String(message.id), session);
       session.status = "attention";
-      publish(session, approval2);
+      publish(session, approval3);
     }
     if (direction === "editor" && !message.method) {
       const pending = permissions.get(String(message.id));
@@ -3836,16 +3840,16 @@ function attachAcp(socket, onEvent) {
 async function proxyAcp(config2, executable, args2) {
   if (!config2.localSecret) throw new Error("Start dashup watch before using the ACP proxy");
   const socket = await new Promise((resolve3, reject) => {
-    const connect3 = request({
+    const connect4 = request({
       hostname: "127.0.0.1",
       port: connectorPort(),
       method: "CONNECT",
       path: "/acp",
       headers: { Authorization: `Bearer ${config2.localSecret}` }
     });
-    connect3.on("connect", (response, stream) => response.statusCode === 200 ? resolve3(stream) : reject(new Error("Dashup ACP connection was rejected")));
-    connect3.on("error", reject);
-    connect3.end();
+    connect4.on("connect", (response, stream) => response.statusCode === 200 ? resolve3(stream) : reject(new Error("Dashup ACP connection was rejected")));
+    connect4.on("error", reject);
+    connect4.end();
   });
   const child = spawn(executable, args2, { stdio: ["pipe", "pipe", "inherit"], windowsHide: true });
   const local = /* @__PURE__ */ new Set();
@@ -4004,13 +4008,16 @@ async function proxyAcp(config2, executable, args2) {
 
 // src/pair.ts
 import { hostname } from "node:os";
+import { promisify } from "node:util";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
 import { randomBytes as randomBytes2, createHash as createHash2 } from "node:crypto";
 import QRCode from "qrcode";
 import * as ui from "@clack/prompts";
 import { z } from "zod";
 
 // package.json
-var version = "0.1.3";
+var version = "0.1.5";
 
 // src/pair.ts
 var Invitation = z.object({
@@ -4026,29 +4033,55 @@ function invitation(config2, secret = config2.secret) {
   const computer = createHash2("sha256").update(secret).digest("hex");
   return { code, key, text: formatPairingCode({ api: config2.api, computer, code, key }) };
 }
-async function scanned(config2, { code, text: text3 }, done, secret = config2.secret) {
-  const qr = await QRCode.toString(text3, {
-    type: "terminal",
-    small: true,
-    errorCorrectionLevel: "L"
+var SCAN = "Scan this in the Dashup app under Pair a computer. It expires in 5 minutes.";
+var BROWSER = {
+  darwin: ["open"],
+  win32: ["rundll32", "url.dll,FileProtocolHandler"]
+};
+var NO_BROWSER = "No browser here can show the pairing code. Run dashup pair in a terminal on this computer.";
+async function show(text3) {
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)
+    throw new Error(NO_BROWSER);
+  const path = `/${randomBytes2(16).toString("hex")}`;
+  const qr = await QRCode.toString(text3, { type: "svg", margin: 2, errorCorrectionLevel: "L" });
+  const page = `<!doctype html><meta charset="utf-8"><title>Pair with Dashup</title><style>body{margin:0;min-height:100vh;display:grid;place-items:center;background:#fff;color:#16181d;font:16px/1.5 system-ui,sans-serif}main{max-width:22rem;padding:2rem;text-align:center}svg{width:100%;margin:1rem 0}code{font-size:11px;word-break:break-all;color:#5d6470}</style><main><p>${SCAN}</p>${qr}<p>Can't scan? Paste this code instead:</p><code>${text3}</code></main>`;
+  const server = createServer((request2, response) => {
+    if (request2.url !== path) return void response.writeHead(404).end();
+    response.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store",
+      "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'",
+      "Referrer-Policy": "no-referrer"
+    });
+    response.end(page);
   });
-  const rows = qr.split("\n").filter((row) => row.replace(/\x1b\[\d+m/g, ""));
+  await new Promise((resolve3) => server.listen(0, "127.0.0.1", resolve3));
+  const [command2, ...args2] = BROWSER[process.platform] ?? ["xdg-open"];
+  const url2 = `http://127.0.0.1:${server.address().port}${path}`;
+  try {
+    await promisify(execFile)(command2, [...args2, url2]);
+  } catch {
+    server.close();
+    throw new Error(NO_BROWSER);
+  }
+  process.stdout.write(`Opened the pairing code in a browser on this computer. ${SCAN}
+`);
+  return () => server.close();
+}
+async function scanned(config2, { code, text: text3 }, done, secret = config2.secret) {
   if (interactive) {
-    ui.log.step("Scan this in the Dashup app under Pair a computer. It expires in 5 minutes.");
+    const qr = await QRCode.toString(text3, {
+      type: "terminal",
+      small: true,
+      errorCorrectionLevel: "L"
+    });
+    ui.log.step(SCAN);
     ui.log.message("Can't scan? Paste this code instead:", { spacing: 0 });
     process.stdout.write(`   ${text3}
 `);
-    ui.log.message(rows);
-  } else {
-    process.stdout.write(
-      `
-Pairing code: ${text3}
-
-${rows.join("\n")}
-Scan this in the Dashup app (Pair a computer). It expires in 5 minutes.
-`
-    );
+    ui.log.message(qr.split("\n").filter((row) => row.replace(/\x1b\[\d+m/g, "")));
   }
+  const close = interactive ? void 0 : await show(text3);
   const waiting = interactive ? ui.spinner() : void 0;
   waiting?.start("Waiting for your phone");
   try {
@@ -4071,16 +4104,18 @@ Scan this in the Dashup app (Pair a computer). It expires in 5 minutes.
     if (!waiting) throw error;
     waiting.error(error instanceof Error ? error.message : "Pairing failed");
     throw Object.assign(error, { reported: true });
+  } finally {
+    close?.();
   }
 }
 var reported = (error) => error?.reported === true;
-async function link(config2) {
+async function link(config2, account) {
   const secret = newSecret(randomBytes2);
   const invite = invitation(config2, secret);
   const { pairing, email } = await scanned(
     config2,
     invite,
-    (account) => `Scanned by ${account}`,
+    (account2) => `Scanned by ${account2}`,
     secret
   );
   const linked = { ...config2, secret };
@@ -4091,14 +4126,13 @@ async function link(config2) {
     kind: "desktop",
     platform
   });
-  const confirmed = await ui.confirm({
-    message: `Pair this computer with ${email}?`,
-    initialValue: false
-  });
+  const confirmed = account ? email.toLowerCase() === account.toLowerCase() : await ui.confirm({ message: `Pair this computer with ${email}?`, initialValue: false });
   if (confirmed !== true) {
     await api(linked, `/dashup/pairings/${pairing.id}`, void 0, "DELETE").catch(() => {
     });
-    ui.cancel("Pairing cancelled. Nothing was shared.");
+    ui.cancel(
+      account ? `Pairing cancelled: that phone uses ${email}, not ${account}. Nothing was shared.` : "Pairing cancelled. Nothing was shared."
+    );
     return false;
   }
   Object.assign(config2, {
@@ -4120,9 +4154,9 @@ import { createInterface as createInterface2 } from "node:readline";
 import { spawn as spawn2 } from "node:child_process";
 
 // src/screen.ts
-import { promisify } from "node:util";
-import { execFile, spawnSync } from "node:child_process";
-var run = promisify(execFile);
+import { promisify as promisify2 } from "node:util";
+import { execFile as execFile2, spawnSync } from "node:child_process";
+var run = promisify2(execFile2);
 var powershell = (source) => run("powershell.exe", [
   "-NoProfile",
   "-NonInteractive",
@@ -4379,7 +4413,7 @@ var Viewer = class _Viewer {
 // src/discovery.ts
 import { homedir as homedir3 } from "node:os";
 import { createHmac } from "node:crypto";
-import { basename, join as join3 } from "node:path";
+import { basename, dirname as dirname3, join as join3 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { zstdDecompressSync } from "node:zlib";
 import { watch, existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
@@ -4539,6 +4573,7 @@ function title(value2, fallback) {
   const text3 = typeof value2 === "string" ? value2.trim().split("\n")[0].trim() : "";
   return text3 ? text3.slice(0, TITLE_LIMIT) : fallback;
 }
+var injected = (content) => /^\s*(# AGENTS\.md instructions for |<[a-z_][\w -]*>)/i.test(text(content));
 function text(value2) {
   if (typeof value2 === "string") return value2;
   if (Array.isArray(value2)) return value2.map(text).filter(Boolean).join("\n");
@@ -4607,6 +4642,7 @@ function step(id, name, input, result) {
     }
   };
 }
+var claudeHome = () => process.env.CLAUDE_CONFIG_DIR ?? join2(homedir2(), ".claude");
 var claudeMessage = (row) => (row.type === "user" || row.type === "assistant") && !row.isSidechain;
 function claudeChange(change) {
   if (typeof change?.filePath !== "string") return void 0;
@@ -4684,7 +4720,9 @@ function claude(root, scan) {
         continue;
       }
       const named = latest.find((row) => row.type === "custom-title" || row.type === "ai-title");
-      const first = rows.find((row) => row.type === "user" && !row.isMeta && !row.isSidechain);
+      const first = rows.find(
+        (row) => row.type === "user" && !row.isMeta && !row.isSidechain && !injected(row.message?.content)
+      );
       scan.sessions.push({
         harness: "claude",
         id: owner.sessionId,
@@ -4732,7 +4770,7 @@ function codexMessages(path) {
     if (!item) return [];
     const id = String(item.id ?? row.ordinal ?? `${index}`);
     if (item.type === "message" && ["user", "assistant"].includes(item.role))
-      return prose(id, item.role, item.content);
+      return item.role === "user" && injected(item.content) ? [] : prose(id, item.role, item.content);
     if (!["function_call", "custom_tool_call"].includes(item.type)) return [];
     const input = item.type === "function_call" ? parse(String(item.arguments)) ?? item.arguments : item.input;
     const output = outputs.get(item.call_id);
@@ -4773,6 +4811,7 @@ function codex(root, scan) {
       scan.warnings.push(`Cannot read Codex session index: ${index}`);
     }
   }
+  const titles = codexTitles(root);
   for (const path of [
     ...files(join2(root, "sessions"), scan),
     ...files(join2(root, "archived_sessions"), scan)
@@ -4788,13 +4827,16 @@ function codex(root, scan) {
       }
       const named = names.get(owner.id);
       const first = rows.find(
-        (row) => row.type === "response_item" && row.payload?.type === "message" && row.payload.role === "user"
+        (row) => row.type === "response_item" && row.payload?.type === "message" && row.payload.role === "user" && !injected(row.payload.content)
       );
       scan.sessions.push({
         harness: "codex",
         id: owner.id,
         cwd,
-        title: title(named?.thread_name ?? text(first?.payload?.content), "Codex thread"),
+        title: title(
+          named?.thread_name ?? titles.get(owner.id) ?? text(first?.payload?.content),
+          "Codex thread"
+        ),
         parent: typeof owner.parent_thread_id === "string" ? owner.parent_thread_id : void 0,
         updatedAt: date(latest.find(codexItem)?.timestamp, statSync(path).mtimeMs),
         files: [path, ...existsSync3(index) ? [index] : []],
@@ -4863,6 +4905,30 @@ function databaseMessages(path, session) {
     db.close();
   }
 }
+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() : "";
+  return [row.agent_nickname, task?.replace(/_/g, " ")].filter(Boolean).join(" \xB7 ");
+}
+function codexTitles(root) {
+  const titles = /* @__PURE__ */ new Map();
+  const state = (existsSync3(root) ? readdirSync(root) : []).filter((name) => /^state_\d+\.sqlite$/.test(name)).sort((a, b) => Number(b.match(/\d+/)[0]) - Number(a.match(/\d+/)[0]))[0];
+  if (!state) return titles;
+  let db;
+  try {
+    db = openDatabase(join2(root, state));
+    for (const row of db.prepare("SELECT id, title, first_user_message, source, agent_nickname FROM threads").all()) {
+      const name = [row.title, row.first_user_message].find(
+        (value2) => typeof value2 === "string" && !!value2.trim() && !injected(value2)
+      );
+      if (typeof row.id === "string") titles.set(row.id, name ?? codexSubagent(row));
+    }
+  } catch {
+  } finally {
+    db?.close();
+  }
+  return titles;
+}
 function openCodeDatabase(path, scan) {
   if (!existsSync3(path)) {
     watchParent(path, scan);
@@ -4961,7 +5027,7 @@ function openCodeLegacy(root, scan) {
 function scanHistories() {
   const home = homedir2();
   const scan = { sessions: [], paths: /* @__PURE__ */ new Set(), warnings: [] };
-  claude(process.env.CLAUDE_CONFIG_DIR ?? join2(home, ".claude"), scan);
+  claude(claudeHome(), scan);
   codex(process.env.CODEX_HOME ?? join2(home, ".codex"), scan);
   const opencode = join2(process.env.XDG_DATA_HOME ?? join2(home, ".local/share"), "opencode");
   openCodeDatabase(process.env.OPENCODE_DB ?? join2(opencode, "opencode.db"), scan);
@@ -5103,7 +5169,7 @@ var Discovery = class {
     const project = this.project(session.cwd);
     const thread = {
       id: agentThread(session.harness, session.id, this.secret),
-      title: session.title,
+      title: session.title ?? "",
       editor: "cli",
       status: "unknown",
       updatedAt: session.updatedAt,
@@ -5122,13 +5188,24 @@ var Discovery = class {
     thread.updatedAt = session.updatedAt;
     if (session.parent) thread.parent = agentThread(session.harness, session.parent, this.secret);
   }
+  // Where new projects go: the folders holding this computer's projects, most used first.
+  folders() {
+    const counts = /* @__PURE__ */ new Map();
+    for (const project of this.projects.values())
+      if (!project.remote) {
+        const parent = dirname3(project.path);
+        counts.set(parent, (counts.get(parent) ?? 0) + 1);
+      }
+    const folders = [...counts].sort((a, b) => b[1] - a[1]).map(([folder]) => folder).filter((folder) => existsSync4(folder)).slice(0, 3);
+    return folders.length ? folders : [homedir3()];
+  }
   observe(session) {
     const found = this.native(session);
     const location2 = this.locations.get(found.thread.id);
     location2.live = session;
     Object.assign(found.thread, {
       editor: session.editor ?? found.thread.editor,
-      title: session.title,
+      title: session.title ?? found.thread.title,
       status: session.status,
       updatedAt: location2.history?.updatedAt ?? session.updatedAt,
       capabilities: {
@@ -5347,6 +5424,8 @@ var Discovery = class {
 
 // src/connector.ts
 import { z as z2 } from "zod";
+import { join as join9 } from "node:path";
+import { mkdir } from "node:fs/promises";
 import { randomBytes as randomBytes4 } from "node:crypto";
 
 // ../../node_modules/.pnpm/engine.io-client@6.6.7/node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
@@ -16365,11 +16444,17 @@ async function publishHistory(config2, pair, project, thread, messages5) {
   return summary;
 }
 
+// src/harness/live.ts
+import { promisify as promisify6 } from "node:util";
+import { execFile as execFile6 } from "node:child_process";
+
 // src/harness/codex.ts
 import WebSocket2 from "ws";
 import { homedir as homedir4 } from "node:os";
 import { connect } from "node:net";
+import { promisify as promisify3 } from "node:util";
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { execFile as execFile3 } from "node:child_process";
 import { join as join4, isAbsolute as isAbsolute2 } from "node:path";
 import { stat, readdir, readFile } from "node:fs/promises";
 var REQUEST_MS = 4e3;
@@ -16401,13 +16486,12 @@ function approval(id, method, params) {
     choices: DECISIONS.filter((choice) => !unavailable || choice.id === "decline").map((choice) => ({ ...choice }))
   };
 }
+var codexHome = () => process.env.DASHUP_CODEX_HOME ?? process.env.CODEX_HOME ?? join4(homedir4(), ".codex");
 async function sockets() {
   const explicit = process.env.DASHUP_CODEX_SOCKET;
   if (explicit !== void 0) return explicit && isAbsolute2(explicit) ? [explicit] : [];
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
-  const homes = /* @__PURE__ */ new Set([
-    process.env.DASHUP_CODEX_HOME ?? process.env.CODEX_HOME ?? join4(homedir4(), ".codex")
-  ]);
+  const homes = /* @__PURE__ */ new Set([codexHome()]);
   if (process.platform === "linux") {
     const entries2 = await readdir("/proc").catch(() => []);
     for (const pid of entries2.filter((value2) => /^\d+$/.test(value2)).slice(0, MAX_PROCESSES)) {
@@ -16593,6 +16677,16 @@ var Client = class {
     this.requests.set(id, result);
     return result;
   }
+  // Starts a thread in `cwd` with Codex's own settings, then its first turn.
+  async start(cwd, text3) {
+    await this.connect();
+    if (!this.controls) throw new Error("Update Codex to start threads from Dashup");
+    const id = (await this.call("thread/start", { cwd })).thread?.id;
+    if (typeof id !== "string") throw new Error("Codex did not start a thread");
+    await this.call("turn/start", { threadId: id, input: [{ type: "text", text: text3, text_elements: [] }] });
+    this.changed();
+    return id;
+  }
   async read() {
     await this.connect();
     const loaded = await this.call("thread/loaded/list", { limit: MAX_SESSIONS });
@@ -16640,12 +16734,12 @@ var Client = class {
             this.changed();
           }) : void 0,
           approve: approvals.length ? (requestId, approvalId, choice) => this.once(requestId, async () => {
-            const approval2 = this.approvals.get(approvalId);
+            const approval3 = this.approvals.get(approvalId);
             const socket = this.socket;
-            if (!approval2 || approval2.threadId !== id || !approval2.approval.choices.some((value2) => value2.id === choice) || socket?.readyState !== WebSocket2.OPEN)
+            if (!approval3 || approval3.threadId !== id || !approval3.approval.choices.some((value2) => value2.id === choice) || socket?.readyState !== WebSocket2.OPEN)
               throw new Error("Codex approval is no longer pending");
             await new Promise((resolve3, reject) => socket.send(
-              JSON.stringify({ id: approval2.requestId, result: { decision: choice } }),
+              JSON.stringify({ id: approval3.requestId, result: { decision: choice } }),
               (error) => error ? reject(new Error("Codex approval could not be sent")) : resolve3()
             ));
             this.approvals.delete(approvalId);
@@ -16675,8 +16769,25 @@ var Codex = class {
   }
   changed;
   clients = /* @__PURE__ */ new Map();
+  // Control sockets of daemons this connector started, which discovery may not look for.
+  started = /* @__PURE__ */ new Set();
+  // Codex's own daemon runs the threads Dashup starts, so they outlive this connector.
+  async start(cwd, text3) {
+    const path = process.env.DASHUP_CODEX_SOCKET || join4(codexHome(), ...SOCKET_PARTS);
+    await promisify3(execFile3)("codex", ["app-server", "daemon", "start"], {
+      timeout: 6e4,
+      shell: process.platform === "win32"
+    });
+    this.started.add(path);
+    let client = this.clients.get(path);
+    if (!client) {
+      client = new Client(path, this.changed);
+      this.clients.set(path, client);
+    }
+    return client.start(cwd, text3);
+  }
   async refresh() {
-    const paths = new Set(await sockets());
+    const paths = /* @__PURE__ */ new Set([...await sockets(), ...this.started]);
     for (const [path, client] of this.clients)
       if (!paths.has(path)) {
         client.stop();
@@ -16700,26 +16811,360 @@ var Codex = class {
   }
 };
 
+// src/harness/headless.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { createInterface as createInterface3 } from "node:readline";
+import { spawn as spawn3 } from "node:child_process";
+var CHOICES = [
+  { id: "accept", label: "Allow once" },
+  { id: "decline", label: "Reject" }
+];
+var EDITS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "NotebookEdit", "Write"]);
+var MAX_REQUESTS = 1e3;
+var NOTIFY_MS = 100;
+function approval2(id, request2) {
+  const input = request2.input ?? {};
+  const tool = String(request2.display_name ?? request2.tool_name ?? "a tool");
+  let detail = [
+    typeof request2.description === "string" ? request2.description : "",
+    typeof input.command === "string" ? input.command : JSON.stringify(input, null, 2)
+  ].filter(Boolean).join("\n\n");
+  if (Buffer.byteLength(detail) > MAX_PREVIEW)
+    detail = Buffer.from(detail).subarray(0, MAX_PREVIEW).toString("utf8");
+  return {
+    id,
+    title: request2.tool_name === "Bash" ? "Allow command?" : EDITS.has(request2.tool_name) ? "Allow file changes?" : `Allow ${tool}?`,
+    detail,
+    choices: CHOICES.map((choice) => ({ ...choice }))
+  };
+}
+var Session = 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;
+  // Messages written to this turn's process that Claude Code has not finished answering.
+  open = 0;
+  // Once Claude Code has saved the session, later turns resume it.
+  saved = false;
+  approvals = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  write(value2) {
+    this.turn?.stdin.write(`${JSON.stringify(value2)}
+`);
+  }
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= MAX_REQUESTS)
+      throw new Error("Claude Code command history is full; restart Dashup before sending");
+    const result = action();
+    this.requests.set(id, result);
+    return result;
+  }
+  // Resolves once Claude Code takes the message, or says why it could not start.
+  say(text3) {
+    this.messages.push({ id: randomUUID3(), role: "user", text: text3 });
+    this.status = "working";
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const message = { type: "user", message: { role: "user", content: text3 } };
+    if (this.turn) {
+      this.open++;
+      this.write(message);
+      this.changed();
+      return Promise.resolve();
+    }
+    const turn = this.turn = spawn3(
+      "claude",
+      [
+        "-p",
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--permission-prompt-tool",
+        "stdio",
+        ...this.saved ? ["--resume", this.id] : ["--session-id", this.id]
+      ],
+      { cwd: this.cwd, stdio: "pipe", shell: process.platform === "win32" }
+    );
+    this.open = 1;
+    let errors = "";
+    turn.stdin.on("error", () => {
+    });
+    turn.stderr.on("data", (chunk) => {
+      errors = (errors + String(chunk)).slice(-2e3);
+    });
+    const started = new Promise((resolve3, reject) => {
+      createInterface3({ input: turn.stdout }).on("line", (line) => {
+        if (this.receive(line)) resolve3();
+      });
+      const end = (reason) => {
+        reject(new Error(reason));
+        if (this.turn !== turn) return;
+        this.turn = void 0;
+        this.open = 0;
+        this.approvals.clear();
+        this.status = "idle";
+        this.changed();
+      };
+      turn.once("error", () => end("Claude Code is not installed on this computer"));
+      turn.once("exit", () => end(errors.trim() || "Claude Code stopped before starting"));
+    });
+    this.write(message);
+    this.changed();
+    return started;
+  }
+  // Handles one line of Claude Code's output, and says whether it started the session.
+  receive(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return false;
+    }
+    const init = message.type === "system" && message.subtype === "init";
+    if (init) this.saved = true;
+    else if (message.type === "assistant") {
+      const text3 = (Array.isArray(message.message?.content) ? message.message.content : []).filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n\n");
+      if (!text3) return false;
+      this.messages.push({ id: String(message.message?.id ?? randomUUID3()), role: "assistant", text: text3 });
+    } else if (message.type === "control_request" && message.request?.subtype === "can_use_tool") {
+      const id = randomUUID3();
+      this.approvals.set(id, {
+        request: String(message.request_id),
+        input: message.request.input ?? {},
+        approval: approval2(id, message.request)
+      });
+      this.status = "attention";
+    } else if (message.type === "result") {
+      if (--this.open <= 0) this.turn?.stdin.end();
+    } else return false;
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.changed();
+    return init;
+  }
+  live() {
+    return {
+      id: this.id,
+      cwd: this.cwd,
+      title: this.title,
+      harness: "claude",
+      updatedAt: this.updatedAt,
+      status: this.status,
+      messages: [...this.messages],
+      approvals: [...this.approvals.values()].map((pending) => pending.approval),
+      send: (requestId, text3) => this.once(requestId, () => this.say(text3)),
+      stop: this.turn ? (requestId) => this.once(requestId, async () => {
+        if (!this.turn) throw new Error("Nothing is running in this Claude Code session");
+        this.write({
+          type: "control_request",
+          request_id: randomUUID3(),
+          request: { subtype: "interrupt" }
+        });
+      }) : void 0,
+      approve: this.approvals.size ? (requestId, approvalId, choice) => this.once(requestId, async () => {
+        const pending = this.approvals.get(approvalId);
+        if (!pending || !this.turn || !CHOICES.some((value2) => value2.id === choice))
+          throw new Error("Claude Code approval is no longer pending");
+        this.write({
+          type: "control_response",
+          response: {
+            subtype: "success",
+            request_id: pending.request,
+            response: choice === "accept" ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: "The person rejected this from their phone." }
+          }
+        });
+        this.approvals.delete(approvalId);
+        if (!this.approvals.size) this.status = "working";
+        this.changed();
+      }) : void 0
+    };
+  }
+  end() {
+    this.turn?.kill();
+  }
+};
+var Headless = 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_MS);
+    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 Session(randomUUID3(), 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;
+  }
+  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/claude.ts
+import { join as join5 } from "node:path";
+import { connect as connect2 } from "node:net";
+import { watch as watch2 } from "node:fs";
+import { lstat, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+var PEER_PROTOCOL = 1;
+var MAX_SESSIONS2 = 100;
+var REQUEST_MS2 = 4e3;
+var MAX_REQUESTS2 = 1e3;
+var ENVELOPE = "cross-session-message";
+var STATUS = {
+  busy: "working",
+  idle: "idle",
+  shell: "idle",
+  waiting: "attention"
+};
+async function registrations() {
+  if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
+  const directory2 = join5(claudeHome(), "sessions");
+  const names = await readdir2(directory2).catch(() => []);
+  const found = await Promise.all(
+    names.filter((name) => /^\d+\.json$/.test(name)).slice(0, MAX_SESSIONS2).map(async (name) => {
+      try {
+        const value2 = JSON.parse(await readFile2(join5(directory2, name), "utf8"));
+        if (typeof value2.sessionId !== "string" || typeof value2.cwd !== "string") return [];
+        process.kill(value2.pid, 0);
+        return [value2];
+      } catch {
+        return [];
+      }
+    })
+  );
+  return found.flat();
+}
+async function post(session, path, text3) {
+  const file = await lstat(path);
+  if (!file.isSocket() || process.getuid && file.uid !== process.getuid())
+    throw new Error("Claude Code inbox is not owned by this user");
+  const body2 = text3.replace(new RegExp(`<(?=/?${ENVELOPE})`, "gi"), "<\\");
+  const line = JSON.stringify({
+    type: "user",
+    session_id: session.sessionId,
+    priority: "next",
+    message: { role: "user", content: `<${ENVELOPE} from-name="Dashup">
+${body2}
+</${ENVELOPE}>` }
+  });
+  await new Promise((resolve3, reject) => {
+    const socket = connect2(path);
+    socket.setTimeout(REQUEST_MS2, () => socket.destroy(new Error("timed out")));
+    socket.once("error", () => reject(new Error("Claude Code is not accepting messages")));
+    socket.end(`${line}
+`, resolve3);
+  });
+}
+var Claude = class {
+  constructor(changed) {
+    this.changed = changed;
+  }
+  changed;
+  watcher;
+  notify;
+  requests = /* @__PURE__ */ new Map();
+  async refresh() {
+    this.watch();
+    return (await registrations()).map((session) => {
+      const path = session.peerProtocol === PEER_PROTOCOL ? session.messagingSocketPath : void 0;
+      return {
+        id: session.sessionId,
+        harness: "claude",
+        cwd: session.cwd,
+        updatedAt: new Date(session.updatedAt ?? 0).toISOString(),
+        status: STATUS[session.status ?? ""] ?? "unknown",
+        messages: [],
+        approvals: [],
+        send: path ? (requestId, text3) => this.once(requestId, () => post(session, path, text3)) : void 0
+      };
+    });
+  }
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= MAX_REQUESTS2) this.requests.delete(this.requests.keys().next().value);
+    const result = action();
+    this.requests.set(id, result);
+    return result;
+  }
+  watch() {
+    if (this.watcher || process.env.DASHUP_LIVE_DISCOVERY === "0") return;
+    try {
+      const watcher = this.watcher = watch2(join5(claudeHome(), "sessions"), () => {
+        if (this.notify) return;
+        this.notify = setTimeout(() => {
+          this.notify = void 0;
+          this.changed();
+        }, 100);
+        this.notify.unref();
+      });
+      watcher.on("error", () => {
+        watcher.close();
+        if (this.watcher === watcher) this.watcher = void 0;
+      });
+    } catch {
+    }
+  }
+  stop() {
+    clearTimeout(this.notify);
+    this.watcher?.close();
+    this.watcher = void 0;
+  }
+};
+
 // src/harness/vscode.ts
 import Socket3 from "ws";
 import { homedir as homedir5 } from "node:os";
-import { connect as connect2 } from "node:net";
-import { promisify as promisify2 } from "node:util";
+import { connect as connect3 } from "node:net";
+import { promisify as promisify4 } from "node:util";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { execFile as execFile2 } from "node:child_process";
-import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
-import { stat as stat2, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
-import { join as join5, dirname as dirname3, basename as basename2, isAbsolute as isAbsolute3 } from "node:path";
+import { execFile as execFile4 } from "node:child_process";
+import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
+import { stat as stat2, readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
+import { join as join6, dirname as dirname4, basename as basename2, 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";
-var REQUEST_MS2 = 4e3;
+var REQUEST_MS3 = 4e3;
 var MAX_BYTES2 = 8 * 1024 * 1024;
 var MAX_METADATA = 64 * 1024;
 var MAX_HOSTS = 16;
-var MAX_SESSIONS2 = 100;
+var MAX_SESSIONS3 = 100;
 var ROOT_CHANNEL = "ahp-root://";
-var run2 = promisify2(execFile2);
+var run2 = promisify4(execFile4);
 var CONFIRMATION_CHOICES = [
   { id: "approve", label: "Allow once", kind: "approve" },
   { id: "deny", label: "Reject", kind: "deny" }
@@ -16727,10 +17172,10 @@ var CONFIRMATION_CHOICES = [
 function roots() {
   const override = process.env.DASHUP_AHP_DATA ?? process.env.DASHUP_VSCODE_DATA;
   if (override !== void 0)
-    return override ? [basename2(override) === "User" ? dirname3(override) : override] : [];
+    return override ? [basename2(override) === "User" ? dirname4(override) : override] : [];
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
-  const base = process.platform === "darwin" ? join5(homedir5(), "Library/Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join5(homedir5(), "AppData/Roaming") : process.env.XDG_CONFIG_HOME ?? join5(homedir5(), ".config");
-  return ["Code", "Code - Insiders"].map((name) => join5(base, name));
+  const base = process.platform === "darwin" ? join6(homedir5(), "Library/Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join6(homedir5(), "AppData/Roaming") : process.env.XDG_CONFIG_HOME ?? join6(homedir5(), ".config");
+  return ["Code", "Code - Insiders"].map((name) => join6(base, name));
 }
 async function privateFile(path, limit) {
   const file = await stat2(path).catch(() => void 0);
@@ -16747,7 +17192,7 @@ async function privateFile(path, limit) {
           "-EncodedCommand",
           Buffer.from(script, "utf16le").toString("base64")
         ],
-        { timeout: REQUEST_MS2, maxBuffer: MAX_METADATA }
+        { timeout: REQUEST_MS3, maxBuffer: MAX_METADATA }
       );
       return stdout.trim().toLowerCase() === "true";
     } catch {
@@ -16759,16 +17204,16 @@ async function privateFile(path, limit) {
 async function entries() {
   const result = /* @__PURE__ */ new Map();
   for (const root of roots()) {
-    const registry2 = join5(root, "agent-host/local-endpoint");
-    const files2 = (await readdir2(join5(registry2, "entries")).catch(() => [])).filter((name) => name.endsWith(".json")).slice(0, MAX_HOSTS);
+    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 sources = [
-      ...files2.map((name) => join5(registry2, "entries", name)),
-      join5(registry2, "metadata.json")
+      ...files2.map((name) => join6(registry2, "entries", name)),
+      join6(registry2, "metadata.json")
     ];
     for (const path of sources) {
       try {
         if (!await privateFile(path, MAX_METADATA)) continue;
-        const parsed = JSON.parse(await readFile2(path, "utf8"));
+        const parsed = JSON.parse(await readFile3(path, "utf8"));
         const rows = basename2(path) === "metadata.json" && Array.isArray(parsed) ? parsed : [parsed];
         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))
@@ -16788,7 +17233,7 @@ async function entries() {
             if (!socket?.isSocket() || process.getuid && socket.uid !== process.getuid())
               continue;
           }
-          if (!await privateFile(dirname3(path), MAX_BYTES2)) continue;
+          if (!await privateFile(dirname4(path), MAX_BYTES2)) continue;
           const key = `${root}\0${identity2}`;
           if (!result.has(key))
             result.set(key, {
@@ -16901,7 +17346,7 @@ var Host = class {
   client;
   connecting;
   stopped = false;
-  clientId = `dashup-${randomUUID3()}`;
+  clientId = `dashup-${randomUUID4()}`;
   resources = /* @__PURE__ */ new Map();
   subscriptions = /* @__PURE__ */ new Set();
   receipts = /* @__PURE__ */ new Map();
@@ -16953,9 +17398,9 @@ var Host = class {
     if (this.connecting) return this.connecting;
     this.connecting = (async () => {
       const socket = new Socket3(`ws://localhost/?tkn=${encodeURIComponent(this.entry.token)}`, {
-        createConnection: () => connect2(this.entry.path),
+        createConnection: () => connect3(this.entry.path),
         maxPayload: MAX_BYTES2,
-        handshakeTimeout: REQUEST_MS2
+        handshakeTimeout: REQUEST_MS3
       });
       socket.on("error", () => {
       });
@@ -16988,7 +17433,7 @@ var Host = class {
         }
       };
       const client = this.client = new AhpClient(transport, {
-        requestTimeoutMs: REQUEST_MS2,
+        requestTimeoutMs: REQUEST_MS3,
         subscriptionBuffer: 1024
       });
       this.resources.clear();
@@ -17052,7 +17497,7 @@ var Host = class {
       const timer = setTimeout(() => {
         this.receipts.delete(handle.clientSeq);
         reject(new Error("Native AHP action was not acknowledged; delivery is unknown"));
-      }, REQUEST_MS2);
+      }, REQUEST_MS3);
       this.receipts.set(handle.clientSeq, { resolve: resolve3, reject, timer });
     });
     this.requests.set(requestId, pending);
@@ -17062,12 +17507,12 @@ var Host = class {
     await this.connect();
     const catalog = await this.client.request("listSessions", {
       channel: ROOT_CHANNEL,
-      limit: MAX_SESSIONS2
+      limit: MAX_SESSIONS3
     });
     if (!Array.isArray(catalog.items)) return [];
     const result = [];
     const active = /* @__PURE__ */ new Set();
-    for (const summary of catalog.items.slice(0, MAX_SESSIONS2)) {
+    for (const summary of catalog.items.slice(0, MAX_SESSIONS3)) {
       try {
         const session = await this.subscribe(summary.resource);
         if (!session || session.lifecycle !== "ready" || !Array.isArray(session.chats)) continue;
@@ -17129,7 +17574,7 @@ var Host = class {
                 message: { text: value2, origin: { kind: "user" } }
               });
             } : void 0,
-            approve: approvals.some((approval2) => approval2.choices.length) ? (requestId, approvalId, choice) => {
+            approve: approvals.some((approval3) => approval3.choices.length) ? (requestId, approvalId, choice) => {
               const prior = this.requests.get(requestId);
               if (prior) return prior;
               const current = this.resources.get(summary.resource)?.state;
@@ -17200,15 +17645,15 @@ var VSCode = class {
 };
 
 // src/harness/opencode.ts
-import { join as join6 } from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { join as join7 } from "node:path";
+import { promisify as promisify5 } from "node:util";
 import { createHash as createHash4 } from "node:crypto";
-import { execFile as execFile3 } from "node:child_process";
-import { stat as stat3, readlink, readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
-var run3 = promisify3(execFile3);
-var REQUEST_MS3 = 4e3;
+import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
+import { stat as stat3, readlink, readdir as readdir4, readFile as readFile4 } from "node:fs/promises";
+var run3 = promisify5(execFile5);
+var REQUEST_MS4 = 4e3;
 var MAX_BYTES3 = 8 * 1024 * 1024;
-var MAX_SESSIONS3 = 100;
+var MAX_SESSIONS4 = 100;
 var MAX_PROCESSES2 = 4096;
 var MAX_ENDPOINTS = 32;
 var EVENT_DELAY_MS = 100;
@@ -17231,10 +17676,10 @@ function authorization(environment) {
 }
 async function linuxEndpoints() {
   const result = [];
-  const processes = (await readdir3("/proc")).filter((id) => /^\d+$/.test(id)).slice(0, MAX_PROCESSES2);
+  const processes = (await readdir4("/proc")).filter((id) => /^\d+$/.test(id)).slice(0, MAX_PROCESSES2);
   const listeners = /* @__PURE__ */ new Map();
   for (const name of ["tcp", "tcp6"]) {
-    const table = await readFile3(`/proc/net/${name}`, "utf8").catch(() => "");
+    const table = await readFile4(`/proc/net/${name}`, "utf8").catch(() => "");
     for (const line of table.split("\n").slice(1)) {
       const columns = line.trim().split(/\s+/);
       if (columns[3] !== "0A") continue;
@@ -17250,16 +17695,16 @@ async function linuxEndpoints() {
       const directory2 = `/proc/${pid}`;
       const owner = await stat3(directory2);
       if (process.getuid && owner.uid !== process.getuid()) continue;
-      const command2 = (await readFile3(join6(directory2, "cmdline"), "utf8")).slice(0, 4096);
+      const command2 = (await readFile4(join7(directory2, "cmdline"), "utf8")).slice(0, 4096);
       if (!/(?:^|[\/\0 ])opencode(?:[\0 .]|$)/.test(command2)) continue;
       const environment = Object.fromEntries(
-        (await readFile3(join6(directory2, "environ"), "utf8")).split("\0").map((entry) => {
+        (await readFile4(join7(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 readdir3(join6(directory2, "fd"))).slice(0, 1024)) {
-        const target = await readlink(join6(directory2, "fd", fd)).catch(() => "");
+      for (const fd of (await readdir4(join7(directory2, "fd"))).slice(0, 1024)) {
+        const target = await readlink(join7(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) });
@@ -17288,7 +17733,7 @@ async function endpoints() {
     const { stdout } = await run3(
       "lsof",
       ["-nP", "-a", "-c", "opencode", "-iTCP", "-sTCP:LISTEN", "-Fn"],
-      { timeout: REQUEST_MS3, maxBuffer: MAX_BYTES3 }
+      { timeout: REQUEST_MS4, maxBuffer: MAX_BYTES3 }
     );
     return stdout.split("\n").flatMap((line) => {
       const port = /^n(?:127\.0\.0\.1|\[::1\]|\*):(\d+)$/.exec(line)?.[1];
@@ -17305,7 +17750,7 @@ async function endpoints() {
     const { stdout } = await run3(
       "powershell.exe",
       ["-NoProfile", "-NonInteractive", "-Command", script],
-      { timeout: REQUEST_MS3, maxBuffer: MAX_BYTES3 }
+      { timeout: REQUEST_MS4, maxBuffer: MAX_BYTES3 }
     );
     return stdout.split(/\r?\n/).filter((port) => /^\d+$/.test(port)).slice(0, MAX_ENDPOINTS).map((port) => ({
       url: localEndpoint(`http://127.0.0.1:${port}`),
@@ -17425,7 +17870,7 @@ var Server = class {
     };
   }
   async request(path, directory2, payload) {
-    const signal = AbortSignal.timeout(REQUEST_MS3);
+    const signal = AbortSignal.timeout(REQUEST_MS4);
     const response = await fetch(this.endpoint.url + path, {
       method: payload === void 0 ? "GET" : "POST",
       headers: {
@@ -17452,15 +17897,25 @@ var Server = class {
     this.requests.set(id, pending);
     return pending;
   }
+  // A session Dashup starts takes OpenCode's default agent and model for its folder.
+  async start(cwd, text3) {
+    const id = (await this.request("/session", cwd, {}))?.id;
+    if (typeof id !== "string") throw new Error("OpenCode did not start a session");
+    await this.request(`/session/${encodeURIComponent(id)}/prompt_async`, cwd, {
+      parts: [{ type: "text", text: text3 }]
+    });
+    this.changed();
+    return id;
+  }
   async read() {
     const health = await this.request("/global/health");
     if (health?.healthy !== true || typeof health.version !== "string") return [];
     this.listen();
-    const sessions = await this.request(`/session?limit=${MAX_SESSIONS3}`);
+    const sessions = await this.request(`/session?limit=${MAX_SESSIONS4}`);
     if (!Array.isArray(sessions)) return [];
     const result = [];
     const states = /* @__PURE__ */ new Map();
-    for (const session of sessions.slice(0, MAX_SESSIONS3)) {
+    for (const session of sessions.slice(0, MAX_SESSIONS4)) {
       if (typeof session?.id !== "string" || typeof session.directory !== "string" || !session.directory)
         continue;
       try {
@@ -17536,7 +17991,7 @@ var Server = class {
             });
             this.changed();
           }),
-          approve: approvals.some((approval2) => approval2.choices.length) ? (requestId, approvalId, choice) => this.once(requestId, async () => {
+          approve: approvals.some((approval3) => approval3.choices.length) ? (requestId, approvalId, choice) => this.once(requestId, async () => {
             if (this.stopped) throw new Error("OpenCode is disconnected");
             if (approvalId.startsWith("question:")) {
               const requestID = approvalId.slice("question:".length);
@@ -17585,7 +18040,7 @@ var Server = class {
   listen() {
     if (this.stream || this.retry || this.stopped) return;
     const controller = this.stream = new AbortController();
-    const connectTimer = setTimeout(() => controller.abort(), REQUEST_MS3);
+    const connectTimer = setTimeout(() => controller.abort(), REQUEST_MS4);
     connectTimer.unref();
     void (async () => {
       const response = await fetch(this.endpoint.url + "/global/event", {
@@ -17654,15 +18109,57 @@ var Server = class {
     clearTimeout(this.notify);
   }
 };
+function serve(cwd) {
+  const child = spawn4("opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0"], {
+    cwd,
+    stdio: ["ignore", "pipe", "ignore"],
+    shell: process.platform === "win32"
+  });
+  const endpoint = new Promise((resolve3, reject) => {
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      output = (output + String(chunk)).slice(-4096);
+      const port = /https?:\/\/(?:127\.0\.0\.1|localhost):(\d+)/.exec(output)?.[1];
+      if (port)
+        resolve3({
+          url: localEndpoint(`http://127.0.0.1:${port}`),
+          authorization: authorization(process.env)
+        });
+    });
+    child.once("error", () => reject(new Error("OpenCode is not installed on this computer")));
+    child.once("exit", () => reject(new Error("OpenCode stopped before it started serving")));
+  });
+  return { process: child, endpoint };
+}
 var OpenCode = class {
   constructor(changed) {
     this.changed = changed;
   }
   changed;
   servers = /* @__PURE__ */ new Map();
+  // Servers this connector started, by folder.
+  started = /* @__PURE__ */ new Map();
+  async start(cwd, text3) {
+    let served = this.started.get(cwd);
+    if (!served) this.started.set(cwd, served = serve(cwd));
+    const endpoint = await served.endpoint.catch((error) => {
+      this.started.delete(cwd);
+      throw error;
+    });
+    let server = this.servers.get(endpoint.url);
+    if (!server) {
+      server = new Server(endpoint, this.changed);
+      this.servers.set(endpoint.url, server);
+    }
+    return server.start(cwd, text3);
+  }
   async refresh() {
     const discovered = await endpoints().catch(() => []);
     const current = new Map(discovered.map((endpoint) => [endpoint.url, endpoint]));
+    for (const served of this.started.values()) {
+      const endpoint = await served.endpoint.catch(() => void 0);
+      if (endpoint) current.set(endpoint.url, endpoint);
+    }
     for (const [url2, server] of this.servers)
       if (!current.has(url2)) {
         server.stop();
@@ -17683,6 +18180,8 @@ var OpenCode = class {
   stop() {
     for (const server of this.servers.values()) server.stop();
     this.servers.clear();
+    for (const served of this.started.values()) served.process.kill();
+    this.started.clear();
   }
 };
 
@@ -17691,6 +18190,8 @@ var DISCOVERY_MS = 1e4;
 var LiveHarnesses = class {
   listeners = /* @__PURE__ */ new Set();
   codex = new Codex(() => this.changed());
+  headless = new Headless(() => this.changed());
+  claude = new Claude(() => this.changed());
   vscode = new VSCode(() => this.changed());
   opencode = new OpenCode(() => this.changed());
   timer;
@@ -17704,8 +18205,10 @@ var LiveHarnesses = class {
     if (this.refreshing) return this.refreshing;
     this.refreshing = (async () => {
       const results = await Promise.allSettled([
+        this.headless.refresh(),
         this.opencode.refresh(),
         this.codex.refresh(),
+        this.claude.refresh(),
         this.vscode.refresh()
       ]);
       const sessions = /* @__PURE__ */ new Map();
@@ -17721,6 +18224,27 @@ var LiveHarnesses = class {
     });
     return this.refreshing;
   }
+  // The agents whose own command runs on this computer.
+  async agents() {
+    const harnesses = ["claude", "codex", "opencode"];
+    const runs = await Promise.all(
+      harnesses.map((harness) => promisify6(execFile6)(harness, ["--version"], {
+        timeout: 1e4,
+        shell: process.platform === "win32"
+      }).then(
+        () => true,
+        () => false
+      ))
+    );
+    return harnesses.filter((_, index) => runs[index]);
+  }
+  // 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
+    );
+  }
   watch(onChange) {
     this.listeners.add(onChange);
     if (!this.timer && process.env.DASHUP_LIVE_DISCOVERY !== "0") {
@@ -17739,20 +18263,22 @@ var LiveHarnesses = class {
     this.stopped = true;
     clearInterval(this.timer);
     this.listeners.clear();
+    this.headless.stop();
     this.opencode.stop();
     this.codex.stop();
+    this.claude.stop();
     this.vscode.stop();
   }
 };
 
 // src/harness/queue.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { spawn as spawn3 } from "node:child_process";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { spawn as spawn5 } from "node:child_process";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
-import { join as join7, dirname as dirname4, basename as basename3 } from "node:path";
+import { join as join8, dirname as dirname5, basename as basename3 } from "node:path";
 import { statSync as statSync2, existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync3, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
 var CODEX_VERSION = "0.160.1";
-var REQUEST_MS4 = 1e4;
+var REQUEST_MS5 = 1e4;
 var MAX_BYTES4 = 1024 * 1024;
 var MAX_PROCESSES3 = 4096;
 var MAX_FILES = 4096;
@@ -17768,9 +18294,9 @@ function sameFile(left, right) {
   return left.path === right.path && left.device === right.device && left.inode === right.inode;
 }
 function packageVersion(executable) {
-  let directory2 = dirname4(executable);
-  for (let depth = 0; depth < 8; depth++, directory2 = dirname4(directory2)) {
-    const path = join7(directory2, "package.json");
+  let directory2 = dirname5(executable);
+  for (let depth = 0; depth < 8; depth++, directory2 = dirname5(directory2)) {
+    const path = join8(directory2, "package.json");
     if (!existsSync5(path)) continue;
     const value2 = JSON.parse(readFileSync3(path, "utf8"));
     if (value2.name?.startsWith("@openai/codex-")) return value2.version;
@@ -17780,40 +18306,40 @@ function packageVersion(executable) {
 function processOwners(pid) {
   const root = `/proc/${pid}`;
   if (process.getuid && statSync2(root).uid !== process.getuid()) return [];
-  const executable = realpathSync2.native(join7(root, "exe"));
+  const executable = realpathSync2.native(join8(root, "exe"));
   if (basename3(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
-  const status2 = readFileSync3(join7(root, "stat"), "utf8");
+  const status2 = readFileSync3(join8(root, "stat"), "utf8");
   const start = status2.slice(status2.lastIndexOf(")") + 2).split(" ")[19];
   if (!start || !/^\d+$/.test(start)) return [];
-  const fds = readdirSync3(join7(root, "fd")).slice(0, MAX_FILES);
+  const fds = readdirSync3(join8(root, "fd")).slice(0, MAX_FILES);
   const files2 = fds.flatMap((fd) => {
     try {
-      return [{ fd, path: readlinkSync(join7(root, "fd", fd)) }];
+      return [{ fd, path: readlinkSync(join8(root, "fd", fd)) }];
     } catch {
       return [];
     }
   });
   return files2.flatMap(({ fd, path }) => {
-    if (basename3(dirname4(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
+    if (basename3(dirname5(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
     const thread = basename3(path, ".lock");
     if (!THREAD_ID.test(thread)) return [];
     try {
-      const lock = readFileSync3(join7(root, "fdinfo", fd), "utf8");
+      const lock = readFileSync3(join8(root, "fdinfo", fd), "utf8");
       if (!/FLOCK\s+ADVISORY\s+WRITE/.test(lock)) return [];
-      const home = realpathSync2.native(dirname4(dirname4(path)));
+      const home = realpathSync2.native(dirname5(dirname5(path)));
       const directory2 = statSync2(home);
       if (process.getuid && directory2.uid !== process.getuid()) return [];
-      const queue = identity(join7(home, "queue_1.sqlite"));
+      const queue = identity(join8(home, "queue_1.sqlite"));
       if (!files2.some((file) => {
         try {
-          return sameFile(identity(join7(root, "fd", file.fd)), queue);
+          return sameFile(identity(join8(root, "fd", file.fd)), queue);
         } catch {
           return false;
         }
       }))
         return [];
       const rollout = files2.find(
-        (file) => file.path.startsWith(join7(home, "sessions") + "/") && file.path.endsWith(`-${thread}.jsonl`)
+        (file) => file.path.startsWith(join8(home, "sessions") + "/") && file.path.endsWith(`-${thread}.jsonl`)
       );
       if (!rollout) return [];
       return [
@@ -17825,7 +18351,7 @@ function processOwners(pid) {
           thread,
           queue,
           version: CODEX_VERSION,
-          cwd: realpathSync2.native(join7(root, "cwd")),
+          cwd: realpathSync2.native(join8(root, "cwd")),
           rollout: identity(rollout.path)
         }
       ];
@@ -17871,7 +18397,7 @@ function validateOwner(owner) {
 function validateEvidence(owner) {
   if (realpathSync2.native(owner.home) !== owner.home || process.getuid && statSync2(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 = join7(owner.home, "thread_history_1.sqlite");
+  const path = join8(owner.home, "thread_history_1.sqlite");
   if (existsSync5(path) && identity(path).path !== path)
     throw new Error("Native history is outside the original home");
 }
@@ -17888,7 +18414,7 @@ function nativeReceipt(owner, clientId) {
   } finally {
     queue.close();
   }
-  const path = join7(owner.home, "thread_history_1.sqlite");
+  const path = join8(owner.home, "thread_history_1.sqlite");
   if (!existsSync5(path)) return { queueId };
   const history = new DatabaseSync3(path, { readOnly: true });
   try {
@@ -17944,7 +18470,7 @@ var Writer = class {
   tail = "";
   pending = /* @__PURE__ */ new Map();
   constructor(owner) {
-    this.process = spawn3(owner.executable, ["app-server", "--listen", "stdio://"], {
+    this.process = spawn5(owner.executable, ["app-server", "--listen", "stdio://"], {
       cwd: owner.cwd,
       env: { ...process.env, CODEX_HOME: owner.home },
       stdio: ["pipe", "pipe", "ignore"]
@@ -17984,7 +18510,7 @@ var Writer = class {
         this.pending.delete(id);
         reject(new Error("Native queue acknowledgement was not received"));
         this.close();
-      }, REQUEST_MS4);
+      }, REQUEST_MS5);
       this.pending.set(id, { resolve: resolve3, reject, timer });
       this.process.stdin.write(JSON.stringify({ id, method, params }) + "\n");
     });
@@ -18031,7 +18557,7 @@ var NativeQueue = class {
     if (existing) return existing;
     if (this.stopped) throw new Error("The connector is stopping");
     validateOwner(scope2.owner);
-    const clientUserMessageId = randomUUID4();
+    const clientUserMessageId = randomUUID5();
     const request2 = { ...scope2, receipt: { state: "unknown", clientUserMessageId } };
     let writer;
     try {
@@ -18116,7 +18642,13 @@ var Command = z2.object({
     z2.object({ kind: z2.literal("thread.stop") }).strict(),
     z2.object({ kind: z2.literal("approval.respond"), approvalId: z2.string(), choice: z2.string() }).strict(),
     z2.object({ kind: z2.literal("screen.start"), sessionId: z2.string().min(1).max(128) }).strict(),
-    z2.object({ kind: z2.literal("screen.stop"), sessionId: z2.string().min(1).max(128) }).strict()
+    z2.object({ kind: z2.literal("screen.stop"), sessionId: z2.string().min(1).max(128) }).strict(),
+    z2.object({
+      kind: z2.literal("session.start"),
+      harness: z2.enum(["claude", "codex", "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 {
@@ -18178,6 +18710,8 @@ var Connector = class {
   listed = /* @__PURE__ */ new Map();
   listedProjects = /* @__PURE__ */ new Map();
   overviewQueued = false;
+  // The agents that can start sessions here.
+  startable = [];
   snapshots = /* @__PURE__ */ new Set();
   nativeSnapshots = /* @__PURE__ */ new Map();
   queueReceipts = /* @__PURE__ */ new Map();
@@ -18191,6 +18725,7 @@ var Connector = class {
       this.nativeSnapshots.set(thread.id, structuredClone(this.threadState(project, thread)));
     }
     this.refreshQueues();
+    void this.findAgents();
     this.stopWatching = this.discovery.watch(this.rescan);
     this.releases.push(this.harnesses.watch(this.rescan));
     this.releases.push(
@@ -18229,15 +18764,15 @@ var Connector = class {
             for (const project of this.discovery.projects.values())
               for (const thread of project.threads) {
                 const native = this.discovery.locations.get(thread.id)?.live;
-                const approval2 = native?.approvals[0];
-                if (!approval2) continue;
+                const approval3 = native?.approvals[0];
+                if (!approval3) continue;
                 await this.thread(pair, project, thread);
                 await this.send(pair, {
                   type: "attention",
                   projectId: project.id,
                   threadId: thread.id,
-                  title: approval2.title,
-                  body: approval2.detail,
+                  title: approval3.title,
+                  body: approval3.detail,
                   reason: "approval"
                 });
               }
@@ -18405,6 +18940,10 @@ var Connector = class {
     }
     return {
       type: "projects",
+      version,
+      screen: this.discovery.capabilities.screen,
+      agents: this.startable,
+      folders: this.discovery.folders(),
       projects: [...this.listedProjects.values()],
       sessions: [
         ...sessions.filter(busy),
@@ -18412,6 +18951,11 @@ var Connector = class {
       ]
     };
   }
+  // Agents change only when someone installs or removes one, so a refresh asks again.
+  async findAgents() {
+    this.startable = await this.harnesses.agents();
+    this.refreshOverview();
+  }
   async listProjects(pair) {
     const overview = this.overview();
     const text3 = JSON.stringify(overview);
@@ -18477,9 +19021,9 @@ var Connector = class {
       if (JSON.stringify(prior) === JSON.stringify(snapshot)) continue;
       this.nativeSnapshots.set(thread.id, structuredClone(snapshot));
       for (const pair of this.activePairs()) await this.thread(pair, project, thread);
-      for (const approval2 of session.approvals)
-        if (!prior?.approvals.some((item) => item.id === approval2.id))
-          await this.attention(project.id, thread.id, approval2.title, approval2.detail, "approval");
+      for (const approval3 of session.approvals)
+        if (!prior?.approvals.some((item) => item.id === approval3.id))
+          await this.attention(project.id, thread.id, approval3.title, approval3.detail, "approval");
       if (prior?.thread.status === "working" && thread.status === "idle")
         await this.attention(
           project.id,
@@ -18561,18 +19105,21 @@ var Connector = class {
   async execute(pair, content, envelope) {
     let queue = void 0;
     try {
-      if (["screen.start", "approval.respond", "thread.stop"].includes(content.action.kind) && Math.abs(Date.now() - Date.parse(envelope.sentAt)) > EPHEMERAL_TTL_MS)
+      if (["screen.start", "approval.respond", "thread.stop", "session.start"].includes(
+        content.action.kind
+      ) && Math.abs(Date.now() - Date.parse(envelope.sentAt)) > EPHEMERAL_TTL_MS)
         throw new Error("Command expired. Try again while this computer is online.");
-      queue = await this.command(pair, content);
+      const outcome = await this.command(pair, content);
       delete this.config.unconfirmed[content.requestId];
-      if (queue) {
+      if (outcome && "state" in outcome) {
+        queue = outcome;
         await this.queueResult(pair, content.requestId, content.projectId, queue);
         this.queueReceipts.set(content.requestId, JSON.stringify(queue));
         return;
       }
       await this.send(
         pair,
-        { type: "result", requestId: content.requestId, ok: true },
+        { type: "result", requestId: content.requestId, ok: true, ...outcome ? { started: outcome } : {} },
         content.projectId
       );
     } catch (error) {
@@ -18607,7 +19154,7 @@ var Connector = class {
     }
   }
   attach(socket) {
-    const sessions = bridgeAcp(socket, (session, approval2) => {
+    const sessions = bridgeAcp(socket, (session, approval3) => {
       this.agents.set(session.id, session);
       const { project, thread } = this.adopt(session);
       if (!this.snapshots.has(session.id)) {
@@ -18622,15 +19169,15 @@ var Connector = class {
           }
         }).catch((error) => this.report(error));
       }
-      if (approval2)
+      if (approval3)
         this.work = this.work.then(async () => {
-          if (this.agents.get(session.id) !== session || ![...session.approvals.values()].includes(approval2))
+          if (this.agents.get(session.id) !== session || ![...session.approvals.values()].includes(approval3))
             return;
           await this.attention(
             project.id,
             thread.id,
-            approval2.title,
-            approval2.detail,
+            approval3.title,
+            approval3.detail,
             "approval"
           );
         }).catch((error) => this.report(error));
@@ -18699,9 +19246,12 @@ var Connector = class {
   }
   async command(pair, command2) {
     if (command2.action.kind === "projects.refresh") {
+      await this.findAgents();
       await this.changed();
       return this.publishProjects(pair);
     }
+    if (command2.action.kind === "session.start")
+      return this.startSession(command2.projectId, command2.action);
     const project = this.discovery.projects.get(command2.projectId);
     if (!project) throw new Error("Project is no longer open on this computer");
     const thread = project.threads.find((item) => item.id === command2.threadId);
@@ -18758,15 +19308,15 @@ var Connector = class {
         const action = command2.action;
         const native = this.discovery.locations.get(thread.id)?.live;
         if (native?.approve) {
-          const approval3 = native.approvals.find((item) => item.id === action.approvalId);
-          if (!approval3?.choices.some((choice) => choice.id === action.choice))
+          const approval4 = native.approvals.find((item) => item.id === action.approvalId);
+          if (!approval4?.choices.some((choice) => choice.id === action.choice))
             throw new Error("Approval is no longer available");
-          return native.approve(command2.requestId, approval3.id, action.choice);
+          return native.approve(command2.requestId, approval4.id, action.choice);
         }
         const agent = this.attached(thread);
         if (!agent) throw new Error("Approval requires an attached ACP session. Use Screen.");
-        const [request2, approval2] = [...agent.approvals].find(([, item]) => item.id === action.approvalId) ?? [];
-        if (!approval2?.choices.some((choice) => choice.id === action.choice))
+        const [request2, approval3] = [...agent.approvals].find(([, item]) => item.id === action.approvalId) ?? [];
+        if (!approval3?.choices.some((choice) => choice.id === action.choice))
           throw new Error("Approval is no longer available");
         return commandAcp(agent, command2.requestId, {
           kind: "approval",
@@ -18782,6 +19332,37 @@ var Connector = class {
         return;
     }
   }
+  // Starts an agent in a project, or in a new folder inside one this computer offers. Commands run
+  // in the work queue, so this refreshes directly rather than queueing a change behind itself.
+  async startSession(projectId, { harness, text: text3, folder }) {
+    if (!this.startable.includes(harness))
+      throw new Error(`${HARNESSES[harness]} doesn't run on this computer`);
+    let cwd;
+    if (folder) {
+      const name = folder.name.trim();
+      if (!this.discovery.folders().includes(folder.parent))
+        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);
+      await mkdir(cwd).catch((error) => {
+        throw new Error(error.code === "EEXIST" ? `${name} already exists` : `Couldn't create ${name}`);
+      });
+    } else {
+      const project = this.discovery.projects.get(projectId);
+      if (!project) throw new Error("Project is no longer open on this computer");
+      if (project.remote)
+        throw new Error(`Install -up on ${project.remote.host} to start sessions there`);
+      cwd = project.path;
+    }
+    const session = await this.harnesses.start(harness, cwd, text3);
+    await this.changed();
+    for (const project of this.discovery.projects.values())
+      for (const thread of project.threads)
+        if (thread.agent?.harness === harness && thread.agent.sessionId === session)
+          return { projectId: project.id, threadId: thread.id };
+    throw new Error(`${HARNESSES[harness]} started, but this computer hasn't listed it yet`);
+  }
   report(error) {
     process.stderr.write(`${error instanceof Error ? error.message : "Dashup operation failed"}
 `);
@@ -18790,19 +19371,19 @@ var Connector = class {
 
 // src/install.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { promisify as promisify4 } from "node:util";
+import { homedir as homedir6, userInfo } from "node:os";
+import { promisify as promisify7 } from "node:util";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { execFile as execFile4, spawn as spawn4 } from "node:child_process";
-import { cp, mkdir, rm, writeFile } from "node:fs/promises";
-import { dirname as dirname5, join as join8, relative, sep } from "node:path";
-var run4 = promisify4(execFile4);
+import { execFile as execFile7, spawn as spawn6 } from "node:child_process";
+import { cp, mkdir as mkdir2, rm, writeFile } from "node:fs/promises";
+import { dirname as dirname6, join as join10, 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 serviceFile = () => process.platform === "darwin" ? join8(homedir6(), "Library/LaunchAgents/com.dashup.connector.plist") : process.platform === "win32" ? join8(
-  process.env.APPDATA ?? join8(homedir6(), "AppData/Roaming"),
+var serviceFile = () => process.platform === "darwin" ? join10(homedir6(), "Library/LaunchAgents/com.dashup.connector.plist") : process.platform === "win32" ? join10(
+  process.env.APPDATA ?? join10(homedir6(), "AppData/Roaming"),
   "Microsoft/Windows/Start Menu/Programs/Startup/Dashup.vbs"
-) : join8(homedir6(), ".config/systemd/user/dashup.service");
+) : join10(homedir6(), ".config/systemd/user/dashup.service");
 var startupInstalled = () => existsSync6(serviceFile());
 function service(platform, node, entry, config2) {
   const command2 = [node, ...NODE_FLAGS, entry];
@@ -18838,17 +19419,17 @@ 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 = join8(dirname5(configPath()), "app");
+  const app = join10(dirname6(configPath()), "app");
   await rm(app, { recursive: true, force: true });
-  await cp(join8(root, "node_modules"), join8(app, "node_modules"), {
+  await cp(join10(root, "node_modules"), join10(app, "node_modules"), {
     recursive: true,
     verbatimSymlinks: true
   });
-  return join8(app, relative(root, entry));
+  return join10(app, relative(root, entry));
 }
 async function installStartup() {
   const path = serviceFile();
-  await mkdir(dirname5(path), { recursive: true });
+  await mkdir2(dirname6(path), { recursive: true });
   await writeFile(
     path,
     service(process.platform, process.execPath, await durableEntry(), configPath())
@@ -18858,13 +19439,28 @@ async function installStartup() {
     });
     await run4("launchctl", ["load", path]);
   } else if (process.platform === "win32") {
-    spawn4("wscript.exe", [path], { detached: true, stdio: "ignore" }).unref();
+    spawn6("wscript.exe", [path], { detached: true, stdio: "ignore" }).unref();
   } else {
     await run4("systemctl", ["--user", "daemon-reload"]);
     await run4("systemctl", ["--user", "enable", "dashup.service"]);
     await run4("systemctl", ["--user", "restart", "dashup.service"]);
+    if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)
+      return run4("loginctl", ["enable-linger"]).then(
+        () => void 0,
+        () => `It stops when you log out. To keep it running, run sudo loginctl enable-linger ${userInfo().username}.`
+      );
   }
 }
+async function uninstallStartup() {
+  const path = serviceFile();
+  if (process.platform === "darwin") await run4("launchctl", ["unload", path]).catch(() => {
+  });
+  else if (process.platform !== "win32")
+    await run4("systemctl", ["--user", "disable", "dashup.service"]).catch(() => {
+    });
+  await rm(path, { force: true });
+  await rm(join10(dirname6(configPath()), "app"), { recursive: true, force: true });
+}
 
 // src/index.ts
 var config = loadConfig();
@@ -18902,9 +19498,9 @@ async function background() {
   try {
     await running("/stop", { method: "POST" }).catch(() => null);
     await answering(false);
-    await installStartup();
+    const note = await installStartup();
     if (await answering(true)) {
-      const message = "Dashup runs in the background and starts when you sign in.";
+      const message = `Dashup runs in the background and starts when you sign in.${note ? ` ${note}` : ""}`;
       if (waiting) waiting.stop(message);
       else process.stdout.write(`${message}
 `);
@@ -18941,11 +19537,21 @@ async function main() {
       throw new Error("Use a separate DASHUP_CONFIG file to connect a different server");
     config.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 (!await background()) process.exitCode = 1;
     return;
   }
+  if (command === "uninstall") {
+    await running("/stop", { method: "POST" }).catch(() => null);
+    await answering(false);
+    await uninstallStartup();
+    process.stdout.write("Dashup no longer starts when you sign in. This computer stays paired.\n");
+    return;
+  }
   if (command === "stop") {
     const response = await running("/stop", { method: "POST" }).catch(refused);
     if (!response) throw new Error("Dashup is not running on this computer");
@@ -19036,20 +19642,24 @@ async function main() {
   }
   if (!["pair", "watch"].includes(command)) {
     process.stdout.write(
-      "Dashup: pair | watch | projects | alert --project <id> | doctor | permissions --screen --control | stop | acp -- <original-agent-command> | install\n"
+      "Dashup: pair [--account <email>] | watch | projects | alert --project <id> | doctor | permissions --screen --control | stop | acp -- <original-agent-command> | install | uninstall\n"
     );
     return;
   }
   const pairPhone = (invite) => scanned(config, invite, (email) => `Paired a phone signed in as ${email}`);
   const keepRunning = async (stopHere) => {
-    if (!interactive) return;
-    const answer = startupInstalled() || await ui2.confirm({ message: BACKGROUND });
-    if (answer === true) {
+    const answer = startupInstalled() || interactive && await ui2.confirm({ message: BACKGROUND }) === true;
+    if (answer) {
       stopHere();
       const started = await background();
       ui2.outro(started ? DONE2 : "Run dashup to keep Dashup running in this terminal.");
       process.exit(started ? 0 : 1);
     }
+    if (!interactive) {
+      stopHere();
+      process.stdout.write("Paired. Run dashup install to keep Dashup running in the background.\n");
+      process.exit(0);
+    }
     ui2.log.info("Dashup runs in this terminal. Keep it open; Ctrl+C stops it.");
     ui2.outro(DONE2);
   };
@@ -19075,10 +19685,12 @@ async function main() {
     if (interactive) ui2.outro(DONE2);
     process.exit();
   }
-  if (!config.secret && !interactive)
-    throw new Error("Run dashup pair in a terminal to pair this computer.");
+  if (!config.secret && !interactive && !account)
+    throw new Error(
+      "To pair this computer, run dashup pair in a terminal, or add --account with your Dashup email."
+    );
   let connector;
-  const server = createServer(async (request2, response) => {
+  const server = createServer2(async (request2, response) => {
     if (!authorized(request2)) {
       response.writeHead(403).end();
       return;
@@ -19157,7 +19769,7 @@ async function main() {
     const linking = !config.secret;
     if (linking) {
       intro2();
-      if (!await link(config)) process.exit(1);
+      if (!await link(config, account)) process.exit(1);
       await keepRunning(() => server.close());
     }
     connector = new Connector(config);