openhome-cli 0.1.0

package/src/commands/trigger.ts

@@ -0,0 +1,193 @@
+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;
+const RESPONSE_TIMEOUT = 30_000;
+
+export async function triggerCommand(
+  phraseArg?: string,
+  opts: { agent?: string } = {},
+): Promise<void> {
+  p.intro("⚡ Trigger an ability");
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated. Run: openhome login");
+    process.exit(1);
+  }
+
+  // Resolve phrase
+  let phrase = phraseArg;
+  if (!phrase) {
+    const input = await p.text({
+      message: "Trigger phrase (e.g. 'play aquaprime')",
+      validate: (val) => {
+        if (!val || !val.trim()) return "A trigger phrase is required";
+      },
+    });
+    handleCancel(input);
+    phrase = (input as string).trim();
+  }
+
+  // Resolve agent ID
+  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);
+    }
+  }
+
+  // Connect, send trigger, wait for response, disconnect
+  const wsUrl = `${WS_BASE}${ENDPOINTS.voiceStream(apiKey, agentId)}`;
+  info(`Sending "${chalk.bold(phrase)}" to agent ${chalk.bold(agentId)}...`);
+
+  const s = p.spinner();
+  s.start("Waiting for response...");
+
+  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 fullResponse = "";
+    let responseTimer: ReturnType<typeof setTimeout> | null = null;
+    let pingInterval: ReturnType<typeof setInterval> | null = null;
+
+    function cleanup(): void {
+      if (pingInterval) clearInterval(pingInterval);
+      if (responseTimer) clearTimeout(responseTimer);
+      if (ws.readyState === WebSocket.OPEN) ws.close(1000);
+    }
+
+    ws.on("open", () => {
+      // Send trigger phrase immediately
+      ws.send(JSON.stringify({ type: "transcribed", data: phrase }));
+
+      // Keepalive
+      pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, PING_INTERVAL);
+
+      // Timeout if no response
+      responseTimer = setTimeout(() => {
+        s.stop("Timed out waiting for response.");
+        if (fullResponse) {
+          console.log(`\n${chalk.cyan("Agent:")} ${fullResponse}`);
+        }
+        cleanup();
+        resolve();
+      }, RESPONSE_TIMEOUT);
+    });
+
+    ws.on("message", (raw: WebSocket.Data) => {
+      try {
+        const msg = JSON.parse(raw.toString()) as {
+          type: string;
+          data: unknown;
+        };
+
+        switch (msg.type) {
+          case "message": {
+            const data = msg.data as {
+              content?: string;
+              role?: string;
+              live?: boolean;
+              final?: boolean;
+            };
+            if (data.content && data.role === "assistant") {
+              fullResponse += data.content;
+              if (!data.live || data.final) {
+                // Got final response
+                s.stop("Response received.");
+                console.log(`\n${chalk.cyan("Agent:")} ${fullResponse}\n`);
+                cleanup();
+                resolve();
+              }
+            }
+            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" }));
+              if (fullResponse) {
+                s.stop("Response received.");
+                console.log(`\n${chalk.cyan("Agent:")} ${fullResponse}\n`);
+                cleanup();
+                resolve();
+              }
+            }
+            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 };
+            s.stop("Error.");
+            error(
+              `Server error: ${errData?.message || errData?.title || "Unknown"}`,
+            );
+            cleanup();
+            resolve();
+            break;
+          }
+        }
+      } catch {
+        // ignore
+      }
+    });
+
+    ws.on("error", (err: Error) => {
+      s.stop("Connection error.");
+      error(err.message);
+      resolve();
+    });
+
+    ws.on("close", () => {
+      if (pingInterval) clearInterval(pingInterval);
+      if (responseTimer) clearTimeout(responseTimer);
+      resolve();
+    });
+  });
+}

package/src/commands/validate.ts

