@nowcrew/daemon 0.6.88-beta.27 → 0.6.88-beta.29

package/dist/machine-windows-environment-script.js

@@ -0,0 +1,158 @@
+/** 固定可信脚本；无 profile、动态命令、注册表写入或桌面用户切换。 */
+export const WINDOWS_ENVIRONMENT_CAPTURE_SCRIPT = String.raw `
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+try {
+  Add-Type -TypeDefinition @'
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Security.Principal;
+using System.Text;
+using Microsoft.Win32;
+
+public sealed class NowWorkEnvironmentSnapshot {
+  public Dictionary<string, string> env;
+  public string[] sourceOwnedKeys;
+  public string accountSid;
+}
+
+public static class NowWorkNativeEnvironment {
+  private const int MaxBytes = 1048576;
+  private const int MaxKeys = 4096;
+  [DllImport("userenv.dll", SetLastError = true)]
+  [return: MarshalAs(UnmanagedType.Bool)]
+  private static extern bool CreateEnvironmentBlock(out IntPtr block, IntPtr token, [MarshalAs(UnmanagedType.Bool)] bool inherit);
+  [DllImport("userenv.dll", SetLastError = true)]
+  [return: MarshalAs(UnmanagedType.Bool)]
+  private static extern bool DestroyEnvironmentBlock(IntPtr block);
+
+  private static void CheckLength(long length) {
+    if (length > MaxBytes) throw new InvalidOperationException("capture_too_large");
+  }
+
+  private static void WriteRaw(BinaryWriter writer, object value) {
+    if (value == null) { writer.Write((byte)0); return; }
+    if (value is string) { writer.Write((byte)1); writer.Write((string)value); }
+    else if (value is int) { writer.Write((byte)2); writer.Write((int)value); }
+    else if (value is long) { writer.Write((byte)3); writer.Write((long)value); }
+    else if (value is byte[]) {
+      byte[] bytes = (byte[])value;
+      CheckLength(bytes.Length);
+      writer.Write((byte)4); writer.Write(bytes.Length); writer.Write(bytes);
+    } else if (value is string[]) {
+      string[] values = (string[])value;
+      writer.Write((byte)5); writer.Write(values.Length);
+      foreach (string item in values) { writer.Write(item); CheckLength(writer.BaseStream.Length); }
+    } else { throw new InvalidOperationException("capture_unavailable"); }
+    CheckLength(writer.BaseStream.Length);
+  }
+
+  private static void ReadRegistry(RegistryKey root, string path, BinaryWriter writer, HashSet<string> owned) {
+    using (RegistryKey key = root.OpenSubKey(path, false)) {
+      writer.Write(path);
+      writer.Write(key != null);
+      if (key == null) return;
+      string[] names = key.GetValueNames();
+      if (names.Length > MaxKeys) throw new InvalidOperationException("capture_too_large");
+      Array.Sort(names, StringComparer.Ordinal);
+      writer.Write(names.Length);
+      foreach (string name in names) {
+        writer.Write(name);
+        writer.Write((int)key.GetValueKind(name));
+        WriteRaw(writer, key.GetValue(name, null, RegistryValueOptions.DoNotExpandEnvironmentNames));
+        if (name.Length > 0 && name.IndexOf('=') < 0 && name.IndexOf('\0') < 0) owned.Add(name);
+        if (owned.Count > MaxKeys) throw new InvalidOperationException("capture_too_large");
+        CheckLength(writer.BaseStream.Length);
+      }
+    }
+  }
+
+  // 只在本地比较 key/type/raw-value 指纹，不输出原始值或指纹。
+  private static string Fingerprint(out string[] sourceOwnedKeys) {
+    HashSet<string> owned = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+    using (MemoryStream memory = new MemoryStream()) {
+      using (BinaryWriter writer = new BinaryWriter(memory, Encoding.UTF8, true)) {
+        ReadRegistry(Registry.LocalMachine, @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment", writer, owned);
+        ReadRegistry(Registry.CurrentUser, "Environment", writer, owned);
+      }
+      sourceOwnedKeys = new string[owned.Count];
+      owned.CopyTo(sourceOwnedKeys);
+      Array.Sort(sourceOwnedKeys, StringComparer.OrdinalIgnoreCase);
+      using (SHA256 hash = SHA256.Create()) { return Convert.ToBase64String(hash.ComputeHash(memory.ToArray())); }
+    }
+  }
+
+  private static Dictionary<string, string> DecodeBlock(IntPtr block) {
+    Dictionary<string, string> values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+    StringBuilder entry = new StringBuilder();
+    for (int offset = 0; offset < MaxBytes; offset += 2) {
+      char character = (char)Marshal.ReadInt16(block, offset);
+      if (character != '\0') { entry.Append(character); continue; }
+      if (entry.Length == 0) return values;
+      string text = entry.ToString();
+      entry.Length = 0;
+      int equals = text.IndexOf('=');
+      if (equals == 0) continue; // =C: 等驱动器工作目录条目不是普通环境变量。
+      if (equals < 1) throw new InvalidOperationException("capture_unavailable");
+      string name = text.Substring(0, equals);
+      if (values.ContainsKey(name)) throw new InvalidOperationException("capture_unavailable");
+      values.Add(name, text.Substring(equals + 1));
+      if (values.Count > MaxKeys) throw new InvalidOperationException("capture_too_large");
+    }
+    throw new InvalidOperationException("capture_too_large");
+  }
+
+  public static NowWorkEnvironmentSnapshot Capture() {
+    using (WindowsIdentity identity = WindowsIdentity.GetCurrent()) {
+      if (identity.User == null) throw new InvalidOperationException("capture_unavailable");
+      for (int attempt = 0; attempt < 4; attempt++) {
+        string[] owned;
+        string before = Fingerprint(out owned);
+        IntPtr block = IntPtr.Zero;
+        Dictionary<string, string> values;
+        try {
+          // bInherit=false：让 userenv 原生重建最新系统 + 当前账号环境，含 Path / REG_EXPAND_SZ。
+          if (!CreateEnvironmentBlock(out block, identity.Token, false)) throw new InvalidOperationException("capture_unavailable");
+          values = DecodeBlock(block);
+        } finally {
+          if (block != IntPtr.Zero && !DestroyEnvironmentBlock(block)) throw new InvalidOperationException("capture_unavailable");
+        }
+        string[] afterOwned;
+        string after = Fingerprint(out afterOwned);
+        if (before.Equals(after, StringComparison.Ordinal)) {
+          return new NowWorkEnvironmentSnapshot { env = values, sourceOwnedKeys = owned, accountSid = identity.User.Value };
+        }
+      }
+      throw new InvalidOperationException("capture_unavailable");
+    }
+  }
+}
+'@ -ErrorAction Stop | Out-Null
+  $snapshot = [NowWorkNativeEnvironment]::Capture()
+  $json = ConvertTo-Json -InputObject $snapshot -Depth 5 -Compress
+  if ([Text.Encoding]::UTF8.GetByteCount($json) -gt 1048576) { exit 12 }
+  [Console]::Write($json)
+  exit 0
+} catch {
+  # 不输出异常：它可能携带注册表值、编译器命令或用户路径。
+  if ($_.Exception.ToString().Contains('capture_too_large')) { exit 12 }
+  exit 11
+}
+`;
+export const WINDOWS_DAEMON_SID_SCRIPT = String.raw `
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+$identity = $null
+try {
+  $identity = [System.Security.Principal.WindowsIdentity]::GetCurrent()
+  $json = ConvertTo-Json -InputObject @{ accountSid = $identity.User.Value } -Compress
+  [Console]::Write($json)
+} catch { exit 11 } finally {
+  if ($null -ne $identity) { $identity.Dispose() }
+}
+`;

