@lesscap/baton-cli 0.7.5 → 0.7.6

package/dist/baton.mjs

@@ -4815,7 +4815,7 @@ var viewWorker = (cfg) => {
     apiToken: worker2.apiToken
   };
 };
-var worktreeConfig = (cfg) => ({
+var worktreeConfig = (cfg, session2) => ({
   server: cfg.server,
   project: cfg.projectId,
   baseBranch: cfg.baseBranch,
@@ -4825,7 +4825,8 @@ var worktreeConfig = (cfg) => ({
     agentKind: cfg.agentKind,
     machineId: cfg.machineId,
     apiToken: cfg.apiToken
-  }
+  },
+  ...session2 === void 0 ? {} : { session: session2 }
 });
 
 // src/config.ts
@@ -4990,6 +4991,19 @@ var withRetry = async (fn, opts = {}) => {
   throw lastErr;
 };
 
+// src/client/services.ts
+var servicesClient = (baseUrl) => {
+  const u = (path) => `${baseUrl}${path}`;
+  return {
+    listByProject: (projectId) => request(u(`/projects/${projectId}/services`), { method: "GET" }),
+    run: (workerId, input) => request(u(`/workers/${workerId}/services`), { method: "POST", body: input }),
+    stop: (workerId, name) => request(u(`/workers/${workerId}/services/${encodeURIComponent(name)}`), {
+      method: "DELETE"
+    }),
+    report: (input) => request(u("/workers/me/services"), { method: "PUT", body: input })
+  };
+};
+
 // src/client/sessions.ts
 var sessionsClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -5113,6 +5127,7 @@ var clientFromBase = (baseUrl) => ({
   requirements: requirementClient(baseUrl),
   tasks: taskClient(baseUrl),
   sessions: sessionsClient(baseUrl),
+  services: servicesClient(baseUrl),
   loops: loopsClient(baseUrl),
   workers: workersClient(baseUrl)
 });
@@ -6251,6 +6266,162 @@ var requirement = defineCommand({
   }
 });
 
+// src/worker/service-child.ts
+import { spawn } from "node:child_process";
+
+// src/worker/proc.ts
+var killProcessGroup = (proc) => {
+  if (proc.pid === void 0) return;
+  killPidGroup(proc.pid);
+};
+var killPidGroup = (pid, signal = "SIGTERM") => {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+  }
+};
+
+// src/worker/service-child.ts
+var isStart = (message) => {
+  if (typeof message !== "object" || message === null) return false;
+  const value = message;
+  return value.type === "start" && typeof value.cwd === "string" && Array.isArray(value.argv) && value.argv.length > 0 && value.argv.every((arg) => typeof arg === "string");
+};
+var isStop = (message) => typeof message === "object" && message !== null && message.type === "stop";
+var send = (message) => {
+  if (process.connected) process.send?.(message);
+};
+var runServiceChild = () => {
+  let app = null;
+  let killTimer = null;
+  let stopping = false;
+  const stop = () => {
+    if (stopping) return;
+    stopping = true;
+    if (!app?.pid) {
+      process.exit(0);
+      return;
+    }
+    killPidGroup(app.pid);
+    killTimer = setTimeout(() => {
+      if (app?.pid) killPidGroup(app.pid, "SIGKILL");
+    }, 5e3);
+    killTimer.unref();
+  };
+  process.on("disconnect", stop);
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  process.on("message", (message) => {
+    if (isStop(message)) return stop();
+    if (!isStart(message) || app) return;
+    const [command, ...args] = message.argv;
+    app = spawn(command ?? "", args, {
+      cwd: message.cwd,
+      detached: true,
+      stdio: "inherit",
+      env: process.env
+    });
+    app.once("spawn", () => send({ type: "started", pid: app?.pid }));
+    app.once("error", (error) => {
+      send({ type: "error", error: error.message });
+      process.exit(1);
+    });
+    app.once("exit", (code, signal) => {
+      if (killTimer) clearTimeout(killTimer);
+      process.exit(code ?? (signal ? 1 : 0));
+    });
+  });
+};
+var serviceChildCommand = defineCommand({
+  meta: { name: "child", description: "internal service process wrapper", hidden: true },
+  run: runServiceChild
+});
+
+// src/commands/service.ts
+var serviceHandle = (service2) => `W-${service2.workerId}/${service2.name}`;
+var formatUptime = (startedAt, now = Date.now()) => {
+  const seconds = Math.max(0, Math.floor((now - startedAt) / 1e3));
+  if (seconds >= 86400) return `${Math.floor(seconds / 86400)}d`;
+  if (seconds >= 3600) return `${Math.floor(seconds / 3600)}h`;
+  if (seconds >= 60) return `${Math.floor(seconds / 60)}m`;
+  return `${seconds}s`;
+};
+var currentContext = () => {
+  const config = loadProjectConfig(projectConfigPath());
+  if (!config.worker || !config.session)
+    throw new Error("service run requires a Baton session worktree");
+  return { workerId: config.worker.id, sessionId: config.session };
+};
+var currentWorker = () => {
+  const worker2 = loadProjectConfig(projectConfigPath()).worker;
+  if (!worker2) throw new Error("no worker in scope");
+  return worker2.id;
+};
+var parseTarget = (target) => {
+  const explicit = target.match(/^W-(\d+)\/(.+)$/i);
+  return explicit ? { workerId: Number(explicit[1]), name: explicit[2] ?? "" } : { workerId: currentWorker(), name: target };
+};
+var runCommand2 = defineCommand({
+  meta: { name: "run", description: "run a service on the current worker" },
+  args: {
+    name: { type: "positional", required: true, description: "service name" },
+    ...common
+  },
+  run: async ({ args, rawArgs }) => {
+    const separator = rawArgs.indexOf("--");
+    const argv = separator === -1 ? [] : rawArgs.slice(separator + 1);
+    if (argv.length === 0) throw new Error("command required after `--`");
+    const context = currentContext();
+    const result = await clientFor(args).services.run(context.workerId, {
+      sessionId: context.sessionId,
+      name: args.name,
+      argv
+    });
+    if (!result.ok) throw new Error(result.error);
+    if (args.json) return console.log(toJson(result));
+    console.log(`running W-${context.workerId}/${args.name}`);
+    if (result.logPath) console.log(`logs: ${result.logPath}`);
+  }
+});
+var lsCommand = defineCommand({
+  meta: { name: "ls", description: "list live services in the current project" },
+  args: common,
+  run: async ({ args }) => {
+    const client = clientFor(args);
+    const projectId = resolveProjectId({});
+    const services = await client.services.listByProject(projectId);
+    if (args.json) return console.log(toJson(services));
+    if (services.length === 0) return console.log("(none)");
+    const workers = await client.workers.listByProject(projectId);
+    const names = new Map(workers.map((worker2) => [worker2.id, worker2.name]));
+    services.sort((a, b) => a.workerId - b.workerId || a.name.localeCompare(b.name)).map(
+      (item) => `${serviceHandle(item)}  ${names.get(item.workerId) ?? "unknown"}  session=${item.sessionId}  uptime=${formatUptime(item.startedAt)}`
+    ).forEach((line) => {
+      console.log(line);
+    });
+  }
+});
+var stopCommand = defineCommand({
+  meta: { name: "stop", description: "stop and remove a live service" },
+  args: {
+    service: {
+      type: "positional",
+      required: true,
+      description: "service name, or W-N/name"
+    },
+    ...common
+  },
+  run: async ({ args }) => {
+    const target = parseTarget(args.service);
+    await clientFor(args).services.stop(target.workerId, target.name);
+    console.log(args.json ? toJson({ ok: true, service: args.service }) : `stopped ${args.service}`);
+  }
+});
+var service = defineCommand({
+  meta: { name: "service", description: "run and stop worker-managed development services" },
+  subCommands: { run: runCommand2, ls: lsCommand, stop: stopCommand, child: serviceChildCommand }
+});
+
 // src/commands/session/abort.ts
 var sessionAbortCommand = defineCommand({
   meta: {
@@ -7777,21 +7948,26 @@ var HEARTBEAT_TIMEOUT_MS = 15e3;
 var HEARTBEAT_DEAD_MS = 15e4;
 var STREAM_STALE_MS = 9e4;
 var createLiveness = (deps) => {
-  const { client, cfg, log, isStreamOpen, onTrip } = deps;
+  const { heartbeat, log, isStreamOpen, reportRuntime, onTrip } = deps;
   let heartbeatOkAt = Date.now();
   let streamOkAt = Date.now();
   let timer = null;
   const ping = async () => {
+    if (reportRuntime)
+      void reportRuntime().catch((error) => log(`service report failed: ${String(error)}`));
+    let timeout;
     try {
       await Promise.race([
-        client.workers.heartbeat(cfg.machineId),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("heartbeat timeout")), HEARTBEAT_TIMEOUT_MS)
-        )
+        heartbeat(),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new Error("heartbeat timeout")), HEARTBEAT_TIMEOUT_MS);
+        })
       ]);
       heartbeatOkAt = Date.now();
     } catch (e) {
       log(`heartbeat failed: ${String(e)}`);
+    } finally {
+      if (timeout) clearTimeout(timeout);
     }
   };
   const tick = () => {
@@ -7818,20 +7994,185 @@ var createLiveness = (deps) => {
   };
 };
 
