@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

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

@@ -0,0 +1,215 @@
+import { spawn } from "node:child_process";
+import { win32 } from "node:path";
+import { MACHINE_ENVIRONMENT_MAX_BYTES, MACHINE_ENVIRONMENT_MAX_ENTRIES, MachineEnvironmentCaptureError, } from "./machine-environment-contract.js";
+import { WINDOWS_DAEMON_SID_SCRIPT, WINDOWS_ENVIRONMENT_CAPTURE_SCRIPT } from "./machine-windows-environment-script.js";
+const CAPTURE_TIMEOUT_MS = 8_000;
+const CLEANUP_TIMEOUT_MS = 2_000;
+const validSid = (value) => typeof value === "string" && value.length <= 184 && /^S-1-(?:\d+-)+\d+$/.test(value);
+const unavailable = () => new MachineEnvironmentCaptureError("windows_environment_unavailable");
+const validKey = (key) => key.length > 0 && !/[=\0]/.test(key);
+function systemExecutable(startupEnv, relative) {
+    const roots = Object.entries(startupEnv).filter(([key]) => key.toUpperCase() === "SYSTEMROOT");
+    const root = roots[0]?.[1];
+    if (roots.length !== 1 || !root || !/^[A-Za-z]:[\\/]/.test(root) || /[\0\r\n]/.test(root)
+        || root.slice(2).includes(":") || root.split(/[\\/]/).some((part) => part === "." || part === ".."))
+        throw unavailable();
+    return win32.join(root, "System32", relative);
+}
+/** 仅终止本调用仍持有的活 helper PID；根进程已退出时不按旧 PID 杀进程。 */
+export const runWindowsEnvironmentProcess = (request) => new Promise((resolve, reject) => {
+    if (request.signal?.aborted || request.deadline <= Date.now()) {
+        reject(new MachineEnvironmentCaptureError("shell_capture_timeout"));
+        return;
+    }
+    let child;
+    try {
+        child = spawn(request.file, [...request.args], {
+            env: { ...request.env }, stdio: ["ignore", "pipe", "pipe"], shell: false, windowsHide: true,
+        });
+    }
+    catch {
+        reject(unavailable());
+        return;
+    }
+    let settled = false;
+    let failure;
+    let cleanupTimer;
+    let killer;
+    let killerClosed = true;
+    let helperClosed = false;
+    const chunks = [];
+    let bytes = 0;
+    function finish(error) {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(captureTimer);
+        if (cleanupTimer !== undefined)
+            clearTimeout(cleanupTimer);
+        request.signal?.removeEventListener("abort", abort);
+        if (error) {
+            chunks.length = 0;
+            reject(new MachineEnvironmentCaptureError(error));
+        }
+        else
+            resolve(Buffer.concat(chunks));
+    }
+    function finishCleanup() {
+        if (helperClosed && killerClosed)
+            finish(failure);
+    }
+    function stop(code) {
+        if (failure || settled)
+            return;
+        failure = code;
+        chunks.length = 0;
+        clearTimeout(captureTimer);
+        cleanupTimer = setTimeout(() => {
+            // Node 的 kill 使用本 ChildProcess 的句柄；这里不使用已退出 helper 的陈旧 PID。
+            if (killer && killer.exitCode === null && killer.signalCode === null)
+                killer.kill();
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill();
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            child.unref();
+            finish("shell_cleanup_failed");
+        }, CLEANUP_TIMEOUT_MS);
+        if (child.pid && child.exitCode === null && child.signalCode === null) {
+            try {
+                killerClosed = false;
+                killer = spawn(systemExecutable(request.env, "taskkill.exe"), ["/PID", String(child.pid), "/T", "/F"], {
+                    env: { ...request.env }, stdio: "ignore", shell: false, windowsHide: true,
+                });
+                killer.once("error", () => { killerClosed = true; failure = "shell_cleanup_failed"; child.kill(); finishCleanup(); });
+                killer.once("close", (exitCode) => {
+                    killerClosed = true;
+                    if (exitCode !== 0)
+                        failure = "shell_cleanup_failed";
+                    finishCleanup();
+                });
+            }
+            catch {
+                killerClosed = true;
+                failure = "shell_cleanup_failed";
+                child.kill();
+            }
+        }
+        finishCleanup();
+    }
+    const abort = () => stop("shell_capture_timeout");
+    const captureTimer = setTimeout(abort, Math.max(1, request.deadline - Date.now()));
+    request.signal?.addEventListener("abort", abort, { once: true });
+    child.stdout?.on("data", (data) => {
+        if (settled || failure)
+            return;
+        bytes += data.length;
+        if (bytes > request.maxBytes)
+            stop("shell_capture_too_large");
+        else
+            chunks.push(Buffer.from(data));
+    });
+    child.stderr?.on("data", (data) => {
+        if (settled || failure)
+            return;
+        bytes += data.length;
+        if (bytes > request.maxBytes)
+            stop("shell_capture_too_large");
+    });
+    child.once("error", () => {
+        if (failure)
+            return;
+        finish("windows_environment_unavailable");
+    });
+    child.once("close", (code) => {
+        helperClosed = true;
+        if (failure)
+            finishCleanup();
+        else if (code === 0)
+            finish();
+        else
+            finish(code === 12 ? "shell_capture_too_large" : "windows_environment_unavailable");
+    });
+    if (request.signal?.aborted)
+        abort();
+});
+async function runScript(options, script) {
+    const deadline = Math.min(options.deadline ?? Date.now() + CAPTURE_TIMEOUT_MS, Date.now() + CAPTURE_TIMEOUT_MS);
+    if (options.signal?.aborted || deadline <= Date.now())
+        throw new MachineEnvironmentCaptureError("shell_capture_timeout");
+    const maxBytes = Math.min(options.maxBytes ?? MACHINE_ENVIRONMENT_MAX_BYTES, MACHINE_ENVIRONMENT_MAX_BYTES);
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+        throw unavailable();
+    const file = systemExecutable(options.startupEnv, "WindowsPowerShell\\v1.0\\powershell.exe");
+    let output;
+    try {
+        output = await (options.runner ?? runWindowsEnvironmentProcess)({
+            file, args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")],
+            env: options.startupEnv, deadline, maxBytes, ...(options.signal ? { signal: options.signal } : {}),
+        });
+    }
+    catch (error) {
+        if (error instanceof MachineEnvironmentCaptureError)
+            throw new MachineEnvironmentCaptureError(error.code);
+        throw unavailable();
+    }
+    if (output.length > maxBytes)
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    try {
+        const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(output));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw unavailable();
+        return parsed;
+    }
+    catch {
+        throw unavailable();
+    }
+}
+export async function captureWindowsEnvironment(options) {
+    if (!validSid(options.expectedSid))
+        throw unavailable();
+    const payload = await runScript(options, WINDOWS_ENVIRONMENT_CAPTURE_SCRIPT);
+    if (!validSid(payload.accountSid))
+        throw unavailable();
+    if (payload.accountSid !== options.expectedSid)
+        throw new MachineEnvironmentCaptureError("windows_environment_identity_mismatch");
+    if (!payload.env || typeof payload.env !== "object" || Array.isArray(payload.env) || !Array.isArray(payload.sourceOwnedKeys))
+        throw unavailable();
+    const entries = Object.entries(payload.env);
+    if (entries.length > MACHINE_ENVIRONMENT_MAX_ENTRIES || payload.sourceOwnedKeys.length > MACHINE_ENVIRONMENT_MAX_ENTRIES) {
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    }
+    const env = Object.create(null);
+    const seen = new Set();
+    for (const [key, value] of entries) {
+        const folded = key.toUpperCase();
+        if (!validKey(key) || seen.has(folded) || typeof value !== "string" || value.includes("\0"))
+            throw unavailable();
+        seen.add(folded);
+        env[key] = value;
+    }
+    seen.clear();
+    const sourceOwnedKeys = [];
+    for (const key of payload.sourceOwnedKeys) {
+        if (typeof key !== "string" || !validKey(key) || seen.has(key.toUpperCase()))
+            throw unavailable();
+        seen.add(key.toUpperCase());
+        sourceOwnedKeys.push(key);
+    }
+    return Object.freeze({ env: Object.freeze(env), sourceOwnedKeys: Object.freeze(sourceOwnedKeys), accountSid: payload.accountSid });
+}
+export async function resolveWindowsDaemonSid(options) {
+    const payload = await runScript(options, WINDOWS_DAEMON_SID_SCRIPT);
+    if (!validSid(payload.accountSid))
+        throw unavailable();
+    return payload.accountSid;
+}
+export const captureWindowsMachineEnvironment = async (request) => {
+    const options = { startupEnv: request.startupEnv, signal: request.signal, deadline: request.deadline };
+    const expectedSid = request.account.sid ?? await resolveWindowsDaemonSid(options);
+    const result = await captureWindowsEnvironment({ ...options, expectedSid });
+    return {
+        ...result,
+        sourceLocations: ["HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment", "HKCU\\Environment"],
+    };
+};

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/main.js

