openhome-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,3184 @@
+import {
+  getApiKey,
+  getConfig,
+  getTrackedAbilities,
+  keychainDelete,
+  registerAbility,
+  saveApiKey,
+  saveConfig
+} from "./chunk-Q4UKUXDB.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import { fileURLToPath } from "url";
+import { dirname, join as join6 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+
+// src/api/endpoints.ts
+var API_BASE = "https://app.openhome.com";
+var WS_BASE = "wss://app.openhome.com";
+var ENDPOINTS = {
+  getPersonalities: "/api/sdk/get_personalities",
+  verifyApiKey: "/api/sdk/verify_apikey/",
+  uploadCapability: "/api/capabilities/add-capability/",
+  listCapabilities: "/api/capabilities/get-all-capability/",
+  getCapability: (id) => `/api/capabilities/get-capability/${id}/`,
+  deleteCapability: (id) => `/api/capabilities/delete-capability/${id}/`,
+  bulkDeleteCapabilities: "/api/capabilities/delete-capability/",
+  editInstalledCapability: (id) => `/api/capabilities/edit-installed-capability/${id}/`,
+  editPersonality: "/api/personalities/edit-personality/",
+  voiceStream: (apiKey, agentId) => `/websocket/voice-stream/${apiKey}/${agentId}`
+};
+
+// src/api/client.ts
+var NotImplementedError = class extends Error {
+  constructor(endpoint) {
+    super(`API endpoint not yet implemented: ${endpoint}`);
+    this.name = "NotImplementedError";
+  }
+};
+var ApiError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ApiError";
+  }
+};
+var ApiClient = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl ?? API_BASE;
+    if (!this.baseUrl.startsWith("https://")) {
+      throw new Error("API base URL must use HTTPS. Got: " + this.baseUrl);
+    }
+  }
+  baseUrl;
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        ...options.headers ?? {}
+      }
+    });
+    if (!response.ok) {
+      let body = null;
+      try {
+        body = await response.json();
+      } catch {
+      }
+      if (body?.error?.code === "NOT_IMPLEMENTED" || response.status === 404) {
+        throw new NotImplementedError(path);
+      }
+      throw new ApiError(
+        body?.error?.code ?? String(response.status),
+        body?.error?.message ?? response.statusText,
+        body?.error?.details
+      );
+    }
+    return response.json();
+  }
+  async getPersonalities() {
+    const data = await this.request(
+      ENDPOINTS.getPersonalities,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ api_key: this.apiKey, with_image: true })
+      }
+    );
+    return data.personalities;
+  }
+  async uploadAbility(zipBuffer, imageBuffer, imageName, metadata) {
+    const form = new FormData();
+    form.append(
+      "zip_file",
+      new Blob([zipBuffer], {
+        type: "application/zip"
+      }),
+      "ability.zip"
+    );
+    if (imageBuffer && imageName) {
+      const imageExt = imageName.split(".").pop()?.toLowerCase() ?? "png";
+      const imageMime = imageExt === "jpg" || imageExt === "jpeg" ? "image/jpeg" : "image/png";
+      form.append(
+        "image_file",
+        new Blob([imageBuffer], { type: imageMime }),
+        imageName
+      );
+    }
+    form.append("name", metadata.name);
+    form.append("description", metadata.description);
+    form.append("category", metadata.category);
+    form.append("trigger_words", metadata.matching_hotwords.join(", "));
+    if (metadata.personality_id) {
+      form.append("personality_id", metadata.personality_id);
+    }
+    return this.request(ENDPOINTS.uploadCapability, {
+      method: "POST",
+      body: form
+    });
+  }
+  async listAbilities() {
+    return this.request(ENDPOINTS.listCapabilities, {
+      method: "GET"
+    });
+  }
+  async getAbility(id) {
+    return this.request(ENDPOINTS.getCapability(id), {
+      method: "GET"
+    });
+  }
+  async verifyApiKey(apiKey) {
+    return this.request(ENDPOINTS.verifyApiKey, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ api_key: apiKey })
+    });
+  }
+  async deleteCapability(id) {
+    try {
+      return await this.request(
+        ENDPOINTS.bulkDeleteCapabilities,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            ids: [Number.isNaN(Number(id)) ? id : Number(id)]
+          })
+        }
+      );
+    } catch (err) {
+      if (err instanceof NotImplementedError) {
+        return this.request(
+          ENDPOINTS.deleteCapability(id),
+          { method: "DELETE" }
+        );
+      }
+      throw err;
+    }
+  }
+  async toggleCapability(id, enabled) {
+    return this.request(
+      ENDPOINTS.editInstalledCapability(id),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ enabled })
+      }
+    );
+  }
+  async assignCapabilities(personalityId, capabilityIds) {
+    return this.request(ENDPOINTS.editPersonality, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        personality_id: personalityId,
+        matching_capabilities: capabilityIds
+      })
+    });
+  }
+};
+
+// src/ui/format.ts
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+function success(msg) {
+  console.log(chalk.green(`\u2713 ${msg}`));
+}
+function error(msg) {
+  console.error(chalk.red(`\u2717 ${msg}`));
+}
+function warn(msg) {
+  console.warn(chalk.yellow(`\u26A0 ${msg}`));
+}
+function info(msg) {
+  console.log(chalk.cyan(`\u2139 ${msg}`));
+}
+function table(rows) {
+  if (rows.length === 0) {
+    info("No items to display.");
+    return;
+  }
+  const keys = Object.keys(rows[0]);
+  const widths = {};
+  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;
+      }
+    }
+  }
+  const headerLine = keys.map((k) => chalk.bold(k.padEnd(widths[k]))).join("  ");
+  console.log(headerLine);
+  console.log(keys.map((k) => "\u2500".repeat(widths[k])).join("  "));
+  for (const row of rows) {
+    const line = keys.map((k) => String(row[k] ?? "").padEnd(widths[k])).join("  ");
+    console.log(line);
+  }
+}
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+}
+
+// src/commands/login.ts
+import chalk2 from "chalk";
+async function loginCommand() {
+  p.intro("\u{1F511} 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;
+  try {
+    const client = new ApiClient(apiKey);
+    const verification = await client.verifyApiKey(apiKey);
+    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);
+  success("API key saved.");
+  if (agents.length > 0) {
+    p.note(
+      agents.map((a) => `${chalk2.bold(a.name)}  ${chalk2.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.");
+}
+
+// src/commands/init.ts
+import {
+  mkdirSync,
+  writeFileSync,
+  copyFileSync,
+  existsSync as existsSync2,
+  readdirSync as readdirSync2
+} from "fs";
+import { join as join2, resolve, extname } from "path";
+import { homedir } from "os";
+
+// src/validation/validator.ts
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+
+// src/validation/rules.ts
+var REQUIRED_FILES = ["main.py", "README.md", "__init__.py"];
+var BLOCKED_IMPORTS = [
+  "redis",
+  "from src.utils.db_handler",
+  "connection_manager",
+  "user_config"
+];
+var BLOCKED_PATTERNS = [
+  {
+    regex: /\bprint\s*\(/,
+    message: "Use self.worker.editor_logging_handler instead of print()"
+  },
+  {
+    regex: /\basyncio\.sleep\s*\(/,
+    message: "Use self.worker.session_tasks.sleep() instead"
+  },
+  {
+    regex: /\basyncio\.create_task\s*\(/,
+    message: "Use self.worker.session_tasks.create() instead"
+  },
+  { regex: /\bexec\s*\(/, message: "exec() not allowed" },
+  { regex: /\beval\s*\(/, message: "eval() not allowed" },
+  { regex: /\bpickle\./, message: "pickle not allowed" },
+  { regex: /\bdill\./, message: "dill not allowed" },
+  { regex: /\bshelve\./, message: "shelve not allowed" },
+  { regex: /\bmarshal\./, message: "marshal not allowed" },
+  {
+    regex: /\bopen\s*\(/,
+    message: "raw open() not allowed \u2014 use capability_worker file helpers"
+  },
+  { regex: /\bassert\s+/, message: "assert not allowed" },
+  { regex: /\bhashlib\.md5\s*\(/, message: "MD5 not allowed" }
+];
+var REQUIRED_PATTERNS = [
+  {
+    regex: /resume_normal_flow\s*\(/,
+    message: "resume_normal_flow() must be called"
+  },
+  {
+    regex: /class\s+\w+.*MatchingCapability/,
+    message: "Class must extend MatchingCapability"
+  },
+  { regex: /def\s+call\s*\(/, message: "Must have a call() method" },
+  {
+    regex: /worker\s*:\s*AgentWorker\s*=\s*None/,
+    message: "Must declare worker: AgentWorker = None"
+  },
+  {
+    regex: /capability_worker\s*:\s*CapabilityWorker\s*=\s*None/,
+    message: "Must declare capability_worker: CapabilityWorker = None"
+  }
+];
+var REGISTER_CAPABILITY_PATTERN = /#\s?\{\{register[_ ]capability\}\}/;
+var HARDCODED_KEY_PATTERN = /(sk_|sk-|key_)[a-zA-Z0-9]{20,}/;
+var MULTIPLE_CLASSES_PATTERN = /^class\s+/gm;
+
+// src/validation/validator.ts
+function readFile(filePath) {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function validateAbility(dirPath) {
+  const errors = [];
+  const warnings = [];
+  for (const required of REQUIRED_FILES) {
+    const fullPath = join(dirPath, required);
+    if (!existsSync(fullPath)) {
+      errors.push({
+        severity: "error",
+        message: `Missing required file: ${required}`,
+        file: required
+      });
+    }
+  }
+  const configPath = join(dirPath, "config.json");
+  if (existsSync(configPath)) {
+    const configContent = readFile(configPath);
+    if (configContent) {
+      try {
+        const config = JSON.parse(configContent);
+        if (typeof config.unique_name !== "string" || !config.unique_name) {
+          errors.push({
+            severity: "error",
+            message: "config.json: unique_name must be a non-empty string",
+            file: "config.json"
+          });
+        }
+        if (!Array.isArray(config.matching_hotwords) || !config.matching_hotwords.every(
+          (h) => typeof h === "string"
+        )) {
+          errors.push({
+            severity: "error",
+            message: "config.json: matching_hotwords must be an array of strings",
+            file: "config.json"
+          });
+        }
+      } catch {
+        errors.push({
+          severity: "error",
+          message: "config.json: invalid JSON",
+          file: "config.json"
+        });
+      }
+    }
+  } else {
+    errors.push({
+      severity: "error",
+      message: "Missing required file: config.json",
+      file: "config.json"
+    });
+  }
+  const mainPath = join(dirPath, "main.py");
+  const mainContent = readFile(mainPath);
+  if (mainContent) {
+    const lines = mainContent.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line.startsWith("import ") && !line.startsWith("from ") && !line.includes("import "))
+        continue;
+      for (const blocked of BLOCKED_IMPORTS) {
+        if (line.includes(blocked)) {
+          errors.push({
+            severity: "error",
+            message: `Blocked import "${blocked}" on line ${i + 1}`,
+            file: "main.py"
+          });
+        }
+      }
+    }
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      for (const { regex, message } of BLOCKED_PATTERNS) {
+        if (regex.test(line)) {
+          errors.push({
+            severity: "error",
+            message: `${message} (line ${i + 1})`,
+            file: "main.py"
+          });
+        }
+      }
+    }
+    for (const { regex, message } of REQUIRED_PATTERNS) {
+      if (!regex.test(mainContent)) {
+        errors.push({ severity: "error", message, file: "main.py" });
+      }
+    }
+    if (!REGISTER_CAPABILITY_PATTERN.test(mainContent)) {
+      errors.push({
+        severity: "error",
+        message: "Missing #{{register_capability}} tag in main.py",
+        file: "main.py"
+      });
+    }
+    const keyMatches = mainContent.match(HARDCODED_KEY_PATTERN);
+    if (keyMatches) {
+      warnings.push({
+        severity: "warning",
+        message: `Possible hardcoded API key detected in main.py \u2014 use capability_worker.get_single_key() instead`,
+        file: "main.py"
+      });
+    }
+    const classMatches = mainContent.match(MULTIPLE_CLASSES_PATTERN);
+    if (classMatches && classMatches.length > 1) {
+      warnings.push({
+        severity: "warning",
+        message: `Multiple class definitions found (${classMatches.length}). Only one MatchingCapability class is expected.`,
+        file: "main.py"
+      });
+    }
+  }
+  let pyFiles = [];
+  try {
+    pyFiles = readdirSync(dirPath).filter(
+      (f) => f.endsWith(".py") && f !== "main.py"
+    );
+  } catch {
+  }
+  for (const pyFile of pyFiles) {
+    const content = readFile(join(dirPath, pyFile));
+    if (!content) continue;
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      for (const { regex, message } of BLOCKED_PATTERNS) {
+        if (regex.test(line)) {
+          errors.push({
+            severity: "error",
+            message: `${message} (line ${i + 1})`,
+            file: pyFile
+          });
+        }
+      }
+    }
+  }
+  return {
+    passed: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+// src/commands/init.ts
+var DAEMON_TEMPLATES = /* @__PURE__ */ new Set(["background", "alarm"]);
+function toClassName(name) {
+  return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+var SHARED_INIT = "";
+function sharedConfig() {
+  return `{
+  "unique_name": "{{UNIQUE_NAME}}",
+  "description": "{{DESCRIPTION}}",
+  "category": "{{CATEGORY}}",
+  "matching_hotwords": {{HOTWORDS}}
+}
+`;
+}
+function skillReadme() {
+  return `# {{DISPLAY_NAME}}
+
+A custom OpenHome ability.
+
+## Trigger Words
+
+{{HOTWORD_LIST}}
+`;
+}
+function daemonReadme() {
+  return `# {{DISPLAY_NAME}}
+
+A background OpenHome daemon. Runs automatically on session start \u2014 no trigger words required.
+
+## Trigger Words
+
+{{HOTWORD_LIST}}
+`;
+}
+function getTemplate(templateType, file) {
+  if (file === "config.json") return sharedConfig();
+  if (file === "__init__.py") return SHARED_INIT;
+  if (file === "README.md") {
+    return DAEMON_TEMPLATES.has(templateType) ? daemonReadme() : skillReadme();
+  }
+  const templates = {
+    // ── BASIC ────────────────────────────────────────────────────────────
+    basic: {
+      "main.py": `from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        await self.capability_worker.speak("Hello! This ability is working.")
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── API ──────────────────────────────────────────────────────────────
+    api: {
+      "main.py": `import requests
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        api_key = self.capability_worker.get_single_key("api_key")
+        response = requests.get(
+            "https://api.example.com/data",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10,
+        )
+        data = response.json()
+        await self.capability_worker.speak(f"Here's what I found: {data.get('result', 'nothing')}")
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── LOOP ─────────────────────────────────────────────────────────────
+    loop: {
+      "main.py": `import asyncio
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        await self.capability_worker.speak("I'll listen and check in periodically.")
+
+        while True:
+            self.capability_worker.start_audio_recording()
+            await self.worker.session_tasks.sleep(90)
+            self.capability_worker.stop_audio_recording()
+
+            recording = self.capability_worker.get_audio_recording()
+            length = self.capability_worker.get_audio_recording_length()
+            self.capability_worker.flush_audio_recording()
+
+            if length > 2:
+                response = self.capability_worker.text_to_text_response(
+                    f"The user has been speaking for {length:.0f} seconds. "
+                    "Summarize what you heard and respond helpfully.",
+                    self.capability_worker.get_full_message_history(),
+                )
+                await self.capability_worker.speak(response)
+
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── EMAIL ────────────────────────────────────────────────────────────
+    email: {
+      "main.py": `import json
+import smtplib
+from email.mime.text import MIMEText
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        creds = self.capability_worker.get_single_key("email_config")
+        if not creds:
+            await self.capability_worker.speak("Email is not configured yet.")
+            self.capability_worker.resume_normal_flow()
+            return
+
+        config = json.loads(creds) if isinstance(creds, str) else creds
+
+        reply = await self.capability_worker.run_io_loop(
+            "Who should I send the email to?"
+        )
+        to_addr = reply.strip()
+
+        subject = await self.capability_worker.run_io_loop("What's the subject?")
+        body = await self.capability_worker.run_io_loop("What should the email say?")
+
+        confirmed = await self.capability_worker.run_confirmation_loop(
+            f"Send email to {to_addr} with subject '{subject}'?"
+        )
+
+        if confirmed:
+            msg = MIMEText(body)
+            msg["Subject"] = subject
+            msg["From"] = config["from"]
+            msg["To"] = to_addr
+
+            try:
+                with smtplib.SMTP(config["smtp_host"], config.get("smtp_port", 587)) as server:
+                    server.starttls()
+                    server.login(config["from"], config["password"])
+                    server.send_message(msg)
+                await self.capability_worker.speak("Email sent!")
+            except Exception as e:
+                self.worker.editor_logging_handler.error(f"Email failed: {e}")
+                await self.capability_worker.speak("Sorry, the email failed to send.")
+        else:
+            await self.capability_worker.speak("Email cancelled.")
+
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── BACKGROUND (daemon) ───────────────────────────────────────────────
+    // background.py holds the active logic; main.py is a minimal no-op stub
+    background: {
+      "main.py": `from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        self.capability_worker.resume_normal_flow()
+`,
+      "background.py": `import asyncio
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        while True:
+            # Your background logic here
+            self.worker.editor_logging_handler.info("Background tick")
+
+            # Example: check something and notify
+            # await self.capability_worker.speak("Heads up!")
+
+            await self.worker.session_tasks.sleep(60)
+`
+    },
+    // ── ALARM (skill + daemon combo) ──────────────────────────────────────
+    alarm: {
+      "main.py": `from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        reply = await self.capability_worker.run_io_loop(
+            "What should I remind you about?"
+        )
+        minutes = await self.capability_worker.run_io_loop(
+            "In how many minutes?"
+        )
+
+        try:
+            mins = int(minutes.strip())
+        except ValueError:
+            await self.capability_worker.speak("I didn't understand the time. Try again.")
+            self.capability_worker.resume_normal_flow()
+            return
+
+        self.capability_worker.write_file(
+            "pending_alarm.json",
+            f'{{"message": "{reply}", "minutes": {mins}}}',
+            temp=True,
+        )
+        await self.capability_worker.speak(f"Got it! I'll remind you in {mins} minutes.")
+        self.capability_worker.resume_normal_flow()
+`,
+      "background.py": `import json
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}Background(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        while True:
+            if self.capability_worker.check_if_file_exists("pending_alarm.json", temp=True):
+                raw = self.capability_worker.read_file("pending_alarm.json", temp=True)
+                alarm = json.loads(raw)
+                await self.worker.session_tasks.sleep(alarm["minutes"] * 60)
+                await self.capability_worker.speak(f"Reminder: {alarm['message']}")
+                self.capability_worker.delete_file("pending_alarm.json", temp=True)
+            await self.worker.session_tasks.sleep(10)
+`
+    },
+    // ── READWRITE ────────────────────────────────────────────────────────
+    readwrite: {
+      "main.py": `import json
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        reply = await self.capability_worker.run_io_loop(
+            "What would you like me to remember?"
+        )
+
+        # Read existing notes or start fresh
+        if self.capability_worker.check_if_file_exists("notes.json", temp=False):
+            raw = self.capability_worker.read_file("notes.json", temp=False)
+            notes = json.loads(raw)
+        else:
+            notes = []
+
+        notes.append(reply.strip())
+        self.capability_worker.write_file(
+            "notes.json",
+            json.dumps(notes, indent=2),
+            temp=False,
+            mode="w",
+        )
+
+        await self.capability_worker.speak(
+            f"Got it! I now have {len(notes)} note{'s' if len(notes) != 1 else ''} saved."
+        )
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── LOCAL ────────────────────────────────────────────────────────────
+    local: {
+      "main.py": `from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        reply = await self.capability_worker.run_io_loop(
+            "What would you like me to do on your device?"
+        )
+
+        # Use text_to_text to interpret the command
+        response = self.capability_worker.text_to_text_response(
+            f"The user wants to: {reply}. Generate a helpful response.",
+            self.capability_worker.get_full_message_history(),
+        )
+
+        # Send action to DevKit hardware if connected
+        self.capability_worker.send_devkit_action({
+            "type": "command",
+            "payload": reply.strip(),
+        })
+
+        await self.capability_worker.speak(response)
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── OPENCLAW ─────────────────────────────────────────────────────────
+    openclaw: {
+      "main.py": `import requests
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        reply = await self.capability_worker.run_io_loop(
+            "What would you like me to handle?"
+        )
+
+        gateway_url = self.capability_worker.get_single_key("openclaw_gateway_url")
+        gateway_token = self.capability_worker.get_single_key("openclaw_gateway_token")
+
+        if not gateway_url or not gateway_token:
+            await self.capability_worker.speak(
+                "OpenClaw gateway is not configured. Add openclaw_gateway_url and openclaw_gateway_token as secrets."
+            )
+            self.capability_worker.resume_normal_flow()
+            return
+
+        try:
+            resp = requests.post(
+                f"{gateway_url}/v1/chat",
+                headers={
+                    "Authorization": f"Bearer {gateway_token}",
+                    "Content-Type": "application/json",
+                },
+                json={"message": reply.strip()},
+                timeout=30,
+            )
+            data = resp.json()
+            answer = data.get("reply", data.get("response", "No response from OpenClaw."))
+            await self.capability_worker.speak(answer)
+        except Exception as e:
+            self.worker.editor_logging_handler.error(f"OpenClaw error: {e}")
+            await self.capability_worker.speak("Sorry, I couldn't reach OpenClaw.")
+
+        self.capability_worker.resume_normal_flow()
+`
+    }
+  };
+  return templates[templateType]?.[file] ?? "";
+}
+function applyTemplate(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+function getFileList(templateType) {
+  const base = ["__init__.py", "README.md", "config.json"];
+  if (templateType === "background") {
+    return ["main.py", "background.py", ...base];
+  }
+  if (templateType === "alarm") {
+    return ["main.py", "background.py", ...base];
+  }
+  return ["main.py", ...base];
+}
+function getTemplateOptions(category) {
+  if (category === "skill") {
+    return [
+      {
+        value: "basic",
+        label: "Basic",
+        hint: "Simple ability with speak + user_response"
+      },
+      {
+        value: "api",
+        label: "API",
+        hint: "Calls an external API using a stored secret"
+      },
+      {
+        value: "loop",
+        label: "Loop (ambient observer)",
+        hint: "Records audio periodically and checks in"
+      },
+      {
+        value: "email",
+        label: "Email",
+        hint: "Sends email via SMTP using stored credentials"
+      },
+      {
+        value: "readwrite",
+        label: "File Storage",
+        hint: "Reads and writes persistent JSON files"
+      },
+      {
+        value: "local",
+        label: "Local (DevKit)",
+        hint: "Executes commands on the local device via DevKit"
+      },
+      {
+        value: "openclaw",
+        label: "OpenClaw",
+        hint: "Forwards requests to the OpenClaw gateway"
+      }
+    ];
+  }
+  if (category === "brain") {
+    return [
+      {
+        value: "basic",
+        label: "Basic",
+        hint: "Simple ability with speak + user_response"
+      },
+      {
+        value: "api",
+        label: "API",
+        hint: "Calls an external API using a stored secret"
+      }
+    ];
+  }
+  return [
+    {
+      value: "background",
+      label: "Background (continuous)",
+      hint: "Runs a loop from session start, no trigger"
+    },
+    {
+      value: "alarm",
+      label: "Alarm (skill + daemon combo)",
+      hint: "Skill sets an alarm; background.py fires it"
+    }
+  ];
+}
+async function initCommand(nameArg) {
+  p.intro("Create a new OpenHome ability");
+  let name;
+  if (nameArg) {
+    name = nameArg.trim();
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+      error(
+        "Invalid name. Use lowercase letters, numbers, and hyphens only. Must start with a letter."
+      );
+      process.exit(1);
+    }
+  } else {
+    const nameInput = await p.text({
+      message: "What should your ability be called?",
+      placeholder: "my-cool-ability",
+      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. Must start with a letter.";
+      }
+    });
+    handleCancel(nameInput);
+    name = nameInput.trim();
+  }
+  const category = await p.select({
+    message: "What type of ability?",
+    options: [
+      {
+        value: "skill",
+        label: "Skill",
+        hint: "User-triggered, runs on demand (most common)"
+      },
+      {
+        value: "brain",
+        label: "Brain Skill",
+        hint: "Auto-triggered by the agent's intelligence"
+      },
+      {
+        value: "daemon",
+        label: "Background Daemon",
+        hint: "Runs continuously from session start"
+      }
+    ]
+  });
+  handleCancel(category);
+  const descInput = await p.text({
+    message: "Short description for the marketplace",
+    placeholder: "A fun ability that checks the weather",
+    validate: (val) => {
+      if (!val || !val.trim()) return "Description is required";
+    }
+  });
+  handleCancel(descInput);
+  const description = descInput.trim();
+  const templateOptions = getTemplateOptions(category);
+  const templateType = await p.select({
+    message: "Choose a template",
+    options: templateOptions
+  });
+  handleCancel(templateType);
+  const hotwordInput = await p.text({
+    message: DAEMON_TEMPLATES.has(templateType) ? "Trigger words (comma-separated, or leave empty for daemons)" : "Trigger words (comma-separated)",
+    placeholder: "check weather, weather please",
+    validate: (val) => {
+      if (!DAEMON_TEMPLATES.has(templateType)) {
+        if (!val || !val.trim()) return "At least one trigger word is required";
+      }
+    }
+  });
+  handleCancel(hotwordInput);
+  const hotwords = hotwordInput.split(",").map((h) => h.trim()).filter(Boolean);
+  const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
+  const home = homedir();
+  const candidateDirs = [
+    process.cwd(),
+    join2(home, "Desktop"),
+    join2(home, "Downloads"),
+    join2(home, "Pictures"),
+    join2(home, "Images"),
+    join2(home, ".openhome", "icons")
+  ];
+  if (process.env.USERPROFILE) {
+    candidateDirs.push(
+      join2(process.env.USERPROFILE, "Desktop"),
+      join2(process.env.USERPROFILE, "Downloads"),
+      join2(process.env.USERPROFILE, "Pictures")
+    );
+  }
+  const scanDirs = [...new Set(candidateDirs)];
+  const foundImages = [];
+  for (const dir of scanDirs) {
+    if (!existsSync2(dir)) continue;
+    try {
+      const files2 = readdirSync2(dir);
+      for (const file of files2) {
+        if (IMAGE_EXTS.has(extname(file).toLowerCase())) {
+          const full = join2(dir, file);
+          const shortDir = dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
+          foundImages.push({
+            path: full,
+            label: `${file}  (${shortDir})`
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  let iconSourcePath;
+  if (foundImages.length > 0) {
+    const imageOptions = [
+      ...foundImages.map((img) => ({ value: img.path, label: img.label })),
+      { value: "__custom__", label: "Other...", hint: "Enter a path manually" }
+    ];
+    const selected = await p.select({
+      message: "Select an icon image (PNG or JPG for marketplace)",
+      options: imageOptions
+    });
+    handleCancel(selected);
+    if (selected === "__custom__") {
+      const iconInput = await p.text({
+        message: "Path to icon image",
+        placeholder: "./icon.png",
+        validate: (val) => {
+          if (!val || !val.trim()) return "An icon image is required";
+          const resolved = resolve(val.trim());
+          if (!existsSync2(resolved)) return `File not found: ${val.trim()}`;
+          const ext = extname(resolved).toLowerCase();
+          if (!IMAGE_EXTS.has(ext)) return "Image must be PNG or JPG";
+        }
+      });
+      handleCancel(iconInput);
+      iconSourcePath = resolve(iconInput.trim());
+    } else {
+      iconSourcePath = selected;
+    }
+  } else {
+    const iconInput = await p.text({
+      message: "Path to icon image (PNG or JPG for marketplace)",
+      placeholder: "./icon.png",
+      validate: (val) => {
+        if (!val || !val.trim()) return "An icon image is required";
+        const resolved = resolve(val.trim());
+        if (!existsSync2(resolved)) return `File not found: ${val.trim()}`;
+        const ext = extname(resolved).toLowerCase();
+        if (!IMAGE_EXTS.has(ext)) return "Image must be PNG or JPG";
+      }
+    });
+    handleCancel(iconInput);
+    iconSourcePath = resolve(iconInput.trim());
+  }
+  const iconExt = extname(iconSourcePath).toLowerCase();
+  const iconFileName = iconExt === ".jpeg" ? "icon.jpg" : `icon${iconExt}`;
+  const abilitiesDir = resolve("abilities");
+  const targetDir = join2(abilitiesDir, name);
+  if (existsSync2(targetDir)) {
+    error(`Directory "abilities/${name}" already exists.`);
+    process.exit(1);
+  }
+  const confirmed = await p.confirm({
+    message: `Create ability "${name}" with ${hotwords.length} trigger word(s)?`
+  });
+  handleCancel(confirmed);
+  if (!confirmed) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  const s = p.spinner();
+  s.start("Generating ability files...");
+  mkdirSync(targetDir, { recursive: true });
+  const className = toClassName(name);
+  const displayName = name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+  const vars = {
+    CLASS_NAME: className,
+    UNIQUE_NAME: name,
+    DISPLAY_NAME: displayName,
+    DESCRIPTION: description,
+    CATEGORY: category,
+    HOTWORDS: JSON.stringify(hotwords),
+    HOTWORD_LIST: hotwords.length > 0 ? hotwords.map((h) => `- "${h}"`).join("\n") : "_None (daemon)_"
+  };
+  const resolvedTemplate = templateType;
+  const files = getFileList(resolvedTemplate);
+  for (const file of files) {
+    const content = applyTemplate(getTemplate(resolvedTemplate, file), vars);
+    writeFileSync(join2(targetDir, file), content, "utf8");
+  }
+  copyFileSync(iconSourcePath, join2(targetDir, iconFileName));
+  s.stop("Files generated.");
+  registerAbility(name, targetDir);
+  const result = validateAbility(targetDir);
+  if (result.passed) {
+    success("Validation passed.");
+  } else {
+    for (const issue of result.errors) {
+      error(`${issue.file ? `[${issue.file}] ` : ""}${issue.message}`);
+    }
+  }
+  for (const w of result.warnings) {
+    warn(`${w.file ? `[${w.file}] ` : ""}${w.message}`);
+  }
+  p.note(`cd abilities/${name}
+openhome deploy`, "Next steps");
+  p.outro(`Ability "${name}" is ready!`);
+}
+
+// src/commands/deploy.ts
+import { resolve as resolve2, join as join3, basename as basename2, extname as extname2 } from "path";
+import {
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync3,
+  readdirSync as readdirSync3
+} from "fs";
+import { homedir as homedir2 } from "os";
+
+// src/util/zip.ts
+import archiver from "archiver";
+import { createWriteStream } from "fs";
+import { Writable } from "stream";
+async function createAbilityZip(dirPath) {
+  return new Promise((resolve5, reject) => {
+    const chunks = [];
+    const writable = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+    writable.on("finish", () => {
+      resolve5(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);
+  });
+}
+
+// src/api/mock-client.ts
+var MOCK_PERSONALITIES = [
+  { id: "pers_alice", name: "Alice", description: "Friendly assistant" },
+  { id: "pers_bob", name: "Bob", description: "Technical expert" },
+  { id: "pers_cara", name: "Cara", description: "Creative companion" }
+];
+var MOCK_ABILITIES = [
+  {
+    ability_id: "abl_weather_001",
+    unique_name: "weather-check",
+    display_name: "Weather Check",
+    version: 3,
+    status: "active",
+    personality_ids: ["pers_alice", "pers_bob"],
+    created_at: "2026-01-10T12:00:00Z",
+    updated_at: "2026-03-01T09:30:00Z"
+  },
+  {
+    ability_id: "abl_timer_002",
+    unique_name: "pomodoro-timer",
+    display_name: "Pomodoro Timer",
+    version: 1,
+    status: "processing",
+    personality_ids: ["pers_cara"],
+    created_at: "2026-03-18T08:00:00Z",
+    updated_at: "2026-03-18T08:05:00Z"
+  },
+  {
+    ability_id: "abl_news_003",
+    unique_name: "news-briefing",
+    display_name: "News Briefing",
+    version: 2,
+    status: "failed",
+    personality_ids: [],
+    created_at: "2026-02-20T14:00:00Z",
+    updated_at: "2026-02-21T10:00:00Z"
+  }
+];
+var MockApiClient = class {
+  async getPersonalities() {
+    return Promise.resolve(MOCK_PERSONALITIES);
+  }
+  async uploadAbility(_zipBuffer, _imageBuffer, _imageName, _metadata) {
+    return Promise.resolve({
+      ability_id: `abl_mock_${Date.now()}`,
+      unique_name: "mock-ability",
+      version: 1,
+      status: "processing",
+      validation_errors: [],
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      message: "[MOCK] Ability uploaded successfully and is being processed."
+    });
+  }
+  async listAbilities() {
+    return Promise.resolve({ abilities: MOCK_ABILITIES });
+  }
+  async verifyApiKey(_apiKey) {
+    return Promise.resolve({
+      valid: true,
+      message: "[MOCK] API key is valid."
+    });
+  }
+  async deleteCapability(id) {
+    return Promise.resolve({
+      message: `[MOCK] Capability ${id} deleted successfully.`
+    });
+  }
+  async toggleCapability(id, enabled) {
+    return Promise.resolve({
+      enabled,
+      message: `[MOCK] Capability ${id} ${enabled ? "enabled" : "disabled"}.`
+    });
+  }
+  async assignCapabilities(personalityId, capabilityIds) {
+    return Promise.resolve({
+      message: `[MOCK] Agent ${personalityId} updated with ${capabilityIds.length} capability(s).`
+    });
+  }
+  async getAbility(id) {
+    const found = MOCK_ABILITIES.find(
+      (a) => a.ability_id === id || a.unique_name === id
+    );
+    const base = found ?? MOCK_ABILITIES[0];
+    return Promise.resolve({
+      ...base,
+      validation_errors: base.status === "failed" ? ["Missing resume_normal_flow() call in main.py"] : [],
+      deploy_history: [
+        {
+          version: base.version,
+          status: base.status === "active" ? "success" : "failed",
+          timestamp: base.updated_at,
+          message: base.status === "active" ? "Deployed successfully" : "Validation failed"
+        },
+        ...base.version > 1 ? [
+          {
+            version: base.version - 1,
+            status: "success",
+            timestamp: base.created_at,
+            message: "Deployed successfully"
+          }
+        ] : []
+      ]
+    });
+  }
+};
+
+// src/commands/deploy.ts
+var IMAGE_EXTENSIONS = ["png", "jpg", "jpeg"];
+var ICON_NAMES = IMAGE_EXTENSIONS.flatMap((ext) => [
+  `icon.${ext}`,
+  `image.${ext}`,
+  `logo.${ext}`
+]);
+function findIcon(dir) {
+  for (const name of ICON_NAMES) {
+    const p2 = join3(dir, name);
+    if (existsSync3(p2)) return p2;
+  }
+  return null;
+}
+async function resolveAbilityDir(pathArg) {
+  if (pathArg && pathArg !== ".") {
+    return resolve2(pathArg);
+  }
+  const tracked = getTrackedAbilities();
+  const cwd = process.cwd();
+  const cwdIsAbility = existsSync3(resolve2(cwd, "config.json"));
+  if (cwdIsAbility) {
+    info(`Detected ability in current directory`);
+    return cwd;
+  }
+  const options = [];
+  for (const a of tracked) {
+    const home = homedir2();
+    options.push({
+      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} (${options[0].hint})`);
+    return options[0].value;
+  }
+  if (options.length > 0) {
+    options.push({
+      value: "__custom__",
+      label: "Other...",
+      hint: "Enter a path manually"
+    });
+    const selected = await p.select({
+      message: "Which ability do you want to deploy?",
+      options
+    });
+    handleCancel(selected);
+    if (selected !== "__custom__") {
+      return selected;
+    }
+  }
+  const pathInput = await p.text({
+    message: "Path to ability directory",
+    placeholder: "./my-ability",
+    validate: (val) => {
+      if (!val || !val.trim()) return "Path is required";
+      if (!existsSync3(resolve2(val.trim(), "config.json"))) {
+        return `No config.json found in "${val.trim()}"`;
+      }
+    }
+  });
+  handleCancel(pathInput);
+  return resolve2(pathInput.trim());
+}
+async function deployCommand(pathArg, opts = {}) {
+  p.intro("\u{1F680} Deploy ability");
+  const targetDir = await resolveAbilityDir(pathArg);
+  const s = p.spinner();
+  s.start("Validating ability...");
+  const validation = validateAbility(targetDir);
+  if (!validation.passed) {
+    s.stop("Validation failed.");
+    for (const issue of validation.errors) {
+      error(`  ${issue.file ? `[${issue.file}] ` : ""}${issue.message}`);
+    }
+    process.exit(1);
+  }
+  s.stop("Validation passed.");
+  if (validation.warnings.length > 0) {
+    for (const w of validation.warnings) {
+      warn(`  ${w.file ? `[${w.file}] ` : ""}${w.message}`);
+    }
+  }
+  const configPath = join3(targetDir, "config.json");
+  let abilityConfig;
+  try {
+    abilityConfig = JSON.parse(
+      readFileSync2(configPath, "utf8")
+    );
+  } catch {
+    error("Could not read config.json");
+    process.exit(1);
+  }
+  const uniqueName = abilityConfig.unique_name;
+  const hotwords = abilityConfig.matching_hotwords ?? [];
+  let description = abilityConfig.description?.trim();
+  if (!description) {
+    const descInput = await p.text({
+      message: "Ability description (required for marketplace)",
+      placeholder: "A fun ability that does something cool",
+      validate: (val) => {
+        if (!val || !val.trim()) return "Description is required";
+      }
+    });
+    handleCancel(descInput);
+    description = descInput.trim();
+  }
+  let category = abilityConfig.category;
+  if (!category || !["skill", "brain", "daemon"].includes(category)) {
+    const catChoice = await p.select({
+      message: "Ability 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(catChoice);
+    category = catChoice;
+  }
+  let imagePath = findIcon(targetDir);
+  if (imagePath) {
+    info(`Found icon: ${basename2(imagePath)}`);
+  } else {
+    const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
+    const home = homedir2();
+    const scanDirs = [
+      .../* @__PURE__ */ new Set([
+        process.cwd(),
+        targetDir,
+        join3(home, "Desktop"),
+        join3(home, "Downloads"),
+        join3(home, "Pictures"),
+        join3(home, "Images"),
+        join3(home, ".openhome", "icons")
+      ])
+    ];
+    const foundImages = [];
+    for (const dir of scanDirs) {
+      if (!existsSync3(dir)) continue;
+      try {
+        for (const file of readdirSync3(dir)) {
+          if (IMAGE_EXTS.has(extname2(file).toLowerCase())) {
+            const full = join3(dir, file);
+            const shortDir = dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
+            foundImages.push({
+              path: full,
+              label: `${file}  (${shortDir})`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    if (foundImages.length > 0) {
+      const imageOptions = [
+        ...foundImages.map((img) => ({ value: img.path, label: img.label })),
+        {
+          value: "__custom__",
+          label: "Other...",
+          hint: "Enter a path manually"
+        },
+        {
+          value: "__skip__",
+          label: "Skip",
+          hint: "Upload without an icon (optional)"
+        }
+      ];
+      const selected = await p.select({
+        message: "Select an icon image (optional)",
+        options: imageOptions
+      });
+      handleCancel(selected);
+      if (selected === "__custom__") {
+        const imgInput = await p.text({
+          message: "Path to icon image",
+          placeholder: "./icon.png",
+          validate: (val) => {
+            if (!val || !val.trim()) return void 0;
+            const resolved = resolve2(val.trim());
+            if (!existsSync3(resolved)) return `File not found: ${val.trim()}`;
+            if (!IMAGE_EXTS.has(extname2(resolved).toLowerCase()))
+              return "Image must be PNG or JPG";
+          }
+        });
+        handleCancel(imgInput);
+        const trimmed = imgInput.trim();
+        if (trimmed) imagePath = resolve2(trimmed);
+      } else if (selected !== "__skip__") {
+        imagePath = selected;
+      }
+    } else {
+      const imgInput = await p.text({
+        message: "Path to ability icon image (PNG or JPG, optional \u2014 press Enter to skip)",
+        placeholder: "./icon.png",
+        validate: (val) => {
+          if (!val || !val.trim()) return void 0;
+          const resolved = resolve2(val.trim());
+          if (!existsSync3(resolved)) return `File not found: ${val.trim()}`;
+          if (!IMAGE_EXTS.has(extname2(resolved).toLowerCase()))
+            return "Image must be PNG or JPG";
+        }
+      });
+      handleCancel(imgInput);
+      const trimmed = imgInput.trim();
+      if (trimmed) imagePath = resolve2(trimmed);
+    }
+  }
+  const imageBuffer = imagePath ? readFileSync2(imagePath) : null;
+  const imageName = imagePath ? basename2(imagePath) : null;
+  const personalityId = opts.personality ?? getConfig().default_personality_id;
+  const metadata = {
+    name: uniqueName,
+    description,
+    category,
+    matching_hotwords: hotwords,
+    personality_id: personalityId
+  };
+  if (opts.dryRun) {
+    p.note(
+      [
+        `Directory:   ${targetDir}`,
+        `Name:        ${uniqueName}`,
+        `Description: ${description}`,
+        `Category:    ${category}`,
+        `Image:       ${imageName ?? "(none)"}`,
+        `Hotwords:    ${hotwords.join(", ")}`,
+        `Agent:       ${personalityId ?? "(none set)"}`
+      ].join("\n"),
+      "Dry Run \u2014 would deploy"
+    );
+    p.outro("No changes made.");
+    return;
+  }
+  s.start("Creating ability zip...");
+  let zipBuffer;
+  try {
+    zipBuffer = await createAbilityZip(targetDir);
+    s.stop(`Zip created (${(zipBuffer.length / 1024).toFixed(1)} KB)`);
+  } catch (err) {
+    s.stop("Failed to create zip.");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  if (opts.mock) {
+    s.start("Uploading ability (mock)...");
+    const mockClient = new MockApiClient();
+    const result = await mockClient.uploadAbility(
+      zipBuffer,
+      imageBuffer,
+      imageName,
+      metadata
+    );
+    s.stop("Upload complete.");
+    p.note(
+      [
+        `Ability ID: ${result.ability_id}`,
+        `Status:     ${result.status}`,
+        `Message:    ${result.message}`
+      ].join("\n"),
+      "Mock Deploy Result"
+    );
+    p.outro("Mock deploy complete.");
+    return;
+  }
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated. Run: openhome login");
+    process.exit(1);
+  }
+  const confirmed = await p.confirm({
+    message: `Deploy "${uniqueName}" to OpenHome?`
+  });
+  handleCancel(confirmed);
+  if (!confirmed) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  s.start("Uploading ability...");
+  try {
+    const client = new ApiClient(apiKey, getConfig().api_base_url);
+    const result = await client.uploadAbility(
+      zipBuffer,
+      imageBuffer,
+      imageName,
+      metadata
+    );
+    s.stop("Upload complete.");
+    p.note(
+      [
+        `Ability ID: ${result.ability_id}`,
+        `Version:    ${result.version}`,
+        `Status:     ${result.status}`,
+        result.message ? `Message:    ${result.message}` : ""
+      ].filter(Boolean).join("\n"),
+      "Deploy Result"
+    );
+    p.outro("Deployed successfully! \u{1F389}");
+  } catch (err) {
+    s.stop("Upload failed.");
+    if (err instanceof NotImplementedError) {
+      warn("This API endpoint is not yet available on the OpenHome server.");
+      const outDir = join3(homedir2(), ".openhome");
+      mkdirSync2(outDir, { recursive: true });
+      const outPath = join3(outDir, "last-deploy.zip");
+      writeFileSync2(outPath, zipBuffer);
+      p.note(
+        [
+          `Your ability was validated and zipped successfully.`,
+          `Zip saved to: ${outPath}`,
+          ``,
+          `Upload manually at https://app.openhome.com`
+        ].join("\n"),
+        "API Not Available Yet"
+      );
+      p.outro("Zip ready for manual upload.");
+      return;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.toLowerCase().includes("same name")) {
+      error(`An ability named "${uniqueName}" already exists.`);
+      warn(
+        `To update it, delete it first with: openhome delete
+Or rename it in config.json and redeploy.`
+      );
+    } else {
+      error(`Deploy failed: ${msg}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/delete.ts
+import chalk3 from "chalk";
+async function deleteCommand(abilityArg, opts = {}) {
+  p.intro("\u{1F5D1}\uFE0F  Delete ability");
+  let client;
+  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...");
+  let 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;
+  }
+  let targetId;
+  let targetName;
+  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: `${chalk3.gray(a.status)}  v${a.version}`
+      }))
+    });
+    handleCancel(selected);
+    targetId = selected;
+    targetName = abilities.find((a) => a.ability_id === targetId)?.unique_name ?? targetId;
+  }
+  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);
+  }
+}
+
+// src/commands/toggle.ts
+import chalk4 from "chalk";
+async function toggleCommand(abilityArg, opts = {}) {
+  p.intro("\u26A1 Enable / Disable ability");
+  let client;
+  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...");
+  let 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;
+  }
+  let targetId;
+  let targetName;
+  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" ? chalk4.gray("disabled") : chalk4.green("enabled")}  v${a.version}`
+      }))
+    });
+    handleCancel(selected);
+    targetId = selected;
+    targetName = abilities.find((a) => a.ability_id === targetId)?.unique_name ?? targetId;
+  }
+  let enabled;
+  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);
+  }
+}
+
+// src/commands/assign.ts
+import chalk5 from "chalk";
+async function assignCommand(opts = {}) {
+  p.intro("\u{1F517} Assign abilities to agent");
+  let client;
+  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;
+  let 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;
+  }
+  const agentId = await p.select({
+    message: "Which agent do you want to update?",
+    options: personalities.map((pers) => ({
+      value: pers.id,
+      label: pers.name,
+      hint: chalk5.gray(pers.id)
+    }))
+  });
+  handleCancel(agentId);
+  const agentName = personalities.find((p2) => p2.id === agentId)?.name ?? String(agentId);
+  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;
+  const numericIds = chosenIds.map((id) => Number(id)).filter((id) => !Number.isNaN(id));
+  const capabilityIds = numericIds.length === chosenIds.length ? numericIds : chosenIds;
+  s.start(`Assigning ${chosenIds.length} ability(s) to "${agentName}"...`);
+  try {
+    const result = await client.assignCapabilities(
+      agentId,
+      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);
+  }
+}
+
+// src/commands/list.ts
+import chalk6 from "chalk";
+function statusColor(status) {
+  switch (status) {
+    case "active":
+      return chalk6.green(status);
+    case "processing":
+      return chalk6.yellow(status);
+    case "failed":
+      return chalk6.red(status);
+    case "disabled":
+      return chalk6.gray(status);
+    default:
+      return status;
+  }
+}
+async function listCommand(opts = {}) {
+  p.intro("\u{1F4CB} Your abilities");
+  let client;
+  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 = 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);
+  }
+}
+
+// src/commands/status.ts
+import { join as join4, resolve as resolve3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import chalk7 from "chalk";
+function statusBadge(status) {
+  switch (status) {
+    case "active":
+      return chalk7.bgGreen.black(` ${status.toUpperCase()} `);
+    case "processing":
+      return chalk7.bgYellow.black(` ${status.toUpperCase()} `);
+    case "failed":
+      return chalk7.bgRed.white(` ${status.toUpperCase()} `);
+    case "disabled":
+      return chalk7.bgGray.white(` ${status.toUpperCase()} `);
+    default:
+      return chalk7.bgWhite.black(` ${status.toUpperCase()} `);
+  }
+}
+function readAbilityName(dir) {
+  const configPath = join4(dir, "config.json");
+  if (!existsSync4(configPath)) return null;
+  try {
+    const cfg = JSON.parse(readFileSync3(configPath, "utf8"));
+    return cfg.unique_name ?? null;
+  } catch {
+    return null;
+  }
+}
+async function resolveAbilityName() {
+  const cwdName = readAbilityName(resolve3("."));
+  if (cwdName) {
+    info(`Detected ability: ${cwdName}`);
+    return cwdName;
+  }
+  const tracked = getTrackedAbilities();
+  const options = [];
+  const home = homedir3();
+  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;
+  }
+  return void 0;
+}
+async function statusCommand(abilityArg, opts = {}) {
+  let abilityId = abilityArg;
+  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(`\u{1F50D} Status: ${abilityId}`);
+  let client;
+  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.");
+    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"
+    );
+    if (ability.validation_errors.length > 0) {
+      p.note(
+        ability.validation_errors.map((e) => chalk7.red(`\u2717 ${e}`)).join("\n"),
+        "Validation Errors"
+      );
+    }
+    if (ability.deploy_history.length > 0) {
+      const historyLines = ability.deploy_history.map((event) => {
+        const icon = event.status === "success" ? chalk7.green("\u2713") : chalk7.red("\u2717");
+        return `${icon}  v${event.version}  ${event.message}  ${chalk7.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);
+  }
+}
+
+// src/commands/agents.ts
+import chalk8 from "chalk";
+async function agentsCommand(opts = {}) {
+  p.intro("\u{1F916} Your Agents");
+  let client;
+  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) => `${chalk8.bold(pers.name)}  ${chalk8.gray(pers.id)}`).join("\n"),
+      "Agents"
+    );
+    const config = getConfig();
+    const currentDefault = config.default_personality_id;
+    if (currentDefault) {
+      const match = personalities.find((p2) => p2.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;
+      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);
+  }
+}
+
+// src/commands/logout.ts
+async function logoutCommand() {
+  keychainDelete();
+  const config = getConfig();
+  delete config.api_key;
+  delete config.default_personality_id;
+  saveConfig(config);
+  success("Logged out. API key and default agent cleared.");
+}
+
+// src/commands/chat.ts
+import WebSocket from "ws";
+import chalk9 from "chalk";
+import * as readline from "readline";
+var PING_INTERVAL = 3e4;
+async function chatCommand(agentArg, opts = {}) {
+  p.intro("\u{1F4AC} Chat with your agent");
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated. Run: openhome login");
+    process.exit(1);
+  }
+  let agentId = agentArg ?? 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. 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;
+    } 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(`Connecting to agent ${chalk9.bold(agentId)}...`);
+  await new Promise((resolve5) => {
+    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 = "";
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    function promptUser() {
+      rl.question(chalk9.green("You: "), (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          promptUser();
+          return;
+        }
+        if (trimmed === "/quit" || trimmed === "/exit" || trimmed === "/q") {
+          info("Closing connection...");
+          ws.close(1e3);
+          rl.close();
+          return;
+        }
+        if (!connected) {
+          error("Not connected yet. Please wait...");
+          promptUser();
+          return;
+        }
+        ws.send(
+          JSON.stringify({
+            type: "transcribed",
+            data: trimmed
+          })
+        );
+        promptUser();
+      });
+    }
+    let pingInterval = null;
+    ws.on("open", () => {
+      connected = true;
+      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(
+        chalk9.gray(
+          "  Tip: Send trigger words to activate abilities (e.g. 'play aquaprime')"
+        )
+      );
+      console.log("");
+      promptUser();
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        switch (msg.type) {
+          case "message": {
+            const data = msg.data;
+            if (data.content && data.role === "assistant") {
+              if (data.live && !data.final) {
+                const prefix = `${chalk9.cyan("Agent:")} `;
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write(`${prefix}${data.content}`);
+                currentResponse = data.content;
+              } else {
+                if (currentResponse !== "") {
+                  console.log("");
+                } else {
+                  console.log(`${chalk9.cyan("Agent:")} ${data.content}`);
+                }
+                currentResponse = "";
+                console.log("");
+              }
+            }
+            break;
+          }
+          case "text": {
+            const textData = msg.data;
+            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 (currentResponse === "") {
+                console.log(
+                  chalk9.gray("  (Agent sent audio \u2014 text-only mode)")
+                );
+                console.log("");
+              }
+            }
+            break;
+          }
+          case "audio":
+            ws.send(JSON.stringify({ type: "ack", data: "audio-received" }));
+            break;
+          case "error-event": {
+            const errData = msg.data;
+            const errMsg = errData?.message || errData?.title || "Unknown error";
+            error(`Server error: ${errMsg}`);
+            break;
+          }
+          case "interrupt":
+            if (currentResponse !== "") {
+              console.log("");
+              currentResponse = "";
+            }
+            break;
+          case "action":
+          case "log":
+          case "question":
+          case "progress":
+            break;
+          default:
+            break;
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      console.error("");
+      error(`WebSocket error: ${err.message}`);
+      rl.close();
+      resolve5();
+    });
+    ws.on("close", (code) => {
+      if (pingInterval) clearInterval(pingInterval);
+      console.log("");
+      if (code === 1e3) {
+        info("Disconnected.");
+      } else {
+        info(`Connection closed (code: ${code})`);
+      }
+      rl.close();
+      resolve5();
+    });
+    rl.on("close", () => {
+      if (connected) {
+        ws.close(1e3);
+      }
+    });
+  });
+}
+
+// src/commands/trigger.ts
+import WebSocket2 from "ws";
+import chalk10 from "chalk";
+var PING_INTERVAL2 = 3e4;
+var RESPONSE_TIMEOUT = 3e4;
+async function triggerCommand(phraseArg, opts = {}) {
+  p.intro("\u26A1 Trigger an ability");
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated. Run: openhome login");
+    process.exit(1);
+  }
+  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.trim();
+  }
+  let agentId = opts.agent ?? getConfig().default_personality_id;
+  if (!agentId) {
+    const s2 = p.spinner();
+    s2.start("Fetching agents...");
+    try {
+      const client = new ApiClient(apiKey);
+      const agents = await client.getPersonalities();
+      s2.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;
+    } catch (err) {
+      s2.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(`Sending "${chalk10.bold(phrase)}" to agent ${chalk10.bold(agentId)}...`);
+  const s = p.spinner();
+  s.start("Waiting for response...");
+  await new Promise((resolve5) => {
+    const ws = new WebSocket2(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 = null;
+    let pingInterval = null;
+    function cleanup() {
+      if (pingInterval) clearInterval(pingInterval);
+      if (responseTimer) clearTimeout(responseTimer);
+      if (ws.readyState === WebSocket2.OPEN) ws.close(1e3);
+    }
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ type: "transcribed", data: phrase }));
+      pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket2.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, PING_INTERVAL2);
+      responseTimer = setTimeout(() => {
+        s.stop("Timed out waiting for response.");
+        if (fullResponse) {
+          console.log(`
+${chalk10.cyan("Agent:")} ${fullResponse}`);
+        }
+        cleanup();
+        resolve5();
+      }, RESPONSE_TIMEOUT);
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        switch (msg.type) {
+          case "message": {
+            const data = msg.data;
+            if (data.content && data.role === "assistant") {
+              fullResponse += data.content;
+              if (!data.live || data.final) {
+                s.stop("Response received.");
+                console.log(`
+${chalk10.cyan("Agent:")} ${fullResponse}
+`);
+                cleanup();
+                resolve5();
+              }
+            }
+            break;
+          }
+          case "text": {
+            const textData = msg.data;
+            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(`
+${chalk10.cyan("Agent:")} ${fullResponse}
+`);
+                cleanup();
+                resolve5();
+              }
+            }
+            break;
+          }
+          case "audio":
+            ws.send(JSON.stringify({ type: "ack", data: "audio-received" }));
+            break;
+          case "error-event": {
+            const errData = msg.data;
+            s.stop("Error.");
+            error(
+              `Server error: ${errData?.message || errData?.title || "Unknown"}`
+            );
+            cleanup();
+            resolve5();
+            break;
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      s.stop("Connection error.");
+      error(err.message);
+      resolve5();
+    });
+    ws.on("close", () => {
+      if (pingInterval) clearInterval(pingInterval);
+      if (responseTimer) clearTimeout(responseTimer);
+      resolve5();
+    });
+  });
+}
+
+// src/commands/whoami.ts
+import chalk11 from "chalk";
+import { homedir as homedir4 } from "os";
+async function whoamiCommand() {
+  p.intro("\u{1F464} OpenHome CLI Status");
+  const apiKey = getApiKey();
+  const config = getConfig();
+  const tracked = getTrackedAbilities();
+  const home = homedir4();
+  if (apiKey) {
+    const masked = apiKey.slice(0, 6) + "..." + apiKey.slice(-4);
+    info(`Authenticated: ${chalk11.green("yes")}  (key: ${chalk11.gray(masked)})`);
+  } else {
+    info(
+      `Authenticated: ${chalk11.red("no")}  \u2014 run ${chalk11.bold("openhome login")}`
+    );
+  }
+  if (config.default_personality_id) {
+    info(`Default agent: ${chalk11.bold(config.default_personality_id)}`);
+  } else {
+    info(
+      `Default agent: ${chalk11.gray("not set")}  \u2014 run ${chalk11.bold("openhome agents")}`
+    );
+  }
+  if (config.api_base_url) {
+    info(`API base: ${config.api_base_url}`);
+  }
+  if (tracked.length > 0) {
+    const lines = tracked.map((a) => {
+      const shortPath = a.path.startsWith(home) ? `~${a.path.slice(home.length)}` : a.path;
+      return `  ${chalk11.bold(a.name)}  ${chalk11.gray(shortPath)}`;
+    });
+    p.note(lines.join("\n"), `${tracked.length} tracked ability(s)`);
+  } else {
+    info(
+      `Tracked abilities: ${chalk11.gray("none")}  \u2014 run ${chalk11.bold("openhome init")}`
+    );
+  }
+  p.outro("Done.");
+}
+
+// src/commands/config-edit.ts
+import { join as join5, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+async function resolveDir() {
+  const cwd = resolve4(".");
+  if (existsSync5(join5(cwd, "config.json"))) {
+    info("Detected ability in current directory");
+    return cwd;
+  }
+  const tracked = getTrackedAbilities();
+  const home = homedir5();
+  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;
+  }
+  return void 0;
+}
+async function configEditCommand(pathArg) {
+  p.intro("\u2699\uFE0F  Edit ability config");
+  const dir = pathArg ? resolve4(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 = join5(dir, "config.json");
+  if (!existsSync5(configPath)) {
+    error(`No config.json found in ${dir}`);
+    process.exit(1);
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync4(configPath, "utf8"));
+  } catch {
+    error("Failed to parse config.json");
+    process.exit(1);
+  }
+  p.note(
+    [
+      `Name:        ${config.unique_name}`,
+      `Description: ${config.description}`,
+      `Category:    ${config.category}`,
+      `Triggers:    ${config.matching_hotwords.join(", ")}`
+    ].join("\n"),
+    "Current config"
+  );
+  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.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.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;
+      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.trim();
+      break;
+    }
+  }
+  writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+  success(`Updated ${field} in config.json`);
+  p.outro("Done.");
+}
+
+// src/commands/logs.ts
+import WebSocket3 from "ws";
+import chalk12 from "chalk";
+var PING_INTERVAL3 = 3e4;
+async function logsCommand(opts = {}) {
+  p.intro("\u{1F4E1} 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;
+    } 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 ${chalk12.bold(agentId)}...`);
+  info(`Press ${chalk12.bold("Ctrl+C")} to stop.
+`);
+  await new Promise((resolve5) => {
+    const ws = new WebSocket3(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 = null;
+    ws.on("open", () => {
+      success("Connected. Waiting for messages...\n");
+      pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket3.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, PING_INTERVAL3);
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        const ts = chalk12.gray((/* @__PURE__ */ new Date()).toLocaleTimeString());
+        switch (msg.type) {
+          case "log":
+            console.log(
+              `${ts} ${chalk12.blue("[LOG]")} ${JSON.stringify(msg.data)}`
+            );
+            break;
+          case "action":
+            console.log(
+              `${ts} ${chalk12.magenta("[ACTION]")} ${JSON.stringify(msg.data)}`
+            );
+            break;
+          case "progress":
+            console.log(
+              `${ts} ${chalk12.yellow("[PROGRESS]")} ${JSON.stringify(msg.data)}`
+            );
+            break;
+          case "question":
+            console.log(
+              `${ts} ${chalk12.cyan("[QUESTION]")} ${JSON.stringify(msg.data)}`
+            );
+            break;
+          case "message": {
+            const data = msg.data;
+            if (data.content && !data.live) {
+              const role = data.role === "assistant" ? chalk12.cyan("AGENT") : chalk12.green("USER");
+              console.log(`${ts} ${chalk12.white(`[${role}]`)} ${data.content}`);
+            }
+            break;
+          }
+          case "text": {
+            const textData = msg.data;
+            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;
+            console.log(
+              `${ts} ${chalk12.red("[ERROR]")} ${errData?.message || errData?.title || JSON.stringify(msg.data)}`
+            );
+            break;
+          }
+          default:
+            console.log(
+              `${ts} ${chalk12.gray(`[${msg.type}]`)} ${JSON.stringify(msg.data)}`
+            );
+            break;
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      error(`WebSocket error: ${err.message}`);
+      resolve5();
+    });
+    ws.on("close", (code) => {
+      if (pingInterval) clearInterval(pingInterval);
+      console.log("");
+      info(`Connection closed (code: ${code})`);
+      resolve5();
+    });
+    process.on("SIGINT", () => {
+      console.log("");
+      info("Stopping log stream...");
+      ws.close(1e3);
+    });
+  });
+}
+
+// src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var version = "0.1.0";
+try {
+  const pkg = JSON.parse(
+    readFileSync5(join6(__dirname, "..", "package.json"), "utf8")
+  );
+  version = pkg.version ?? version;
+} catch {
+}
+async function ensureLoggedIn() {
+  const { getApiKey: getApiKey2 } = await import("./store-DR7EKQ5T.js");
+  const key = getApiKey2();
+  if (!key) {
+    await loginCommand();
+    console.log("");
+  }
+}
+async function interactiveMenu() {
+  p.intro(`\u{1F3E0} OpenHome CLI v${version}`);
+  await ensureLoggedIn();
+  let running = true;
+  while (running) {
+    const choice = await p.select({
+      message: "What would you like to do?",
+      options: [
+        {
+          value: "init",
+          label: "\u2728  Create Ability",
+          hint: "Scaffold a new ability from templates"
+        },
+        {
+          value: "deploy",
+          label: "\u{1F680}  Deploy",
+          hint: "Upload ability to OpenHome"
+        },
+        {
+          value: "chat",
+          label: "\u{1F4AC}  Chat",
+          hint: "Talk to your agent"
+        },
+        {
+          value: "trigger",
+          label: "\u26A1  Trigger",
+          hint: "Fire an ability remotely with a phrase"
+        },
+        {
+          value: "list",
+          label: "\u{1F4CB}  My Abilities",
+          hint: "List deployed abilities"
+        },
+        {
+          value: "delete",
+          label: "\u{1F5D1}\uFE0F   Delete Ability",
+          hint: "Remove a deployed ability"
+        },
+        {
+          value: "toggle",
+          label: "\u26A1  Enable / Disable",
+          hint: "Toggle an ability on or off"
+        },
+        {
+          value: "assign",
+          label: "\u{1F517}  Assign to Agent",
+          hint: "Link abilities to an agent"
+        },
+        {
+          value: "agents",
+          label: "\u{1F916}  My Agents",
+          hint: "View agents and set default"
+        },
+        {
+          value: "status",
+          label: "\u{1F50D}  Status",
+          hint: "Check ability status"
+        },
+        {
+          value: "config",
+          label: "\u2699\uFE0F   Edit Config",
+          hint: "Update trigger words, description, category"
+        },
+        {
+          value: "logs",
+          label: "\u{1F4E1}  Logs",
+          hint: "Stream live agent messages"
+        },
+        {
+          value: "whoami",
+          label: "\u{1F464}  Who Am I",
+          hint: "Show auth, default agent, tracked abilities"
+        },
+        {
+          value: "logout",
+          label: "\u{1F513}  Log Out",
+          hint: "Clear credentials and re-authenticate"
+        },
+        { value: "exit", label: "\u{1F44B}  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("");
+    }
+  }
+  p.outro("See you next time!");
+}
+var program = new Command();
+program.name("openhome").description("OpenHome CLI \u2014 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) => {
+  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, opts) => {
+    await deployCommand(path, opts);
+  }
+);
+program.command("chat [agent]").description("Chat with an agent via WebSocket").action(async (agent) => {
+  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, opts) => {
+  await triggerCommand(phrase, opts);
+});
+program.command("list").description("List all deployed abilities").option("--mock", "Use mock API client").action(async (opts) => {
+  await listCommand(opts);
+});
+program.command("delete [ability]").description("Delete a deployed ability").option("--mock", "Use mock API client").action(async (ability, opts) => {
+  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, opts) => {
+    await toggleCommand(ability, opts);
+  }
+);
+program.command("assign").description("Assign abilities to an agent").option("--mock", "Use mock API client").action(async (opts) => {
+  await assignCommand(opts);
+});
+program.command("agents").description("View your agents and set a default").option("--mock", "Use mock API client").action(async (opts) => {
+  await agentsCommand(opts);
+});
+program.command("status [ability]").description("Show detailed status of an ability").option("--mock", "Use mock API client").action(async (ability, opts) => {
+  await statusCommand(ability, opts);
+});
+program.command("config [path]").description("Edit trigger words, description, or category in config.json").action(async (path) => {
+  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) => {
+  await logsCommand(opts);
+});
+program.command("whoami").description("Show auth status, default agent, and tracked abilities").action(async () => {
+  await whoamiCommand();
+});
+if (process.argv.length <= 2) {
+  interactiveMenu().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+} else {
+  program.parseAsync(process.argv).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}