openhome-cli 0.1.0

package/src/commands/list.ts

@@ -0,0 +1,78 @@
+import { ApiClient, NotImplementedError } from "../api/client.js";
+import { MockApiClient } from "../api/mock-client.js";
+import { getApiKey, getConfig } from "../config/store.js";
+import { error, warn, info, table, p } from "../ui/format.js";
+import type { TableRow } from "../ui/format.js";
+import chalk from "chalk";
+
+function statusColor(status: string): string {
+  switch (status) {
+    case "active":
+      return chalk.green(status);
+    case "processing":
+      return chalk.yellow(status);
+    case "failed":
+      return chalk.red(status);
+    case "disabled":
+      return chalk.gray(status);
+    default:
+      return status;
+  }
+}
+
+export async function listCommand(
+  opts: { mock?: boolean } = {},
+): Promise<void> {
+  p.intro("📋 Your abilities");
+
+  let client: ApiClient | MockApiClient;
+
+  if (opts.mock) {
+    client = new MockApiClient();
+  } else {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      error("Not authenticated. Run: openhome login");
+      process.exit(1);
+    }
+    client = new ApiClient(apiKey, getConfig().api_base_url);
+  }
+
+  const s = p.spinner();
+  s.start("Fetching abilities...");
+
+  try {
+    const { abilities } = await client.listAbilities();
+    s.stop(`Found ${abilities.length} ability(s).`);
+
+    if (abilities.length === 0) {
+      info("No abilities found. Run: openhome init");
+      p.outro("Deploy your first ability with: openhome deploy");
+      return;
+    }
+
+    const rows: TableRow[] = abilities.map((a) => ({
+      Name: a.unique_name,
+      Display: a.display_name,
+      Version: a.version,
+      Status: statusColor(a.status),
+      Updated: new Date(a.updated_at).toLocaleDateString(),
+    }));
+
+    console.log("");
+    table(rows);
+    p.outro(`${abilities.length} ability(s) total.`);
+  } catch (err) {
+    s.stop("Failed.");
+
+    if (err instanceof NotImplementedError) {
+      p.note("Use --mock to see example output.", "API Not Available Yet");
+      p.outro("List endpoint not yet implemented.");
+      return;
+    }
+    error(
+      `Failed to list abilities: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/login.ts

@@ -0,0 +1,54 @@
+import { ApiClient } from "../api/client.js";
+import type { Personality } from "../api/contracts.js";
+import { saveApiKey } from "../config/store.js";
+import { success, error, info, p, handleCancel } from "../ui/format.js";
+import chalk from "chalk";
+
+export async function loginCommand(): Promise<void> {
+  p.intro("🔑 OpenHome Login");
+
+  const apiKey = await p.password({
+    message: "Enter your OpenHome API key",
+    validate: (val) => {
+      if (!val || !val.trim()) return "API key is required";
+    },
+  });
+  handleCancel(apiKey);
+
+  const s = p.spinner();
+  s.start("Verifying API key...");
+
+  let agents: Personality[];
+  try {
+    const client = new ApiClient(apiKey as string);
+    const verification = await client.verifyApiKey(apiKey as string);
+    if (!verification.valid) {
+      s.stop("Verification failed.");
+      error(verification.message ?? "Invalid API key.");
+      process.exit(1);
+    }
+    agents = await client.getPersonalities();
+    s.stop("API key verified.");
+  } catch (err) {
+    s.stop("Verification failed.");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+
+  saveApiKey(apiKey as string);
+  success("API key saved.");
+
+  // Show agents on this account
+  if (agents.length > 0) {
+    p.note(
+      agents
+        .map((a) => `${chalk.bold(a.name)}  ${chalk.gray(a.id)}`)
+        .join("\n"),
+      `${agents.length} agent(s) on this account`,
+    );
+  } else {
+    info("No agents found. Create one at https://app.openhome.com");
+  }
+
+  p.outro("Logged in! You're ready to go.");
+}

package/src/commands/logout.ts

@@ -0,0 +1,14 @@
+import { getConfig, saveConfig } from "../config/store.js";
+import { keychainDelete } from "../config/keychain.js";
+import { success } from "../ui/format.js";
+
+export async function logoutCommand(): Promise<void> {
+  keychainDelete();
+
+  const config = getConfig();
+  delete config.api_key;
+  delete config.default_personality_id;
+  saveConfig(config);
+
+  success("Logged out. API key and default agent cleared.");
+}

package/src/commands/logs.ts

@@ -0,0 +1,174 @@
+import WebSocket from "ws";
+import { getApiKey, getConfig } from "../config/store.js";
+import { ApiClient } from "../api/client.js";
+import { WS_BASE, ENDPOINTS } from "../api/endpoints.js";
+import { error, success, info, p, handleCancel } from "../ui/format.js";
+import chalk from "chalk";
+
+const PING_INTERVAL = 30_000;
+
+export async function logsCommand(
+  opts: { agent?: string } = {},
+): Promise<void> {
+  p.intro("📡 Stream agent logs");
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated. Run: openhome login");
+    process.exit(1);
+  }
+
+  let agentId = opts.agent ?? getConfig().default_personality_id;
+
+  if (!agentId) {
+    const s = p.spinner();
+    s.start("Fetching agents...");
+    try {
+      const client = new ApiClient(apiKey);
+      const agents = await client.getPersonalities();
+      s.stop(`Found ${agents.length} agent(s).`);
+
+      if (agents.length === 0) {
+        error("No agents found.");
+        process.exit(1);
+      }
+
+      const selected = await p.select({
+        message: "Which agent?",
+        options: agents.map((a) => ({
+          value: a.id,
+          label: a.name,
+          hint: a.id,
+        })),
+      });
+      handleCancel(selected);
+      agentId = selected as string;
+    } catch (err) {
+      s.stop("Failed.");
+      error(
+        `Could not fetch agents: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      process.exit(1);
+    }
+  }
+
+  const wsUrl = `${WS_BASE}${ENDPOINTS.voiceStream(apiKey, agentId)}`;
+  info(`Streaming logs from agent ${chalk.bold(agentId)}...`);
+  info(`Press ${chalk.bold("Ctrl+C")} to stop.\n`);
+
+  await new Promise<void>((resolve) => {
+    const ws = new WebSocket(wsUrl, {
+      perMessageDeflate: false,
+      headers: {
+        Origin: "https://app.openhome.com",
+        "User-Agent":
+          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+      },
+    });
+
+    let pingInterval: ReturnType<typeof setInterval> | null = null;
+
+    ws.on("open", () => {
+      success("Connected. Waiting for messages...\n");
+
+      pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, PING_INTERVAL);
+    });
+
+    ws.on("message", (raw: WebSocket.Data) => {
+      try {
+        const msg = JSON.parse(raw.toString()) as {
+          type: string;
+          data: unknown;
+        };
+        const ts = chalk.gray(new Date().toLocaleTimeString());
+
+        switch (msg.type) {
+          case "log":
+            console.log(
+              `${ts} ${chalk.blue("[LOG]")} ${JSON.stringify(msg.data)}`,
+            );
+            break;
+          case "action":
+            console.log(
+              `${ts} ${chalk.magenta("[ACTION]")} ${JSON.stringify(msg.data)}`,
+            );
+            break;
+          case "progress":
+            console.log(
+              `${ts} ${chalk.yellow("[PROGRESS]")} ${JSON.stringify(msg.data)}`,
+            );
+            break;
+          case "question":
+            console.log(
+              `${ts} ${chalk.cyan("[QUESTION]")} ${JSON.stringify(msg.data)}`,
+            );
+            break;
+          case "message": {
+            const data = msg.data as {
+              content?: string;
+              role?: string;
+              live?: boolean;
+            };
+            if (data.content && !data.live) {
+              const role =
+                data.role === "assistant"
+                  ? chalk.cyan("AGENT")
+                  : chalk.green("USER");
+              console.log(`${ts} ${chalk.white(`[${role}]`)} ${data.content}`);
+            }
+            break;
+          }
+          case "text": {
+            const textData = msg.data as string;
+            if (textData === "audio-init") {
+              ws.send(JSON.stringify({ type: "text", data: "bot-speaking" }));
+            } else if (textData === "audio-end") {
+              ws.send(JSON.stringify({ type: "text", data: "bot-speak-end" }));
+            }
+            break;
+          }
+          case "audio":
+            ws.send(JSON.stringify({ type: "ack", data: "audio-received" }));
+            break;
+          case "error-event": {
+            const errData = msg.data as { message?: string; title?: string };
+            console.log(
+              `${ts} ${chalk.red("[ERROR]")} ${errData?.message || errData?.title || JSON.stringify(msg.data)}`,
+            );
+            break;
+          }
+          default:
+            console.log(
+              `${ts} ${chalk.gray(`[${msg.type}]`)} ${JSON.stringify(msg.data)}`,
+            );
+            break;
+        }
+      } catch {
+        // ignore non-JSON
+      }
+    });
+
+    ws.on("error", (err: Error) => {
+      error(`WebSocket error: ${err.message}`);
+      resolve();
+    });
+
+    ws.on("close", (code: number) => {
+      if (pingInterval) clearInterval(pingInterval);
+      console.log("");
+      info(`Connection closed (code: ${code})`);
+      resolve();
+    });
+
+    // Handle Ctrl+C
+    process.on("SIGINT", () => {
+      console.log("");
+      info("Stopping log stream...");
+      ws.close(1000);
+    });
+  });
+}