+// src/worker/service-supervisor.ts
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join8 } from "node:path";
+
+// src/worker/service-process.ts
+import { spawn as spawn2 } from "node:child_process";
+import { closeSync, existsSync as existsSync5, openSync } from "node:fs";
+import { dirname as dirname2, join as join7 } from "node:path";
+import { fileURLToPath } from "node:url";
+var START_TIMEOUT_MS = 1e4;
+var isWrapperMessage = (message) => {
+  if (typeof message !== "object" || message === null) return false;
+  const value = message;
+  if (value.type === "started") return typeof value.pid === "number";
+  return value.type === "error" && typeof value.error === "string";
+};
+var binPath = () => {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const devShim = join7(here, "..", "..", "bin", "baton.mjs");
+  return existsSync5(devShim) ? devShim : fileURLToPath(import.meta.url);
+};
+var startServiceProcess = (input) => {
+  const logFd = openSync(input.logPath, "a");
+  let wrapper;
+  try {
+    wrapper = spawn2(process.execPath, [binPath(), "service", "child"], {
+      detached: false,
+      stdio: ["ignore", logFd, logFd, "ipc"],
+      env: process.env
+    });
+  } finally {
+    closeSync(logFd);
+  }
+  const started = new Promise((resolve2, reject) => {
+    let settled = false;
+    let timer;
+    const cleanup = () => {
+      clearTimeout(timer);
+      wrapper.off("message", onMessage);
+      wrapper.off("error", onError);
+      wrapper.off("exit", onExit);
+    };
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (result instanceof Error) reject(result);
+      else resolve2(result);
+    };
+    const onMessage = (message) => {
+      if (!isWrapperMessage(message)) return;
+      if (message.type === "started") finish(message.pid);
+      else finish(new Error(message.error));
+    };
+    const onError = (error) => finish(error);
+    const onExit = (code) => finish(new Error(`service wrapper exited before start (code=${code ?? -1})`));
+    wrapper.on("message", onMessage);
+    wrapper.once("error", onError);
+    wrapper.once("exit", onExit);
+    timer = setTimeout(() => {
+      if (wrapper.connected) wrapper.send({ type: "stop" });
+      finish(new Error("service wrapper did not start in time"));
+    }, START_TIMEOUT_MS);
+    timer.unref();
+    wrapper.send({ type: "start", argv: input.argv, cwd: input.cwd }, (error) => {
+      if (error) finish(error);
+    });
+  });
+  return { wrapper, started };
+};
+
+// src/worker/service-supervisor.ts
+var waitForExit = (child) => child.exitCode !== null ? Promise.resolve() : new Promise((resolve2) => child.once("exit", () => resolve2()));
+var createServiceSupervisor = (deps) => {
+  const { getSession, sendReport, cfg, log } = deps;
+  const entries = /* @__PURE__ */ new Map();
+  let reportQueue = Promise.resolve();
+  const snapshot = () => [...entries.values()].filter((entry) => entry.appPid !== void 0).map(({ sessionId, name, startedAt }) => ({ sessionId, name, startedAt }));
+  const report = (result) => {
+    const body = { services: snapshot(), ...result ? { result } : {} };
+    const request2 = reportQueue.then(() => sendReport(body)).then(() => {
+    });
+    reportQueue = request2.catch(() => {
+    });
+    return request2;
+  };
+  const remove = (entry) => {
+    if (entries.get(entry.name) !== entry) return;
+    entries.delete(entry.name);
+    void report().catch(() => {
+    });
+  };
+  const stopEntry = (entry) => {
+    if (entry.wrapper.connected) {
+      entry.wrapper.send({ type: "stop" });
+      return;
+    }
+    if (entry.appPid) killPidGroup(entry.appPid, "SIGKILL");
+  };
+  const runOne = async (requestId, sessionId, name, argv) => {
+    if (entries.has(name))
+      return report({
+        requestId,
+        ok: false,
+        error: `service "${name}" is already running`,
+        status: 409
+      });
+    const session2 = await getSession(sessionId);
+    if (session2.workerId !== cfg.workerId || !session2.worktreePath)
+      return report({
+        requestId,
+        ok: false,
+        error: "session is not materialized on this worker",
+        status: 400
+      });
+    const logDir = join8(session2.worktreePath, ".baton-services");
+    const logPath = join8(logDir, `${name}.log`);
+    mkdirSync4(logDir, { recursive: true });
+    const { wrapper, started } = startServiceProcess({ argv, cwd: session2.worktreePath, logPath });
+    const entry = {
+      wrapper,
+      sessionId,
+      name,
+      startedAt: Date.now()
+    };
+    entries.set(name, entry);
+    wrapper.once("exit", (code) => {
+      log(`service ${name} exited (code=${code ?? -1})`);
+      remove(entry);
+    });
+    try {
+      entry.appPid = await started;
+    } catch (error) {
+      remove(entry);
+      return report({ requestId, ok: false, error: String(error), status: 500 });
+    }
+    const service2 = {
+      workerId: cfg.workerId,
+      sessionId,
+      name,
+      startedAt: entry.startedAt
+    };
+    log(`service ${name} started in ${session2.worktreePath}`);
+    await report({ requestId, ok: true, service: service2, logPath });
+  };
+  const run = async (requestId, sessionId, name, argv) => {
+    try {
+      await runOne(requestId, sessionId, name, argv);
+    } catch (error) {
+      await report({ requestId, ok: false, error: String(error), status: 500 });
+    }
+  };
+  const stop = async (requestId, name) => {
+    const entry = entries.get(name);
+    if (!entry)
+      return report({ requestId, ok: false, error: `service "${name}" not found`, status: 404 });
+    stopEntry(entry);
+    await waitForExit(entry.wrapper);
+    remove(entry);
+    await report({ requestId, ok: true });
+  };
+  const stopSession = async (sessionId) => {
+    const matches = [...entries.values()].filter((entry) => entry.sessionId === sessionId);
+    matches.forEach(stopEntry);
+    await Promise.all(matches.map((entry) => waitForExit(entry.wrapper)));
+    matches.forEach(remove);
+  };
+  const killAll = () => entries.forEach(stopEntry);
+  return { run, stop, stopSession, report, killAll };
+};
+
 // src/worker/session-supervisor.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname2, join as join8 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync as existsSync6 } from "node:fs";
