@zhijiewang/openharness 2.8.0 → 2.9.0

package/dist/commands/skills.js

@@ -1,9 +1,38 @@
 /**
- * Skill management commands — /skill-create, /skill-delete, /skill-edit, /skill-search, /skill-install
+ * Skill management commands — /skills, /skill-create, /skill-delete, /skill-edit, /skill-search, /skill-install
  */
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { discoverSkills } from "../harness/plugins.js";
 export function registerSkillCommands(register) {
+    register("skills", "List all available skills", () => {
+        const skills = discoverSkills();
+        if (skills.length === 0) {
+            return {
+                output: "No skills found. Create .oh/skills/*.md to add one, or run /skill-search to browse the registry.",
+                handled: true,
+            };
+        }
+        // Group by source for readability
+        const lines = ["Available skills:"];
+        const sourceLabel = {
+            project: "[project]",
+            global: "[global]",
+            plugin: "[plugin]",
+        };
+        // Sort: bundled-style (project, no path under .oh) first, then by source then name
+        const sorted = [...skills].sort((a, b) => {
+            if (a.source !== b.source)
+                return a.source.localeCompare(b.source);
+            return a.name.localeCompare(b.name);
+        });
+        for (const s of sorted) {
+            const tag = sourceLabel[s.source] ?? `[${s.source}]`;
+            const desc = s.description ? `: ${s.description}` : "";
+            lines.push(`  - ${s.name} ${tag}${desc}`);
+        }
+        return { output: lines.join("\n"), handled: true };
+    });
     register("skill-create", "Create a new skill file", (args) => {
         const name = args.trim();
         if (!name)
@@ -92,10 +121,21 @@ How to confirm the skill worked correctly.
         });
         return { output: "Searching skills registry...", handled: true };
     });
