@nggaigc/cli 0.1.53 → 0.1.55

package/README.md

@@ -12,7 +12,13 @@ CLI 保留 macOS npm symlink 入口与 packed-TGZ launcher 检查，并验证随
 
 从 CLI `0.1.52` 起，Intel Mac 仅放开安装限制，安装的签名包与 macOS 辅助程序字节保持不变；未做 Intel 兼容性适配或真机验收，不保证登录及工作流可用，运行失败按原有机制报告。实际公开版本和 `@latest` 状态以 npm registry 为准，Apple Silicon 真机验收需单独进行。
 
-CLI `0.1.53` 随包安装已签名的 NGGAIGC 根 Skill `1.1.49`，保留豆包工作识别和 Intel Mac 安装放行；后续独立工作流仍经当前目录解析、在线准入和签名验签加载。
+CLI `0.1.55` 是兼容修复候选，实际公开版本与 `latest` 以 registry 为准。它通过官方签名 ZIP 的完整文件闭包识别现有根 Skill `1.1.49`／`1.1.50`；本地安装标记仅作提示。兼容时直接复用现有启动器，当前目录确实要求新版根时才安全升级；不会降级已验证的新版安装。旧目录仍使用根149时，保留已装150，并在不可发现为 active Skill 的私有缓存内验证、使用官方149兼容运行文件；目录切到新版后使用150，启动回执指向实际受信运行文件。保留豆包工作识别和 Intel Mac 安装放行的原边界。
+
+升级在原安装锁内先验证私有临时目录的文件类型、哈希和系统可表达的执行位，再原子替换并复验。失败时恢复已验证旧安装；进程中断后先按原事务读回恢复，不盲目开始新升级。Windows 不把 POSIX 执行位当作其系统权限证明，真机验收另记。
+
+旧的显式 `start-skill skill.<id> <version>` 只有在官方受签、精确绑定当前目录的有限迁移许可内，才可转到同一 Skill 的当前版本；结果分别返回 `requestedVersion` 与 `resolvedVersion`，在线准入使用真实新版本及哈希。未列版本、目录变化、停用或验签失败均停止。确需固定版本可加 `--exact-version`，此时绝不迁移到其他版本。无版本调用仍要求唯一 active 入口，不激活旧版本。
+
+此许可仅用于新启动。已经受理或结果未知的任务保留原请求和任务身份；`client` 将原参数交给已验证启动器，不为恢复任务重新准入、提交或付费。
 
 ## 统一安装入口（0.1.46 起）
 

package/dist/bundle.js

@@ -36,8 +36,13 @@ async function json(file) {
         throw new CliError("PACKAGE_VERIFICATION_FAILED");
     }
 }