package/dist/marketplace-controller.js

@@ -0,0 +1,75 @@
+import { MarketplaceRequestSchema, marketplaceActive } from "./marketplace-protocol.js";
+import { resolveMarketplaceScopes, runMarketplaceScope } from "./marketplace-runner.js";
+export function createMarketplaceController(deps) {
+    const operations = new Map();
+    let stopped = false;
+    let current = null;
+    const now = deps.now ?? Date.now;
+    const wait = deps.wait ?? (() => new Promise(resolve => { setTimeout(resolve, 1000); }));
+    const execute = async (request) => {
+        const id = request.operationId;
+        const deadline = now() + 10 * 60_000;
+        let lease = null;
+        try {
+            while (!stopped && now() < deadline && lease === null) {
+                lease = await deps.acquire();
+                if (!lease)
+                    await wait();
+            }
+            if (!lease || stopped) {
+                operations.set(id, { operationId: id, status: "failed", results: [], errorCode: "runtime_busy" });
+                return;
+            }
+            operations.set(id, { operationId: id, status: "running", results: [], errorCode: null });
+            const scopes = await (deps.resolve ?? resolveMarketplaceScopes)(request.targets, deps.agentsRoot);
+            const results = [];
+            for (const scope of scopes) {
+                if (stopped || now() >= deadline)
+                    throw new Error("operation_deadline");
+                results.push(await (deps.run ?? runMarketplaceScope)(scope, request.mode));
+                operations.set(id, { operationId: id, status: "running", results: [...results], errorCode: null });
+                if (now() >= deadline)
+                    throw new Error("operation_deadline");
+            }
+            const successes = results.filter(x => !["failed", "missing_cli"].includes(x.status)).length;
+            operations.set(id, { operationId: id, results, status: successes === results.length ? "completed" : successes ? "partial" : "failed", errorCode: null });
+        }
+        catch {
+            const previous = operations.get(id);
+            operations.set(id, { ...previous, status: previous.results.some(x => !x.errorCode) ? "partial" : "failed", errorCode: "execution_failed" });
+        }
+        finally {
+            try {
+                await lease?.release();
+            }
+            catch {
+                const previous = operations.get(id);
+                operations.set(id, { ...previous, status: "partial", errorCode: "execution_failed" });
+            }
+        }
+    };
+    return {
+        handle(raw) {
+            const parsed = MarketplaceRequestSchema.safeParse(raw);
+            if (!parsed.success || stopped)
+                return { ok: false, error: "invalid_request" };
+            const request = parsed.data;
+            const existing = operations.get(request.operationId);
+            if (existing)
+                return { ok: true, data: existing };
+            if (request.action === "status")
+                return { ok: true, data: { operationId: request.operationId, status: "unknown", results: [], errorCode: "operation_unknown" } };
+            if (process.platform !== "darwin" && process.platform !== "linux")
+                return { ok: false, error: "unsupported_platform" };
+            if (current !== null || [...operations.values()].some(x => marketplaceActive(x.status)))
+                return { ok: false, error: "runtime_busy" };
+            if (operations.size >= 100)
+                operations.delete(operations.keys().next().value);
+            const accepted = { operationId: request.operationId, status: "queued", results: [], errorCode: null };
+            operations.set(request.operationId, accepted);
+            current = execute(request).finally(() => { current = null; });
+            return { ok: true, data: accepted };
+        },
+        async stop() { stopped = true; await current; },
+    };
+}

