talon-agent 1.12.0 → 1.34.0

package/src/cli/config.ts

@@ -0,0 +1,105 @@
+/**
+ * CLI config model + load/save/format helpers, plus the banner.
+ *
+ * This is the on-disk `talon.json` shape as the CLI sees it; the runtime has
+ * its own richer config type in util/config.ts.
+ */
+
+import pc from "picocolors";
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import writeFileAtomic from "write-file-atomic";
+import { dirs } from "../util/paths.js";
+import { CONFIG_FILE } from "./context.js";
+
+export function printBanner(): void {
+  console.log();
+  console.log(`  ${pc.bold(pc.cyan("🦅 Talon"))}`);
+  console.log(`  ${pc.dim("Agentic AI harness")}`);
+  console.log();
+}
+
+export type Config = {
+  frontend: string | string[];
+  /** Active backend (`claude` / `kilo` / `opencode` / `codex` / `openai-agents`). */
+  backend?: "claude" | "kilo" | "opencode" | "codex" | "openai-agents";
+  botToken?: string;
+  claudeBinary?: string;
+  /** Codex-specific OpenAI API key. */
+  codexApiKey?: string;
+  /** OpenAI API key — used by OpenAI Agents and legacy Codex config. */
+  openaiApiKey?: string;
+  /** OpenAI-compatible base URL — OpenRouter, Azure, Ollama, LiteLLM, etc. */
+  openaiBaseUrl?: string;
+  /** OpenAI API surface — "responses" (default) or "chat_completions" (most third parties). */
+  openaiApiMode?: "responses" | "chat_completions";
+  model: string;
+  concurrency: number;
+  pulse: boolean;
+  pulseIntervalMs: number;
+  adminUserId?: number;
+  apiId?: number;
+  apiHash?: string;
+  maxMessageLength: number;
+  plugins?: unknown[];
+  // Teams
+  teamsWebhookUrl?: string;
+  teamsWebhookSecret?: string;
+  teamsWebhookPort?: number;
+  teamsBotDisplayName?: string;
+  // Discord
+  discord?: {
+    botToken: string;
+    applicationId: string;
+    allowedUsers?: string[];
+    allowedGuilds?: string[];
+    allowedChannels?: string[];
+    adminUserIds?: string[];
+    [key: string]: unknown;
+  };
+};
+
+export const DEFAULTS: Config = {
+  frontend: "telegram",
+  model: "default",
+  concurrency: 1,
+  pulse: true,
+  pulseIntervalMs: 300000,
+  maxMessageLength: 4000,
+};
+
+export function loadConfig(): Config {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      return { ...DEFAULTS, ...JSON.parse(readFileSync(CONFIG_FILE, "utf-8")) };
+    }
+  } catch {
+    /* corrupt */
+  }
+  return { ...DEFAULTS };
+}
+
+export function saveConfig(config: Config): void {
+  if (!existsSync(dirs.root)) mkdirSync(dirs.root, { recursive: true });
+  const clean = Object.fromEntries(
+    Object.entries(config).filter(([, v]) => v !== undefined),
+  );
+  writeFileAtomic.sync(CONFIG_FILE, JSON.stringify(clean, null, 2) + "\n");
+}
+
+export function maskToken(token: string | undefined): string {
+  if (!token || token.length < 10) return pc.red("not set");
+  return pc.green(token.slice(0, 8) + "..." + token.slice(-4));
+}
+
+export function isConfigured(config: Config): boolean {
+  const fes = Array.isArray(config.frontend)
+    ? config.frontend
+    : [config.frontend];
+  return fes.every((fe) => {
+    if (fe === "telegram") return !!config.botToken;
+    if (fe === "terminal") return true;
+    if (fe === "teams") return !!config.teamsWebhookUrl;
+    if (fe === "discord") return !!config.discord?.botToken;
+    return false;
+  });
+}

