rovecode 0.3.2 → 0.4.0-beta.2

package/src/plugins/index.ts

@@ -1,50 +0,0 @@
-/** Plugins (the package, not the surface). A plugin is a folder with a `plugin.json` that bundles what
- *  rovecode can already be extended with — an in-process module of tools and hooks, custom commands,
- *  skills, MCP servers — so one `rovecode plugin add` installs all of it, `plugin list` shows all of it,
- *  and a project can ship its own under `.rovecode/plugins/` behind a per-machine trust step.
- *
- *  Module map: manifest.ts (plugin.json → PluginManifest) · state.ts (~/.rovecode/plugins.json:
- *  disabled + trusted digests) · discover.ts (the two roots → DiscoveredPlugin with a status, no code
- *  run) · load.ts (import + validate the active ones → typed contributions) · install.ts (the human's
- *  verbs) · cli.ts (`rovecode plugin …`). `loadPlugins` is the one call the runtime makes. */
-
-import { rovecodeHome } from "../providers/auth.ts";
-import { discoverPlugins, type DiscoveredPlugin } from "./discover.ts";
-import { activatePlugins, type LoadedPlugin } from "./load.ts";
-import { loadState } from "./state.ts";
-
-export type { PluginManifest } from "./manifest.ts";
-export { PLUGIN_API_VERSION, MANIFEST_FILE, parseManifest, contributions } from "./manifest.ts";
-export type { PluginState } from "./state.ts";
-export { loadState, saveState, statePath, pluginDigest, pluginFiles } from "./state.ts";
-export type { DiscoveredPlugin, PluginScope, PluginStatus } from "./discover.ts";
-export { discoverPlugins, pluginRoots } from "./discover.ts";
-export type { LoadedPlugin, PluginModule, PluginCtx } from "./load.ts";
-export { activatePlugins, DEFAULT_PLUGIN_TIMEOUT_MS } from "./load.ts";
-export { addPlugin, removePlugin, setPluginEnabled, trustPlugin, untrustPlugin, scopeRoot, isGitSource } from "./install.ts";
-export { cmdPlugin, PLUGIN_USAGE } from "./cli.ts";
-
-export interface LoadPluginsOptions { home?: string; timeoutMs?: number }
-export interface LoadedPlugins {
-  /** every discovered plugin, active ones carrying their contributions */
-  plugins: LoadedPlugin[];
-  /** discovery + activation notes, in order — for the boot transcript */
-  warnings: string[];
-}
-
-/** discover, then activate the active ones; the runtime's single entry point */
-export async function loadPlugins(cwd: string, opts: LoadPluginsOptions = {}): Promise<LoadedPlugins> {
-  const home = opts.home ?? rovecodeHome();
-  const found = discoverPlugins(cwd, { home, state: loadState(home) });
-  const act = await activatePlugins(found.plugins, { cwd, home, ...(opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}) });
-  return { plugins: act.plugins, warnings: [...found.warnings, ...act.warnings] };
-}
-
-/** one line per plugin the boot transcript can echo: `plugins: 2 active (safety-net, notes) · 1 untrusted (acme)` */
-export function summarizePlugins(p: readonly Pick<DiscoveredPlugin, "name" | "status">[]): string | null {
-  if (p.length === 0) return null;
-  const by = (s: DiscoveredPlugin["status"]): string[] => p.filter((x) => x.status === s).map((x) => x.name);
-  const parts: string[] = [];
-  for (const s of ["active", "untrusted", "disabled", "broken"] as const) { const n = by(s); if (n.length) parts.push(`${n.length} ${s} (${n.join(", ")})`); }
-  return `plugins: ${parts.join(" · ")}`;
-}

package/src/plugins/install.ts