-export async function verifyBundle(input) {
+export async function verifyBundle(input, expectedVersion = "1.1.50") {
     try {
+        for (const file of [input.archive, input.manifest, input.trust]) {
+            const info = await lstat(file);
+            if (!info.isFile() || info.isSymbolicLink())
+                throw new Error();
+        }
         const manifestValue = await json(input.manifest);
         const trustValue = await json(input.trust);
         const signature = record(manifestValue)
@@ -47,7 +52,7 @@ export async function verifyBundle(input) {
             !exactKeys(manifestValue, manifestKeys) ||
             manifestValue.schemaVersion !== "nggaigc-plugin-package/v1" ||
             manifestValue.artifactId !== "plugin.nggaigc" ||
-            manifestValue.version !== "1.1.49" ||
+            manifestValue.version !== expectedVersion ||
             manifestValue.artifactPath !==
                 `packages/plugins/nggaigc-plugin-${manifestValue.version}.zip` ||
             typeof manifestValue.sourceCommit !== "string" ||
@@ -120,6 +125,22 @@ export async function verifyBundle(input) {
         if (!record(pluginMetadata) ||
             pluginMetadata.version !== manifestValue.version)
             throw new Error();
+        const rootSource = contents.find((entry) => entry.name === "skills/nggaigc/references/source.json");
+        const rootBootstrap = contents.find((entry) => entry.name === "skills/nggaigc/scripts/bootstrap-public.json");
+        const sourceIdentity = rootSource
+            ? JSON.parse(rootSource.bytes.toString("utf8"))
+            : null;
+        const bootstrapIdentity = rootBootstrap
+            ? JSON.parse(rootBootstrap.bytes.toString("utf8"))
+            : null;
+        if (!record(sourceIdentity) ||
+            sourceIdentity.id !== "skill.nggaigc" ||
+            sourceIdentity.version !== manifestValue.version ||
+            sourceIdentity.clientProtocol !== 1 ||
+            !record(bootstrapIdentity) ||
+            bootstrapIdentity.version !== manifestValue.version ||
+            bootstrapIdentity.credentialTarget !== "NGGAIGC/Codex/v1")
+            throw new Error();
         const supported = contents.find((entry) => entry.name === "skills/nggaigc/scripts/supported-platforms.json");
         if (!supported)
             throw new Error();
@@ -139,6 +160,9 @@ export async function verifyBundle(input) {
             version: manifestValue.version,
             platforms: manifestValue.platforms,
             sha256: manifestValue.sha256,
+            executableFiles: contents
+                .filter((entry) => entry.executable)
+                .map((entry) => entry.name),
         };
     }
     catch (error) {
@@ -213,18 +237,39 @@ export async function verifyExtractedBundle(directory, expected) {
         throw new CliError("PACKAGE_VERIFICATION_FAILED");
     }
 }
-export async function verifyInstalledSkill(directory, bundleFiles) {
+export async function verifyInstalledSkill(directory, bundleFiles, executableFiles) {
     const prefix = "skills/nggaigc/";
     const expected = Object.fromEntries(Object.entries(bundleFiles)
         .filter(([name]) => name.startsWith(prefix))
         .map(([name, digest]) => [name.slice(prefix.length), digest]));
     try {
+        const rootFacts = await lstat(directory);
+        if (!rootFacts.isDirectory() || rootFacts.isSymbolicLink())
+            throw new Error();
         const actual = await entries(directory);
         const allowed = [...Object.keys(expected), ".nggaigc-install.json"].sort();
         if (JSON.stringify(actual) !== JSON.stringify(allowed))
             throw new Error();
+        const checkDirectories = async (parent, prefix = "") => {
+            for (const child of await readdir(parent, { withFileTypes: true }))
+                if (child.isDirectory()) {
+                    const relative = prefix + child.name + "/";
+                    if (!Object.keys(expected).some((name) => name.startsWith(relative)))
+                        throw new Error();
+                    await checkDirectories(path.join(parent, child.name), relative);
+                }
+        };
+        await checkDirectories(directory);
         for (const [name, digest] of Object.entries(expected)) {
-            const bytes = await readFile(path.resolve(directory, ...name.split("/")));
+            const absolute = path.resolve(directory, ...name.split("/"));
+            const facts = await lstat(absolute);
+            if (!facts.isFile() || facts.isSymbolicLink())
+                throw new Error();
+            if (executableFiles &&
+                process.platform !== "win32" &&
+                Boolean(facts.mode & 0o111) !== executableFiles.includes(prefix + name))
+                throw new Error();
+            const bytes = await readFile(absolute);
             if (createHash("sha256").update(bytes).digest("hex") !== digest)
                 throw new Error();
         }

package/dist/install.js

@@ -1,3 +1,4 @@
+import { withRootLock, installVerifiedRootLocked } from "./root-upgrade.js";
 import { createRequire } from "node:module";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import os from "node:os";
@@ -9,7 +10,7 @@ import { resolveSkillLocation, } from "./skill-location.js";
 function defaultBundle() {
     const vendor = fileURLToPath(new URL("../vendor/", import.meta.url));
     return {
-        archive: path.join(vendor, "nggaigc-plugin-1.1.49.zip"),
+        archive: path.join(vendor, "nggaigc-plugin-1.1.50.zip"),
         manifest: path.join(vendor, "manifest.json"),
         trust: path.join(vendor, "trusted-keys.json"),
     };
@@ -242,7 +243,9 @@ export async function runInstall(options = {}) {
         const installer = require(path.join(extracted, "installer", "install.cjs"));
         if (!installer || typeof installer.main !== "function")
             throw new CliError("INSTALLATION_FAILED");
-        const installation = await installSkill(installer, path.join(extracted, "skills", "nggaigc"), profile, skillsDirectory, bundle.version, bundle.files);
+        const installation = options.bundle
+            ? await installSkill(installer, path.join(extracted, "skills/nggaigc"), profile, skillsDirectory, bundle.version, bundle.files)
+            : await withRootLock(skillsDirectory, () => installVerifiedRootLocked(skillsDirectory, bundle));
         const installedScripts = path.join(skillsDirectory, "nggaigc", "scripts");
         if (options.connect === false)
             return { status: "installed", installation, version: bundle.version };

package/dist/main.js

@@ -27,6 +27,9 @@ const errorMessages = {
     LOCAL_SESSION_FAILED: "本地凭据会话未能完成；请先处理本地错误，不要重复网页授权。",
     LOCAL_SESSION_TIMEOUT: "本地凭据会话超时；请先检查当前本地进程，不要重复网页授权。",
     POWERSHELL_EXECUTION_POLICY_BLOCKED: "Windows 脚本执行受到系统或组织策略限制，设备连接未完成。安装器没有更改执行策略。",
+    ROOT_UPGRADE_RESTORED: "上次升级中断，已恢复并验证旧安装；本次未重新升级或提交任务。请确认恢复结果后再发起新的升级。",
+    ROOT_RECOVERY_REQUIRED: "本地升级状态无法安全恢复，已停止；请保留安装目录和事务记录并联系支持。",
+    INSTALL_BUSY: "同一安装目录正在使用或更新，请等待原操作完成。",
     INSTALLATION_FAILED: "本地安装未完成，请检查现有文件状态后重试。",
     SKILL_PAIR_UPGRADE_REQUIRED: "检测到无法安全配套迁移的本地 Seedream Skill，已停止升级。请保留旧 Skill 和任务文件并联系支持。",
     SKILL_PAIR_RECOVERY_REQUIRED: "检测到本地组合安装中断或目录变化，已停止自动操作。请保留相关目录和任务文件并联系支持。",
@@ -42,7 +45,7 @@ export async function main(args, runtime = {}) {
         output([
             "NGGAIGC CLI",
             "install [--agent codex|workbuddy|doubao-work|universal | --skills-dir <absolute-directory>] [--no-login]",
-            "start-skill skill.<id> [version] [--agent codex|workbuddy|doubao-work|universal | --skills-dir <absolute-directory>]",
+            "start-skill skill.<id> [version] [--exact-version] [--agent codex|workbuddy|doubao-work|universal | --skills-dir <absolute-directory>]",
             "client [--agent codex|workbuddy|doubao-work|universal | --skills-dir <absolute-directory>] -- <command> [arguments]",
             "Default: automatically detect Codex, WorkBuddy or Doubao Work. If unknown or conflicting, select one; non-interactive calls return selection-required (exit 3).",
             "Codex: existing CODEX_HOME is preserved, otherwise ~/.codex/skills. WorkBuddy: its runtime config directory/skills, otherwise ~/.workbuddy/skills; existing legacy ~/.codebuddy installs are reused. Doubao Work: ~/DoubaoWork/skills. Explicit legacy universal/custom targets remain supported.",
@@ -86,7 +89,9 @@ export async function main(args, runtime = {}) {
     }
     let parsed;
     try {
-        parsed = parseSkillLocation(args.slice(1));
+        parsed = parseSkillLocation(args
+            .slice(1)
+            .filter((value) => args[0] !== "start-skill" || value !== "--exact-version"));
     }
     catch {
         errorOutput(`${errorMessages.INVALID_INPUT}\n`);
@@ -94,10 +99,14 @@ export async function main(args, runtime = {}) {
     }
     const parameters = parsed.positional;
     if (args[0] === "start-skill" &&
-        (parameters.length === 1 || parameters.length === 2)) {
+        (parameters.length === 1 || parameters.length === 2) &&
+        (!args.includes("--exact-version") || parameters.length === 2)) {
         try {
             const location = await selectCommandLocation({ ...runtime.skillOptions, ...parsed.location }, runtime.agentSelection);
-            const result = await (runtime.startSkill ?? runSkillStartCommand)(parameters[0], parameters[1], location);
+            const result = await (runtime.startSkill ?? runSkillStartCommand)(parameters[0], parameters[1], {
+                ...location,
+                ...(args.includes("--exact-version") ? { exactVersion: true } : {}),
+            });
             output(`${JSON.stringify({ status: "ready", ...result })}\n`);
             return 0;
         }

package/dist/root-store.js

@@ -0,0 +1,172 @@
+/** Official root material is authenticity evidence; a local marker is only a hint. */
+import { createHash, randomBytes } from "node:crypto";
+import { lstat, mkdir, readFile, rename, copyFile, open, realpath, rm, } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { verifyBundle, verifyInstalledSkill, extractBundle, verifyExtractedBundle, } from "./bundle.js";
+import { stateDirectoryForSkills } from "./skill-location.js";
+import { CliError } from "./errors.js";
+export const rootVendor = fileURLToPath(new URL("../vendor/", import.meta.url));
+const versionPattern = /^\d+\.\d+\.\d+$/;
+export async function exists(file) {
+    try {
+        await lstat(file);
+        return true;
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return false;
+        throw e;
+    }
+}
+export async function realDirectory(directory) {
+    const info = await lstat(directory);
+    if (!info.isDirectory() || info.isSymbolicLink())
+        throw new CliError("INSTALL_PATH_UNSAFE");
+}
+export async function privateDirectory(directory) {
+    if (!(await exists(directory))) {
+        await privateDirectory(path.dirname(directory));
+        await mkdir(directory, { mode: 0o700 });
+    }
+    await realDirectory(directory);
+    if ((await realpath(directory)) !== path.resolve(directory))
+        throw new CliError("INSTALL_PATH_UNSAFE");
+}
+export async function syncDirectory(directory) {
+    if (process.platform === "win32")
+        return; // Windows has no portable fsync(directory).
+    const fd = await open(directory, "r");
+    try {
+        await fd.sync();
+    }
+    finally {
+        await fd.close();
+    }
+}
+export function proofDirectory(skills, version) {
+    if (!versionPattern.test(version))
+        throw new CliError("ROOT_UNAVAILABLE");
+    return path.join(stateDirectoryForSkills(skills), "root-proofs", version);
+}
+export function bundleFiles(directory, version, vendor = rootVendor) {
+    return {
+        archive: path.join(directory, `nggaigc-plugin-${version}.zip`),
+        manifest: path.join(directory, "manifest.json"),
+        trust: path.join(vendor, "trusted-keys.json"),
+    };
+}
+export async function knownBundle(skills, version, vendor = rootVendor) {
+    const cache = proofDirectory(skills, version);
+    // An existing corrupt cache is rejected; never silently replace its evidence.
+    if (await exists(cache)) {
+        await realDirectory(cache);
+        if ((await realpath(cache)) !== path.resolve(cache))
+            throw new CliError("INSTALL_PATH_UNSAFE");
+        return verifyBundle(bundleFiles(cache, version, vendor), version);
+    }
+    return verifyBundle(bundleFiles(version === "1.1.50" ? vendor : path.join(vendor, "roots", version), version, vendor), version);
+}
+export async function saveProof(skills, bundle, vendor = rootVendor) {
+    const dest = proofDirectory(skills, bundle.version);
+    if (await exists(dest)) {
+        const prior = await knownBundle(skills, bundle.version, vendor);
+        if (prior.sha256 !== bundle.sha256)
+            throw new CliError("PACKAGE_VERIFICATION_FAILED");
+        return;
+    }
+    const parent = path.dirname(dest);
+    await privateDirectory(parent);
+    const temp = path.join(parent, `.proof-${bundle.version}-${randomBytes(16).toString("hex")}`);
+    await mkdir(temp, { mode: 0o700 });
+    await copyFile(bundle.archive, path.join(temp, `nggaigc-plugin-${bundle.version}.zip`), 1);
+    // The archive-adjacent manifest is already cryptographically validated above.
+    await copyFile(path.join(path.dirname(bundle.archive), "manifest.json"), path.join(temp, "manifest.json"), 1);
+    const verified = await verifyBundle(bundleFiles(temp, bundle.version, vendor), bundle.version);
+    if (verified.sha256 !== bundle.sha256)
+        throw new CliError("PACKAGE_VERIFICATION_FAILED");
+    for (const file of [
+        path.join(temp, `nggaigc-plugin-${bundle.version}.zip`),
+        path.join(temp, "manifest.json"),
+    ]) {
+        const fd = await open(file, "r");
+        try {
+            await fd.sync();
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    await syncDirectory(temp);
+    await rename(temp, dest);
+    await syncDirectory(parent);
+}
+export async function trustedRoot(skills, vendor = rootVendor) {
+    const root = path.join(skills, "nggaigc");
+    await realDirectory(root);
+    let version;
+    try {
+        version = JSON.parse(await readFile(path.join(root, "references/source.json"), "utf8")).version;
+    }
+    catch {
+        throw new CliError("ROOT_UNAVAILABLE");
+    }
+    if (typeof version !== "string" || !versionPattern.test(version))
+        throw new CliError("ROOT_UNAVAILABLE");
+    const bundle = await knownBundle(skills, version, vendor);
+    await verifyInstalledSkill(root, bundle.files, bundle.executableFiles);
+    // This binds source.json and protocol to the signed payload, regardless of marker.version.
+    return { version: bundle.version, bundle, directory: root };
+}
+/** Creation holds the install lock; verified immutable reuse is read-only. */
+export async function trustedRuntime(skills, version, vendor = rootVendor, create = true) {
+    if (!["1.1.49", "1.1.50"].includes(version))
+        throw new CliError("ROOT_UNAVAILABLE");
+    await trustedRoot(skills, vendor);
+    // Delegates always use an immutable runtime, including the currently installed version.
+    const bundle = await knownBundle(skills, version, vendor);
+    const parent = path.join(stateDirectoryForSkills(skills), "root-runtimes");
+    const directory = path.join(parent, version);
+    if (await exists(directory)) {
+        if ((await realpath(directory)) !== path.resolve(directory))
+            throw new CliError("INSTALL_PATH_UNSAFE");
+        await verifyInstalledSkill(directory, bundle.files, bundle.executableFiles);
+        return { version, bundle, directory };
+    }
+    if (!create)
+        throw new CliError("ROOT_RUNTIME_UNAVAILABLE");
+    await privateDirectory(parent);
+    const temporary = path.join(parent, ".runtime-" + randomBytes(16).toString("hex"));
+    try {
+        await extractBundle(bundle.archive, temporary, bundle.sha256);
+        await verifyExtractedBundle(temporary, bundle.files);
+        const root = path.join(temporary, "skills/nggaigc");
+        const marker = await open(path.join(root, ".nggaigc-install.json"), "wx", 0o600);
+        try {
+            await marker.writeFile(JSON.stringify({
+                schemaVersion: "nggaigc-local-install/v1",
+                version,
+                installedAt: new Date().toISOString(),
+            }) + "\n");
+            await marker.sync();
+        }
+        finally {
+            await marker.close();
+        }
+        await verifyInstalledSkill(root, bundle.files, bundle.executableFiles);
+        if (await exists(directory))
+            throw new CliError("ROOT_RECOVERY_REQUIRED");
+        await rename(root, directory);
+        await syncDirectory(parent);
+        await verifyInstalledSkill(directory, bundle.files, bundle.executableFiles);
+        return { version, bundle, directory };
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+export async function bytesHash(file) {
+    return createHash("sha256")
+        .update(await readFile(file))
+        .digest("hex");
+}