@phuetz/code-buddy 1.1.0 → 1.2.0

package/dist/agent/extended-thinking.js

@@ -67,6 +67,33 @@ export class ExtendedThinkingManager {
         this.alwaysEnabled = value;
         logger.info(`Extended thinking always-enabled: ${value}`);
     }
+    /**
+     * Apply a UI/settings thinking level — `off | minimal | low | medium | high | xhigh`.
+     * `off` (or any unknown level) disables thinking; any other level enables it with a
+     * scaled token budget. This is the runtime entry point for hot-swapping the level from
+     * the Cowork ReasoningLevelPicker; the OpenAI-compat / Grok / Ollama providers read
+     * {@link getThinkingConfig} fresh per request, so the change takes effect next turn.
+     */
+    applyThinkingLevel(level) {
+        const budgets = {
+            minimal: 1024,
+            low: 2048,
+            medium: 4096,
+            high: 8192,
+            xhigh: 16384,
+        };
+        const budget = budgets[level];
+        if (budget === undefined) {
+            this.enabled = false;
+            this.alwaysEnabled = false;
+            logger.info(`Extended thinking disabled (level=${level})`);
+            return;
+        }
+        this.maxThinkingTokens = budget;
+        this.enabled = false; // the configured level drives state via alwaysEnabled
+        this.alwaysEnabled = true;
+        logger.info(`Extended thinking level=${level} (budget: ${budget} tokens)`);
+    }
     /**
      * Get the thinking configuration to merge into API request parameters.
      * Returns an object with a `thinking` key when enabled, or an empty object when disabled.

package/dist/agent/hermes-browser-backends.js

@@ -10,6 +10,8 @@ import { spawnSync } from 'child_process';
 import { mkdir, mkdtemp, stat } from 'fs/promises';
 import { tmpdir } from 'os';
 import { isAbsolute, join, resolve } from 'path';
+import { executeBrowserUseAction } from '../browser-automation/browser-use-runner.js';
+import { closeCamofox, launchCamofox } from '../browser-automation/camofox-runner.js';
 const require = createRequire(import.meta.url);
 function presentEnvKeys(env, keys) {
     return keys.filter((key) => Boolean(env[key]?.trim()));
@@ -143,15 +145,17 @@ function browserUseBackend(env) {
         label: 'Browser Use gateway',
         officialSurface: 'Browser Use managed browser mode',
         status: configured ? 'configured' : 'missing',
-        installed: false,
+        installed: true,
         configured,
-        runnable: false,
+        runnable: configured,
         command: null,
         version: null,
         credentialSources,
-        smokeCommand: null,
-        notes: ['Tracked for Hermes parity; Code Buddy does not yet expose a first-class Browser Use runtime runner.'],
-        remediation: ['Use local Playwright today, or wire the Nous Tool Gateway before claiming Browser Use backend parity.'],
+        smokeCommand: configured ? 'buddy hermes browser-smoke browser-use --json' : null,
+        notes: ['Browser Use runner routes actions through the Browser Use API or Nous Tool Gateway (src/browser-automation/browser-use-runner.ts).'],
+        remediation: configured
+            ? []
+            : ['Set BROWSER_USE_API_KEY or CODEBUDDY_NOUS_TOOL_GATEWAY_URL to enable the Browser Use backend.'],
     };
 }
 function firecrawlBackend(env) {
@@ -184,13 +188,13 @@ function camofoxBackend(env) {
         status: installed ? 'available' : 'missing',
         installed,
         configured: installed,
-        runnable: false,
+        runnable: installed,
         command: installed ? (camofox.ok ? 'camofox' : 'camoufox') : null,
         version: installed ? firstLine(camoufox.output) : null,
         credentialSources: [],
-        smokeCommand: null,
-        notes: ['Detected only as an optional upstream-compatible backend; no Code Buddy runner is wired yet.'],
-        remediation: installed ? ['Wire a first-class runner before claiming Camofox parity.'] : ['Install Camofox/Camoufox only if this backend is required.'],
+        smokeCommand: installed ? 'buddy hermes browser-smoke camofox --json' : null,
+        notes: ['Camofox runner launches the anti-detect Firefox Playwright server and connects via firefox.connect() (src/browser-automation/camofox-runner.ts).'],
+        remediation: installed ? [] : ['Install Camofox/Camoufox only if this backend is required.'],
     };
 }
 function recordingBackend() {
@@ -271,13 +275,13 @@ function browserRouteGateReason(backend) {
         return 'Browserbase is configured but excluded from auto browser routing; use the explicit smoke runner for managed sessions.';
     }
     if (backend.id === 'browser-use' && backend.configured) {
-        return 'Browser Use is configured but excluded from auto browser routing until the Nous Tool Gateway runner is wired.';
+        return null; // Browser Use runner is wired — eligible for auto-routing.
     }
     if (backend.id === 'firecrawl' && backend.configured) {
         return 'Firecrawl is configured but excluded from auto browser routing because it is an extraction backend, not an interactive browser session.';
     }
     if (backend.id === 'camofox' && backend.installed) {
-        return 'Camofox/Camoufox is installed but excluded from auto browser routing until a first-class runner exists.';
+        return null; // Camofox runner is wired — eligible for auto-routing.
     }
     return null;
 }
@@ -538,6 +542,136 @@ async function runBrowserbaseSmoke(now, env) {
         }
     }
 }
+async function runBrowserUseSmoke(now, env) {
+    const started = now();
+    const startedAtMs = Date.now();
+    const apiKey = env.BROWSER_USE_API_KEY?.trim();
+    const gatewayUrl = env.CODEBUDDY_NOUS_TOOL_GATEWAY_URL?.trim();
+    if (!apiKey && !gatewayUrl) {
+        return {
+            backendId: 'browser-use',
+            command: null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Browser Use gateway',
+            ok: false,
+            output: 'BROWSER_USE_API_KEY or CODEBUDDY_NOUS_TOOL_GATEWAY_URL is required for browser-use smoke.',
+            startedAt: started.toISOString(),
+            status: 'not-runnable',
+            stdout: '',
+            stderr: 'BROWSER_USE_API_KEY or CODEBUDDY_NOUS_TOOL_GATEWAY_URL is required for browser-use smoke.',
+        };
+    }
+    const result = await executeBrowserUseAction('Open the page and report the title or main heading.', 'https://example.com', {
+        apiKey,
+        gatewayUrl,
+        timeout: 60_000,
+    });
+    const output = result.content ?? (result.screenshot ? 'Browser Use returned screenshot data.' : '');
+    return {
+        backendId: 'browser-use',
+        command: null,
+        durationMs: Math.max(0, Date.now() - startedAtMs),
+        finishedAt: now().toISOString(),
+        label: 'Browser Use gateway',
+        ok: result.ok,
+        output: result.ok ? output : result.error ?? 'Browser Use smoke failed.',
+        startedAt: started.toISOString(),
+        status: result.ok ? 'passed' : 'failed',
+        stdout: result.ok ? output : '',
+        stderr: result.ok ? '' : result.error ?? 'Browser Use smoke failed.',
+    };
+}
+async function runCamofoxSmoke(now, env) {
+    const started = now();
+    const startedAtMs = Date.now();
+    const binaryPath = env.CODEBUDDY_CAMOFOX_BINARY?.trim() || undefined;
+    const pythonPath = env.CODEBUDDY_CAMOFOX_PYTHON?.trim() || undefined;
+    // Camoufox is Firefox: launch its Playwright server and connect via
+    // firefox.connect() — NOT chromium.connectOverCDP(). The launch step returns
+    // a Playwright-server wsEndpoint; the connect below proves the repo's pinned
+    // Playwright can actually drive it (this is where the version-lock, if any,
+    // surfaces honestly rather than being faked as success on the endpoint alone).
+    const result = await launchCamofox({
+        binaryPath,
+        pythonPath,
+        headless: true,
+        timeout: 30_000,
+    });
+    if (!result.ok) {
+        const message = result.error ?? 'Camofox smoke failed.';
+        return {
+            backendId: 'camofox',
+            command: binaryPath ?? pythonPath ?? null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Camofox / Camoufox',
+            ok: false,
+            output: message,
+            startedAt: started.toISOString(),
+            status: /not (found|importable)|No module named/i.test(message) ? 'not-runnable' : 'failed',
+            stdout: '',
+            stderr: message,
+        };
+    }
+    const wsEndpoint = result.wsEndpoint;
+    let browser = null;
+    let context = null;
+    try {
+        const playwright = await import('playwright');
+        browser = await playwright.firefox.connect(wsEndpoint);
+        context = await browser.newContext();
+        const page = await context.newPage();
+        await page.goto('data:text/html,<title>OK-HERMES-CAMOFOX</title><h1>OK-HERMES-CAMOFOX</h1>', {
+            waitUntil: 'domcontentloaded',
+        });
+        const title = await page.title();
+        const heading = await page.locator('h1').textContent();
+        const ok = title === 'OK-HERMES-CAMOFOX' && heading === 'OK-HERMES-CAMOFOX';
+        const output = `title=${title}; heading=${heading ?? ''}; pid=${result.pid ?? 'unknown'}`;
+        return {
+            backendId: 'camofox',
+            command: binaryPath ?? pythonPath ?? null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Camofox / Camoufox',
+            ok,
+            output,
+            startedAt: started.toISOString(),
+            status: ok ? 'passed' : 'failed',
+            stdout: ok ? output : '',
+            stderr: ok ? '' : 'Unexpected Camofox page content.',
+            // Never expose the host:port wsEndpoint in the result.
+            session: { url: 'camoufox-firefox-server' },
+        };
+    }
+    catch (error) {
+        // A Playwright version-guard mismatch (server driver vs repo client) lands
+        // here. Report it honestly as a failure with the connect error message —
+        // do not fall back to a fake success.
+        const message = errorMessage(error);
+        return {
+            backendId: 'camofox',
+            command: binaryPath ?? pythonPath ?? null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Camofox / Camoufox',
+            ok: false,
+            output: message,
+            startedAt: started.toISOString(),
+            status: 'failed',
+            stdout: '',
+            stderr: message,
+        };
+    }
+    finally {
+        await context?.close().catch(() => undefined);
+        await browser?.close().catch(() => undefined);
+        if (result.pid) {
+            await closeCamofox(result.pid).catch(() => undefined);
+        }
+    }
+}
 async function runLocalPlaywrightSmoke(now, options = {}) {
     const started = now();
     const startedAtMs = Date.now();
@@ -700,6 +834,12 @@ export async function runHermesBrowserBackendSmoke(options) {
     if (backend.id === 'browserbase') {
         return runBrowserbaseSmoke(now, env);
     }
+    if (backend.id === 'browser-use') {
+        return runBrowserUseSmoke(now, env);
+    }
+    if (backend.id === 'camofox') {
+        return runCamofoxSmoke(now, env);
+    }
     if (!backend.runnable) {
         return blockedSmokeResult(backend.id, 'not-runnable', `${backend.label} is not runnable on this host.`, {
             backend,

package/dist/agent/hermes-claw-migrate.d.ts

@@ -100,6 +100,65 @@ export interface ClawAgentBehaviorSettings {
  * are mapped; everything else stays archived for manual review.
  */
 export declare function mapClawAgentBehavior(cfg: Record<string, unknown>): ClawAgentBehaviorSettings;