@@ -1,184 +0,0 @@
-/** Plugins: the human's verbs — add, remove, enable, disable, trust. Each is a small filesystem
- *  operation plus a plugins.json edit; none imports plugin code (that is load.ts, at runtime, after
- *  these decisions). `add` takes a folder or a git URL: a URL is cloned shallow into a temp folder and
- *  from there on treated exactly like a folder (validated BEFORE anything is copied into place — a
- *  folder without a usable manifest never lands in ~/.rovecode/plugins). Adding into the project scope
- *  records the folder's digest as trusted: the human ran the command, that is the yes. */
-
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve, sep } from "node:path";
-import { pluginRoots, type PluginScope } from "./discover.ts";
-import { MANIFEST_FILE, parseManifest, type PluginManifest } from "./manifest.ts";
-import { isDir, loadState, pluginDigest, saveState, trustKey } from "./state.ts";
-
-export type Spawn = (cmd: string[], cwd: string) => Promise<{ code: number; stderr: string }>;
-/** the copy step, injectable for one reason: a test cannot otherwise arrange a copy that fails PART WAY
- *  through, which is the only failure the staging directory exists to survive. A real half-copy needs a
- *  full disk or a locked file; a fake one needs three lines. */
-export type CopyTree = (from: string, to: string, filter: (path: string) => boolean) => void;
-export interface InstallOptions {
-  cwd: string;
-  home: string;
-  scope: PluginScope;
-  /** replace an existing plugin of the same name */
-  force?: boolean;
-  /** the plugin's folder INSIDE the source, when the source is a repository that publishes several.
-   *
-   *  Every real plugin is one: rovecode's own three live in `plugins/safety-net`, `plugins/notes` and
-   *  `plugins/conventional-commits`, and a catalog could not install any of them while `add` only looked
-   *  at the clone root. Rejected rather than normalised: an absolute path, a drive letter, or any `..`
-   *  segment — a subfolder that climbs out of the clone is an attempt, not a typo. */
-  subfolder?: string;
-  /** see {@link CopyTree} — real installs never pass this */
-  copy?: CopyTree;
-  /** Clones already made during THIS command, keyed by `cloneKey`. One monorepo publishes all three
-   *  first-party plugins, so installing them today clones the same repository three times — measured at
-   *  15.5 s per plugin install, 28.3 s for a project-scope one. The map is opened per command and disposed
-   *  with `disposeCloneCache`; nothing here caches across commands, because a clone that outlives the
-   *  command it was made for is a stale tree waiting to be installed from. */
-  cloneCache?: Map<string, string>;
-  /** how `git clone` runs; default Bun.spawn — tests inject one that never touches the network */
-  spawn?: Spawn;
-}
-
-/** The key a clone is cached under.
- *
- *  `ref` is not something `addPlugin` takes yet — pinning is not implemented — but it is part of the key
- *  from the start, and deliberately so: a cache keyed on the URL alone hands back the wrong tree the day
- *  two refs of one repository are in play, and that bug would appear in a feature far away from here. With
- *  the key in one function, whoever adds pinning changes this and every caller inherits it. */
-export const cloneKey = (source: string, ref?: string): string => `${source}#${ref ?? ""}`;
-
-/** Remove every clone a command made. Call it in a `finally`: a half-written clone that outlives its
- *  command is litter in %TEMP% that nobody will ever look at again. */
-export function disposeCloneCache(cache: Map<string, string> | undefined): void {
-  if (cache === undefined) return;
-  for (const dir of cache.values()) rmSync(dir, { recursive: true, force: true });
-  cache.clear();
-}
-export type AddResult = { ok: true; name: string; dir: string; scope: PluginScope; manifest: PluginManifest } | { ok: false; error: string };
-
-const GIT_URL_RE = /^(?:https?:\/\/|git@|ssh:\/\/|git:\/\/)|\.git$/i;
-export const isGitSource = (s: string): boolean => GIT_URL_RE.test(s) && !existsSync(s);
-
-const defaultSpawn: Spawn = async (cmd, cwd) => {
-  const proc = Bun.spawn(cmd, { cwd, stdout: "ignore", stderr: "pipe", stdin: "ignore" });
-  const stderr = await new Response(proc.stderr).text();
-  return { code: await proc.exited, stderr };
-};
-
-/** the folder a scope's plugins live in */
-export function scopeRoot(scope: PluginScope, cwd: string, home: string): string {
-  return pluginRoots(cwd, home).find(([s]) => s === scope)?.[1] ?? join(home, "plugins");
-}
-
-/** true for a symbolic link; an entry we cannot stat is treated as one and skipped */
-function isSymlink(p: string): boolean {
-  try { return lstatSync(p).isSymbolicLink(); } catch { return true; }
-}
-
-export async function addPlugin(source: string, opts: InstallOptions): Promise<AddResult> {
-  let src = source, tmp: string | null = null;
-  const copy: CopyTree = opts.copy ?? ((from, to, filter) => cpSync(from, to, { recursive: true, filter }));
-  try {
-    if (isGitSource(source)) {
-      const key = cloneKey(source);
-      const cached = opts.cloneCache?.get(key);
-      if (cached !== undefined && isDir(cached)) {
-        src = cached;                       // owned by the cache, so `tmp` stays null and nothing is removed
-      } else {
-        tmp = mkdtempSync(join(tmpdir(), "rovecode-plugin-"));
-        const r = await (opts.spawn ?? defaultSpawn)(["git", "clone", "--depth", "1", "--quiet", "--", source, "."], tmp);
-        if (r.code !== 0) return { ok: false, error: `git clone failed (exit ${r.code})${r.stderr.trim() ? `: ${r.stderr.trim().split("\n").at(-1)}` : ""}` };
-        src = tmp;
-        if (opts.cloneCache !== undefined) { opts.cloneCache.set(key, tmp); tmp = null; }   // ownership moves
-      }
-    }
-    src = resolve(src);
-    if (opts.subfolder !== undefined && opts.subfolder !== "") {
-      const sub = opts.subfolder.split("\\").join("/");
-      if (sub.startsWith("/") || /^[A-Za-z]:/.test(sub) || sub.split("/").includes("..")) {
-        return { ok: false, error: `subfolder "${opts.subfolder}" escapes the source` };
-      }
-      const inner = resolve(join(src, sub));
-      // resolve() alone is not the check: it happily returns a path outside src for a crafted input
-      if (inner !== src && !inner.startsWith(src + sep)) return { ok: false, error: `subfolder "${opts.subfolder}" escapes the source` };
-      if (!isDir(inner)) return { ok: false, error: `${source}: no folder "${opts.subfolder}" inside it` };
-      src = inner;
-    }
-    if (!isDir(src)) return { ok: false, error: `${source}: not a directory` };
-    const file = join(src, MANIFEST_FILE);
-    if (!existsSync(file)) return { ok: false, error: `${source}: no ${MANIFEST_FILE} — a plugin is a folder with a manifest` };
-    const warnings: string[] = [];
-    const manifest = parseManifest(readFileSync(file, "utf8"), file, warnings);
-    if (manifest === null) return { ok: false, error: warnings.join("; ") || `${file}: invalid manifest` };
-    const root = scopeRoot(opts.scope, opts.cwd, opts.home);
-    const dest = join(root, manifest.name);
-    if (resolve(dest) === src) return { ok: false, error: `${source} is already the installed copy` };
-    if (existsSync(dest) && !opts.force) return { ok: false, error: `plugin "${manifest.name}" already exists at ${dest} (use --force to replace)` };
-    // Copied beside the target and swapped in. `rmSync(dest)` then `cpSync` reads naturally and is wrong:
-    // between those two lines the plugin does not exist, and anything that ends the copy early — a full
-    // disk, a file another process holds open on Windows, ^C during `market update --all` — has already
-    // deleted a working plugin and leaves a half-written folder wearing its name. Rename is the one step
-    // the filesystem will not perform half way.
-    mkdirSync(root, { recursive: true });
-    const staging = mkdtempSync(join(root, `.rovecode-add-${manifest.name}-`));
-    try {
-      copy(src, staging, (p) => !/(?:^|[\\/])(?:node_modules|\.git)(?:[\\/]|$)/.test(p) && !isSymlink(p));
-      if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
-      renameSync(staging, dest);
-    } catch (e) {
-      // a returned error, not a thrown one: every other way this function fails is a value, and `market
-      // install a b c` should report which one could not be copied and carry on with the rest
-      return { ok: false, error: `could not install "${manifest.name}" into ${dest}: ${e instanceof Error ? e.message : String(e)}` };
-    } finally {
-      rmSync(staging, { recursive: true, force: true });   // already gone once the rename succeeded
-    }
-    if (opts.scope === "project") { // the human installed it: trust this exact content on this machine
-      const state = loadState(opts.home);
-      state.trusted[trustKey(dest)] = pluginDigest(dest);
-      saveState(opts.home, state);
-    }
-    return { ok: true, name: manifest.name, dir: dest, scope: opts.scope, manifest };
-  } finally {
-    if (tmp) rmSync(tmp, { recursive: true, force: true });
-  }
-}
-
-export function removePlugin(name: string, opts: { cwd: string; home: string; scope: PluginScope }): { ok: true; dir: string } | { ok: false; error: string } {
-  const dir = join(scopeRoot(opts.scope, opts.cwd, opts.home), name);
-  if (!isDir(dir)) return { ok: false, error: `no ${opts.scope} plugin "${name}" at ${dir}` };
-  rmSync(dir, { recursive: true, force: true });
-  const state = loadState(opts.home);
-  delete state.trusted[trustKey(dir)];
-  saveState(opts.home, state);
-  return { ok: true, dir };
-}
-
-export function setPluginEnabled(name: string, enabled: boolean, home: string): string {
-  const state = loadState(home);
-  state.disabled = state.disabled.filter((n) => n !== name);
-  if (!enabled) state.disabled.push(name);
-  return saveState(home, state);
-}
-
-/** approve a project plugin's CURRENT content; a later change to any file asks again */
-export function trustPlugin(name: string, opts: { cwd: string; home: string }): { ok: true; dir: string; digest: string } | { ok: false; error: string } {
-  const dir = join(scopeRoot("project", opts.cwd, opts.home), name);
-  if (!isDir(dir) || !existsSync(join(dir, MANIFEST_FILE))) return { ok: false, error: `no project plugin "${name}" under ${scopeRoot("project", opts.cwd, opts.home)}` };
-  const digest = pluginDigest(dir);
-  const state = loadState(opts.home);
-  state.trusted[trustKey(dir)] = digest;
-  saveState(opts.home, state);
-  return { ok: true, dir, digest };
-}
-
-export function untrustPlugin(name: string, opts: { cwd: string; home: string }): boolean {
-  const dir = join(scopeRoot("project", opts.cwd, opts.home), name);
-  const state = loadState(opts.home);
-  const had = trustKey(dir) in state.trusted;
-  delete state.trusted[trustKey(dir)];
-  saveState(opts.home, state);
-  return had;
-}

