@yijiancaotang/cli 0.0.0-stage → 1.1.0

package/dist/local-records.js

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import { join, relative, resolve, sep, isAbsolute } from "node:path";
+import { asRecord, CliError } from "./errors.js";
+import { OwnedTree } from "./installation.js";
+import { isPlatformId } from "./local-types.js";
+import { bindSkillAgent, completeSkillInventory } from "./skill-assets.js";
+const unsafe = () => new CliError("local_record_unsafe", "本机连接说明或技能安装记录未通过核对。", "保留现有连接和文件，先由本人核对本机记录；不要重新批准、覆盖或删除。", 7);
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const keys = (value, expected) => Object.keys(value).sort().join(",") === [...expected].sort().join(",");
+const id = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value);
+const hash = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+const label = (value) => typeof value === "string" && value.trim() === value && [...value].length >= 1 && [...value].length <= 80 && !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value) && !/[^\S ]/u.test(value);
+const date = (value) => typeof value === "string" && /^\d{4}-\d\d-\d\dT/.test(value) && Number.isFinite(Date.parse(value));
+// These records contain no credentials. Immutable, content-addressed receipts
+// retain upgrade history; identical setup never rewrites or accumulates files.
+// They document installation, and never authorize overwriting a skill.
+export class LocalRecords {
+    agent;
+    environment;
+    origin;
+    tree;
+    connectionDirectory;
+    skillDirectory;
+    constructor(home, agent, environment, origin) {
+        this.agent = agent;
+        this.environment = environment;
+        this.origin = origin;
+        this.tree = new OwnedTree(home);
+        this.connectionDirectory = join(this.tree.home, ".caotang", "connection-info", environment, agent.fileKey);
+        this.skillDirectory = join(this.tree.home, ".caotang", "skill-receipts", agent.fileKey);
+    }
+    async read(path) {
+        try {
+            const bytes = await this.tree.read(path, 32768);
+            if (!bytes)
+                return null;
+            const value = asRecord(JSON.parse(bytes.toString("utf8")));
+            if (!value)
+                throw unsafe();
+            return value;
+        }
+        catch {
+            throw unsafe();
+        }
+    }
+    async connection(tokenId, secrets = []) {
+        if (!id(tokenId))
+            throw unsafe();
+        const record = await this.read(join(this.connectionDirectory, `${tokenId}.json`));
+        if (!record)
+            return null;
+        const connectionName = record.connection_name;
+        if (!keys(record, ["version", "environment", "origin", "agent_key", "token_id", "connection_name", "connected_at"])
+            || record.version !== 1 || record.environment !== this.environment || record.origin !== this.origin || record.agent_key !== this.agent.key || record.token_id !== tokenId
+            || !label(connectionName) || !date(record.connected_at) || secrets.some(secret => secret.length >= 8 && connectionName.includes(secret)))
+            throw unsafe();
+        return { connection_name: connectionName, connection_name_source: "local_authorization_record", connected_at: record.connected_at, connection_time_source: "device_authorization" };
+    }
+    async rememberConnection(tokenId, info, secrets = []) {
+        if (!id(tokenId) || info.connection_name_source !== "local_authorization_record" || !label(info.connection_name) || !date(info.connected_at)
+            || secrets.some(secret => secret.length >= 8 && info.connection_name.includes(secret)))
+            throw unsafe();
+        const record = { version: 1, environment: this.environment, origin: this.origin, agent_key: this.agent.key, token_id: tokenId, connection_name: info.connection_name, connected_at: info.connected_at };
+        try {
+            await this.tree.writeNew(join(this.connectionDirectory, `${tokenId}.json`), Buffer.from(JSON.stringify(record)), 0o600);
+        }
+        catch {
+            throw unsafe();
+        }
+    }
+    targetPath(path) {
+        if (typeof path !== "string" || !path || isAbsolute(path) || /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(path))
+            throw unsafe();
+        const absolute = this.tree.within(join(this.tree.home, path));
+        if (absolute === this.tree.home || relative(this.tree.home, absolute) !== path || path.split(sep).includes(".."))
+            throw unsafe();
+        return absolute;
+    }
+    async targets() {
+        let names;
+        try {
+            names = await this.tree.list(this.skillDirectory);
+        }
+        catch {
+            throw unsafe();
+        }
+        if (!names)
+            return [];
+        if (names.length > 256)
+            throw unsafe();
+        const targets = new Map();
+        for (const name of names) {
+            if (!/^[a-z-]+\.[a-f0-9]{64}\.json$/.test(name))
+                throw unsafe();
+            const value = await this.read(join(this.skillDirectory, name));
+            if (!value || !keys(value, ["version", "agent_key", "platform", "skill_directory", "bundle_sha", "skills"]) || value.version !== 1 || value.agent_key !== this.agent.key
+                || typeof value.platform !== "string" || !isPlatformId(value.platform) || !hash(value.bundle_sha) || !Array.isArray(value.skills)
+                || !value.skills.every(item => { const entry = asRecord(item); return entry && keys(entry, ["name", "sha256"]) && typeof entry.name === "string" && hash(entry.sha256); })
+                || !completeSkillInventory(value.skills.map(item => item.name)) || name !== `${value.platform}.${digest(JSON.stringify(value))}.json`)
+                throw unsafe();
+            const skillDirectory = this.targetPath(value.skill_directory);
+            try {
+                await this.tree.list(skillDirectory);
+            }
+            catch {
+                throw unsafe();
+            }
+            // A retained receipt cannot make a removed directory appear installed.
+            // Keep the target so the ordinary inspector reports its missing skills.
+            const target = { id: value.platform, skillDirectory, detected: true, evidence: "skills" };
+            const previous = targets.get(target.id);
+            if (previous && previous.skillDirectory !== target.skillDirectory)
+                throw unsafe();
+            targets.set(target.id, target);
+        }
+        return [...targets.values()];
+    }
+    async rememberInstallation(targets, assets, bundleSha) {
+        if (!hash(bundleSha) || !completeSkillInventory(assets.map(asset => asset.name)))
+            throw unsafe();
+        for (const target of targets) {
+            const bound = assets.map(asset => bindSkillAgent(asset, this.agent.key));
+            if (!await verifiedSkillFiles(this.tree.home, target, bound))
+                throw unsafe();
+            const record = { version: 1, agent_key: this.agent.key, platform: target.id, skill_directory: relative(this.tree.home, resolve(target.skillDirectory)), bundle_sha: bundleSha, skills: bound.map(({ name, sha256 }) => ({ name, sha256 })) };
+            this.targetPath(record.skill_directory);
+            try {
+                await this.tree.writeNew(join(this.skillDirectory, `${target.id}.${digest(JSON.stringify(record))}.json`), Buffer.from(JSON.stringify(record)), 0o600);
+            }
+            catch {
+                throw unsafe();
+            }
+        }
+    }
+}
+export async function verifiedSkillFiles(home, target, assets) {
+    const tree = new OwnedTree(home);
+    if (!completeSkillInventory(assets.map(asset => asset.name)))
+        return false;
+    for (const asset of assets) {
+        const directory = join(target.skillDirectory, asset.name), entries = await tree.list(directory);
+        if (!entries || entries.length !== 1 || entries[0] !== "SKILL.md")
+            return false;
+        const bytes = await tree.read(join(directory, "SKILL.md"), 65536);
+        if (!bytes || digest(bytes) !== asset.sha256)
+            return false;
+    }
+    return true;
+}

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/managed-skill-baseline.js

