chainlesschain 0.162.149 → 0.162.151

package/src/lib/plugin-runtime/__tests__/remote-source.test.js

@@ -0,0 +1,256 @@
+/**
+ * remote-source tests — resolving a plugin from a hosted registry/manifest URL,
+ * with private-token auth and an offline cache. `fetch` and fs are injected via
+ * `_deps` so nothing hits the network or the real disk.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  isRemoteSource,
+  validateRegistry,
+  resolvePluginEntry,
+  listRegistryPlugins,
+  resolveRegistryToken,
+  fetchRegistry,
+  resolveRemoteSource,
+  registryCachePath,
+  _deps,
+} from "../remote-source.js";
+
+const REGISTRY = {
+  name: "acme",
+  plugins: [
+    {
+      name: "toml-tools",
+      source: "https://github.com/x/toml.git",
+      ref: "v1.0.0",
+      version: "1.0.0",
+      description: "TOML LSP",
+      sha256: "abc123",
+    },
+    { name: "py-helpers", source: "owner/py-helpers" },
+  ],
+};
+
+/** A fake in-memory fs + fetch wired into _deps. */
+function install(fakes = {}) {
+  const files = new Map(fakes.files || []);
+  _deps.existsSync = (p) => files.has(String(p));
+  _deps.readFileSync = (p) => {
+    if (!files.has(String(p))) throw new Error("ENOENT");
+    return files.get(String(p));
+  };
+  _deps.writeFileSync = (p, text) => files.set(String(p), text);
+  _deps.mkdirSync = () => {};
+  if (fakes.fetch) _deps.fetch = fakes.fetch;
+  return files;
+}
+
+/** Build a fetch that returns JSON once, then throws (to test caching). */
+function okThenOffline(body) {
+  let calls = 0;
+  return vi.fn(async () => {
+    calls++;
+    if (calls === 1) {
+      return { ok: true, status: 200, text: async () => JSON.stringify(body) };
+    }
+    throw new Error("ECONNREFUSED");
+  });
+}
+
+let orig;
+beforeEach(() => {
+  orig = { ..._deps };
+  delete process.env.CC_PLUGIN_REGISTRY_TOKEN;
+});
+afterEach(() => {
+  Object.assign(_deps, orig);
+  vi.restoreAllMocks();
+  delete process.env.CC_PLUGIN_REGISTRY_TOKEN;
+});
+
+describe("isRemoteSource", () => {
+  it("recognizes http(s) .json URLs", () => {
+    expect(isRemoteSource("https://x.com/registry.json")).toBe(true);
+    expect(isRemoteSource("http://x.com/a/b.json?ref=1")).toBe(true);
+  });
+  it("rejects local dirs, git URLs, and owner/repo", () => {
+    expect(isRemoteSource("./plugins/foo")).toBe(false);
+    expect(isRemoteSource("https://github.com/x/foo.git")).toBe(false);
+    expect(isRemoteSource("owner/repo")).toBe(false);
+  });
+});
+
+describe("validateRegistry", () => {
+  it("accepts a multi-plugin index", () => {
+    expect(validateRegistry(REGISTRY).plugins).toHaveLength(2);
+  });
+  it("wraps a single-plugin manifest into a one-entry registry", () => {
+    const r = validateRegistry({
+      name: "solo",
+      source: "owner/solo",
+      ref: "v2",
+    });
+    expect(r.plugins).toEqual([
+      { name: "solo", source: "owner/solo", ref: "v2" },
+    ]);
+  });
+  it("rejects garbage and entries missing name/source", () => {
+    expect(() => validateRegistry(null)).toThrow(/not a JSON object/);
+    expect(() => validateRegistry({ foo: 1 })).toThrow(
+      /plugins.*array.*source/,
+    );
+    expect(() => validateRegistry({ plugins: [{ name: "x" }] })).toThrow(
+      /missing name\/source/,
+    );
+  });
+});
+
+describe("resolvePluginEntry", () => {
+  it("selects by name", () => {
+    expect(resolvePluginEntry(REGISTRY, "py-helpers").source).toBe(
+      "owner/py-helpers",
+    );
+  });
+  it("auto-selects the sole plugin when name omitted", () => {
+    const solo = { plugins: [REGISTRY.plugins[0]] };
+    expect(resolvePluginEntry(solo).name).toBe("toml-tools");
+  });
+  it("requires a name when the registry has many", () => {
+    expect(() => resolvePluginEntry(REGISTRY)).toThrow(/pick one with --name/);
+  });
+  it("lists options when the name is unknown", () => {
+    expect(() => resolvePluginEntry(REGISTRY, "nope")).toThrow(
+      /not found.*toml-tools, py-helpers/s,
+    );
+  });
+});
+
+describe("resolveRegistryToken", () => {
+  it("prefers an explicit token, then env, then per-host config", () => {
+    expect(
+      resolveRegistryToken("https://h/r.json", { token: "explicit" }),
+    ).toBe("explicit");
+    process.env.CC_PLUGIN_REGISTRY_TOKEN = "envtok";
+    expect(resolveRegistryToken("https://h/r.json", {})).toBe("envtok");
+    delete process.env.CC_PLUGIN_REGISTRY_TOKEN;
+    const config = { plugins: { registryTokens: { "priv.co": "cfgtok" } } };
+    expect(resolveRegistryToken("https://priv.co/r.json", { config })).toBe(
+      "cfgtok",
+    );
+    expect(
+      resolveRegistryToken("https://other.co/r.json", { config }),
+    ).toBeNull();
+  });
+});
+
+describe("fetchRegistry", () => {
+  it("fetches, validates, and caches; sends a bearer token when given", async () => {
+    const fetch = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify(REGISTRY),
+    }));
+    install({ fetch });
+    const { registry, fromCache } = await fetchRegistry("https://h/r.json", {
+      token: "t",
+      cacheDir: "/cache",
+    });
+    expect(fromCache).toBe(false);
+    expect(registry.plugins).toHaveLength(2);
+    const [, init] = fetch.mock.calls[0];
+    expect(init.headers.Authorization).toBe("Bearer t");
+  });
+
+  it("falls back to the offline cache when the network fails", async () => {
+    const fetch = okThenOffline(REGISTRY);
+    install({ fetch });
+    // 1st call populates the cache
+    await fetchRegistry("https://h/r.json", { cacheDir: "/cache" });
+    // 2nd call: network throws → served from cache
+    const { registry, fromCache } = await fetchRegistry("https://h/r.json", {
+      cacheDir: "/cache",
+    });
+    expect(fromCache).toBe(true);
+    expect(registry.plugins).toHaveLength(2);
+  });
+
+  it("throws on HTTP error with no cache", async () => {
+    const fetch = vi.fn(async () => ({
+      ok: false,
+      status: 404,
+      statusText: "Not Found",
+      text: async () => "",
+    }));
+    install({ fetch });
+    await expect(
+      fetchRegistry("https://h/missing.json", { cacheDir: "/cache" }),
+    ).rejects.toThrow(/HTTP 404/);
+  });
+
+  it("throws when offline and nothing is cached", async () => {
+    const fetch = vi.fn(async () => {
+      throw new Error("ENOTFOUND");
+    });
+    install({ fetch });
+    await expect(
+      fetchRegistry("https://h/r.json", { cacheDir: "/cache" }),
+    ).rejects.toThrow(/no offline cache/);
+  });
+});
+
+describe("resolveRemoteSource", () => {
+  it("resolves a named entry to a git source string with a #ref and carries sha256", async () => {
+    const fetch = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify(REGISTRY),
+    }));
+    install({ fetch });
+    const r = await resolveRemoteSource("https://h/r.json", {
+      name: "toml-tools",
+      cacheDir: "/cache",
+    });
+    expect(r.source).toBe("https://github.com/x/toml.git#v1.0.0");
+    expect(r.sha256).toBe("abc123");
+    expect(r.fromCache).toBe(false);
+  });
+
+  it("omits the #ref when the entry has none", async () => {
+    const fetch = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify(REGISTRY),
+    }));
+    install({ fetch });
+    const r = await resolveRemoteSource("https://h/r.json", {
+      name: "py-helpers",
+      cacheDir: "/cache",
+    });
+    expect(r.source).toBe("owner/py-helpers");
+    expect(r.ref).toBeNull();
+  });
+});
+
+describe("listRegistryPlugins", () => {
+  it("flattens entries for display", () => {
+    const rows = listRegistryPlugins(REGISTRY);
+    expect(rows.map((r) => r.name)).toEqual(["toml-tools", "py-helpers"]);
+    expect(rows[0]).toMatchObject({
+      version: "1.0.0",
+      ref: "v1.0.0",
+      description: "TOML LSP",
+    });
+  });
+});
+
+describe("registryCachePath", () => {
+  it("is stable and content-addressed by URL", () => {
+    const a = registryCachePath("https://h/r.json", "/cache");
+    const b = registryCachePath("https://h/r.json", "/cache");
+    const c = registryCachePath("https://h/OTHER.json", "/cache");
+    expect(a).toBe(b);
+    expect(a).not.toBe(c);
+    expect(a.endsWith(".json")).toBe(true);
+  });
+});