package/src/plugins/load.ts

@@ -1,124 +0,0 @@
-/** Plugins: activation. For every ACTIVE plugin, import its entry module (Bun runs TypeScript natively:
- *  `await import()`, no build step — the .rovecode/hooks.ts idiom, the same trust class), validate the
- *  default export, and resolve the declarative contributions (commands dir, skills dir, MCP servers).
- *  The result is a set of already-typed things the runtime drops onto existing seams:
- *    tools → ToolRegistry.register (the same policy path as built-ins: kind → action, deny-default)
- *    hooks → HookRunner.add(set, source) (timeout-bounded and isolated by the runner, like hook files)
- *    commandsDir / skillsDir → the commands and skills loaders' extra roots
- *    mcp → appended to loadMcpConfig's servers
- *  A module that fails, hangs or lies about its version costs ONE warning and that plugin's code
- *  contributions — never a throw, never the other plugins. Disabled/untrusted/broken plugins are
- *  returned with empty contributions so `plugin list` can still show them. */
-
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { HOOK_NAMES, type HookSet } from "../core/hooks.ts";
-import type { Tool, ToolKind } from "../core/types.ts";
-import { isRecord } from "../mcp/config.ts";
-import type { DiscoveredPlugin } from "./discover.ts";
-import { PLUGIN_API_VERSION } from "./manifest.ts";
-
-/** what the entry module receives when `tools` is a function */
-export interface PluginCtx { cwd: string; home: string; pluginDir: string }
-
-/** the entry module's default export */
-export interface PluginModule {
-  api: number;
-  tools?: Tool[] | ((ctx: PluginCtx) => Tool[] | Promise<Tool[]>);
-  hooks?: HookSet;
-}
-
-/** a discovered plugin plus what its entry module contributed (empty unless status is active) */
-export interface LoadedPlugin extends DiscoveredPlugin {
-  tools: Tool[];
-  hooks: HookSet | null;
-}
-
-export interface ActivateOptions { cwd: string; home: string; /** import + tools() budget per plugin (default: ROVECODE_PLUGIN_TIMEOUT_MS, else 5000) */ timeoutMs?: number }
-export const DEFAULT_PLUGIN_TIMEOUT_MS = 5000;
-/** ROVECODE_PLUGIN_TIMEOUT_MS: blank/invalid/< 1 → default (the hooks.ts hookTimeoutMs rule) */
-export function pluginTimeoutMs(env: Record<string, string | undefined> = process.env): number {
-  const n = Number(env.ROVECODE_PLUGIN_TIMEOUT_MS);
-  return Number.isFinite(n) && n >= 1 ? Math.floor(n) : DEFAULT_PLUGIN_TIMEOUT_MS;
-}
-
-const KINDS: readonly ToolKind[] = ["read", "write", "execute", "spawn", "memory", "network", "custom"];
-const TOOL_NAME_RE = /^[a-z][a-z0-9_]{0,63}$/;
-const TIMED_OUT = Symbol("timed-out");
-
-async function withTimeout<T>(p: Promise<T>, ms: number): Promise<T | typeof TIMED_OUT> {
-  let t: ReturnType<typeof setTimeout> | undefined;
-  const timer = new Promise<typeof TIMED_OUT>((r) => { t = setTimeout(() => r(TIMED_OUT), ms); });
-  try { return await Promise.race([p, timer]); } finally { if (t !== undefined) clearTimeout(t); }
-}
-const errText = (e: unknown): string => (e instanceof Error ? e.message : String(e));
-
-export async function activatePlugins(found: readonly DiscoveredPlugin[], opts: ActivateOptions): Promise<{ plugins: LoadedPlugin[]; warnings: string[] }> {
-  const warnings: string[] = [];
-  const plugins: LoadedPlugin[] = [];
-  for (const p of found) plugins.push(await activateOne(p, opts, warnings));
-  return { plugins, warnings };
-}
-
-async function activateOne(p: DiscoveredPlugin, opts: ActivateOptions, warnings: string[]): Promise<LoadedPlugin> {
-  const out: LoadedPlugin = { ...p, tools: [], hooks: null };
-  if (p.status !== "active" || p.manifest === null) return out; // untrusted / disabled / broken: nothing of theirs runs
-  const m = p.manifest, tag = `plugin ${p.name}`;
-  if (!m.entry) return out;
-  const entry = join(p.dir, m.entry);
-  if (!existsSync(entry)) { warnings.push(`${tag}: entry ${m.entry} does not exist — no tools or hooks loaded`); return out; }
-  const ms = opts.timeoutMs ?? pluginTimeoutMs();
-  let mod: unknown;
-  try { mod = await withTimeout(import(pathToFileURL(entry).href), ms); }
-  catch (e) { warnings.push(`${tag}: ${m.entry} failed to load — ${errText(e)}`); return out; }
-  if (mod === TIMED_OUT) { warnings.push(`${tag}: ${m.entry} load timed out after ${ms}ms (top-level await?) — skipped`); return out; }
-  const dflt: unknown = isRecord(mod) ? mod["default"] : undefined;
-  if (!isRecord(dflt)) { warnings.push(`${tag}: ${m.entry} must \`export default { api: ${PLUGIN_API_VERSION}, tools?, hooks? }\` — skipped`); return out; }
-  if (dflt["api"] !== PLUGIN_API_VERSION) { warnings.push(`${tag}: ${m.entry} declares api ${String(dflt["api"])}; this rovecode speaks ${PLUGIN_API_VERSION} — skipped`); return out; }
-  for (const key of Object.keys(dflt)) if (!["api", "tools", "hooks"].includes(key)) warnings.push(`${tag}: ${m.entry} exports unknown member "${key}" — ignored`);
-  // tools: an array, or a factory that gets the plugin's ctx (its own folder for data files, the cwd, the home)
-  if (dflt["tools"] !== undefined) {
-    let list: unknown;
-    try {
-      const raw = dflt["tools"];
-      list = typeof raw === "function" ? await withTimeout(Promise.resolve((raw as (c: PluginCtx) => unknown)({ cwd: opts.cwd, home: opts.home, pluginDir: p.dir })), ms) : raw;
-    } catch (e) { warnings.push(`${tag}: tools() threw — ${errText(e)}`); list = []; }
-    if (list === TIMED_OUT) { warnings.push(`${tag}: tools() timed out after ${ms}ms — no tools loaded`); list = []; }
-    if (!Array.isArray(list)) { warnings.push(`${tag}: "tools" must be an array (or a function returning one) — ignored`); list = []; }
-    const seen = new Set<string>();
-    for (const t of list as unknown[]) {
-      const ok = validateTool(t, tag, warnings);
-      if (!ok) continue;
-      if (seen.has(ok.schema.name)) { warnings.push(`${tag}: tool "${ok.schema.name}" declared twice — first kept`); continue; }
-      seen.add(ok.schema.name); out.tools.push(ok);
-    }
-  }
-  // hooks: the HookSet shape hooks.ts validates for files — unknown names and non-functions dropped, the rest kept
-  if (dflt["hooks"] !== undefined) {
-    if (!isRecord(dflt["hooks"])) warnings.push(`${tag}: "hooks" must be an object of hook functions — ignored`);
-    else {
-      const set: Record<string, unknown> = {};
-      for (const [name, fn] of Object.entries(dflt["hooks"])) {
-        if (!(HOOK_NAMES as readonly string[]).includes(name)) { warnings.push(`${tag}: unknown hook "${name}" ignored (known: ${HOOK_NAMES.join(", ")})`); continue; }
-        if (typeof fn !== "function") { warnings.push(`${tag}: hook "${name}" is not a function — ignored`); continue; }
-        set[name] = fn;
-      }
-      if (Object.keys(set).length) out.hooks = set as HookSet;
-    }
-  }
-  return out;
-}
-
-/** a Tool as core/types.ts defines it; anything else is named and dropped */
-function validateTool(t: unknown, tag: string, warnings: string[]): Tool | null {
-  if (!isRecord(t) || !isRecord(t["schema"])) { warnings.push(`${tag}: a tool without a schema was dropped`); return null; }
-  const s = t["schema"];
-  const name = s["name"];
-  if (typeof name !== "string" || !TOOL_NAME_RE.test(name)) { warnings.push(`${tag}: tool name ${JSON.stringify(name)} must match ${TOOL_NAME_RE} — dropped`); return null; }
-  if (typeof s["description"] !== "string" || !s["description"].trim()) { warnings.push(`${tag}: tool "${name}" needs a description — dropped`); return null; }
-  if (!isRecord(s["args"])) { warnings.push(`${tag}: tool "${name}" needs a JSON-Schema "args" object — dropped`); return null; }
-  if (!KINDS.includes(t["kind"] as ToolKind)) { warnings.push(`${tag}: tool "${name}" kind ${JSON.stringify(t["kind"])} is not one of ${KINDS.join("|")} — dropped (the kind is its permission class)`); return null; }
-  if (typeof t["execute"] !== "function") { warnings.push(`${tag}: tool "${name}" has no execute() — dropped`); return null; }
-  return t as unknown as Tool;
-}

