openhome-cli 0.1.0

package/dist/store-DR7EKQ5T.js

@@ -0,0 +1,16 @@
+import {
+  getApiKey,
+  getConfig,
+  getTrackedAbilities,
+  registerAbility,
+  saveApiKey,
+  saveConfig
+} from "./chunk-Q4UKUXDB.js";
+export {
+  getApiKey,
+  getConfig,
+  getTrackedAbilities,
+  registerAbility,
+  saveApiKey,
+  saveConfig
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "openhome-cli",
+  "version": "0.1.0",
+  "description": "CLI for managing OpenHome voice AI abilities",
+  "type": "module",
+  "bin": {
+    "openhome": "./bin/openhome.js"
+  },
+  "main": "dist/cli.js",
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --dts --clean",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "openhome",
+    "voice",
+    "ai",
+    "cli",
+    "abilities"
+  ],
+  "author": "Bradymck <mckmuze@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "archiver": "^7.0.1",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.3",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.9"
+  }
+}

package/src/api/client.ts

@@ -0,0 +1,231 @@
+import type {
+  GetPersonalitiesResponse,
+  Personality,
+  UploadAbilityResponse,
+  UploadAbilityMetadata,
+  ListAbilitiesResponse,
+  GetAbilityResponse,
+  ApiErrorResponse,
+  VerifyApiKeyResponse,
+  DeleteCapabilityResponse,
+  ToggleCapabilityResponse,
+  AssignCapabilitiesResponse,
+} from "./contracts.js";
+import { API_BASE, ENDPOINTS } from "./endpoints.js";
+
+export class NotImplementedError extends Error {
+  constructor(endpoint: string) {
+    super(`API endpoint not yet implemented: ${endpoint}`);
+    this.name = "NotImplementedError";
+  }
+}
+
+export class ApiError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+    public readonly details?: Record<string, unknown>,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+export interface IApiClient {
+  getPersonalities(): Promise<Personality[]>;
+  verifyApiKey(apiKey: string): Promise<VerifyApiKeyResponse>;
+  uploadAbility(
+    zipBuffer: Buffer,
+    imageBuffer: Buffer | null,
+    imageName: string | null,
+    metadata: UploadAbilityMetadata,
+  ): Promise<UploadAbilityResponse>;
+  listAbilities(): Promise<ListAbilitiesResponse>;
+  getAbility(id: string): Promise<GetAbilityResponse>;
+  deleteCapability(id: string): Promise<DeleteCapabilityResponse>;
+  toggleCapability(
+    id: string,
+    enabled: boolean,
+  ): Promise<ToggleCapabilityResponse>;
+  assignCapabilities(
+    personalityId: string,
+    capabilityIds: number[],
+  ): Promise<AssignCapabilitiesResponse>;
+}
+
+export class ApiClient implements IApiClient {
+  private readonly baseUrl: string;
+
+  constructor(
+    private readonly apiKey: string,
+    baseUrl?: string,
+  ) {
+    this.baseUrl = baseUrl ?? API_BASE;
+    if (!this.baseUrl.startsWith("https://")) {
+      throw new Error("API base URL must use HTTPS. Got: " + this.baseUrl);
+    }
+  }
+
+  private async request<T>(
+    path: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        ...(options.headers ?? {}),
+      },
+    });
+
+    if (!response.ok) {
+      let body: ApiErrorResponse | null = null;
+      try {
+        body = (await response.json()) as ApiErrorResponse;
+      } catch {
+        // ignore parse errors
+      }
+
+      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() as Promise<T>;
+  }
+
+  async getPersonalities(): Promise<Personality[]> {
+    const data = await this.request<GetPersonalitiesResponse>(
+      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: Buffer,
+    imageBuffer: Buffer | null,
+    imageName: string | null,
+    metadata: UploadAbilityMetadata,
+  ): Promise<UploadAbilityResponse> {
+    const form = new FormData();
+    form.append(
+      "zip_file",
+      new Blob([zipBuffer as unknown as ArrayBuffer], {
+        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 as unknown as ArrayBuffer], { 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<UploadAbilityResponse>(ENDPOINTS.uploadCapability, {
+      method: "POST",
+      body: form,
+    });
+  }
+
+  async listAbilities(): Promise<ListAbilitiesResponse> {
+    return this.request<ListAbilitiesResponse>(ENDPOINTS.listCapabilities, {
+      method: "GET",
+    });
+  }
+
+  async getAbility(id: string): Promise<GetAbilityResponse> {
+    return this.request<GetAbilityResponse>(ENDPOINTS.getCapability(id), {
+      method: "GET",
+    });
+  }
+
+  async verifyApiKey(apiKey: string): Promise<VerifyApiKeyResponse> {
+    return this.request<VerifyApiKeyResponse>(ENDPOINTS.verifyApiKey, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ api_key: apiKey }),
+    });
+  }
+
+  async deleteCapability(id: string): Promise<DeleteCapabilityResponse> {
+    // Try the new bulk POST endpoint first (staging → production soon).
+    // Falls back to the legacy DELETE endpoint automatically if the new one
+    // isn't live yet (404 or NOT_IMPLEMENTED). Once the new endpoint is
+    // fully deployed, the fallback becomes unreachable dead code.
+    try {
+      return await this.request<DeleteCapabilityResponse>(
+        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) {
+        // New endpoint not live yet — fall back to legacy DELETE
+        return this.request<DeleteCapabilityResponse>(
+          ENDPOINTS.deleteCapability(id),
+          { method: "DELETE" },
+        );
+      }
+      throw err;
+    }
+  }
+
+  async toggleCapability(
+    id: string,
+    enabled: boolean,
+  ): Promise<ToggleCapabilityResponse> {
+    return this.request<ToggleCapabilityResponse>(
+      ENDPOINTS.editInstalledCapability(id),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ enabled }),
+      },
+    );
+  }
+
+  async assignCapabilities(
+    personalityId: string,
+    capabilityIds: number[],
+  ): Promise<AssignCapabilitiesResponse> {
+    return this.request<AssignCapabilitiesResponse>(ENDPOINTS.editPersonality, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        personality_id: personalityId,
+        matching_capabilities: capabilityIds,
+      }),
+    });
+  }
+}