package/src/lib/plugin-runtime/hooks.js

@@ -60,11 +60,27 @@ export function collectPluginHooks(opts = {}) {
   for (const p of trusted) {
     if (!p.manifest || p.manifest.ok !== true) continue;
     const h = p.manifest.components?.hooks;
-    if (!h || !h.absPath) continue;
+    if (!h) continue;
     let parsed;
-    try {
-      parsed = JSON.parse(_deps.readFileSync(h.absPath, "utf8"));
-    } catch {
+    if (h.absPath) {
+      try {
+        parsed = JSON.parse(_deps.readFileSync(h.absPath, "utf8"));
+      } catch {
+        continue;
+      }
+    } else if (h.inline) {
+      // Hooks declared inline in plugin.json — the normalized component keeps
+      // only counts, so re-read the raw manifest for the actual entries (same
+      // approach as the MCP collector). Without this, inline hooks never fire.
+      try {
+        const raw = JSON.parse(
+          _deps.readFileSync(p.manifest.manifestPath, "utf8"),
+        );
+        parsed = raw && typeof raw === "object" ? raw.hooks : null;
+      } catch {
+        continue;
+      }
+    } else {
       continue;
     }
     const map = normalizeHookMap(parsed);

package/src/lib/plugin-runtime/install.js

@@ -320,6 +320,14 @@ export function uninstall(name, opts = {}) {
         `${name}@${opts.version} is not installed at ${scope} scope`,
       );
     }
+    // Capture the active version BEFORE removing, so we only repoint `.active`
+    // when the version we removed WAS the active one. Removing a NON-active
+    // version (e.g. cleaning up a newer version after rolling back to an older
+    // pinned one) must not silently change which version is active — the old
+    // code always rewrote `.active` to the newest remaining, so uninstalling an
+    // unrelated version could bump the user's pinned choice.
+    const removedWasActive =
+      getActiveVersion(name, { scope, cwd }) === opts.version;
     _deps.rmSync(dir, { recursive: true, force: true });
     removed.push(opts.version);
     // Repoint .active to the newest remaining version, or clear it.
@@ -333,7 +341,7 @@ export function uninstall(name, opts = {}) {
         recursive: true,
         force: true,
       });
-    } else if (_deps.existsSync(activeFile)) {
+    } else if (removedWasActive && _deps.existsSync(activeFile)) {
       _deps.writeFileSync(activeFile, remaining[0], "utf8");
     }
     return { removed };