package/src/cli/context.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared CLI context — package root and well-known file paths.
+ *
+ * PKG_ROOT is resolved from this file's own location (src/cli/) two levels up
+ * to the package root, so it's independent of the process cwd — matching the
+ * original `src/cli.ts` derivation (which sat one level up, in src/).
+ */
+
+import { dirname, resolve } from "node:path";
+import { files as pathFiles } from "../util/paths.js";
+
+// Bun-compiled binaries embed the source tree — import.meta.dirname points
+// into the virtual FS (prefix ~BUN / $bunfs) which has no real disk path.
+// Fall back to the directory containing the executable instead.
+const isBunEmbedded =
+  (import.meta.dirname ?? "").includes("~BUN") ||
+  (import.meta.dirname ?? "").includes("$bunfs");
+
+export const PKG_ROOT = isBunEmbedded
+  ? dirname(process.execPath)
+  : resolve(import.meta.dirname ?? process.cwd(), "..", "..");
+export const CONFIG_FILE = pathFiles.config;
+export const LOG_FILE = pathFiles.log;

package/src/cli/daemon.ts

@@ -0,0 +1,95 @@
+/**
+ * Daemon management — renders the outcomes of start/stop/restart.
+ *
+ * Lifecycle logic lives in core/daemon/ (pidfile, discovery, control);
+ * this module only renders the outcomes.
+ */
+
+import pc from "picocolors";
+import {
+  startDaemon,
+  stopDaemon,
+  restartDaemon,
+  type StartOutcome,
+  type StopOutcome,
+} from "../core/daemon/control.js";
+import { PKG_ROOT } from "./context.js";
+
+function renderStartOutcome(result: StartOutcome): void {
+  if (result.ok) {
+    const port = result.port ? `, gateway :${result.port}` : "";
+    console.log(`  ${pc.green("●")} Talon started (PID ${result.pid}${port})`);
+    console.log(`  ${pc.dim("Logs:")} talon logs`);
+    console.log(`  ${pc.dim("Stop:")} talon stop\n`);
+    return;
+  }
+  switch (result.reason) {
+    case "already-running": {
+      const inst = result.instance;
+      const port = inst.port ? `, gateway :${inst.port}` : "";
+      console.log(
+        `  ${pc.yellow("!")} Talon is already running (PID ${inst.pid}${port})`,
+      );
+      if (inst.pidfileStale) {
+        console.log(
+          `  ${pc.dim("The PID file was stale — repaired from the live instance.")}`,
+        );
+      }
+      console.log(
+        `  Use ${pc.cyan("talon restart")} to restart, or ${pc.cyan("talon stop")} to stop.\n`,
+      );
+      return;
+    }
+    case "spawn-failed":
+      console.log(
+        `  ${pc.red("✖")} Failed to start Talon${result.detail ? pc.dim(` — ${result.detail}`) : ""}\n`,
+      );
+      return;
+    case "exited-early":
+      console.log(`  ${pc.red("✖")} Talon ${result.detail} during startup`);
+      console.log(`  Check ${pc.cyan("talon logs")} for details.\n`);
+      return;
+    case "boot-timeout":
+      console.log(
+        `  ${pc.yellow("!")} Talon was spawned but has not reported healthy yet.`,
+      );
+      console.log(
+        `  It may still be starting — check ${pc.cyan("talon status")} and ${pc.cyan("talon logs")}.\n`,
+      );
+      return;
+  }
+}
+
+function renderStopOutcome(result: StopOutcome): void {
+  if (result.stopped) {
+    const how =
+      result.method === "http"
+        ? "graceful"
+        : result.method === "sigterm"
+          ? "SIGTERM"
+          : "SIGKILL";
+    console.log(`  ${pc.red("●")} Talon stopped (PID ${result.pid}, ${how})\n`);
+    return;
+  }
+  if (result.reason === "not-running") {
+    console.log(`  ${pc.dim("●")} Talon is not running\n`);
+    return;
+  }
+  console.log(
+    `  ${pc.red("✖")} Could not stop Talon (PID ${result.pid}) — the process did not exit\n`,
+  );
+}
+
+export async function daemonStart(): Promise<void> {
+  renderStartOutcome(await startDaemon({ pkgRoot: PKG_ROOT }));
+}
+
+export async function daemonStop(): Promise<void> {
+  renderStopOutcome(await stopDaemon());
+}
+
+export async function daemonRestart(): Promise<void> {
+  const { stop, start } = await restartDaemon({ pkgRoot: PKG_ROOT });
+  renderStopOutcome(stop);
+  renderStartOutcome(start);
+}

package/src/cli/doctor.ts

