@lesscap/baton-cli 0.3.0 → 0.3.2

package/dist/baton.mjs

@@ -949,28 +949,33 @@ function getBaseURL() {
 // src/client/channel.ts
 var channelClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
-  const authed = (token) => ({ authorization: `Bearer ${token}` });
-  const sendJson = (token) => ({ "content-type": "application/json", ...authed(token) });
+  const JSON_CT = { "content-type": "application/json" };
   const member = (channelId, name) => u(`/channels/${channelId}/members/${encodeURIComponent(name)}`);
   return {
-    create: async (title, description) => {
-      const res = await fetch(u("/channels"), {
+    create: async (workspaceId, title, description, token) => {
+      const res = await fetch(u(`/workspaces/${workspaceId}/channels`), {
         method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ ...title ? { title } : {}, ...description ? { description } : {} })
+        headers: { ...JSON_CT, ...token ? { authorization: `Bearer ${token}` } : {} },
+        body: JSON.stringify({
+          ...title ? { title } : {},
+          ...description ? { description } : {}
+        })
       });
-      if (!res.ok) throw new Error(`POST /channels \u2192 ${res.status}: ${await res.text()}`);
+      if (!res.ok)
+        throw new Error(
+          `POST /workspaces/${workspaceId}/channels \u2192 ${res.status}: ${await res.text()}`
+        );
       return await res.json();
     },
-    manifest: async (channelId, token) => {
-      const res = await fetch(u(`/channels/${channelId}`), { headers: authed(token) });
+    manifest: async (channelId) => {
+      const res = await fetch(u(`/channels/${channelId}`));
       if (!res.ok) throw new Error(`GET channel \u2192 ${res.status}: ${await res.text()}`);
       return await res.json();
     },
-    update: async (channelId, token, patch2) => {
+    update: async (channelId, patch2) => {
       const res = await fetch(u(`/channels/${channelId}`), {
         method: "PATCH",
-        headers: sendJson(token),
+        headers: JSON_CT,
         body: JSON.stringify(patch2)
       });
       if (!res.ok) throw new Error(`PATCH channel \u2192 ${res.status}: ${await res.text()}`);
@@ -981,60 +986,63 @@ var channelClient = (baseUrl) => {
       if (!res.ok) throw new Error(`GET /channels/help \u2192 ${res.status}: ${await res.text()}`);
       return await res.text();
     },
-    destroy: async (channelId, token) => {
-      const res = await fetch(u(`/channels/${channelId}`), {
-        method: "DELETE",
-        headers: authed(token)
-      });
+    destroy: async (channelId) => {
+      const res = await fetch(u(`/channels/${channelId}`), { method: "DELETE" });
       if (!res.ok) throw new Error(`DELETE channel \u2192 ${res.status}: ${await res.text()}`);
     },
-    join: async (channelId, token, name, kind) => {
+    join: async (channelId, name, kind) => {
       const res = await fetch(member(channelId, name), {
         method: "PUT",
-        headers: sendJson(token),
+        headers: JSON_CT,
         body: JSON.stringify({ kind: kind ?? "agent" })
       });
       if (!res.ok) throw new Error(`join channel \u2192 ${res.status}: ${await res.text()}`);
       return (await res.json()).members;
     },
-    leave: async (channelId, token, name) => {
-      const res = await fetch(member(channelId, name), { method: "DELETE", headers: authed(token) });
+    leave: async (channelId, name) => {
+      const res = await fetch(member(channelId, name), { method: "DELETE" });
       if (!res.ok) throw new Error(`leave channel \u2192 ${res.status}: ${await res.text()}`);
     },
-    members: async (channelId, token) => {
-      const res = await fetch(u(`/channels/${channelId}/members`), { headers: authed(token) });
+    members: async (channelId) => {
+      const res = await fetch(u(`/channels/${channelId}/members`));
       if (!res.ok) throw new Error(`GET members \u2192 ${res.status}: ${await res.text()}`);
       return (await res.json()).members;
     },
-    send: async (channelId, token, msg) => {
+    send: async (channelId, msg) => {
       const res = await fetch(u(`/channels/${channelId}/messages`), {
         method: "POST",
-        headers: sendJson(token),
+        headers: JSON_CT,
         body: JSON.stringify(msg)
       });
       if (!res.ok) throw new Error(`POST channel message \u2192 ${res.status}: ${await res.text()}`);
       return await res.json();
     },
-    read: async (channelId, token, opts) => {
+    uploadAttachment: async (channelId, input) => {
+      const res = await fetch(
+        u(`/channels/${channelId}/attachments?filename=${encodeURIComponent(input.filename)}`),
+        { method: "POST", headers: { "content-type": input.contentType }, body: input.body }
+      );
+      if (!res.ok) throw new Error(`upload attachment \u2192 ${res.status}: ${await res.text()}`);
+      return await res.json();
+    },
+    downloadAttachment: async (channelId, attId) => {
+      const res = await fetch(u(`/channels/${channelId}/attachments/${attId}`));
+      if (!res.ok) throw new Error(`download attachment \u2192 ${res.status}: ${await res.text()}`);
+      return res;
+    },
+    read: async (channelId, opts) => {
       const params = new URLSearchParams({ since: String(opts?.since ?? 0) });
       if (opts?.for) params.set("for", opts.for);
-      const res = await fetch(u(`/channels/${channelId}/messages?${params}`), {
-        headers: authed(token)
-      });
+      const res = await fetch(u(`/channels/${channelId}/messages?${params}`));
       if (!res.ok) throw new Error(`GET messages \u2192 ${res.status}: ${await res.text()}`);
       return (await res.json()).messages;
     },
-    listen: (channelId, token, opts) => {
+    listen: (channelId, opts) => {
       let cursor = opts.since ?? 0;
       const params = new URLSearchParams({ since: String(cursor) });
       if (opts.for) params.set("for", opts.for);
       if (opts.as) params.set("as", opts.as);
-      const es = new EventSource(u(`/channels/${channelId}/stream?${params}`), {
-        fetch: (url, init2) => fetch(url, {
-          ...init2,
-          headers: { ...init2?.headers, ...authed(token) }
-        })
-      });
+      const es = new EventSource(u(`/channels/${channelId}/stream?${params}`));
       es.onmessage = (e) => {
         try {
           const m = JSON.parse(e.data);
@@ -1126,7 +1134,7 @@ var fmtTask = (t) => `${t.code}  [${t.status}]  ${t.title}`;
 var fmtComment = (c) => `${c.workerId !== void 0 ? `worker#${c.workerId}` : "you"}  ${c.body}`;
 var fmtSession = (s) => `${s.id}  ${s.name}  ${s.attached ? "[active]" : "[inactive]"}  ${s.worktreePath ?? "(pending)"}`;
 var fmtWorker = (w) => {
-  const offline = w.alive === false ? "  [offline]" : "";
+  const offline = w.connected === false ? "  [offline]" : "";
   return `W-${w.id}  ${w.name}  ${w.hostname}${offline}`;
 };
 var renderOne = (item, fmt, json) => json ? toJson(item) : fmt(item);
@@ -1221,6 +1229,25 @@ var requirementClient = (baseUrl) => {
   };
 };
 
+// src/client/retry.ts
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var withRetry = async (fn, opts = {}) => {
+  const tries = Math.max(1, opts.tries ?? 4);
+  const baseMs = opts.baseMs ?? 300;
+  let lastErr;
+  for (let i = 0; i < tries; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i === tries - 1) break;
+      const backoff = baseMs * 2 ** i;
+      await sleep(backoff + Math.random() * baseMs);
+    }
+  }
+  throw lastErr;
+};
+
 // src/client/sessions.ts
 var sessionsClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -1343,15 +1370,24 @@ var clientFromBase = (baseUrl) => ({
   sessions: sessionsClient(baseUrl),
   workers: workersClient(baseUrl)
 });
+var BOUNDARY_EVENTS = /* @__PURE__ */ new Set([
+  "turn_start",
+  "turn_complete",
+  "turn_error"
+]);
+var emitRetries = () => Number(process.env.BATON_EMIT_RETRIES) || 4;
 var createWorkerClient = (baseUrl, workerToken, sessionId) => {
   const u = (p) => `${baseUrl}${p}`;
   const auth = { authorization: `Bearer ${workerToken}` };
   return {
-    emitEvent: (type, payload) => request(u(`/sessions/${sessionId}/events`), {
-      method: "POST",
-      body: { type, payload },
-      headers: auth
-    }),
+    emitEvent: (type, payload) => {
+      const post = () => request(u(`/sessions/${sessionId}/events`), {
+        method: "POST",
+        body: { type, payload },
+        headers: auth
+      });
+      return BOUNDARY_EVENTS.has(type) ? withRetry(post, { tries: emitRetries() }) : post();
+    },
     setActive: (active) => request(u(`/sessions/${sessionId}/status`), {
       method: "POST",
       body: { active },
@@ -1381,6 +1417,11 @@ var clientFor = (args) => {
   const auth = resolveAuth(process.env, fileToken);
   return createClient(baseUrl, auth && auth !== "cookie" ? auth : void 0);
 };
+var resolveBearer = () => {
+  const fileToken = loadProjectConfigOrNull(projectConfigPath())?.worker?.apiToken;
+  const auth = resolveAuth(process.env, fileToken);
+  return auth && auth !== "cookie" ? auth.bearer : void 0;
+};
 var resolveProjectId = (args) => {
   if (args.project !== void 0 && args.project !== "") return Number(args.project);
   const cfg = loadProjectConfigOrNull(projectConfigPath());
@@ -1406,11 +1447,10 @@ var closeCommand = defineCommand({
   meta: { name: "close", description: "delete a channel (removes the room and all its messages)" },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
-    token: { type: "string", required: true, description: "channel token" },
     ...common
   },
   run: async ({ args }) => {
-    await channelClient(resolveBaseUrl(args.url)).destroy(args.channel, args.token);
+    await channelClient(resolveBaseUrl(args.url)).destroy(args.channel);
     console.log(args.json ? toJson({ ok: true, deleted: args.channel }) : `closed ${args.channel}`);
   }
 });
@@ -1422,35 +1462,77 @@ var readStdin = async () => {
   return Buffer.concat(chunks).toString("utf8");
 };
 var renderRoster = (members) => members.length ? members.map((m) => `  ${m.name} (${m.kind})`).join("\n") : "  (nobody online)";
-var inviteBlock = (url, channelId, token) => [
-  "\u2500\u2500 Share this to invite anyone into the room \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
-  "You're invited to a baton channel. Three steps to get going:",
-  `  1) see the room:  curl -sS -H "authorization: Bearer ${token}" "${url}/channels/${channelId}"`,
-  `  2) read protocol: curl -sS "${url}/channels/help"`,
-  "  3) follow it to join / listen / send (pick your own NAME).",
-  "",
-  `connection: url=${url} channel=${channelId} token=${token}`,
-  "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
-].join("\n");
+var webLink = (url, channelId) => {
+  const origin = url.replace(/\/api\/?$/, "");
+  return origin === url ? null : `${origin}/channel/${channelId}`;
+};
+var inviteBlock = (url, channelId) => {
+  const web = webLink(url, channelId);
+  return [
+    "\u2500\u2500 Share this to invite anyone into the room \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    ...web ? [`Humans \u2014 open in a browser:  ${web}`, ""] : [],
+    "Agents \u2014 two curl steps:",
+    `  1) see the room:  curl -sS "${url}/channels/${channelId}"`,
+    `  2) read protocol: curl -sS "${url}/channels/help"  (then join / listen / send, pick your own NAME)`,
+    "",
+    `connection: url=${url} channel=${channelId}`,
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  ].join("\n");
+};
 
 // src/commands/channel/create.ts
 var createCommand = defineCommand({
-  meta: { name: "create", description: "open a channel (chat room) and print an invite" },
+  meta: {
+    name: "create",
+    description: "open a channel (chat room) in a workspace and print an invite"
+  },
   args: {
+    workspace: {
+      type: "string",
+      description: "owning workspace id (or the cwd .baton.json workspace)"
+    },
     name: { type: "string", description: "room title (optional)" },
-    desc: { type: "string", description: "room self-description: purpose / topic / how to participate" },
+    desc: {
+      type: "string",
+      description: "room self-description: purpose / topic / how to participate"
+    },
     ...common
   },
   run: async ({ args }) => {
     const url = resolveBaseUrl(args.url);
-    const { channelId, token } = await channelClient(url).create(args.name, args.desc);
+    const workspaceId = resolveWorkspaceId(args);
+    const { channelId } = await channelClient(url).create(
+      workspaceId,
+      args.name,
+      args.desc,
+      resolveBearer()
+    );
     if (args.json) {
-      console.log(toJson({ channelId, token, url, name: args.name, description: args.desc }));
+      console.log(toJson({ channelId, url, workspaceId, name: args.name, description: args.desc }));
       return;
     }
-    console.log(`channel ${channelId} opened
+    console.log(`channel ${channelId} opened in workspace ${workspaceId}
 `);
-    console.log(inviteBlock(url, channelId, token));
+    console.log(inviteBlock(url, channelId));
+  }
+});
+
+// src/commands/channel/download.ts
+import { writeFileSync as writeFileSync2 } from "node:fs";
+var downloadCommand = defineCommand({
+  meta: { name: "download", description: "download a channel attachment to a file" },
+  args: {
+    channel: { type: "positional", required: true, description: "channel id" },
+    att: { type: "positional", required: true, description: "attachment id (from a message ref)" },
+    out: { type: "string", alias: "o", description: "output file path (default: ./<attId>)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const url = resolveBaseUrl(args.url);
+    const res = await channelClient(url).downloadAttachment(args.channel, args.att);
+    const out = args.out ?? args.att;
+    writeFileSync2(out, Buffer.from(await res.arrayBuffer()));
+    console.log(`saved \u2192 ${out}`);
   }
 });
 
@@ -1459,12 +1541,11 @@ var aboutCommand = defineCommand({
   meta: { name: "about", description: "show a channel's manifest (description + online roster)" },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
-    token: { type: "string", required: true, description: "channel token" },
     ...common
   },
   run: async ({ args }) => {
     const url = resolveBaseUrl(args.url);
-    const m = await channelClient(url).manifest(args.channel, args.token);
+    const m = await channelClient(url).manifest(args.channel);
     if (args.json) {
       console.log(toJson(m));
       return;
@@ -1479,7 +1560,7 @@ protocol: curl -sS "${url}${m.help}"`);
   }
 });
 var helpCommand = defineCommand({
-  meta: { name: "help", description: "print the channel protocol doc (no token needed)" },
+  meta: { name: "help", description: "print the channel protocol doc" },
   args: { ...common },
   run: async ({ args }) => {
     console.log(await channelClient(resolveBaseUrl(args.url)).help());
@@ -1489,12 +1570,11 @@ var membersCommand = defineCommand({
   meta: { name: "members", description: "list the channel's online roster" },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
-    token: { type: "string", required: true, description: "channel token" },
     ...common
   },
   run: async ({ args }) => {
     const url = resolveBaseUrl(args.url);
-    const members = await channelClient(url).members(args.channel, args.token);
+    const members = await channelClient(url).members(args.channel);
     console.log(args.json ? toJson(members) : renderRoster(members));
   }
 });
@@ -1502,7 +1582,6 @@ var updateCommand = defineCommand({
   meta: { name: "update", description: "update a channel's title / description (topic + rules)" },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
-    token: { type: "string", required: true, description: "channel token" },
     title: { type: "string", description: "new title" },
     desc: { type: "string", description: "new description (purpose / topic / rules)" },
     ...common
@@ -1511,7 +1590,7 @@ var updateCommand = defineCommand({
     if (args.title === void 0 && args.desc === void 0)
       throw new Error("nothing to update: pass --title and/or --desc");
     const url = resolveBaseUrl(args.url);
-    const ch = await channelClient(url).update(args.channel, args.token, {
+    const ch = await channelClient(url).update(args.channel, {
       title: args.title,
       description: args.desc
     });
@@ -1520,7 +1599,7 @@ var updateCommand = defineCommand({
 });
 
 // src/commands/channel/listen.ts
-import { mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
@@ -1552,6 +1631,12 @@ var unstartedUserMessages = (events) => {
   const started = startedMessageIds(events);
   return events.filter((e) => e.type === "user_message" && !started.has(e.id));
 };
+var opensTurn = (e) => e.type === "user_message" || e.type === "turn_start";
+var closesTurn = (e) => e.type === "turn_complete" || e.type === "turn_error";
+var isAgentWorking = (events) => {
+  const last = events.findLast((e) => opensTurn(e) || closesTurn(e));
+  return last ? opensTurn(last) : false;
+};
 
 // src/commands/channel/listen.ts
 var PREVIEW = 280;
@@ -1569,7 +1654,7 @@ var runListen = async (o) => {
   const surface = (m) => {
     const text = typeof m.text === "string" ? m.text : "";
     const file = join2(spillDir, `${m.seq}.txt`);
-    writeFileSync2(file, text);
+    writeFileSync3(file, text);
     const truncated = text.length > PREVIEW;
     emit({
       type: "channel.message",
@@ -1582,10 +1667,17 @@ var runListen = async (o) => {
       chars: text.length,
       truncated,
       preview: truncated ? `${text.slice(0, PREVIEW)} \u2026` : text,
+      // BASE-prefixed urls so the subscribing agent can fetch directly.
+      attachments: m.attachments?.length ? m.attachments.map((a) => ({
+        filename: a.filename,
+        contentType: a.contentType,
+        size: a.size,
+        url: `${o.url}${a.url}`
+      })) : void 0,
       file
     });
   };
-  const close = channelClient(o.url).listen(o.channel, o.token, {
+  const close = channelClient(o.url).listen(o.channel, {
     since: o.since,
     for: o.for,
     as: o.from,
@@ -1612,8 +1704,10 @@ var listenCommand = defineCommand({
   },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
-    token: { type: "string", required: true, description: "channel token" },
-    from: { type: "string", description: "your name; your own messages skipped, presence kept fresh" },
+    from: {
+      type: "string",
+      description: "your name; your own messages skipped, presence kept fresh"
+    },
     since: { type: "string", description: "replay messages after this seq (default 0 = full)" },
     for: { type: "string", description: "only broadcasts + messages addressed to this name" },
     ...common
@@ -1622,7 +1716,6 @@ var listenCommand = defineCommand({
     await runListen({
       url: resolveBaseUrl(args.url),
       channel: args.channel,
-      token: args.token,
       from: args.from ?? "",
       since: args.since ? Number(args.since) : 0,
       for: args.for
@@ -1632,30 +1725,35 @@ var listenCommand = defineCommand({
 
 // src/commands/channel/join.ts
 var joinCommand = defineCommand({
-  meta: { name: "join", description: "join a channel (register presence); --listen to also stream" },
+  meta: {
+    name: "join",
+    description: "join a channel (register presence); --listen to also stream"
+  },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
-    token: { type: "string", required: true, description: "channel token" },
     from: { type: "string", required: true, description: "your participant name" },
     kind: { type: "string", description: "your kind: agent (default) | human" },
-    listen: { type: "boolean", description: "after joining, stream messages (background subscriber)" },
+    listen: {
+      type: "boolean",
+      description: "after joining, stream messages (background subscriber)"
+    },
     since: { type: "string", description: "with --listen: replay after this seq (default 0)" },
     ...common
   },
   run: async ({ args }) => {
     const url = resolveBaseUrl(args.url);
     const kind = args.kind === "human" ? "human" : "agent";
-    const members = await channelClient(url).join(args.channel, args.token, args.from, kind);
+    const members = await channelClient(url).join(args.channel, args.from, kind);
     if (!args.listen) {
       if (args.json) console.log(toJson({ joined: args.from, members }));
-      else console.log(`joined as ${args.from} (${members.length} online)
+      else
+        console.log(`joined as ${args.from} (${members.length} online)
 ${renderRoster(members)}`);
       return;
     }
     await runListen({
       url,
       channel: args.channel,
-      token: args.token,
       from: args.from,
       since: args.since ? Number(args.since) : 0
     });
@@ -1663,11 +1761,16 @@ ${renderRoster(members)}`);
 });
 
 // src/commands/channel/read.ts
+var fmtMessage = (m, base) => {
+  const head = `${m.seq}  ${m.from}  ${m.text}`;
+  const atts = (m.attachments ?? []).map((a) => `
+    \u{1F4CE} ${a.filename} \u2192 ${base}${a.url}`).join("");
+  return head + atts;
+};
 var readCommand = defineCommand({
   meta: { name: "read", description: "poll channel messages once (curl-style, since a cursor)" },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
-    token: { type: "string", required: true, description: "channel token" },
     since: { type: "string", description: "only messages after this seq (default 0)" },
     from: { type: "string", description: "skip messages from this name (no echo)" },
     for: { type: "string", description: "only broadcasts + messages addressed to this name" },
@@ -1675,40 +1778,99 @@ var readCommand = defineCommand({
   },
   run: async ({ args }) => {
     const url = resolveBaseUrl(args.url);
-    const msgs = await channelClient(url).read(args.channel, args.token, {
+    const msgs = await channelClient(url).read(args.channel, {
       since: args.since ? Number(args.since) : 0,
       for: args.for
     });
     const out = args.from ? msgs.filter((m) => m.from !== args.from) : msgs;
     if (args.json) console.log(toJson(out));
-    else console.log(out.length ? out.map((m) => `${m.seq}  ${m.from}  ${m.text}`).join("\n") : "(none)");
+    else console.log(out.length ? out.map((m) => fmtMessage(m, url)).join("\n") : "(none)");
   }
 });
 
 // src/commands/channel/send.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { openAsBlob as openAsBlob2, readFileSync as readFileSync2 } from "node:fs";
+import { basename as basename2 } from "node:path";
+
+// src/mime.ts
+import { extname } from "node:path";
+var BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv"
+};
+var contentTypeForPath = (path) => BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
+
+// src/commands/attach.ts
+import { openAsBlob } from "node:fs";
+import { basename } from "node:path";
+var attachPaths = (raw) => (raw === void 0 ? [] : Array.isArray(raw) ? raw : [raw]).flatMap((p) => p.split(",")).map((p) => p.trim()).filter(Boolean);
+var uploadAttachments = async (client, sessionId, paths) => {
+  const out = [];
+  for (const path of paths) {
+    const body = await openAsBlob(path, { type: contentTypeForPath(path) });
+    out.push(
+      await client.sessions.uploadAttachment(sessionId, {
+        filename: basename(path),
+        contentType: contentTypeForPath(path),
+        body
+      })
+    );
+  }
+  return out;
+};
+
+// src/commands/channel/send.ts
 var sendCommand = defineCommand({
   meta: { name: "send", description: "post one message to a channel" },
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
     text: { type: "positional", required: false, description: "message text (short one-liner)" },
-    token: { type: "string", required: true, description: "channel token" },
     from: { type: "string", description: "your participant name (default: peer)" },
-    to: { type: "string", description: "direct it at these names (comma-separated); omit = broadcast" },
+    to: {
+      type: "string",
+      description: "direct it at these names (comma-separated); omit = broadcast"
+    },
     file: { type: "string", description: "read message body from this file (for large content)" },
+    attach: {
+      type: "string",
+      description: "attach file(s) (comma-separated paths); uploaded + carried on the message"
+    },
     ...common
   },
   run: async ({ args }) => {
     const url = resolveBaseUrl(args.url);
+    const client = channelClient(url);
     let text = args.text;
     if (text === void 0 && args.file) text = readFileSync2(args.file, "utf8");
     if (text === void 0 && !process.stdin.isTTY) text = await readStdin();
-    if (text === void 0 || text === "")
-      throw new Error("nothing to send: provide text, --file <path>, or pipe stdin");
-    const msg = await channelClient(url).send(args.channel, args.token, {
+    const attachments = [];
+    for (const path of attachPaths(args.attach)) {
+      attachments.push(
+        await client.uploadAttachment(args.channel, {
+          filename: basename2(path),
+          contentType: contentTypeForPath(path),
+          body: await openAsBlob2(path, { type: contentTypeForPath(path) })
+        })
+      );
+    }
+    if (!text && attachments.length === 0)
+      throw new Error(
+        "nothing to send: provide text, --file <path>, --attach <file>, or pipe stdin"
+      );
+    const msg = await client.send(args.channel, {
       from: args.from ?? "peer",
-      text,
-      to: splitCsv(args.to)
+      text: text ?? "",
+      to: splitCsv(args.to),
+      attachments: attachments.length ? attachments : void 0
     });
     if (args.json) console.log(toJson(msg));
     else console.log(`sent (seq ${msg.seq})`);
@@ -1719,7 +1881,7 @@ var sendCommand = defineCommand({
 var channel = defineCommand({
   meta: {
     name: "channel",
-    description: "multi-agent chat room: create / about / update / help / join / members / send / read / listen / close"
+    description: "multi-agent chat room: create / about / update / help / join / members / send / read / listen / download / close"
   },
   subCommands: {
     create: createCommand,
@@ -1731,6 +1893,7 @@ var channel = defineCommand({
     send: sendCommand,
     read: readCommand,
     listen: listenCommand,
+    download: downloadCommand,
     close: closeCommand
   }
 });
@@ -1874,7 +2037,7 @@ var project = defineCommand({
 });
 
 // src/commands/relay.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join3 } from "node:path";
 
@@ -2009,7 +2172,7 @@ var listenCommand2 = defineCommand({
     const surface = (m) => {
       const text = typeof m.text === "string" ? m.text : "";
       const file = join3(spillDir, `${m.seq}.txt`);
-      writeFileSync3(file, text);
+      writeFileSync4(file, text);
       const truncated = text.length > PREVIEW2;
       emit({
         type: "relay.message",
@@ -2506,6 +2669,7 @@ var toTurnResult = (message) => {
 
 // src/session/runner/turn.ts
 var turnTimeoutMs = () => Number(process.env.BATON_TURN_TIMEOUT_MS) || 30 * 6e4;
+var heartbeatMs = () => Number(process.env.BATON_TURN_HEARTBEAT_MS) || 3e4;
 var TIMEOUT = /* @__PURE__ */ Symbol("turn-timeout");
 var ABORTED = /* @__PURE__ */ Symbol("turn-aborted");
 var finalizeTurn = async (result, worker2, log) => {
@@ -2558,6 +2722,7 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
   const abort = new AbortController();
   const ceiling = turnTimeoutMs();
   let timer;
+  let heartbeat;
   const timeout = new Promise((resolve2) => {
     timer = setTimeout(() => resolve2(TIMEOUT), ceiling);
   });
@@ -2566,6 +2731,9 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
     else externalSignal?.addEventListener("abort", () => resolve2(ABORTED), { once: true });
   });
   try {
+    heartbeat = setInterval(() => {
+      void worker2.emitEvent("turn_heartbeat", {}).catch((e) => log(`[heartbeat] ${String(e)}`));
+    }, heartbeatMs());
     const messages = startQuery(config, text, resuming, queryFn, abort, log, {
       envOverlay,
       planMode,
@@ -2600,6 +2768,7 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
     return -1;
   } finally {
     clearTimeout(timer);
+    clearInterval(heartbeat);
   }
 };
 
@@ -2680,10 +2849,17 @@ var runDaemon = async (config, deps, signal) => {
       busy = false;
     }
   };
+  const closeOrphanedTurn = async (reason) => {
+    const events = await deps.worker.listEvents();
+    if (!isAgentWorking(events)) return;
+    await deps.worker.emitEvent("turn_error", { message: reason, synthetic: true });
+    log(`closed orphaned open turn (${reason})`);
+  };
   const reconcile = async () => {
     reconciling = true;
     try {
-      const pending = unstartedUserMessages(await deps.worker.listEvents());
+      const events = await deps.worker.listEvents();
+      const pending = unstartedUserMessages(events);
       let added = 0;
       for (const ev of pending) {
         if (state.seen.has(ev.sequence)) continue;
@@ -2695,6 +2871,12 @@ var runDaemon = async (config, deps, signal) => {
         log(`reconciled ${added} queued message(s) from transcript`);
         lastActivity = Date.now();
         void drain();
+      } else if (pendingQueue.length === 0 && !busy && !currentTurn && isAgentWorking(events)) {
+        await deps.worker.emitEvent("turn_error", {
+          message: "turn abandoned \u2014 runner restarted",
+          synthetic: true
+        });
+        log("reconcile: closed orphaned open turn from a prior child");
       }
     } catch (e) {
       log(`reconcile failed: ${String(e)}`);
@@ -2719,6 +2901,11 @@ var runDaemon = async (config, deps, signal) => {
       if (currentTurn) {
         log("interrupt \u2014 aborting current turn");
         currentTurn.abort();
+      } else {
+        log("interrupt \u2014 no live turn; closing any orphaned open turn");
+        void closeOrphanedTurn("interrupted by user").catch(
+          (e) => log(`orphan close failed: ${String(e)}`)
+        );
       }
     },
     // Report active only now that we're subscribed — before this, a message
@@ -2811,44 +2998,6 @@ var sessionRunCommand = defineCommand({
   }
 });
 
-// src/commands/attach.ts
-import { openAsBlob } from "node:fs";
-import { basename } from "node:path";
-
-// src/mime.ts
-import { extname } from "node:path";
-var BY_EXT = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".pdf": "application/pdf",
-  ".txt": "text/plain",
-  ".md": "text/markdown",
-  ".json": "application/json",
-  ".csv": "text/csv"
-};
-var contentTypeForPath = (path) => BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
-
-// src/commands/attach.ts
-var attachPaths = (raw) => (raw === void 0 ? [] : Array.isArray(raw) ? raw : [raw]).flatMap((p) => p.split(",")).map((p) => p.trim()).filter(Boolean);
-var uploadAttachments = async (client, sessionId, paths) => {
-  const out = [];
-  for (const path of paths) {
-    const body = await openAsBlob(path, { type: contentTypeForPath(path) });
-    out.push(
-      await client.sessions.uploadAttachment(sessionId, {
-        filename: basename(path),
-        contentType: contentTypeForPath(path),
-        body
-      })
-    );
-  }
-  return out;
-};
-
 // src/commands/session/send.ts
 var sessionSendCommand = defineCommand({
   meta: { name: "send", description: "post a chat message into a session (no streaming reply)" },
@@ -3229,6 +3378,17 @@ var removeWorktree = (repo, worktreePath) => {
   } catch {
   }
 };
+var restoreWorktree = (repo, worktreePath, sessionCode) => {
+  spawnSync2("git", ["-C", repo, "worktree", "prune"], { stdio: "pipe" });
+  mkdirSync3(dirname(worktreePath), { recursive: true });
+  const branch = `baton/${sessionCode}`;
+  const reuse = spawnSync2("git", ["-C", repo, "worktree", "add", worktreePath, branch], {
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (reuse.status === 0) return;
+  createWorktree({ repo, worktreePath, sessionCode, base: repoHeadBranch(repo) });
+};
 
 // src/worker/watchdog.ts
 var stale = (okAt, now, thresholdMs) => now - okAt > thresholdMs;
@@ -3316,6 +3476,9 @@ var runWorkerDaemon = async (cfg, client, signal) => {
       });
       await client.sessions.materialize(sessionId, { agentSessionId, worktreePath }, cfg.apiToken);
       log(`materialized session #${sessionId} \u2192 ${worktreePath}`);
+    } else if (!existsSync5(worktreePath)) {
+      restoreWorktree(repo, worktreePath, session2.agentSessionId.slice(0, 8));
+      log(`recreated session #${sessionId} worktree (was missing) \u2192 ${worktreePath}`);
     }
     ensureExcluded(repo, PROJECT_CONFIG_NAME);
     saveProjectConfig(join7(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg));
@@ -3421,7 +3584,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
 
 // src/worker/machine-id.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname3, join as join8 } from "node:path";
 var machineIdPath = (env = process.env) => join8(env.XDG_DATA_HOME ?? join8(env.HOME ?? homedir3(), ".local/share"), "baton", "machine-id");
@@ -3432,7 +3595,7 @@ var readOrCreateMachineId = (path = machineIdPath()) => {
   }
   const id = randomUUID2();
   mkdirSync4(dirname3(path), { recursive: true });
-  writeFileSync4(path, `${id}
+  writeFileSync5(path, `${id}
 `, "utf8");
   return id;
 };
@@ -3492,7 +3655,10 @@ var worker = defineCommand({
             "no baton server \u2014 pass --url <url> (e.g. https://baton.fmap.dev/api), set BATON_URL, or run `baton init`"
           );
         if (!args.json) console.log(`registering against ${server}`);
-        const c = createClient(server);
+        const cfgPath = configPathFromArgs(args);
+        const fileToken = loadProjectConfigOrNull(cfgPath)?.worker?.apiToken;
+        const auth = resolveAuth(process.env, fileToken);
+        const c = createClient(server, auth && auth !== "cookie" ? auth : void 0);
         const hostname = osHostname();
         const machineId = readOrCreateMachineId();
         const name = args.name ?? hostname;
@@ -3505,7 +3671,7 @@ var worker = defineCommand({
             hostname,
             machineId
           },
-          configPathFromArgs(args)
+          cfgPath
         );
         if (args.json) {
           console.log(toJson({ ...out, configPath, machineIdPath: machineIdPath() }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "license": "MIT",
   "type": "module",
   "description": "baton CLI — register/run a worker, manage projects/requirements/tasks/sessions",