-    register("skill-install", "Install a skill from the registry", (args) => {
-        const name = args.trim();
+    register("skill-install", "Install a skill from the registry. Use --accept-license=<SPDX> for non-permissive licenses.", (args) => {
+        // Parse: <name> [--accept-license=<SPDX>]
+        const tokens = args.trim().split(/\s+/).filter(Boolean);
+        if (tokens.length === 0)
+            return { output: "Usage: /skill-install <name> [--accept-license=<SPDX>]", handled: true };
+        let name = "";
+        let acceptLicense;
+        for (const tok of tokens) {
+            if (tok.startsWith("--accept-license="))
+                acceptLicense = tok.slice("--accept-license=".length);
+            else if (!name)
+                name = tok;
+        }
         if (!name)
-            return { output: "Usage: /skill-install <name>", handled: true };
+            return { output: "Usage: /skill-install <name> [--accept-license=<SPDX>]", handled: true };
         import("../harness/skill-registry.js").then(async ({ fetchRegistry, installSkill }) => {
             try {
                 const registry = await fetchRegistry();
@@ -104,8 +144,13 @@ How to confirm the skill worked correctly.
                     console.log(`Skill "${name}" not found in registry. Try /skill-search first.`);
                     return;
                 }
-                const path = await installSkill(skill);
-                console.log(`Installed skill "${skill.name}" to ${path}`);
+                const result = await installSkill(skill, { acceptLicense });
+                if (result.ok) {
+                    console.log(`Installed skill "${skill.name}" to ${result.filePath}`);
+                }
+                else {
+                    console.log(result.message);
+                }
             }
             catch (err) {
                 console.log(`Installation failed: ${err.message}`);

package/dist/components/App.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { getCompanionSystemPrompt, loadCompanionRuntime } from "../cybergotchi/config.js";
 import { readOhConfig } from "../harness/config.js";
-import { loadMemories, memoriesToPrompt } from "../harness/memory.js";
+import { claudeMdToPrompt, loadClaudeMdHierarchy, loadMemories, memoriesToPrompt } from "../harness/memory.js";
 import { detectProject, projectContextToPrompt } from "../harness/onboarding.js";
 import { discoverSkills, skillsToPrompt } from "../harness/plugins.js";
 import { loadRulesAsPrompt } from "../harness/rules.js";
@@ -59,6 +59,12 @@ export default function App({ provider, tools, permissionMode, systemPrompt, mod
         const rulesPrompt = loadRulesAsPrompt();
         if (rulesPrompt)
             parts.push(rulesPrompt);
+        // CLAUDE.md: hierarchical project instructions (Anthropic convention).
+        // Additive with OH's own memory system — both layers inject into the prompt.
+        const claudeMd = loadClaudeMdHierarchy();
+        const claudeMdPrompt = claudeMdToPrompt(claudeMd);
+        if (claudeMdPrompt)
+            parts.push(claudeMdPrompt);
         // Auto-memory: load saved learnings into context
         const memories = loadMemories();
         const memoryPrompt = memoriesToPrompt(memories);

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). */

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 & {

package/dist/harness/marketplace.js

@@ -7,59 +7,196 @@
  * Inspired by Claude Code's marketplace model.
  */
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 const MARKETPLACE_DIR = join(homedir(), ".oh", "marketplaces");
 const PLUGIN_CACHE_DIR = join(homedir(), ".oh", "plugins", "cache");
 const INSTALLED_PLUGINS_FILE = join(homedir(), ".oh", "plugins", "installed.json");
+// Claude Code plugin manifest path relative to plugin root
+const CC_MANIFEST_PATH = join(".claude-plugin", "plugin.json");
+/** Parse a `.claude-plugin/plugin.json` file at the given plugin root, or null if missing/invalid. */
+export function parseCcPluginManifest(pluginRoot) {
+    const path = join(pluginRoot, CC_MANIFEST_PATH);
+    if (!existsSync(path))
+        return null;
+    try {
+        const m = JSON.parse(readFileSync(path, "utf-8"));
+        if (typeof m?.name !== "string" || typeof m?.description !== "string")
+            return null;
+        return m;
+    }
+    catch {
+        return null;
+    }
+}
+/** Convert a CcMarketplace to OH's internal Marketplace type (lossy: dropped fields like `owner` are not stored). */
+export function ccMarketplaceToOh(cc) {
+    const plugins = [];
+    for (const p of cc.plugins) {
+        const ohSource = ccSourceToOh(p.source);
+        if (!ohSource)
+            continue; // Skip relative-path sources — only resolvable inside the marketplace repo
+        plugins.push({
+            name: p.name,
+            description: p.description ?? "",
+            version: p.version ?? "0.0.0",
+            author: typeof p.author === "string" ? p.author : p.author?.name,
+            source: ohSource,
+        });
+    }
+    return { name: cc.name, version: 1, description: cc.description, plugins };
+}
+function ccSourceToOh(src) {
+    if (typeof src === "string")
+        return null; // relative paths require marketplace-repo context
+    if (src.source === "github")
+        return { type: "github", repo: src.repo };
+    if (src.source === "url")
+        return { type: "url", url: src.url };
+    if (src.source === "npm")
+        return { type: "npm", package: src.package };
+    return null;
+}
+/** Parse marketplace JSON text. Tries CC format (.claude-plugin/marketplace.json shape) first, falls back to OH-native. */
+export function parseMarketplaceJson(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!raw || typeof raw !== "object")
+        return null;
+    const obj = raw;
+    if (!Array.isArray(obj.plugins))
+        return null;
+    // Detect CC format: any plugin entry has either a string `source` or `source.source` (kind tag)
+    const looksCc = obj.plugins.some((p) => {
+        if (!p || typeof p !== "object")
+            return false;
+        const s = p.source;
+        return typeof s === "string" || (s !== null && typeof s === "object" && "source" in s);
+    });
+    if (looksCc) {
+        return ccMarketplaceToOh(obj);
+    }
+    // OH-native format
+    return obj;
+}
+/** Discover plugin-shipped MCP servers from `cachePath/.mcp.json`. Returns raw object for the runtime to merge. */
+export function getPluginMcpServers(cachePath) {
+    const path = join(cachePath, ".mcp.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf-8"));
+        // Claude Code shape: { "mcpServers": { name: { command, args, env, ... } } }
+        // Some plugins store the inner map directly. Accept both.
+        if (data && typeof data === "object") {
+            if ("mcpServers" in data && typeof data.mcpServers === "object")
+                return data.mcpServers;
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Discover plugin-shipped hooks from `cachePath/hooks/hooks.json`. Returns raw config for the runtime to register. */
+export function getPluginHooks(cachePath) {
+    const path = join(cachePath, "hooks", "hooks.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf-8"));
+        if (data && typeof data === "object")
+            return data;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Discover plugin-shipped LSP servers from `cachePath/.lsp.json`. Returns raw config for the runtime to register. */
+export function getPluginLspServers(cachePath) {
+    const path = join(cachePath, ".lsp.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf-8"));
+        if (data && typeof data === "object") {
+            if ("lspServers" in data && typeof data.lspServers === "object")
+                return data.lspServers;
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // ── Marketplace Management ──
-/** Add a marketplace from a URL, GitHub repo, or local path */
+/** 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 function addMarketplace(nameOrUrl) {
     mkdirSync(MARKETPLACE_DIR, { recursive: true });
-    // Fetch marketplace.json
-    let data;
+    // Candidate filenames to try, in priority order
+    const candidatePaths = ["marketplace.json", ".claude-plugin/marketplace.json"];
+    let data = null;
     let marketplaceName;
     if (nameOrUrl.startsWith("http")) {
-        // URL
-        try {
-            data = execSync(`curl -sL "${nameOrUrl}/marketplace.json"`, { encoding: "utf-8", timeout: 10_000 });
-            marketplaceName = new URL(nameOrUrl).hostname;
-        }
-        catch {
-            return null;
+        marketplaceName = new URL(nameOrUrl).hostname;
+        for (const fname of candidatePaths) {
+            try {
+                const text = execSync(`curl -sfL "${nameOrUrl}/${fname}"`, { encoding: "utf-8", timeout: 10_000 });
+                if (text.trim()) {
+                    data = text;
+                    break;
+                }
+            }
+            catch {
+                /* try next */
+            }
         }
     }
     else if (nameOrUrl.includes("/") && !nameOrUrl.startsWith(".")) {
-        // GitHub repo (owner/repo format)
-        try {
-            const url = `https://raw.githubusercontent.com/${nameOrUrl}/main/marketplace.json`;
-            data = execSync(`curl -sL "${url}"`, { encoding: "utf-8", timeout: 10_000 });
-            marketplaceName = nameOrUrl.replace("/", "-");
-        }
-        catch {
-            return null;
+        marketplaceName = nameOrUrl.replace("/", "-");
+        for (const fname of candidatePaths) {
+            try {
+                const url = `https://raw.githubusercontent.com/${nameOrUrl}/main/${fname}`;
+                const text = execSync(`curl -sfL "${url}"`, { encoding: "utf-8", timeout: 10_000 });
+                if (text.trim()) {
+                    data = text;
+                    break;
+                }
+            }
+            catch {
+                /* try next */
+            }
         }
     }
-    else if (existsSync(join(nameOrUrl, "marketplace.json"))) {
-        // Local path
-        data = readFileSync(join(nameOrUrl, "marketplace.json"), "utf-8");
+    else {
         marketplaceName = basename(nameOrUrl);
+        for (const fname of candidatePaths) {
+            const path = join(nameOrUrl, fname);
+            if (existsSync(path)) {
+                data = readFileSync(path, "utf-8");
+                break;
+            }
+        }
     }
-    else {
+    if (!data)
         return null;
-    }
-    try {
-        const marketplace = JSON.parse(data);
-        if (!marketplace.plugins || !Array.isArray(marketplace.plugins))
-            return null;
-        marketplace.name = marketplace.name ?? marketplaceName;
-        writeFileSync(join(MARKETPLACE_DIR, `${marketplace.name}.json`), JSON.stringify(marketplace, null, 2));
-        return marketplace;
-    }
-    catch {
+    const marketplace = parseMarketplaceJson(data);
+    if (!marketplace)
         return null;
-    }
+    marketplace.name = marketplace.name ?? marketplaceName;
+    writeFileSync(join(MARKETPLACE_DIR, `${marketplace.name}.json`), JSON.stringify(marketplace, null, 2));
+    return marketplace;
 }
 /** Remove a marketplace */
 export function removeMarketplace(name) {
@@ -199,17 +336,102 @@ export function uninstallPlugin(name) {
     saveInstalledPluginList(remaining);
     return true;
 }
-/** 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 function getInstalledPlugins() {
-    if (!existsSync(INSTALLED_PLUGINS_FILE))
-        return [];
+    const recorded = (() => {
+        if (!existsSync(INSTALLED_PLUGINS_FILE))
+            return [];
+        try {
+            return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, "utf-8"));
+        }
+        catch {
+            return [];
+        }
+    })();
+    // Enrich recorded plugins from their CC manifest if present
+    const enriched = recorded.map((p) => mergeManifest(p, parseCcPluginManifest(p.cachePath)));
+    const seenPaths = new Set(enriched.map((p) => p.cachePath));
+    // Discover CC-style plugins in PLUGIN_CACHE_DIR not already recorded
+    const discovered = [];
+    if (existsSync(PLUGIN_CACHE_DIR)) {
+        try {
+            for (const nameEntry of readdirSync(PLUGIN_CACHE_DIR)) {
+                const nameDir = join(PLUGIN_CACHE_DIR, nameEntry);
+                if (!safeIsDirectory(nameDir))
+                    continue;
+                // Plugin can sit either at <name>/ or <name>/<version>/
+                const candidates = [nameDir, ...listSubdirs(nameDir)];
+                for (const root of candidates) {
+                    if (seenPaths.has(root))
+                        continue;
+                    const manifest = parseCcPluginManifest(root);
+                    if (!manifest)
+                        continue;
+                    discovered.push({
+                        name: manifest.name,
+                        version: manifest.version ?? "0.0.0",
+                        marketplace: "discovered",
+                        installedAt: tryStatTime(root),
+                        cachePath: root,
+                        ...projectManifestFields(manifest),
+                    });
+                    seenPaths.add(root);
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return [...enriched, ...discovered];
+}
+function safeIsDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function listSubdirs(dir) {
     try {
-        return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, "utf-8"));
+        return readdirSync(dir)
+            .map((entry) => join(dir, entry))
+            .filter((p) => safeIsDirectory(p));
     }
     catch {
         return [];
     }
 }
+function tryStatTime(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return Date.now();
+    }
+}
+function projectManifestFields(m) {
+    return {
+        description: m.description,
+        author: typeof m.author === "string" ? m.author : m.author?.name,
+        license: m.license,
+        homepage: m.homepage,
+        keywords: m.keywords,
+    };
+}
+function mergeManifest(plugin, manifest) {
+    if (!manifest)
+        return plugin;
+    return { ...plugin, ...projectManifestFields(manifest) };
+}
 function saveInstalledPlugin(plugin) {
     const installed = getInstalledPlugins();
     // Replace existing version