@@ -0,0 +1,53 @@
+/**
+ * `talon doctor` — environment + native-module checks, plus whether the bot
+ * is currently running.
+ */
+
+import pc from "picocolors";
+import { existsSync } from "node:fs";
+import { findRunningInstance } from "../core/daemon/discovery.js";
+import { printBanner, loadConfig } from "./config.js";
+import { CONFIG_FILE } from "./context.js";
+
+const DOCTOR_ICONS: Record<string, string> = {
+  ok: pc.green("✓"),
+  warn: pc.yellow("!"),
+  fail: pc.red("✗"),
+  info: pc.dim("-"),
+};
+
+export async function runDoctor(): Promise<void> {
+  printBanner();
+  console.log(`  ${pc.bold("Environment check")}\n`);
+  const { collectDoctorReport } = await import("../core/doctor.js");
+  const hasConfigFile = existsSync(CONFIG_FILE);
+  const report = await collectDoctorReport({
+    config: hasConfigFile ? loadConfig() : undefined,
+    hasConfigFile,
+  });
+  for (const check of report.checks) {
+    const detail = check.detail ? ` ${pc.dim(`(${check.detail})`)}` : "";
+    console.log(`  ${DOCTOR_ICONS[check.status]} ${check.label}${detail}`);
+  }
+  // Native plane, one line per embedded module with provenance.
+  for (const mod of report.native) {
+    const size = mod.sizeBytes
+      ? ` · ${(mod.sizeBytes / 1024).toFixed(1)} KB`
+      : "";
+    const note = mod.note ? ` ${pc.dim(`(${mod.note})`)}` : "";
+    console.log(
+      `  ${mod.ok ? pc.green("✓") : pc.red("✗")} Native: ${mod.name} ${pc.dim(`${mod.language} → ${mod.target}${size}`)}${note}`,
+    );
+  }
+  const instance = await findRunningInstance();
+  if (instance) {
+    console.log(`  ${pc.green("✓")} Bot is running (PID ${instance.pid})`);
+  } else {
+    console.log(`  ${pc.dim("-")} Bot is not running`);
+  }
+  console.log(
+    report.issues === 0
+      ? `\n  ${pc.green("All checks passed.")}\n`
+      : `\n  ${pc.yellow(`${report.issues} issue(s) found.`)}\n`,
+  );
+}

package/src/cli/index.ts

