@lesscap/baton-cli 0.3.1 → 0.3.3

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,79 +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();
     },
-    uploadAttachment: async (channelId, token, input) => {
+    uploadAttachment: async (channelId, input) => {
       const res = await fetch(
         u(`/channels/${channelId}/attachments?filename=${encodeURIComponent(input.filename)}`),
-        {
-          method: "POST",
-          headers: { "content-type": input.contentType, ...authed(token) },
-          body: input.body
-        }
+        { 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, token, attId) => {
-      const res = await fetch(u(`/channels/${channelId}/attachments/${attId}`), {
-        headers: authed(token)
-      });
+    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, token, opts) => {
+    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);
@@ -1145,9 +1134,20 @@ 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 fmtInterval = (sec) => {
+  if (sec % 86400 === 0) return `${sec / 86400}d`;
+  if (sec % 3600 === 0) return `${sec / 3600}h`;
+  if (sec % 60 === 0) return `${sec / 60}m`;
+  return `${sec}s`;
+};
+var fmtLoop = (l) => {
+  const label = l.name ? `${l.name}  ` : "";
+  const last = l.lastStatus ? `  last:${l.lastStatus}` : "";
+  return `${l.id}  [${l.enabled ? "on" : "off"}]  ${label}every ${fmtInterval(l.intervalSec)}${last}  "${l.message}"`;
+};
 var renderOne = (item, fmt, json) => json ? toJson(item) : fmt(item);
 var renderList = (items, fmt, json) => {
   if (json) return toJson(items);
@@ -1204,6 +1204,20 @@ var primeLogin = (baseUrl) => {
   );
 };
 
+// src/client/loops.ts
+var loopsClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  return {
+    create: (sessionId, input) => request(u(`/sessions/${sessionId}/loops`), { method: "POST", body: input }),
+    listBySession: (sessionId) => request(u(`/sessions/${sessionId}/loops`), { method: "GET" }),
+    get: (id) => request(u(`/loops/${id}`), { method: "GET" }),
+    update: (id, input) => request(u(`/loops/${id}`), { method: "PATCH", body: input }),
+    remove: async (id) => {
+      await request(u(`/loops/${id}`), { method: "DELETE" });
+    }
+  };
+};
+
 // src/client/projects.ts
 var projectClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -1379,6 +1393,7 @@ var clientFromBase = (baseUrl) => ({
   requirements: requirementClient(baseUrl),
   tasks: taskClient(baseUrl),
   sessions: sessionsClient(baseUrl),
+  loops: loopsClient(baseUrl),
   workers: workersClient(baseUrl)
 });
 var BOUNDARY_EVENTS = /* @__PURE__ */ new Set([
@@ -1428,6 +1443,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());
@@ -1447,17 +1467,23 @@ var parseWorkerHandle = (handle) => {
   return m ? Number(m[1]) : null;
 };
 var splitCsv = (s) => s ? s.split(",").map((x) => x.trim()).filter(Boolean) : void 0;
+var parseDuration = (s) => {
+  const m = s.trim().match(/^(\d+)\s*([smhd]?)$/);
+  if (!m) throw new Error(`bad interval "${s}" \u2014 use e.g. 90s, 30m, 2h, 1d`);
+  const n = Number(m[1]);
+  const mult = m[2] === "d" ? 86400 : m[2] === "h" ? 3600 : m[2] === "m" ? 60 : 1;
+  return n * mult;
+};
 
 // src/commands/channel/close.ts
 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}`);
   }
 });
@@ -1469,42 +1495,58 @@ 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 webLink = (url, channelId, token) => {
+var webLink = (url, channelId) => {
   const origin = url.replace(/\/api\/?$/, "");
-  return origin === url ? null : `${origin}/channel/${channelId}#token=${token}`;
+  return origin === url ? null : `${origin}/channel/${channelId}`;
 };
-var inviteBlock = (url, channelId, token) => {
-  const web = webLink(url, channelId, token);
+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 -H "authorization: Bearer ${token}" "${url}/channels/${channelId}"`,
+    `  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} token=${token}`,
+    `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));
   }
 });
 
