@locusai/locus-telegram 0.22.12 → 0.22.14

package/bin/locus-telegram.js

@@ -9480,19 +9480,11 @@ var init_config = __esm(() => {
   init_dist();
 });
 
-// src/pm2.ts
+// ../pm2/dist/index.js
 import { execSync } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
 import { dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getPm2Bin() {
-  try {
-    const currentFile = fileURLToPath(import.meta.url);
-    const packageRoot = dirname(dirname(currentFile));
-    const localPm2 = join2(packageRoot, "..", "..", ".bin", "pm2");
-    if (existsSync2(localPm2))
-      return localPm2;
-  } catch {}
   try {
     const result = execSync("which pm2", {
       encoding: "utf-8",
@@ -9516,51 +9508,47 @@ function pm2Exec(args) {
     throw new Error(err.stderr?.trim() || err.message || "PM2 command failed");
   }
 }
-function getBotScriptPath() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const packageRoot = dirname(dirname(currentFile));
-  return join2(packageRoot, "bin", "locus-telegram.js");
-}
-function pm2Start() {
-  const script = getBotScriptPath();
+function pm2Start(config) {
+  const { processName, scriptPath, scriptArgs = [] } = config;
   const pm2 = getPm2Bin();
   try {
     const list = pm2Exec("jlist");
     const processes = JSON.parse(list);
-    const existing = processes.find((p) => p.name === PROCESS_NAME);
+    const existing = processes.find((p) => p.name === processName);
     if (existing) {
-      pm2Exec(`restart ${PROCESS_NAME}`);
-      return `Restarted ${PROCESS_NAME}`;
+      pm2Exec(`restart ${processName}`);
+      return `Restarted ${processName}`;
     }
   } catch {}
-  execSync(`${pm2} start ${JSON.stringify(script)} --name ${PROCESS_NAME} -- bot`, {
+  const argsStr = scriptArgs.length > 0 ? ` -- ${scriptArgs.join(" ")}` : "";
+  execSync(`${pm2} start ${JSON.stringify(scriptPath)} --name ${processName}${argsStr}`, {
     encoding: "utf-8",
     stdio: "inherit",
     env: process.env
   });
-  return `Started ${PROCESS_NAME}`;
+  return `Started ${processName}`;
 }
-function pm2Stop() {
-  pm2Exec(`stop ${PROCESS_NAME}`);
-  return `Stopped ${PROCESS_NAME}`;
+function pm2Stop(config) {
+  pm2Exec(`stop ${config.processName}`);
+  return `Stopped ${config.processName}`;
 }
-function pm2Restart() {
-  pm2Exec(`restart ${PROCESS_NAME}`);
-  return `Restarted ${PROCESS_NAME}`;
+function pm2Restart(config) {
+  pm2Exec(`restart ${config.processName}`);
+  return `Restarted ${config.processName}`;
 }
-function pm2Delete() {
-  pm2Exec(`delete ${PROCESS_NAME}`);
-  return `Deleted ${PROCESS_NAME}`;
+function pm2Delete(config) {
+  pm2Exec(`delete ${config.processName}`);
+  return `Deleted ${config.processName}`;
 }
-function pm2Status() {
+function pm2Status(config) {
   try {
     const list = pm2Exec("jlist");
     const processes = JSON.parse(list);
-    const proc = processes.find((p) => p.name === PROCESS_NAME);
+    const proc = processes.find((p) => p.name === config.processName);
     if (!proc)
       return null;
     return {
-      name: PROCESS_NAME,
+      name: config.processName,
       status: proc.pm2_env?.status ?? "unknown",
       pid: proc.pid ?? null,
       uptime: proc.pm2_env?.pm_uptime ?? null,
@@ -9571,17 +9559,285 @@ function pm2Status() {
     return null;
   }
 }
-function pm2Logs(lines = 50) {
+function pm2Logs(config, lines = 50) {
   try {
-    return pm2Exec(`logs ${PROCESS_NAME} --nostream --lines ${lines}`);
+    return pm2Exec(`logs ${config.processName} --nostream --lines ${lines}`);
   } catch {
     return "No logs available.";
   }
 }
-var PROCESS_NAME = "locus-telegram";
-var init_pm2 = () => {};
+function resolvePackageScript(importMetaUrl, binName) {
+  const currentFile = fileURLToPath(importMetaUrl);
+  const packageRoot = dirname(dirname(currentFile));
+  return join2(packageRoot, "bin", `${binName}.js`);
+}
+var init_dist2 = () => {};
 
-// src/tracker.ts
+// src/pm2.ts
+function getConfig() {
+  return {
+    processName: "locus-telegram",
+    scriptPath: resolvePackageScript(import.meta.url, "locus-telegram"),
+    scriptArgs: ["bot"]
+  };
+}
+function pm2Start2() {
+  return pm2Start(getConfig());
+}
+function pm2Stop2() {
+  return pm2Stop(getConfig());
+}
+function pm2Restart2() {
+  return pm2Restart(getConfig());
+}
+function pm2Delete2() {
+  return pm2Delete(getConfig());
+}
+function pm2Status2() {
+  return pm2Status(getConfig());
+}
+function pm2Logs2(lines = 50) {
+  return pm2Logs(getConfig(), lines);
+}
+var init_pm2 = __esm(() => {
+  init_dist2();
+});
+
+// ../gateway/dist/index.js
+import { exec as execCb } from "node:child_process";
+import { promisify } from "node:util";
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+function getCommandDefinition(command) {
+  return COMMAND_REGISTRY[command] ?? null;
+}
+function invokeLocusStream2(args, cwd) {
+  return spawn2("locus", args, {
+    cwd: cwd ?? process.cwd(),
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env,
+    shell: false
+  });
+}
+function formatData2(data) {
+  if (!data || Object.keys(data).length === 0)
+    return "";
+  return ` ${dim2(JSON.stringify(data))}`;
+}
+function createLogger2(name) {
+  const prefix = dim2(`[${name}]`);
+  return {
+    info(msg, data) {
+      process.stderr.write(`${bold2(cyan2("●"))} ${prefix} ${msg}${formatData2(data)}
+`);
+    },
+    warn(msg, data) {
+      process.stderr.write(`${bold2(yellow2("⚠"))}  ${prefix} ${yellow2(msg)}${formatData2(data)}
+`);
+    },
+    error(msg, data) {
+      process.stderr.write(`${bold2(red2("✗"))} ${prefix} ${red2(msg)}${formatData2(data)}
+`);
+    },
+    debug(msg, data) {
+      if (!process.env.LOCUS_DEBUG)
+        return;
+      process.stderr.write(`${gray2("⋯")} ${prefix} ${gray2(msg)}${formatData2(data)}
+`);
+    }
+  };
+}
+
+class CommandExecutor {
+  tracker;
+  constructor(tracker) {
+    this.tracker = tracker;
+  }
+  getTracker() {
+    return this.tracker;
+  }
+  async executeLocusCommand(sessionId, command, args, callbacks) {
+    const definition = getCommandDefinition(command);
+    if (!definition) {
+      return {
+        text: `Unknown command: /${command}`,
+        format: "plain",
+        exitCode: 1
+      };
+    }
+    if (definition.requiresArgs && args.length === 0) {
+      return {
+        text: definition.requiresArgs,
+        format: "plain",
+        exitCode: 1
+      };
+    }
+    const conflict = this.tracker.checkExclusiveConflict(sessionId, command);
+    if (conflict) {
+      return {
+        text: formatConflictText(command, conflict),
+        format: "plain",
+        exitCode: 1
+      };
+    }
+    const fullArgs = [...definition.cliArgs, ...args];
+    if (definition.streaming && callbacks) {
+      return this.executeStreaming(sessionId, command, args, fullArgs, callbacks);
+    }
+    return this.executeBuffered(sessionId, command, args, fullArgs);
+  }
+  async executeGit(sessionId, command, args, gitArgs) {
+    const conflict = this.tracker.checkExclusiveConflict(sessionId, command);
+    if (conflict) {
+      return {
+        text: formatConflictText(command, conflict),
+        format: "plain",
+        exitCode: 1
+      };
+    }
+    const trackingId = this.tracker.track(sessionId, command, args);
+    try {
+      const { stdout } = await exec(`git ${gitArgs}`, { cwd: process.cwd() });
+      return {
+        text: stdout,
+        format: "plain",
+        exitCode: 0
+      };
+    } catch (error) {
+      const errStr = String(error);
+      return {
+        text: errStr,
+        format: "plain",
+        exitCode: 1
+      };
+    } finally {
+      this.tracker.untrack(sessionId, trackingId);
+    }
+  }
+  async executeStreaming(sessionId, command, args, fullArgs, callbacks) {
+    const child = invokeLocusStream2(fullArgs);
+    const trackingId = this.tracker.track(sessionId, command, args, child);
+    let output = "";
+    let lastUpdateTime = 0;
+    let updateTimer = null;
+    let messageId = "";
+    const displayCmd = `locus ${fullArgs.join(" ")}`;
+    const startResult = await callbacks.onStart(formatStreamingText(displayCmd, "", false));
+    if (startResult)
+      messageId = startResult;
+    const pushUpdate = async () => {
+      const now = Date.now();
+      if (now - lastUpdateTime < STREAM_UPDATE_INTERVAL)
+        return;
+      lastUpdateTime = now;
+      try {
+        await callbacks.onUpdate(messageId, formatStreamingText(displayCmd, output, false));
+      } catch {}
+    };
+    child.stdout?.on("data", (chunk) => {
+      output += chunk.toString();
+      if (updateTimer)
+        clearTimeout(updateTimer);
+      updateTimer = setTimeout(pushUpdate, STREAM_UPDATE_INTERVAL);
+    });
+    child.stderr?.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    return new Promise((resolve) => {
+      child.on("close", async (exitCode) => {
+        this.tracker.untrack(sessionId, trackingId);
+        if (updateTimer)
+          clearTimeout(updateTimer);
+        const code = exitCode ?? 0;
+        await callbacks.onComplete(messageId, formatStreamingText(displayCmd, output, true), code);
+        resolve({
+          text: output,
+          format: "plain",
+          streaming: true,
+          exitCode: code
+        });
+      });
+    });
+  }
+  async executeBuffered(sessionId, command, args, fullArgs) {
+    const child = invokeLocusStream2(fullArgs);
+    const trackingId = this.tracker.track(sessionId, command, args, child);
+    let output = "";
+    child.stdout?.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    return new Promise((resolve) => {
+      child.on("close", (exitCode) => {
+        this.tracker.untrack(sessionId, trackingId);
+        const code = exitCode ?? 0;
+        resolve({
+          text: output,
+          format: "plain",
+          exitCode: code
+        });
+      });
+    });
+  }
+}
+function formatConflictText(blockedCommand, conflict) {
+  const running = conflict.runningCommand;
+  const runningLabel = `/${running.command}${running.args.length ? ` ${running.args.join(" ")}` : ""}`;
+  return `/${blockedCommand} cannot start — ${runningLabel} is already running.
+
+Send /cancel to abort it, or wait for it to finish.`;
+}
+function formatStreamingText(command, output, isComplete) {
+  const status = isComplete ? "[DONE]" : "[RUNNING]";
+  const header = `${status} ${command}`;
+  if (!output.trim()) {
+    return isComplete ? `${header}
+
+Completed.` : `${header}
+
+Running...
+
+Send /cancel to abort`;
+  }
+  const lines = output.trim().split(`
+`);
+  const lastLines = lines.slice(-30).join(`
+`);
+  const hint = isComplete ? "" : `
+
+Send /cancel to abort`;
+  return `${header}
+
+${lastLines}${hint}`;
+}
+
+class CommandRouter {
+  prefix;
+  constructor(prefix = "/") {
+    this.prefix = prefix;
+  }
+  parse(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith(this.prefix)) {
+      return { type: "freetext", text: trimmed };
+    }
+    const withoutPrefix = trimmed.slice(this.prefix.length);
+    const parts = withoutPrefix.split(/\s+/);
+    const rawCommand = parts[0] ?? "";
+    const command = rawCommand.replace(/@\S+$/, "").toLowerCase();
+    if (!command) {
+      return { type: "freetext", text: trimmed };
+    }
+    const args = parts.slice(1);
+    return {
+      type: "command",
+      command,
+      args,
+      raw: trimmed
+    };
+  }
+}
 function getExclusivityGroup(command) {
   if (WORKSPACE_EXCLUSIVE.has(command))
     return "workspace";
@@ -9592,7 +9848,7 @@ function getExclusivityGroup(command) {
 
 class CommandTracker {
   active = new Map;
-  track(chatId, command, args, childProcess = null) {
+  track(sessionId, command, args, childProcess = null) {
     const id = String(nextId++);
     const entry = {
       id,
@@ -9601,32 +9857,32 @@ class CommandTracker {
       childProcess,
       startedAt: new Date
     };
-    const list = this.active.get(chatId);
+    const list = this.active.get(sessionId);
     if (list) {
       list.push(entry);
     } else {
-      this.active.set(chatId, [entry]);
+      this.active.set(sessionId, [entry]);
     }
     return id;
   }
-  untrack(chatId, id) {
-    const list = this.active.get(chatId);
+  untrack(sessionId, id) {
+    const list = this.active.get(sessionId);
     if (!list)
       return;
     const idx = list.findIndex((c) => c.id === id);
     if (idx !== -1)
       list.splice(idx, 1);
     if (list.length === 0)
-      this.active.delete(chatId);
+      this.active.delete(sessionId);
   }
-  getActive(chatId) {
-    return this.active.get(chatId) ?? [];
+  getActive(sessionId) {
+    return this.active.get(sessionId) ?? [];
   }
-  checkExclusiveConflict(chatId, command) {
+  checkExclusiveConflict(sessionId, command) {
     const group = getExclusivityGroup(command);
     if (!group)
       return null;
-    const list = this.active.get(chatId);
+    const list = this.active.get(sessionId);
     if (!list)
       return null;
     for (const entry of list) {
@@ -9636,8 +9892,8 @@ class CommandTracker {
     }
     return null;
   }
-  kill(chatId, id) {
-    const list = this.active.get(chatId);
+  kill(sessionId, id) {
+    const list = this.active.get(sessionId);
     if (!list)
       return false;
     const entry = list.find((c) => c.id === id);
@@ -9646,11 +9902,11 @@ class CommandTracker {
     if (entry.childProcess && !entry.childProcess.killed) {
       entry.childProcess.kill("SIGTERM");
     }
-    this.untrack(chatId, id);
+    this.untrack(sessionId, id);
     return true;
   }
-  killAll(chatId) {
-    const list = this.active.get(chatId);
+  killAll(sessionId) {
+    const list = this.active.get(sessionId);
     if (!list)
       return 0;
     let killed = 0;
@@ -9660,25 +9916,191 @@ class CommandTracker {
       }
       killed++;
     }
-    this.active.delete(chatId);
+    this.active.delete(sessionId);
     return killed;
   }
 }
-var WORKSPACE_EXCLUSIVE, GIT_EXCLUSIVE, nextId = 1, commandTracker;
+
+class Gateway {
+  adapters = new Map;
+  router;
+  executor;
+  tracker;
+  onEvent;
+  constructor(options = {}) {
+    this.router = new CommandRouter;
+    this.tracker = new CommandTracker;
+    this.executor = new CommandExecutor(this.tracker);
+    this.onEvent = options.onEvent;
+  }
+  register(adapter) {
+    if (this.adapters.has(adapter.platform)) {
+      throw new Error(`Adapter already registered for platform: ${adapter.platform}`);
+    }
+    this.adapters.set(adapter.platform, adapter);
+    logger.info(`Registered adapter: ${adapter.platform}`);
+  }
+  getAdapter(platform) {
+    return this.adapters.get(platform);
+  }
+  getRouter() {
+    return this.router;
+  }
+  getExecutor() {
+    return this.executor;
+  }
+  getTracker() {
+    return this.tracker;
+  }
+  async handleMessage(message) {
+    this.emit({ type: "message_received", message });
+    const adapter = this.adapters.get(message.platform);
+    if (!adapter) {
+      logger.warn(`No adapter registered for platform: ${message.platform}`);
+      return;
+    }
+    const parsed = this.router.parse(message.text);
+    if (parsed.type === "freetext") {
+      await this.executeCommand(adapter, message.sessionId, "exec", [parsed.text], message);
+      return;
+    }
+    await this.executeCommand(adapter, message.sessionId, parsed.command, parsed.args, message);
+  }
+  async start() {
+    const platforms = Array.from(this.adapters.keys());
+    logger.info(`Starting gateway with adapters: ${platforms.join(", ")}`);
+    for (const [platform, adapter] of this.adapters) {
+      try {
+        await adapter.start();
+        logger.info(`Started adapter: ${platform}`);
+      } catch (error) {
+        logger.error(`Failed to start adapter: ${platform}`, {
+          error: String(error)
+        });
+        throw error;
+      }
+    }
+  }
+  async stop() {
+    for (const [platform, adapter] of this.adapters) {
+      try {
+        await adapter.stop();
+        logger.info(`Stopped adapter: ${platform}`);
+      } catch (error) {
+        logger.warn(`Error stopping adapter: ${platform}`, {
+          error: String(error)
+        });
+      }
+    }
+  }
+  async executeCommand(adapter, sessionId, command, args, _originalMessage) {
+    this.emit({
+      type: "command_started",
+      sessionId,
+      command,
+      args
+    });
+    let streamCallbacks;
+    if (adapter.capabilities.supportsStreaming && adapter.edit) {
+      const adapterRef = adapter;
+      const sentMessageId = "";
+      streamCallbacks = {
+        async onStart(text) {
+          await adapterRef.send(sessionId, {
+            text,
+            format: "plain"
+          });
+          return sentMessageId;
+        },
+        async onUpdate(messageId, text) {
+          if (adapterRef.edit) {
+            await adapterRef.edit(sessionId, messageId, {
+              text,
+              format: "plain"
+            });
+          }
+        },
+        async onComplete(messageId, text, _exitCode) {
+          if (adapterRef.edit) {
+            await adapterRef.edit(sessionId, messageId, {
+              text,
+              format: "plain"
+            });
+          }
+        }
+      };
+    }
+    const result = await this.executor.executeLocusCommand(sessionId, command, args, streamCallbacks);
+    this.emit({
+      type: "command_completed",
+      sessionId,
+      command,
+      exitCode: result.exitCode
+    });
+    if (!result.streaming) {
+      await adapter.send(sessionId, {
+        text: result.text,
+        format: result.format,
+        actions: result.actions
+      });
+    }
+  }
+  emit(event) {
+    if (this.onEvent) {
+      try {
+        this.onEvent(event);
+      } catch (error) {
+        logger.warn("Event handler error", { error: String(error) });
+      }
+    }
+  }
+}
+var COMMAND_REGISTRY, STREAMING_COMMANDS, colorEnabled2 = () => process.stderr.isTTY === true && process.env.NO_COLOR === undefined, wrap2 = (open, close) => (text) => colorEnabled2() ? `${open}${text}${close}` : text, bold2, dim2, red2, yellow2, cyan2, gray2, exec, STREAM_UPDATE_INTERVAL = 2000, WORKSPACE_EXCLUSIVE, GIT_EXCLUSIVE, nextId = 1, logger;
+var init_dist3 = __esm(() => {
+  COMMAND_REGISTRY = {
+    run: { cliArgs: ["run"], streaming: true },
+    status: { cliArgs: ["status"], streaming: false },
+    issues: { cliArgs: ["issue", "list"], streaming: false },
+    issue: { cliArgs: ["issue", "show"], streaming: false },
+    sprint: { cliArgs: ["sprint"], streaming: false },
+    plan: { cliArgs: ["plan"], streaming: true },
+    review: { cliArgs: ["review"], streaming: true },
+    iterate: { cliArgs: ["iterate"], streaming: true },
+    discuss: {
+      cliArgs: ["discuss"],
+      streaming: true,
+      requiresArgs: `Please provide a discussion topic.
+
+Example: /discuss Should we use Redis or in-memory caching?`
+    },
+    exec: {
+      cliArgs: ["exec"],
+      streaming: true,
+      requiresArgs: `Please provide a prompt.
+
+Example: /exec Add error handling to the API`
+    },
+    logs: { cliArgs: ["logs"], streaming: false },
+    config: { cliArgs: ["config"], streaming: false },
+    artifacts: { cliArgs: ["artifacts"], streaming: false }
+  };
+  STREAMING_COMMANDS = new Set(Object.entries(COMMAND_REGISTRY).filter(([, def]) => def.streaming).map(([name]) => name));
+  bold2 = wrap2("\x1B[1m", "\x1B[22m");
+  dim2 = wrap2("\x1B[2m", "\x1B[22m");
+  red2 = wrap2("\x1B[31m", "\x1B[39m");
+  yellow2 = wrap2("\x1B[33m", "\x1B[39m");
+  cyan2 = wrap2("\x1B[36m", "\x1B[39m");
+  gray2 = wrap2("\x1B[90m", "\x1B[39m");
+  exec = promisify(execCb);
+  WORKSPACE_EXCLUSIVE = new Set(["run", "plan", "iterate", "exec"]);
+  GIT_EXCLUSIVE = new Set(["stage", "commit", "checkout", "stash", "pr"]);
+  logger = createLogger2("gateway");
+});
+
+// src/tracker.ts
+var commandTracker;
 var init_tracker = __esm(() => {
-  WORKSPACE_EXCLUSIVE = new Set([
-    "run",
-    "plan",
-    "iterate",
-    "exec"
-  ]);
-  GIT_EXCLUSIVE = new Set([
-    "stage",
-    "commit",
-    "checkout",
-    "stash",
-    "pr"
-  ]);
+  init_dist3();
   commandTracker = new CommandTracker;
 });
 
@@ -9690,7 +10112,7 @@ function codeBlock(text, language = "") {
   const truncated = truncate(text, MAX_CODE_LENGTH);
   return `<pre><code${language ? ` class="language-${language}"` : ""}>${escapeHtml(truncated)}</code></pre>`;
 }
-function bold2(text) {
+function bold3(text) {
   return `<b>${text}</b>`;
 }
 function italic(text) {
@@ -9705,7 +10127,7 @@ function truncate(text, maxLength = MAX_MESSAGE_LENGTH) {
 }
 function formatCommandResult(command, output, exitCode) {
   const status = exitCode === 0 ? "✅" : "❌";
-  const header = `${status} ${bold2(escapeHtml(command))}`;
+  const header = `${status} ${bold3(escapeHtml(command))}`;
   if (!output.trim()) {
     return exitCode === 0 ? `${header}
 
@@ -9719,7 +10141,7 @@ ${codeBlock(output.trim())}`;
 }
 function formatStreamingMessage(command, output, isComplete) {
   const status = isComplete ? "✅" : "⏳";
-  const header = `${status} ${bold2(escapeHtml(command))}`;
+  const header = `${status} ${bold3(escapeHtml(command))}`;
   if (!output.trim()) {
     return `${header}
 
@@ -9740,12 +10162,12 @@ ${codeBlock(lastLines)}${hint}`;
 }
 function formatConflictMessage(blockedCommand, running) {
   const runningLabel = `/${escapeHtml(running.command)}${running.args.length ? ` ${escapeHtml(running.args.join(" "))}` : ""}`;
-  return `⚠️ ${bold2(escapeHtml(`/${blockedCommand}`))} cannot start — ${bold2(runningLabel)} is already running.
+  return `⚠️ ${bold3(escapeHtml(`/${blockedCommand}`))} cannot start — ${bold3(runningLabel)} is already running.
 
 Send /cancel to abort it, or wait for it to finish.`;
 }
 function formatError(message, detail) {
-  let text = `❌ ${bold2("Error")}
+  let text = `❌ ${bold3("Error")}
 
 ${escapeHtml(message)}`;
   if (detail) {
@@ -9768,7 +10190,8 @@ async function handleCancel(ctx) {
   const chatId = ctx.chat?.id;
   if (!chatId)
     return;
-  const active = commandTracker.getActive(chatId);
+  const sessionId = String(chatId);
+  const active = commandTracker.getActive(sessionId);
   if (active.length === 0) {
     await ctx.reply(`ℹ️ No commands are currently running.`, {
       parse_mode: "HTML"
@@ -9777,8 +10200,8 @@ async function handleCancel(ctx) {
   }
   if (active.length === 1) {
     const cmd = active[0];
-    commandTracker.kill(chatId, cmd.id);
-    await ctx.reply(`\uD83D\uDED1 Cancelled ${bold2(`/${escapeHtml(cmd.command)}`)}${cmd.args.length ? ` ${escapeHtml(cmd.args.join(" "))}` : ""}`, { parse_mode: "HTML" });
+    commandTracker.kill(sessionId, cmd.id);
+    await ctx.reply(`\uD83D\uDED1 Cancelled ${bold3(`/${escapeHtml(cmd.command)}`)}${cmd.args.length ? ` ${escapeHtml(cmd.args.join(" "))}` : ""}`, { parse_mode: "HTML" });
     return;
   }
   const kb = new import_grammy.InlineKeyboard;
@@ -9787,7 +10210,7 @@ async function handleCancel(ctx) {
     kb.text(`\uD83D\uDED1 ${label}`, `${CANCEL_CMD_PREFIX}${cmd.id}`).row();
   }
   kb.text("\uD83D\uDED1 Cancel All", CANCEL_ALL);
-  await ctx.reply(`${bold2("Multiple commands running:")}
+  await ctx.reply(`${bold3("Multiple commands running:")}
 
 ${italic("Select which to cancel:")}`, { parse_mode: "HTML", reply_markup: kb });
 }
@@ -9798,17 +10221,18 @@ async function handleCancelCallback(ctx) {
   const chatId = ctx.chat?.id;
   if (!chatId)
     return;
+  const sessionId = String(chatId);
   if (data === CANCEL_ALL) {
-    const count = commandTracker.killAll(chatId);
+    const count = commandTracker.killAll(sessionId);
     await ctx.answerCallbackQuery({ text: `Cancelled ${count} command(s)` });
-    await ctx.editMessageText(`\uD83D\uDED1 Cancelled ${bold2(`${count} command(s)`)}.`, {
+    await ctx.editMessageText(`\uD83D\uDED1 Cancelled ${bold3(`${count} command(s)`)}.`, {
       parse_mode: "HTML"
     });
     return;
   }
   if (data.startsWith(CANCEL_CMD_PREFIX)) {
     const id = data.slice(CANCEL_CMD_PREFIX.length);
-    const killed = commandTracker.kill(chatId, id);
+    const killed = commandTracker.kill(sessionId, id);
     if (killed) {
       await ctx.answerCallbackQuery({ text: "Command cancelled" });
       await ctx.editMessageText(`\uD83D\uDED1 Command cancelled.`, {
@@ -9877,11 +10301,11 @@ var init_keyboards = __esm(() => {
 // src/ui/messages.ts
 function welcomeMessage() {
   return [
-    `${bold2("\uD83E\uDD16 Locus Telegram Remote Control")}`,
+    `${bold3("\uD83E\uDD16 Locus Telegram Remote Control")}`,
     "",
     "Control your Locus agent directly from Telegram.",
     "",
-    `${bold2("Locus Commands")}`,
+    `${bold3("Locus Commands")}`,
     "/run [issue#...] — Execute issues",
     "/status — Dashboard view",
     "/issues [filters] — List issues",
@@ -9896,7 +10320,7 @@ function welcomeMessage() {
     "/config [path] — View config",
     "/artifacts — View artifacts",
     "",
-    `${bold2("Git Commands")}`,
+    `${bold3("Git Commands")}`,
     "/gitstatus — Git status",
     "/stage [files|.] — Stage files",
     "/commit &lt;message&gt; — Commit changes",
@@ -9906,10 +10330,10 @@ function welcomeMessage() {
     "/diff — Show diff",
     "/pr &lt;title&gt; — Create pull request",
     "",
-    `${bold2("Control")}`,
+    `${bold3("Control")}`,
     "/cancel — Abort running commands",
     "",
-    `${bold2("Service Commands")}`,
+    `${bold3("Service Commands")}`,
     "/service start|stop|restart|status|logs",
     "",
     "/help — Show this message"
@@ -9917,14 +10341,14 @@ function welcomeMessage() {
 `);
 }
 function runStartedMessage(target) {
-  return `\uD83D\uDE80 ${bold2("Run Started")} — ${escapeHtml(target)}`;
+  return `\uD83D\uDE80 ${bold3("Run Started")} — ${escapeHtml(target)}`;
 }
 function reviewStartedMessage(prNumber) {
-  return `\uD83D\uDD0D ${bold2("Reviewing")} PR #${prNumber}...`;
+  return `\uD83D\uDD0D ${bold3("Reviewing")} PR #${prNumber}...`;
 }
 function gitCommitMessage(message, hash) {
   return [
-    `✅ ${bold2("Committed")}`,
+    `✅ ${bold3("Committed")}`,
     "",
     `Message: ${escapeHtml(message)}`,
     `Hash: ${escapeHtml(hash)}`
@@ -9932,17 +10356,17 @@ function gitCommitMessage(message, hash) {
 `);
 }
 function gitBranchCreatedMessage(name) {
-  return `✅ Branch ${bold2(escapeHtml(name))} created.`;
+  return `✅ Branch ${bold3(escapeHtml(name))} created.`;
 }
 function gitCheckoutMessage(branch) {
-  return `✅ Switched to branch ${bold2(escapeHtml(branch))}.`;
+  return `✅ Switched to branch ${bold3(escapeHtml(branch))}.`;
 }
 function gitStashMessage(action) {
-  return `✅ ${bold2("Stash")} — ${escapeHtml(action)} completed.`;
+  return `✅ ${bold3("Stash")} — ${escapeHtml(action)} completed.`;
 }
 function prCreatedMessage(prNumber, url) {
   return [
-    `✅ ${bold2("Pull Request Created")}`,
+    `✅ ${bold3("Pull Request Created")}`,
     "",
     `PR #${prNumber}: ${escapeHtml(url)}`
   ].join(`
@@ -9952,9 +10376,9 @@ function serviceStatusMessage(status, pid, uptime, memory, restarts) {
   const uptimeStr = uptime ? formatUptime(uptime) : "N/A";
   const memoryStr = memory ? formatMemory(memory) : "N/A";
   return [
-    `\uD83E\uDD16 ${bold2("Locus Telegram Bot")}`,
+    `\uD83E\uDD16 ${bold3("Locus Telegram Bot")}`,
     "",
-    `Status: ${bold2(status)}`,
+    `Status: ${bold3(status)}`,
     `PID: ${pid ?? "N/A"}`,
     `Uptime: ${uptimeStr}`,
     `Memory: ${memoryStr}`,
@@ -9964,10 +10388,10 @@ function serviceStatusMessage(status, pid, uptime, memory, restarts) {
 }
 function serviceNotRunningMessage() {
   return [
-    `⚠️ ${bold2("Bot Not Running")}`,
+    `⚠️ ${bold3("Bot Not Running")}`,
     "",
     "Start the bot with:",
-    `${bold2("locus pkg telegram start")}`
+    `${bold3("locus pkg telegram start")}`
   ].join(`
 `);
 }
@@ -9992,10 +10416,10 @@ function formatMemory(bytes) {
 var init_messages = () => {};
 
 // src/commands/git.ts
-import { exec as execCb } from "node:child_process";
-import { promisify } from "node:util";
+import { exec as execCb2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
 async function git(args) {
-  const { stdout } = await exec(`git ${args}`, { cwd: process.cwd() });
+  const { stdout } = await exec2(`git ${args}`, { cwd: process.cwd() });
   return stdout;
 }
 async function gitSafe(args) {
@@ -10009,18 +10433,19 @@ async function tracked(ctx, command, args, fn) {
   const chatId = ctx.chat?.id;
   if (!chatId)
     return;
-  const conflict = commandTracker.checkExclusiveConflict(chatId, command);
+  const sessionId = String(chatId);
+  const conflict = commandTracker.checkExclusiveConflict(sessionId, command);
   if (conflict) {
     await ctx.reply(formatConflictMessage(command, conflict.runningCommand), {
       parse_mode: "HTML"
     });
     return;
   }
-  const id = commandTracker.track(chatId, command, args);
+  const id = commandTracker.track(sessionId, command, args);
   try {
     await fn();
   } finally {
-    commandTracker.untrack(chatId, id);
+    commandTracker.untrack(sessionId, id);
   }
 }
 async function handleGitStatus(ctx) {
@@ -10034,11 +10459,13 @@ async function handleGitStatus(ctx) {
         return;
       }
       const branch = (await git("branch --show-current")).trim();
-      await ctx.reply(`${bold2("Branch:")} ${escapeHtml(branch)}
+      await ctx.reply(`${bold3("Branch:")} ${escapeHtml(branch)}
 
 ${codeBlock(status)}`, { parse_mode: "HTML" });
     } catch (error) {
-      await ctx.reply(formatError("Failed to get git status", String(error)), { parse_mode: "HTML" });
+      await ctx.reply(formatError("Failed to get git status", String(error)), {
+        parse_mode: "HTML"
+      });
     }
   });
 }
@@ -10149,7 +10576,7 @@ async function handleBranch(ctx, args) {
       if (args.length === 0) {
         const branches = await git("branch -a --format='%(refname:short)'");
         const current = (await git("branch --show-current")).trim();
-        await ctx.reply(`${bold2("Current:")} ${escapeHtml(current)}
+        await ctx.reply(`${bold3("Current:")} ${escapeHtml(current)}
 
 ${codeBlock(branches)}`, { parse_mode: "HTML" });
       } else {
@@ -10196,14 +10623,16 @@ async function handleDiff(ctx) {
             parse_mode: "HTML"
           });
         } else {
-          await ctx.reply(`${bold2("Staged changes:")}
+          await ctx.reply(`${bold3("Staged changes:")}
 
 ${codeBlock(staged)}`, { parse_mode: "HTML" });
         }
       } else {
-        await ctx.reply(`${bold2("Unstaged changes:")}
+        await ctx.reply(`${bold3("Unstaged changes:")}
 
-${codeBlock(diff)}`, { parse_mode: "HTML" });
+${codeBlock(diff)}`, {
+          parse_mode: "HTML"
+        });
       }
     } catch (error) {
       await ctx.reply(formatError("Diff failed", String(error)), {
@@ -10226,7 +10655,7 @@ async function handlePR(ctx, args) {
       try {
         await git(`push -u origin ${branch}`);
       } catch {}
-      const { stdout: result } = await exec(`gh pr create --title ${JSON.stringify(title)} --body "Created via Locus Telegram Bot" --head ${branch}`, { cwd: process.cwd() });
+      const { stdout: result } = await exec2(`gh pr create --title ${JSON.stringify(title)} --body "Created via Locus Telegram Bot" --head ${branch}`, { cwd: process.cwd() });
       const prMatch = result.match(/\/pull\/(\d+)/);
       const prNumber = prMatch ? Number(prMatch[1]) : 0;
       await ctx.reply(prCreatedMessage(prNumber, result.trim()), {
@@ -10239,37 +10668,37 @@ async function handlePR(ctx, args) {
     }
   });
 }
-var exec;
+var exec2;
 var init_git = __esm(() => {
   init_tracker();
   init_keyboards();
   init_messages();
-  exec = promisify(execCb);
+  exec2 = promisify2(execCb2);
 });
 
 // src/commands/locus.ts
 async function handleLocusCommand(ctx, command, args) {
-  const cliArgs = COMMAND_MAP[command];
-  if (!cliArgs) {
+  const definition = getCommandDefinition(command);
+  if (!definition) {
     await ctx.reply(`Unknown command: /${command}`);
     return;
   }
-  const requiresArgsMsg = REQUIRES_ARGS[command];
-  if (requiresArgsMsg && args.length === 0) {
-    await ctx.reply(requiresArgsMsg);
+  if (definition.requiresArgs && args.length === 0) {
+    await ctx.reply(definition.requiresArgs);
     return;
   }
   const chatId = ctx.chat?.id;
   if (!chatId)
     return;
-  const conflict = commandTracker.checkExclusiveConflict(chatId, command);
+  const sessionId = String(chatId);
+  const conflict = commandTracker.checkExclusiveConflict(sessionId, command);
   if (conflict) {
     await ctx.reply(formatConflictMessage(command, conflict.runningCommand), {
       parse_mode: "HTML"
     });
     return;
   }
-  const fullArgs = [...cliArgs, ...args];
+  const fullArgs = [...definition.cliArgs, ...args];
   const displayCmd = `locus ${fullArgs.join(" ")}`;
   const isStreaming = STREAMING_COMMANDS.has(command);
   if (command === "run" && args.length > 0) {
@@ -10289,8 +10718,9 @@ async function handleStreamingCommand(ctx, displayCmd, fullArgs, command, args)
   const chatId = ctx.chat?.id;
   if (!chatId)
     return;
+  const sessionId = String(chatId);
   const child = invokeLocusStream(fullArgs);
-  const trackingId = commandTracker.track(chatId, command, args, child);
+  const trackingId = commandTracker.track(sessionId, command, args, child);
   let output = "";
   let lastEditTime = 0;
   let editTimer = null;
@@ -10317,7 +10747,7 @@ async function handleStreamingCommand(ctx, displayCmd, fullArgs, command, args)
   });
   await new Promise((resolve) => {
     child.on("close", async (exitCode) => {
-      commandTracker.untrack(chatId, trackingId);
+      commandTracker.untrack(sessionId, trackingId);
       if (editTimer)
         clearTimeout(editTimer);
       try {
@@ -10335,8 +10765,9 @@ async function handleBufferedCommand(ctx, displayCmd, fullArgs, command) {
   const chatId = ctx.chat?.id;
   if (!chatId)
     return;
+  const sessionId = String(chatId);
   const child = invokeLocusStream(fullArgs);
-  const trackingId = commandTracker.track(chatId, command, [], child);
+  const trackingId = commandTracker.track(sessionId, command, [], child);
   let output = "";
   child.stdout?.on("data", (chunk) => {
     output += chunk.toString();
@@ -10346,7 +10777,7 @@ async function handleBufferedCommand(ctx, displayCmd, fullArgs, command) {
   });
   await new Promise((resolve) => {
     child.on("close", async (exitCode) => {
-      commandTracker.untrack(chatId, trackingId);
+      commandTracker.untrack(sessionId, trackingId);
       const result = formatCommandResult(displayCmd, output, exitCode ?? 0);
       const keyboard = getPostCommandKeyboard(command, [], exitCode ?? 0);
       await ctx.reply(result, {
@@ -10379,43 +10810,13 @@ function getPostCommandKeyboard(command, args, exitCode) {
       return null;
   }
 }
-var COMMAND_MAP, STREAMING_COMMANDS, REQUIRES_ARGS, EDIT_INTERVAL = 2000;
+var EDIT_INTERVAL = 2000;
 var init_locus = __esm(() => {
+  init_dist3();
   init_dist();
   init_tracker();
   init_keyboards();
   init_messages();
-  COMMAND_MAP = {
-    run: ["run"],
-    status: ["status"],
-    issues: ["issue", "list"],
-    issue: ["issue", "show"],
-    sprint: ["sprint"],
-    plan: ["plan"],
-    review: ["review"],
-    iterate: ["iterate"],
-    discuss: ["discuss"],
-    exec: ["exec"],
-    logs: ["logs"],
-    config: ["config"],
-    artifacts: ["artifacts"]
-  };
-  STREAMING_COMMANDS = new Set([
-    "run",
-    "plan",
-    "review",
-    "iterate",
-    "discuss",
-    "exec"
-  ]);
-  REQUIRES_ARGS = {
-    exec: `Please provide a prompt.
-
-Example: /exec Add error handling to the API`,
-    discuss: `Please provide a discussion topic.
-
-Example: /discuss Should we use Redis or in-memory caching?`
-  };
 });
 
 // src/commands/service.ts
@@ -10424,27 +10825,27 @@ async function handleService(ctx, args) {
   try {
     switch (subcommand) {
       case "start": {
-        const result = pm2Start();
+        const result = pm2Start2();
         await ctx.reply(formatSuccess(result), { parse_mode: "HTML" });
         break;
       }
       case "stop": {
-        const result = pm2Stop();
+        const result = pm2Stop2();
         await ctx.reply(formatSuccess(result), { parse_mode: "HTML" });
         break;
       }
       case "restart": {
-        const result = pm2Restart();
+        const result = pm2Restart2();
         await ctx.reply(formatSuccess(result), { parse_mode: "HTML" });
         break;
       }
       case "delete": {
-        const result = pm2Delete();
+        const result = pm2Delete2();
         await ctx.reply(formatSuccess(result), { parse_mode: "HTML" });
         break;
       }
       case "status": {
-        const status = pm2Status();
+        const status = pm2Status2();
         if (!status) {
           await ctx.reply(serviceNotRunningMessage(), {
             parse_mode: "HTML"
@@ -10456,7 +10857,7 @@ async function handleService(ctx, args) {
       }
       case "logs": {
         const lines = args[1] ? Number(args[1]) : 50;
-        const logs = pm2Logs(lines);
+        const logs = pm2Logs2(lines);
         await ctx.reply(codeBlock(logs), { parse_mode: "HTML" });
         break;
       }
@@ -10485,7 +10886,7 @@ function createBot(config) {
   bot.use(async (ctx, next) => {
     const chatId = ctx.chat?.id;
     if (!chatId || !config.allowedChatIds.includes(chatId)) {
-      logger.warn("Unauthorized access attempt", {
+      logger2.warn("Unauthorized access attempt", {
         chatId,
         from: ctx.from?.username
       });
@@ -10659,7 +11060,7 @@ function parseArgs(text, command) {
     return [];
   return rest.split(/\s+/);
 }
-var import_grammy3, logger;
+var import_grammy3, logger2;
 var init_bot = __esm(() => {
   init_dist();
   init_cancel();
@@ -10669,7 +11070,7 @@ var init_bot = __esm(() => {
   init_keyboards();
   init_messages();
   import_grammy3 = __toESM(require_mod(), 1);
-  logger = createLogger("telegram");
+  logger2 = createLogger("telegram");
 });
 
 // src/index.ts
@@ -10705,25 +11106,25 @@ async function main(args) {
   }
 }
 function handleStart() {
-  const result = pm2Start();
-  logger2.info(result);
+  const result = pm2Start2();
+  logger3.info(result);
 }
 function handleStop() {
-  const result = pm2Stop();
-  logger2.info(result);
+  const result = pm2Stop2();
+  logger3.info(result);
 }
 function handleRestart() {
-  const result = pm2Restart();
-  logger2.info(result);
+  const result = pm2Restart2();
+  logger3.info(result);
 }
 function handleDelete() {
-  const result = pm2Delete();
-  logger2.info(result);
+  const result = pm2Delete2();
+  logger3.info(result);
 }
 function handleStatus() {
-  const status = pm2Status();
+  const status = pm2Status2();
   if (!status) {
-    logger2.warn("Bot is not running");
+    logger3.warn("Bot is not running");
     return;
   }
   const uptimeStr = status.uptime ? `${Math.floor((Date.now() - status.uptime) / 1000)}s` : "N/A";
@@ -10739,15 +11140,15 @@ function handleStatus() {
 }
 function handleLogs(args) {
   const lines = args[0] ? Number(args[0]) : 50;
-  const logs = pm2Logs(lines);
+  const logs = pm2Logs2(lines);
   console.log(logs);
 }
 async function handleBot() {
   const config = loadTelegramConfig();
   const { createBot: createBot2 } = await Promise.resolve().then(() => (init_bot(), exports_bot));
   const bot = createBot2(config);
-  logger2.info("Starting Telegram bot...");
-  logger2.info(`Allowed chat IDs: ${config.allowedChatIds.join(", ")}`);
+  logger3.info("Starting Telegram bot...");
+  logger3.info(`Allowed chat IDs: ${config.allowedChatIds.join(", ")}`);
   try {
     await bot.api.setMyCommands([
       { command: "run", description: "Execute issues" },
@@ -10775,20 +11176,20 @@ async function handleBot() {
       { command: "service", description: "Manage bot process" },
       { command: "help", description: "Show help message" }
     ]);
-    logger2.info("Telegram command menu synced.");
+    logger3.info("Telegram command menu synced.");
   } catch (err) {
-    logger2.warn("Failed to sync command menu", { error: String(err) });
+    logger3.warn("Failed to sync command menu", { error: String(err) });
   }
   await bot.api.deleteWebhook({ drop_pending_updates: true });
   const runner = import_runner.run(bot);
   const shutdown = () => {
-    logger2.info("Shutting down bot...");
+    logger3.info("Shutting down bot...");
     runner.stop();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  logger2.info("Bot is running. Send /help in Telegram to get started.");
+  logger3.info("Bot is running. Send /help in Telegram to get started.");
 }
 function printHelp() {
   console.log(`
@@ -10820,13 +11221,13 @@ function printHelp() {
     locus pkg telegram bot        # Run in foreground (development)
   `);
 }
-var import_runner, logger2;
+var import_runner, logger3;
 var init_src = __esm(() => {
   init_dist();
   init_config();
   init_pm2();
   import_runner = __toESM(require_mod2(), 1);
-  logger2 = createLogger("telegram");
+  logger3 = createLogger("telegram");
 });
 
 // src/cli.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@locusai/locus-telegram",
-  "version": "0.22.12",
+  "version": "0.22.14",
   "description": "Remote-control Locus via Telegram with full CLI mapping, git operations, and PM2 management",
   "type": "module",
   "bin": {
@@ -27,9 +27,10 @@
   },
   "dependencies": {
     "@grammyjs/runner": "^2.0.3",
-    "@locusai/sdk": "^0.22.12",
-    "grammy": "^1.35.0",
-    "pm2": "^6.0.5"
+    "@locusai/locus-gateway": "^0.22.14",
+    "@locusai/locus-pm2": "^0.22.14",
+    "@locusai/sdk": "^0.22.14",
+    "grammy": "^1.35.0"
   },
   "devDependencies": {
     "typescript": "^5.8.3"