+/**
+ * Cron job entry as translated from an OpenClaw `cronJobs` array element into
+ * the shape consumed by CronScheduler.addJob().
+ */
+export interface ClawCronJobEntry {
+    name: string;
+    schedule: string;
+    task: string;
+}
+/**
+ * Map OpenClaw cron config to a list of CronJob-compatible entries.
+ *
+ * OpenClaw stores cron jobs as an array of `{ schedule, task, label? }` objects
+ * or — in 2026.6.x — under `scheduler.jobs`. Only entries with both a valid
+ * 5-field cron expression and a non-empty task string are mapped. Everything
+ * else is silently dropped (will remain in the archived raw slice if one
+ * exists).
+ */
+export declare function mapClawCronJobs(cfg: Record<string, unknown>): ClawCronJobEntry[];
+/**
+ * Map OpenClaw command allowlist into a flat string array of allowed command
+ * basenames / patterns, consumable by Code Buddy's command validator.
+ *
+ * OpenClaw stores these as a flat string array under `commandAllowlist`,
+ * `allowlist`, or `allowedCommands`. Items that look like credentials or paths
+ * outside of simple command names are filtered out.
+ */
+export declare function mapClawCommandAllowlist(cfg: Record<string, unknown>): string[];
+/**
+ * Map OpenClaw memory backend config to a Code Buddy memory provider name.
+ *
+ * Only well-known provider names are accepted; unknown strings are left
+ * unmapped (will stay in the archive). Credentials (API keys, URLs) in the
+ * memory backend config are never imported.
+ */
+export declare function mapClawMemoryBackend(cfg: Record<string, unknown>): string | undefined;
+/**
+ * Map OpenClaw exec timeout to a numeric millisecond value for Code Buddy's
+ * `execTimeout` setting.
+ *
+ * OpenClaw stores this as seconds (integer) or milliseconds (large integer).
+ * Values ≤ 0 are ignored. Values that look like seconds (≤ 3600) are
+ * multiplied by 1000. Clamped to a maximum of 3600000 ms (1 hour).
+ */
+export declare function mapClawExecTimeout(cfg: Record<string, unknown>): number | undefined;
+/**
+ * Vision config fields that Code Buddy consumes.
+ */
+export interface ClawVisionSettings {
+    visionEnabled?: boolean;
+    visionModel?: string;
+}
+/**
+ * Map OpenClaw vision settings to Code Buddy's vision config keys.
+ *
+ * Only the `enabled` boolean and `model` string are imported. Provider
+ * credentials, endpoint URLs, and other complex fields are left archived.
+ */
+export declare function mapClawVisionSettings(cfg: Record<string, unknown>): ClawVisionSettings;
 /** Build the migration plan (read-only; no writes). */
 export declare function buildClawMigrationPlan(opts?: ClawMigrationOptions): ClawMigrationEntry[];
 /**