@@ -1515,13 +1557,12 @@ var downloadCommand = defineCommand({
   args: {
     channel: { type: "positional", required: true, description: "channel id" },
     att: { type: "positional", required: true, description: "attachment id (from a message ref)" },
-    token: { type: "string", required: true, description: "channel token" },
     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.token, args.att);
+    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}`);
@@ -1533,12 +1574,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;
@@ -1553,7 +1593,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());
@@ -1563,12 +1603,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));
   }
 });
@@ -1576,7 +1615,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
@@ -1585,7 +1623,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
     });
@@ -1672,7 +1710,7 @@ var runListen = async (o) => {
       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,
@@ -1699,8 +1737,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
@@ -1709,7 +1749,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
@@ -1719,30 +1758,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
     });
@@ -1760,7 +1804,6 @@ 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" },
@@ -1768,7 +1811,7 @@ 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
     });
@@ -1824,11 +1867,16 @@ var sendCommand = defineCommand({
   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" },
+    attach: {
+      type: "string",
+      description: "attach file(s) (comma-separated paths); uploaded + carried on the message"
+    },
     ...common
   },
   run: async ({ args }) => {
@@ -1840,7 +1888,7 @@ var sendCommand = defineCommand({
     const attachments = [];
     for (const path of attachPaths(args.attach)) {
       attachments.push(
-        await client.uploadAttachment(args.channel, args.token, {
+        await client.uploadAttachment(args.channel, {
           filename: basename2(path),
           contentType: contentTypeForPath(path),
           body: await openAsBlob2(path, { type: contentTypeForPath(path) })
@@ -1848,8 +1896,10 @@ var sendCommand = defineCommand({
       );
     }
     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, args.token, {
+      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: text ?? "",
       to: splitCsv(args.to),
@@ -1945,6 +1995,163 @@ var init = defineCommand({
   }
 });
 
+// src/commands/session/shared.ts
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+var defaultWorktreeDir = (env = process.env) => env.BATON_WORKTREE_DIR ?? join3(env.XDG_DATA_HOME ?? join3(env.HOME ?? homedir(), ".local/share"), "baton", "worktrees");
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+var resolveSession = async (client, projectId, handle) => {
+  const asInt = Number(handle);
+  if (Number.isInteger(asInt) && asInt > 0) {
+    const byId = await client.sessions.get(asInt).catch(() => null);
+    if (byId) return { id: byId.id, name: byId.name };
+  }
+  const byName = await client.sessions.findByName(projectId, handle);
+  if (byName) return { id: byName.id, name: byName.name };
+  throw new Error(`session "${handle}" not found in project ${projectId}`);
+};
+
+// src/commands/loop/create.ts
+var loopCreateCommand = defineCommand({
+  meta: { name: "create", description: "create a recurring scheduled message on a session" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    message: {
+      type: "string",
+      required: true,
+      description: "message sent to the session each beat"
+    },
+    every: {
+      type: "string",
+      required: true,
+      description: "interval: 90s / 30m / 2h / 1d (min 30s)"
+    },
+    name: { type: "string", description: "optional label" },
+    off: { type: "boolean", description: "create paused (disabled)" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const session2 = await resolveSession(c, resolveProjectId(args), args.session);
+    const loop2 = await c.loops.create(session2.id, {
+      message: args.message,
+      intervalSec: parseDuration(args.every),
+      name: args.name,
+      enabled: !args.off
+    });
+    console.log(renderOne(loop2, fmtLoop, Boolean(args.json)));
+  }
+});
+
+// src/commands/loop/disable.ts
+var loopDisableCommand = defineCommand({
+  meta: { name: "disable", description: "disable (pause) a loop" },
+  args: {
+    loop: { type: "positional", required: true, description: "loop int id" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const loop2 = await c.loops.update(Number(args.loop), { enabled: false });
+    console.log(renderOne(loop2, fmtLoop, Boolean(args.json)));
+  }
+});
+
+// src/commands/loop/enable.ts
+var loopEnableCommand = defineCommand({
+  meta: { name: "enable", description: "enable (resume) a loop" },
+  args: {
+    loop: { type: "positional", required: true, description: "loop int id" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const loop2 = await c.loops.update(Number(args.loop), { enabled: true });
+    console.log(renderOne(loop2, fmtLoop, Boolean(args.json)));
+  }
+});
+
+// src/commands/loop/get.ts
+var loopGetCommand = defineCommand({
+  meta: { name: "get", description: "show one loop" },
+  args: {
+    loop: { type: "positional", required: true, description: "loop int id" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const loop2 = await c.loops.get(Number(args.loop));
+    console.log(renderOne(loop2, fmtLoop, Boolean(args.json)));
+  }
+});
+
+// src/commands/loop/ls.ts
+var loopLsCommand = defineCommand({
+  meta: { name: "ls", description: "list a session's loops" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const session2 = await resolveSession(c, resolveProjectId(args), args.session);
+    const loops = await c.loops.listBySession(session2.id);
+    console.log(renderList(loops, fmtLoop, Boolean(args.json)));
+  }
+});
+
+// src/commands/loop/rm.ts
+var loopRmCommand = defineCommand({
+  meta: { name: "rm", description: "delete a loop" },
+  args: {
+    loop: { type: "positional", required: true, description: "loop int id" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const id = Number(args.loop);
+    await c.loops.remove(id);
+    console.log(removed("loop", id, Boolean(args.json)));
+  }
+});
+
+// src/commands/loop/set.ts
+var loopSetCommand = defineCommand({
+  meta: { name: "set", description: "update a loop (message / interval / name)" },
+  args: {
+    loop: { type: "positional", required: true, description: "loop int id" },
+    message: { type: "string", description: "new message" },
+    every: { type: "string", description: "new interval: 90s / 30m / 2h / 1d" },
+    name: { type: "string", description: "new label" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const patch2 = {};
+    if (args.message !== void 0) patch2.message = args.message;
+    if (args.every !== void 0 && args.every !== "") patch2.intervalSec = parseDuration(args.every);
+    if (args.name !== void 0) patch2.name = args.name;
+    const loop2 = await c.loops.update(Number(args.loop), patch2);
+    console.log(renderOne(loop2, fmtLoop, Boolean(args.json)));
+  }
+});
+
+// src/commands/loop.ts
+var loop = defineCommand({
+  meta: { name: "loop", description: "recurring scheduled messages that wake a session" },
+  subCommands: {
+    create: loopCreateCommand,
+    ls: loopLsCommand,
+    get: loopGetCommand,
+    set: loopSetCommand,
+    enable: loopEnableCommand,
+    disable: loopDisableCommand,
+    rm: loopRmCommand
+  }
+});
+
 // src/commands/project.ts
 var createProject = (c, input, json) => c.projects.create(input).then((p) => renderOne(p, fmtProject, json));
 var listProjects = (c, workspaceId, json) => c.projects.listByWorkspace(workspaceId).then((ps) => renderList(ps, fmtProject, json));
@@ -2022,7 +2229,7 @@ var project = defineCommand({
 // src/commands/relay.ts
 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";
+import { join as join4 } from "node:path";
 
 // src/client/relay.ts
 var relayClient = (baseUrl) => {
@@ -2150,11 +2357,11 @@ var listenCommand2 = defineCommand({
       process.stdout.write(`${JSON.stringify(o)}
 `);
     };
-    const spillDir = join3(tmpdir2(), "hotline", args.channel);
+    const spillDir = join4(tmpdir2(), "hotline", args.channel);
     mkdirSync2(spillDir, { recursive: true });
     const surface = (m) => {
       const text = typeof m.text === "string" ? m.text : "";
-      const file = join3(spillDir, `${m.seq}.txt`);
+      const file = join4(spillDir, `${m.seq}.txt`);
       writeFileSync4(file, text);
       const truncated = text.length > PREVIEW2;
       emit({
@@ -2308,22 +2515,6 @@ var requirement = defineCommand({
   }
 });
 
-// src/commands/session/shared.ts
-import { homedir } from "node:os";
-import { join as join4 } from "node:path";
-var defaultWorktreeDir = (env = process.env) => env.BATON_WORKTREE_DIR ?? join4(env.XDG_DATA_HOME ?? join4(env.HOME ?? homedir(), ".local/share"), "baton", "worktrees");
-var slug = (s) => s.toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
-var resolveSession = async (client, projectId, handle) => {
-  const asInt = Number(handle);
-  if (Number.isInteger(asInt) && asInt > 0) {
-    const byId = await client.sessions.get(asInt).catch(() => null);
-    if (byId) return { id: byId.id, name: byId.name };
-  }
-  const byName = await client.sessions.findByName(projectId, handle);
-  if (byName) return { id: byName.id, name: byName.name };
-  throw new Error(`session "${handle}" not found in project ${projectId}`);
-};
-
 // src/commands/session/abort.ts
 var sessionAbortCommand = defineCommand({
   meta: {
@@ -3361,6 +3552,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;
@@ -3448,6 +3650,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));
@@ -3624,7 +3829,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;
@@ -3637,7 +3845,7 @@ var worker = defineCommand({
             hostname,
             machineId
           },
-          configPathFromArgs(args)
+          cfgPath
         );
         if (args.json) {
           console.log(toJson({ ...out, configPath, machineIdPath: machineIdPath() }));
@@ -3832,6 +4040,7 @@ var main = defineCommand({
     init,
     worker,
     session,
+    loop,
     relay,
     channel,
     workspace,

package/package.json

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