package/dist/marketplace-protocol.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+// 与另一个进程中的 marketplace-protocol.ts 保持一致；跨进程契约测试校验摘要。
+export const MARKETPLACE_CAPABILITY = "marketplace_update_v1";
+export const MARKETPLACE = "nowwork-pm";
+export const PLUGIN = "AIinterview-plugin";
+export const MarketplaceModeSchema = z.enum(["inspect", "refresh", "update"]);
+export const MarketplaceStatusSchema = z.enum(["queued", "running", "completed", "partial", "failed", "unknown"]);
+export const MarketplaceTargetSchema = z.object({
+    handle: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/).optional(),
+    runtime: z.enum(["claude", "codex"]),
+    provider: z.enum(["default", "custom", "deepseek"]).default("default"),
+    hasProviderKey: z.boolean().default(false),
+    paths: z.object({ HOME: z.string().min(1).max(4096).optional(), CODEX_HOME: z.string().min(1).max(4096).optional(),
+        CLAUDE_CONFIG_DIR: z.string().min(1).max(4096).optional() }).strict().default({}),
+}).strict();
+export const MarketplaceRequestSchema = z.object({
+    type: z.literal("marketplace:operation"), action: z.enum(["start", "status"]),
+    operationId: z.string().uuid(), mode: MarketplaceModeSchema.optional(),
+    targets: z.array(MarketplaceTargetSchema).min(1).max(202).optional(),
+}).strict().refine(x => x.action !== "start" || (x.mode !== undefined && x.targets !== undefined));
+const Version = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,79}$/).nullable();
+const Revision = z.string().regex(/^[a-f0-9]{40}$/).nullable();
+export const MarketplaceResultSchema = z.object({
+    runtime: z.enum(["claude", "codex"]), scopeId: z.string().regex(/^[a-f0-9]{16}$/),
+    agents: z.array(z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/)).max(200),
+    shared: z.boolean(), status: z.enum(["checked", "refreshed", "updated", "unchanged", "not_installed", "missing_cli", "failed"]),
+    beforeVersion: Version, afterVersion: Version, targetVersion: Version,
+    marketRevision: Revision, installedRevision: Revision, enabled: z.boolean().nullable(),
+    activation: z.enum(["not_changed", "reload_required", "unverified"]),
+    errorCode: z.enum(["scope_unavailable", "market_not_registered", "command_failed", "command_timeout", "invalid_inventory",
+        "verification_failed", "unsupported_installation", "cli_missing", "configuration_changed"]).nullable(),
+}).strict();
+export const MarketplaceReportSchema = z.object({
+    operationId: z.string().uuid(), status: MarketplaceStatusSchema,
+    results: z.array(MarketplaceResultSchema).max(202),
+    errorCode: z.enum(["runtime_busy", "execution_failed", "operation_unknown", "unsupported_platform", "too_many_scopes"]).nullable(),
+}).strict();
+export const marketplaceActive = (status) => status === "queued" || status === "running";

