openhome-cli 0.1.0

package/src/commands/chat.ts

@@ -0,0 +1,265 @@
+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";
+import * as readline from "node:readline";
+
+interface WsMessage {
+  type: string;
+  data: unknown;
+}
+
+interface WsTextData {
+  content: string;
+  role: string;
+  live?: boolean;
+  final?: boolean;
+}
+
+const PING_INTERVAL = 30_000;
+
+export async function chatCommand(
+  agentArg?: string,
+  opts: { mock?: boolean } = {},
+): Promise<void> {
+  p.intro("💬 Chat with your agent");
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated. Run: openhome login");
+    process.exit(1);
+  }
+
+  // Resolve agent ID
+  let agentId = agentArg ?? getConfig().default_personality_id;
+
+  if (!agentId) {
+    // Fetch agents and let user pick
+    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. Create one at https://app.openhome.com");
+        process.exit(1);
+      }
+
+      const selected = await p.select({
+        message: "Which agent do you want to chat with?",
+        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);
+    }
+  }
+
+  // Connect WebSocket — wrap in a Promise so the menu waits for chat to end
+  const wsUrl = `${WS_BASE}${ENDPOINTS.voiceStream(apiKey, agentId)}`;
+  info(`Connecting to agent ${chalk.bold(agentId)}...`);
+
+  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 connected = false;
+    let currentResponse = "";
+
+    // Readline for user input
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    function promptUser(): void {
+      rl.question(chalk.green("You: "), (input) => {
+        const trimmed = input.trim();
+
+        if (!trimmed) {
+          promptUser();
+          return;
+        }
+
+        if (trimmed === "/quit" || trimmed === "/exit" || trimmed === "/q") {
+          info("Closing connection...");
+          ws.close(1000);
+          rl.close();
+          return;
+        }
+
+        if (!connected) {
+          error("Not connected yet. Please wait...");
+          promptUser();
+          return;
+        }
+
+        // Send text message to agent (same as useOpenHomeVoice.sendText)
+        ws.send(
+          JSON.stringify({
+            type: "transcribed",
+            data: trimmed,
+          }),
+        );
+
+        // Prompt again immediately for next input
+        promptUser();
+      });
+    }
+
+    // Keepalive ping every 30s (matches browser implementation)
+    let pingInterval: ReturnType<typeof setInterval> | null = null;
+
+    ws.on("open", () => {
+      connected = true;
+
+      // Keepalive ping — matches useOpenHomeVoice pattern
+      pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, PING_INTERVAL);
+
+      success("Connected! Type a message and press Enter. Type /quit to exit.");
+      console.log(
+        chalk.gray(
+          "  Tip: Send trigger words to activate abilities (e.g. 'play aquaprime')",
+        ),
+      );
+      console.log("");
+      promptUser();
+    });
+
+    ws.on("message", (raw: WebSocket.Data) => {
+      try {
+        const msg = JSON.parse(raw.toString()) as WsMessage;
+
+        switch (msg.type) {
+          case "message": {
+            const data = msg.data as WsTextData;
+            if (data.content && data.role === "assistant") {
+              if (data.live && !data.final) {
+                // Streaming — OpenHome sends the full accumulated text each time,
+                // not just the new token. Clear the line and rewrite.
+                const prefix = `${chalk.cyan("Agent:")} `;
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write(`${prefix}${data.content}`);
+                currentResponse = data.content;
+              } else {
+                // Final message
+                if (currentResponse !== "") {
+                  // End of stream — just add newline after the streamed line
+                  console.log("");
+                } else {
+                  // Non-streamed complete message
+                  console.log(`${chalk.cyan("Agent:")} ${data.content}`);
+                }
+                currentResponse = "";
+                console.log("");
+              }
+            }
+            break;
+          }
+          case "text": {
+            // Control messages from server
+            const textData = msg.data as string;
+            if (textData === "audio-init") {
+              // Server starting audio — tell it we're "playing"
+              ws.send(JSON.stringify({ type: "text", data: "bot-speaking" }));
+            } else if (textData === "audio-end") {
+              // Server done with audio — tell it we finished
+              ws.send(JSON.stringify({ type: "text", data: "bot-speak-end" }));
+              // If no text was streamed, show a note
+              if (currentResponse === "") {
+                console.log(
+                  chalk.gray("  (Agent sent audio — text-only mode)"),
+                );
+                console.log("");
+              }
+            }
+            break;
+          }
+          case "audio":
+            // Acknowledge audio receipt (protocol requirement)
+            ws.send(JSON.stringify({ type: "ack", data: "audio-received" }));
+            break;
+          case "error-event": {
+            const errData = msg.data as {
+              message?: string;
+              title?: string;
+              close_connection?: boolean;
+            };
+            const errMsg =
+              errData?.message || errData?.title || "Unknown error";
+            error(`Server error: ${errMsg}`);
+            break;
+          }
+          case "interrupt":
+            // Agent was interrupted
+            if (currentResponse !== "") {
+              console.log(""); // newline
+              currentResponse = "";
+            }
+            break;
+          case "action":
+          case "log":
+          case "question":
+          case "progress":
+            // Informational — ignore in CLI
+            break;
+          default:
+            break;
+        }
+      } catch {
+        // Not JSON — ignore
+      }
+    });
+
+    ws.on("error", (err: Error) => {
+      console.error("");
+      error(`WebSocket error: ${err.message}`);
+      rl.close();
+      resolve();
+    });
+
+    ws.on("close", (code: number) => {
+      if (pingInterval) clearInterval(pingInterval);
+      console.log("");
+      if (code === 1000) {
+        info("Disconnected.");
+      } else {
+        info(`Connection closed (code: ${code})`);
+      }
+      rl.close();
+      resolve();
+    });
+
+    // Handle Ctrl+C
+    rl.on("close", () => {
+      if (connected) {
+        ws.close(1000);
+      }
+    });
+  });
+}

