lettokenburn-cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,326 +1,841 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { execFile } from 'node:child_process';
-import { createInterface } from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { agentApi, CliApiError } from './api.js';
-import { loadConfig, resolveRuntimeOptions, saveConfig } from './config.js';
-import { printData } from './output.js';
-import { startRepl } from './repl.js';
-import { resolveContext } from './skills.js';
-import { startMcpServer } from './mcp.js';
-import { startAcpServer } from './acp.js';
-const program = new Command();
-program
-    .name('ltb')
-    .description('LetTokenBurn CLI for agents, tasks, skills, and MCP integration')
-    .option('--base-url <url>', 'API base URL')
-    .option('--api-key <key>', 'LTB agent API key')
-    .option('--json', 'Output JSON');
-const auth = program
-    .command('auth')
-    .description('Manage CLI authentication');
-auth
-    .command('login')
-    .description('Store an API key in ~/.ltb/config.json')
-    .option('--api-key <key>', 'LTB API key to store')
-    .option('--browser', 'Open the browser to the agent console before prompting for the key')
-    .action(async (options, command) => {
-    const runtime = getRuntime(command);
-    const mergedOptions = command.optsWithGlobals();
-    if (options.browser) {
-        const url = `${runtime.baseUrl}/agent`;
-        await openBrowser(url);
-        process.stdout.write(`Opened ${url}\n`);
-        process.stdout.write('Create or copy an API key from the Agent Console, then paste it here.\n');
+
+// src/index.ts
+import { Command } from "commander";
+import { execFile } from "child_process";
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+function getConfigPath() {
+  return process.env.LTB_CONFIG || join(homedir(), ".ltb", "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) return {};
+  try {
+    return JSON.parse(readFileSync(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function resolveRuntimeOptions(input3 = {}) {
+  const config = loadConfig();
+  return {
+    baseUrl: input3.baseUrl || process.env.LTB_BASE_URL || config.baseUrl || "https://api.lettokenburn.com",
+    apiKey: input3.apiKey || process.env.LTB_API_KEY || config.apiKey || "",
+    output: input3.output || process.env.LTB_OUTPUT || config.defaultOutput || "text",
+    projectDir: resolve(input3.projectDir || process.env.LTB_PROJECT_DIR || process.cwd())
+  };
+}
+function requireApiKey(baseUrl, apiKey) {
+  if (!apiKey) {
+    throw new Error(`Missing API key. Run "ltb auth login --api-key <ltb-...>" or set LTB_API_KEY for ${baseUrl}.`);
+  }
+}
+
+// src/api.ts
+var CliApiError = class extends Error {
+  constructor(status, body) {
+    super(`API request failed with status ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "CliApiError";
+  }
+  status;
+  body;
+};
+async function apiRequest(method, baseUrl, path, apiKey, body) {
+  requireApiKey(baseUrl, apiKey);
+  const response = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = text;
+  }
+  if (!response.ok) {
+    throw new CliApiError(response.status, payload);
+  }
+  return payload;
+}
+var agentApi = {
+  whoami(baseUrl, apiKey) {
+    return apiRequest("GET", baseUrl, "/v1/agent/me", apiKey);
+  },
+  health(baseUrl, apiKey) {
+    return apiRequest("GET", baseUrl, "/v1/agent/health", apiKey);
+  },
+  listTasks(baseUrl, apiKey, input3) {
+    const params = new URLSearchParams();
+    if (input3.module) params.set("module", input3.module);
+    if (input3.status) params.set("status", input3.status);
+    if (input3.page) params.set("page", String(input3.page));
+    if (input3.limit) params.set("limit", String(input3.limit));
+    const query = params.toString();
+    return apiRequest("GET", baseUrl, `/v1/agent/tasks${query ? `?${query}` : ""}`, apiKey);
+  },
+  claimTask(baseUrl, apiKey, taskId) {
+    return apiRequest("POST", baseUrl, `/v1/agent/tasks/${taskId}/claim`, apiKey);
+  },
+  claimStatus(baseUrl, apiKey, claimId) {
+    return apiRequest("GET", baseUrl, `/v1/agent/claims/${claimId}/status`, apiKey);
+  },
+  submitClaim(baseUrl, apiKey, claimId, input3) {
+    return apiRequest("POST", baseUrl, `/v1/agent/claims/${claimId}/submit`, apiKey, input3);
+  },
+  listEvents(baseUrl, apiKey, input3) {
+    const params = new URLSearchParams();
+    if (input3.status && input3.status !== "all") params.set("status", input3.status);
+    if (input3.limit) params.set("limit", String(input3.limit));
+    if (input3.cursor) params.set("cursor", input3.cursor);
+    const query = params.toString();
+    return apiRequest(
+      "GET",
+      baseUrl,
+      `/v1/agent/events${query ? `?${query}` : ""}`,
+      apiKey
+    );
+  },
+  listWebhooks(baseUrl, apiKey) {
+    return apiRequest("GET", baseUrl, "/v1/agent/webhooks", apiKey);
+  },
+  createWebhook(baseUrl, apiKey, input3) {
+    return apiRequest("POST", baseUrl, "/v1/agent/webhooks", apiKey, input3);
+  },
+  pauseWebhook(baseUrl, apiKey, webhookId) {
+    return apiRequest("POST", baseUrl, `/v1/agent/webhooks/${webhookId}/pause`, apiKey);
+  },
+  resumeWebhook(baseUrl, apiKey, webhookId) {
+    return apiRequest("POST", baseUrl, `/v1/agent/webhooks/${webhookId}/resume`, apiKey);
+  },
+  deleteWebhook(baseUrl, apiKey, webhookId) {
+    return apiRequest("DELETE", baseUrl, `/v1/agent/webhooks/${webhookId}`, apiKey);
+  },
+  retryEvent(baseUrl, apiKey, deliveryId) {
+    return apiRequest("POST", baseUrl, `/v1/agent/events/${deliveryId}/retry`, apiKey);
+  }
+};
+
+// src/output.ts
+function printData(data, json) {
+  if (json) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+    return;
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      process.stdout.write("No results.\n");
+      return;
+    }
+    const rows = data.map((item) => normalizeRow(item));
+    const headers = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
+    const widths = headers.map((header) => Math.max(header.length, ...rows.map((row) => String(row[header] ?? "").length)));
+    process.stdout.write(
+      headers.map((header, index) => header.padEnd(widths[index])).join("  ") + "\n"
+    );
+    process.stdout.write(
+      headers.map((_, index) => "-".repeat(widths[index])).join("  ") + "\n"
+    );
+    rows.forEach((row) => {
+      process.stdout.write(
+        headers.map((header, index) => String(row[header] ?? "").padEnd(widths[index])).join("  ") + "\n"
+      );
+    });
+    return;
+  }
+  process.stdout.write(formatObject(data) + "\n");
+}
+function formatObject(data) {
+  if (data == null) return "null";
+  if (typeof data === "string") return data;
+  return JSON.stringify(data, null, 2);
+}
+function normalizeRow(value) {
+  if (!value || typeof value !== "object") return { value: String(value) };
+  const record = value;
+  const next = {};
+  for (const [key, field] of Object.entries(record)) {
+    if (field == null) {
+      next[key] = "";
+    } else if (typeof field === "object") {
+      next[key] = JSON.stringify(field);
+    } else {
+      next[key] = String(field);
+    }
+  }
+  return next;
+}
+
+// src/repl.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/skills.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+function listSkills(projectDir) {
+  const projectSkills = join2(projectDir, ".ltb", "skills");
+  const globalSkills = join2(homedir2(), ".ltb", "skills");
+  return [
+    ...readSkillDir(projectSkills, "project"),
+    ...readSkillDir(globalSkills, "global")
+  ];
+}
+function readContextFiles(projectDir) {
+  const files = ["LTB.md", "AGENTS.md"].map((name) => ({ name, path: resolve2(projectDir, name) })).filter((entry) => existsSync2(entry.path)).map((entry) => ({
+    ...entry,
+    content: readFileSync2(entry.path, "utf8")
+  }));
+  return files;
+}
+function resolveContext(projectDir) {
+  return {
+    projectDir,
+    files: readContextFiles(projectDir),
+    skills: listSkills(projectDir)
+  };
+}
+function readSkillDir(baseDir, scope) {
+  if (!existsSync2(baseDir)) return [];
+  return readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => ({
+    scope,
+    name: entry.name,
+    path: join2(baseDir, entry.name, "SKILL.md")
+  })).filter((entry) => existsSync2(entry.path));
+}
+
+// src/repl.ts
+async function startRepl(runtime) {
+  const rl = createInterface({ input, output });
+  process.stdout.write("LTB REPL. Commands: help, whoami, tasks, claim <id>, status <id>, events, skills, context, exit\n");
+  while (true) {
+    const line = (await rl.question("ltb> ")).trim();
+    if (!line) continue;
+    if (line === "exit" || line === "quit") break;
+    if (line === "help") {
+      process.stdout.write("whoami | tasks [module] [status] | claim <taskId> | status <claimId> | events | skills | context | exit\n");
+      continue;
+    }
+    const [command, arg1, arg2] = line.split(/\s+/);
+    try {
+      switch (command) {
+        case "whoami":
+          printData((await agentApi.whoami(runtime.baseUrl, runtime.apiKey)).data, false);
+          break;
+        case "tasks":
+          printData((await agentApi.listTasks(runtime.baseUrl, runtime.apiKey, {
+            module: arg1,
+            status: arg2,
+            limit: 10
+          })).data, false);
+          break;
+        case "claim":
+          if (!arg1) throw new Error("Usage: claim <taskId>");
+          printData((await agentApi.claimTask(runtime.baseUrl, runtime.apiKey, arg1)).data, false);
+          break;
+        case "status":
+          if (!arg1) throw new Error("Usage: status <claimId>");
+          printData((await agentApi.claimStatus(runtime.baseUrl, runtime.apiKey, arg1)).data, false);
+          break;
+        case "events":
+          printData((await agentApi.listEvents(runtime.baseUrl, runtime.apiKey, { limit: 10 })).data, false);
+          break;
+        case "skills":
+          printData(resolveContext(runtime.projectDir).skills, false);
+          break;
+        case "context":
+          printData(resolveContext(runtime.projectDir), false);
+          break;
+        default:
+          process.stdout.write(`Unknown command: ${command}
+`);
+      }
+    } catch (error) {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
     }
-    const apiKey = options.apiKey || mergedOptions.apiKey || await prompt('LTB API key: ');
-    const current = loadConfig();
-    saveConfig({ ...current, baseUrl: runtime.baseUrl, apiKey });
-    process.stdout.write(`Saved API key to config.\n`);
+  }
+  rl.close();
+}
+
+// src/mcp.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+async function startMcpServer(runtime) {
+  const server = new Server(
+    { name: "ltb-cli", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "ltb_task_list",
+        description: "List LetTokenBurn tasks from the agent API",
+        inputSchema: {
+          type: "object",
+          properties: {
+            module: { type: "string" },
+            status: { type: "string" },
+            page: { type: "number" },
+            limit: { type: "number" }
+          }
+        }
+      },
+      {
+        name: "ltb_task_claim",
+        description: "Claim a LetTokenBurn task by id",
+        inputSchema: {
+          type: "object",
+          required: ["taskId"],
+          properties: {
+            taskId: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "ltb_claim_status",
+        description: "Fetch structured claim status",
+        inputSchema: {
+          type: "object",
+          required: ["claimId"],
+          properties: {
+            claimId: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "ltb_claim_submit",
+        description: "Submit a claim result",
+        inputSchema: {
+          type: "object",
+          required: ["claimId", "resultType", "content"],
+          properties: {
+            claimId: { type: "string" },
+            resultType: { type: "string" },
+            content: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "ltb_events_list",
+        description: "List webhook delivery events for the agent key",
+        inputSchema: {
+          type: "object",
+          properties: {
+            status: { type: "string" },
+            limit: { type: "number" },
+            cursor: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "ltb_skills_list",
+        description: "List project and global skills visible to the LTB CLI",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "ltb_context_show",
+        description: "Show project context files and discovered skills",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const args = request.params.arguments ?? {};
+    switch (request.params.name) {
+      case "ltb_task_list":
+        return asToolResult(await agentApi.listTasks(runtime.baseUrl, runtime.apiKey, {
+          module: stringArg(args.module),
+          status: stringArg(args.status),
+          page: numberArg(args.page),
+          limit: numberArg(args.limit)
+        }));
+      case "ltb_task_claim":
+        return asToolResult(await agentApi.claimTask(runtime.baseUrl, runtime.apiKey, stringRequired(args.taskId, "taskId")));
+      case "ltb_claim_status":
+        return asToolResult(await agentApi.claimStatus(runtime.baseUrl, runtime.apiKey, stringRequired(args.claimId, "claimId")));
+      case "ltb_claim_submit":
+        return asToolResult(await agentApi.submitClaim(runtime.baseUrl, runtime.apiKey, stringRequired(args.claimId, "claimId"), {
+          resultType: stringRequired(args.resultType, "resultType"),
+          content: stringRequired(args.content, "content")
+        }));
+      case "ltb_events_list":
+        return asToolResult(await agentApi.listEvents(runtime.baseUrl, runtime.apiKey, {
+          status: stringArg(args.status),
+          limit: numberArg(args.limit),
+          cursor: stringArg(args.cursor)
+        }));
+      case "ltb_skills_list":
+        return asToolResult(resolveContext(runtime.projectDir).skills);
+      case "ltb_context_show":
+        return asToolResult(resolveContext(runtime.projectDir));
+      default:
+        throw new Error(`Unknown MCP tool: ${request.params.name}`);
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+function asToolResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+function stringArg(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberArg(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim()) return Number(value);
+  return void 0;
+}
+function stringRequired(value, name) {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  throw new Error(`Missing required argument: ${name}`);
+}
+
+// src/acp.ts
+import * as acp from "@agentclientprotocol/sdk";
+import { Readable, Writable } from "stream";
+import { randomUUID } from "crypto";
+async function startAcpServer(runtime) {
+  const input3 = Writable.toWeb(process.stdout);
+  const output3 = Readable.toWeb(process.stdin);
+  const stream = acp.ndJsonStream(input3, output3);
+  new acp.AgentSideConnection((conn) => new LtbAcpAgent(conn, runtime), stream);
+}
+var LtbAcpAgent = class {
+  constructor(connection, runtime) {
+    this.connection = connection;
+    this.runtime = runtime;
+  }
+  connection;
+  runtime;
+  sessions = /* @__PURE__ */ new Map();
+  async initialize() {
+    return {
+      protocolVersion: acp.PROTOCOL_VERSION,
+      agentInfo: {
+        name: "ltb-cli",
+        version: "0.1.0"
+      },
+      agentCapabilities: {
+        loadSession: false
+      }
+    };
+  }
+  async newSession() {
+    const sessionId = randomUUID();
+    this.sessions.set(sessionId, { mode: "ops", cancelled: false });
+    return {
+      sessionId,
+      modes: {
+        currentModeId: "ops",
+        availableModes: [
+          { id: "ops", name: "Operations", description: "Run LTB task, claim, event, and webhook operations." },
+          { id: "ask", name: "Ask", description: "Explain how to use the LTB CLI and agent workflow." }
+        ]
+      }
+    };
+  }
+  async authenticate() {
+    return {};
+  }
+  async setSessionMode(params) {
+    const session = this.requireSession(params.sessionId);
+    session.mode = params.modeId === "ask" ? "ask" : "ops";
+    return {};
+  }
+  async prompt(params) {
+    const session = this.requireSession(params.sessionId);
+    session.cancelled = false;
+    const text = params.prompt.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+    const userMessageId = params.messageId ?? randomUUID();
+    const result = await this.handlePrompt(params.sessionId, text, session.mode);
+    if (session.cancelled) {
+      return { stopReason: "cancelled", userMessageId };
+    }
+    await this.connection.sessionUpdate({
+      sessionId: params.sessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: {
+          type: "text",
+          text: result
+        },
+        messageId: randomUUID()
+      }
+    });
+    return {
+      stopReason: "end_turn",
+      userMessageId
+    };
+  }
+  async cancel(params) {
+    const session = this.sessions.get(params.sessionId);
+    if (session) {
+      session.cancelled = true;
+    }
+  }
+  async handlePrompt(sessionId, text, mode) {
+    if (!text) {
+      return this.helpText();
+    }
+    if (mode === "ask") {
+      return this.helpText();
+    }
+    const normalized = text.trim();
+    if (normalized === "help" || normalized === "/help") {
+      return this.helpText();
+    }
+    if (normalized === "/skills") {
+      return JSON.stringify(resolveContext(this.runtime.projectDir).skills, null, 2);
+    }
+    if (normalized === "/context") {
+      return JSON.stringify(resolveContext(this.runtime.projectDir), null, 2);
+    }
+    if (normalized.startsWith("/tasks")) {
+      const [, module, status] = normalized.split(/\s+/);
+      await this.sendToolCall(sessionId, "ltb_task_list", { module, status });
+      const result = await agentApi.listTasks(this.runtime.baseUrl, this.runtime.apiKey, { module, status, limit: 20 });
+      return JSON.stringify(result, null, 2);
+    }
+    if (normalized.startsWith("/claim ")) {
+      const [, taskId] = normalized.split(/\s+/);
+      if (!taskId) {
+        return "Usage: /claim <taskId>";
+      }
+      await this.sendToolCall(sessionId, "ltb_task_claim", { taskId });
+      const result = await agentApi.claimTask(this.runtime.baseUrl, this.runtime.apiKey, taskId);
+      return JSON.stringify(result, null, 2);
+    }
+    if (normalized.startsWith("/status ")) {
+      const [, claimId] = normalized.split(/\s+/);
+      if (!claimId) {
+        return "Usage: /status <claimId>";
+      }
+      await this.sendToolCall(sessionId, "ltb_claim_status", { claimId });
+      const result = await agentApi.claimStatus(this.runtime.baseUrl, this.runtime.apiKey, claimId);
+      return JSON.stringify(result, null, 2);
+    }
+    if (normalized.startsWith("/events")) {
+      const [, status] = normalized.split(/\s+/);
+      await this.sendToolCall(sessionId, "ltb_events_list", { status });
+      const result = await agentApi.listEvents(this.runtime.baseUrl, this.runtime.apiKey, { status, limit: 20 });
+      return JSON.stringify(result, null, 2);
+    }
+    if (normalized === "/webhooks") {
+      await this.sendToolCall(sessionId, "ltb_webhook_list", {});
+      const result = await agentApi.listWebhooks(this.runtime.baseUrl, this.runtime.apiKey);
+      return JSON.stringify(result, null, 2);
+    }
+    return this.helpText();
+  }
+  async sendToolCall(sessionId, title, rawInput) {
+    const toolCallId = randomUUID();
+    await this.connection.sessionUpdate({
+      sessionId,
+      update: {
+        sessionUpdate: "tool_call",
+        toolCallId,
+        title,
+        kind: "execute",
+        status: "completed",
+        rawInput,
+        rawOutput: { ok: true }
+      }
+    });
+  }
+  requireSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Unknown ACP session: ${sessionId}`);
+    }
+    return session;
+  }
+  helpText() {
+    return [
+      "LTB ACP agent is command-oriented.",
+      "Supported prompts:",
+      "/tasks [module] [status]",
+      "/claim <taskId>",
+      "/status <claimId>",
+      "/events [status]",
+      "/webhooks",
+      "/skills",
+      "/context",
+      "/help"
+    ].join("\n");
+  }
+};
+
+// src/index.ts
+var program = new Command();
+program.name("ltb").description("LetTokenBurn CLI for agents, tasks, skills, and MCP integration").option("--base-url <url>", "API base URL").option("--api-key <key>", "LTB agent API key").option("--json", "Output JSON");
+var auth = program.command("auth").description("Manage CLI authentication");
+auth.command("login").description("Store an API key in ~/.ltb/config.json").option("--api-key <key>", "LTB API key to store").option("--browser", "Open the browser to the agent console before prompting for the key").action(async (options, command) => {
+  const runtime = getRuntime(command);
+  const mergedOptions = command.optsWithGlobals();
+  if (options.browser) {
+    const url = `${runtime.baseUrl}/agent`;
+    await openBrowser(url);
+    process.stdout.write(`Opened ${url}
+`);
+    process.stdout.write("Create or copy an API key from the Agent Console, then paste it here.\n");
+  }
+  const apiKey = options.apiKey || mergedOptions.apiKey || await prompt("LTB API key: ");
+  const current = loadConfig();
+  saveConfig({ ...current, baseUrl: runtime.baseUrl, apiKey });
+  process.stdout.write(`Saved API key to config.
+`);
 });
-const authWhoami = new Command('whoami')
-    .description('Show current agent identity')
-    .action(async (_opts, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.whoami(runtime.baseUrl, runtime.apiKey);
-    printData(result.data, runtime.output === 'json');
+var authWhoami = new Command("whoami").description("Show current agent identity").action(async (_opts, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.whoami(runtime.baseUrl, runtime.apiKey);
+  printData(result.data, runtime.output === "json");
 });
 auth.addCommand(authWhoami);
-const task = program.command('task').description('Task operations');
-task.command('list')
-    .description('List agent-friendly tasks')
-    .option('--module <module>')
-    .option('--status <status>')
-    .option('--page <page>', 'Page number', parseInt)
-    .option('--limit <limit>', 'Page size', parseInt)
-    .action(async (options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.listTasks(runtime.baseUrl, runtime.apiKey, options);
-    printData(runtime.output === 'json' ? result : result.data, runtime.output === 'json');
+var task = program.command("task").description("Task operations");
+task.command("list").description("List agent-friendly tasks").option("--module <module>").option("--status <status>").option("--page <page>", "Page number", parseInt).option("--limit <limit>", "Page size", parseInt).action(async (options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.listTasks(runtime.baseUrl, runtime.apiKey, options);
+  printData(runtime.output === "json" ? result : result.data, runtime.output === "json");
 });
-task.command('claim')
-    .description('Claim a task')
-    .argument('<taskId>')
-    .action(async (taskId, _options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.claimTask(runtime.baseUrl, runtime.apiKey, taskId);
-    printData(result.data, runtime.output === 'json');
+task.command("claim").description("Claim a task").argument("<taskId>").action(async (taskId, _options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.claimTask(runtime.baseUrl, runtime.apiKey, taskId);
+  printData(result.data, runtime.output === "json");
 });
-const claim = program.command('claim').description('Claim operations');
-claim.command('status')
-    .description('Get structured claim status')
-    .argument('<claimId>')
-    .action(async (claimId, _options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.claimStatus(runtime.baseUrl, runtime.apiKey, claimId);
-    printData(result.data, runtime.output === 'json');
+var claim = program.command("claim").description("Claim operations");
+claim.command("status").description("Get structured claim status").argument("<claimId>").action(async (claimId, _options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.claimStatus(runtime.baseUrl, runtime.apiKey, claimId);
+  printData(result.data, runtime.output === "json");
 });
-claim.command('submit')
-    .description('Submit a claim result')
-    .argument('<claimId>')
-    .requiredOption('--result-type <resultType>')
-    .requiredOption('--content <content>')
-    .action(async (claimId, options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.submitClaim(runtime.baseUrl, runtime.apiKey, claimId, {
-        resultType: options.resultType,
-        content: options.content,
-    });
-    printData(result.data, runtime.output === 'json');
+claim.command("submit").description("Submit a claim result").argument("<claimId>").requiredOption("--result-type <resultType>").requiredOption("--content <content>").action(async (claimId, options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.submitClaim(runtime.baseUrl, runtime.apiKey, claimId, {
+    resultType: options.resultType,
+    content: options.content
+  });
+  printData(result.data, runtime.output === "json");
 });
-const events = program.command('events').description('Webhook delivery and agent event polling');
-events.command('list')
-    .description('List delivery events')
-    .option('--status <status>', 'all|delivered|dead_letter')
-    .option('--limit <limit>', 'Result size', parseInt)
-    .option('--cursor <cursor>')
-    .action(async (options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.listEvents(runtime.baseUrl, runtime.apiKey, options);
-    printData(runtime.output === 'json' ? result : result.data, runtime.output === 'json');
+var events = program.command("events").description("Webhook delivery and agent event polling");
+events.command("list").description("List delivery events").option("--status <status>", "all|delivered|dead_letter").option("--limit <limit>", "Result size", parseInt).option("--cursor <cursor>").action(async (options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.listEvents(runtime.baseUrl, runtime.apiKey, options);
+  printData(runtime.output === "json" ? result : result.data, runtime.output === "json");
 });
-events.command('watch')
-    .description('Poll delivery events continuously')
-    .option('--status <status>', 'all|delivered|dead_letter', 'all')
-    .option('--limit <limit>', 'Result size', parseInt, 10)
-    .option('--interval <seconds>', 'Polling interval', parseInt, 15)
-    .action(async (options, command) => {
-    const runtime = getRuntime(command);
-    const seen = new Set();
-    process.stdout.write(`Watching events every ${options.interval}s\n`);
-    while (true) {
-        const result = await agentApi.listEvents(runtime.baseUrl, runtime.apiKey, {
-            status: options.status,
-            limit: options.limit,
-        });
-        const items = result.data.filter((entry) => !entry.id || !seen.has(entry.id));
-        for (const item of items) {
-            if (item.id)
-                seen.add(item.id);
-        }
-        if (items.length > 0) {
-            printData(runtime.output === 'json' ? { data: items } : items, runtime.output === 'json');
-        }
-        await sleep(options.interval * 1000);
+events.command("watch").description("Poll delivery events continuously").option("--status <status>", "all|delivered|dead_letter", "all").option("--limit <limit>", "Result size", parseInt, 10).option("--interval <seconds>", "Polling interval", parseInt, 15).action(async (options, command) => {
+  const runtime = getRuntime(command);
+  const seen = /* @__PURE__ */ new Set();
+  process.stdout.write(`Watching events every ${options.interval}s
+`);
+  while (true) {
+    const result = await agentApi.listEvents(runtime.baseUrl, runtime.apiKey, {
+      status: options.status,
+      limit: options.limit
+    });
+    const items = result.data.filter((entry) => !entry.id || !seen.has(entry.id));
+    for (const item of items) {
+      if (item.id) seen.add(item.id);
     }
+    if (items.length > 0) {
+      printData(runtime.output === "json" ? { data: items } : items, runtime.output === "json");
+    }
+    await sleep(options.interval * 1e3);
+  }
 });
-events.command('retry')
-    .description('Retry a failed or dead-letter delivery')
-    .argument('<deliveryId>')
-    .action(async (deliveryId, _options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.retryEvent(runtime.baseUrl, runtime.apiKey, deliveryId);
-    printData(result.data, runtime.output === 'json');
+events.command("retry").description("Retry a failed or dead-letter delivery").argument("<deliveryId>").action(async (deliveryId, _options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.retryEvent(runtime.baseUrl, runtime.apiKey, deliveryId);
+  printData(result.data, runtime.output === "json");
 });
-const webhook = program.command('webhook').description('Manage outbound webhook subscriptions');
-webhook.command('list')
-    .description('List webhook subscriptions')
-    .action(async (_options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.listWebhooks(runtime.baseUrl, runtime.apiKey);
-    printData(result.data, runtime.output === 'json');
+var webhook = program.command("webhook").description("Manage outbound webhook subscriptions");
+webhook.command("list").description("List webhook subscriptions").action(async (_options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.listWebhooks(runtime.baseUrl, runtime.apiKey);
+  printData(result.data, runtime.output === "json");
 });
-webhook.command('create')
-    .description('Create a webhook subscription')
-    .requiredOption('--name <name>')
-    .requiredOption('--target-url <url>')
-    .option('--secret <secret>')
-    .option('--bot-agent-id <id>')
-    .option('--events <events>', 'Comma-separated events', 'claim.reviewed,appeal.resolved')
-    .action(async (options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.createWebhook(runtime.baseUrl, runtime.apiKey, {
-        name: options.name,
-        targetUrl: options.targetUrl,
-        secret: options.secret ?? null,
-        botAgentId: options.botAgentId ?? null,
-        eventTypes: String(options.events).split(',').map((v) => v.trim()).filter(Boolean),
-    });
-    printData(result.data, runtime.output === 'json');
+webhook.command("create").description("Create a webhook subscription").requiredOption("--name <name>").requiredOption("--target-url <url>").option("--secret <secret>").option("--bot-agent-id <id>").option("--events <events>", "Comma-separated events", "claim.reviewed,appeal.resolved").action(async (options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.createWebhook(runtime.baseUrl, runtime.apiKey, {
+    name: options.name,
+    targetUrl: options.targetUrl,
+    secret: options.secret ?? null,
+    botAgentId: options.botAgentId ?? null,
+    eventTypes: String(options.events).split(",").map((v) => v.trim()).filter(Boolean)
+  });
+  printData(result.data, runtime.output === "json");
 });
-webhook.command('pause')
-    .description('Pause a webhook subscription')
-    .argument('<webhookId>')
-    .action(async (webhookId, _options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.pauseWebhook(runtime.baseUrl, runtime.apiKey, webhookId);
-    printData(result.data, runtime.output === 'json');
+webhook.command("pause").description("Pause a webhook subscription").argument("<webhookId>").action(async (webhookId, _options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.pauseWebhook(runtime.baseUrl, runtime.apiKey, webhookId);
+  printData(result.data, runtime.output === "json");
 });
-webhook.command('resume')
-    .description('Resume a paused webhook subscription')
-    .argument('<webhookId>')
-    .action(async (webhookId, _options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.resumeWebhook(runtime.baseUrl, runtime.apiKey, webhookId);
-    printData(result.data, runtime.output === 'json');
+webhook.command("resume").description("Resume a paused webhook subscription").argument("<webhookId>").action(async (webhookId, _options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.resumeWebhook(runtime.baseUrl, runtime.apiKey, webhookId);
+  printData(result.data, runtime.output === "json");
 });
-webhook.command('delete')
-    .description('Delete a webhook subscription')
-    .argument('<webhookId>')
-    .action(async (webhookId, _options, command) => {
-    const runtime = getRuntime(command);
-    const result = await agentApi.deleteWebhook(runtime.baseUrl, runtime.apiKey, webhookId);
-    printData(result.data, runtime.output === 'json');
+webhook.command("delete").description("Delete a webhook subscription").argument("<webhookId>").action(async (webhookId, _options, command) => {
+  const runtime = getRuntime(command);
+  const result = await agentApi.deleteWebhook(runtime.baseUrl, runtime.apiKey, webhookId);
+  printData(result.data, runtime.output === "json");
 });
-const skills = program.command('skills').description('Project and global skill discovery');
-skills.command('list')
-    .description('List discovered skills')
-    .action(async (_options, command) => {
-    const runtime = getRuntime(command);
-    printData(resolveContext(runtime.projectDir).skills, runtime.output === 'json');
+var skills = program.command("skills").description("Project and global skill discovery");
+skills.command("list").description("List discovered skills").action(async (_options, command) => {
+  const runtime = getRuntime(command);
+  printData(resolveContext(runtime.projectDir).skills, runtime.output === "json");
 });
-program.command('context')
-    .description('Show resolved LTB project context')
-    .action(async (_options, command) => {
-    const runtime = getRuntime(command);
-    printData(resolveContext(runtime.projectDir), runtime.output === 'json');
+program.command("context").description("Show resolved LTB project context").action(async (_options, command) => {
+  const runtime = getRuntime(command);
+  printData(resolveContext(runtime.projectDir), runtime.output === "json");
 });
-program.command('doctor')
-    .description('Run connectivity and integration health checks for the current API key')
-    .action(async (_options, command) => {
-    const runtime = getRuntime(command);
-    const [manifest, actor, health] = await Promise.all([
-        fetch(`${runtime.baseUrl}/v1/meta/agent-manifest`).then(async (response) => {
-            if (!response.ok)
-                throw new Error(`Manifest request failed with ${response.status}`);
-            return response.json();
-        }),
-        agentApi.whoami(runtime.baseUrl, runtime.apiKey),
-        agentApi.health(runtime.baseUrl, runtime.apiKey),
-    ]);
-    const context = resolveContext(runtime.projectDir);
-    const payload = {
-        baseUrl: runtime.baseUrl,
-        actor: actor.data,
-        manifest: {
-            workflowCount: manifest?.data?.workflows?.length ?? 0,
-            webhookEventCount: manifest?.data?.webhookEvents?.length ?? 0,
-            scopes: manifest?.data?.auth?.scopes ?? [],
-        },
-        context: {
-            hasLtbMd: context.files.some((file) => file.name === 'LTB.md'),
-            skillCount: context.skills.length,
-        },
-        health: health.data,
-    };
-    printData(payload, runtime.output === 'json');
+program.command("doctor").description("Run connectivity and integration health checks for the current API key").action(async (_options, command) => {
+  const runtime = getRuntime(command);
+  const [manifest, actor, health] = await Promise.all([
+    fetch(`${runtime.baseUrl}/v1/meta/agent-manifest`).then(async (response) => {
+      if (!response.ok) throw new Error(`Manifest request failed with ${response.status}`);
+      return response.json();
+    }),
+    agentApi.whoami(runtime.baseUrl, runtime.apiKey),
+    agentApi.health(runtime.baseUrl, runtime.apiKey)
+  ]);
+  const context = resolveContext(runtime.projectDir);
+  const payload = {
+    baseUrl: runtime.baseUrl,
+    actor: actor.data,
+    manifest: {
+      workflowCount: manifest?.data?.workflows?.length ?? 0,
+      webhookEventCount: manifest?.data?.webhookEvents?.length ?? 0,
+      scopes: manifest?.data?.auth?.scopes ?? []
+    },
+    context: {
+      hasLtbMd: context.files.some((file) => file.name === "LTB.md"),
+      skillCount: context.skills.length
+    },
+    health: health.data
+  };
+  printData(payload, runtime.output === "json");
 });
-program.command('repl')
-    .description('Start a minimal interactive shell')
-    .action(async (_options, command) => {
-    const runtime = getRuntime(command);
-    await startRepl(runtime);
+program.command("repl").description("Start a minimal interactive shell").action(async (_options, command) => {
+  const runtime = getRuntime(command);
+  await startRepl(runtime);
 });
-const mcp = program.command('mcp').description('Run LTB as an MCP stdio server');
-mcp.command('serve')
-    .description('Start MCP stdio server')
-    .action(async (_options, command) => {
-    const runtime = getRuntime(command);
-    await startMcpServer(runtime);
+var mcp = program.command("mcp").description("Run LTB as an MCP stdio server");
+mcp.command("serve").description("Start MCP stdio server").action(async (_options, command) => {
+  const runtime = getRuntime(command);
+  await startMcpServer(runtime);
 });
-const acpCommand = program.command('acp').description('Run LTB as an ACP agent server');
-acpCommand.command('serve')
-    .description('Start ACP ndjson server')
-    .action(async (_options, command) => {
-    const runtime = getRuntime(command);
-    await startAcpServer(runtime);
+var acpCommand = program.command("acp").description("Run LTB as an ACP agent server");
+acpCommand.command("serve").description("Start ACP ndjson server").action(async (_options, command) => {
+  const runtime = getRuntime(command);
+  await startAcpServer(runtime);
 });
 program.configureOutput({
-    outputError: (str, write) => write(str),
+  outputError: (str, write) => write(str)
 });
-program.hook('preAction', (_thisCommand, actionCommand) => {
-    const commandPath = getCommandPath(actionCommand);
-    const requiresApiKey = [
-        'ltb auth whoami',
-        'ltb task list',
-        'ltb task claim',
-        'ltb claim status',
-        'ltb claim submit',
-        'ltb events list',
-        'ltb events watch',
-        'ltb events retry',
-        'ltb webhook list',
-        'ltb webhook create',
-        'ltb webhook pause',
-        'ltb webhook resume',
-        'ltb webhook delete',
-        'ltb repl',
-        'ltb mcp serve',
-        'ltb acp serve',
-    ].includes(commandPath);
-    if (requiresApiKey) {
-        const runtime = getRuntime(actionCommand);
-        if (!runtime.apiKey) {
-            throw new Error('Missing API key. Run "ltb auth login --api-key <ltb-...>" first.');
-        }
+program.hook("preAction", (_thisCommand, actionCommand) => {
+  const commandPath = getCommandPath(actionCommand);
+  const requiresApiKey = [
+    "ltb auth whoami",
+    "ltb task list",
+    "ltb task claim",
+    "ltb claim status",
+    "ltb claim submit",
+    "ltb events list",
+    "ltb events watch",
+    "ltb events retry",
+    "ltb webhook list",
+    "ltb webhook create",
+    "ltb webhook pause",
+    "ltb webhook resume",
+    "ltb webhook delete",
+    "ltb repl",
+    "ltb mcp serve",
+    "ltb acp serve"
+  ].includes(commandPath);
+  if (requiresApiKey) {
+    const runtime = getRuntime(actionCommand);
+    if (!runtime.apiKey) {
+      throw new Error('Missing API key. Run "ltb auth login --api-key <ltb-...>" first.');
     }
+  }
 });
 program.parseAsync(process.argv).catch((error) => {
-    if (error instanceof CliApiError) {
-        process.stderr.write(`${JSON.stringify(error.body, null, 2)}\n`);
-    }
-    else {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    }
-    process.exit(1);
+  if (error instanceof CliApiError) {
+    process.stderr.write(`${JSON.stringify(error.body, null, 2)}
+`);
+  } else {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  }
+  process.exit(1);
 });
 function getRuntime(command) {
-    const opts = command.optsWithGlobals();
-    return resolveRuntimeOptions({
-        baseUrl: opts.baseUrl,
-        apiKey: opts.apiKey,
-        output: opts.json ? 'json' : undefined,
-    });
+  const opts = command.optsWithGlobals();
+  return resolveRuntimeOptions({
+    baseUrl: opts.baseUrl,
+    apiKey: opts.apiKey,
+    output: opts.json ? "json" : void 0
+  });
 }
 async function prompt(promptText) {
-    const rl = createInterface({ input, output });
-    const value = await rl.question(promptText);
-    rl.close();
-    return value.trim();
+  const rl = createInterface2({ input: input2, output: output2 });
+  const value = await rl.question(promptText);
+  rl.close();
+  return value.trim();
 }
 function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function getCommandPath(command) {
-    const names = [];
-    let current = command;
-    while (current) {
-        names.unshift(current.name());
-        current = current.parent ?? null;
-    }
-    return names.join(' ');
+  const names = [];
+  let current = command;
+  while (current) {
+    names.unshift(current.name());
+    current = current.parent ?? null;
+  }
+  return names.join(" ");
 }
 async function openBrowser(url) {
-    const platform = process.platform;
-    const command = platform === 'darwin' ? 'open' : 'xdg-open';
-    await new Promise((resolve, reject) => {
-        execFile(command, [url], (error) => {
-            if (error)
-                reject(error);
-            else
-                resolve();
-        });
+  const platform = process.platform;
+  const command = platform === "darwin" ? "open" : "xdg-open";
+  await new Promise((resolve3, reject) => {
+    execFile(command, [url], (error) => {
+      if (error) reject(error);
+      else resolve3();
     });
+  });
 }
-//# sourceMappingURL=index.js.map