wispy-cli 2.7.9 → 2.7.11

package/bin/wispy.mjs

@@ -49,6 +49,11 @@ Usage:
                                Manage configuration
   wispy model                  Show or change AI model
   wispy doctor                 Check system health
+  wispy browser [tabs|attach|navigate|screenshot|doctor]
+                               Browser control via local-browser-bridge
+  wispy secrets [list|set|delete|get]
+                               Manage encrypted secrets & API keys
+  wispy tts "<text>"           Text-to-speech (OpenAI or macOS say)
   wispy trust [level|log]      Security level & audit
   wispy ws [start-client|run-debug]
                                WebSocket operations
@@ -161,6 +166,27 @@ if (command === "doctor") {
     for (const c of checks) {
       console.log(`  ${c.ok ? "✓" : "✗"} ${c.name}`);
     }
+
+    // Browser bridge check
+    try {
+      const { BrowserBridge } = await import(join(rootDir, "core/browser.mjs"));
+      const bridge = new BrowserBridge();
+      const h = await bridge.health();
+      if (h?.ok || (!h?.error && h !== null)) {
+        const caps = await bridge.capabilities().catch(() => ({}));
+        const browsers = Array.isArray(caps?.browsers) ? caps.browsers : [];
+        const session = bridge._session;
+        const detail = browsers.length
+          ? `${browsers.join(", ")} available${session ? ", session active" : ""}`
+          : "running";
+        console.log(`  ✓ Browser bridge    ${detail}`);
+      } else {
+        console.log(`  ✗ Browser bridge    not running (start with: npx local-browser-bridge serve)`);
+      }
+    } catch {
+      console.log(`  ✗ Browser bridge    not running (start with: npx local-browser-bridge serve)`);
+    }
+
     console.log("");
 
     if (!provider?.key) {
@@ -175,6 +201,273 @@ if (command === "doctor") {
   process.exit(0);
 }
 
+// ── Browser ───────────────────────────────────────────────────────────────────
+
+if (command === "browser") {
+  try {
+    const { BrowserBridge } = await import(join(rootDir, "core/browser.mjs"));
+    const bridge = new BrowserBridge();
+    const sub = args[1];
+
+    if (!sub || sub === "status") {
+      // wispy browser — show status
+      const h = await bridge.health();
+      const status = bridge.status();
+      const running = h?.ok || (!h?.error && h !== null);
+      console.log(`\n  Browser Bridge`);
+      console.log(`  URL:      ${bridge.baseUrl}`);
+      console.log(`  Status:   ${running ? "✓ running" : "✗ not running"}`);
+      if (!running) {
+        console.log(`  Hint:     npx local-browser-bridge serve`);
+      } else {
+        const caps = await bridge.capabilities().catch(() => ({}));
+        if (caps?.browsers?.length) {
+          console.log(`  Browsers: ${caps.browsers.join(", ")}`);
+        }
+      }
+      if (status.session) {
+        console.log(`  Session:  ${status.session.id} (${status.session.browser ?? "unknown"})`);
+      } else {
+        console.log(`  Session:  none`);
+      }
+      console.log("");
+    } else if (sub === "tabs") {
+      // wispy browser tabs
+      const browser = args[2];
+      const result = await bridge.listTabs(browser);
+      if (result?.error) {
+        console.error(`  ✗ ${result.error}`);
+      } else {
+        const tabs = result?.tabs ?? result;
+        console.log(`\n  Open tabs:`);
+        if (Array.isArray(tabs)) {
+          for (const t of tabs) {
+            const title = t.title ?? t.name ?? "(no title)";
+            const url = t.url ?? "";
+            console.log(`    • ${title}${url ? `  —  ${url}` : ""}`);
+          }
+        } else {
+          console.log(JSON.stringify(tabs, null, 2));
+        }
+        console.log("");
+      }
+    } else if (sub === "attach") {
+      // wispy browser attach [browser]
+      const browser = args[2];
+      console.log(`\n  Attaching to ${browser ?? "best available browser"}...`);
+      let result;
+      if (browser) {
+        result = await bridge.attach(browser);
+      } else {
+        result = await bridge.autoAttach();
+      }
+      if (result?.error) {
+        console.error(`  ✗ ${result.error}`);
+      } else {
+        const id = result?.id ?? result?.sessionId ?? "?";
+        const br = result?.browser ?? browser ?? "unknown";
+        console.log(`  ✓ Attached (${br}, session: ${id})`);
+      }
+      console.log("");
+    } else if (sub === "navigate") {
+      // wispy browser navigate <url>
+      const url = args[2];
+      if (!url) { console.error("  Usage: wispy browser navigate <url>"); process.exit(1); }
+      console.log(`\n  Navigating to ${url}...`);
+      const result = await bridge.navigate(url);
+      if (result?.error) {
+        console.error(`  ✗ ${result.error}`);
+      } else {
+        console.log(`  ✓ Navigated`);
+      }
+      console.log("");
+    } else if (sub === "screenshot") {
+      // wispy browser screenshot
+      const result = await bridge.screenshot();
+      if (result?.error) {
+        console.error(`  ✗ ${result.error}`);
+      } else {
+        const data = result?.screenshot ?? result?.data;
+        if (data) {
+          console.log(`\n  Screenshot captured (${data.length} base64 chars)`);
+          // Optionally save to file
+          const outFile = args[2] ?? `wispy-screenshot-${Date.now()}.png`;
+          const buf = Buffer.from(data, "base64");
+          const { writeFile: wf } = await import("node:fs/promises");
+          await wf(outFile, buf);
+          console.log(`  Saved to: ${outFile}`);
+        } else {
+          console.log(`  Screenshot result:`, JSON.stringify(result, null, 2));
+        }
+        console.log("");
+      }
+    } else if (sub === "doctor") {
+      // wispy browser doctor — full diagnostics
+      console.log(`\n  Browser Bridge Diagnostics`);
+      console.log(`  URL: ${bridge.baseUrl}`);
+
+      const h = await bridge.health();
+      const running = h?.ok || (!h?.error && h !== null);
+      console.log(`  Health: ${running ? "✓ ok" : "✗ not running"}`);
+
+      if (running) {
+        const caps = await bridge.capabilities();
+        console.log(`\n  Capabilities:`);
+        console.log(JSON.stringify(caps, null, 2).split("\n").map(l => "    " + l).join("\n"));
+
+        const browsers = Array.isArray(caps?.browsers) ? caps.browsers : [];
+        for (const br of browsers) {
+          const diag = await bridge.diagnostics(br);
+          console.log(`\n  Diagnostics (${br}):`);
+          console.log(JSON.stringify(diag, null, 2).split("\n").map(l => "    " + l).join("\n"));
+        }
+
+        const sessions = await bridge.listSessions();
+        console.log(`\n  Sessions:`);
+        console.log(JSON.stringify(sessions, null, 2).split("\n").map(l => "    " + l).join("\n"));
+      } else {
+        console.log(`  Start with: npx local-browser-bridge serve`);
+      }
+      console.log("");
+    } else {
+      console.error(`  Unknown subcommand: ${sub}`);
+      console.log(`  Usage: wispy browser [status|tabs|attach|navigate <url>|screenshot|doctor]`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("Browser command error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ── Secrets ───────────────────────────────────────────────────────────────────
+
+if (command === "secrets") {
+  try {
+    const { SecretsManager } = await import(join(rootDir, "core/secrets.mjs"));
+    const sm = new SecretsManager();
+    const sub = args[1];
+
+    if (!sub || sub === "list") {
+      const keys = await sm.list();
+      if (keys.length === 0) {
+        console.log("No secrets stored. Use: wispy secrets set <key> <value>");
+      } else {
+        console.log(`\n  Stored secrets (${keys.length}):\n`);
+        for (const k of keys) {
+          console.log(`    ${k}`);
+        }
+        console.log("");
+      }
+    } else if (sub === "set") {
+      const key = args[2];
+      const value = args[3];
+      if (!key || value === undefined) {
+        console.error("Usage: wispy secrets set <key> <value>");
+        process.exit(1);
+      }
+      await sm.set(key, value);
+      console.log(`Secret '${key}' stored (encrypted).`);
+    } else if (sub === "delete") {
+      const key = args[2];
+      if (!key) {
+        console.error("Usage: wispy secrets delete <key>");
+        process.exit(1);
+      }
+      const result = await sm.delete(key);
+      if (result.success) {
+        console.log(`Secret '${key}' deleted.`);
+      } else {
+        console.error(`Secret '${key}' not found.`);
+        process.exit(1);
+      }
+    } else if (sub === "get") {
+      const key = args[2];
+      if (!key) {
+        console.error("Usage: wispy secrets get <key>");
+        process.exit(1);
+      }
+      const value = await sm.resolve(key);
+      if (value) {
+        console.log(`${key} = ***`);
+        console.log("(Use --reveal flag to show value — not recommended)");
+        if (args.includes("--reveal")) {
+          console.log(`Value: ${value}`);
+        }
+      } else {
+        console.log(`Secret '${key}' not found.`);
+      }
+    } else {
+      console.error(`Unknown secrets subcommand: ${sub}`);
+      console.log("Available: list, set <key> <value>, delete <key>, get <key>");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("Secrets error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ── TTS ───────────────────────────────────────────────────────────────────────
+
+if (command === "tts") {
+  try {
+    const { SecretsManager } = await import(join(rootDir, "core/secrets.mjs"));
+    const { TTSManager } = await import(join(rootDir, "core/tts.mjs"));
+
+    const sm = new SecretsManager();
+    const tts = new TTSManager(sm);
+
+    // Parse args: wispy tts "text" [--voice name] [--provider openai|macos] [--play]
+    let textArg = args[1];
+    if (!textArg) {
+      console.error('Usage: wispy tts "text to speak" [--voice <name>] [--provider openai|macos] [--play]');
+      process.exit(1);
+    }
+
+    const voiceIdx = args.indexOf("--voice");
+    const providerIdx = args.indexOf("--provider");
+    const shouldPlay = args.includes("--play");
+
+    const voice = voiceIdx !== -1 ? args[voiceIdx + 1] : undefined;
+    const provider = providerIdx !== -1 ? args[providerIdx + 1] : "auto";
+
+    console.log(`  Generating speech (provider: ${provider})...`);
+    const result = await tts.speak(textArg, { voice, provider });
+
+    if (result.error) {
+      console.error(`  TTS Error: ${result.error}`);
+      process.exit(1);
+    }
+
+    console.log(`  Provider: ${result.provider}`);
+    console.log(`  Voice:    ${result.voice}`);
+    console.log(`  Format:   ${result.format}`);
+    console.log(`  File:     ${result.path}`);
+
+    if (shouldPlay) {
+      const { execFile } = await import("node:child_process");
+      const { promisify } = await import("node:util");
+      const exec = promisify(execFile);
+      try {
+        if (process.platform === "darwin") {
+          await exec("afplay", [result.path]);
+        } else {
+          console.log('  Use --play flag only on macOS. Play manually with your audio player.');
+        }
+      } catch (playErr) {
+        console.error(`  Playback failed: ${playErr.message}`);
+      }
+    }
+  } catch (err) {
+    console.error("TTS error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
 // ── Trust ─────────────────────────────────────────────────────────────────────
 
 if (command === "trust") {

package/core/config.mjs

@@ -193,17 +193,35 @@ export async function detectProvider() {
     }
   }
 
-  // 4. macOS Keychain
-  const keychainMap = [
-    ["google-ai-key", "google"],
-    ["anthropic-api-key", "anthropic"],
-    ["openai-api-key", "openai"],
-  ];
-  for (const [service, provider] of keychainMap) {
-    const key = await tryKeychainKey(service);
-    if (key) {
-      process.env[PROVIDERS[provider].envKeys[0]] = key;
-      return { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
+  // 4. macOS Keychain (via SecretsManager for unified resolution)
+  try {
+    const { getSecretsManager } = await import("./secrets.mjs");
+    const sm = getSecretsManager({ wispyDir: WISPY_DIR });
+    const keychainProviderMap = [
+      ["GOOGLE_AI_KEY", "google"],
+      ["ANTHROPIC_API_KEY", "anthropic"],
+      ["OPENAI_API_KEY", "openai"],
+    ];
+    for (const [envKey, provider] of keychainProviderMap) {
+      const key = await sm.resolve(envKey);
+      if (key) {
+        process.env[PROVIDERS[provider].envKeys[0]] = key;
+        return { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
+      }
+    }
+  } catch {
+    // SecretsManager unavailable — fallback to legacy Keychain
+    const keychainMap = [
+      ["google-ai-key", "google"],
+      ["anthropic-api-key", "anthropic"],
+      ["openai-api-key", "openai"],
+    ];
+    for (const [service, provider] of keychainMap) {
+      const key = await tryKeychainKey(service);
+      if (key) {
+        process.env[PROVIDERS[provider].envKeys[0]] = key;
+        return { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
+      }
     }
   }
 

package/core/features.mjs

@@ -0,0 +1,225 @@
+/**
+ * core/features.mjs — Feature flag system for Wispy
+ *
+ * Provides a registry of feature flags with stages (stable/experimental/development)
+ * and methods to enable/disable features, persisting state to config.
+ */
+
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { WISPY_DIR, CONFIG_PATH, loadConfig, saveConfig } from "./config.mjs";
+
+/**
+ * Registry of all known features.
+ * @type {Record<string, { stage: "stable"|"experimental"|"development", default: boolean, description: string }>}
+ */
+const FEATURE_REGISTRY = {
+  // ── Stable features ──────────────────────────────────────────────────────
+  smart_routing: {
+    stage: "stable",
+    default: true,
+    description: "Route tasks to optimal models",
+  },
+  task_decomposition: {
+    stage: "stable",
+    default: true,
+    description: "Split complex tasks into parallel subtasks",
+  },
+  loop_detection: {
+    stage: "stable",
+    default: true,
+    description: "Detect and break tool-call loops",
+  },
+  context_compaction: {
+    stage: "stable",
+    default: true,
+    description: "Auto-compact context when approaching token limit",
+  },
+
+  // ── Experimental features ────────────────────────────────────────────────
+  browser_integration: {
+    stage: "experimental",
+    default: false,
+    description: "Native browser control via local-browser-bridge",
+  },
+  auto_memory: {
+    stage: "experimental",
+    default: false,
+    description: "Auto-extract facts from conversations to memory",
+  },
+  tts: {
+    stage: "experimental",
+    default: false,
+    description: "Text-to-speech output",
+  },
+
+  // ── Under development ────────────────────────────────────────────────────
+  multi_agent: {
+    stage: "development",
+    default: false,
+    description: "Multi-agent orchestration patterns",
+  },
+  cloud_sync: {
+    stage: "development",
+    default: false,
+    description: "Sync sessions to cloud",
+  },
+  image_generation: {
+    stage: "development",
+    default: false,
+    description: "Generate images from prompts",
+  },
+};
+
+export class FeatureManager {
+  /**
+   * @param {string} [configPath] - Path to config.json (defaults to ~/.wispy/config.json)
+   */
+  constructor(configPath) {
+    this._configPath = configPath ?? CONFIG_PATH;
+    /** @type {Record<string, boolean>} — cached overrides from config */
+    this._overrides = null;
+  }
+
+  /**
+   * Load feature overrides from config (lazy, cached per call).
+   * @returns {Promise<Record<string, boolean>>}
+   */
+  async _loadOverrides() {
+    if (this._overrides !== null) return this._overrides;
+    try {
+      const raw = await readFile(this._configPath, "utf8");
+      const cfg = JSON.parse(raw);
+      this._overrides = cfg.features ?? {};
+    } catch {
+      this._overrides = {};
+    }
+    return this._overrides;
+  }
+
+  /** Invalidate the cache so next read picks up fresh config. */
+  _invalidate() {
+    this._overrides = null;
+  }
+
+  /**
+   * Check if a feature is enabled.
+   * Config override takes precedence over registry default.
+   * Profile-level features (passed in opts) take precedence over global config.
+   * @param {string} name
+   * @param {Record<string, boolean>} [profileFeatures] - Profile-level overrides
+   * @returns {Promise<boolean>}
+   */
+  async isEnabled(name, profileFeatures = {}) {
+    const reg = FEATURE_REGISTRY[name];
+    if (!reg) return false; // Unknown features are disabled
+
+    // Profile override first
+    if (name in profileFeatures) return Boolean(profileFeatures[name]);
+
+    // Config override second
+    const overrides = await this._loadOverrides();
+    if (name in overrides) return Boolean(overrides[name]);
+
+    // Registry default
+    return reg.default;
+  }
+
+  /**
+   * Synchronous isEnabled using pre-loaded overrides.
+   * Call _loadOverrides() first if needed.
+   * @param {string} name
+   * @param {Record<string, boolean>} [overrides]
+   * @param {Record<string, boolean>} [profileFeatures]
+   * @returns {boolean}
+   */
+  isEnabledSync(name, overrides = {}, profileFeatures = {}) {
+    const reg = FEATURE_REGISTRY[name];
+    if (!reg) return false;
+    if (name in profileFeatures) return Boolean(profileFeatures[name]);
+    if (name in overrides) return Boolean(overrides[name]);
+    return reg.default;
+  }
+
+  /**
+   * Enable a feature and persist to config.
+   * @param {string} name
+   */
+  async enable(name) {
+    if (!FEATURE_REGISTRY[name]) {
+      throw new Error(`Unknown feature: "${name}". Use "wispy features" to see available features.`);
+    }
+    const raw = await this._readConfig();
+    if (!raw.features) raw.features = {};
+    raw.features[name] = true;
+    await this._writeConfig(raw);
+    this._invalidate();
+    return { success: true, name, enabled: true };
+  }
+
+  /**
+   * Disable a feature and persist to config.
+   * @param {string} name
+   */
+  async disable(name) {
+    if (!FEATURE_REGISTRY[name]) {
+      throw new Error(`Unknown feature: "${name}". Use "wispy features" to see available features.`);
+    }
+    const raw = await this._readConfig();
+    if (!raw.features) raw.features = {};
+    raw.features[name] = false;
+    await this._writeConfig(raw);
+    this._invalidate();
+    return { success: true, name, enabled: false };
+  }
+
+  /**
+   * List all features with their current status.
+   * @returns {Promise<Array<{ name: string, stage: string, enabled: boolean, default: boolean, description: string }>>}
+   */
+  async list() {
+    const overrides = await this._loadOverrides();
+    return Object.entries(FEATURE_REGISTRY).map(([name, meta]) => ({
+      name,
+      stage: meta.stage,
+      enabled: name in overrides ? Boolean(overrides[name]) : meta.default,
+      default: meta.default,
+      description: meta.description,
+    }));
+  }
+
+  /**
+   * Get the stage of a feature.
+   * @param {string} name
+   * @returns {"stable"|"experimental"|"development"|null}
+   */
+  getStage(name) {
+    return FEATURE_REGISTRY[name]?.stage ?? null;
+  }
+
+  async _readConfig() {
+    await mkdir(WISPY_DIR, { recursive: true });
+    try {
+      return JSON.parse(await readFile(this._configPath, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+
+  async _writeConfig(cfg) {
+    await mkdir(WISPY_DIR, { recursive: true });
+    await writeFile(this._configPath, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  }
+}
+
+/** Singleton instance */
+let _instance = null;
+
+/** Get or create the global FeatureManager instance. */
+export function getFeatureManager(configPath) {
+  if (!_instance) _instance = new FeatureManager(configPath);
+  return _instance;
+}
+
+/** Export the registry for introspection. */
+export { FEATURE_REGISTRY };