package/src/plugins/manifest.ts

@@ -1,92 +0,0 @@
-/** Plugins: the manifest. A plugin is a FOLDER with a `plugin.json` that names what the folder
- *  contributes — an in-process entry module (tools + hooks), a directory of custom commands, a
- *  directory of skills, MCP servers. Nothing here is a new extension API: every contribution lands on
- *  a seam rovecode already has (core/hooks.ts HookSet, core/tools.ts ToolRegistry, tui/commands.ts,
- *  skills/index.ts, mcp/config.ts). The plugin is the package, not the surface (ADR-013: no 1.8k-line
- *  extension API — a small typed set, versioned; the manifest is versioned the same way hooks are).
- *
- *  Pure: text in, manifest or null out, every rejection a warning that names the file and the field.
- *  Paths in the manifest are RELATIVE and may not climb out of the plugin folder — a manifest is data
- *  from a checkout, and "../../.rovecode/hooks.ts" is not a plugin's to name. */
-
-import { isRecord } from "../mcp/config.ts";
-
-export const PLUGIN_API_VERSION = 1;
-export const MANIFEST_FILE = "plugin.json";
-/** `rovecode plugin list` and the palette show this; a paragraph is not a description */
-export const MAX_DESCRIPTION_CHARS = 200;
-
-export interface PluginManifest {
-  /** identity: folder-safe, lowercase, unique per scope — `conventional-commits`, `safety-net` */
-  name: string;
-  version: string;
-  description: string;
-  /** manifest/API version gate; this rovecode speaks PLUGIN_API_VERSION */
-  api: number;
-  /** relative path of the in-process module (`export default { api: 1, tools, hooks }`); .ts or .js */
-  entry?: string;
-  /** relative directory of `*.md` custom commands (tui/commands.ts format) */
-  commands?: string;
-  /** relative directory walked for SKILL.md files (skills/index.ts format) */
-  skills?: string;
-  /** MCP servers keyed by name, `.rovecode/mcp.json` entry shape */
-  mcp?: Record<string, unknown>;
-}
-
-const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
-const ENTRY_RE = /\.(?:[cm]?[jt]s)$/i;
-
-/** a relative path that stays inside the plugin: no absolute, no drive, no `..` segment */
-export function insidePlugin(p: string): boolean {
-  if (p.length === 0 || p.startsWith("/") || p.startsWith("\\") || /^[A-Za-z]:/.test(p)) return false;
-  return !p.split(/[\\/]/).some((seg) => seg === "..");
-}
-
-/** `plugin.json` text → manifest, or null with the reasons appended to `warnings`. A wrong or missing
- *  `api` is a hard skip (the version gate); everything else that is off is dropped field by field so
- *  a typo in `skills` does not lose the plugin's tools. */
-export function parseManifest(text: string, file: string, warnings: string[]): PluginManifest | null {
-  let raw: unknown;
-  try { raw = JSON.parse(text); } catch (e) { warnings.push(`${file}: not valid JSON — ${(e as Error).message}`); return null; }
-  if (!isRecord(raw)) { warnings.push(`${file}: must be an object`); return null; }
-  const api = raw["api"];
-  if (api !== PLUGIN_API_VERSION) {
-    const shown = api === undefined ? "missing" : typeof api === "string" ? JSON.stringify(api) : String(api);
-    warnings.push(`${file}: plugin API version ${shown} is not supported (this rovecode speaks ${PLUGIN_API_VERSION}) — skipped`);
-    return null;
-  }
-  const name = raw["name"];
-  if (typeof name !== "string" || !NAME_RE.test(name)) { warnings.push(`${file}: "name" must match ${NAME_RE} — skipped`); return null; }
-  const version = typeof raw["version"] === "string" && raw["version"].trim() ? raw["version"].trim().slice(0, 40) : null;
-  if (version === null) { warnings.push(`${file}: "version" must be a non-empty string — skipped`); return null; }
-  const m: PluginManifest = { name, version, description: "", api: PLUGIN_API_VERSION };
-  if (raw["description"] !== undefined) {
-    if (typeof raw["description"] === "string") m.description = raw["description"].replace(/\s+/g, " ").trim().slice(0, MAX_DESCRIPTION_CHARS);
-    else warnings.push(`${file}: "description" is not a string — ignored`);
-  }
-  for (const key of ["entry", "commands", "skills"] as const) {
-    const v = raw[key];
-    if (v === undefined) continue;
-    if (typeof v !== "string" || !insidePlugin(v)) { warnings.push(`${file}: "${key}" must be a relative path inside the plugin — ignored`); continue; }
-    if (key === "entry" && !ENTRY_RE.test(v)) { warnings.push(`${file}: "entry" must be a .ts or .js module — ignored`); continue; }
-    m[key] = v.replace(/\\/g, "/");
-  }
-  if (raw["mcp"] !== undefined) {
-    if (isRecord(raw["mcp"])) m.mcp = raw["mcp"];
-    else warnings.push(`${file}: "mcp" must be an object of servers keyed by name — ignored`);
-  }
-  for (const key of Object.keys(raw)) {
-    if (!["name", "version", "description", "api", "entry", "commands", "skills", "mcp"].includes(key)) warnings.push(`${file}: unknown field "${key}" ignored`);
-  }
-  return m;
-}
-
-/** what a manifest says it brings, for `plugin list` / `plugin show` / the trust prompt */
-export function contributions(m: PluginManifest): string[] {
-  const out: string[] = [];
-  if (m.entry) out.push(`code: ${m.entry}`);
-  if (m.commands) out.push(`commands: ${m.commands}/`);
-  if (m.skills) out.push(`skills: ${m.skills}/`);
-  if (m.mcp) out.push(`mcp: ${Object.keys(m.mcp).join(", ") || "(none)"}`);
-  return out;
-}