package/src/api/contracts.ts

@@ -0,0 +1,103 @@
+// Existing endpoints
+
+export interface GetPersonalitiesRequest {
+  api_key: string;
+  with_image?: boolean;
+}
+
+export interface Personality {
+  id: string;
+  name: string;
+  description?: string;
+  image?: string;
+}
+
+export interface GetPersonalitiesResponse {
+  personalities: Personality[];
+}
+
+// Upload request metadata
+export type AbilityCategory = "skill" | "brain" | "daemon";
+
+export interface UploadAbilityMetadata {
+  name: string;
+  description: string;
+  category: AbilityCategory;
+  matching_hotwords: string[];
+  personality_id?: string;
+}
+
+export interface UploadAbilityResponse {
+  ability_id: string;
+  unique_name: string;
+  version: number;
+  status: "processing" | "active" | "failed";
+  validation_errors: string[];
+  created_at: string;
+  message: string;
+}
+
+export interface AbilitySummary {
+  ability_id: string;
+  unique_name: string;
+  display_name: string;
+  version: number;
+  status: "processing" | "active" | "failed" | "disabled";
+  personality_ids: string[];
+  created_at: string;
+  updated_at: string;
+}
+
+export interface ListAbilitiesResponse {
+  abilities: AbilitySummary[];
+}
+
+export interface GetAbilityResponse extends AbilitySummary {
+  validation_errors: string[];
+  deploy_history: DeployEvent[];
+}
+
+export interface DeployEvent {
+  version: number;
+  status: "success" | "failed";
+  timestamp: string;
+  message: string;
+}
+
+export interface ApiErrorResponse {
+  error: {
+    code:
+      | "UNAUTHORIZED"
+      | "VALIDATION_FAILED"
+      | "NOT_FOUND"
+      | "NOT_IMPLEMENTED";
+    message: string;
+    details?: Record<string, unknown>;
+  };
+}
+
+// Verify API key
+export interface VerifyApiKeyResponse {
+  valid: boolean;
+  message?: string;
+}
+
+// Delete capability
+export interface DeleteCapabilityResponse {
+  message?: string;
+}
+
+// Toggle capability enabled/disabled
+export interface ToggleCapabilityResponse {
+  enabled?: boolean;
+  message?: string;
+}
+
+// Assign capabilities to a personality
+export interface AssignCapabilitiesRequest {
+  matching_capabilities: number[];
+}
+
+export interface AssignCapabilitiesResponse {
+  message?: string;
+}

package/src/api/endpoints.ts