@@ -0,0 +1,53 @@
+import { resolve } from "node:path";
+import { validateAbility } from "../validation/validator.js";
+import { success, error, warn, p } from "../ui/format.js";
+import chalk from "chalk";
+
+export async function validateCommand(pathArg: string = "."): Promise<void> {
+  const targetDir = resolve(pathArg);
+  p.intro(`🔎 Validate ability`);
+
+  const s = p.spinner();
+  s.start("Running checks...");
+
+  const result = validateAbility(targetDir);
+
+  if (result.errors.length === 0 && result.warnings.length === 0) {
+    s.stop("All checks passed.");
+    p.outro("Ability is ready to deploy! 🎉");
+    return;
+  }
+
+  s.stop("Checks complete.");
+
+  if (result.errors.length > 0) {
+    p.note(
+      result.errors
+        .map(
+          (issue) =>
+            `${chalk.red("✗")} ${issue.file ? chalk.bold(`[${issue.file}]`) + " " : ""}${issue.message}`,
+        )
+        .join("\n"),
+      `${result.errors.length} Error(s)`,
+    );
+  }
+
+  if (result.warnings.length > 0) {
+    p.note(
+      result.warnings
+        .map(
+          (w) =>
+            `${chalk.yellow("⚠")} ${w.file ? chalk.bold(`[${w.file}]`) + " " : ""}${w.message}`,
+        )
+        .join("\n"),
+      `${result.warnings.length} Warning(s)`,
+    );
+  }
+
+  if (result.passed) {
+    p.outro("Validation passed (with warnings).");
+  } else {
+    error("Fix errors before deploying.");
+    process.exit(1);
+  }
+}

package/src/commands/whoami.ts

@@ -0,0 +1,54 @@
+import { getApiKey, getConfig, getTrackedAbilities } from "../config/store.js";
+import { p, info } from "../ui/format.js";
+import chalk from "chalk";
+import { homedir } from "node:os";
+
+export async function whoamiCommand(): Promise<void> {
+  p.intro("👤 OpenHome CLI Status");
+
+  const apiKey = getApiKey();
+  const config = getConfig();
+  const tracked = getTrackedAbilities();
+  const home = homedir();
+
+  // Auth status
+  if (apiKey) {
+    const masked = apiKey.slice(0, 6) + "..." + apiKey.slice(-4);
+    info(`Authenticated: ${chalk.green("yes")}  (key: ${chalk.gray(masked)})`);
+  } else {
+    info(
+      `Authenticated: ${chalk.red("no")}  — run ${chalk.bold("openhome login")}`,
+    );
+  }
+
+  // Default agent
+  if (config.default_personality_id) {
+    info(`Default agent: ${chalk.bold(config.default_personality_id)}`);
+  } else {
+    info(
+      `Default agent: ${chalk.gray("not set")}  — run ${chalk.bold("openhome agents")}`,
+    );
+  }
+
+  // API base
+  if (config.api_base_url) {
+    info(`API base: ${config.api_base_url}`);
+  }
+
+  // Tracked abilities
+  if (tracked.length > 0) {
+    const lines = tracked.map((a) => {
+      const shortPath = a.path.startsWith(home)
+        ? `~${a.path.slice(home.length)}`
+        : a.path;
+      return `  ${chalk.bold(a.name)}  ${chalk.gray(shortPath)}`;
+    });
+    p.note(lines.join("\n"), `${tracked.length} tracked ability(s)`);
+  } else {
+    info(
+      `Tracked abilities: ${chalk.gray("none")}  — run ${chalk.bold("openhome init")}`,
+    );
+  }
+
+  p.outro("Done.");
+}

package/src/config/keychain.ts

