macroclaw 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macroclaw",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "Telegram-to-Claude-Code bridge",
   "license": "MIT",
   "type": "module",

package/src/app.test.ts

@@ -141,12 +141,12 @@ describe("App", () => {
     expect(bot.filterHandlers.has("callback_query:data")).toBe(true);
   });
 
-  it("registers chatid, session, and bg commands", () => {
+  it("registers chatid, bg, and sessions commands", () => {
     const app = new App(makeConfig());
     const bot = app.bot as any;
     expect(bot.commandHandlers.has("chatid")).toBe(true);
-    expect(bot.commandHandlers.has("session")).toBe(true);
     expect(bot.commandHandlers.has("bg")).toBe(true);
+    expect(bot.commandHandlers.has("sessions")).toBe(true);
   });
 
   it("registers error handler", () => {
@@ -166,7 +166,7 @@ describe("App", () => {
       await new Promise((r) => setTimeout(r, 50));
 
       const claude = config.claude as Claude & { calls: CallInfo[] };
-      expect(claude.calls[0].prompt).toBe("hello");
+      expect(claude.calls[0].prompt).toContain("<text>hello</text>");
     });
 
     it("ignores messages from unauthorized chats", async () => {
@@ -219,7 +219,7 @@ describe("App", () => {
       await new Promise((r) => setTimeout(r, 50));
 
       const claude = config.claude as Claude & { calls: CallInfo[] };
-      expect(claude.calls[0].prompt).toBe("bg: research pricing");
+      expect(claude.calls[0].prompt).toContain("<text>bg: research pricing</text>");
     });
 
     it("sends error wrapped in response", async () => {
@@ -269,7 +269,7 @@ describe("App", () => {
       expect(bot.api.getFile).toHaveBeenCalledWith("large");
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toContain("[File:");
+      expect(claude.calls[0].prompt).toContain("<file path=");
 
       globalThis.fetch = origFetch;
     });
@@ -297,7 +297,7 @@ describe("App", () => {
       expect(bot.api.getFile).toHaveBeenCalledWith("doc-id");
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toContain("[File:");
+      expect(claude.calls[0].prompt).toContain("<file path=");
 
       globalThis.fetch = origFetch;
     });
@@ -363,7 +363,7 @@ describe("App", () => {
 
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toBe("hello from voice");
+      expect(claude.calls[0].prompt).toContain("<text>hello from voice</text>");
 
       globalThis.fetch = origFetch;
     });
@@ -532,7 +532,7 @@ describe("App", () => {
       expect(ctx.editMessageReplyMarkup).toHaveBeenCalledWith({ reply_markup: { inline_keyboard: [[{ text: "✓ Yes", callback_data: "_noop" }]] } });
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toBe('[Context: button-click] User tapped "Yes"');
+      expect(claude.calls[0].prompt).toContain('<button>Yes</button>');
     });
 
     it("handles _dismiss callback by removing reply markup", async () => {
@@ -576,7 +576,7 @@ describe("App", () => {
       expect(ctx.editMessageReplyMarkup).toHaveBeenCalledWith({ reply_markup: { inline_keyboard: [[{ text: "✓ Opened", callback_data: "_noop" }]] } });
       const calls = (bot.api.sendMessage as any).mock.calls;
       const text = calls[calls.length - 1][1];
-      expect(text).toBe("Agent not found or already finished.");
+      expect(text).toBe("Session not found or already finished.");
     });
 
     it("handles peek: callback by routing to orchestrator.handlePeek", async () => {
@@ -599,7 +599,7 @@ describe("App", () => {
       expect(ctx.editMessageReplyMarkup).toHaveBeenCalledWith({ reply_markup: { inline_keyboard: [[{ text: "✓ Peeked", callback_data: "_noop" }]] } });
       const calls = (bot.api.sendMessage as any).mock.calls;
       const text = calls[calls.length - 1][1];
-      expect(text).toBe("Agent not found or already finished.");
+      expect(text).toBe("Session not found or already finished.");
     });
 
     it("handles kill: callback by routing to orchestrator.handleKill", async () => {
@@ -622,7 +622,7 @@ describe("App", () => {
       expect(ctx.editMessageReplyMarkup).toHaveBeenCalledWith({ reply_markup: { inline_keyboard: [[{ text: "✓ Killed", callback_data: "_noop" }]] } });
       const calls = (bot.api.sendMessage as any).mock.calls;
       const text = calls[calls.length - 1][1];
-      expect(text).toBe("Agent not found or already finished.");
+      expect(text).toBe("Session not found or already finished.");
     });
 
     it("ignores callback_query from unauthorized chats", async () => {
@@ -676,35 +676,9 @@ describe("App", () => {
       expect(ctx.reply).toHaveBeenCalledWith("Chat ID: `12345`", { parse_mode: "Markdown" });
     });
 
-    it("/session sends session ID via sendMessage", async () => {
-      const app = new App(makeConfig());
-      const bot = app.bot as any;
-      const handler = bot.commandHandlers.get("session")!;
-      const ctx = { chat: { id: 12345 } };
-
-      handler(ctx);
-      await new Promise((r) => setTimeout(r, 50));
-
-      const calls = (bot.api.sendMessage as any).mock.calls;
-      expect(calls.length).toBeGreaterThan(0);
-      const text = calls[calls.length - 1][1];
-      expect(text).toBe("Session: <code>test-session</code>");
-    });
-
-    it("/session is ignored for unauthorized chats", async () => {
-      const app = new App(makeConfig());
-      const bot = app.bot as any;
-      const handler = bot.commandHandlers.get("session")!;
-      const ctx = { chat: { id: 99999 } };
-
-      handler(ctx);
-      await new Promise((r) => setTimeout(r, 50));
-
-      expect((bot.api.sendMessage as any).mock.calls.length).toBe(0);
-    });
-
-    it("/bg shows no agents via sendMessage when none are running", async () => {
-      const app = new App(makeConfig());
+    it("/bg without prompt sends usage hint", async () => {
+      const config = makeConfig();
+      const app = new App(config);
       const bot = app.bot as any;
       const handler = bot.commandHandlers.get("bg")!;
       const ctx = { chat: { id: 12345 }, match: "" };
@@ -712,9 +686,9 @@ describe("App", () => {
       handler(ctx);
       await new Promise((r) => setTimeout(r, 50));
 
+      expect((config.claude as Claude & { calls: CallInfo[] }).calls).toHaveLength(0);
       const calls = (bot.api.sendMessage as any).mock.calls;
-      const text = calls[calls.length - 1][1];
-      expect(text).toBe("No background agents running.");
+      expect(calls[calls.length - 1][1]).toBe("Usage: /bg &lt;prompt&gt;");
     });
 
     it("/bg with prompt spawns a background agent via sendMessage", async () => {
@@ -739,46 +713,34 @@ describe("App", () => {
       expect(claude.calls).toHaveLength(1);
     });
 
-    it("/bg lists active background agents via sendMessage", async () => {
-      const claude = mockClaude((): RunningQuery<unknown> => ({
-        sessionId: `bg-${Date.now()}`,
-        startedAt: new Date(),
-        result: new Promise(() => {}),
-        kill: mock(async () => {}),
-      }));
-      const config = makeConfig({ claude });
-      const app = new App(config);
+    it("/sessions lists running sessions via sendMessage", async () => {
+      const app = new App(makeConfig());
       const bot = app.bot as any;
-      const bgHandler = bot.commandHandlers.get("bg")!;
-
-      const spawnCtx = { chat: { id: 12345 }, match: "long task" };
-      bgHandler(spawnCtx);
-      await new Promise((r) => setTimeout(r, 10));
+      const handler = bot.commandHandlers.get("sessions")!;
+      const ctx = { chat: { id: 12345 } };
 
-      const listCtx = { chat: { id: 12345 }, match: "" };
-      bgHandler(listCtx);
-      await new Promise((r) => setTimeout(r, 10));
+      handler(ctx);
+      await new Promise((r) => setTimeout(r, 50));
 
       const calls = (bot.api.sendMessage as any).mock.calls;
-      const lastText = calls[calls.length - 1][1];
-      expect(lastText).toContain("long-task");
-      expect(lastText).toMatch(/\d+s/);
+      const text = calls[calls.length - 1][1];
+      expect(text).toBe("No running sessions.");
     });
 
-    it("shows 'none' when no session exists yet", async () => {
-      if (existsSync(tmpSettingsDir)) rmSync(tmpSettingsDir, { recursive: true });
+    it("/sessions is ignored for unauthorized chats", async () => {
       const app = new App(makeConfig());
       const bot = app.bot as any;
-      const handler = bot.commandHandlers.get("session")!;
-      const ctx = { chat: { id: 12345 } };
+      const handler = bot.commandHandlers.get("sessions")!;
+      const ctx = { chat: { id: 99999 } };
 
       handler(ctx);
       await new Promise((r) => setTimeout(r, 50));
 
-      const calls = (bot.api.sendMessage as any).mock.calls;
-      const text = calls[calls.length - 1][1];
-      expect(text).toBe("Session: <code>none</code>");
+      // No sendMessage calls for unauthorized
+      expect((bot.api.sendMessage as any).mock.calls.length).toBe(0);
     });
+
+
   });
 
   describe("error handler", () => {
@@ -803,8 +765,8 @@ describe("App", () => {
       app.start();
       expect(bot.api.setMyCommands).toHaveBeenCalledWith([
         { command: "chatid", description: "Show current chat ID" },
-        { command: "session", description: "Show current session ID" },
-        { command: "bg", description: "List or spawn background agents" },
+        { command: "bg", description: "Spawn a background agent" },
+        { command: "sessions", description: "List running sessions" },
       ]);
     });
   });

package/src/app.ts

@@ -43,13 +43,13 @@ export class App {
   start() {
     log.info("Starting macroclaw...");
     const scheduler = new Scheduler(this.#config.workspace, {
-      onJob: (name, prompt, model) => this.#orchestrator.handleCron(name, prompt, model),
+      onJob: (name, prompt, model, missed) => this.#orchestrator.handleCron(name, prompt, model, missed),
     });
     scheduler.start();
     this.#bot.api.setMyCommands([
       { command: "chatid", description: "Show current chat ID" },
-      { command: "session", description: "Show current session ID" },
-      { command: "bg", description: "List or spawn background agents" },
+      { command: "bg", description: "Spawn a background agent" },
+      { command: "sessions", description: "List running sessions" },
     ]).catch((err) => log.error({ err }, "Failed to set commands"));
     this.#bot.start({
       onStart: (botInfo) => {
@@ -73,22 +73,22 @@ export class App {
       ctx.reply(`Chat ID: \`${ctx.chat.id}\``, { parse_mode: "Markdown" });
     });
 
-    this.#bot.command("session", (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
-      log.debug("Command /session");
-      this.#orchestrator.handleSessionCommand();
-    });
-
     this.#bot.command("bg", (ctx) => {
       if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
       const prompt = ctx.match?.trim();
-      if (prompt) {
-        log.debug({ prompt }, "Command /bg spawn");
-        this.#orchestrator.handleBackgroundCommand(prompt);
+      if (!prompt) {
+        log.debug("Command /bg without prompt");
+        sendResponse(this.#bot, this.#config.authorizedChatId, "Usage: /bg <prompt>");
         return;
       }
-      log.debug("Command /bg list");
-      this.#orchestrator.handleBackgroundList();
+      log.debug({ prompt }, "Command /bg spawn");
+      this.#orchestrator.handleBackgroundCommand(prompt);
+    });
+
+    this.#bot.command("sessions", (ctx) => {
+      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
+      log.debug("Command /sessions");
+      this.#orchestrator.handleSessions();
     });
 
     this.#bot.on("message:photo", async (ctx) => {

package/src/claude.ts

@@ -123,7 +123,7 @@ export class Claude {
     if (systemPrompt) args.push("--append-system-prompt", systemPrompt);
     args.push(prompt);
 
-    log.debug({ model, sessionId, promptLen: prompt.length, mode: mode.kind, hasSystemPrompt: !!systemPrompt }, "Sending to Claude");
+    log.debug({ model, sessionId, promptLen: prompt.length, mode: mode.kind, hasSystemPrompt: !!systemPrompt, prompt }, "Sending to Claude");
 
     const proc = Bun.spawn(args, { cwd: this.#workspace, env, stdout: "pipe", stderr: "pipe" });
     const startedAt = new Date();

package/src/index.ts

@@ -8,6 +8,10 @@ import { SpeechToText } from "./speech-to-text";
 export async function start(): Promise<void> {
   const log = createLogger("index");
 
+  process.on("unhandledRejection", (err) => {
+    log.error({ err }, "Unhandled rejection");
+  });
+
   const mgr = new SettingsManager();
   const settings = mgr.load();
   const { settings: resolved, overrides } = mgr.applyEnvOverrides(settings);

package/src/naming.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { generateName } from "./naming";
+
+describe("generateName", () => {
+  test("extracts content words from English prompt", () => {
+    expect(generateName("please research the best coffee shops in Prague")).toBe("research-best-coffee-shops");
+  });
+
+  test("extracts content words from Czech prompt", () => {
+    expect(generateName("najdi nejlepsi kavárny v Praze a porovnej ceny")).toBe("najdi-nejlepsi-kavrny-praze");
+  });
+
+  test("returns 'task' for stop-words-only prompt", () => {
+    expect(generateName("please do this for me")).toBe("task");
+  });
+
+  test("returns 'task' for empty prompt", () => {
+    expect(generateName("")).toBe("task");
+  });
+
+  test("strips non-alphanumeric characters", () => {
+    expect(generateName("fix bug #123 in auth-service!")).toBe("fix-bug-123-auth");
+  });
+
+  test("respects maxWords parameter", () => {
+    expect(generateName("deploy new redis cluster with monitoring", 2)).toBe("deploy-new");
+  });
+
+  test("skips single-character words", () => {
+    expect(generateName("a b c deploy x y z")).toBe("deploy");
+  });
+
+  test("handles mixed English and Czech", () => {
+    expect(generateName("zkontroluj jestli je deploy hotovy")).toBe("zkontroluj-jestli-deploy-hotovy");
+  });
+
+  test("respects maxLength and drops words that would exceed it", () => {
+    expect(generateName("deploy infrastructure monitoring cluster", 4, 25)).toBe("deploy-infrastructure");
+  });
+
+  test("returns 'task' for very long single nonsense word", () => {
+    expect(generateName("a".repeat(500))).toBe("task");
+  });
+});

package/src/naming.ts

@@ -0,0 +1,54 @@
+/** Generates a short kebab-case name from a prompt by extracting content words. */
+
+const STOP_WORDS = new Set([
+  // English
+  "a", "about", "above", "after", "again", "all", "also", "am", "an", "and",
+  "any", "are", "as", "at", "be", "because", "been", "before", "being",
+  "between", "both", "but", "by", "can", "could", "did", "do", "does",
+  "doing", "down", "during", "each", "few", "for", "from", "further", "get",
+  "got", "had", "has", "have", "having", "he", "her", "here", "hers",
+  "herself", "him", "himself", "his", "how", "i", "if", "in", "into", "is",
+  "it", "its", "itself", "just", "know", "let", "like", "make", "may", "me",
+  "might", "more", "most", "must", "my", "myself", "need", "no", "nor", "not",
+  "now", "of", "off", "on", "once", "only", "or", "other", "our", "ours",
+  "ourselves", "out", "over", "own", "please", "really", "right", "same",
+  "shall", "she", "should", "so", "some", "such", "take", "than", "that",
+  "the", "their", "theirs", "them", "themselves", "then", "there", "these",
+  "they", "this", "those", "through", "to", "too", "under", "until", "up",
+  "us", "very", "want", "was", "we", "were", "what", "when", "where", "which",
+  "while", "who", "whom", "why", "will", "with", "would", "you", "your",
+  "yours", "yourself", "yourselves",
+  // Czech
+  "a", "aby", "aj", "ale", "ani", "ano", "asi", "az", "bez", "bude", "budem",
+  "budes", "by", "byl", "byla", "byli", "bylo", "byt", "ci", "co", "dal",
+  "dane", "do", "ho", "i", "ja", "jak", "jako", "je", "jeho", "jej", "jeji",
+  "jen", "jeste", "ji", "jich", "jim", "jine", "jiz", "jsem", "jses", "jsi",
+  "jsme", "jsou", "jste", "k", "kam", "kde", "kdo", "kdyz", "ke", "ktera",
+  "ktere", "kteri", "kterou", "ktery", "ma", "mam", "mate", "me", "mezi",
+  "mi", "mit", "mne", "mnou", "moc", "moje", "moji", "mu", "muze", "my",
+  "na", "nad", "nam", "nami", "nas", "nasi", "ne", "nebo", "nebot", "necht",
+  "nejsou", "neni", "nez", "nic", "nim", "o", "od", "on", "ona", "oni",
+  "ono", "pak", "po", "pod", "podle", "pokud", "potom", "pouze", "prave",
+  "pro", "proc", "proto", "protoze", "prvni", "pred", "presto", "pri", "sam",
+  "se", "si", "sice", "sve", "svou", "svuj", "svych", "svym", "svymi", "ta",
+  "tak", "take", "takze", "tato", "te", "tedy", "ten", "tento", "ti", "tim",
+  "to", "toho", "tohle", "tom", "tomu", "tu", "tuto", "tvuj", "ty", "tyto",
+  "u", "uz", "v", "vam", "vas", "vase", "ve", "vsak", "vse", "vsech",
+  "vsechno", "vsichni", "z", "za", "zda", "zde", "ze",
+]);
+
+export function generateName(prompt: string, maxWords = 4, maxLength = 40): string {
+  const words = prompt
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .replace(/-/g, " ")
+    .split(/\s+/)
+    .filter((w) => w.length > 1 && !STOP_WORDS.has(w));
+  let name = "";
+  for (const word of words.slice(0, maxWords)) {
+    const candidate = name ? `${name}-${word}` : word;
+    if (candidate.length > maxLength) break;
+    name = candidate;
+  }
+  return name || "task";
+}