package/src/lib/plugin-runtime/monitors.js

@@ -79,11 +79,27 @@ export function collectPluginMonitors(opts = {}) {
   for (const p of trusted) {
     if (!p.manifest || p.manifest.ok !== true) continue;
     const m = p.manifest.components?.monitors;
-    if (!m || !m.absPath) continue;
+    if (!m) continue;
     let parsed;
-    try {
-      parsed = JSON.parse(_deps.readFileSync(m.absPath, "utf8"));
-    } catch {
+    if (m.absPath) {
+      try {
+        parsed = JSON.parse(_deps.readFileSync(m.absPath, "utf8"));
+      } catch {
+        continue;
+      }
+    } else if (m.inline) {
+      // Monitors declared inline in plugin.json — the normalized component keeps
+      // only counts, so re-read the raw manifest for the actual entries (same
+      // approach as the MCP collector). Without this, inline monitors never spawn.
+      try {
+        const raw = JSON.parse(
+          _deps.readFileSync(p.manifest.manifestPath, "utf8"),
+        );
+        parsed = raw && typeof raw === "object" ? raw.monitors : null;
+      } catch {
+        continue;
+      }
+    } else {
       continue;
     }
     const list = Array.isArray(parsed?.monitors)

package/src/lib/plugin-runtime/policy.js

@@ -43,7 +43,15 @@ export function loadManagedPluginPolicy(opts = {}) {
   const key = String(
     opts.managedSettingsFile || env.CC_MANAGED_SETTINGS || "<default>",
   );
-  if (_cache.has(key)) return _cache.get(key);
+  if (_cache.has(key)) {
+    const cached = _cache.get(key);
+    // A cached failure sentinel must re-throw on EVERY call — otherwise the
+    // first call fails closed but later callers get the truthy {__invalid}
+    // object, treat it as an empty policy, and silently bypass the org's
+    // deny/allow/requireSignedPlugins enforcement (fail-open).
+    if (cached && cached.__invalid) throw cached.__invalid;
+    return cached;
+  }
   let settings = null;
   try {
     const loaded = _deps.loadManagedSettings({

package/src/lib/plugin-runtime/remote-source.js

@@ -0,0 +1,240 @@
+/**
+ * Remote plugin sources — install from a hosted registry / manifest URL, not
+ * just a local dir or git URL (Phase 3 "远程 manifest" + "私有仓认证" + "离线
+ * seed cache" work items).
+ *
+ * A remote source is an `https?://…/*.json` document, in one of two shapes:
+ *
+ *   1. Registry index — many plugins, selected by name:
+ *      { "name": "acme-registry",
+ *        "plugins": [
+ *          { "name": "toml-tools", "source": "https://github.com/x/toml.git",
+ *            "ref": "v1.0.0", "version": "1.0.0", "description": "…", "sha256": "…" },
+ *          { "name": "py-helpers", "source": "owner/py-helpers" }
+ *        ] }
+ *
+ *   2. Single-plugin manifest — one plugin, no selection needed:
+ *      { "name": "toml-tools", "source": "https://github.com/x/toml.git", "ref": "v1.0.0" }
+ *
+ * The remote layer is an INDIRECTION: it resolves a name → a git source string
+ * that the existing installer (`installFromSource`) already knows how to clone.
+ * This keeps the sync install core untouched and avoids bundling a tarball
+ * extractor. Downloaded registry JSON is cached content-addressed so browsing /
+ * installing works OFFLINE, and a bearer token can gate a PRIVATE registry.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import crypto from "crypto";
+import { getElectronUserDataDir } from "../paths.js";
+
+export const _deps = {
+  // Node 22+ global fetch; injectable for tests.
+  fetch: (...args) => globalThis.fetch(...args),
+  readFileSync: fs.readFileSync,
+  writeFileSync: fs.writeFileSync,
+  existsSync: fs.existsSync,
+  mkdirSync: fs.mkdirSync,
+};
+
+const DEFAULT_TIMEOUT_MS = 15_000;
+
+/** True when `raw` looks like a remote registry/manifest URL (http(s) + .json). */
+export function isRemoteSource(raw) {
+  const s = String(raw || "").trim();
+  return /^https?:\/\//i.test(s) && /\.json(\?.*)?(#.*)?$/i.test(s);
+}
+
+/** Where a fetched registry is cached (content-addressed by its URL). */
+export function registryCachePath(url, cacheDir) {
+  const dir =
+    cacheDir || path.join(getElectronUserDataDir(), "plugin-registry-cache");
+  const hash = crypto
+    .createHash("sha256")
+    .update(String(url))
+    .digest("hex")
+    .slice(0, 32);
+  return path.join(dir, `${hash}.json`);
+}
+
+/**
+ * Resolve the bearer token for a registry host from (in order): explicit
+ * `opts.token`, `CC_PLUGIN_REGISTRY_TOKEN` env, or a per-host map in config
+ * (`config.plugins.registryTokens[host]`). Returns null if none — a public
+ * registry needs no token.
+ */
+export function resolveRegistryToken(url, { token, config } = {}) {
+  if (token) return token;
+  if (process.env.CC_PLUGIN_REGISTRY_TOKEN)
+    return process.env.CC_PLUGIN_REGISTRY_TOKEN;
+  try {
+    const host = new URL(url).host;
+    const map = config?.plugins?.registryTokens;
+    if (map && map[host]) return map[host];
+  } catch {
+    /* bad URL — handled by fetch */
+  }
+  return null;
+}
+
+/**
+ * GET a registry/manifest URL as JSON, with optional bearer auth. On success the
+ * body is written to the offline cache; on a network/HTTP failure we fall back
+ * to that cache (so a previously-seen registry still installs offline). Throws
+ * only when neither the network NOR the cache can produce a valid document.
+ *
+ * @returns {Promise<{ registry: object, fromCache: boolean }>}
+ */
+export async function fetchRegistry(url, opts = {}) {
+  const {
+    token,
+    cacheDir,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    allowCache = true,
+  } = opts;
+  const cachePath = registryCachePath(url, cacheDir);
+  const headers = { Accept: "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  let networkErr = null;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+      res = await _deps.fetch(url, {
+        headers,
+        redirect: "follow",
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      throw new Error(
+        `registry fetch failed: HTTP ${res.status} ${res.statusText || ""}`.trim(),
+      );
+    }
+    const text = await res.text();
+    const registry = validateRegistry(JSON.parse(text), url);
+    if (allowCache) writeCache(cachePath, text);
+    return { registry, fromCache: false };
+  } catch (err) {
+    networkErr = err;
+  }
+
+  // Network failed — try the offline cache.
+  if (allowCache && _deps.existsSync(cachePath)) {
+    try {
+      const text = _deps.readFileSync(cachePath, "utf8");
+      const registry = validateRegistry(JSON.parse(text), url);
+      return { registry, fromCache: true };
+    } catch {
+      /* cache unreadable — fall through to throw the network error */
+    }
+  }
+  throw new Error(
+    `could not fetch registry ${url}: ${networkErr ? networkErr.message : "unknown error"}` +
+      (allowCache ? " (no offline cache available)" : ""),
+  );
+}
+
+function writeCache(cachePath, text) {
+  try {
+    _deps.mkdirSync(path.dirname(cachePath), { recursive: true });
+    _deps.writeFileSync(cachePath, text, "utf8");
+  } catch {
+    /* caching is best-effort; a read-only cache dir must not break install */
+  }
+}
+
+/** Validate + normalize a fetched document into a registry object. Throws on garbage. */
+export function validateRegistry(doc, url = "") {
+  if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+    throw new Error(`registry at ${url} is not a JSON object`);
+  }
+  if (Array.isArray(doc.plugins)) {
+    for (const p of doc.plugins) {
+      if (!p || typeof p !== "object" || !p.name || !p.source) {
+        throw new Error(
+          `registry at ${url} has a plugin entry missing name/source`,
+        );
+      }
+    }
+    return doc;
+  }
+  // Single-plugin manifest.
+  if (doc.source) {
+    return { plugins: [doc] };
+  }
+  throw new Error(
+    `registry at ${url} must have a "plugins" array or a top-level "source"`,
+  );
+}
+
+/** List installable entries from a registry (for `cc plugin search`). */
+export function listRegistryPlugins(registry) {
+  return (registry.plugins || []).map((p) => ({
+    name: p.name,
+    version: p.version || null,
+    source: p.source,
+    ref: p.ref || null,
+    description: p.description || "",
+  }));
+}
+
+/**
+ * Pick one plugin entry from a registry. When the registry has exactly one
+ * plugin, `name` is optional; otherwise it must match. Returns the entry, or
+ * throws with a helpful list.
+ */
+export function resolvePluginEntry(registry, name) {
+  const plugins = registry.plugins || [];
+  if (plugins.length === 0) throw new Error("registry has no plugins");
+  if (!name) {
+    if (plugins.length === 1) return plugins[0];
+    throw new Error(
+      `registry has ${plugins.length} plugins — pick one with --name <plugin>:\n  ` +
+        plugins.map((p) => p.name).join(", "),
+    );
+  }
+  const entry = plugins.find((p) => p.name === name);
+  if (!entry) {
+    throw new Error(
+      `plugin "${name}" not found in registry. Available:\n  ` +
+        plugins.map((p) => p.name).join(", "),
+    );
+  }
+  return entry;
+}
+
+/**
+ * Full resolution: fetch the registry (with auth + offline cache), select the
+ * entry, and return the git source string the existing installer consumes plus
+ * carry-through metadata (ref pins the checkout; sha256 becomes an install
+ * integrity check).
+ *
+ * @returns {Promise<{ source: string, ref: string|null, sha256: string|null,
+ *   entry: object, fromCache: boolean }>}
+ */
+export async function resolveRemoteSource(url, opts = {}) {
+  const token = resolveRegistryToken(url, opts);
+  const { registry, fromCache } = await fetchRegistry(url, { ...opts, token });
+  const entry = resolvePluginEntry(registry, opts.name);
+  // Carry a `#ref` on the source string so installFromSource pins the checkout,
+  // matching its existing `owner/repo#ref` / `url#ref` convention.
+  const source = entry.ref ? `${entry.source}#${entry.ref}` : entry.source;
+  return {
+    source,
+    ref: entry.ref || null,
+    sha256: entry.sha256 || null,
+    entry,
+    fromCache,
+  };
+}
+
+/** Best-effort local temp dir helper (kept here so tests can stub fs deps). */
+export function _tmpRoot() {
+  return os.tmpdir();
+}

package/src/lib/plugin-runtime/signature.js

@@ -77,6 +77,22 @@ export function verifyInstalledSignature(plugin, opts = {}) {
     return { signed: false, reason: "lock is not signature-verified" };
   }
   const manifestFile = path.join(plugin.root, lock.manifest || "plugin.json");
+  // `lock.manifest` is untrusted — it lives in the (writable) plugin dir. A lock
+  // pointing OUTSIDE the plugin root (`manifest: "../../secret"`) would make us
+  // re-hash an arbitrary file and, with a matching locked sha256, forge
+  // signed:true — which gates load-time requireSignedPlugins. A plugin's manifest
+  // is ALWAYS inside its own root, so reject any path that escapes it (boundary
+  // via path.relative, not startsWith — the sandbox-fs-policy pattern).
+  const rel = path.relative(
+    path.resolve(plugin.root),
+    path.resolve(manifestFile),
+  );
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+    return {
+      signed: false,
+      reason: "lock manifest path escapes the plugin root",
+    };
+  }
   if (!_deps.existsSync(manifestFile)) {
     return { signed: false, reason: "locked manifest file is missing" };
   }