@@ -7,7 +7,6 @@
  */
 import { parseArgs } from "node:util";
 import { homedir } from "node:os";
-import { join } from "node:path";
 import { loadConfig, ConfigError } from "./config.js";
 import { detectDaemonLang, formatDaemonText, translateDaemon } from "./i18n.js";
 import { cliVersion, daemonVersion } from "./machine-info.js";
@@ -25,19 +24,9 @@ import { assertManagedServiceStartup } from "./managed-service-startup.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { acquireDaemonInstallationLease, runWithDaemonInstallationLease, } from "./daemon-installation-lease.js";
 import { createStorageRuntimeOwnershipBinding, loadStorageRuntime } from "./storage-runtime.js";
-import { readStorageMigrationReceipt } from "./storage-migration-controller.js";
-import { storageMigrationStatusReplay } from "./storage-status-replay.js";
-import { runStorageWorkerCommand } from "./storage-worker-command.js";
-import { probeStorageMigrationRuntime } from "./storage-runtime-readiness.js";
-import { createStorageTargetConfirmationHandler } from "./storage-target-confirmation.js";
 import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 import { storageServiceEnvironment } from "./computer-service.js";
 async function main() {
-    const workerResult = await runStorageWorkerCommand(process.argv.slice(2));
-    if (workerResult !== null) {
-        process.exitCode = workerResult;
-        return;
-    }
     const computerResult = await runComputerCommand(process.argv.slice(2));
     if (computerResult !== null) {
         process.exitCode = computerResult;
@@ -74,7 +63,6 @@ async function main() {
     // 不把 machine token 放进 argv / plist / systemd unit / scheduled task。
     if (values["daemon-home"])
         process.env.CREW_DAEMON_HOME = values["daemon-home"];
-    let activeDaemonHome;
     const localHome = resolveDaemonLocalStateRoot({
         userHome: homedir(),
         platform: process.platform,
@@ -85,7 +73,6 @@ async function main() {
     });
     if (values.profile) {
         const home = daemonHome(process.env, values.profile);
-        activeDaemonHome = home;
         const profile = await loadProfile(values.profile, home);
         if (cmd === "serve") {
             await assertProfileAgentsRootUnique(profile, home, homedir());
@@ -148,68 +135,16 @@ async function main() {
         const installationLease = installation === null
             ? null
             : await acquireDaemonInstallationLease(installation.npmPrefix, { localHome });
-        const migrationRuntime = values.profile === undefined || activeDaemonHome === undefined || storageRuntime !== null
-            ? { ready: false, reason: "not_legacy_source" }
-            : await probeStorageMigrationRuntime({
-                profile: values.profile,
-                serverUrl: config.serverUrl,
-                currentDaemonHome: activeDaemonHome,
-                currentAgentsRoot: config.agentsRoot,
-                userHome: homedir(),
-                platform: process.platform,
-                ...(process.getuid === undefined ? {} : { uid: process.getuid() }),
-                environment: process.env,
-            });
-        const targetStorageBinding = storageRuntime === null
+        const storageBinding = storageRuntime === null
             ? null
             : createStorageRuntimeOwnershipBinding(storageRuntime);
-        const targetConfirmation = storageRuntime?.identity.storageMigrationId === undefined
-            ? null
-            : createStorageTargetConfirmationHandler({
-                backupsRoot: storageRuntime.local.backupsRoot,
-                identity: storageRuntime.identity,
-                profile: storageRuntime.installation.profile,
-                completionTimeoutMs: 180_000,
-            });
-        const storageMigration = storageRuntime !== null
-            ? {
-                ready: false,
-                statusOutboxPath: join(storageRuntime.local.stateRoot, "storage-status-outbox.json"),
-                identity: targetStorageBinding.identity,
-                bindServerIdentity: targetStorageBinding.bind,
-                ...(targetConfirmation === null ? {} : { confirm: targetConfirmation.handle }),
-                ...(storageRuntime.identity.storageMigrationId === undefined ? {} : {
-                    replayStatus: async (send) => {
-                        const migrationId = storageRuntime.identity.storageMigrationId;
-                        const receipt = await readStorageMigrationReceipt(storageRuntime.local.backupsRoot, migrationId);
-                        if (receipt === null)
-                            throw new Error(`storage migration receipt not found: ${migrationId}`);
-                        for (const frame of storageMigrationStatusReplay(receipt, {
-                            migrationId,
-                            environment: storageRuntime.identity.storageEnvironment,
-                            workspaceId: storageRuntime.identity.storageWorkspaceId,
-                            profile: storageRuntime.installation.profile,
-                        }))
-                            send(frame);
-                    },
-                }),
-            }
-            : migrationRuntime.ready
-                ? {
-                    ready: true,
-                    statusOutboxPath: migrationRuntime.runtime.statusOutboxPath,
-                    identity: migrationRuntime.runtime.identity,
-                    controller: migrationRuntime.runtime.controller,
-                    attach: migrationRuntime.runtime.attach,
-                    bindServerIdentity: migrationRuntime.runtime.bindServerIdentity,
-                    replayStatus: migrationRuntime.runtime.replayStatus,
-                }
-                : undefined;
         await runWithDaemonInstallationLease(installationLease, async () => {
             const service = serve(runtimeConfig, {
                 ...(values.profile === undefined ? {} : { profileName: values.profile }),
                 localHome,
-                ...(storageMigration === undefined ? {} : { storageMigration }),
+                ...(storageBinding === null ? {} : {
+                    storageRuntime: { identity: storageBinding.identity, bindServerIdentity: storageBinding.bind },
+                }),
             });
             await runServeLifecycle(service);
         });

package/dist/marketplace-command.js

@@ -0,0 +1,21 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+export class MarketplaceFailure extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+const exec = promisify(execFile);
+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");
+    }
+};

package/dist/marketplace-controller.js

@@ -0,0 +1,80 @@
+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 {
+            const scopes = await (deps.resolve ?? resolveMarketplaceScopes)(request.targets, deps.agentsRoot);
+            // 查询不使用任务执行槽；只有写入运行时共用市场/插件目录时才等待独占保护。
+            if (request.mode === "update") {
+                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;
+                }
+            }
+            if (stopped || now() >= deadline)
+                throw new Error("operation_deadline");
+            operations.set(id, { operationId: id, status: "running", results: [], errorCode: null });
+            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";