@cjhyy/code-shell-core 0.5.0-rc.0 → 0.5.0-rc.2

package/dist/plugins/installer/types.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/** Codex `.codex-plugin/plugin.json`. v1 reads required fields; unknowns pass through. */
+export declare const CodexPluginManifest: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mcpServers: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    skills: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mcpServers: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    skills: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mcpServers: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    skills: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export type CodexPluginManifest = z.infer<typeof CodexPluginManifest>;
+/** `.cs-meta.json` written into every installed plugin dir. */
+export declare const CSMeta: z.ZodObject<{
+    name: z.ZodString;
+    format: z.ZodEnum<["cc", "codex"]>;
+    version: z.ZodOptional<z.ZodString>;
+    source: z.ZodString;
+    installedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    name: string;
+    format: "codex" | "cc";
+    installedAt: string;
+    version?: string | undefined;
+}, {
+    source: string;
+    name: string;
+    format: "codex" | "cc";
+    installedAt: string;
+    version?: string | undefined;
+}>;
+export type CSMeta = z.infer<typeof CSMeta>;
+export declare class PluginInstallError extends Error {
+    constructor(message: string);
+}

package/dist/plugins/installer/types.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/** Codex `.codex-plugin/plugin.json`. v1 reads required fields; unknowns pass through. */
+export const CodexPluginManifest = z
+    .object({
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    // string → relative path to a .mcp.json; object → inline mcpServers map
+    mcpServers: z.union([z.string(), z.record(z.any())]).optional(),
+    skills: z.string().optional(),
+    agents: z.string().optional(),
+})
+    .passthrough();
+/** `.cs-meta.json` written into every installed plugin dir. */
+export const CSMeta = z.object({
+    name: z.string(),
+    format: z.enum(["cc", "codex"]),
+    version: z.string().optional(),
+    source: z.string(),
+    installedAt: z.string(),
+});
+export class PluginInstallError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PluginInstallError";
+    }
+}

package/dist/plugins/installer/uninstall.d.ts

@@ -0,0 +1,2 @@
+/** Remove a locally-installed plugin dir + its installed_plugins.json entry. */
+export declare function uninstallPluginByName(name: string): void;

package/dist/plugins/installer/uninstall.js

@@ -0,0 +1,14 @@
+import { existsSync, rmSync } from "node:fs";
+import { pluginInstallDir, assertSafePluginName } from "./paths.js";
+import { removeInstallEntries, pluginInstallKey } from "../installedPlugins.js";
+import { PluginInstallError } from "./types.js";
+/** Remove a locally-installed plugin dir + its installed_plugins.json entry. */
+export function uninstallPluginByName(name) {
+    assertSafePluginName(name);
+    const dir = pluginInstallDir(name);
+    if (!existsSync(dir)) {
+        throw new PluginInstallError(`no plugin named '${name}'`);
+    }
+    rmSync(dir, { recursive: true, force: true });
+    removeInstallEntries(pluginInstallKey(name, "local"));
+}

package/dist/plugins/installer/update.d.ts

@@ -0,0 +1,14 @@
+export interface UpdateResult {
+    updated: boolean;
+    reason: string;
+}
+/**
+ * Reinstall a plugin from its recorded source.
+ *
+ * - Local source: reinstall when the source version changed, or when `force`.
+ *   CC plugins have no version → only `force` updates them.
+ * - Remote (git) source: re-clone and reinstall every time — git sources carry
+ *   no local version file to compare, so update is always a fresh pull
+ *   (equivalent to `--force`; cheap and reliable). See spec §9.
+ */
+export declare function updatePluginByName(name: string, installedAt: string, force: boolean): Promise<UpdateResult>;