package/src/commands/status.ts

@@ -0,0 +1,174 @@
+import { join, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { ApiClient, NotImplementedError } from "../api/client.js";
+import { MockApiClient } from "../api/mock-client.js";
+import { getApiKey, getConfig, getTrackedAbilities } from "../config/store.js";
+import { error, warn, info, p, handleCancel } from "../ui/format.js";
+import chalk from "chalk";
+
+function statusBadge(status: string): string {
+  switch (status) {
+    case "active":
+      return chalk.bgGreen.black(` ${status.toUpperCase()} `);
+    case "processing":
+      return chalk.bgYellow.black(` ${status.toUpperCase()} `);
+    case "failed":
+      return chalk.bgRed.white(` ${status.toUpperCase()} `);
+    case "disabled":
+      return chalk.bgGray.white(` ${status.toUpperCase()} `);
+    default:
+      return chalk.bgWhite.black(` ${status.toUpperCase()} `);
+  }
+}
+
+/** Read unique_name from a config.json in a directory. */
+function readAbilityName(dir: string): string | null {
+  const configPath = join(dir, "config.json");
+  if (!existsSync(configPath)) return null;
+  try {
+    const cfg = JSON.parse(readFileSync(configPath, "utf8")) as {
+      unique_name?: string;
+    };
+    return cfg.unique_name ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Resolve ability name: check cwd, then pick from tracked abilities. */
+async function resolveAbilityName(): Promise<string | undefined> {
+  // Check current directory first
+  const cwdName = readAbilityName(resolve("."));
+  if (cwdName) {
+    info(`Detected ability: ${cwdName}`);
+    return cwdName;
+  }
+
+  // Build list from tracked abilities
+  const tracked = getTrackedAbilities();
+  const options: { value: string; label: string; hint?: string }[] = [];
+  const home = homedir();
+
+  for (const a of tracked) {
+    const name = readAbilityName(a.path);
+    if (name) {
+      options.push({
+        value: name,
+        label: a.name,
+        hint: a.path.startsWith(home)
+          ? `~${a.path.slice(home.length)}`
+          : a.path,
+      });
+    }
+  }
+
+  if (options.length === 1) {
+    info(`Using ability: ${options[0].label}`);
+    return options[0].value;
+  }
+
+  if (options.length > 0) {
+    const selected = await p.select({
+      message: "Which ability do you want to check?",
+      options,
+    });
+    handleCancel(selected);
+    return selected as string;
+  }
+
+  return undefined;
+}
+
+export async function statusCommand(
+  abilityArg?: string,
+  opts: { mock?: boolean } = {},
+): Promise<void> {
+  let abilityId = abilityArg;
+
+  // If no arg, try to resolve from cwd or tracked abilities
+  if (!abilityId) {
+    abilityId = await resolveAbilityName();
+  }
+
+  if (!abilityId) {
+    error(
+      "No ability found. Pass a name, run from an ability directory, or create one with: openhome init",
+    );
+    process.exit(1);
+  }
+
+  p.intro(`🔍 Status: ${abilityId}`);
+
+  let client: ApiClient | MockApiClient;
+
+  if (opts.mock) {
+    client = new MockApiClient();
+  } else {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      error("Not authenticated. Run: openhome login");
+      process.exit(1);
+    }
+    client = new ApiClient(apiKey, getConfig().api_base_url);
+  }
+
+  const s = p.spinner();
+  s.start("Fetching status...");
+
+  try {
+    const ability = await client.getAbility(abilityId);
+    s.stop("Status loaded.");
+
+    // Main info
+    p.note(
+      [
+        `Name:       ${ability.unique_name}`,
+        `Display:    ${ability.display_name}`,
+        `Status:     ${statusBadge(ability.status)}`,
+        `Version:    v${ability.version}`,
+        `Updated:    ${new Date(ability.updated_at).toLocaleString()}`,
+        `Created:    ${new Date(ability.created_at).toLocaleString()}`,
+        ability.personality_ids.length > 0
+          ? `Linked to:  ${ability.personality_ids.join(", ")}`
+          : null,
+      ]
+        .filter(Boolean)
+        .join("\n"),
+      "Ability Details",
+    );
+
+    // Validation errors
+    if (ability.validation_errors.length > 0) {
+      p.note(
+        ability.validation_errors.map((e) => chalk.red(`✗ ${e}`)).join("\n"),
+        "Validation Errors",
+      );
+    }
+
+    // Deploy history
+    if (ability.deploy_history.length > 0) {
+      const historyLines = ability.deploy_history.map((event) => {
+        const icon =
+          event.status === "success" ? chalk.green("✓") : chalk.red("✗");
+        return `${icon}  v${event.version}  ${event.message}  ${chalk.gray(new Date(event.timestamp).toLocaleString())}`;
+      });
+
+      p.note(historyLines.join("\n"), "Deploy History");
+    }
+
+    p.outro("Done.");
+  } catch (err) {
+    s.stop("Failed.");
+
+    if (err instanceof NotImplementedError) {
+      p.note("Use --mock to see example output.", "API Not Available Yet");
+      p.outro("Status endpoint not yet implemented.");
+      return;
+    }
+    error(
+      `Failed to get status: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/toggle.ts

@@ -0,0 +1,118 @@
+import { ApiClient, NotImplementedError } from "../api/client.js";
+import { MockApiClient } from "../api/mock-client.js";
+import { getApiKey, getConfig } from "../config/store.js";
+import { error, success, p, handleCancel } from "../ui/format.js";
+import chalk from "chalk";
+
+export async function toggleCommand(
+  abilityArg?: string,
+  opts: { mock?: boolean; enable?: boolean; disable?: boolean } = {},
+): Promise<void> {
+  p.intro("⚡ Enable / Disable ability");
+
+  let client: ApiClient | MockApiClient;
+
+  if (opts.mock) {
+    client = new MockApiClient();
+  } else {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      error("Not authenticated. Run: openhome login");
+      process.exit(1);
+    }
+    client = new ApiClient(apiKey, getConfig().api_base_url);
+  }
+
+  // Fetch abilities
+  const s = p.spinner();
+  s.start("Fetching abilities...");
+
+  let abilities: Awaited<ReturnType<typeof client.listAbilities>>["abilities"];
+  try {
+    const result = await client.listAbilities();
+    abilities = result.abilities;
+    s.stop(`Found ${abilities.length} ability(s).`);
+  } catch (err) {
+    s.stop("Failed to fetch abilities.");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+
+  if (abilities.length === 0) {
+    p.outro("No abilities found.");
+    return;
+  }
+
+  // Resolve target
+  let targetId: string;
+  let targetName: string;
+
+  if (abilityArg) {
+    const match = abilities.find(
+      (a) =>
+        a.unique_name === abilityArg ||
+        a.display_name === abilityArg ||
+        a.ability_id === abilityArg,
+    );
+    if (!match) {
+      error(`No ability found matching "${abilityArg}".`);
+      process.exit(1);
+    }
+    targetId = match.ability_id;
+    targetName = match.unique_name;
+  } else {
+    const selected = await p.select({
+      message: "Which ability do you want to toggle?",
+      options: abilities.map((a) => ({
+        value: a.ability_id,
+        label: a.unique_name,
+        hint: `${a.status === "disabled" ? chalk.gray("disabled") : chalk.green("enabled")}  v${a.version}`,
+      })),
+    });
+    handleCancel(selected);
+    targetId = selected as string;
+    targetName =
+      abilities.find((a) => a.ability_id === targetId)?.unique_name ?? targetId;
+  }
+
+  // Resolve enable/disable
+  let enabled: boolean;
+
+  if (opts.enable) {
+    enabled = true;
+  } else if (opts.disable) {
+    enabled = false;
+  } else {
+    const current = abilities.find((a) => a.ability_id === targetId);
+    const action = await p.select({
+      message: `"${targetName}" is currently ${current?.status ?? "unknown"}. What do you want to do?`,
+      options: [
+        { value: "enable", label: "Enable" },
+        { value: "disable", label: "Disable" },
+      ],
+    });
+    handleCancel(action);
+    enabled = action === "enable";
+  }
+
+  s.start(`${enabled ? "Enabling" : "Disabling"} "${targetName}"...`);
+  try {
+    const result = await client.toggleCapability(targetId, enabled);
+    s.stop("Done.");
+    success(
+      result.message ??
+        `"${targetName}" ${enabled ? "enabled" : "disabled"} successfully.`,
+    );
+    p.outro("Done.");
+  } catch (err) {
+    s.stop("Failed.");
+
+    if (err instanceof NotImplementedError) {
+      p.note("Toggle endpoint not yet implemented.", "API Not Available Yet");
+      return;
+    }
+
+    error(`Toggle failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}