openhome-cli 0.1.0

package/src/cli.ts

@@ -0,0 +1,339 @@
+import { Command } from "commander";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { readFileSync } from "node:fs";
+
+import { loginCommand } from "./commands/login.js";
+import { initCommand } from "./commands/init.js";
+import { deployCommand } from "./commands/deploy.js";
+import { deleteCommand } from "./commands/delete.js";
+import { toggleCommand } from "./commands/toggle.js";
+import { assignCommand } from "./commands/assign.js";
+import { listCommand } from "./commands/list.js";
+import { statusCommand } from "./commands/status.js";
+import { agentsCommand } from "./commands/agents.js";
+import { logoutCommand } from "./commands/logout.js";
+import { chatCommand } from "./commands/chat.js";
+import { triggerCommand } from "./commands/trigger.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { configEditCommand } from "./commands/config-edit.js";
+import { logsCommand } from "./commands/logs.js";
+import { p, handleCancel } from "./ui/format.js";
+
+// Read version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let version = "0.1.0";
+try {
+  const pkg = JSON.parse(
+    readFileSync(join(__dirname, "..", "package.json"), "utf8"),
+  ) as { version?: string };
+  version = pkg.version ?? version;
+} catch {
+  // fallback to default
+}
+
+// ── Interactive menu (bare `openhome` with no args) ──────────────
+
+async function ensureLoggedIn(): Promise<void> {
+  const { getApiKey } = await import("./config/store.js");
+  const key = getApiKey();
+  if (!key) {
+    await loginCommand();
+    console.log("");
+  }
+}
+
+async function interactiveMenu(): Promise<void> {
+  p.intro(`🏠 OpenHome CLI v${version}`);
+
+  // Login first if not authenticated
+  await ensureLoggedIn();
+
+  let running = true;
+  while (running) {
+    const choice = await p.select({
+      message: "What would you like to do?",
+      options: [
+        {
+          value: "init",
+          label: "✨  Create Ability",
+          hint: "Scaffold a new ability from templates",
+        },
+        {
+          value: "deploy",
+          label: "🚀  Deploy",
+          hint: "Upload ability to OpenHome",
+        },
+        {
+          value: "chat",
+          label: "💬  Chat",
+          hint: "Talk to your agent",
+        },
+        {
+          value: "trigger",
+          label: "⚡  Trigger",
+          hint: "Fire an ability remotely with a phrase",
+        },
+        {
+          value: "list",
+          label: "📋  My Abilities",
+          hint: "List deployed abilities",
+        },
+        {
+          value: "delete",
+          label: "🗑️   Delete Ability",
+          hint: "Remove a deployed ability",
+        },
+        {
+          value: "toggle",
+          label: "⚡  Enable / Disable",
+          hint: "Toggle an ability on or off",
+        },
+        {
+          value: "assign",
+          label: "🔗  Assign to Agent",
+          hint: "Link abilities to an agent",
+        },
+        {
+          value: "agents",
+          label: "🤖  My Agents",
+          hint: "View agents and set default",
+        },
+        {
+          value: "status",
+          label: "🔍  Status",
+          hint: "Check ability status",
+        },
+        {
+          value: "config",
+          label: "⚙️   Edit Config",
+          hint: "Update trigger words, description, category",
+        },
+        {
+          value: "logs",
+          label: "📡  Logs",
+          hint: "Stream live agent messages",
+        },
+        {
+          value: "whoami",
+          label: "👤  Who Am I",
+          hint: "Show auth, default agent, tracked abilities",
+        },
+        {
+          value: "logout",
+          label: "🔓  Log Out",
+          hint: "Clear credentials and re-authenticate",
+        },
+        { value: "exit", label: "👋  Exit", hint: "Quit" },
+      ],
+    });
+    handleCancel(choice);
+
+    switch (choice) {
+      case "init":
+        await initCommand();
+        break;
+      case "deploy":
+        await deployCommand();
+        break;
+      case "chat":
+        await chatCommand();
+        break;
+      case "trigger":
+        await triggerCommand();
+        break;
+      case "list":
+        await listCommand();
+        break;
+      case "delete":
+        await deleteCommand();
+        break;
+      case "toggle":
+        await toggleCommand();
+        break;
+      case "assign":
+        await assignCommand();
+        break;
+      case "agents":
+        await agentsCommand();
+        break;
+      case "status":
+        await statusCommand();
+        break;
+      case "config":
+        await configEditCommand();
+        break;
+      case "logs":
+        await logsCommand();
+        break;
+      case "whoami":
+        await whoamiCommand();
+        break;
+      case "logout":
+        await logoutCommand();
+        await ensureLoggedIn();
+        break;
+      case "exit":
+        running = false;
+        break;
+    }
+
+    if (running) {
+      console.log(""); // spacing between commands
+    }
+  }
+
+  p.outro("See you next time!");
+}
+
+// ── Commander subcommands (direct usage) ─────────────────────────
+
+const program = new Command();
+
+program
+  .name("openhome")
+  .description("OpenHome CLI — manage abilities from your terminal")
+  .version(version, "-v, --version", "Output the current version");
+
+program
+  .command("login")
+  .description("Authenticate with your OpenHome API key")
+  .action(async () => {
+    await loginCommand();
+  });
+
+program
+  .command("logout")
+  .description("Log out and clear stored credentials")
+  .action(async () => {
+    await logoutCommand();
+  });
+
+program
+  .command("init [name]")
+  .description("Scaffold a new ability from templates")
+  .action(async (name?: string) => {
+    await initCommand(name);
+  });
+
+program
+  .command("deploy [path]")
+  .description("Validate and deploy an ability to OpenHome")
+  .option("--dry-run", "Show what would be deployed without sending")
+  .option("--mock", "Use mock API client (no real network calls)")
+  .option("--personality <id>", "Agent ID to attach the ability to")
+  .action(
+    async (
+      path: string | undefined,
+      opts: { dryRun?: boolean; mock?: boolean; personality?: string },
+    ) => {
+      await deployCommand(path, opts);
+    },
+  );
+
+program
+  .command("chat [agent]")
+  .description("Chat with an agent via WebSocket")
+  .action(async (agent?: string) => {
+    await chatCommand(agent);
+  });
+
+program
+  .command("trigger [phrase]")
+  .description("Send a trigger phrase to fire an ability remotely")
+  .option("--agent <id>", "Agent ID (uses default if not set)")
+  .action(async (phrase?: string, opts?: { agent?: string }) => {
+    await triggerCommand(phrase, opts);
+  });
+
+program
+  .command("list")
+  .description("List all deployed abilities")
+  .option("--mock", "Use mock API client")
+  .action(async (opts: { mock?: boolean }) => {
+    await listCommand(opts);
+  });
+
+program
+  .command("delete [ability]")
+  .description("Delete a deployed ability")
+  .option("--mock", "Use mock API client")
+  .action(async (ability: string | undefined, opts: { mock?: boolean }) => {
+    await deleteCommand(ability, opts);
+  });
+
+program
+  .command("toggle [ability]")
+  .description("Enable or disable a deployed ability")
+  .option("--enable", "Enable the ability")
+  .option("--disable", "Disable the ability")
+  .option("--mock", "Use mock API client")
+  .action(
+    async (
+      ability: string | undefined,
+      opts: { mock?: boolean; enable?: boolean; disable?: boolean },
+    ) => {
+      await toggleCommand(ability, opts);
+    },
+  );
+
+program
+  .command("assign")
+  .description("Assign abilities to an agent")
+  .option("--mock", "Use mock API client")
+  .action(async (opts: { mock?: boolean }) => {
+    await assignCommand(opts);
+  });
+
+program
+  .command("agents")
+  .description("View your agents and set a default")
+  .option("--mock", "Use mock API client")
+  .action(async (opts: { mock?: boolean }) => {
+    await agentsCommand(opts);
+  });
+
+program
+  .command("status [ability]")
+  .description("Show detailed status of an ability")
+  .option("--mock", "Use mock API client")
+  .action(async (ability: string | undefined, opts: { mock?: boolean }) => {
+    await statusCommand(ability, opts);
+  });
+
+program
+  .command("config [path]")
+  .description("Edit trigger words, description, or category in config.json")
+  .action(async (path?: string) => {
+    await configEditCommand(path);
+  });
+
+program
+  .command("logs")
+  .description("Stream live agent messages and logs")
+  .option("--agent <id>", "Agent ID (uses default if not set)")
+  .action(async (opts: { agent?: string }) => {
+    await logsCommand(opts);
+  });
+
+program
+  .command("whoami")
+  .description("Show auth status, default agent, and tracked abilities")
+  .action(async () => {
+    await whoamiCommand();
+  });
+
+// ── Entry point: menu if no args, subcommand otherwise ───────────
+
+if (process.argv.length <= 2) {
+  interactiveMenu().catch((err: unknown) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+} else {
+  program.parseAsync(process.argv).catch((err: unknown) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}

package/src/commands/agents.ts

@@ -0,0 +1,88 @@
+import { ApiClient, NotImplementedError } from "../api/client.js";
+import { MockApiClient } from "../api/mock-client.js";
+import { getApiKey, getConfig, saveConfig } from "../config/store.js";
+import { error, success, info, p, handleCancel } from "../ui/format.js";
+import chalk from "chalk";
+
+export async function agentsCommand(
+  opts: { mock?: boolean } = {},
+): Promise<void> {
+  p.intro("🤖 Your Agents");
+
+  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 agents...");
+
+  try {
+    const personalities = await client.getPersonalities();
+    s.stop(`Found ${personalities.length} agent(s).`);
+
+    if (personalities.length === 0) {
+      info("No agents found. Create one at https://app.openhome.com");
+      p.outro("Done.");
+      return;
+    }
+
+    p.note(
+      personalities
+        .map((pers) => `${chalk.bold(pers.name)}  ${chalk.gray(pers.id)}`)
+        .join("\n"),
+      "Agents",
+    );
+
+    const config = getConfig();
+    const currentDefault = config.default_personality_id;
+
+    if (currentDefault) {
+      const match = personalities.find((p) => p.id === currentDefault);
+      info(`Default agent: ${match ? match.name : currentDefault}`);
+    }
+
+    const setDefault = await p.confirm({
+      message: "Set or change your default agent?",
+    });
+    handleCancel(setDefault);
+
+    if (setDefault) {
+      const selected = await p.select({
+        message: "Choose default agent",
+        options: personalities.map((pers) => ({
+          value: pers.id,
+          label: pers.name,
+          hint: pers.id,
+        })),
+      });
+      handleCancel(selected);
+
+      config.default_personality_id = selected as string;
+      saveConfig(config);
+      success(`Default agent set: ${String(selected)}`);
+    }
+
+    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("Agents endpoint not yet implemented.");
+      return;
+    }
+    error(
+      `Failed to fetch agents: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/assign.ts

@@ -0,0 +1,123 @@
+import { ApiClient, NotImplementedError } from "../api/client.js";
+import { MockApiClient } from "../api/mock-client.js";
+import { getApiKey, getConfig } from "../config/store.js";
+import { error, success, info, p, handleCancel } from "../ui/format.js";
+import chalk from "chalk";
+
+export async function assignCommand(
+  opts: { mock?: boolean } = {},
+): Promise<void> {
+  p.intro("🔗 Assign abilities to agent");
+
+  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 agents and abilities...");
+
+  let personalities: Awaited<ReturnType<typeof client.getPersonalities>>;
+  let abilities: Awaited<ReturnType<typeof client.listAbilities>>["abilities"];
+
+  try {
+    [personalities, { abilities }] = await Promise.all([
+      client.getPersonalities(),
+      client.listAbilities(),
+    ]);
+    s.stop(
+      `Found ${personalities.length} agent(s), ${abilities.length} ability(s).`,
+    );
+  } catch (err) {
+    s.stop("Failed to fetch data.");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+
+  if (personalities.length === 0) {
+    p.outro("No agents found. Create one at https://app.openhome.com");
+    return;
+  }
+
+  if (abilities.length === 0) {
+    p.outro("No abilities found. Run: openhome deploy");
+    return;
+  }
+
+  // Pick agent
+  const agentId = await p.select({
+    message: "Which agent do you want to update?",
+    options: personalities.map((pers) => ({
+      value: pers.id,
+      label: pers.name,
+      hint: chalk.gray(pers.id),
+    })),
+  });
+  handleCancel(agentId);
+
+  const agentName =
+    personalities.find((p) => p.id === agentId)?.name ?? String(agentId);
+
+  // Show current assignments and let user pick which abilities to assign
+  info(
+    `Select abilities to assign to "${agentName}". Deselecting all unassigns everything.`,
+  );
+
+  const selectedIds = await p.multiselect({
+    message: `Abilities for "${agentName}"`,
+    options: abilities.map((a) => ({
+      value: a.ability_id,
+      label: a.unique_name,
+      hint: `${a.status}  v${a.version}`,
+    })),
+    required: false,
+  });
+  handleCancel(selectedIds);
+
+  const chosenIds = selectedIds as string[];
+
+  // Convert ability_ids to numbers for the API payload
+  // The API expects numeric IDs; if the real API returns string IDs we send them as-is
+  const numericIds = chosenIds
+    .map((id) => Number(id))
+    .filter((id) => !Number.isNaN(id));
+
+  // If any ID couldn't be parsed as a number, fall back to the raw list
+  // (lets the server validate — better than silently dropping)
+  const capabilityIds =
+    numericIds.length === chosenIds.length
+      ? numericIds
+      : (chosenIds as unknown as number[]);
+
+  s.start(`Assigning ${chosenIds.length} ability(s) to "${agentName}"...`);
+  try {
+    const result = await client.assignCapabilities(
+      agentId as string,
+      capabilityIds,
+    );
+    s.stop("Done.");
+    success(
+      result.message ??
+        `"${agentName}" updated with ${chosenIds.length} ability(s).`,
+    );
+    p.outro("Done.");
+  } catch (err) {
+    s.stop("Failed.");
+
+    if (err instanceof NotImplementedError) {
+      p.note("Assign endpoint not yet implemented.", "API Not Available Yet");
+      return;
+    }
+
+    error(`Assign failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}