@@ -0,0 +1,62 @@
+import { execFileSync } from "node:child_process";
+
+const SERVICE = "openhome-cli";
+const ACCOUNT = "api-key";
+
+export function keychainGet(
+  service: string = SERVICE,
+  account: string = ACCOUNT,
+): string | null {
+  try {
+    const result = execFileSync(
+      "security",
+      ["find-generic-password", "-a", account, "-s", service, "-w"],
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] },
+    );
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export function keychainSet(
+  password: string,
+  service: string = SERVICE,
+  account: string = ACCOUNT,
+): boolean {
+  try {
+    execFileSync(
+      "security",
+      [
+        "add-generic-password",
+        "-a",
+        account,
+        "-s",
+        service,
+        "-w",
+        password,
+        "-U",
+      ],
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function keychainDelete(
+  service: string = SERVICE,
+  account: string = ACCOUNT,
+): boolean {
+  try {
+    execFileSync(
+      "security",
+      ["delete-generic-password", "-a", account, "-s", service],
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/config/store.ts

@@ -0,0 +1,137 @@
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  readdirSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { keychainGet, keychainSet } from "./keychain.js";
+
+export interface TrackedAbility {
+  name: string;
+  path: string;
+  created_at: string;
+}
+
+export interface CliConfig {
+  api_base_url?: string;
+  default_personality_id?: string;
+  api_key?: string;
+  abilities?: TrackedAbility[];
+}
+
+const CONFIG_DIR = join(homedir(), ".openhome");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+export function getConfig(): CliConfig {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf8");
+    return JSON.parse(raw) as CliConfig;
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(config: CliConfig): void {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}
+
+export function getApiKey(): string | null {
+  // Try keychain first
+  const fromKeychain = keychainGet();
+  if (fromKeychain) return fromKeychain;
+
+  // Fallback to config file
+  const config = getConfig();
+  return config.api_key ?? null;
+}
+
+export function registerAbility(name: string, absPath: string): void {
+  const config = getConfig();
+  const abilities = config.abilities ?? [];
+
+  // Update existing entry or add new one
+  const idx = abilities.findIndex((a) => a.path === absPath);
+  if (idx >= 0) {
+    abilities[idx].name = name;
+  } else {
+    abilities.push({
+      name,
+      path: absPath,
+      created_at: new Date().toISOString(),
+    });
+  }
+
+  config.abilities = abilities;
+  saveConfig(config);
+}
+
+export function getTrackedAbilities(): TrackedAbility[] {
+  const config = getConfig();
+  const tracked = (config.abilities ?? []).filter((a) => {
+    try {
+      return existsSync(join(a.path, "config.json"));
+    } catch {
+      return false;
+    }
+  });
+
+  // Auto-discover abilities in ./abilities/ that aren't tracked yet
+  const abilitiesDir = join(process.cwd(), "abilities");
+  if (existsSync(abilitiesDir)) {
+    try {
+      const dirs = readdirSync(abilitiesDir, { withFileTypes: true });
+      for (const d of dirs) {
+        if (!d.isDirectory()) continue;
+        const dirPath = join(abilitiesDir, d.name);
+        const configPath = join(dirPath, "config.json");
+        if (!existsSync(configPath)) continue;
+        if (tracked.some((a) => a.path === dirPath)) continue;
+
+        // Read name from config.json
+        try {
+          const abilityConfig = JSON.parse(
+            readFileSync(configPath, "utf8"),
+          ) as { unique_name?: string };
+          tracked.push({
+            name: abilityConfig.unique_name ?? d.name,
+            path: dirPath,
+            created_at: new Date().toISOString(),
+          });
+        } catch {
+          // skip unreadable configs
+        }
+      }
+    } catch {
+      // skip if abilities/ can't be read
+    }
+  }
+
+  return tracked;
+}
+
+export function saveApiKey(key: string): void {
+  const saved = keychainSet(key);
+  if (!saved) {
+    // Fallback: save in config file (less secure)
+    const config = getConfig();
+    config.api_key = key;
+    saveConfig(config);
+  }
+}

package/src/ui/format.ts

@@ -0,0 +1,95 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+
+// Re-export clack for direct use in commands
+export { p };
+
+export function success(msg: string): void {
+  console.log(chalk.green(`✓ ${msg}`));
+}
+
+export function error(msg: string): void {
+  console.error(chalk.red(`✗ ${msg}`));
+}
+
+export function warn(msg: string): void {
+  console.warn(chalk.yellow(`⚠ ${msg}`));
+}
+
+export function info(msg: string): void {
+  console.log(chalk.cyan(`ℹ ${msg}`));
+}
+
+export function header(msg: string): void {
+  console.log("");
+  console.log(chalk.bold(msg));
+  console.log(chalk.bold("─".repeat(msg.length)));
+}
+
+export interface TableRow {
+  [key: string]: string | number;
+}
+
+export function table(rows: TableRow[]): void {
+  if (rows.length === 0) {
+    info("No items to display.");
+    return;
+  }
+
+  const keys = Object.keys(rows[0]);
+
+  // Calculate column widths
+  const widths: Record<string, number> = {};
+  for (const key of keys) {
+    widths[key] = key.length;
+  }
+  for (const row of rows) {
+    for (const key of keys) {
+      const val = String(row[key] ?? "");
+      if (val.length > widths[key]) {
+        widths[key] = val.length;
+      }
+    }
+  }
+
+  // Header row
+  const headerLine = keys
+    .map((k) => chalk.bold(k.padEnd(widths[k])))
+    .join("  ");
+  console.log(headerLine);
+  console.log(keys.map((k) => "─".repeat(widths[k])).join("  "));
+
+  // Data rows
+  for (const row of rows) {
+    const line = keys
+      .map((k) => String(row[k] ?? "").padEnd(widths[k]))
+      .join("  ");
+    console.log(line);
+  }
+}
+
+export function spinner(msg: string): { stop: (finalMsg?: string) => void } {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${chalk.cyan(frames[i++ % frames.length])} ${msg}`);
+  }, 80);
+
+  return {
+    stop(finalMsg?: string) {
+      clearInterval(interval);
+      process.stdout.write("\r" + " ".repeat(msg.length + 4) + "\r");
+      if (finalMsg) {
+        console.log(finalMsg);
+      }
+    },
+  };
+}
+
+/** Check if user cancelled a clack prompt (Ctrl+C) */
+export function handleCancel(value: unknown): void {
+  if (p.isCancel(value)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+}

package/src/util/zip.ts

@@ -0,0 +1,74 @@
+import archiver from "archiver";
+import { createWriteStream } from "node:fs";
+import { Writable } from "node:stream";
+
+export async function createAbilityZip(dirPath: string): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+
+    const writable = new Writable({
+      write(chunk: Buffer, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      },
+    });
+
+    writable.on("finish", () => {
+      resolve(Buffer.concat(chunks));
+    });
+
+    writable.on("error", reject);
+
+    const archive = archiver("zip", { zlib: { level: 9 } });
+
+    archive.on("error", reject);
+    archive.pipe(writable);
+
+    archive.glob("**/*", {
+      cwd: dirPath,
+      ignore: [
+        "**/__pycache__/**",
+        "**/*.pyc",
+        "**/.git/**",
+        "**/.env",
+        "**/.env.*",
+        "**/secrets.*",
+        "**/*.key",
+        "**/*.pem",
+      ],
+    });
+
+    archive.finalize().catch(reject);
+  });
+}
+
+// Convenience: write zip to a file path
+export async function writeAbilityZip(
+  dirPath: string,
+  outPath: string,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const output = createWriteStream(outPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+
+    output.on("close", resolve);
+    archive.on("error", reject);
+    archive.pipe(output);
+
+    archive.glob("**/*", {
+      cwd: dirPath,
+      ignore: [
+        "**/__pycache__/**",
+        "**/*.pyc",
+        "**/.git/**",
+        "**/.env",
+        "**/.env.*",
+        "**/secrets.*",
+        "**/*.key",
+        "**/*.pem",
+      ],
+    });
+
+    archive.finalize().catch(reject);
+  });
+}