package/dist/plugins/installer/update.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { detectPluginFormat } from "./detectFormat.js";
+import { pluginInstallDir } from "./paths.js";
+import { uninstallPluginByName } from "./uninstall.js";
+import { installPluginFromPath } from "./install.js";
+import { installPluginFromSource } from "./installFromSource.js";
+import { parseSource } from "./parseSource.js";
+import { CodexPluginManifest, CSMeta, PluginInstallError } from "./types.js";
+/**
+ * Reinstall a plugin from its recorded source.
+ *
+ * - Local source: reinstall when the source version changed, or when `force`.
+ *   CC plugins have no version → only `force` updates them.
+ * - Remote (git) source: re-clone and reinstall every time — git sources carry
+ *   no local version file to compare, so update is always a fresh pull
+ *   (equivalent to `--force`; cheap and reliable). See spec §9.
+ */
+export async function updatePluginByName(name, installedAt, force) {
+    const dir = pluginInstallDir(name);
+    const metaPath = join(dir, ".cs-meta.json");
+    if (!existsSync(metaPath))
+        throw new PluginInstallError(`no plugin named '${name}'`);
+    const meta = CSMeta.parse(JSON.parse(readFileSync(metaPath, "utf-8")));
+    const parsed = parseSource(meta.source);
+    if (parsed.kind === "remote") {
+        // No local version to diff against — always re-clone and reinstall.
+        // uninstall-then-install isn't atomic: if the reinstall fails (clone
+        // error, bad plugin) the old copy is already gone. We can't roll back the
+        // removal, but we surface a clear error instead of leaving silent
+        // inconsistency.
+        uninstallPluginByName(name);
+        try {
+            await installPluginFromSource(parsed, name, installedAt);
+        }
+        catch (err) {
+            throw new PluginInstallError(`update failed and '${name}' was removed during reinstall: ` +
+                `${err instanceof Error ? err.message : String(err)}. Reinstall it from ${meta.source}.`);
+        }
+        return { updated: true, reason: "reinstalled from git source" };
+    }
+    if (!existsSync(meta.source)) {
+        throw new PluginInstallError(`source no longer exists: ${meta.source}`);
+    }
+    if (!force) {
+        if (detectPluginFormat(meta.source) === "codex") {
+            const manifest = CodexPluginManifest.parse(JSON.parse(readFileSync(join(meta.source, ".codex-plugin", "plugin.json"), "utf-8")));
+            if (manifest.version === meta.version) {
+                return { updated: false, reason: "already up to date" };
+            }
+        }
+        else {
+            return { updated: false, reason: "CC plugin needs --force to reinstall" };
+        }
+    }
+    uninstallPluginByName(name);
+    try {
+        await installPluginFromPath(meta.source, name, installedAt);
+    }
+    catch (err) {
+        throw new PluginInstallError(`update failed and '${name}' was removed during reinstall: ` +
+            `${err instanceof Error ? err.message : String(err)}. Reinstall it from ${meta.source}.`);
+    }
+    return { updated: true, reason: "reinstalled" };
+}

package/dist/plugins/loadPluginHooks.d.ts

@@ -48,5 +48,12 @@ import type { HookRegistry } from "../hooks/registry.js";
  * multiple times — the caller is responsible for not double-registering
  * (HookRegistry has no de-dup; the engine constructor calls this exactly
  * once after creating the registry).
+ *
+ * `disabledPlugins` is the coarse "plugin total switch" — bare plugin names
+ * (no `@marketplace`, no `:` suffix), matching scanSkills' semantics. A
+ * disabled plugin contributes NO hooks, so e.g. disabling "superpowers"
+ * also suppresses its SessionStart injection — not just its Skill-tool
+ * entries. Without this, `disabledPlugins` only filtered the skill list and
+ * the plugin's hooks still fired regardless.
  */
-export declare function loadPluginHooks(registry: HookRegistry): void;
+export declare function loadPluginHooks(registry: HookRegistry, disabledPlugins?: string[]): void;

package/dist/plugins/loadPluginHooks.js