+import { dirname as dirname3, join as join10 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
-// src/session/runner/title-codex.ts
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join7 } from "node:path";
-import { Codex as Codex2 } from "@openai/codex-sdk";
-
 // src/session/runner/title.ts
 var clip = (s, max) => s.length > max ? s.slice(0, max) : s;
 var isDeclined = (title) => title.replace(/[^a-z]/gi, "").toUpperCase() === "NONE";
@@ -7920,6 +8261,10 @@ var generateTitle = async (input) => {
 };
 
 // src/session/runner/title-codex.ts
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join9 } from "node:path";
+import { Codex as Codex2 } from "@openai/codex-sdk";
 var generateTitleWithCodex = async (input) => {
   const { userText, assistantText } = input;
   if (`${userText}${assistantText}`.trim().length < 4) return { kind: "declined" };
@@ -7927,7 +8272,7 @@ var generateTitleWithCodex = async (input) => {
   const timer = setTimeout(() => abort.abort(), TITLE_TIMEOUT_MS);
   let cwd = "";
   try {
-    cwd = await mkdtemp(join7(tmpdir3(), "baton-title-"));
+    cwd = await mkdtemp(join9(tmpdir3(), "baton-title-"));
     const client = input.client ?? new Codex2();
     const thread = client.startThread({
       workingDirectory: cwd,
@@ -7953,20 +8298,11 @@ var generateTitleWithCodex = async (input) => {
   }
 };
 
-// src/worker/proc.ts
-var killProcessGroup = (proc) => {
-  if (proc.pid === void 0) return;
-  try {
-    process.kill(-proc.pid, "SIGTERM");
-  } catch {
-  }
-};
-
 // src/worker/session-supervisor.ts
-var binPath = () => {
-  const here = dirname2(fileURLToPath(import.meta.url));
-  const devShim = join8(here, "..", "..", "bin", "baton.mjs");
-  return existsSync5(devShim) ? devShim : fileURLToPath(import.meta.url);
+var binPath2 = () => {
+  const here = dirname3(fileURLToPath2(import.meta.url));
+  const devShim = join10(here, "..", "..", "bin", "baton.mjs");
+  return existsSync6(devShim) ? devShim : fileURLToPath2(import.meta.url);
 };
 var createSessionSupervisor = (deps) => {
   const { client, cfg, repo, log, hasTerminal, closeTerminal } = deps;
@@ -7993,7 +8329,7 @@ var createSessionSupervisor = (deps) => {
   };
   const spawnChild = (sessionId, worktreePath) => {
     if (children.has(sessionId)) return;
-    const child = spawn(process.execPath, [binPath(), "session", "run", String(sessionId)], {
+    const child = spawn3(process.execPath, [binPath2(), "session", "run", String(sessionId)], {
       detached: true,
       stdio: "inherit",
       env: { ...process.env, BATON_SERVER: cfg.server, BATON_WORKER_TOKEN: cfg.apiToken }
@@ -8019,7 +8355,7 @@ var createSessionSupervisor = (deps) => {
     if (!session2.agentSessionId || !worktreePath) {
       const sessionCode = randomUUID();
       const agentSessionId = session2.agentKind === "codex" ? `pending:${sessionCode}` : sessionCode;
-      worktreePath = join8(worktreeDir, slug(`${name}-${sessionCode.slice(0, 8)}`));
+      worktreePath = join10(worktreeDir, slug(`${name}-${sessionCode.slice(0, 8)}`));
       const base = await syncedBase();
       if (wasCanceled()) return log(`session #${sessionId} start canceled during git sync`);
       createWorktree({
@@ -8031,13 +8367,14 @@ var createSessionSupervisor = (deps) => {
       await client.sessions.materialize(sessionId, { agentSessionId, worktreePath }, cfg.apiToken);
       if (wasCanceled()) return log(`session #${sessionId} start canceled after materializing`);
       log(`materialized session #${sessionId} \u2192 ${worktreePath}`);
-    } else if (!existsSync5(worktreePath)) {
+    } else if (!existsSync6(worktreePath)) {
       await restoreWorktree(repo, worktreePath, session2.agentSessionId.slice(0, 8), baseBranch);
       if (wasCanceled()) return log(`session #${sessionId} start canceled during worktree restore`);
       log(`recreated session #${sessionId} worktree (was missing) \u2192 ${worktreePath}`);
     }
     ensureExcluded(repo, PROJECT_CONFIG_NAME);
-    saveProjectConfig(join8(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg));
+    ensureExcluded(repo, ".baton-services/");
+    saveProjectConfig(join10(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg, sessionId));
     if (hasTerminal(sessionId))
       return log(`session #${sessionId} terminal opened mid-start \u2014 skipping headless start`);
     spawnChild(sessionId, worktreePath);
@@ -8125,8 +8462,8 @@ var createSessionSupervisor = (deps) => {
 };
 
 // src/worker/terminal-manager.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { spawn as spawn2 } from "node-pty";
+import { existsSync as existsSync8 } from "node:fs";
+import { spawn as spawn4 } from "node-pty";
 
 // ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
 var import_stream2 = __toESM(require_stream(), 1);
@@ -8139,16 +8476,16 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
 // src/worker/pty.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 var MAX_TERMINALS = 10;
 var ptyArgs = (agentSessionId, hasJsonl) => hasJsonl ? ["--resume", agentSessionId] : ["--session-id", agentSessionId];
 var hasSessionJsonl = (agentSessionId) => {
-  const root = join9(homedir3(), ".claude", "projects");
-  if (!existsSync6(root)) return false;
+  const root = join11(homedir3(), ".claude", "projects");
+  if (!existsSync7(root)) return false;
   for (const dir of readdirSync2(root))
-    if (existsSync6(join9(root, dir, `${agentSessionId}.jsonl`))) return true;
+    if (existsSync7(join11(root, dir, `${agentSessionId}.jsonl`))) return true;
   return false;
 };
 var serverTerminalWsUrl = (server, sessionId) => `${server.replace(/^http/, "ws")}/workers/me/terminal/ws?sessionId=${sessionId}`;
@@ -8159,13 +8496,13 @@ var createTerminalManager = (deps) => {
   const { cfg, log, hasChild } = deps;
   const terminals = /* @__PURE__ */ new Map();
   const open = (sessionId, agentSessionId, worktreePath) => {
-    const why = terminals.has(sessionId) ? "already open" : hasChild(sessionId) ? "headless child running" : !existsSync7(worktreePath) ? `worktree missing (${worktreePath})` : terminals.size >= MAX_TERMINALS ? `cap ${MAX_TERMINALS} reached` : null;
+    const why = terminals.has(sessionId) ? "already open" : hasChild(sessionId) ? "headless child running" : !existsSync8(worktreePath) ? `worktree missing (${worktreePath})` : terminals.size >= MAX_TERMINALS ? `cap ${MAX_TERMINALS} reached` : null;
     if (why) {
       log(`terminal #${sessionId}: ${why} \u2014 refusing`);
       return;
     }
     const claudeBin = process.env.BATON_CLAUDE_BIN ?? "claude";
-    const term = spawn2(claudeBin, ptyArgs(agentSessionId, hasSessionJsonl(agentSessionId)), {
+    const term = spawn4(claudeBin, ptyArgs(agentSessionId, hasSessionJsonl(agentSessionId)), {
       name: "xterm-color",
       cols: 80,
       rows: 24,
@@ -8251,14 +8588,20 @@ var runWorkerDaemon = async (cfg, client, signal) => {
     log,
     hasChild: (id) => supervisor.has(id)
   });
+  const services = createServiceSupervisor({
+    getSession: (sessionId) => client.sessions.get(sessionId),
+    sendReport: (report) => client.services.report(report),
+    cfg,
+    log
+  });
   let fatal = false;
   let stop = () => {
   };
   const liveness = createLiveness({
-    client,
-    cfg,
+    heartbeat: () => client.workers.heartbeat(cfg.machineId),
     log,
     isStreamOpen: () => es.readyState === ES_OPEN,
+    reportRuntime: () => services.report(),
     onTrip: (reason) => {
       if (fatal) return;
       log(`${reason} \u2014 exiting so the supervisor restarts a clean worker`);
@@ -8278,6 +8621,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
   es.onopen = () => {
     liveness.markStreamOk();
     void supervisor.reconcile().catch((err) => log(`reconcile failed: ${String(err)}`));
+    void services.report().catch((err) => log(`service report failed: ${String(err)}`));
   };
   es.onmessage = (e) => {
     liveness.markStreamOk();
@@ -8286,14 +8630,18 @@ var runWorkerDaemon = async (cfg, client, signal) => {
       if (cmd.cmd === "session.start")
         void supervisor.start(cmd.sessionId, cmd.name).catch((err) => log(`start failed: ${String(err)}`));
       else if (cmd.cmd === "session.stop") supervisor.stop(cmd.sessionId);
-      else if (cmd.cmd === "session.delete") supervisor.remove(cmd.sessionId, cmd.worktreePath);
+      else if (cmd.cmd === "session.delete")
+        void services.stopSession(cmd.sessionId).then(() => supervisor.remove(cmd.sessionId, cmd.worktreePath)).catch((err) => log(`service cleanup failed: ${String(err)}`));
       else if (cmd.cmd === "session.title")
         void supervisor.title(cmd.sessionId, cmd.agentSessionId, cmd.worktreePath).catch((err) => log(`title failed: ${String(err)}`));
       else if (cmd.cmd === "session.terminal") {
         if (cmd.action === "open")
           terminals.open(cmd.sessionId, cmd.agentSessionId, cmd.worktreePath);
         else terminals.close(cmd.sessionId);
-      }
+      } else if (cmd.cmd === "service.run")
+        void services.run(cmd.requestId, cmd.sessionId, cmd.name, cmd.argv).catch((err) => log(`service run failed: ${String(err)}`));
+      else if (cmd.cmd === "service.stop")
+        void services.stop(cmd.requestId, cmd.name).catch((err) => log(`service stop failed: ${String(err)}`));
     } catch {
     }
   };
@@ -8307,6 +8655,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
   });
   es.close();
   liveness.stop();
+  services.killAll();
   supervisor.killAll();
   terminals.killAll();
   if (fatal) process.exit(1);
@@ -8314,17 +8663,17 @@ var runWorkerDaemon = async (cfg, client, signal) => {
 
 // src/worker/machine-id.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname3, join as join10 } from "node:path";
-var machineIdPath = (env = process.env) => join10(env.XDG_DATA_HOME ?? join10(env.HOME ?? homedir4(), ".local/share"), "baton", "machine-id");
+import { dirname as dirname4, join as join12 } from "node:path";
+var machineIdPath = (env = process.env) => join12(env.XDG_DATA_HOME ?? join12(env.HOME ?? homedir4(), ".local/share"), "baton", "machine-id");
 var readOrCreateMachineId = (path = machineIdPath()) => {
-  if (existsSync8(path)) {
+  if (existsSync9(path)) {
     const s = readFileSync6(path, "utf8").trim();
     if (s) return s;
   }
   const id = randomUUID2();
-  mkdirSync4(dirname3(path), { recursive: true });
+  mkdirSync5(dirname4(path), { recursive: true });
   writeFileSync5(path, `${id}
 `, "utf8");
   return id;
@@ -8639,6 +8988,7 @@ var main = defineCommand({
     init,
     worker,
     session,
+    service,
     loop,
     relay,
     channel,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "license": "MIT",
   "publishConfig": {
     "access": "public"