package/src/commands/config-edit.ts

@@ -0,0 +1,163 @@
+import { join, resolve } from "node:path";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { getTrackedAbilities } from "../config/store.js";
+import { error, success, info, p, handleCancel } from "../ui/format.js";
+import chalk from "chalk";
+
+interface AbilityConfig {
+  unique_name: string;
+  description: string;
+  category: string;
+  matching_hotwords: string[];
+  [key: string]: unknown;
+}
+
+/** Resolve an ability directory from tracked abilities or cwd. */
+async function resolveDir(): Promise<string | undefined> {
+  const cwd = resolve(".");
+  if (existsSync(join(cwd, "config.json"))) {
+    info("Detected ability in current directory");
+    return cwd;
+  }
+
+  const tracked = getTrackedAbilities();
+  const home = homedir();
+  const options = tracked.map((a) => ({
+    value: a.path,
+    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 edit?",
+      options,
+    });
+    handleCancel(selected);
+    return selected as string;
+  }
+
+  return undefined;
+}
+
+export async function configEditCommand(pathArg?: string): Promise<void> {
+  p.intro("⚙️  Edit ability config");
+
+  const dir = pathArg ? resolve(pathArg) : await resolveDir();
+  if (!dir) {
+    error(
+      "No ability found. Run from an ability directory or create one with: openhome init",
+    );
+    process.exit(1);
+  }
+
+  const configPath = join(dir, "config.json");
+  if (!existsSync(configPath)) {
+    error(`No config.json found in ${dir}`);
+    process.exit(1);
+  }
+
+  let config: AbilityConfig;
+  try {
+    config = JSON.parse(readFileSync(configPath, "utf8")) as AbilityConfig;
+  } catch {
+    error("Failed to parse config.json");
+    process.exit(1);
+  }
+
+  // Show current config
+  p.note(
+    [
+      `Name:        ${config.unique_name}`,
+      `Description: ${config.description}`,
+      `Category:    ${config.category}`,
+      `Triggers:    ${config.matching_hotwords.join(", ")}`,
+    ].join("\n"),
+    "Current config",
+  );
+
+  // What to edit?
+  const field = await p.select({
+    message: "What do you want to change?",
+    options: [
+      { value: "description", label: "Description" },
+      { value: "hotwords", label: "Trigger words" },
+      { value: "category", label: "Category" },
+      { value: "name", label: "Unique name" },
+    ],
+  });
+  handleCancel(field);
+
+  switch (field) {
+    case "description": {
+      const input = await p.text({
+        message: "New description",
+        initialValue: config.description,
+        validate: (val) => {
+          if (!val || !val.trim()) return "Description is required";
+        },
+      });
+      handleCancel(input);
+      config.description = (input as string).trim();
+      break;
+    }
+    case "hotwords": {
+      const input = await p.text({
+        message: "Trigger words (comma-separated)",
+        initialValue: config.matching_hotwords.join(", "),
+        validate: (val) => {
+          if (!val || !val.trim())
+            return "At least one trigger word is required";
+        },
+      });
+      handleCancel(input);
+      config.matching_hotwords = (input as string)
+        .split(",")
+        .map((h) => h.trim())
+        .filter(Boolean);
+      break;
+    }
+    case "category": {
+      const selected = await p.select({
+        message: "New category",
+        options: [
+          { value: "skill", label: "Skill", hint: "User-triggered" },
+          { value: "brain", label: "Brain Skill", hint: "Auto-triggered" },
+          {
+            value: "daemon",
+            label: "Background Daemon",
+            hint: "Runs continuously",
+          },
+        ],
+      });
+      handleCancel(selected);
+      config.category = selected as string;
+      break;
+    }
+    case "name": {
+      const input = await p.text({
+        message: "New unique name",
+        initialValue: config.unique_name,
+        validate: (val) => {
+          if (!val || !val.trim()) return "Name is required";
+          if (!/^[a-z][a-z0-9-]*$/.test(val.trim()))
+            return "Use lowercase letters, numbers, and hyphens only.";
+        },
+      });
+      handleCancel(input);
+      config.unique_name = (input as string).trim();
+      break;
+    }
+  }
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+  success(`Updated ${field as string} in config.json`);
+
+  p.outro("Done.");
+}

