@zhijiewang/openharness 2.5.0 → 2.9.0

package/dist/components/InitWizard.js

@@ -92,6 +92,65 @@ export default function InitWizard({ onDone }) {
     const [selectedMcp, setSelectedMcp] = useState(new Set());
     const [mcpIdx, setMcpIdx] = useState(0);
     const provider = PROVIDERS[providerIdx];
+    // ── Connection test ──
+    const runTest = useCallback(async (prov, key, url) => {
+        setTestStatus("testing");
+        try {
+            const { createProviderInstance } = await import("../providers/index.js");
+            const p = createProviderInstance(prov.key, {
+                name: prov.key,
+                apiKey: key || process.env[`${prov.key.toUpperCase()}_API_KEY`],
+                baseUrl: url || prov.defaultBaseUrl,
+                defaultModel: prov.defaultModel,
+            });
+            const fetched = "fetchModels" in p && typeof p.fetchModels === "function"
+                ? await p.fetchModels()
+                : p.listModels();
+            const modelNames = fetched.map((m) => m.id);
+            setAvailableModels(modelNames.length > 0 ? modelNames : [prov.defaultModel]);
+            setTestStatus("ok");
+            setTimeout(() => setStep("model"), 600);
+        }
+        catch (err) {
+            setTestStatus("fail");
+            setTestError(err instanceof Error ? err.message : String(err));
+            setAvailableModels([prov.defaultModel]);
+            setTimeout(() => setStep("model"), 800);
+        }
+    }, []);
+    // ── Write final config ──
+    const writeFinal = useCallback(() => {
+        const selectedModel = availableModels.length > 0 ? (availableModels[modelIdx] ?? model) : model;
+        // Build MCP server configs from selected registry entries
+        let mcpServers;
+        if (selectedMcp.size > 0) {
+            try {
+                const { MCP_REGISTRY } = require("../mcp/registry.js");
+                mcpServers = [...selectedMcp]
+                    .map((name) => MCP_REGISTRY.find((e) => e.name === name))
+                    .filter(Boolean)
+                    .map((e) => ({
+                    name: e.name,
+                    command: "npx",
+                    args: ["-y", e.package, ...(e.args ?? [])],
+                    ...(e.envVars?.length ? { env: Object.fromEntries(e.envVars.map((v) => [v, `YOUR_${v}`])) } : {}),
+                }));
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        writeOhConfig({
+            provider: provider.key,
+            model: selectedModel || provider.defaultModel,
+            permissionMode: PERMISSION_MODES[permIdx].key,
+            ...(apiKey ? { apiKey } : {}),
+            ...(baseUrl ? { baseUrl } : {}),
+            ...(mcpServers?.length ? { mcpServers } : {}),
+        });
+        setStep("done");
+        setTimeout(() => onDone?.(), 1500);
+    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp, onDone]);
     // ── Keyboard navigation ──
     useInput(useCallback((input, key) => {
         if (step === "provider") {
@@ -175,68 +234,7 @@ export default function InitWizard({ onDone }) {
             if (input === "n" || input === "N")
                 writeFinal();
         }
-    }, 
-    // biome-ignore lint/correctness/useExhaustiveDependencies: runTest/writeFinal declared below, providerIdx intentionally omitted
-    [step, providerIdx, provider, modelIdx, availableModels, model, suggestedMcp, mcpIdx]));
-    // ── Connection test ──
-    const runTest = async (prov, key, url) => {
-        setTestStatus("testing");
-        try {
-            const { createProviderInstance } = await import("../providers/index.js");
-            const p = createProviderInstance(prov.key, {
-                name: prov.key,
-                apiKey: key || process.env[`${prov.key.toUpperCase()}_API_KEY`],
-                baseUrl: url || prov.defaultBaseUrl,
-                defaultModel: prov.defaultModel,
-            });
-            const fetched = "fetchModels" in p && typeof p.fetchModels === "function"
-                ? await p.fetchModels()
-                : p.listModels();
-            const modelNames = fetched.map((m) => m.id);
-            setAvailableModels(modelNames.length > 0 ? modelNames : [prov.defaultModel]);
-            setTestStatus("ok");
-            setTimeout(() => setStep("model"), 600);
-        }
-        catch (err) {
-            setTestStatus("fail");
-            setTestError(err instanceof Error ? err.message : String(err));
-            setAvailableModels([prov.defaultModel]);
-            setTimeout(() => setStep("model"), 800);
-        }
-    };
-    // ── Write final config ──
-    const writeFinal = useCallback(() => {
-        const selectedModel = availableModels.length > 0 ? (availableModels[modelIdx] ?? model) : model;
-        // Build MCP server configs from selected registry entries
-        let mcpServers;
-        if (selectedMcp.size > 0) {
-            try {
-                const { MCP_REGISTRY } = require("../mcp/registry.js");
-                mcpServers = [...selectedMcp]
-                    .map((name) => MCP_REGISTRY.find((e) => e.name === name))
-                    .filter(Boolean)
-                    .map((e) => ({
-                    name: e.name,
-                    command: "npx",
-                    args: ["-y", e.package, ...(e.args ?? [])],
-                    ...(e.envVars?.length ? { env: Object.fromEntries(e.envVars.map((v) => [v, `YOUR_${v}`])) } : {}),
-                }));
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        writeOhConfig({
-            provider: provider.key,
-            model: selectedModel || provider.defaultModel,
-            permissionMode: PERMISSION_MODES[permIdx].key,
-            ...(apiKey ? { apiKey } : {}),
-            ...(baseUrl ? { baseUrl } : {}),
-            ...(mcpServers?.length ? { mcpServers } : {}),
-        });
-        setStep("done");
-        setTimeout(() => onDone?.(), 1500);
-    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp, onDone]);
+    }, [step, provider, modelIdx, availableModels, model, suggestedMcp, mcpIdx, runTest, writeFinal]));
     // ── Render ──
     if (showSetup) {
         return (_jsx(CybergotchiSetup, { onComplete: () => {

package/dist/harness/config.d.ts

@@ -98,6 +98,17 @@ export type OhConfig = {
         rateLimit?: number;
         allowedTools?: string[];
     };
+    /**
+     * Environment variables injected into child processes spawned by the harness —
+     * Bash/Monitor/PowerShell tool executions and MCP server subprocesses. Useful
+     * for passing API keys to MCP servers without embedding them in the server's
+     * `env` field (which is per-server) or requiring the user to export them in
+     * their shell. Claude Code convention: same shape as `settings.json.env`.
+     *
+     * Implementation: read by `safeEnv()` in `src/utils/safe-env.ts` — every
+     * call-site that already uses `safeEnv()` picks this up automatically.
+     */
+    env?: Record<string, string>;
 };
 /** Clear cached config (call after writes or to force re-read) */
 export declare function invalidateConfigCache(): void;

package/dist/harness/hooks.d.ts

@@ -9,6 +9,7 @@
  * - http: POST JSON to URL, expect { allowed: true/false }
  * - prompt: LLM yes/no check via provider.complete()
  */
+import type { HookDef } from "./config.js";
 export type HookEvent = "sessionStart" | "sessionEnd" | "preToolUse" | "postToolUse" | "fileChanged" | "cwdChanged" | "subagentStart" | "subagentStop" | "preCompact" | "postCompact" | "configChange" | "notification";
 export type HookContext = {
     toolName?: string;
@@ -32,6 +33,19 @@ export type HookContext = {
 };
 /** Clear hook cache (call after config changes) */
 export declare function invalidateHookCache(): void;
+/**
+ * Evaluate a hook matcher against the current tool name.
+ *
+ * Supported forms (Claude Code compatible):
+ *  - No matcher → always matches.
+ *  - `/pattern/flags` → treated as a regex. Flags optional.
+ *  - `mcp__server__tool` → literal match is a substring check (works for the
+ *    standard `mcp__<server>__<tool>` naming convention).
+ *  - `prefix*` or glob-ish → simple wildcard translated to regex.
+ *  - Anything else → case-sensitive substring (legacy behavior — back-compat).
+ */
+/** @internal Exposed for testing. */
+export declare function matchesHook(def: HookDef, ctx: HookContext): boolean;
 /**
  * Emit a hook event. For preToolUse, returns false if any hook blocks the call.
  *

package/dist/harness/hooks.js

@@ -58,11 +58,54 @@ function buildEnv(event, ctx) {
         env.OH_MESSAGE = ctx.message;
     return env;
 }
-function matchesHook(def, ctx) {
-    if (def.match && ctx.toolName && !ctx.toolName.includes(def.match)) {
-        return false;
+/**
+ * Evaluate a hook matcher against the current tool name.
+ *
+ * Supported forms (Claude Code compatible):
+ *  - No matcher → always matches.
+ *  - `/pattern/flags` → treated as a regex. Flags optional.
+ *  - `mcp__server__tool` → literal match is a substring check (works for the
+ *    standard `mcp__<server>__<tool>` naming convention).
+ *  - `prefix*` or glob-ish → simple wildcard translated to regex.
+ *  - Anything else → case-sensitive substring (legacy behavior — back-compat).
+ */
+/** @internal Exposed for testing. */
+export function matchesHook(def, ctx) {
+    if (!def.match)
+        return true;
+    if (!ctx.toolName)
+        return true;
+    const match = def.match;
+    // /regex/flags form
+    if (match.length > 2 && match.startsWith("/")) {
+        const lastSlash = match.lastIndexOf("/");
+        if (lastSlash > 0) {
+            try {
+                const pattern = match.slice(1, lastSlash);
+                const flags = match.slice(lastSlash + 1);
+                return new RegExp(pattern, flags).test(ctx.toolName);
+            }
+            catch {
+                return false;
+            }
+        }
     }
-    return true;
+    // Simple glob: asterisks translated to `.*`, anchored. Only activates if the
+    // match contains an asterisk — otherwise treat as substring for back-compat.
+    if (match.includes("*")) {
+        const escaped = match
+            .split("*")
+            .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+            .join(".*");
+        try {
+            return new RegExp(`^${escaped}$`).test(ctx.toolName);
+        }
+        catch {
+            return false;
+        }
+    }
+    // Legacy substring match
+    return ctx.toolName.includes(match);
 }
 // ── Hook Executors ──
 /** Run a command hook. Returns exit code (0 = success/allowed). */
@@ -117,13 +160,16 @@ async function runHttpHook(url, event, ctx, timeoutMs = 10_000) {
         return false;
     }
 }
-/** Run a prompt hook. Uses LLM to make a yes/no decision. */
+/**
+ * Run a prompt hook. Uses LLM to make a yes/no decision.
+ *
+ * Currently a stub — prompt hooks always allow because the hook system
+ * runs outside the query loop and has no access to a Provider instance.
+ * Full implementation requires passing a Provider via HookContext so the
+ * hook can call provider.complete() with the prompt text.
+ */
 async function runPromptHook(_promptText, _ctx) {
-    // Prompt hooks require a provider — skip if not available
-    // This is a lightweight check; full LLM call would need provider injection
-    // For now, prompt hooks evaluate the prompt text as a simple template
-    // TODO: inject provider for full LLM-based prompt hooks
-    return true; // Default allow if no LLM available
+    return true;
 }
 // ── Hook Execution ──
 /** Execute a single hook definition. Returns true if allowed. */

package/dist/harness/marketplace.d.ts

@@ -36,8 +36,76 @@ export type InstalledPlugin = {
     marketplace: string;
     installedAt: number;
     cachePath: string;
+    /** Optional fields populated from `.claude-plugin/plugin.json` if present */
+    description?: string;
+    author?: string;
+    license?: string;
+    homepage?: string;
+    keywords?: string[];
+};
+/** Claude Code plugin manifest (`.claude-plugin/plugin.json`).
+ * Required: name, description. All other fields optional.
+ */
+export type CcPluginManifest = {
+    name: string;
+    description: string;
+    version?: string;
+    author?: {
+        name?: string;
+        email?: string;
+    } | string;
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    keywords?: string[];
+};
+/** Parse a `.claude-plugin/plugin.json` file at the given plugin root, or null if missing/invalid. */
+export declare function parseCcPluginManifest(pluginRoot: string): CcPluginManifest | null;
+/** Claude Code marketplace.json format — superset of OH's marketplace.json with source-typed entries. */
+export type CcMarketplacePluginSource = string | {
+    source: "github";
+    repo: string;
+    ref?: string;
+} | {
+    source: "url";
+    url: string;
+} | {
+    source: "npm";
+    package: string;
+    version?: string;
+};
+export type CcMarketplaceEntry = {
+    name: string;
+    description?: string;
+    version?: string;
+    author?: {
+        name?: string;
+        email?: string;
+    } | string;
+    source: CcMarketplacePluginSource;
 };
-/** Add a marketplace from a URL, GitHub repo, or local path */
+export type CcMarketplace = {
+    name: string;
+    description?: string;
+    owner?: {
+        name?: string;
+        email?: string;
+    };
+    plugins: CcMarketplaceEntry[];
+};
+/** Convert a CcMarketplace to OH's internal Marketplace type (lossy: dropped fields like `owner` are not stored). */
+export declare function ccMarketplaceToOh(cc: CcMarketplace): Marketplace;
+/** Parse marketplace JSON text. Tries CC format (.claude-plugin/marketplace.json shape) first, falls back to OH-native. */
+export declare function parseMarketplaceJson(text: string): Marketplace | null;
+/** Discover plugin-shipped MCP servers from `cachePath/.mcp.json`. Returns raw object for the runtime to merge. */
+export declare function getPluginMcpServers(cachePath: string): Record<string, unknown> | null;
+/** Discover plugin-shipped hooks from `cachePath/hooks/hooks.json`. Returns raw config for the runtime to register. */
+export declare function getPluginHooks(cachePath: string): Record<string, unknown> | null;
+/** Discover plugin-shipped LSP servers from `cachePath/.lsp.json`. Returns raw config for the runtime to register. */
+export declare function getPluginLspServers(cachePath: string): Record<string, unknown> | null;
+/** Add a marketplace from a URL, GitHub repo, or local path.
+ * Probes for both OH-native `marketplace.json` and Claude Code `.claude-plugin/marketplace.json`.
+ */
 export declare function addMarketplace(nameOrUrl: string): Marketplace | null;
 /** Remove a marketplace */
 export declare function removeMarketplace(name: string): boolean;
@@ -51,7 +119,14 @@ export declare function searchMarketplace(query: string): Array<MarketplaceEntry
 export declare function installPlugin(pluginName: string, marketplaceName?: string): InstalledPlugin | null;
 /** Uninstall a plugin */
 export declare function uninstallPlugin(name: string): boolean;
-/** Get all installed plugins */
+/** Get all installed plugins.
+ * Sources merged in priority order:
+ * 1. installed.json (plugins installed via /plugin install or addMarketplace flow)
+ * 2. CC-style plugins discovered in PLUGIN_CACHE_DIR via .claude-plugin/plugin.json
+ *    (covers plugins manually dropped in the cache, or installed by parallel tooling)
+ * Plugins from #1 are enriched with manifest data if their cachePath has one.
+ * De-duplication is by cachePath.
+ */
 export declare function getInstalledPlugins(): InstalledPlugin[];
 /** Format marketplace entries for display */
 export declare function formatMarketplaceSearch(results: Array<MarketplaceEntry & {