@@ -0,0 +1,139 @@
+/**
+ * Talon CLI — interactive setup, management, and monitoring.
+ *
+ * The entry point (`src/cli.ts`) handles the must-run-first hidden subcommand
+ * dispatch, then delegates to `runCli()` here. Each user-facing command lives
+ * in its own module:
+ *
+ *   - `config`      — config model + load/save/format + banner
+ *   - `setup`       — guided setup wizard
+ *   - `status`      — health / stats summary
+ *   - `config-view` — print + edit configuration
+ *   - `logs`        — tail the log file
+ *   - `doctor`      — environment + native-module checks
+ *   - `chat`        — terminal chat mode
+ *   - `daemon`      — start/stop/restart outcome rendering
+ *   - `menu`        — interactive main menu (no-subcommand default)
+ */
+
+import pc from "picocolors";
+// Imported (not read from disk) so `--version` works in a standalone
+// `bun build --compile` binary, which has no package.json on disk — bun
+// inlines the JSON at compile time; tsx/node resolve it from the package.
+import pkg from "../../package.json" with { type: "json" };
+import { PKG_ROOT } from "./context.js";
+import { printBanner } from "./config.js";
+import { runSetup } from "./setup.js";
+import { showStatus } from "./status.js";
+import { viewConfig } from "./config-view.js";
+import { tailLogs } from "./logs.js";
+import { runDoctor } from "./doctor.js";
+import { startChat } from "./chat.js";
+import { daemonStart, daemonStop, daemonRestart } from "./daemon.js";
+import { mainMenu } from "./menu.js";
+
+export * from "./context.js";
+export * from "./config.js";
+export { runSetup } from "./setup.js";
+export { showStatus, formatUptime } from "./status.js";
+export { viewConfig } from "./config-view.js";
+export { tailLogs, formatLogLine } from "./logs.js";
+export { runDoctor } from "./doctor.js";
+export { startChat } from "./chat.js";
+export { daemonStart, daemonStop, daemonRestart } from "./daemon.js";
+export { mainMenu } from "./menu.js";
+
+/** Every dispatchable subcommand — the unknown-command suggester's vocabulary. */
+const CLI_COMMANDS = [
+  "setup",
+  "status",
+  "config",
+  "logs",
+  "start",
+  "stop",
+  "restart",
+  "run",
+  "chat",
+  "doctor",
+];
+
+/** Route a `talon <command>` invocation. Called by the entry point. */
+export async function runCli(): Promise<void> {
+  const command = process.argv[2];
+  switch (command) {
+    case "setup":
+      runSetup();
+      break;
+    case "status":
+      showStatus();
+      break;
+    case "config":
+      viewConfig();
+      break;
+    case "logs":
+      tailLogs();
+      break;
+    case "start":
+      printBanner();
+      await daemonStart();
+      break;
+    case "stop":
+      printBanner();
+      await daemonStop();
+      break;
+    case "restart":
+      printBanner();
+      await daemonRestart();
+      break;
+    case "run":
+      process.chdir(PKG_ROOT);
+      import("../index.js");
+      break;
+    case "chat":
+      process.chdir(PKG_ROOT);
+      startChat();
+      break;
+    case "doctor":
+      runDoctor();
+      break;
+    case "--version":
+    case "-v": {
+      console.log(pkg.version);
+      break;
+    }
+    case "--help":
+    case "-h":
+      printBanner();
+      console.log("  Usage: talon [command]\n");
+      console.log("  Commands:");
+      console.log(`    ${pc.cyan("setup")}      Guided setup wizard`);
+      console.log(`    ${pc.cyan("start")}      Start as background daemon`);
+      console.log(`    ${pc.cyan("stop")}       Stop the daemon`);
+      console.log(`    ${pc.cyan("restart")}    Restart the daemon`);
+      console.log(`    ${pc.cyan("run")}        Run in foreground (attached)`);
+      console.log(`    ${pc.cyan("chat")}       Terminal chat mode`);
+      console.log(`    ${pc.cyan("status")}     Show bot health`);
+      console.log(`    ${pc.cyan("config")}     View/edit configuration`);
+      console.log(`    ${pc.cyan("logs")}       Tail log file`);
+      console.log(`    ${pc.cyan("doctor")}     Validate environment`);
+      console.log(`    ${pc.cyan("--version")}  Print the package version`);
+      console.log();
+      console.log(
+        `  Run ${pc.cyan("talon")} with no args for interactive menu.\n`,
+      );
+      break;
+    case undefined:
+      mainMenu();
+      break;
+    default: {
+      // "did you mean ...?" via the C similarity core (native/strsim-c).
+      const { closestMatch } = await import("../native/strsim.js");
+      const suggestion = closestMatch(command, CLI_COMMANDS);
+      const hint = suggestion
+        ? `Did you mean ${pc.cyan(`talon ${suggestion.value}`)}?`
+        : `Run ${pc.cyan("talon --help")} for usage.`;
+      console.error(`  Unknown command: ${command}\n  ${hint}\n`);
+      process.exit(1);
+    }
+  }
+}

package/src/cli/logs.ts

@@ -0,0 +1,60 @@
+/**
+ * `talon logs` — pretty-print the last lines of the JSON log file and then
+ * tail it live.
+ */
+
+import pc from "picocolors";
+import { existsSync, readFileSync, watchFile } from "node:fs";
+import { printBanner } from "./config.js";
+import { LOG_FILE } from "./context.js";
+
+const LEVEL_LABELS: Record<number, string> = {
+  10: pc.dim("TRC"),
+  20: pc.dim("DBG"),
+  30: pc.blue("INF"),
+  40: pc.yellow("WRN"),
+  50: pc.red("ERR"),
+  60: pc.bgRed(pc.white("FTL")),
+};
+
+export function formatLogLine(line: string): string {
+  try {
+    const obj = JSON.parse(line);
+    const level = LEVEL_LABELS[obj.level as number] ?? pc.dim("???");
+    const time = pc.dim(
+      new Date(obj.time as number).toTimeString().slice(0, 8),
+    );
+    const comp = pc.cyan(((obj.component as string) ?? "?").padEnd(10));
+    return `  ${time} ${level} ${comp} ${obj.msg}${obj.err ? pc.red(` (${obj.err})`) : ""}`;
+  } catch {
+    return `  ${line}`;
+  }
+}
+
+export async function tailLogs(): Promise<void> {
+  printBanner();
+  if (!existsSync(LOG_FILE)) {
+    console.log(
+      `  No log file. Start the bot first: ${pc.cyan("talon start")}\n`,
+    );
+    return;
+  }
+  console.log(
+    `  ${pc.dim("Tailing")} ${pc.dim(LOG_FILE)}\n  ${pc.dim("Press Ctrl+C to stop")}\n`,
+  );
+  const content = readFileSync(LOG_FILE, "utf-8");
+  const lines = content.trim().split("\n");
+  for (const line of lines.slice(-30)) console.log(formatLogLine(line));
+  let lastSize = lines.length;
+  watchFile(LOG_FILE, { interval: 500 }, () => {
+    try {
+      const nl = readFileSync(LOG_FILE, "utf-8").trim().split("\n");
+      for (let i = lastSize; i < nl.length; i++)
+        console.log(formatLogLine(nl[i]));
+      lastSize = nl.length;
+    } catch {
+      /* ignore */
+    }
+  });
+  await new Promise(() => {});
+}