@@ -0,0 +1,19 @@
+export const API_BASE = "https://app.openhome.com";
+
+export const WS_BASE = "wss://app.openhome.com";
+
+export const ENDPOINTS = {
+  getPersonalities: "/api/sdk/get_personalities",
+  verifyApiKey: "/api/sdk/verify_apikey/",
+  uploadCapability: "/api/capabilities/add-capability/",
+  listCapabilities: "/api/capabilities/get-all-capability/",
+  getCapability: (id: string) => `/api/capabilities/get-capability/${id}/`,
+  deleteCapability: (id: string) =>
+    `/api/capabilities/delete-capability/${id}/`,
+  bulkDeleteCapabilities: "/api/capabilities/delete-capability/",
+  editInstalledCapability: (id: string) =>
+    `/api/capabilities/edit-installed-capability/${id}/`,
+  editPersonality: "/api/personalities/edit-personality/",
+  voiceStream: (apiKey: string, agentId: string) =>
+    `/websocket/voice-stream/${apiKey}/${agentId}`,
+} as const;

package/src/api/mock-client.ts

@@ -0,0 +1,145 @@
+import type {
+  Personality,
+  UploadAbilityResponse,
+  UploadAbilityMetadata,
+  ListAbilitiesResponse,
+  GetAbilityResponse,
+  VerifyApiKeyResponse,
+  DeleteCapabilityResponse,
+  ToggleCapabilityResponse,
+  AssignCapabilitiesResponse,
+} from "./contracts.js";
+import type { IApiClient } from "./client.js";
+
+const MOCK_PERSONALITIES: Personality[] = [
+  { id: "pers_alice", name: "Alice", description: "Friendly assistant" },
+  { id: "pers_bob", name: "Bob", description: "Technical expert" },
+  { id: "pers_cara", name: "Cara", description: "Creative companion" },
+];
+
+const MOCK_ABILITIES = [
+  {
+    ability_id: "abl_weather_001",
+    unique_name: "weather-check",
+    display_name: "Weather Check",
+    version: 3,
+    status: "active" as const,
+    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" as const,
+    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" as const,
+    personality_ids: [],
+    created_at: "2026-02-20T14:00:00Z",
+    updated_at: "2026-02-21T10:00:00Z",
+  },
+];
+
+export class MockApiClient implements IApiClient {
+  async getPersonalities(): Promise<Personality[]> {
+    return Promise.resolve(MOCK_PERSONALITIES);
+  }
+
+  async uploadAbility(
+    _zipBuffer: Buffer,
+    _imageBuffer: Buffer | null,
+    _imageName: string | null,
+    _metadata: UploadAbilityMetadata,
+  ): Promise<UploadAbilityResponse> {
+    return Promise.resolve({
+      ability_id: `abl_mock_${Date.now()}`,
+      unique_name: "mock-ability",
+      version: 1,
+      status: "processing",
+      validation_errors: [],
+      created_at: new Date().toISOString(),
+      message: "[MOCK] Ability uploaded successfully and is being processed.",
+    });
+  }
+
+  async listAbilities(): Promise<ListAbilitiesResponse> {
+    return Promise.resolve({ abilities: MOCK_ABILITIES });
+  }
+
+  async verifyApiKey(_apiKey: string): Promise<VerifyApiKeyResponse> {
+    return Promise.resolve({
+      valid: true,
+      message: "[MOCK] API key is valid.",
+    });
+  }
+
+  async deleteCapability(id: string): Promise<DeleteCapabilityResponse> {
+    return Promise.resolve({
+      message: `[MOCK] Capability ${id} deleted successfully.`,
+    });
+  }
+
+  async toggleCapability(
+    id: string,
+    enabled: boolean,
+  ): Promise<ToggleCapabilityResponse> {
+    return Promise.resolve({
+      enabled,
+      message: `[MOCK] Capability ${id} ${enabled ? "enabled" : "disabled"}.`,
+    });
+  }
+
+  async assignCapabilities(
+    personalityId: string,
+    capabilityIds: number[],
+  ): Promise<AssignCapabilitiesResponse> {
+    return Promise.resolve({
+      message: `[MOCK] Agent ${personalityId} updated with ${capabilityIds.length} capability(s).`,
+    });
+  }
+
+  async getAbility(id: string): Promise<GetAbilityResponse> {
+    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" as const,
+                timestamp: base.created_at,
+                message: "Deployed successfully",
+              },
+            ]
+          : []),
+      ],
+    });
+  }
+}