@@ -0,0 +1,35 @@
+// Public CLI 1.0.0 skill templates from reviewed commit 74530387. These pins
+// authorize only exact per-AI rendering after the complete old bundle verifies;
+// installation receipts, directory names and same-name files are never proof.
+export const LEGACY_MANAGED_SKILLS = [
+    {
+        "name": "caotang-context",
+        "description": "每个新对话第一件工作前，即使未提草堂也主动短读一次；闲聊和纯问答不读，接入同意门优先。",
+        "sha256": "e698b74c7fc0e81ae5155a842e5bcc026c0383cb528dac66ef4ee869703e89b1"
+    },
+    {
+        "name": "caotang-save-knowledge",
+        "description": "仅在要写入一间草堂私有知识、来源或长势时加载；确认内容再写，公开须本人网页确认。",
+        "sha256": "5c10105f96691697d7640e0c1e7a9ad5e8b79250dadc0c8d126e5538609391eb"
+    },
+    {
+        "name": "caotang-project-progress",
+        "description": "用户要记录一间草堂项目进展时，确认后保存私有进展，并按需局部更新认知摘要或阶段；项目公开须申请并由本人网页确认。",
+        "sha256": "bbece00f3f69fddb8ef57c12a4d84576238c962ae1526367cecdc102ac0cf409"
+    },
+    {
+        "name": "caotang-search",
+        "description": "用户询问一间草堂以前记录的项目、进展或知识时，先按词或时间检索，需要全文才读详情，并说明实际查询范围和权限缺口。",
+        "sha256": "d1feb8c82f841a0baa3fc4e70085d5eb90d0d7e35fdb08d3e3d0fd0d3bae967a"
+    },
+    {
+        "name": "caotang-workday",
+        "description": "仅在完成重要工作或收工时，整理一间草堂进展和下一步，先确认再保存；不承担开工。",
+        "sha256": "e6673787c66472fb58799b75da85894594da7c7da9a3b110d250a1166b1a358f"
+    },
+    {
+        "name": "caotang-first-connect",
+        "description": "一间草堂接入对话按入口首次安装和账号状态分流：有内容或未知先问一次再读，空账号只拟私有条目，同意才写；重复接入不问不读。",
+        "sha256": "47202fb64c5a9cd06ad06740be7f1ba1734400439bbb125c3138a0239b1bbd53"
+    }
+];