package/src/cli/menu.ts

@@ -0,0 +1,104 @@
+/**
+ * Interactive main menu — shown when `talon` runs with no subcommand. Runs
+ * setup on first launch, otherwise offers start/stop/chat/status/config/etc.
+ */
+
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { existsSync } from "node:fs";
+import { findRunningInstance } from "../core/daemon/discovery.js";
+import { printBanner, loadConfig, isConfigured } from "./config.js";
+import { CONFIG_FILE, PKG_ROOT } from "./context.js";
+import { runSetup } from "./setup.js";
+import { showStatus } from "./status.js";
+import { viewConfig } from "./config-view.js";
+import { tailLogs } from "./logs.js";
+import { startChat } from "./chat.js";
+import { daemonStart, daemonStop, daemonRestart } from "./daemon.js";
+
+export async function mainMenu(): Promise<void> {
+  printBanner();
+  if (!existsSync(CONFIG_FILE) || !isConfigured(loadConfig())) {
+    p.intro(pc.inverse(" Welcome to Talon "));
+    p.note(
+      "Talon is an agentic AI harness.\nSupports Telegram and Terminal.\nLet's get you set up.",
+      "First time?",
+    );
+    await runSetup();
+    return;
+  }
+
+  const running = (await findRunningInstance()) !== null;
+  const config = loadConfig();
+  const statusDot = running
+    ? `${pc.green("●")} running`
+    : `${pc.red("●")} stopped`;
+  const fes = Array.isArray(config.frontend)
+    ? config.frontend
+    : [config.frontend];
+  const frontendLabel = fes
+    .map((f) =>
+      f === "telegram"
+        ? "Telegram"
+        : f === "teams"
+          ? "Teams"
+          : f === "discord"
+            ? "Discord"
+            : "Terminal",
+    )
+    .join(" + ");
+
+  const action = await p.select({
+    message: `Talon ${statusDot} ${pc.dim(`(${frontendLabel})`)}`,
+    options: [
+      ...(!running
+        ? [
+            {
+              value: "start" as const,
+              label: `Start ${frontendLabel}`,
+              hint: "background daemon",
+            },
+          ]
+        : []),
+      ...(running
+        ? [
+            { value: "restart" as const, label: "Restart" },
+            { value: "stop" as const, label: "Stop" },
+          ]
+        : []),
+      { value: "chat", label: "Chat in terminal", hint: "talk to Talon here" },
+      { value: "status", label: "Status", hint: "health and stats" },
+      { value: "config", label: "Config", hint: "view or edit" },
+      { value: "logs", label: "Logs", hint: "tail live" },
+      { value: "setup", label: "Setup", hint: "re-run wizard" },
+    ],
+  });
+  if (p.isCancel(action)) process.exit(0);
+  switch (action) {
+    case "start":
+      await daemonStart();
+      break;
+    case "stop":
+      daemonStop();
+      break;
+    case "restart":
+      await daemonRestart();
+      break;
+    case "chat":
+      process.chdir(PKG_ROOT);
+      await startChat();
+      break;
+    case "status":
+      await showStatus();
+      break;
+    case "config":
+      await viewConfig();
+      break;
+    case "logs":
+      await tailLogs();
+      break;
+    case "setup":
+      await runSetup();
+      break;
+  }
+}