package/src/plugins/state.ts

@@ -1,83 +0,0 @@
-/** Plugins: what the human decided about them — `~/.rovecode/plugins.json`. Two facts only:
- *  which plugins are switched off, and which PROJECT plugins this machine trusts, by folder and by a
- *  digest of the folder's contents.
- *
- *  Why a digest and why in the USER home: a project plugin lives in a checkout, and a checkout is
- *  data from the network. Recording "trusted: true" inside `<cwd>/.rovecode/settings.json` would let the
- *  repository trust itself; recording it here, keyed by the plugin's absolute folder and the hash of
- *  every file in it, means the human said yes to THIS code on THIS machine, and a `git pull` that
- *  changes the plugin asks again. User-scope plugins need no record: `rovecode plugin add` copying a
- *  folder into `~/.rovecode/plugins` IS the human's yes.
- *
- *  A missing, unreadable or malformed file reads as "nothing decided" — never an error. */
-
-import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-
-export interface PluginState {
-  /** plugin names switched off in every scope */
-  disabled: string[];
-  /** absolute project-plugin folder → digest the human approved */
-  trusted: Record<string, string>;
-}
-
-export const STATE_FILE = "plugins.json";
-export const statePath = (home: string): string => join(home, STATE_FILE);
-
-const SKIP_DIRS = new Set(["node_modules", ".git"]);
-
-export function loadState(home: string): PluginState {
-  const out: PluginState = { disabled: [], trusted: {} };
-  let raw: unknown;
-  try { raw = JSON.parse(readFileSync(statePath(home), "utf8")); } catch { return out; }
-  if (typeof raw !== "object" || raw === null) return out;
-  const r = raw as Record<string, unknown>;
-  if (Array.isArray(r["disabled"])) out.disabled = r["disabled"].filter((v): v is string => typeof v === "string");
-  if (typeof r["trusted"] === "object" && r["trusted"] !== null && !Array.isArray(r["trusted"])) {
-    for (const [k, v] of Object.entries(r["trusted"] as Record<string, unknown>)) if (typeof v === "string") out.trusted[k] = v;
-  }
-  return out;
-}
-
-export function saveState(home: string, state: PluginState): string {
-  const path = statePath(home);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify({ disabled: [...state.disabled].sort(), trusted: state.trusted }, null, 2) + "\n");
-  return path;
-}
-
-/** every regular file under the plugin folder (node_modules/.git skipped), sorted, relative posix paths */
-export function pluginFiles(dir: string): string[] {
-  const out: string[] = [];
-  const walk = (d: string): void => {
-    let entries: import("node:fs").Dirent[];
-    try { entries = readdirSync(d, { withFileTypes: true }); } catch { return; }
-    for (const e of entries) {
-      if (SKIP_DIRS.has(e.name)) continue;
-      const p = join(d, e.name);
-      if (e.isDirectory()) walk(p);
-      else if (e.isFile()) out.push(relative(dir, p).replace(/\\/g, "/"));
-    }
-  };
-  walk(dir);
-  return out.sort();
-}
-
-/** sha256 over `<relative path>\0<bytes>\0` for every file — the same folder gives the same digest on
- *  every machine, and one changed byte in one file changes it */
-export function pluginDigest(dir: string): string {
-  const h = createHash("sha256");
-  for (const rel of pluginFiles(dir)) {
-    h.update(rel); h.update("\0");
-    try { h.update(readFileSync(join(dir, rel))); } catch { /* vanished mid-walk: the digest still moves */ }
-    h.update("\0");
-  }
-  return h.digest("hex");
-}
-
-export const trustKey = (dir: string): string => resolve(dir).replace(/\\/g, "/");
-export function isTrusted(state: PluginState, dir: string, digest: string): boolean { return state.trusted[trustKey(dir)] === digest; }
-
-/** a folder exists and is a directory */
-export function isDir(p: string): boolean { try { return statSync(p).isDirectory(); } catch { return false; } }