@yijiancaotang/cli 0.0.0-stage → 1.0.0

package/dist/local-commands.js

@@ -0,0 +1,136 @@
+import { shellWord } from "./agent-identity.js";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { authLogin } from "./auth.js";
+import { doctor } from "./doctor.js";
+import { CliError, asRecord } from "./errors.js";
+import { inspectLocalInstallation, installLocal } from "./installation.js";
+import { isPlatformId, platformSupported } from "./local-types.js";
+import { detectPlatforms } from "./platforms.js";
+import { loadSkillAssets } from "./skill-assets.js";
+import { defaultConnectionNames, inspectAccountState, onboardingMessage } from "./onboarding.js";
+import { setupFailureMessage } from "./connection-copy.js";
+const root = () => fileURLToPath(new URL("../", import.meta.url));
+const invalid = () => new CliError("invalid_arguments", "命令或参数无效。", "运行 --help；平台支持claude-code、codex、openclaw，以及仅macOS支持的kimi-code、kimi-work和workbuddy。");
+export function selectedPlatforms(value, operatingSystem = process.platform) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw invalid();
+    const values = value.split(",").map(item => item.trim());
+    if (!values.length || new Set(values).size !== values.length || values.some(item => !isPlatformId(item)))
+        throw invalid();
+    if (values.some(id => !platformSupported(id, operatingSystem)))
+        throw new CliError("platform_unsupported", "所选新增平台尚不支持当前系统。", "kimi-code、kimi-work和workbuddy仅支持macOS本机安装；不要套用或猜测其它系统的技能目录。");
+    return values;
+}
+export async function localVersion(packageRoot = root()) {
+    const failed = () => new CliError("version_unavailable", "无法核对当前命令行版本。", "请使用完整的一间草堂命令行构建；不要运行不明升级脚本。", 7);
+    try {
+        const file = await open(join(packageRoot, "package.json"), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        try {
+            const info = await file.stat();
+            if (!info.isFile() || info.nlink !== 1 || info.size < 1 || info.size > 32768)
+                throw failed();
+            const bytes = Buffer.alloc(32769), { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
+            if (bytesRead !== info.size || bytesRead > 32768)
+                throw failed();
+            const data = asRecord(JSON.parse(bytes.subarray(0, bytesRead).toString("utf8")));
+            if (data?.name !== "@yijiancaotang/cli" || (data.private !== true && asRecord(data.publishConfig)?.access !== "public") || typeof data.version !== "string" || !/^\d+\.\d+\.\d+(?:-[a-z0-9.-]+)?$/i.test(data.version))
+                throw failed();
+            return { status: 200, body: { brand: "一间草堂", name: data.name, version: data.version, node_version: process.versions.node, release_status: "released", update_policy: "manual" } };
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch {
+        throw failed();
+    }
+}
+export function manualUpdateInstructions() {
+    return { status: 200, body: { operation: "update", update_policy: "manual", next_action: "运行 npx @yijiancaotang/cli@latest setup --agent <你的名字> 更新到最新版。" } };
+}
+async function targetsFor(ctx, ids, setup) {
+    if (ctx.agent) {
+        if (ids && ids.length !== 1)
+            throw new CliError("invalid_arguments", "每次接入只给一个 AI 平台安装技能。", "请带自己的 --agent 名字，一次只选一个 --platform；其它 AI 分别接入。");
+        ids = ids ?? (ctx.agent.platform ? [ctx.agent.platform] : []);
+        if (!ids.length)
+            return [];
+    }
+    const all = await detectPlatforms({ homeDir: ctx.homeDir, env: ctx.env, applicationRoots: ctx.applicationRoots, operatingSystem: ctx.operatingSystem, platformIds: ids });
+    return ids ? all.filter(target => ids.includes(target.id)) : setup ? all.filter(target => target.detected) : all;
+}
+export async function localDoctor(ctx, flags, authFailure) {
+    return doctor({
+        auth: ctx.auth, authFailure, agent: ctx.agent,
+        inspectLocal: async () => {
+            const assets = await loadSkillAssets(ctx.packageRoot ?? root());
+            return inspectLocalInstallation({ ...ctx, agentName: ctx.agent?.key, assets, targets: await targetsFor(ctx, selectedPlatforms(flags.platform, ctx.operatingSystem), false) });
+        },
+    });
+}
+export async function localSetup(ctx, flags) {
+    const assets = await loadSkillAssets(ctx.packageRoot ?? root()), targets = await targetsFor(ctx, selectedPlatforms(flags.platform, ctx.operatingSystem), true);
+    const local = { ...ctx, agentName: ctx.agent?.key, assets, targets };
+    const installed = await installLocal(local);
+    const newEntries = installed.newlyInstalledPlatforms;
+    let authFailure;
+    let authorizationAttempted = false;
+    // Observe the actual start request after authLogin's credential/abort checks.
+    // Validation and doctor requests do not constitute a new authorization attempt.
+    const observedAuth = {
+        ...ctx.auth,
+        api: {
+            baseUrl: ctx.auth.api.baseUrl,
+            request(path, options) {
+                if (path === "/api/v1/agent/device-auth/start" && options?.method === "POST")
+                    authorizationAttempted = true;
+                return ctx.auth.api.request(path, options);
+            },
+            upload: (url, headers, bytes) => ctx.auth.api.upload(url, headers, bytes),
+            outputSecrets: () => ctx.auth.api.outputSecrets?.() ?? [],
+        },
+    };
+    let newAuthorizationOwner;
+    let loginIdentity;
+    const names = defaultConnectionNames(targets.map(target => target.id), ctx.computerName, ctx.agent?.name);
+    try {
+        const login = await authLogin(observedAuth, { device_name: flags["device-name"] ?? names.deviceName, client_name: flags["client-name"] ?? names.clientName, noOpen: flags["no-open"] === true });
+        const who = asRecord(login.body);
+        if (typeof who?.user_id === "string" && typeof who.token_id === "string" && (who.kind === "manual" || who.kind === "device") && (who.scope === "read_only" || who.scope === "read_write")) {
+            loginIdentity = { userId: who.user_id, tokenId: who.token_id, kind: who.kind, scope: who.scope };
+        }
+        if (who?.new_authorization_confirmed === true && typeof who.user_id === "string")
+            newAuthorizationOwner = who.user_id;
+    }
+    catch (error) {
+        authFailure = error instanceof CliError ? error : new CliError("authorization_delivery_unknown", "无法确认授权操作的结果。", "先在网页核对并吊销未保存的设备，不要自动重新签发。", 6);
+    }
+    let checkedIdentity;
+    const report = await doctor({ auth: ctx.auth, authFailure, agent: ctx.agent, inspectLocal: () => inspectLocalInstallation(local), onIdentity: who => { checkedIdentity = who; } });
+    const body = asRecord(report.result.body);
+    if (!body)
+        throw new CliError("diagnostic_unavailable", "本地安装已执行，但无法确认最终诊断。", "先运行doctor只读核对，不要直接重新授权。", 7);
+    const sameConnection = loginIdentity && checkedIdentity && ["userId", "tokenId", "kind", "scope"].every(key => loginIdentity[key] === checkedIdentity[key]);
+    const identityChanged = body.ready === true && !sameConnection;
+    if (identityChanged) {
+        const issue = { code: "authorization_identity_changed", message: "接入前后的连接核对不一致，尚不能确认接好。", next_action: "请先在网页 Agent 管理和本机 auth status 核对连接；不自动切换账号、重新授权或写入。" };
+        body.ready = false;
+        body.auth = { status: "unknown" };
+        body.issues = [...(Array.isArray(body.issues) ? body.issues : []), issue];
+        body.next_actions = [...(Array.isArray(body.next_actions) ? body.next_actions : []), issue.next_action];
+        report.exitCode = 6;
+    }
+    const confirmed = authorizationAttempted && newAuthorizationOwner !== undefined && report.exitCode === 0 && body.ready === true;
+    const accountState = newEntries.length && body.ready === true && checkedIdentity ? await inspectAccountState(ctx.auth, checkedIdentity.userId) : "unknown";
+    const greeting = body.ready === true && checkedIdentity ? onboardingMessage(newEntries, accountState, checkedIdentity.scope)
+        : { account_state: "unknown", onboarding: { action: "none", newly_connected_platforms: [] }, user_message: setupFailureMessage(identityChanged ? "authorization_identity_changed" : authFailure?.code) };
+    return { exitCode: report.exitCode, result: { status: 200, body: { ...body, operation: "setup", local_installation: { changed: installed.changed, bundle_sha: installed.bundleSha }, authorization_attempted: authorizationAttempted,
+                new_authorization_confirmed: confirmed, ...(confirmed ? { new_authorization_owner_id: newAuthorizationOwner } : {}), ...greeting,
+                ...(ctx.agent && !targets.length ? { generic_usage: { message: "这个 AI 没有专用技能安装位置；请按下列命令使用自己的连接。", commands: ["doctor", "context --start", "projects", "knowledge", "search", "auth status"].map(command => `caotang --agent ${shellWord(ctx.agent.name)} ${command}`) } } : {}),
+                ...(body.ready === true ? { next_conversation: "请开新对话说‘开工了’。" } : {}) } } };
+}

package/dist/local-lock.js

@@ -0,0 +1,245 @@
+import { constants, openSync, closeSync, lstatSync, fstatSync, readSync, writeSync, fsyncSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { basename, dirname } from "node:path";
+import { asRecord } from "./errors.js";
+const same = (a, b) => a.dev === b.dev && a.ino === b.ino;
+const chunkSize = 65536;
+const recordLimit = 256;
+export function deletionDenied(error) {
+    return ["EPERM", "EACCES", "EROFS"].includes(String(asRecord(error)?.code))
+        || (error instanceof Error && error.message.includes("[safe-delete] broker denied delete"));
+}
+function dead(pid) {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return asRecord(error)?.code === "ESRCH";
+    }
+}
+// Local regular files only: a single O_APPEND write orders each ticket. The first
+// unreleased live/unknown ticket owns the lock. Never replace or truncate this
+// inode: delayed contenders must see the same history, even after a crash.
+// File count is constant; journal bytes grow with use. Do not mix with the old
+// rename/compaction protocol or put this journal on a network filesystem.
+export function acquireLocalLock(path, parent, failures) {
+    const { busy, unsafe } = failures, name = basename(path);
+    const ticket = { op: "acquire", pid: process.pid, id: randomUUID() };
+    let fd = -1, identity, appended = false;
+    const check = (info) => {
+        if (!info.isFile() || typeof process.getuid !== "function" || info.uid !== process.getuid()
+            || (info.nlink !== 1 && info.nlink !== 0) || (info.mode & 0o7777) !== 0o600
+            || !Number.isSafeInteger(info.size) || info.size < 0)
+            throw unsafe();
+        if (info.nlink === 0)
+            throw busy();
+    };
+    const pinned = (action) => {
+        const original = process.cwd();
+        try {
+            process.chdir(parent.path);
+            const info = lstatSync(".");
+            if (dirname(path) !== parent.path || !info.isDirectory() || !same(info, parent.identity)
+                || info.uid !== parent.identity.uid || (info.mode & 0o7777) !== 0o700)
+                throw unsafe();
+            return action();
+        }
+        finally {
+            process.chdir(original);
+        }
+    };
+    const current = () => {
+        const opened = fstatSync(fd);
+        check(opened);
+        let named;
+        try {
+            named = lstatSync(name);
+        }
+        catch (error) {
+            if (asRecord(error)?.code === "ENOENT")
+                throw busy();
+            throw error;
+        }
+        check(named);
+        if (!same(opened, identity) || !same(named, identity))
+            throw busy();
+    };
+    const decode = (line) => {
+        if (!line.length || Buffer.byteLength(line) > recordLimit)
+            throw busy();
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            throw busy();
+        }
+        if (!entry || Object.keys(entry).sort().join(",") !== "id,op,pid"
+            || !["acquire", "release"].includes(entry.op) || !Number.isSafeInteger(entry.pid)
+            || entry.pid <= 0 || entry.pid > 2147483647 || typeof entry.id !== "string"
+            || !/^[a-f0-9-]{36}$/.test(entry.id))
+            throw busy();
+        return entry;
+    };
+    const legacyMarkers = () => {
+        for (const legacy of [...Array.from({ length: 16 }, (_, index) => `${name}.admission-${index}`), `${name}.admission-released`, `${name}.next`]) {
+            let before;
+            try {
+                before = lstatSync(legacy);
+            }
+            catch (error) {
+                if (asRecord(error)?.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            check(before);
+            if (before.size > recordLimit)
+                throw unsafe();
+            const reader = openSync(legacy, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            try {
+                const opened = fstatSync(reader);
+                check(opened);
+                if (opened.size > recordLimit)
+                    throw unsafe();
+                if (!same(opened, before))
+                    throw busy();
+                const bytes = Buffer.alloc(recordLimit + 1);
+                let count = 0;
+                while (count < bytes.length) {
+                    const read = readSync(reader, bytes, count, bytes.length - count, count);
+                    if (!read)
+                        break;
+                    count += read;
+                }
+                const after = fstatSync(reader);
+                check(after);
+                let named;
+                try {
+                    named = lstatSync(legacy);
+                }
+                catch (error) {
+                    if (asRecord(error)?.code === "ENOENT")
+                        throw busy();
+                    throw error;
+                }
+                check(named);
+                if (count > recordLimit || after.size > recordLimit || named.size > recordLimit)
+                    throw unsafe();
+                if (!same(after, opened) || !same(after, named) || before.size !== after.size
+                    || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || count !== after.size)
+                    throw busy();
+                if (!count || bytes[count - 1] !== 10)
+                    throw busy();
+                const entry = decode(bytes.subarray(0, count - 1).toString("utf8"));
+                if (entry.op !== "release" && !dead(entry.pid))
+                    throw busy();
+            }
+            finally {
+                closeSync(reader);
+            }
+        }
+    };
+    const pending = () => {
+        current();
+        const before = fstatSync(fd), buffer = Buffer.alloc(chunkSize);
+        const active = new Map(), seen = new Set();
+        let offset = 0, remainder = "";
+        while (offset < before.size) {
+            const count = readSync(fd, buffer, 0, Math.min(buffer.length, before.size - offset), offset);
+            if (!count)
+                throw busy();
+            offset += count;
+            const lines = (remainder + buffer.subarray(0, count).toString("utf8")).split("\n");
+            remainder = lines.pop();
+            if (Buffer.byteLength(remainder) > recordLimit)
+                throw busy();
+            for (const line of lines) {
+                const entry = decode(line);
+                if (entry.op === "acquire") {
+                    if (seen.has(entry.id))
+                        throw busy();
+                    seen.add(entry.id);
+                    active.set(entry.id, entry);
+                }
+                else {
+                    if (active.get(entry.id)?.pid !== entry.pid)
+                        throw busy();
+                    active.delete(entry.id);
+                }
+            }
+        }
+        current();
+        const after = fstatSync(fd);
+        if (remainder || after.size < before.size
+            || (after.size === before.size && (after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)))
+            throw busy();
+        return [...active.values()].filter(entry => !dead(entry.pid));
+    };
+    const append = (entry) => {
+        current();
+        const bytes = Buffer.from(JSON.stringify(entry) + "\n");
+        if (bytes.length > recordLimit || writeSync(fd, bytes) !== bytes.length)
+            throw busy();
+        fsyncSync(fd);
+        current();
+    };
+    try {
+        pinned(() => {
+            let created = false;
+            try {
+                fd = openSync(name, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_APPEND | constants.O_NOFOLLOW, 0o600);
+                created = true;
+            }
+            catch (error) {
+                if (asRecord(error)?.code !== "EEXIST")
+                    throw error;
+                const before = lstatSync(name);
+                if (before.isDirectory())
+                    throw busy();
+                check(before);
+                fd = openSync(name, constants.O_RDWR | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+                check(fstatSync(fd));
+                if (!same(before, fstatSync(fd)))
+                    throw busy();
+            }
+            identity = fstatSync(fd);
+            current();
+            legacyMarkers();
+            if (created ? identity.size !== 0 : pending().length > 0)
+                throw busy();
+            append(ticket);
+            appended = true;
+            if (pending()[0]?.id !== ticket.id)
+                throw busy();
+            current();
+        });
+    }
+    catch (error) {
+        if (appended) {
+            try {
+                pinned(() => append({ ...ticket, op: "release" }));
+            }
+            catch { /* Keep uncertain ownership closed. */ }
+        }
+        if (fd !== -1)
+            closeSync(fd);
+        throw error;
+    }
+    let released = false;
+    return () => {
+        if (released)
+            throw busy();
+        released = true;
+        try {
+            pinned(() => {
+                if (pending()[0]?.id !== ticket.id)
+                    throw busy();
+                append({ ...ticket, op: "release" });
+            });
+        }
+        finally {
+            closeSync(fd);
+        }
+    };
+}

package/dist/local-types.js

@@ -0,0 +1,3 @@
+export const PLATFORM_IDS = ["claude-code", "codex", "openclaw", "kimi-code", "kimi-work", "workbuddy"];
+export const isPlatformId = (value) => PLATFORM_IDS.some(id => id === value);
+export const platformSupported = (id, operatingSystem = process.platform) => operatingSystem === "darwin" || (id !== "kimi-code" && id !== "kimi-work" && id !== "workbuddy");

package/dist/missing-sections.js

@@ -0,0 +1,71 @@
+import { asRecord } from "./errors.js";
+const knownSections = {
+    daily_progress: { capability: "read_projects", label: "日汇总中的进展" },
+    daily_knowledge: { capability: "read_knowledge", label: "日汇总中的知识新增与长势" },
+    search_projects: { capability: "read_projects", label: "搜索中的项目与进展" },
+    search_knowledge: { capability: "read_knowledge", label: "搜索中的知识" },
+    workbench: { capability: "read_workbench", label: "工作台" },
+    briefing: { capability: "read_notifications", label: "简报" },
+    knowledge: { capability: "read_knowledge", label: "知识内容" },
+    recent_knowledge: { capability: "read_knowledge", label: "最近知识" },
+    draft_knowledge: { capability: "read_drafts", label: "草稿知识" },
+    recent_projects: { capability: "read_projects", label: "最近项目" },
+    project_updates: { capability: "read_projects", label: "项目进展" },
+    draft_projects: { capability: "read_projects", label: "项目草稿" },
+    project_drafts: { capability: "read_drafts", label: "项目草稿" },
+    project_draft_checkins: { capability: "read_drafts", label: "项目草稿关联的手写进展" },
+    project_evidence: { capability: "read_projects", label: "项目证据文字" },
+    draft_project_evidence: { capability: "read_drafts", label: "项目草稿证据文字" },
+    knowledge_applied_updates: { capability: "read_knowledge", label: "知识应用进展正文" },
+    draft_knowledge_applied_updates: { capability: "read_drafts", label: "可能含草稿知识的应用进展正文" },
+    knowledge_result: { capability: "read_knowledge", label: "知识写入结果" },
+    project_result: { capability: "read_projects", label: "项目写入结果" },
+    draft_knowledge_result: { capability: "read_drafts", label: "知识草稿写入结果" },
+    draft_project_result: { capability: "read_drafts", label: "项目草稿写入结果" },
+};
+const capabilityLabels = {
+    read_workbench: "读取工作台", read_notifications: "读取通知", read_knowledge: "读取知识",
+    read_drafts: "读取草稿", read_projects: "读取项目",
+};
+function reasonLabel(reason) {
+    if (reason === "capability_disabled")
+        return "开关未开启";
+    if (reason === "token_scope_insufficient")
+        return "设备权限范围不足";
+    if (["permission_denied", "forbidden", "access_denied", "authorization_unavailable", "moderation_blocked"].includes(reason))
+        return "权限不足或访问受限";
+    return "具体原因尚未核实";
+}
+/** Read only protocol locations; never traverse cards, titles, summaries or payloads. */
+export function formatMissingSections(value) {
+    const body = asRecord(value);
+    if (!body)
+        return "";
+    const sources = [
+        { prefix: "", value: body },
+        { prefix: "工作台中的", value: asRecord(body.workbench) },
+        { prefix: "简报中的", value: asRecord(body.briefing) },
+    ];
+    const lines = [], seen = new Set();
+    for (const source of sources) {
+        const rows = source.value?.missing_sections;
+        if (!Array.isArray(rows))
+            continue;
+        // Bound invalid/repeated server metadata to the fixed protocol section set.
+        for (const row of rows.slice(0, 64)) {
+            const item = asRecord(row);
+            if (!item || typeof item.section !== "string" || !Object.hasOwn(knownSections, item.section)
+                || typeof item.reason !== "string")
+                continue;
+            const section = knownSections[item.section];
+            if (item.required_capability !== section.capability)
+                continue;
+            const key = source.prefix + item.section;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            lines.push(`- ${source.prefix}${section.label}：未读取，${reasonLabel(item.reason)}。请在网页检查“${capabilityLabels[section.capability]}”开关及设备权限。`);
+        }
+    }
+    return lines.length ? `部分内容未读取，这不代表没有资料：\n${lines.join("\n")}\n` : "";
+}

package/dist/onboarding.js

@@ -0,0 +1,48 @@
+import { hostname } from "node:os";
+import { resolveCredential } from "./auth.js";
+import { verifiedHabit } from "./habit-wire.js";
+import { connectionCopy } from "./connection-copy.js";
+export const platformNames = {
+    "claude-code": "Claude Code", codex: "Codex", openclaw: "OpenClaw",
+    "kimi-code": "Kimi Code", "kimi-work": "Kimi 工作模式", workbuddy: "WorkBuddy",
+};
+export function defaultConnectionNames(platforms, computerName = hostname(), agentName) {
+    if (agentName !== undefined)
+        return { clientName: agentName, deviceName: agentName };
+    const clientName = agentName ?? (platforms.length === 1 ? platformNames[platforms[0]] : "caotang");
+    const name = computerName.trim().replace(/\.local$/i, "");
+    // Unknown/random/container hosts are not reliable names for a person's computer.
+    const reliable = [...name].length <= 48 && /[a-z\p{Script=Han}]/iu.test(name)
+        && !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\/\\@]/u.test(name)
+        && !/^(?:[a-f\d-]{12,}|ip-\d|localhost$|runner|docker|container|sandbox|codespace|pod-)/i.test(name);
+    return { clientName, deviceName: reliable ? `${clientName} · ${name}` : clientName };
+}
+export async function inspectAccountState(auth, owner) {
+    if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(owner))
+        return "unknown";
+    try {
+        const credential = await resolveCredential(auth);
+        const result = await auth.api.request("/api/v1/agent/m1/habit/start", { method: "GET", token: credential.token, signal: auth.signal });
+        if (result.status !== 200)
+            return "unknown";
+        const body = verifiedHabit(result.body, true);
+        if (body?.owner_id !== owner)
+            return "unknown";
+        return body.account_empty === true ? "empty" : body.account_empty === false ? "has_content" : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function onboardingMessage(newlyConnected, state, scope) {
+    const action = newlyConnected.length === 0 ? "none" : state === "empty" ? "introduce" : "ask_once";
+    const message = action === "none" ? connectionCopy.repeated
+        : scope === "read_only" ? action === "ask_once" ? connectionCopy.read_only_existing : connectionCopy.read_only
+            : action === "introduce" ? connectionCopy.first_empty : connectionCopy.first_existing;
+    return {
+        account_state: state,
+        onboarding: { action, newly_connected_platforms: newlyConnected },
+        user_message: message,
+        skill_activation: newlyConnected.map(platform => ({ platform, message: platform === "codex" || platform === "claude-code" ? "新对话可以加载本次安装的技能。" : "如果看不到技能，请开新对话或重启应用；本次没有自动重启。" })),
+    };
+}

package/dist/output.js

@@ -0,0 +1,52 @@
+import { asRecord, CliError } from "./errors.js";
+import { formatMissingSections } from "./missing-sections.js";
+import { projectedWriteCompleted } from "./write-permissions.js";
+import { formatSearchWarnings } from "./query-search.js";
+import { formatDailyNotice } from "./query-daily.js";
+import { createDraftNotice } from "./create-bundle.js";
+const sensitiveKey = /^(token|access_token|token_value|token_hash|device_code|upload_nonce|upload_url|required_headers|authorization|cookie|set-cookie|x-opc-upload-token)$/i;
+export function redact(value, secrets, depth = 0) {
+    if (depth > 128)
+        throw new CliError("invalid_response", "响应层级超出可安全输出范围。", "请缩小读取范围后核对。", 7);
+    if (typeof value === "string") {
+        let safe = value;
+        for (const secret of secrets)
+            if (secret.length >= 8)
+                safe = safe.split(secret).join("[REDACTED]");
+        return safe;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redact(item, secrets, depth + 1));
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).filter(([key]) => !sensitiveKey.test(key) && !secrets.some((secret) => secret.length >= 8 && key.includes(secret))).map(([key, item]) => [key, redact(item, secrets, depth + 1)]));
+    return value;
+}
+export function renderResult(result, human, secrets) {
+    const data = redact({ http_status: result.status, data: result.body, ...(result.operationAudit?.length ? { operation_audit: result.operationAudit } : {}) }, secrets);
+    const missing = human ? formatMissingSections(asRecord(data)?.data) : "";
+    const writeNotice = human && projectedWriteCompleted(result) ? "写入已完成；以下内容因读取权限未开启而没有返回，不是写入失败。\n" : "";
+    const body = asRecord(result.body);
+    const unknownWrite = explicitUnknownWrite(result);
+    const pendingNotice = human && result.status === 202
+        ? body?.original_receipt === true && body.idempotency_replayed === true ? "这是原回执，当前状态请到网页核对；本次未重新执行。\n" : unknownWrite ? "写入结果暂无法确认，请先在网页核对；不要自动重试。\n" : "请求仍待处理，请在网页核对。\n" : "";
+    const warningNotice = human ? formatSearchWarnings(asRecord(data)?.data) : "";
+    const dailyNotice = human ? formatDailyNotice(asRecord(data)?.data) : "";
+    const draftNotice = human && [200, 201].includes(result.status) ? createDraftNotice(asRecord(data)?.data) : "";
+    const replayNotice = human && [200, 201].includes(result.status) && body?.idempotency_replayed === true ? "这是已有创建请求的回放结果，本次没有重新创建。\n" : "";
+    return `${pendingNotice}${replayNotice}${writeNotice}${missing}${warningNotice}${dailyNotice}${draftNotice}${JSON.stringify(data, null, human ? 2 : undefined)}\n`;
+}
+// Only coherent transport/receipt evidence classifies the submitted write;
+// neither a drafted audit log nor a moderation-pending 202 means unknown.
+export function explicitUnknownWrite(result) {
+    const b = asRecord(result.body);
+    if (result.status !== 202 || !b)
+        return false;
+    return (b.code === undefined || b.code === "write_outcome_unknown")
+        && (b.error === undefined || b.error === "write_outcome_unknown")
+        && (b.write_status === undefined || b.write_status === "unknown")
+        && (b.code === "write_outcome_unknown" || b.error === "write_outcome_unknown" || b.write_status === "unknown");
+}
+export function renderError(error, human, secrets) {
+    const data = redact(error.toJSON(), secrets);
+    return `${human ? formatMissingSections(data) : ""}${JSON.stringify(data, null, human ? 2 : undefined)}\n`;
+}

package/dist/pending-requests.js

@@ -0,0 +1,45 @@
+import { isDeepStrictEqual } from "node:util";
+import { asRecord, CliError } from "./errors.js";
+import { expectCapabilityResult } from "./capability-result.js";
+import { validateInput } from "./input-validation.js";
+const uuid = (value) => typeof value === "string" && /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(value);
+const invalid = () => new CliError("invalid_arguments", "待确认申请参数无效。", "使用 --input 提供目标类型knowledge_card或project、目标UUID和reason；改可见性另填public或private，不提供确认、权限或幂等参数。");
+/** Mirrors the approved MCP pending envelope without importing MCP runtime dependencies. */
+export function createPendingRequest(operation, value) {
+    if (!["delete", "archive", "visibility"].includes(operation))
+        throw invalid();
+    const input = validateInput(value, {
+        fields: {
+            target_type: value => typeof value === "string" && ["knowledge_card", "project"].includes(value),
+            target_id: uuid,
+            reason: value => typeof value === "string" && value.trim().length > 0 && [...value.trim()].length <= 1000,
+            expires_in_hours: value => Number.isInteger(value) && Number(value) >= 1 && Number(value) <= 168,
+            ...(operation === "visibility" ? { visibility: (value) => typeof value === "string" && ["public", "private"].includes(value) } : {}),
+        },
+        required: ["target_type", "target_id", "reason", ...(operation === "visibility" ? ["visibility"] : [])],
+    }, ["request", operation]);
+    const visibility = operation === "visibility";
+    const label = input.target_type === "project" ? "项目" : "知识卡";
+    const shortID = input.target_id.slice(0, 8);
+    const summary = visibility ? `待确认可见性变更：${label} (${shortID}) -> ${input.visibility}` : `待确认${operation === "archive" ? "归档" : "删除"}：${label} (${shortID})`;
+    return {
+        capability: "delete_or_archive",
+        tool_name: visibility ? "request_public_visibility_change" : "request_delete_or_archive",
+        action_type: visibility ? "public_visibility_change" : "delete_or_archive",
+        source_type: "manual", source_id: input.target_id, summary,
+        payload_json: { target_type: input.target_type, target_id: input.target_id, ...(visibility ? { visibility: input.visibility } : { operation }), reason: input.reason },
+        ...(input.expires_in_hours === undefined ? {} : { expires_in_hours: input.expires_in_hours }),
+    };
+}
+export async function requestPendingAction(operation, input, ctx) {
+    const request = createPendingRequest(operation, input);
+    const result = expectCapabilityResult(await ctx.api.request("/api/v1/agent/pending-actions", { method: "POST", token: ctx.token, body: request }), "delete_or_archive", "write");
+    const body = asRecord(result.body), pending = asRecord(body?.pending_action), log = asRecord(body?.action_log);
+    if (result.status !== 202 || body?.requires_confirmation !== true || !uuid(body.pending_action_id)
+        || pending?.id !== body.pending_action_id || pending.status !== "pending" || pending.action_type !== request.action_type
+        || !isDeepStrictEqual(pending.payload_json, request.payload_json)
+        || log?.action_status !== "drafted" || log.tool_name !== request.tool_name) {
+        throw new CliError("pending_result_unknown", "无法核实待确认申请的创建结果。", "先到网页核对待确认记录；不要自动重试或重复发起申请。", 6, { http_status: result.status });
+    }
+    return { ...result, body: { ...body, message: "申请已创建，等你在网页确认。" } };
+}