@jackwener/opencli 1.5.9 → 1.6.0

package/autoresearch/eval-browse.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env npx tsx
+/**
+ * Layer 1: Deterministic Browse Command Testing
+ *
+ * Runs predefined opencli operate command sequences against real websites.
+ * No LLM involved — tests command reliability only.
+ *
+ * Usage:
+ *   npx tsx autoresearch/eval-browse.ts              # Run all tasks
+ *   npx tsx autoresearch/eval-browse.ts --task hn-top5  # Run single task
+ */
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TASKS_FILE = join(__dirname, 'browse-tasks.json');
+const RESULTS_DIR = join(__dirname, 'results');
+const BASELINE_FILE = join(__dirname, 'baseline-browse.txt');
+
+interface BrowseTask {
+  name: string;
+  steps: string[];
+  judge: JudgeCriteria;
+  set?: 'test';
+  note?: string;
+}
+
+type JudgeCriteria =
+  | { type: 'contains'; value: string }
+  | { type: 'arrayMinLength'; minLength: number }
+  | { type: 'nonEmpty' }
+  | { type: 'matchesPattern'; pattern: string };
+
+interface TaskResult {
+  name: string;
+  passed: boolean;
+  duration: number;
+  error?: string;
+  set: 'train' | 'test';
+}
+
+function judge(criteria: JudgeCriteria, output: string): boolean {
+  try {
+    switch (criteria.type) {
+      case 'contains':
+        return output.toLowerCase().includes(criteria.value.toLowerCase());
+      case 'arrayMinLength': {
+        try {
+          const arr = JSON.parse(output);
+          if (Array.isArray(arr)) return arr.length >= criteria.minLength;
+        } catch { /* not JSON array */ }
+        return false;
+      }
+      case 'nonEmpty':
+        return output.trim().length > 0 && output.trim() !== 'null' && output.trim() !== 'undefined';
+      case 'matchesPattern':
+        return new RegExp(criteria.pattern).test(output);
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
+function runCommand(cmd: string): string {
+  try {
+    return execSync(cmd, {
+      cwd: join(__dirname, '..'),
+      timeout: 30000,
+      encoding: 'utf-8',
+      env: process.env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch (err: any) {
+    return err.stdout?.trim() ?? '';
+  }
+}
+
+function runTask(task: BrowseTask): TaskResult {
+  const start = Date.now();
+  let lastOutput = '';
+
+  try {
+    for (const step of task.steps) {
+      lastOutput = runCommand(step);
+    }
+
+    const passed = judge(task.judge, lastOutput);
+
+    return {
+      name: task.name,
+      passed,
+      duration: Date.now() - start,
+      error: passed ? undefined : `Output: ${lastOutput.slice(0, 100)}`,
+      set: task.set === 'test' ? 'test' : 'train',
+    };
+  } catch (err: any) {
+    return {
+      name: task.name,
+      passed: false,
+      duration: Date.now() - start,
+      error: err.message?.slice(0, 100),
+      set: task.set === 'test' ? 'test' : 'train',
+    };
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const singleTask = args.includes('--task') ? args[args.indexOf('--task') + 1] : null;
+
+  const allTasks: BrowseTask[] = JSON.parse(readFileSync(TASKS_FILE, 'utf-8'));
+  const tasks = singleTask ? allTasks.filter(t => t.name === singleTask) : allTasks;
+
+  if (tasks.length === 0) {
+    console.error(`Task "${singleTask}" not found.`);
+    process.exit(1);
+  }
+
+  console.log(`\n🔬 Layer 1: Browse Commands — ${tasks.length} tasks\n`);
+
+  const results: TaskResult[] = [];
+
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    process.stdout.write(`  [${i + 1}/${tasks.length}] ${task.name}...`);
+
+    const result = runTask(task);
+    results.push(result);
+
+    const icon = result.passed ? '✓' : '✗';
+    console.log(` ${icon} (${(result.duration / 1000).toFixed(1)}s)`);
+
+    // Close browser between tasks for clean state
+    if (i < tasks.length - 1) {
+      try { runCommand('opencli operate close'); } catch { /* ignore */ }
+    }
+  }
+
+  // Final close
+  try { runCommand('opencli operate close'); } catch { /* ignore */ }
+
+  // Summary
+  const trainResults = results.filter(r => r.set === 'train');
+  const testResults = results.filter(r => r.set === 'test');
+  const totalPassed = results.filter(r => r.passed).length;
+  const trainPassed = trainResults.filter(r => r.passed).length;
+  const testPassed = testResults.filter(r => r.passed).length;
+  const totalDuration = results.reduce((s, r) => s + r.duration, 0);
+
+  console.log(`\n${'─'.repeat(50)}`);
+  console.log(`  Score:  ${totalPassed}/${results.length} (train: ${trainPassed}/${trainResults.length}, test: ${testPassed}/${testResults.length})`);
+  console.log(`  Time:   ${Math.round(totalDuration / 60000)}min`);
+
+  const failures = results.filter(r => !r.passed);
+  if (failures.length > 0) {
+    console.log(`\n  Failures:`);
+    for (const f of failures) {
+      console.log(`    ✗ ${f.name}: ${f.error ?? 'unknown'}`);
+    }
+  }
+  console.log('');
+
+  // Save result
+  mkdirSync(RESULTS_DIR, { recursive: true });
+  const existing = readdirSync(RESULTS_DIR).filter(f => f.startsWith('browse-')).length;
+  const roundNum = String(existing + 1).padStart(3, '0');
+  const resultPath = join(RESULTS_DIR, `browse-${roundNum}.json`);
+  writeFileSync(resultPath, JSON.stringify({
+    timestamp: new Date().toISOString(),
+    score: `${totalPassed}/${results.length}`,
+    trainScore: `${trainPassed}/${trainResults.length}`,
+    testScore: `${testPassed}/${testResults.length}`,
+    duration: `${Math.round(totalDuration / 60000)}min`,
+    tasks: results,
+  }, null, 2), 'utf-8');
+  console.log(`  Results saved to: ${resultPath}`);
+  console.log(`\nSCORE=${totalPassed}/${results.length}`);
+}
+
+main();

package/autoresearch/eval-skill.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env npx tsx
+/**
+ * Layer 2: Claude Code Skill E2E Testing (LLM Judge)
+ *
+ * Spawns Claude Code with the opencli-operate skill. Claude Code
+ * completes the task using browse commands AND judges its own result.
+ *
+ * Task format: YAML with judge_context (multi-criteria, like Browser Use)
+ *
+ * Usage:
+ *   npx tsx autoresearch/eval-skill.ts                    # Run all
+ *   npx tsx autoresearch/eval-skill.ts --task hn-top5     # Run single
+ */
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TASKS_FILE = join(__dirname, 'skill-tasks.yaml');
+const RESULTS_DIR = join(__dirname, 'results');
+const SKILL_PATH = join(__dirname, '..', 'skills', 'opencli-operate', 'SKILL.md');
+
+// ── Types ──────────────────────────────────────────────────────────
+
+interface SkillTask {
+  name: string;
+  task: string;
+  url?: string;
+  judge_context: string[];
+  max_steps?: number;
+}
+
+interface TaskResult {
+  name: string;
+  passed: boolean;
+  duration: number;
+  cost: number;
+  explanation: string;
+}
+
+// ── Task Definitions (inline, to avoid YAML dependency) ────────────
+
+const TASKS: SkillTask[] = [
+  // Extract
+  { name: "extract-title-example", task: "Extract the main heading text from this page", url: "https://example.com", judge_context: ["Output must contain 'Example Domain'"] },
+  { name: "extract-paragraph-wiki", task: "Extract the first paragraph of the JavaScript article", url: "https://en.wikipedia.org/wiki/JavaScript", judge_context: ["Output must mention 'programming language'", "Output must contain actual paragraph text, not just the title"] },
+  { name: "extract-github-stars", task: "Find the number of stars on this repository", url: "https://github.com/browser-use/browser-use", judge_context: ["Output must contain a number (the star count)"] },
+  { name: "extract-npm-downloads", task: "Find the weekly download count for this package", url: "https://www.npmjs.com/package/zod", judge_context: ["Output must contain a number (weekly downloads)"] },
+
+  // List extraction
+  { name: "list-hn-top5", task: "Extract the top 5 stories with their titles", url: "https://news.ycombinator.com", judge_context: ["Output must contain 5 story titles", "Each title must be an actual HN story, not made up"] },
+  { name: "list-books-5", task: "Extract the first 5 books with their title and price", url: "https://books.toscrape.com", judge_context: ["Output must contain 5 books", "Each book must have a title and a price"] },
+  { name: "list-quotes-3", task: "Extract the first 3 quotes with their text and author", url: "https://quotes.toscrape.com", judge_context: ["Output must contain 3 quotes", "Each quote must have text and an author name"] },
+  { name: "list-github-trending", task: "Extract the top 3 trending repositories with name and description", url: "https://github.com/trending", judge_context: ["Output must contain 3 repositories", "Each must have a repo name"] },
+  { name: "list-jsonplaceholder", task: "Extract the first 5 posts with their title", url: "https://jsonplaceholder.typicode.com/posts", judge_context: ["Output must contain 5 posts", "Each post must have a title"] },
+
+  // Search
+  { name: "search-ddg", task: "Search for 'TypeScript tutorial' and extract the first 3 result titles", url: "https://duckduckgo.com", judge_context: ["The agent must type a search query", "Output must contain at least 3 search result titles"] },
+  { name: "search-npm", task: "Search for 'react' and extract the top 3 package names", url: "https://www.npmjs.com", judge_context: ["The agent must search for 'react'", "Output must contain at least 3 package names"] },
+  { name: "search-wiki", task: "Search for 'Rust programming language' and extract the first sentence of the article", url: "https://en.wikipedia.org", judge_context: ["The agent must search and navigate to the article", "Output must mention 'programming language'"] },
+
+  // Navigation
+  { name: "nav-click-link", task: "Click the 'More information...' link and extract the heading of the new page", url: "https://example.com", judge_context: ["The agent must click a link", "Output must contain 'IANA' or reference the new page"] },
+  { name: "nav-click-hn", task: "Click on the first story link and tell me the title of the page you land on", url: "https://news.ycombinator.com", judge_context: ["The agent must click a story link", "Output must contain the title of the destination page"] },
+  { name: "nav-go-back", task: "Click the 'More information...' link, then go back, and tell me the heading of the original page", url: "https://example.com", judge_context: ["The agent must click a link then go back", "Output must contain 'Example Domain'"] },
+  { name: "nav-multi-step", task: "Click the Next page link at the bottom, then extract the first quote from page 2", url: "https://quotes.toscrape.com", judge_context: ["The agent must navigate to page 2", "Output must contain a quote from page 2"] },
+
+  // Scroll
+  { name: "scroll-footer", task: "Scroll to the bottom and extract the footer text", url: "https://quotes.toscrape.com", judge_context: ["The agent must scroll down", "Output must contain footer or bottom-of-page content"] },
+  { name: "scroll-pagination", task: "Find the pagination info at the bottom of the page", url: "https://books.toscrape.com", judge_context: ["Output must contain page number or pagination info"] },
+
+  // Form
+  { name: "form-fill-basic", task: "Fill the Customer Name with 'OpenCLI' and Telephone with '555-0100'. Do not submit.", url: "https://httpbin.org/forms/post", judge_context: ["The agent must type 'OpenCLI' into a name field", "The agent must type '555-0100' into a phone field", "The form must NOT be submitted"] },
+  { name: "form-radio", task: "Select the 'Medium' pizza size option. Do not submit.", url: "https://httpbin.org/forms/post", judge_context: ["The agent must select a radio button for Medium size"] },
+  { name: "form-login", task: "Fill the username with 'testuser' and password with 'testpass'. Do not submit.", url: "https://the-internet.herokuapp.com/login", judge_context: ["The agent must fill the username field", "The agent must fill the password field", "The form must NOT be submitted"] },
+
+  // Complex
+  { name: "complex-wiki-toc", task: "Extract the table of contents headings", url: "https://en.wikipedia.org/wiki/JavaScript", judge_context: ["Output must contain at least 5 section headings from the table of contents"] },
+  { name: "complex-books-detail", task: "Click on the first book and extract its title and price from the detail page", url: "https://books.toscrape.com", judge_context: ["The agent must click on a book", "Output must contain the book title", "Output must contain a price"] },
+  { name: "complex-quotes-page2", task: "Navigate to page 2 and extract the first 3 quotes with their authors", url: "https://quotes.toscrape.com", judge_context: ["The agent must navigate to page 2", "Output must contain 3 quotes with authors"] },
+  { name: "complex-multi-extract", task: "Extract both the page title and the first paragraph text", url: "https://en.wikipedia.org/wiki/TypeScript", judge_context: ["Output must contain 'TypeScript'", "Output must contain actual paragraph text"] },
+
+  // Bench (harder, real-world)
+  { name: "bench-reddit", task: "Extract the titles of the top 5 posts", url: "https://old.reddit.com", judge_context: ["Output must contain 5 post titles", "Titles must be actual Reddit posts"] },
+  { name: "bench-imdb", task: "Find the year and rating of The Matrix", url: "https://www.imdb.com/title/tt0133093/", judge_context: ["Output must contain '1999'", "Output must contain a rating number"] },
+  { name: "bench-github-profile", task: "Extract the bio and number of public repositories", url: "https://github.com/torvalds", judge_context: ["Output must contain bio text or 'Linux'", "Output must contain a number for repos"] },
+  { name: "bench-httpbin", task: "Extract the User-Agent header shown on this page", url: "https://httpbin.org/headers", judge_context: ["Output must contain a User-Agent string"] },
+  { name: "bench-jsonapi-todo", task: "Extract the first 5 todo items with their title and completion status", url: "https://jsonplaceholder.typicode.com/todos", judge_context: ["Output must contain 5 todo items", "Each must have a title and completed status"] },
+
+  // Codex form (the real test)
+  { name: "codex-form-fill", task: "Fill the basic information using 'opencli' as the identity (first name=open, last name=cli, email=opencli@example.com, GitHub username=opencli). Do NOT submit the form.", url: "https://openai.com/form/codex-for-oss/", judge_context: ["The agent must fill the first name field", "The agent must fill the last name field", "The agent must fill the email field", "The form must NOT be submitted"], max_steps: 15 },
+];
+
+// ── Run Task ───────────────────────────────────────────────────────
+
+function runSkillTask(task: SkillTask): TaskResult {
+  const start = Date.now();
+  const skillContent = readFileSync(SKILL_PATH, 'utf-8');
+  const urlPart = task.url ? ` Start URL: ${task.url}` : '';
+  const criteria = task.judge_context.map((c, i) => `${i + 1}. ${c}`).join('\n');
+
+  const prompt = `Complete this browser task using opencli operate commands:
+
+TASK: ${task.task}${urlPart}
+
+After completing the task, evaluate your own result against these criteria:
+${criteria}
+
+At the very end of your response, output a JSON verdict on its own line:
+{"success": true/false, "explanation": "brief explanation"}
+
+Always close the browser with 'opencli operate close' when done.`;
+
+  try {
+    const output = execSync(
+      `claude -p --dangerously-skip-permissions --allowedTools "Bash(opencli:*)" --system-prompt ${JSON.stringify(skillContent)} --output-format json --no-session-persistence ${JSON.stringify(prompt)}`,
+      {
+        cwd: join(__dirname, '..'),
+        timeout: (task.max_steps ?? 10) * 15_000,
+        encoding: 'utf-8',
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }
+    );
+
+    const duration = Date.now() - start;
+
+    // Parse Claude Code output
+    let resultText = '';
+    let cost = 0;
+    try {
+      const parsed = JSON.parse(output);
+      resultText = parsed.result ?? output;
+      cost = parsed.total_cost_usd ?? 0;
+    } catch {
+      resultText = output;
+    }
+
+    // Extract verdict JSON from the result
+    const verdict = extractVerdict(resultText);
+
+    return {
+      name: task.name,
+      passed: verdict.success,
+      duration,
+      cost,
+      explanation: verdict.explanation,
+    };
+  } catch (err: any) {
+    return {
+      name: task.name,
+      passed: false,
+      duration: Date.now() - start,
+      cost: 0,
+      explanation: (err.stdout ?? err.message ?? 'timeout or crash').slice(0, 200),
+    };
+  }
+}
+
+function extractVerdict(text: string): { success: boolean; explanation: string } {
+  // Try to find {"success": ...} JSON in the text
+  const jsonMatches = text.match(/\{"success"\s*:\s*(true|false)\s*,\s*"explanation"\s*:\s*"([^"]*)"\s*\}/g);
+  if (jsonMatches) {
+    const last = jsonMatches[jsonMatches.length - 1];
+    try {
+      return JSON.parse(last);
+    } catch { /* fall through */ }
+  }
+
+  // Fallback: check for success indicators in text
+  const lower = text.toLowerCase();
+  if (lower.includes('"success": true') || lower.includes('"success":true')) {
+    return { success: true, explanation: 'Parsed success from output' };
+  }
+  if (lower.includes('"success": false') || lower.includes('"success":false')) {
+    return { success: false, explanation: 'Parsed failure from output' };
+  }
+
+  // Final fallback: assume failure if we can't parse
+  return { success: false, explanation: 'Could not parse verdict from output' };
+}
+
+// ── Main ───────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const singleTask = args.includes('--task') ? args[args.indexOf('--task') + 1] : null;
+  const tasks = singleTask ? TASKS.filter(t => t.name === singleTask) : TASKS;
+
+  if (tasks.length === 0) {
+    console.error(`Task "${singleTask}" not found. Available: ${TASKS.map(t => t.name).join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log(`\n🔬 Layer 2: Skill E2E (LLM Judge) — ${tasks.length} tasks\n`);
+
+  const results: TaskResult[] = [];
+
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    process.stdout.write(`  [${i + 1}/${tasks.length}] ${task.name}...`);
+
+    const result = runSkillTask(task);
+    results.push(result);
+
+    const icon = result.passed ? '✓' : '✗';
+    const costStr = result.cost > 0 ? `, $${result.cost.toFixed(2)}` : '';
+    console.log(` ${icon} (${Math.round(result.duration / 1000)}s${costStr})`);
+  }
+
+  // Summary
+  const totalPassed = results.filter(r => r.passed).length;
+  const totalCost = results.reduce((s, r) => s + r.cost, 0);
+  const totalDuration = results.reduce((s, r) => s + r.duration, 0);
+
+  console.log(`\n${'─'.repeat(50)}`);
+  console.log(`  Score:  ${totalPassed}/${results.length} (${Math.round(totalPassed / results.length * 100)}%)`);
+  console.log(`  Cost:   $${totalCost.toFixed(2)}`);
+  console.log(`  Time:   ${Math.round(totalDuration / 60000)}min`);
+
+  const failures = results.filter(r => !r.passed);
+  if (failures.length > 0) {
+    console.log(`\n  Failures:`);
+    for (const f of failures) {
+      console.log(`    ✗ ${f.name}: ${f.explanation}`);
+    }
+  }
+  console.log('');
+
+  // Save
+  mkdirSync(RESULTS_DIR, { recursive: true });
+  const existing = readdirSync(RESULTS_DIR).filter(f => f.startsWith('skill-')).length;
+  const roundNum = String(existing + 1).padStart(3, '0');
+  const resultPath = join(RESULTS_DIR, `skill-${roundNum}.json`);
+  writeFileSync(resultPath, JSON.stringify({
+    timestamp: new Date().toISOString(),
+    score: `${totalPassed}/${results.length}`,
+    totalCost,
+    duration: `${Math.round(totalDuration / 60000)}min`,
+    tasks: results,
+  }, null, 2), 'utf-8');
+  console.log(`  Results saved to: ${resultPath}`);
+  console.log(`\nSCORE=${totalPassed}/${results.length}`);
+}
+
+main();

package/autoresearch/run-browse.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Layer 1: Deterministic browse command testing
+set -e
+cd "$(dirname "$0")/.."
+echo "Building OpenCLI..."
+npm run build > /dev/null 2>&1
+echo "Build OK"
+echo ""
+npx tsx autoresearch/eval-browse.ts "$@"

package/autoresearch/run-skill.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Layer 2: Claude Code skill E2E testing
+set -e
+cd "$(dirname "$0")/.."
+echo "Building OpenCLI..."
+npm run build > /dev/null 2>&1
+echo "Build OK"
+echo ""
+npx tsx autoresearch/eval-skill.ts "$@"

package/dist/browser/daemon-client.d.ts

@@ -6,7 +6,7 @@
 import type { BrowserSessionInfo } from '../types.js';
 export interface DaemonCommand {
     id: string;
-    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'cdp';
     tabId?: number;
     code?: string;
     workspace?: string;
@@ -21,6 +21,8 @@ export interface DaemonCommand {
     files?: string[];
     /** CSS selector for file input element (set-file-input action) */
     selector?: string;
+    cdpMethod?: string;
+    cdpParams?: Record<string, unknown>;
 }
 export interface DaemonResult {
     id: string;
@@ -28,6 +30,23 @@ export interface DaemonResult {
     data?: unknown;
     error?: string;
 }
+export interface DaemonStatus {
+    ok: boolean;
+    pid: number;
+    uptime: number;
+    extensionConnected: boolean;
+    extensionVersion?: string;
+    pending: number;
+    lastCliRequestTime: number;
+    memoryMB: number;
+    port: number;
+}
+export declare function fetchDaemonStatus(opts?: {
+    timeout?: number;
+}): Promise<DaemonStatus | null>;
+export declare function requestDaemonShutdown(opts?: {
+    timeout?: number;
+}): Promise<boolean>;
 /**
  * Check if daemon is running.
  */

package/dist/browser/daemon-client.js

@@ -8,48 +8,58 @@ import { sleep } from '../utils.js';
 import { isTransientBrowserError } from './errors.js';
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
+const OPENCLI_HEADERS = { 'X-OpenCLI': '1' };
 let _idCounter = 0;
 function generateId() {
     return `cmd_${Date.now()}_${++_idCounter}`;
 }
-/**
- * Check if daemon is running.
- */
-export async function isDaemonRunning() {
+async function requestDaemon(pathname, init) {
+    const { timeout = 2000, headers, ...rest } = init ?? {};
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
     try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 2000);
-        const res = await fetch(`${DAEMON_URL}/status`, {
-            headers: { 'X-OpenCLI': '1' },
+        return await fetch(`${DAEMON_URL}${pathname}`, {
+            ...rest,
+            headers: { ...OPENCLI_HEADERS, ...headers },
             signal: controller.signal,
         });
+    }
+    finally {
         clearTimeout(timer);
+    }
+}
+export async function fetchDaemonStatus(opts) {
+    try {
+        const res = await requestDaemon('/status', { timeout: opts?.timeout ?? 2000 });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+export async function requestDaemonShutdown(opts) {
+    try {
+        const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
         return res.ok;
     }
     catch {
         return false;
     }
 }
+/**
+ * Check if daemon is running.
+ */
+export async function isDaemonRunning() {
+    return (await fetchDaemonStatus()) !== null;
+}
 /**
  * Check if daemon is running AND the extension is connected.
  */
 export async function isExtensionConnected() {
-    try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 2000);
-        const res = await fetch(`${DAEMON_URL}/status`, {
-            headers: { 'X-OpenCLI': '1' },
-            signal: controller.signal,
-        });
-        clearTimeout(timer);
-        if (!res.ok)
-            return false;
-        const data = await res.json();
-        return !!data.extensionConnected;
-    }
-    catch {
-        return false;
-    }
+    const status = await fetchDaemonStatus();
+    return !!status?.extensionConnected;
 }
 /**
  * Send a command to the daemon and wait for a result.
@@ -63,15 +73,12 @@ export async function sendCommand(action, params = {}) {
         const id = generateId();
         const command = { id, action, ...params };
         try {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), 30000);
-            const res = await fetch(`${DAEMON_URL}/command`, {
+            const res = await requestDaemon('/command', {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'X-OpenCLI': '1' },
+                headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(command),
-                signal: controller.signal,
+                timeout: 30000,
             });
-            clearTimeout(timer);
             const result = (await res.json());
             if (!result.ok) {
                 // Check if error is a transient extension issue worth retrying

package/dist/browser/daemon-client.test.d.ts

@@ -0,0 +1 @@
+export {};