sakuraai 0.0.1

package/dist/index.js

@@ -0,0 +1,1996 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+import os from "os";
+import path from "path";
+import fs from "fs";
+import { randomUUID } from "crypto";
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function readJson(file, fallback) {
+  try {
+    return { ...fallback, ...JSON.parse(fs.readFileSync(file, "utf8")) };
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(file, value) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
+}
+function defaultConfig() {
+  const hostname2 = os.hostname();
+  return {
+    machineId: randomUUID(),
+    machineName: hostname2,
+    defaultWorkspace: "local",
+    workspaces: [{ id: "local", name: "Local", slug: "local" }],
+    projects: [],
+    agentConfigs: [],
+    daemon: { host: DEFAULT_HOST, port: DEFAULT_PORT }
+  };
+}
+function loadConfig() {
+  if (_config) return _config;
+  const cfg = readJson(CONFIG_PATH, defaultConfig());
+  if (!fs.existsSync(CONFIG_PATH)) writeJson(CONFIG_PATH, cfg);
+  _config = cfg;
+  return cfg;
+}
+function saveConfig(cfg) {
+  _config = cfg;
+  writeJson(CONFIG_PATH, cfg);
+}
+function updateConfig(mut) {
+  const cfg = loadConfig();
+  mut(cfg);
+  saveConfig(cfg);
+  return cfg;
+}
+function loadAuth() {
+  return readJson(AUTH_PATH, {});
+}
+function saveAuth(auth) {
+  writeJson(AUTH_PATH, auth);
+}
+function clearAuth() {
+  try {
+    fs.rmSync(AUTH_PATH, { force: true });
+  } catch {
+  }
+}
+function ensureSakuraDirs() {
+  ensureDir(SAKURA_DIR);
+  ensureDir(LOG_DIR);
+}
+var SAKURA_DIR, CONFIG_PATH, AUTH_PATH, DAEMON_PATH, PID_PATH, LOG_DIR, LOG_PATH, DEFAULT_PORT, DEFAULT_HOST, _config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    SAKURA_DIR = process.env.SAKURA_HOME ?? path.join(os.homedir(), ".sakura");
+    CONFIG_PATH = path.join(SAKURA_DIR, "config.json");
+    AUTH_PATH = path.join(SAKURA_DIR, "auth.json");
+    DAEMON_PATH = path.join(SAKURA_DIR, "daemon.json");
+    PID_PATH = path.join(SAKURA_DIR, "daemon.pid");
+    LOG_DIR = path.join(SAKURA_DIR, "logs");
+    LOG_PATH = path.join(LOG_DIR, "daemon.log");
+    DEFAULT_PORT = Number(process.env.SAKURA_PORT ?? 4787);
+    DEFAULT_HOST = process.env.SAKURA_HOST ?? "127.0.0.1";
+    _config = null;
+  }
+});
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  getToken: () => getToken,
+  isLoggedIn: () => isLoggedIn,
+  login: () => login,
+  logout: () => logout,
+  requireToken: () => requireToken
+});
+import { randomBytes } from "crypto";
+import os2 from "os";
+function getToken() {
+  return process.env.SAKURA_AUTH || loadAuth().token;
+}
+function isLoggedIn() {
+  return !!getToken();
+}
+function generateToken() {
+  return "sk_" + randomBytes(24).toString("hex");
+}
+function login(opts = {}) {
+  const token = opts.auth?.trim() || generateToken();
+  const machineName = opts.machineName?.trim() || os2.hostname();
+  const state = {
+    token,
+    serverUrl: opts.serverUrl,
+    machineName,
+    login: process.env.USER || machineName,
+    loggedInAt: Date.now()
+  };
+  saveAuth(state);
+  updateConfig((cfg) => {
+    cfg.machineName = machineName;
+  });
+  return state;
+}
+function logout() {
+  clearAuth();
+}
+function requireToken() {
+  const t = getToken();
+  if (!t) {
+    throw new Error(
+      "Not signed in. Run `sakuraai login` (or `sakuraai login --auth <token>`) first."
+    );
+  }
+  return t;
+}
+var init_auth = __esm({
+  "src/auth.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/util/output.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+function printJson(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function printJsonl(rows) {
+  for (const r of rows) process.stdout.write(JSON.stringify(r) + "\n");
+}
+function printTable(headers, rows) {
+  const table = new Table({
+    head: headers.map((h) => chalk.bold(h)),
+    style: { head: [], border: [] }
+  });
+  for (const r of rows) table.push(r.map((c) => String(c)));
+  process.stdout.write(table.toString() + "\n");
+}
+function success(msg) {
+  process.stdout.write(chalk.green("\u2713 ") + msg + "\n");
+}
+function info(msg) {
+  process.stdout.write(msg + "\n");
+}
+function warn(msg) {
+  process.stdout.write(chalk.yellow("! ") + msg + "\n");
+}
+function die(msg, code = 1) {
+  process.stderr.write(chalk.red("\u2717 ") + msg + "\n");
+  process.exit(code);
+}
+var init_output = __esm({
+  "src/util/output.ts"() {
+    "use strict";
+  }
+});
+
+// src/logger.ts
+import fs2 from "fs";
+function enableFileLogging() {
+  ensureSakuraDirs();
+  fileLogging = true;
+}
+function write(level, args) {
+  if (LEVELS[level] < threshold) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `${ts} ${level.toUpperCase()} ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}`;
+  process.stderr.write(line + "\n");
+  if (fileLogging) {
+    try {
+      fs2.appendFileSync(LOG_PATH, line + "\n");
+    } catch {
+    }
+  }
+}
+var LEVELS, threshold, fileLogging, log;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    init_config();
+    LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
+    threshold = LEVELS[process.env.SAKURA_LOG_LEVEL ?? "info"] ?? 20;
+    fileLogging = false;
+    log = {
+      debug: (...a) => write("debug", a),
+      info: (...a) => write("info", a),
+      warn: (...a) => write("warn", a),
+      error: (...a) => write("error", a)
+    };
+  }
+});
+
+// src/runtime/util.ts
+import os3 from "os";
+function nowSecs() {
+  return Math.floor(Date.now() / 1e3);
+}
+function formatAge(ageSecs) {
+  if (ageSecs < 3600) return `${Math.floor(Math.max(ageSecs, 60) / 60)}m`;
+  if (ageSecs < 86400) return `${Math.floor(ageSecs / 3600)}h`;
+  return `${Math.floor(ageSecs / 86400)}d`;
+}
+function statusFromAge(ageSecs) {
+  if (ageSecs < 3600) return "active";
+  if (ageSecs < 86400) return "idle";
+  return "done";
+}
+function hostname() {
+  return os3.hostname();
+}
+function stripLeadingTags(input) {
+  let rest = input.trimStart();
+  while (rest.startsWith("<")) {
+    const close = rest.indexOf(">");
+    if (close === -1) break;
+    const tag = rest.slice(1, close).split(/\s+/)[0]?.replace(/\/$/, "");
+    if (!tag) break;
+    const endTag = `</${tag}>`;
+    const end = rest.indexOf(endTag);
+    if (end === -1) break;
+    rest = rest.slice(end + endTag.length).trimStart();
+  }
+  return rest;
+}
+function extractTextFromContent(content) {
+  let raw = null;
+  if (Array.isArray(content)) {
+    const part = content.find(
+      (p) => p && typeof p === "object" && p.type === "text"
+    );
+    raw = part?.text ?? null;
+  } else if (typeof content === "string") {
+    raw = content;
+  }
+  if (raw == null) return null;
+  const stripped = stripLeadingTags(raw);
+  const title = stripped.replace(/\n/g, " ").slice(0, 80).trim();
+  return title.length ? title : null;
+}
+function extractAssistantText(content) {
+  const parts = [];
+  let hasTools = false;
+  if (Array.isArray(content)) {
+    for (const p of content) {
+      const t = p?.type;
+      if (t === "text" && typeof p.text === "string") parts.push(p.text);
+      else if (t === "tool_use" || t === "tool_result") hasTools = true;
+    }
+  } else if (typeof content === "string") {
+    parts.push(content);
+  }
+  return { text: parts.join(""), hasTools };
+}
+function parseIsoUnix(s) {
+  const t = Date.parse(s);
+  return Number.isNaN(t) ? null : Math.floor(t / 1e3);
+}
+function chronoIso(secs) {
+  return new Date(secs * 1e3).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+var HOME;
+var init_util = __esm({
+  "src/runtime/util.ts"() {
+    "use strict";
+    HOME = os3.homedir();
+  }
+});
+
+// src/runtime/claude.ts
+import fs3 from "fs";
+import path2 from "path";
+import { spawn } from "child_process";
+function* jsonlEntries(file) {
+  let content;
+  try {
+    content = fs3.readFileSync(file, "utf8");
+  } catch {
+    return;
+  }
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      yield JSON.parse(line);
+    } catch {
+    }
+  }
+}
+function sessionTitle(file) {
+  for (let pass = 0; pass < 2; pass++) {
+    for (const entry of jsonlEntries(file)) {
+      if (entry?.type !== "user") continue;
+      if (pass === 0 && entry?.userType !== "external") continue;
+      const title = extractTextFromContent(entry?.message?.content);
+      if (title) return title;
+    }
+  }
+  return "Untitled";
+}
+function listSessions() {
+  const host = hostname();
+  const now = nowSecs();
+  const out = [];
+  let dirs;
+  try {
+    dirs = fs3.readdirSync(PROJECTS_DIR, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const d of dirs) {
+    if (!d.isDirectory()) continue;
+    const dir = path2.join(PROJECTS_DIR, d.name);
+    let files;
+    try {
+      files = fs3.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      if (!f.endsWith(".jsonl")) continue;
+      const p = path2.join(dir, f);
+      let mtime;
+      try {
+        mtime = Math.floor(fs3.statSync(p).mtimeMs / 1e3);
+      } catch {
+        continue;
+      }
+      const age = Math.max(0, now - mtime);
+      out.push({
+        id: f.replace(/\.jsonl$/, ""),
+        title: sessionTitle(p),
+        agent: "claude",
+        status: statusFromAge(age),
+        updatedAt: formatAge(age),
+        machine: host,
+        mtime
+      });
+    }
+  }
+  return out;
+}
+function findFile(sessionId) {
+  let dirs;
+  try {
+    dirs = fs3.readdirSync(PROJECTS_DIR);
+  } catch {
+    return null;
+  }
+  for (const d of dirs) {
+    const p = path2.join(PROJECTS_DIR, d, `${sessionId}.jsonl`);
+    if (fs3.existsSync(p)) return p;
+  }
+  return null;
+}
+function readMessages(file) {
+  const msgs = [];
+  let startSecs = null;
+  for (const entry of jsonlEntries(file)) {
+    if (entry?.isSidechain === true) continue;
+    const tsStr = entry?.timestamp ?? "";
+    const tsSecs = parseIsoUnix(tsStr);
+    if (startSecs == null) startSecs = tsSecs;
+    if (entry?.type === "user") {
+      if (entry?.userType !== "external") continue;
+      const text = extractTextFromContent(entry?.message?.content);
+      if (text) {
+        msgs.push({
+          id: entry?.uuid ?? "",
+          role: "user",
+          content: text,
+          timestamp: tsStr,
+          hasToolUse: false
+        });
+      }
+    } else if (entry?.type === "assistant") {
+      const { text, hasTools } = extractAssistantText(entry?.message?.content);
+      if (!text) continue;
+      const inputTokens = entry?.message?.usage?.input_tokens;
+      const elapsed = startSecs != null && tsSecs != null ? Math.max(0, tsSecs - startSecs) : void 0;
+      msgs.push({
+        id: entry?.uuid ?? "",
+        role: "assistant",
+        content: text,
+        timestamp: tsStr,
+        hasToolUse: hasTools,
+        inputTokens: typeof inputTokens === "number" ? inputTokens : void 0,
+        elapsedSecs: elapsed
+      });
+    }
+  }
+  return msgs;
+}
+function messages(sessionId) {
+  const file = findFile(sessionId);
+  return file ? readMessages(file) : [];
+}
+function send(sessionId, message) {
+  return new Promise((resolve) => {
+    const bin = process.env.CLAUDE_BIN || "claude";
+    const child = spawn(bin, ["--resume", sessionId, "-p", message], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on(
+      "error",
+      (e) => resolve({ ok: false, output: "", error: e.message })
+    );
+    child.on(
+      "close",
+      (code) => resolve({
+        ok: code === 0,
+        output: out.trim(),
+        error: code === 0 ? void 0 : err.trim() || `exited ${code}`
+      })
+    );
+  });
+}
+var PROJECTS_DIR;
+var init_claude = __esm({
+  "src/runtime/claude.ts"() {
+    "use strict";
+    init_util();
+    PROJECTS_DIR = path2.join(HOME, ".claude", "projects");
+  }
+});
+
+// src/runtime/codex.ts
+import fs4 from "fs";
+import path3 from "path";
+import { spawn as spawn2 } from "child_process";
+function codexBin() {
+  if (process.env.CODEX_BIN) return process.env.CODEX_BIN;
+  if (fs4.existsSync(MAC_APP_BIN)) return MAC_APP_BIN;
+  return "codex";
+}
+function listSessions2() {
+  const host = hostname();
+  const now = nowSecs();
+  let content;
+  try {
+    content = fs4.readFileSync(INDEX_PATH, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const id = entry?.id;
+    const title = entry?.thread_name;
+    const updatedAt = entry?.updated_at;
+    if (!id || !title || !updatedAt) continue;
+    const mtime = parseIsoUnix(updatedAt);
+    if (mtime == null) continue;
+    const age = Math.max(0, now - mtime);
+    out.push({
+      id,
+      title,
+      agent: "codex",
+      status: statusFromAge(age),
+      updatedAt: formatAge(age),
+      machine: host,
+      mtime
+    });
+  }
+  return out;
+}
+function findFile2(sessionId) {
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const e of entries) {
+      const p = path3.join(dir, e.name);
+      if (e.isDirectory()) {
+        const found = walk(p);
+        if (found) return found;
+      } else if (e.name.endsWith(".jsonl") && e.name.includes(sessionId)) {
+        return p;
+      }
+    }
+    return null;
+  };
+  return walk(SESSIONS_DIR);
+}
+function readMessages2(file) {
+  let content;
+  try {
+    content = fs4.readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  const msgs = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry?.type !== "response_item") continue;
+    const payload = entry?.payload;
+    if (payload?.type !== "message") continue;
+    const role = payload?.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const part = Array.isArray(payload?.content) ? payload.content.find(
+      (p) => ["input_text", "output_text", "text"].includes(p?.type)
+    ) : null;
+    const text = part?.text ?? "";
+    if (!text) continue;
+    const ts = entry?.timestamp ?? "";
+    msgs.push({ id: ts, role, content: text, timestamp: ts, hasToolUse: false });
+  }
+  return msgs;
+}
+function messages2(sessionId) {
+  const file = findFile2(sessionId);
+  return file ? readMessages2(file) : [];
+}
+function send2(sessionId, message) {
+  return new Promise((resolve) => {
+    const child = spawn2(codexBin(), ["exec", "resume", sessionId, message], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on("error", (e) => resolve({ ok: false, output: "", error: e.message }));
+    child.on(
+      "close",
+      (code) => resolve({
+        ok: code === 0,
+        output: out.trim(),
+        error: code === 0 ? void 0 : err.trim() || `exited ${code}`
+      })
+    );
+  });
+}
+var CODEX_DIR, INDEX_PATH, SESSIONS_DIR, MAC_APP_BIN;
+var init_codex = __esm({
+  "src/runtime/codex.ts"() {
+    "use strict";
+    init_util();
+    CODEX_DIR = path3.join(HOME, ".codex");
+    INDEX_PATH = path3.join(CODEX_DIR, "session_index.jsonl");
+    SESSIONS_DIR = path3.join(CODEX_DIR, "sessions");
+    MAC_APP_BIN = "/Applications/Codex.app/Contents/Resources/codex";
+  }
+});
+
+// src/runtime/opencode.ts
+import path4 from "path";
+import fs5 from "fs";
+import { spawn as spawn3 } from "child_process";
+function opencodeBin() {
+  if (process.env.OPENCODE_BIN) return process.env.OPENCODE_BIN;
+  if (fs5.existsSync(MAC_APP_BIN2)) return MAC_APP_BIN2;
+  return "opencode";
+}
+async function loadDriver() {
+  if (_ctor !== void 0) return _ctor;
+  try {
+    const mod = await import("better-sqlite3");
+    _ctor = mod.default ?? mod;
+  } catch {
+    _ctor = null;
+  }
+  return _ctor ?? null;
+}
+function available() {
+  return fs5.existsSync(DB_PATH);
+}
+async function open() {
+  if (!available()) return null;
+  const Ctor = await loadDriver();
+  if (!Ctor) return null;
+  try {
+    return new Ctor(DB_PATH, { readonly: true, fileMustExist: true });
+  } catch {
+    return null;
+  }
+}
+async function listSessions3() {
+  const db = await open();
+  if (!db) return [];
+  const host = hostname();
+  const now = nowSecs();
+  try {
+    const rows = db.prepare(
+      "SELECT id, title, time_updated FROM session WHERE time_archived IS NULL ORDER BY time_updated DESC"
+    ).all();
+    return rows.map((r) => {
+      const mtime = Math.floor(r.time_updated / 1e3);
+      const age = Math.max(0, now - mtime);
+      return {
+        id: r.id,
+        title: r.title,
+        agent: "opencode",
+        status: statusFromAge(age),
+        updatedAt: formatAge(age),
+        machine: host,
+        mtime
+      };
+    });
+  } finally {
+    db.close();
+  }
+}
+async function messages3(sessionId) {
+  const db = await open();
+  if (!db) return [];
+  try {
+    const msgRows = db.prepare(
+      "SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created ASC"
+    ).all(sessionId);
+    const partRows = db.prepare(
+      "SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC"
+    ).all(sessionId);
+    const partsMap = /* @__PURE__ */ new Map();
+    for (const p of partRows) {
+      try {
+        const v = JSON.parse(p.data);
+        if (v?.type === "text" && typeof v.text === "string") {
+          const arr = partsMap.get(p.message_id) ?? [];
+          arr.push(v.text);
+          partsMap.set(p.message_id, arr);
+        }
+      } catch {
+      }
+    }
+    const startMs = msgRows[0]?.time_created ?? 0;
+    const out = [];
+    for (const m of msgRows) {
+      let v;
+      try {
+        v = JSON.parse(m.data);
+      } catch {
+        continue;
+      }
+      const role = v?.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const text = (partsMap.get(m.id) ?? []).join("");
+      if (!text) continue;
+      const mtime = Math.floor(m.time_created / 1e3);
+      out.push({
+        id: m.id,
+        role,
+        content: text,
+        timestamp: chronoIso(mtime),
+        hasToolUse: false,
+        elapsedSecs: role === "assistant" ? Math.floor((m.time_created - startMs) / 1e3) : void 0
+      });
+    }
+    return out;
+  } finally {
+    db.close();
+  }
+}
+function send3(sessionId, message) {
+  return new Promise((resolve) => {
+    const child = spawn3(opencodeBin(), ["run", "-s", sessionId, message], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on("error", (e) => resolve({ ok: false, output: "", error: e.message }));
+    child.on(
+      "close",
+      (code) => resolve({
+        ok: code === 0,
+        output: out.trim(),
+        error: code === 0 ? void 0 : err.trim() || `exited ${code}`
+      })
+    );
+  });
+}
+var DB_PATH, MAC_APP_BIN2, _ctor;
+var init_opencode = __esm({
+  "src/runtime/opencode.ts"() {
+    "use strict";
+    init_util();
+    DB_PATH = path4.join(HOME, ".local", "share", "opencode", "opencode.db");
+    MAC_APP_BIN2 = "/Applications/OpenCode.app/Contents/MacOS/opencode-cli";
+  }
+});
+
+// src/runtime/sessions.ts
+import { spawn as spawn4 } from "child_process";
+async function list(opts = {}) {
+  let sessions = [];
+  if (!opts.agent || opts.agent === "claude") sessions.push(...listSessions());
+  if (!opts.agent || opts.agent === "codex") sessions.push(...listSessions2());
+  if (!opts.agent || opts.agent === "opencode")
+    sessions.push(...await listSessions3());
+  sessions.sort((a, b) => b.mtime - a.mtime);
+  if (opts.limit && opts.limit > 0) sessions = sessions.slice(0, opts.limit);
+  return sessions;
+}
+async function show(sessionId) {
+  const all = await list();
+  return all.find((s) => s.id === sessionId) ?? null;
+}
+async function detectAgent(sessionId) {
+  if (findFile(sessionId)) return "claude";
+  if (findFile2(sessionId)) return "codex";
+  const oc = await messages3(sessionId);
+  if (oc.length) return "opencode";
+  return null;
+}
+async function messages4(sessionId, agent) {
+  const a = agent ?? await detectAgent(sessionId);
+  switch (a) {
+    case "claude":
+      return messages(sessionId);
+    case "codex":
+      return messages2(sessionId);
+    case "opencode":
+      return messages3(sessionId);
+    default:
+      return [];
+  }
+}
+async function history(sessionId, opts = {}, agent) {
+  let msgs = await messages4(sessionId, agent);
+  if (!opts.all && opts.limit && opts.limit > 0) {
+    msgs = msgs.slice(-opts.limit);
+  }
+  if (opts.reverse) msgs = [...msgs].reverse();
+  return msgs;
+}
+async function chat(sessionId, prompt, agent) {
+  const a = agent ?? await detectAgent(sessionId);
+  if (a === "claude") return send(sessionId, prompt);
+  if (a === "codex") return send2(sessionId, prompt);
+  if (a === "opencode") return send3(sessionId, prompt);
+  return {
+    ok: false,
+    output: "",
+    error: `Sending is not supported for this session (got ${a ?? "unknown"}).`
+  };
+}
+function create(prompt, opts = {}) {
+  const agent = opts.agent ?? "claude";
+  if (agent !== "claude") {
+    return Promise.resolve({
+      ok: false,
+      output: "",
+      error: `Creating sessions from the CLI is only supported for Claude (got ${agent}).`
+    });
+  }
+  return new Promise((resolve) => {
+    const bin = process.env.CLAUDE_BIN || "claude";
+    const child = spawn4(bin, ["-p", prompt], {
+      cwd: opts.cwd || process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on("error", (e) => resolve({ ok: false, output: "", error: e.message }));
+    child.on(
+      "close",
+      (code) => resolve({
+        ok: code === 0,
+        output: out.trim(),
+        error: code === 0 ? void 0 : err.trim() || `exited ${code}`
+      })
+    );
+  });
+}
+var init_sessions = __esm({
+  "src/runtime/sessions.ts"() {
+    "use strict";
+    init_claude();
+    init_codex();
+    init_opencode();
+  }
+});
+
+// src/runtime/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  addProject: () => addProject,
+  createAgentConfig: () => createAgentConfig,
+  deleteAgentConfig: () => deleteAgentConfig,
+  deleteProject: () => deleteProject,
+  listAgentConfigs: () => listAgentConfigs,
+  listMachines: () => listMachines,
+  listProjects: () => listProjects,
+  listWorkspaces: () => listWorkspaces,
+  refreshCapabilities: () => refreshCapabilities,
+  resolveAgentConfig: () => resolveAgentConfig,
+  resolveProject: () => resolveProject,
+  thisMachine: () => thisMachine,
+  updateAgentConfig: () => updateAgentConfig
+});
+import os4 from "os";
+import fs6 from "fs";
+import path5 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function listWorkspaces() {
+  return loadConfig().workspaces;
+}
+function detectCli() {
+  const found = [];
+  const candidates = {
+    claude: process.env.CLAUDE_BIN || "claude",
+    codex: process.env.CODEX_BIN || "codex",
+    opencode: process.env.OPENCODE_BIN || "opencode"
+  };
+  const pathDirs = (process.env.PATH || "").split(path5.delimiter);
+  for (const [name, bin] of Object.entries(candidates)) {
+    const onPath = pathDirs.some((dir) => {
+      try {
+        return fs6.existsSync(path5.join(dir, bin));
+      } catch {
+        return false;
+      }
+    });
+    const home = os4.homedir();
+    const dataDirs = {
+      claude: path5.join(home, ".claude"),
+      codex: path5.join(home, ".codex"),
+      opencode: path5.join(home, ".local", "share", "opencode")
+    };
+    if (onPath || fs6.existsSync(dataDirs[name] ?? "")) found.push(name);
+  }
+  return found;
+}
+function thisMachine() {
+  const cfg = loadConfig();
+  return {
+    id: cfg.machineId,
+    name: cfg.machineName,
+    online: true,
+    os: `${os4.type()} ${os4.release()}`,
+    hostname: os4.hostname(),
+    cli: detectCli()
+  };
+}
+function listMachines(onlineOnly = false) {
+  const m = thisMachine();
+  if (onlineOnly && !m.online) return [];
+  return [m];
+}
+function listProjects() {
+  return loadConfig().projects;
+}
+function addProject(dir, name) {
+  const abs = path5.resolve(dir);
+  if (!fs6.existsSync(abs) || !fs6.statSync(abs).isDirectory()) {
+    throw new Error(`Not a directory: ${abs}`);
+  }
+  const existing = loadConfig().projects.find((p) => p.path === abs);
+  if (existing) return existing;
+  const project = {
+    id: randomUUID2(),
+    name: name || path5.basename(abs),
+    path: abs,
+    addedAt: Date.now()
+  };
+  updateConfig((cfg) => {
+    cfg.projects.push(project);
+  });
+  return project;
+}
+function deleteProject(idOrNameOrPath) {
+  let removed = false;
+  updateConfig((cfg) => {
+    const before = cfg.projects.length;
+    cfg.projects = cfg.projects.filter(
+      (p) => p.id !== idOrNameOrPath && p.name !== idOrNameOrPath && p.path !== path5.resolve(idOrNameOrPath)
+    );
+    removed = cfg.projects.length !== before;
+  });
+  return removed;
+}
+function resolveProject(idOrNameOrPath) {
+  const cfg = loadConfig();
+  const abs = path5.resolve(idOrNameOrPath);
+  return cfg.projects.find(
+    (p) => p.id === idOrNameOrPath || p.name === idOrNameOrPath || p.path === abs
+  ) ?? null;
+}
+function listAgentConfigs() {
+  return loadConfig().agentConfigs;
+}
+function resolveAgentConfig(idOrName) {
+  const cfg = loadConfig();
+  const matches = cfg.agentConfigs.filter(
+    (a) => a.id === idOrName || a.name === idOrName
+  );
+  if (matches.length > 1 && !cfg.agentConfigs.some((a) => a.id === idOrName)) {
+    throw new Error(
+      `Multiple agent-configs named "${idOrName}". Use the explicit id instead.`
+    );
+  }
+  return matches[0] ?? null;
+}
+function createAgentConfig(input) {
+  const now = Date.now();
+  const config = {
+    id: randomUUID2(),
+    name: input.name,
+    agentType: input.agentType,
+    description: input.description,
+    env: input.env ?? {},
+    prompt: input.prompt,
+    createdAt: now,
+    updatedAt: now
+  };
+  updateConfig((cfg) => {
+    cfg.agentConfigs.push(config);
+  });
+  return config;
+}
+function updateAgentConfig(idOrName, input) {
+  const target = resolveAgentConfig(idOrName);
+  if (!target) throw new Error(`No agent-config matching "${idOrName}".`);
+  updateConfig((cfg) => {
+    const a = cfg.agentConfigs.find((c) => c.id === target.id);
+    if (input.name !== void 0) a.name = input.name;
+    if (input.description !== void 0)
+      a.description = input.description || void 0;
+    if (input.env) a.env = { ...a.env, ...input.env };
+    if (input.unsetEnv) for (const k of input.unsetEnv) delete a.env[k];
+    if (input.prompt !== void 0) a.prompt = input.prompt || void 0;
+    a.updatedAt = Date.now();
+  });
+  return resolveAgentConfig(target.id);
+}
+function deleteAgentConfig(idOrName) {
+  const target = resolveAgentConfig(idOrName);
+  if (!target) return false;
+  updateConfig((cfg) => {
+    cfg.agentConfigs = cfg.agentConfigs.filter((c) => c.id !== target.id);
+  });
+  return true;
+}
+function refreshCapabilities(idOrName) {
+  const target = resolveAgentConfig(idOrName);
+  if (!target) throw new Error(`No agent-config matching "${idOrName}".`);
+  const cli = detectCli();
+  const cliAvailable = cli.includes(target.agentType);
+  const MODELS = {
+    claude: ["default", "opus", "haiku", "opus-1m"],
+    codex: ["default", "gpt-5-codex"],
+    opencode: ["default"]
+  };
+  const MODES = {
+    claude: ["default", "accept_edits", "plan", "dont_ask", "full_access"],
+    codex: ["default"],
+    opencode: ["default"]
+  };
+  return {
+    agentType: target.agentType,
+    cliAvailable,
+    models: MODELS[target.agentType] ?? ["default"],
+    modes: MODES[target.agentType] ?? ["default"]
+  };
+}
+var init_registry = __esm({
+  "src/runtime/registry.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/tailscale.ts
+import fs7 from "fs";
+import { spawn as spawn5 } from "child_process";
+function tsBin() {
+  const macPath = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
+  if (fs7.existsSync(macPath)) return macPath;
+  return process.env.TAILSCALE_BIN || "tailscale";
+}
+function runTs(args, timeoutMs = 6e4) {
+  return new Promise((resolve) => {
+    const child = spawn5(tsBin(), args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve({
+        ok: false,
+        data: null,
+        stdout: out.trim(),
+        stderr: "tailscale command timed out",
+        code: "timeout"
+      });
+    }, timeoutMs);
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      if (e.code === "ENOENT") {
+        resolve({
+          ok: false,
+          data: null,
+          stdout: "",
+          stderr: "Tailscale is not installed. Install it from https://tailscale.com/download, run `tailscale up`, and connect your phone to the same tailnet.",
+          code: "not_installed"
+        });
+      } else {
+        resolve({
+          ok: false,
+          data: null,
+          stdout: "",
+          stderr: `Failed to launch tailscale: ${e.message}`,
+          code: "spawn_error"
+        });
+      }
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const stdout = out.trim();
+      const stderr = err.trim();
+      let data = null;
+      try {
+        data = JSON.parse(stdout);
+      } catch {
+      }
+      if (code === 0) {
+        resolve({ ok: true, data, stdout, stderr, code: "ok" });
+      } else {
+        resolve({
+          ok: false,
+          data,
+          stdout,
+          stderr: stderr || "tailscale exited with a non-zero status",
+          code: "nonzero"
+        });
+      }
+    });
+  });
+}
+async function status(port2) {
+  const res = await runTs(["status", "--json"]);
+  if (!res.ok) return res;
+  const self = res.data?.Self ?? {};
+  const ips = Array.isArray(self.TailscaleIPs) ? self.TailscaleIPs : [];
+  const ipv4 = ips.find((ip) => !ip.includes(":")) ?? null;
+  const dnsName = typeof self.DNSName === "string" ? self.DNSName.replace(/\.$/, "") : null;
+  const online = self.Online === true;
+  const backendState = res.data?.BackendState ?? "Unknown";
+  const baseUrl = ipv4 ? `http://${ipv4}:${port2}` : null;
+  const sakura = {
+    online,
+    backendState,
+    tailscaleIp: ipv4,
+    dnsName,
+    port: port2,
+    baseUrl
+  };
+  if (res.data && typeof res.data === "object") res.data.sakura = sakura;
+  return res;
+}
+function up() {
+  return runTs(["up"]);
+}
+function down() {
+  return runTs(["down"]);
+}
+function serve(port2) {
+  return runTs(["serve", "--bg", `http://127.0.0.1:${port2}`]);
+}
+function serveOff() {
+  return runTs(["serve", "--https=443", "off"]);
+}
+async function installed() {
+  const r = await runTs(["version"]);
+  return { installed: r.code !== "not_installed", version: r.stdout, code: r.code };
+}
+async function discoverBaseUrl(port2) {
+  try {
+    const r = await status(port2);
+    return r.ok ? r.data?.sakura?.baseUrl ?? null : null;
+  } catch {
+    return null;
+  }
+}
+var init_tailscale = __esm({
+  "src/tailscale.ts"() {
+    "use strict";
+  }
+});
+
+// src/daemon/server.ts
+import http from "http";
+import fs8 from "fs";
+import { URL } from "url";
+function add(method, path6, handler) {
+  const keys = [];
+  const pattern = new RegExp(
+    "^" + path6.replace(/:[^/]+/g, (m) => {
+      keys.push(m.slice(1));
+      return "([^/]+)";
+    }) + "/?$"
+  );
+  routes.push({ method, pattern, keys, handler });
+}
+function ok(data = null) {
+  return { ok: true, data, stdout: "", stderr: "", code: "ok" };
+}
+function fail(code, stderr, data = null) {
+  return { ok: false, data, stdout: "", stderr, code };
+}
+function kvToObj(env) {
+  if (!Array.isArray(env)) return void 0;
+  const out = {};
+  for (const kv of env) {
+    const s = String(kv);
+    const i = s.indexOf("=");
+    if (i > 0) out[s.slice(0, i)] = s.slice(i + 1);
+  }
+  return out;
+}
+function readBody(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (c) => data += c);
+    req.on("end", () => {
+      if (!data) return resolve(null);
+      try {
+        resolve(JSON.parse(data));
+      } catch {
+        resolve(null);
+      }
+    });
+    req.on("error", () => resolve(null));
+  });
+}
+function send4(res, status2, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(status2, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Authorization, Content-Type",
+    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS"
+  });
+  res.end(body);
+}
+function createServer(port2) {
+  return http.createServer(async (req, res) => {
+    const method = req.method ?? "GET";
+    const url = new URL(req.url ?? "/", `http://localhost:${port2}`);
+    if (method === "OPTIONS") return send4(res, 204, {});
+    if (method === "GET" && url.pathname === "/ping") {
+      return send4(res, 200, { pong: true, pid: process.pid });
+    }
+    const expected = getToken();
+    const auth = req.headers["authorization"];
+    const presented = typeof auth === "string" && auth.startsWith("Bearer ") ? auth.slice(7) : void 0;
+    if (!expected || presented !== expected) {
+      return send4(res, 401, { error: "Unauthorized" });
+    }
+    const route = routes.find(
+      (r) => r.method === method && r.pattern.test(url.pathname)
+    );
+    if (!route) return send4(res, 404, { error: "Not found" });
+    const match = route.pattern.exec(url.pathname);
+    const params = {};
+    route.keys.forEach((k, i) => params[k] = decodeURIComponent(match[i + 1]));
+    const body = method === "GET" ? null : await readBody(req);
+    try {
+      const result = await route.handler({ req, res, url, params, body, port: port2 });
+      send4(res, 200, result);
+    } catch (e) {
+      log.error("handler error", e.message);
+      send4(res, 500, fail("nonzero", e.message));
+    }
+  });
+}
+function setVersion(v) {
+  VERSION2 = v;
+}
+var routes, VERSION2;
+var init_server = __esm({
+  "src/daemon/server.ts"() {
+    "use strict";
+    init_auth();
+    init_config();
+    init_logger();
+    init_sessions();
+    init_registry();
+    init_tailscale();
+    init_registry();
+    routes = [];
+    add("GET", "/sessions", async () => {
+      const list2 = await list();
+      return { sessions: list2 };
+    });
+    add("GET", "/sessions/:id/messages", async ({ params, url }) => {
+      const agent = url.searchParams.get("agent") || void 0;
+      const messages5 = await messages4(params.id, agent);
+      return { messages: messages5 };
+    });
+    add("POST", "/sessions/:id/send", async ({ params, body }) => {
+      const agent = body?.agent || void 0;
+      const r = await chat(params.id, String(body?.message ?? ""), agent);
+      return { ok: r.ok, output: r.output, error: r.error };
+    });
+    add(
+      "GET",
+      "/sakura/health",
+      () => ok({ installed: true, daemon: true, version: VERSION2 })
+    );
+    add("GET", "/sakura/status", async ({ port: port2 }) => {
+      const machine = thisMachine();
+      const ts = await discoverBaseUrl(port2).catch(() => null);
+      return ok({
+        runtime: "running",
+        machine,
+        workspaces: listWorkspaces(),
+        tailnetBaseUrl: ts
+      });
+    });
+    add("POST", "/sakura/daemon/:action", ({ params }) => {
+      switch (params.action) {
+        case "status":
+          return ok({ running: true, pid: process.pid, machine: thisMachine() });
+        case "logs": {
+          let logs2 = "";
+          try {
+            const lines = fs8.readFileSync(LOG_PATH, "utf8").split("\n");
+            logs2 = lines.slice(-200).join("\n");
+          } catch {
+          }
+          return ok({ logs: logs2 });
+        }
+        // start/stop/restart are process-level and handled by the CLI, not here.
+        case "start":
+        case "stop":
+        case "restart":
+          return fail(
+            "nonzero",
+            `daemon ${params.action} must be run from the CLI (\`sakuraai daemon ${params.action}\`).`
+          );
+        default:
+          return fail("nonzero", `unknown daemon action: ${params.action}`);
+      }
+    });
+    add("GET", "/sakura/workspaces", () => ok(listWorkspaces()));
+    add(
+      "GET",
+      "/sakura/github",
+      () => (
+        // No cloud backend: GitHub linkage lives in the Sakura server/Convex, not here.
+        ok([])
+      )
+    );
+    add(
+      "GET",
+      "/sakura/machines",
+      ({ url }) => ok(listMachines(url.searchParams.get("onlineOnly") === "true"))
+    );
+    add("GET", "/sakura/projects", () => ok(listProjects()));
+    add("GET", "/sakura/sessions", async ({ url }) => {
+      const limit = Number(url.searchParams.get("limit")) || void 0;
+      const agent = url.searchParams.get("agent") || void 0;
+      return ok(await list({ limit, agent }));
+    });
+    add("POST", "/sakura/sessions", async ({ body }) => {
+      const r = await create(String(body?.prompt ?? ""), {
+        agent: body?.agent,
+        cwd: body?.cwd
+      });
+      return r.ok ? ok({ output: r.output }) : fail("nonzero", r.error ?? "create failed");
+    });
+    add("GET", "/sakura/sessions/:id", async ({ params }) => {
+      const s = await show(params.id);
+      return s ? ok(s) : fail("nonzero", "session not found");
+    });
+    add("GET", "/sakura/sessions/:id/history", async ({ params, url }) => {
+      const all = url.searchParams.get("all") === "true";
+      const limit = Number(url.searchParams.get("limit")) || void 0;
+      const reverse = url.searchParams.get("reverse") === "true";
+      return ok(await history(params.id, { all, limit, reverse }));
+    });
+    add("POST", "/sakura/sessions/:id/chat", async ({ params, body }) => {
+      const r = await chat(params.id, String(body?.prompt ?? ""), body?.agent);
+      return r.ok ? ok({ output: r.output }) : fail("nonzero", r.error ?? "chat failed");
+    });
+    add(
+      "POST",
+      "/sakura/sessions/:id/cancel",
+      () => fail("nonzero", "cancel is not supported for local file-backed sessions")
+    );
+    add(
+      "POST",
+      "/sakura/sessions/:id/rename",
+      () => fail("nonzero", "rename is not supported for local file-backed sessions")
+    );
+    add(
+      "POST",
+      "/sakura/sessions/:id/:action",
+      ({ params }) => (
+        // archive/restore/delete would destroy local agent history — refuse.
+        fail(
+          "nonzero",
+          `${params.action} is disabled for local sessions to avoid deleting agent history`
+        )
+      )
+    );
+    add("GET", "/sakura/agent-configs", () => ok(listAgentConfigs()));
+    add("POST", "/sakura/agent-configs", ({ body }) => {
+      try {
+        return ok(
+          createAgentConfig({
+            name: body.name,
+            agentType: body.agent_type ?? body.agentType,
+            description: body.description,
+            env: kvToObj(body.env),
+            prompt: body.prompt
+          })
+        );
+      } catch (e) {
+        return fail("nonzero", e.message);
+      }
+    });
+    add("PUT", "/sakura/agent-configs", ({ body }) => {
+      try {
+        return ok(
+          updateAgentConfig(body.id_or_name ?? body.idOrName, {
+            name: body.name,
+            description: body.description,
+            env: kvToObj(body.env),
+            unsetEnv: body.unset_env ?? body.unsetEnv,
+            prompt: body.prompt
+          })
+        );
+      } catch (e) {
+        return fail("nonzero", e.message);
+      }
+    });
+    add("GET", "/sakura/agent-configs/:id", ({ params }) => {
+      const a = resolveAgentConfig(params.id);
+      return a ? ok(a) : fail("nonzero", "agent-config not found");
+    });
+    add(
+      "DELETE",
+      "/sakura/agent-configs/:id",
+      ({ params }) => deleteAgentConfig(params.id) ? ok({ deleted: true }) : fail("nonzero", "agent-config not found")
+    );
+    add("POST", "/sakura/agent-configs/:id/refresh", ({ params }) => {
+      try {
+        return ok(refreshCapabilities(params.id));
+      } catch (e) {
+        return fail("nonzero", e.message);
+      }
+    });
+    add("GET", "/tailscale/health", () => installed());
+    add("GET", "/tailscale/status", ({ port: port2 }) => status(port2));
+    add("POST", "/tailscale/up", () => up());
+    add("POST", "/tailscale/down", () => down());
+    add("POST", "/tailscale/serve", ({ port: port2 }) => serve(port2));
+    add("POST", "/tailscale/serve-off", () => serveOff());
+    VERSION2 = "0.0.0";
+  }
+});
+
+// src/daemon/manager.ts
+import fs9 from "fs";
+import { spawn as spawn6 } from "child_process";
+function readDaemonInfo() {
+  try {
+    return JSON.parse(fs9.readFileSync(DAEMON_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function running() {
+  const info2 = readDaemonInfo();
+  if (info2 && pidAlive(info2.pid)) return info2;
+  if (info2) {
+    fs9.rmSync(DAEMON_PATH, { force: true });
+    fs9.rmSync(PID_PATH, { force: true });
+  }
+  return null;
+}
+async function runServer(version) {
+  ensureSakuraDirs();
+  enableFileLogging();
+  setVersion(version);
+  const cfg = loadConfig();
+  const host = process.env.SAKURA_HOST || cfg.daemon.host;
+  const port2 = Number(process.env.SAKURA_PORT || cfg.daemon.port);
+  const server = createServer(port2);
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port2, host === "127.0.0.1" ? "0.0.0.0" : host, resolve);
+  });
+  const info2 = {
+    pid: process.pid,
+    host,
+    port: port2,
+    url: `http://${host}:${port2}`,
+    startedAt: Date.now()
+  };
+  fs9.writeFileSync(DAEMON_PATH, JSON.stringify(info2, null, 2));
+  fs9.writeFileSync(PID_PATH, String(process.pid));
+  const tailnet = await discoverBaseUrl(port2).catch(() => null);
+  log.info(`sakuraai runtime listening on http://0.0.0.0:${port2}`);
+  if (tailnet) log.info(`reachable over Tailscale at ${tailnet}`);
+  log.info("point the Sakura app at the tailnet URL above (Settings \u2192 Connectivity)");
+  const shutdown = () => {
+    log.info("shutting down");
+    server.close();
+    fs9.rmSync(DAEMON_PATH, { force: true });
+    fs9.rmSync(PID_PATH, { force: true });
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+function start() {
+  const existing = running();
+  if (existing) return existing;
+  ensureSakuraDirs();
+  const entry = process.argv[1] ?? "";
+  const out = fs9.openSync(LOG_PATH, "a");
+  const err = fs9.openSync(LOG_PATH, "a");
+  const child = spawn6(process.execPath, [entry, "__run-daemon"], {
+    detached: true,
+    stdio: ["ignore", out, err],
+    env: process.env
+  });
+  child.unref();
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    const info2 = readDaemonInfo();
+    if (info2 && pidAlive(info2.pid)) return info2;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+  }
+  throw new Error("daemon did not come up within 5s; check `sakuraai daemon logs`");
+}
+function stop() {
+  const info2 = running();
+  if (!info2) return false;
+  try {
+    process.kill(info2.pid, "SIGTERM");
+  } catch {
+  }
+  fs9.rmSync(DAEMON_PATH, { force: true });
+  fs9.rmSync(PID_PATH, { force: true });
+  return true;
+}
+function restart() {
+  stop();
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 300);
+  return start();
+}
+function logs(lines = 50) {
+  try {
+    const all = fs9.readFileSync(LOG_PATH, "utf8").split("\n");
+    return all.slice(-lines).join("\n");
+  } catch {
+    return "";
+  }
+}
+var init_manager = __esm({
+  "src/daemon/manager.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+    init_server();
+    init_tailscale();
+  }
+});
+
+// src/pairing.ts
+import qrcode from "qrcode-terminal";
+async function buildPairing() {
+  const token = requireToken();
+  const cfg = loadConfig();
+  const port2 = Number(process.env.SAKURA_PORT || cfg.daemon.port);
+  const tailnet = await discoverBaseUrl(port2).catch(() => null);
+  const url = tailnet ?? `http://${localIp()}:${port2}`;
+  const deepLink = `sakura://pair?url=${encodeURIComponent(url)}&token=${encodeURIComponent(token)}`;
+  return { url, token, deepLink };
+}
+function renderQr(deepLink) {
+  return new Promise((resolve) => {
+    qrcode.generate(deepLink, { small: true }, (qr) => resolve(qr));
+  });
+}
+function localIp() {
+  try {
+    const os5 = __require("os");
+    const nets = os5.networkInterfaces();
+    for (const name of Object.keys(nets)) {
+      for (const net of nets[name] ?? []) {
+        if (net.family === "IPv4" && !net.internal) return net.address;
+      }
+    }
+  } catch {
+  }
+  return "127.0.0.1";
+}
+var init_pairing = __esm({
+  "src/pairing.ts"() {
+    "use strict";
+    init_config();
+    init_auth();
+    init_tailscale();
+  }
+});
+
+// src/commands/pair.ts
+var pair_exports = {};
+__export(pair_exports, {
+  registerPair: () => registerPair,
+  showPairing: () => showPairing
+});
+async function showPairing(opts = {}) {
+  const pairing = await buildPairing();
+  if (opts.json) return printJson(pairing);
+  const qr = await renderQr(pairing.deepLink);
+  info("");
+  info("Scan this with your phone to pair the Sakura app:");
+  info("");
+  info(qr);
+  info(`  URL:   ${pairing.url}`);
+  info(`  Token: ${pairing.token}`);
+  info("");
+  info("Or paste the token into the app (Settings \u2192 Connect).");
+}
+function registerPair(program) {
+  program.command("pair").description("Show a QR code + token to pair the Sakura mobile app").option("--json", "output the pairing payload as JSON").action(async (opts) => {
+    if (!isLoggedIn()) die("Not signed in. Run `sakuraai login` first.");
+    if (opts.json) {
+      return showPairing(opts);
+    }
+    if (!running()) {
+      warn("The daemon is not running \u2014 start it with `sakuraai daemon start` so the app can connect.");
+    }
+    await showPairing(opts);
+    success("Waiting for the app to connect\u2026");
+  });
+}
+var init_pair = __esm({
+  "src/commands/pair.ts"() {
+    "use strict";
+    init_pairing();
+    init_auth();
+    init_manager();
+    init_output();
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/version.ts
+var VERSION = "0.0.1";
+
+// src/index.ts
+init_config();
+
+// src/commands/auth.ts
+init_auth();
+init_config();
+init_output();
+function registerAuth(program) {
+  program.command("login").description("Sign in and register this machine (generates a CLI token to pair the app)").option("--auth <token>", "use a pre-created CLI token instead of generating one").option("--server-url <url>", "Sakura server / Convex URL to associate").option("--machine-name <name>", "override the machine name (defaults to hostname)").option("--json", "output as JSON").action((opts) => {
+    const state = login({
+      auth: opts.auth,
+      serverUrl: opts.serverUrl,
+      machineName: opts.machineName
+    });
+    if (opts.json) return printJson(state);
+    success(`Signed in as ${state.login} on "${state.machineName}".`);
+    info("");
+    info("Pair the Sakura mobile app with this token (Settings \u2192 Connectivity):");
+    info("");
+    info(`    ${state.token}`);
+    info("");
+    info("Then start the runtime so the app can reach this machine:");
+    info("    sakuraai daemon start");
+  });
+  program.command("logout").description("Clear local credentials").action(() => {
+    logout();
+    success("Logged out. The mobile app can no longer reach this machine until you log in again.");
+  });
+  program.command("whoami").description("Show the current login + token status").option("--json", "output as JSON").action((opts) => {
+    const auth = loadAuth();
+    const has = !!getToken();
+    if (opts.json) return printJson({ loggedIn: has, login: auth.login, machineName: auth.machineName });
+    if (!has) return warn("Not signed in. Run `sakuraai login`.");
+    info(`Signed in as ${auth.login ?? "unknown"} on "${auth.machineName ?? "unknown"}".`);
+  });
+}
+
+// src/commands/runtime.ts
+init_manager();
+init_tailscale();
+init_auth();
+init_output();
+function registerRuntime(program, version) {
+  program.command("start").description("Run the Sakura runtime in this terminal (foreground)").option("--auth <token>", "sign in with a CLI token before starting").action(async (opts) => {
+    if (opts.auth) {
+      const { login: login2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+      login2({ auth: opts.auth });
+    }
+    if (!isLoggedIn()) {
+      die("Not signed in. Run `sakuraai login` (or pass --auth <token>) first.");
+    }
+    await runServer(version);
+  });
+  const d = program.command("daemon").description("Manage the background runtime daemon");
+  d.command("start").description("Start the background daemon").action(async () => {
+    if (!isLoggedIn()) die("Not signed in. Run `sakuraai login` first.");
+    const info0 = start();
+    success(`Daemon running (pid ${info0.pid}) on ${info0.url}`);
+    const tailnet = await discoverBaseUrl(info0.port).catch(() => null);
+    if (!tailnet) {
+      warn("Tailscale not detected. Run `sakuraai serve` after `tailscale up` for a private URL.");
+    }
+    const { showPairing: showPairing2 } = await Promise.resolve().then(() => (init_pair(), pair_exports));
+    await showPairing2();
+  });
+  d.command("stop").description("Stop the background daemon").action(() => {
+    stop() ? success("Daemon stopped.") : warn("Daemon was not running.");
+  });
+  d.command("restart").description("Restart the background daemon").action(() => {
+    const i = restart();
+    success(`Daemon restarted (pid ${i.pid}) on ${i.url}`);
+  });
+  d.command("status").description("Show runtime + connection status").option("--json", "output as JSON").action(async (opts) => {
+    const i = running();
+    const tailnet = i ? await discoverBaseUrl(i.port).catch(() => null) : null;
+    if (opts.json) return printJson({ running: !!i, daemon: i, tailnetBaseUrl: tailnet });
+    if (!i) return warn("Daemon is not running. Start it with `sakuraai daemon start`.");
+    success(`Daemon running (pid ${i.pid}) on ${i.url}`);
+    if (tailnet) info(`Tailscale URL: ${tailnet}`);
+  });
+  d.command("logs").description("Print recent daemon logs").option("--lines <n>", "number of lines", "50").action((opts) => {
+    const out = logs(Number(opts.lines) || 50);
+    info(out || "(no logs yet)");
+  });
+}
+
+// src/commands/session.ts
+init_sessions();
+init_output();
+import fs10 from "fs";
+function resolveSessionId(arg) {
+  const id = arg || process.env.SAKURA_SESSION_ID;
+  if (!id) die("Provide a sessionId (positional or via SAKURA_SESSION_ID).");
+  return id;
+}
+async function resolvePrompt(positional, opts) {
+  if (positional) return positional;
+  if (opts.prompt) return opts.prompt;
+  if (opts.promptFile) return fs10.readFileSync(opts.promptFile, "utf8");
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const c of process.stdin) chunks.push(c);
+    const s = Buffer.concat(chunks).toString("utf8").trim();
+    if (s) return s;
+  }
+  die("No prompt provided. Pass text, --prompt, --prompt-file, or pipe via stdin.");
+}
+function registerSession(program) {
+  const s = program.command("session").description("Create, chat with, and inspect coding sessions");
+  s.command("list").description("List sessions in a workspace").option("--workspace <idOrSlug>", "workspace (informational; sessions are local)").option("--agent <agent>", "filter by agent (claude|codex|opencode)").option("--all", "include all sessions").option("--archived", "archived only (n/a for local; returns empty)").option("--limit <n>", "max results").option("--json", "output as JSON").action(async (opts) => {
+    if (opts.archived) {
+      if (opts.json) return printJson([]);
+      return info("No archived sessions (archival is not tracked for local sessions).");
+    }
+    const list2 = await list({
+      agent: opts.agent,
+      limit: opts.limit ? Number(opts.limit) : void 0
+    });
+    if (opts.json) return printJson(list2);
+    if (!list2.length) return info("No sessions found.");
+    printTable(
+      ["ID", "Agent", "Status", "Updated", "Title"],
+      list2.map((x) => [x.id.slice(0, 12), x.agent, x.status, x.updatedAt, x.title])
+    );
+  });
+  s.command("show [sessionId]").description("Show session metadata").option("--json", "output as JSON").action(async (sessionId, opts) => {
+    const id = resolveSessionId(sessionId);
+    const meta = await show(id);
+    if (!meta) die(`Session not found: ${id}`);
+    const msgs = await messages4(id, meta.agent);
+    const enriched = { ...meta, historyCount: msgs.length };
+    if (opts.json) return printJson(enriched);
+    info(`ID:       ${meta.id}`);
+    info(`Title:    ${meta.title}`);
+    info(`Agent:    ${meta.agent}`);
+    info(`Status:   ${meta.status}`);
+    info(`Updated:  ${meta.updatedAt}`);
+    info(`Machine:  ${meta.machine}`);
+    info(`Messages: ${msgs.length}`);
+  });
+  s.command("history [sessionId]").description("Read the visible transcript for a session").option("--limit <n>", "newest N turns").option("--all", "full transcript").option("--reverse", "newest first").option("--json", "output as JSON").option("--jsonl", "output as JSON lines").action(async (sessionId, opts) => {
+    const id = resolveSessionId(sessionId);
+    const msgs = await history(id, {
+      all: opts.all,
+      limit: opts.limit ? Number(opts.limit) : void 0,
+      reverse: opts.reverse
+    });
+    if (opts.jsonl) return printJsonl(msgs);
+    if (opts.json) return printJson(msgs);
+    if (!msgs.length) return info("(no visible turns)");
+    for (const m of msgs) {
+      const who = m.role === "user" ? "\u203A" : "\u2039";
+      info(`${who} [${m.role}] ${m.content}`);
+      info("");
+    }
+  });
+  s.command("create [prompt]").description("Create a new session on this machine and send the first prompt").option("--workspace <idOrSlug>", "workspace").option("--agent-config <idOrName>", "agent config").option("--agent <agent>", "agent runtime (claude|codex|opencode)", "claude").option("--repo <owner/repo>", "attach a GitHub repo (informational)").option("--local-project <id|name|path>", "attach a registered local project").option("--branch <name>", "starting branch").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "model override").option("--env <KEY=VALUE>", "env var (repeatable)", collect, []).option("--prompt <text>", "prompt text").option("--prompt-file <path>", "read prompt from a file").option("--json", "output as JSON").action(async (prompt, opts) => {
+    const text = await resolvePrompt(prompt, opts);
+    let cwd;
+    if (opts.localProject) {
+      const { resolveProject: resolveProject2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+      cwd = resolveProject2(opts.localProject)?.path;
+    }
+    const r = await create(text, { agent: opts.agent, cwd });
+    if (opts.json) return printJson(r);
+    if (!r.ok) die(r.error ?? "create failed");
+    success("Session created.");
+    if (r.output) info(r.output);
+  });
+  s.command("chat [sessionId] [prompt]").description("Send a new turn to an existing session").option("--prompt <text>", "prompt text").option("--prompt-file <path>", "read prompt from a file").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "model override").option("--json", "output as JSON").action(async (sessionId, prompt, opts) => {
+    const id = resolveSessionId(sessionId);
+    const text = await resolvePrompt(prompt, opts);
+    const r = await chat(id, text);
+    if (opts.json) return printJson(r);
+    if (!r.ok) die(r.error ?? "chat failed");
+    success("Turn sent.");
+    if (r.output) info(r.output);
+  });
+  s.command("cancel [sessionId]").description("Cancel the running turn on a local session").action((sessionId) => {
+    resolveSessionId(sessionId);
+    die("Cancel is not supported for local file-backed sessions.", 2);
+  });
+  s.command("rename [sessionId] [title]").description("Rename a session").option("--title <title>", "new title").action((sessionId) => {
+    resolveSessionId(sessionId);
+    die("Rename is not supported for local file-backed sessions.", 2);
+  });
+  for (const action of ["archive", "restore", "delete"]) {
+    s.command(`${action} [sessionId]`).description(`${action[0].toUpperCase()}${action.slice(1)} a session (disabled for local sessions)`).action((sessionId) => {
+      resolveSessionId(sessionId);
+      die(`${action} is disabled for local sessions to avoid deleting agent history.`, 2);
+    });
+  }
+}
+function collect(value, prev) {
+  return prev.concat([value]);
+}
+
+// src/commands/registry.ts
+init_registry();
+init_output();
+function collect2(value, prev) {
+  return prev.concat([value]);
+}
+function envToObj(pairs) {
+  const out = {};
+  for (const kv of pairs) {
+    const i = kv.indexOf("=");
+    if (i > 0) out[kv.slice(0, i)] = kv.slice(i + 1);
+  }
+  return out;
+}
+function registerRegistry(program) {
+  const ws = program.command("workspace").description("Discover accessible workspaces");
+  ws.command("list").description("List workspaces you can access").option("--json", "output as JSON").action((opts) => {
+    const list2 = listWorkspaces();
+    if (opts.json) return printJson(list2);
+    printTable(["ID", "Name", "Slug"], list2.map((w) => [w.id, w.name, w.slug]));
+  });
+  const gh = program.command("github").description("GitHub repositories linked to a workspace");
+  gh.command("list").description("List GitHub repositories linked to a workspace").option("--workspace <idOrSlug>", "workspace").option("--json", "output as JSON").action((opts) => {
+    if (opts.json) return printJson([]);
+    warn("GitHub repositories are managed by the Sakura server, not the local runtime.");
+    info("Link repos in the Sakura app (Settings \u2192 GitHub).");
+  });
+  const proj = program.command("project").description("Manage local project registrations");
+  proj.command("add [path]").description("Register a local project directory").option("--name <name>", "display name (defaults to folder name)").option("--json", "output as JSON").action((p, opts) => {
+    try {
+      const project = addProject(p ?? process.cwd(), opts.name);
+      if (opts.json) return printJson(project);
+      success(`Registered project "${project.name}" \u2192 ${project.path}`);
+    } catch (e) {
+      die(e.message);
+    }
+  });
+  proj.command("list").description("List registered local projects").option("--json", "output as JSON").action((opts) => {
+    const list2 = listProjects();
+    if (opts.json) return printJson(list2);
+    if (!list2.length) return info("No projects registered. Add one with `sakuraai project add`.");
+    printTable(["ID", "Name", "Path"], list2.map((p) => [p.id.slice(0, 8), p.name, p.path]));
+  });
+  proj.command("delete <idOrNameOrPath>").description("Delete a registered local project").action((sel) => {
+    deleteProject(sel) ? success("Project removed.") : warn("No matching project.");
+  });
+  const m = program.command("machine").description("Inspect machines in a workspace");
+  m.command("list").description("List machines in a workspace").option("--workspace <idOrSlug>", "workspace").option("--online-only", "only machines with a recent heartbeat").option("--include-acp-capabilities", "include capability cache in JSON").option("--json", "output as JSON").action((opts) => {
+    const list2 = listMachines(!!opts.onlineOnly);
+    if (opts.json) return printJson(list2);
+    printTable(
+      ["ID", "Name", "Online", "CLI"],
+      list2.map((x) => [x.id.slice(0, 8), x.name, x.online ? "yes" : "no", x.cli.join(", ") || "\u2014"])
+    );
+  });
+  const ac = program.command("agent-config").description("Manage agent configs");
+  ac.command("list").description("List configs in a workspace").option("--workspace <idOrSlug>", "workspace").option("--json", "output as JSON").action((opts) => {
+    const list2 = listAgentConfigs();
+    if (opts.json) return printJson(list2);
+    if (!list2.length) return info("No agent configs. Create one with `sakuraai agent-config create`.");
+    printTable(
+      ["ID", "Name", "Type", "Description"],
+      list2.map((a) => [a.id.slice(0, 8), a.name, a.agentType, a.description ?? ""])
+    );
+  });
+  ac.command("show <idOrName>").description("Show one config").option("--json", "output as JSON").action((sel, opts) => {
+    const a = resolveAgentConfig(sel);
+    if (!a) die(`No agent-config matching "${sel}".`);
+    if (opts.json) return printJson(a);
+    info(JSON.stringify(a, null, 2));
+  });
+  ac.command("create").description("Create a new config").requiredOption("--agent-type <type>", "agent runtime (claude|codex|opencode|<registry>)").requiredOption("--name <name>", "display name").option("--workspace <idOrSlug>", "workspace").option("--description <text>", "description").option("--env <KEY=VALUE>", "env var (repeatable)", collect2, []).option("--prompt <text>", "default prompt prefix").option("--json", "output as JSON").action((opts) => {
+    const a = createAgentConfig({
+      name: opts.name,
+      agentType: opts.agentType,
+      description: opts.description,
+      env: envToObj(opts.env),
+      prompt: opts.prompt
+    });
+    if (opts.json) return printJson(a);
+    success(`Created agent-config "${a.name}" (${a.id}).`);
+  });
+  ac.command("update <idOrName>").description("Update an existing config").option("--name <name>", "new name").option("--description <text>", 'description ("" clears)').option("--env <KEY=VALUE>", "merge env var (repeatable)", collect2, []).option("--unset-env <KEY>", "remove env var (repeatable)", collect2, []).option("--prompt <text>", 'default prompt prefix ("" clears)').option("--json", "output as JSON").action((sel, opts) => {
+    try {
+      const a = updateAgentConfig(sel, {
+        name: opts.name,
+        description: opts.description,
+        env: opts.env.length ? envToObj(opts.env) : void 0,
+        unsetEnv: opts.unsetEnv,
+        prompt: opts.prompt
+      });
+      if (opts.json) return printJson(a);
+      success(`Updated agent-config "${a.name}".`);
+    } catch (e) {
+      die(e.message);
+    }
+  });
+  ac.command("delete <idOrName>").description("Delete a config").action((sel) => {
+    deleteAgentConfig(sel) ? success("Deleted.") : die(`No agent-config matching "${sel}".`);
+  });
+  ac.command("refresh-capabilities <idOrName>").description("Refresh supported modes/models on the current machine").option("--workspace <idOrSlug>", "workspace").option("--machine <idOrName>", "machine (defaults to current)").option("--json", "output as JSON").action((sel, opts) => {
+    try {
+      const caps = refreshCapabilities(sel);
+      if (opts.json) return printJson(caps);
+      success(`Refreshed capabilities for "${sel}".`);
+      info(`  CLI available: ${caps.cliAvailable ? "yes" : "no"}`);
+      info(`  Models: ${caps.models.join(", ")}`);
+      info(`  Modes:  ${caps.modes.join(", ")}`);
+    } catch (e) {
+      die(e.message);
+    }
+  });
+}
+
+// src/commands/connectivity.ts
+init_tailscale();
+init_config();
+init_output();
+function port() {
+  return Number(process.env.SAKURA_PORT || loadConfig().daemon.port);
+}
+function registerConnectivity(program) {
+  const ts = program.command("tailscale").alias("ts").description("Tailscale connectivity for private PC \u2194 mobile access");
+  ts.command("status").description("Show tailnet status + the base URL the app should use").option("--json", "output as JSON").action(async (opts) => {
+    const r = await status(port());
+    if (opts.json) return printJson(r);
+    if (!r.ok) return die(r.stderr || "tailscale status failed");
+    const s = r.data?.sakura;
+    success(`Tailscale: ${s?.backendState ?? "unknown"} (${s?.online ? "online" : "offline"})`);
+    if (s?.tailscaleIp) info(`Tailnet IP:  ${s.tailscaleIp}`);
+    if (s?.dnsName) info(`DNS name:    ${s.dnsName}`);
+    if (s?.baseUrl) {
+      info(`App base URL: ${s.baseUrl}`);
+      info("Set this as EXPO_PUBLIC_API_URL (or paste it in Settings \u2192 Connectivity).");
+    }
+  });
+  ts.command("up").description("Bring this node onto the tailnet").action(async () => {
+    const r = await up();
+    r.ok ? success("Tailscale up.") : die(r.stderr);
+  });
+  ts.command("down").description("Disconnect from the tailnet").action(async () => {
+    const r = await down();
+    r.ok ? success("Tailscale down.") : die(r.stderr);
+  });
+  program.command("serve").description("Expose the runtime port over the tailnet via Tailscale (HTTPS)").action(async () => {
+    const r = await serve(port());
+    if (!r.ok) return die(r.stderr);
+    success("Serving the runtime over the tailnet.");
+    const status2 = await status(port());
+    const url = status2.data?.sakura?.baseUrl;
+    if (url) info(`App base URL: ${url}`);
+    else warn("Run `sakuraai tailscale status` to see the URL.");
+  });
+  program.command("serve-off").description("Stop serving the runtime over the tailnet").action(async () => {
+    const r = await serveOff();
+    r.ok ? success("Stopped serving.") : die(r.stderr);
+  });
+}
+
+// src/index.ts
+init_pair();
+init_manager();
+async function main() {
+  ensureSakuraDirs();
+  if (process.argv[2] === "__run-daemon") {
+    await runServer(VERSION);
+    return;
+  }
+  const program = new Command();
+  program.name("sakuraai").description(
+    "Sakura Agent CLI \u2014 manage local AI coding sessions and reach them from the Sakura app over Tailscale"
+  ).version(VERSION, "-v, --version", "output the version number");
+  registerAuth(program);
+  registerRuntime(program, VERSION);
+  registerSession(program);
+  registerRegistry(program);
+  registerConnectivity(program);
+  registerPair(program);
+  program.showHelpAfterError("(add --help for usage)");
+  await program.parseAsync(process.argv);
+}
+main().catch((e) => {
+  process.stderr.write(`\u2717 ${e.message}
+`);
+  process.exit(1);
+});