package/src/commands/delete.ts

@@ -0,0 +1,107 @@
+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 deleteCommand(
+  abilityArg?: string,
+  opts: { mock?: boolean } = {},
+): Promise<void> {
+  p.intro("🗑️  Delete 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 to let user pick
+  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 to delete.");
+    return;
+  }
+
+  // Resolve target: arg → match by name, or prompt
+  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 delete?",
+      options: abilities.map((a) => ({
+        value: a.ability_id,
+        label: a.unique_name,
+        hint: `${chalk.gray(a.status)}  v${a.version}`,
+      })),
+    });
+    handleCancel(selected);
+    targetId = selected as string;
+    targetName =
+      abilities.find((a) => a.ability_id === targetId)?.unique_name ?? targetId;
+  }
+
+  // Confirm
+  const confirmed = await p.confirm({
+    message: `Delete "${targetName}"? This cannot be undone.`,
+    initialValue: false,
+  });
+  handleCancel(confirmed);
+
+  if (!confirmed) {
+    p.cancel("Aborted.");
+    return;
+  }
+
+  s.start(`Deleting "${targetName}"...`);
+  try {
+    const result = await client.deleteCapability(targetId);
+    s.stop("Deleted.");
+    success(result.message ?? `"${targetName}" deleted successfully.`);
+    p.outro("Done.");
+  } catch (err) {
+    s.stop("Delete failed.");
+
+    if (err instanceof NotImplementedError) {
+      p.note("API Not Available Yet", "Delete endpoint not yet implemented.");
+      return;
+    }
+
+    error(`Delete failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}