@@ -114,10 +114,20 @@ function pluginNameFromKey(key) {
  * multiple times — the caller is responsible for not double-registering
  * (HookRegistry has no de-dup; the engine constructor calls this exactly
  * once after creating the registry).
+ *
+ * `disabledPlugins` is the coarse "plugin total switch" — bare plugin names
+ * (no `@marketplace`, no `:` suffix), matching scanSkills' semantics. A
+ * disabled plugin contributes NO hooks, so e.g. disabling "superpowers"
+ * also suppresses its SessionStart injection — not just its Skill-tool
+ * entries. Without this, `disabledPlugins` only filtered the skill list and
+ * the plugin's hooks still fired regardless.
  */
-export function loadPluginHooks(registry) {
+export function loadPluginHooks(registry, disabledPlugins = []) {
     const data = readInstalledPlugins();
+    const disabledSet = new Set(disabledPlugins);
     for (const [key, entries] of Object.entries(data.plugins)) {
+        if (disabledSet.has(pluginNameFromKey(key)))
+            continue;
         for (const entry of entries) {
             const installPath = entry.installPath;
             if (!installPath || !existsSync(installPath))

package/dist/plugins/marketplaceManager.d.ts

@@ -5,9 +5,15 @@
  * at the MVP subset (github + git sources only, no auto-update,
  * no policy blocking, no GCS mirror).
  */
-import type { MarketplaceSource, PluginMarketplace } from "./types.js";
+import type { MarketplaceFormat, MarketplaceSource, PluginMarketplace } from "./types.js";
+export type { MarketplaceFormat } from "./types.js";
 export declare function marketplacesRoot(): string;
 export declare function marketplaceDir(name: string): string;
+/**
+ * Classify a cloned marketplace by which manifest files it ships:
+ * both → universal, only .agents/plugins → codex, otherwise claude-code.
+ */
+export declare function detectMarketplaceFormat(dir: string): MarketplaceFormat;
 export type AddMarketplaceResult = {
     ok: true;
     name: string;
@@ -40,6 +46,7 @@ export interface ListedMarketplace {
     installLocation: string;
     lastUpdated: string;
     pluginCount: number;
+    format: MarketplaceFormat;
 }
 /**
  * Lists all known marketplaces with a quick plugin count read from each

package/dist/plugins/marketplaceManager.js

@@ -20,8 +20,39 @@ export function marketplacesRoot() {
 export function marketplaceDir(name) {
     return join(marketplacesRoot(), name);
 }
+const CC_MANIFEST_REL = [".claude-plugin", "marketplace.json"];
+const CODEX_MANIFEST_REL = [".agents", "plugins", "marketplace.json"];
+/**
+ * Resolve the marketplace manifest inside a cloned repo. Claude Code's format
+ * lives at .claude-plugin/marketplace.json; the Codex / agents format lives at
+ * .agents/plugins/marketplace.json. Prefer the CC manifest when present (it is
+ * our canonical shape), else fall back to the Codex one. Returns null when
+ * neither exists.
+ */
+function resolveManifestPath(dir) {
+    const cc = join(dir, ...CC_MANIFEST_REL);
+    if (existsSync(cc))
+        return cc;
+    const codex = join(dir, ...CODEX_MANIFEST_REL);
+    if (existsSync(codex))
+        return codex;
+    return null;
+}
 function marketplaceJsonPath(name) {
-    return join(marketplaceDir(name), ".claude-plugin", "marketplace.json");
+    return resolveManifestPath(marketplaceDir(name));
+}
+/**
+ * Classify a cloned marketplace by which manifest files it ships:
+ * both → universal, only .agents/plugins → codex, otherwise claude-code.
+ */
+export function detectMarketplaceFormat(dir) {
+    const hasCc = existsSync(join(dir, ...CC_MANIFEST_REL));
+    const hasCodex = existsSync(join(dir, ...CODEX_MANIFEST_REL));
+    if (hasCc && hasCodex)
+        return "universal";
+    if (hasCodex)
+        return "codex";
+    return "claude-code";
 }
 function sourceToCloneUrl(source) {
     return source.source === "github" ? githubRepoToCloneUrl(source.repo) : source.url;
@@ -55,11 +86,11 @@ export async function addMarketplace(name, source) {
         }
     }
     const manifestPath = marketplaceJsonPath(name);
-    if (!existsSync(manifestPath)) {
+    if (!manifestPath) {
         rmSync(dir, { recursive: true, force: true });
         return {
             ok: false,
-            error: `Marketplace ${name}: .claude-plugin/marketplace.json not found in the cloned repository.`,
+            error: `Marketplace ${name}: no marketplace.json found (looked in .claude-plugin/ and .agents/plugins/).`,
         };
     }
     let raw;
@@ -82,6 +113,7 @@ export async function addMarketplace(name, source) {
         source,
         installLocation: dir,
         lastUpdated: new Date().toISOString(),
+        format: detectMarketplaceFormat(dir),
     };
     upsertKnownMarketplace(name, entry);
     return { ok: true, name, marketplace: v.value, replaced: Boolean(existing) };
@@ -108,7 +140,7 @@ export function loadMarketplace(name) {
     if (!known[name])
         return null;
     const manifestPath = marketplaceJsonPath(name);
-    if (!existsSync(manifestPath))
+    if (!manifestPath)
         return null;
     let raw;
     try {
@@ -136,6 +168,8 @@ export function listMarketplaces() {
             installLocation: entry.installLocation,
             lastUpdated: entry.lastUpdated,
             pluginCount: mp ? mp.plugins.length : -1,
+            // Re-detect from disk when the stored entry predates the format field.
+            format: entry.format ?? detectMarketplaceFormat(entry.installLocation),
         });
     }
     return out.sort((a, b) => a.name.localeCompare(b.name));

package/dist/plugins/pluginCommandHook.js

@@ -31,6 +31,7 @@
  * branch — not the CC one.
  */
 import { spawn } from "node:child_process";
+import { MAX_HOOK_OUTPUT_BYTES } from "../hooks/hook-output.js";
 const DEFAULT_TIMEOUT_MS = 60_000;
 /**
  * Extract the user-facing context string from a CC plugin's stdout JSON.
@@ -99,6 +100,13 @@ export async function runPluginCommandHook(spec, ctx) {
         let stdout = "";
         let stderr = "";
         let settled = false;
+        // Output byte caps mirror src/hooks/shell-runner.ts so a chatty plugin
+        // hook can't hold engine memory hostage. Past the cap we SIGTERM the
+        // child and treat the hook as failed; stderr cap truncates with a
+        // marker instead of failing the hook.
+        let stdoutBytes = 0;
+        let stdoutCapped = false;
+        let stderrCapped = false;
         const settle = (value) => {
             if (settled)
                 return;
@@ -125,9 +133,29 @@ export async function runPluginCommandHook(spec, ctx) {
             settle({});
         }, timeoutMs);
         child.stdout?.on("data", (chunk) => {
+            stdoutBytes += chunk.length;
+            if (stdoutBytes > MAX_HOOK_OUTPUT_BYTES) {
+                if (!stdoutCapped) {
+                    stdoutCapped = true;
+                    // eslint-disable-next-line no-console
+                    console.warn(`[plugin-hook] ${spec.pluginKey} ${ctx.eventName} stdout exceeded ${MAX_HOOK_OUTPUT_BYTES} bytes — killing`);
+                    try {
+                        child.kill("SIGTERM");
+                    }
+                    catch { /* already exited */ }
+                }
+                return;
+            }
             stdout += chunk.toString("utf8");
         });
         child.stderr?.on("data", (chunk) => {
+            if (stderr.length + chunk.length > MAX_HOOK_OUTPUT_BYTES) {
+                if (!stderrCapped) {
+                    stderrCapped = true;
+                    stderr += "\n…[stderr truncated]";
+                }
+                return;
+            }
             stderr += chunk.toString("utf8");
         });
         child.on("error", (err) => {
@@ -138,6 +166,12 @@ export async function runPluginCommandHook(spec, ctx) {
         });
         child.on("close", (code) => {
             clearTimeout(timer);
+            if (stdoutCapped) {
+                // eslint-disable-next-line no-console
+                console.error(`[plugin-hook] ${spec.pluginKey} ${ctx.eventName} killed due to oversized stdout (> ${MAX_HOOK_OUTPUT_BYTES} bytes)`);
+                settle({});
+                return;
+            }
             if (code !== 0) {
                 // eslint-disable-next-line no-console
                 console.warn(`[plugin-hook] ${spec.pluginKey} ${ctx.eventName} exited ${code}; stderr:`, stderr.slice(0, 500));

package/dist/plugins/pluginInstaller.d.ts

@@ -5,6 +5,17 @@
  * sparse-checkout, no npm/pip.
  */
 import type { PluginInstallEntry } from "./types.js";
+/**
+ * Resolve a candidate `installPath` to a realpath and verify it lives strictly
+ * underneath the plugin cache root. Returns the resolved path on success, or
+ * null when the path is missing, escapes the cache, equals the cache root
+ * itself, or is otherwise unsafe to remove.
+ *
+ * Exported so tests can exercise the safety predicate directly without
+ * arranging a full uninstall — the contract this defends (no rmSync outside
+ * the plugin cache) is the entire point of T2 / Workstream A2.
+ */
+export declare function resolveSafePluginPath(installPath: string, cacheRoot: string): string | null;
 export interface VarRewriteReport {
     filesScanned: number;
     filesRewritten: number;
@@ -18,6 +29,16 @@ export type InstallResult = {
     ok: false;
     error: string;
 };
+/**
+ * Compare a marketplace-declared SHA against the cloned HEAD. The
+ * declaration is allowed to be a short prefix (>= 7 chars, standard git
+ * abbreviation length); for stricter integrity guarantees marketplaces
+ * should pin the full 40-char hash. Case-insensitive.
+ *
+ * Exported so a unit test can pin the policy without spinning up a real
+ * clone.
+ */
+export declare function shaMatches(declared: string, actual: string): boolean;
 /**
  * Install a plugin from a previously-added marketplace into the user
  * cache. Idempotent within a process: re-installing replaces the