@lesscap/baton-cli 0.3.2 → 0.3.3

package/dist/baton.mjs

@@ -1137,6 +1137,17 @@ var fmtWorker = (w) => {
   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);
@@ -1193,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}`;
@@ -1368,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([
@@ -1441,6 +1467,13 @@ 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({
@@ -1962,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));
@@ -2039,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) => {
@@ -2167,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({
@@ -2325,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: {
@@ -3866,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.2",
+  "version": "0.3.3",
   "license": "MIT",
   "type": "module",
   "description": "baton CLI — register/run a worker, manage projects/requirements/tasks/sessions",