package/dist/missing-sections.js

@@ -0,0 +1,72 @@
+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: "搜索中的知识" },
+    search_schedule_items: { capability: "read_workbench", 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,54 @@
+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 { calendarStartNotice } from "./habit-wire.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 startNotice = human ? calendarStartNotice(asRecord(data)?.data) : "";
+    const replayNotice = human && [200, 201].includes(result.status) && body?.idempotency_replayed === true ? "这是已有创建请求的回放结果，本次没有重新创建。\n" : "";
+    return `${pendingNotice}${replayNotice}${writeNotice}${startNotice ? startNotice + "\n" : ""}${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: "申请已创建，等你在网页确认。" } };
+}

package/dist/platforms.js

@@ -0,0 +1,239 @@
+import { constants } from "node:fs";
+import { access, lstat, readdir, realpath, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { asRecord, CliError } from "./errors.js";
+import { PLATFORM_IDS, platformSupported } from "./local-types.js";
+const unsafe = () => new CliError("platform_path_unsafe", "平台目录未通过安全检查。", "请使用用户目录内的绝对路径，并检查目录和符号链接；不要提供目录中的配置内容。");
+const metadataError = (error) => {
+    const code = asRecord(error)?.code;
+    return code === "EACCES" || code === "EPERM"
+        ? new CliError("platform_permission_denied", "没有权限检查平台程序目录。", "请由本人检查程序目录的访问权限，不要自动提权或修改权限。", 4)
+        : code === "ELOOP" ? unsafe()
+            : new CliError("platform_detection_failed", "无法完成平台程序检查。", "请检查本地程序目录后重新执行只读检查，不要启动客户端或输出配置内容。");
+};
+const missing = (error) => ["ENOENT", "ENOTDIR"].includes(String(asRecord(error)?.code));
+const absolute = (path) => typeof path === "string" && isAbsolute(path) && !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(path);
+const within = (home, path) => {
+    const part = relative(home, path);
+    return part !== ".." && !part.startsWith(`..${sep}`) && !isAbsolute(part);
+};
+async function executable(path) {
+    try {
+        const info = await stat(path);
+        if (!info.isFile() || (info.mode & 0o111) === 0)
+            return false;
+        try {
+            await access(path, constants.X_OK);
+        }
+        catch (error) {
+            if (["EACCES", "EPERM", "ENOENT", "ENOTDIR"].includes(String(asRecord(error)?.code)))
+                return false;
+            throw error;
+        }
+        return true;
+    }
+    catch (error) {
+        if (missing(error))
+            return false;
+        throw metadataError(error);
+    }
+}
+async function directories(path) {
+    try {
+        return (await readdir(path, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+            .map((entry) => entry.name).sort();
+    }
+    catch (error) {
+        if (missing(error))
+            return [];
+        throw metadataError(error);
+    }
+}
+async function skillDirectory(home, canonicalHome, root) {
+    if (!absolute(root))
+        throw unsafe();
+    const target = resolve(root, "skills");
+    if (!within(home, resolve(root)) || !within(home, target))
+        throw unsafe();
+    // Check existing ancestry as metadata only, including symlink escapes before a missing leaf.
+    let current = home;
+    for (const component of relative(home, target).split(sep).filter(Boolean)) {
+        current = join(current, component);
+        try {
+            const info = await lstat(current);
+            if (info.isSymbolicLink()) {
+                let resolved;
+                try {
+                    resolved = await realpath(current);
+                }
+                catch (error) {
+                    if (missing(error))
+                        throw unsafe();
+                    throw error;
+                }
+                if (!within(canonicalHome, resolved) || !(await stat(current)).isDirectory())
+                    throw unsafe();
+            }
+            else if (!info.isDirectory())
+                throw unsafe();
+        }
+        catch (error) {
+            if (asRecord(error)?.code === "ENOENT")
+                break;
+            if (error instanceof CliError)
+                throw error;
+            throw metadataError(error);
+        }
+    }
+    return target;
+}
+function configuredSkillRoot(home, env, id) {
+    switch (id) {
+        case "claude-code": return env.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
+        case "codex": return join(home, ".agents");
+        case "openclaw": return env.OPENCLAW_STATE_DIR ?? (env.OPENCLAW_HOME === undefined ? join(home, ".openclaw") : (() => {
+            if (!absolute(env.OPENCLAW_HOME) || !within(home, resolve(env.OPENCLAW_HOME)))
+                throw unsafe();
+            return join(env.OPENCLAW_HOME, ".openclaw");
+        })());
+        case "kimi-code": return env.KIMI_CODE_HOME ?? join(home, ".kimi-code");
+        case "kimi-work": return join(home, "Library/Application Support/kimi-desktop/daimon-share/daimon");
+        case "workbuddy": return join(home, ".workbuddy");
+    }
+}
+// Bounded skill-location discovery only. No PATH, application bundle, client
+// executable, configuration contents or arbitrary HOME traversal is involved.
+export async function knownSkillTargets(options) {
+    if (!absolute(options.homeDir))
+        throw unsafe();
+    const home = resolve(options.homeDir);
+    let canonicalHome;
+    try {
+        canonicalHome = await realpath(home);
+        if (!(await stat(home)).isDirectory())
+            throw unsafe();
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
+        throw metadataError(error);
+    }
+    const targets = [];
+    for (const id of PLATFORM_IDS)
+        if (platformSupported(id, options.operatingSystem)) {
+            try {
+                targets.push({ id, detected: false, evidence: "none", skillDirectory: await skillDirectory(home, canonicalHome, configuredSkillRoot(home, options.env, id)) });
+            }
+            catch (error) {
+                // Only optional, bounded discovery isolates a candidate. Explicit or
+                // recorded targets are checked by their original strict path instead.
+                if (!options.skipInvalidCandidates)
+                    throw error;
+            }
+        }
+    return targets;
+}
+async function claudeDesktop(home) {
+    const root = join(home, "Library", "Application Support", "Claude", "claude-code");
+    for (const version of await directories(root)) {
+        if (!/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(version))
+            continue;
+        for (const hash of await directories(join(root, version))) {
+            if (!/^[a-f0-9]{6,64}$/i.test(hash))
+                continue;
+            if (await executable(join(root, version, hash, "claude.app", "Contents", "MacOS", "claude")))
+                return true;
+        }
+    }
+    return false;
+}
+export async function detectPlatforms(options) {
+    if (!absolute(options.homeDir))
+        throw unsafe();
+    const home = resolve(options.homeDir);
+    let canonicalHome;
+    try {
+        canonicalHome = await realpath(home);
+        if (!(await stat(home)).isDirectory())
+            throw unsafe();
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
+        throw metadataError(error);
+    }
+    const { env } = options;
+    const roots = options.applicationRoots ?? ["/Applications", join(home, "Applications")];
+    if (!roots.every(absolute))
+        throw unsafe();
+    const selected = (id) => options.platformIds === undefined || options.platformIds.includes(id);
+    const targets = [];
+    const candidates = ["claude-code", "codex", "openclaw"].map(id => ({ id, root: () => configuredSkillRoot(home, env, id) }));
+    for (const candidate of candidates) {
+        if (selected(candidate.id))
+            targets.push({ id: candidate.id, detected: false, evidence: "none", skillDirectory: await skillDirectory(home, canonicalHome, candidate.root()) });
+    }
+    const pathRoots = (env.PATH ?? "").split(delimiter).filter(absolute);
+    for (const target of targets) {
+        const command = target.id === "claude-code" ? "claude" : target.id;
+        for (const root of pathRoots) {
+            if (await executable(join(root, command))) {
+                target.detected = true;
+                target.evidence = "executable";
+                break;
+            }
+        }
+        if (target.detected)
+            continue;
+        if (target.id === "claude-code") {
+            target.detected = await claudeDesktop(home);
+        }
+        else {
+            const app = target.id === "codex" ? "Codex" : "OpenClaw";
+            for (const root of roots) {
+                if (await executable(join(root, `${app}.app`, "Contents", "MacOS", app))
+                    || (target.id === "codex" && await executable(join(root, "ChatGPT.app", "Contents", "Resources", "codex-cli", "CodexCLI.app", "Contents", "MacOS", "codex")))) {
+                    target.detected = true;
+                    break;
+                }
+            }
+        }
+        if (target.detected)
+            target.evidence = "desktop";
+    }
+    if ((options.operatingSystem ?? process.platform) === "darwin") {
+        // Do not inspect an unselected new platform's personal paths. Without a
+        // selector, only a verified program makes its skill root relevant.
+        for (const [id, app, binary, rootPath, command] of [
+            ["kimi-code", "Kimi Code", "Kimi Code", configuredSkillRoot(home, env, "kimi-code"), "kimi"],
+            ["kimi-work", "Kimi", "Kimi", configuredSkillRoot(home, env, "kimi-work"), null],
+            ["workbuddy", "WorkBuddy", "Electron", configuredSkillRoot(home, env, "workbuddy"), null],
+        ]) {
+            if (!selected(id))
+                continue;
+            let detected = false;
+            let evidence = "none";
+            if (command)
+                for (const root of pathRoots) {
+                    if (await executable(join(root, command))) {
+                        detected = true;
+                        evidence = "executable";
+                        break;
+                    }
+                }
+            if (!detected)
+                for (const root of roots) {
+                    if (await executable(join(root, `${app}.app`, "Contents", "MacOS", binary))) {
+                        detected = true;
+                        evidence = "desktop";
+                        break;
+                    }
+                }
+            if (!detected && options.platformIds === undefined)
+                continue;
+            targets.push({ id, detected, evidence, skillDirectory: await skillDirectory(home, canonicalHome, rootPath) });
+        }
+    }
+    return targets;
+}