package/dist/marketplace-runner.js

@@ -0,0 +1,234 @@
+/** 固定市场操作的短命 CLI 适配；原始命令输出不离开设备。 */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+import { readFile, readdir, realpath, lstat, mkdtemp, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve, isAbsolute, relative, sep } from "node:path";
+import { applyProviderEnv } from "./provider-env.js";
+import { augmentedPath } from "./runtime-path.js";
+import { MARKETPLACE, PLUGIN } from "./marketplace-protocol.js";
+const exec = promisify(execFile);
+const SELECTOR = `${PLUGIN}@${MARKETPLACE}`;
+const SOURCE = "git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git";
+const SOURCE_PATH = "plugins/AIinterview-plugin";
+export class MarketplaceFailure extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+export const runMarketplaceCommand = async (bin, args, options) => {
+    try {
+        const result = await exec(bin, [...args], { ...options, timeout: 120_000, maxBuffer: 4 * 1024 * 1024,
+            killSignal: "SIGKILL", encoding: "utf8" });
+        return result.stdout;
+    }
+    catch (error) {
+        const value = error;
+        throw new MarketplaceFailure(value.code === "ENOENT" ? "cli_missing" : value.killed ? "command_timeout" : "command_failed");
+    }
+};
+const obj = (x) => x !== null && typeof x === "object" && !Array.isArray(x) ? x : {};
+const parse = (text) => { try {
+    return JSON.parse(text);
+}
+catch {
+    throw new MarketplaceFailure("invalid_inventory");
+} };
+const version = (x) => typeof x === "string" && /^[A-Za-z0-9][A-Za-z0-9._+-]{0,79}$/.test(x) ? x : null;
+const sha = (x) => typeof x === "string" && /^[a-f0-9]{40}$/.test(x) ? x : null;
+const within = (root, candidate) => {
+    const child = relative(root, candidate);
+    return child === "" || (child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child));
+};
+const canonical = async (path) => realpath(path).catch(() => resolve(path));
+export async function resolveMarketplaceScopes(targets, agentsRoot, inherited = process.env) {
+    const scopes = new Map();
+    const trustedHome = await canonical(inherited.HOME ?? homedir());
+    for (const target of targets) {
+        const home = target.handle ? join(agentsRoot, target.handle, ".home") : homedir();
+        const agentHome = target.handle ? await canonical(home) : null;
+        const allowedHomeRoots = [trustedHome, ...(agentHome === null ? [] : [agentHome])];
+        const sharedConfigRoot = join(trustedHome, target.runtime === "codex" ? ".codex" : ".claude");
+        const agentConfigRoot = agentHome === null ? null : join(agentHome, target.runtime === "codex" ? ".codex" : ".claude");
+        const allowedConfigRoots = [sharedConfigRoot, ...(agentConfigRoot === null ? [] : [agentConfigRoot])];
+        const suppliedHome = target.paths.HOME;
+        if (suppliedHome !== undefined && !within(allowedHomeRoots[0], await canonical(suppliedHome))
+            && (agentHome === null || !within(agentHome, await canonical(suppliedHome))))
+            throw new MarketplaceFailure("scope_unavailable");
+        const suppliedConfig = target.runtime === "codex" ? target.paths.CODEX_HOME : target.paths.CLAUDE_CONFIG_DIR;
+        const suppliedConfigPath = suppliedConfig === undefined ? null : await canonical(suppliedConfig);
+        if (suppliedConfigPath !== null && !allowedConfigRoots.some(root => within(root, suppliedConfigPath)))
+            throw new MarketplaceFailure("scope_unavailable");
+        // 与 local-executor 使用同一 provider 解析；凭据存在性只用于选择已配置的 provider，不传递凭据内容。
+        const env = applyProviderEnv({ ...inherited, ...target.paths }, target.runtime, target.handle ? {
+            provider: target.provider, providerApiKey: target.hasProviderKey ? "configured" : null,
+        } : {}, home);
+        for (const key of Object.keys(env))
+            if (/^(CREW_|ANTHROPIC_|OPENAI_|DEEPSEEK_)/.test(key))
+                delete env[key];
+        for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR"])
+            delete env[key];
+        env.PATH = augmentedPath(inherited);
+        env.GIT_TERMINAL_PROMPT = "0";
+        env.CI = "1";
+        const raw = target.runtime === "codex" ? env.CODEX_HOME ?? join(env.HOME ?? homedir(), ".codex")
+            : env.CLAUDE_CONFIG_DIR ?? join(env.HOME ?? homedir(), ".claude");
+        if (!isAbsolute(raw))
+            throw new MarketplaceFailure("scope_unavailable");
+        const configHome = await realpath(raw).catch(() => resolve(raw));
+        if (!allowedConfigRoots.some(root => within(root, configHome)))
+            throw new MarketplaceFailure("scope_unavailable");
+        if (target.runtime === "codex")
+            env.CODEX_HOME = configHome;
+        else
+            env.CLAUDE_CONFIG_DIR = configHome;
+        const key = `${target.runtime}:${configHome}`;
+        const prior = scopes.get(key);
+        if (prior) {
+            if (target.handle && !prior.agents.includes(target.handle))
+                prior.agents.push(target.handle);
+            prior.shared ||= !target.handle;
+        }
+        else
+            scopes.set(key, { runtime: target.runtime, configHome, env, agents: target.handle ? [target.handle] : [], shared: !target.handle });
+    }
+    return [...scopes.values()];
+}
+export function parsePluginInventory(runtime, value, configHome) {
+    const rows = Array.isArray(value) ? value : obj(value).installed;
+    if (!Array.isArray(rows))
+        throw new MarketplaceFailure("invalid_inventory");
+    const found = rows.map(obj).filter(x => (x.id ?? x.pluginId) === SELECTOR);
+    if (found.length === 0)
+        return null;
+    if (found.length !== 1)
+        throw new MarketplaceFailure("unsupported_installation");
+    const item = found[0];
+    const v = version(item.version);
+    if (!v || typeof item.enabled !== "boolean")
+        throw new MarketplaceFailure("invalid_inventory");
+    if (runtime === "claude" && item.scope !== "user")
+        throw new MarketplaceFailure("unsupported_installation");
+    const path = runtime === "claude" ? item.installPath : join(configHome, "plugins/cache", MARKETPLACE, PLUGIN, v);
+    if (typeof path !== "string" || !isAbsolute(path))
+        throw new MarketplaceFailure("invalid_inventory");
+    return { version: v, enabled: item.enabled, path, revision: sha(obj(item.source).sha) };
+}
+/** 逐字节比对固定 Git 源子目录，不能只凭 CLI 退出码或版本字符串证明安装完成。 */
+export async function verifyInstalledContent(path, revision, env, command) {
+    const temporary = await mkdtemp(join(tmpdir(), "nowwork-plugin-verify-"));
+    const options = { env, cwd: temporary };
+    try {
+        await command("git", ["init", "--bare", "."], options);
+        await command("git", ["fetch", "--depth=1", SOURCE, revision], options);
+        const tree = await command("git", ["ls-tree", "-rz", `${revision}:${SOURCE_PATH}`], options);
+        const expected = new Map();
+        for (const entry of tree.split("\0").filter(Boolean)) {
+            const match = /^(100644|100755) blob ([a-f0-9]{40})\t(.+)$/.exec(entry);
+            if (!match || match[3].split("/").some(x => x === ".." || x === "."))
+                throw new MarketplaceFailure("verification_failed");
+            expected.set(match[3], match[2]);
+        }
+        if (!expected.size || expected.size > 2000)
+            throw new MarketplaceFailure("verification_failed");
+        const actual = new Map();
+        let bytes = 0;
+        const walk = async (dir, prefix = "") => {
+            for (const name of await readdir(dir)) {
+                if (name === "__pycache__" || name === ".DS_Store")
+                    continue;
+                const entry = join(dir, name);
+                const key = prefix + name;
+                const info = await lstat(entry);
+                if (info.isSymbolicLink())
+                    throw new MarketplaceFailure("verification_failed");
+                if (info.isDirectory())
+                    await walk(entry, key + "/");
+                else if (info.isFile()) {
+                    bytes += info.size;
+                    if (bytes > 100 * 1024 * 1024 || actual.size > 2000)
+                        throw new MarketplaceFailure("verification_failed");
+                    const data = await readFile(entry);
+                    actual.set(key, createHash("sha1").update(`blob ${data.length}\0`).update(data).digest("hex"));
+                }
+                else
+                    throw new MarketplaceFailure("verification_failed");
+            }
+        };
+        await walk(path);
+        if (actual.size !== expected.size || [...expected].some(([name, hash]) => actual.get(name) !== hash))
+            throw new MarketplaceFailure("verification_failed");
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+export async function runMarketplaceScope(scope, mode, command = runMarketplaceCommand, verify = verifyInstalledContent) {
+    let result = { runtime: scope.runtime, scopeId: createHash("sha256").update(`${scope.runtime}:${scope.configHome}`).digest("hex").slice(0, 16),
+        agents: scope.agents, shared: scope.shared, status: "failed", beforeVersion: null, afterVersion: null, targetVersion: null,
+        marketRevision: null, installedRevision: null, enabled: null, activation: "unverified", errorCode: null };
+    const options = { env: scope.env, cwd: scope.configHome };
+    const run = (args) => command(scope.runtime, args, options);
+    const inventory = async () => parsePluginInventory(scope.runtime, parse(await run(["plugin", "list", "--json"])), scope.configHome);
+    try {
+        if (!(await lstat(scope.configHome)).isDirectory())
+            throw new MarketplaceFailure("scope_unavailable");
+        const markets = parse(await run(["plugin", "marketplace", "list", "--json"]));
+        const rows = Array.isArray(markets) ? markets : obj(markets).marketplaces;
+        if (!Array.isArray(rows))
+            throw new MarketplaceFailure("invalid_inventory");
+        const market = rows.map(obj).filter(x => x.name === MARKETPLACE);
+        if (market.length !== 1)
+            throw new MarketplaceFailure("market_not_registered");
+        const root = market[0].root ?? market[0].installLocation;
+        if (typeof root !== "string" || !isAbsolute(root))
+            throw new MarketplaceFailure("invalid_inventory");
+        const before = await inventory();
+        result = { ...result, beforeVersion: before?.version ?? null, afterVersion: before?.version ?? null, enabled: before?.enabled ?? null };
+        if (mode !== "inspect")
+            await run(["plugin", "marketplace", scope.runtime === "claude" ? "update" : "upgrade", MARKETPLACE]);
+        const revision = sha((await command("git", ["-C", root, "rev-parse", "HEAD"], options)).trim());
+        if (!revision)
+            throw new MarketplaceFailure("verification_failed");
+        const manifest = obj(parse(await readFile(join(root, scope.runtime === "claude" ? ".claude-plugin" : ".agents/plugins", "marketplace.json"), "utf8")));
+        const plugins = manifest.plugins;
+        const target = Array.isArray(plugins) ? plugins.map(obj).find(x => x.name === PLUGIN) : undefined;
+        const source = obj(target?.source);
+        const targetVersion = version(target?.version);
+        const targetSha = sha(source.sha);
+        result = { ...result, marketRevision: revision, targetVersion };
+        if (mode === "refresh")
+            return { ...result, status: "refreshed", activation: "not_changed" };
+        if (!before)
+            return { ...result, status: "not_installed", activation: "not_changed" };
+        if (mode === "inspect") {
+            const installed = obj(parse(await readFile(join(before.path, scope.runtime === "claude" ? ".claude-plugin" : ".codex-plugin", "plugin.json"), "utf8")));
+            const actualVersion = version(installed.version);
+            result = { ...result, afterVersion: actualVersion };
+            if (installed.name !== PLUGIN || actualVersion !== before.version)
+                throw new MarketplaceFailure("verification_failed");
+            // 清单可能来自市场元数据；没有文件内容核验就不报告已安装源提交。
+            return { ...result, status: "checked", installedRevision: null, activation: "unverified" };
+        }
+        if (!targetVersion || !targetSha || source.url !== SOURCE || source.path !== SOURCE_PATH || source.source !== "git-subdir")
+            throw new MarketplaceFailure("unsupported_installation");
+        // Codex add 会启用插件；不偷偷改变用户已禁用的状态。
+        if (!before.enabled)
+            throw new MarketplaceFailure("unsupported_installation");
+        await run(scope.runtime === "claude" ? ["plugin", "update", SELECTOR, "--scope", "user", "--json"] : ["plugin", "add", SELECTOR, "--json"]);
+        const after = await inventory();
+        result = { ...result, afterVersion: after?.version ?? null, enabled: after?.enabled ?? null };
+        if (!after || after.version !== targetVersion || after.enabled !== before.enabled)
+            throw new MarketplaceFailure("verification_failed");
+        await verify(after.path, targetSha, scope.env, command);
+        return { ...result, status: before.version === after.version && before.revision === targetSha ? "unchanged" : "updated",
+            installedRevision: targetSha, activation: "reload_required" };
+    }
+    catch (error) {
+        const code = error instanceof MarketplaceFailure ? error.code : "scope_unavailable";
+        return { ...result, status: code === "cli_missing" ? "missing_cli" : "failed", errorCode: code };
+    }
+}

package/dist/marketplace-serve.js

@@ -0,0 +1,17 @@
+import { createMarketplaceController } from "./marketplace-controller.js";
+import { prepareDaemonRestart } from "./daemon-updater.js";
+export function createServeMarketplace(config, localSlots, hostCoordinator) {
+    const controller = createMarketplaceController({ agentsRoot: config.agentsRoot,
+        acquire: async () => { const result = await prepareDaemonRestart({ localSlots, hostCoordinator }); return result.ok ? result : null; } });
+    return {
+        handle(raw, send) {
+            if (!raw || typeof raw !== "object" || !("type" in raw) || raw.type !== "marketplace:operation")
+                return false;
+            const { reqId, ...request } = raw;
+            if (typeof reqId === "string")
+                send({ type: "fs:result", reqId, ...controller.handle(request) });
+            return true;
+        },
+        stop: controller.stop,
+    };
+}