@yijiancaotang/cli 0.0.0-stage → 1.1.0

package/dist/habit-wire.js

@@ -0,0 +1,87 @@
+import { dailySummaryResult } from "./calendar-contract.js";
+import { validDate as validDay } from "./query-validation.js";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+const list = (value, n) => { if (!Array.isArray(value) || value.length > n)
+    throw Error(); return value; };
+const str = (v, max) => { if (typeof v !== "string" || [...v].length > max || v.includes("\0"))
+    throw Error(); return v; };
+const id = (v) => { const s = str(v, 128); if (!/^[a-z0-9_-]+(?![\s\S])/i.test(s))
+    throw Error(); return s; };
+const key = (v) => { const s = str(v, 64); if (!/^[a-z][a-z0-9_]*(?![\s\S])/.test(s))
+    throw Error(); return s; };
+const count = (v) => { if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0)
+    throw Error(); return v; };
+function rule(value) {
+    const r = record(value), text = str(r.text, 200);
+    // The Go writer rejects controls before trimming Unicode White_Space.
+    // A literal BOM is content, while NEL / lone surrogates cannot be stored.
+    if (/[\p{Cc}\u2028\u2029\uD800-\uDFFF]/u.test(text) || !text || text.replace(/^\p{White_Space}+|\p{White_Space}+$/gu, "") !== text)
+        throw Error();
+    return { id: id(r.id), text, created_at: str(r.created_at, 64), updated_at: str(r.updated_at, 64) };
+}
+function pending(value) { const r = record(value), total = count(r.total), items = list(r.items, 3).map(value => { const p = record(value); return { id: id(p.id), action_type: key(p.action_type), summary: str(p.summary, 120) }; }); if (items.length > total)
+    throw Error(); return { total, items }; }
+function day(value) { const r = record(value); if (!validDay(r.date))
+    throw Error(); const total = count(r.total), items = list(r.items, 3).map(value => { const p = record(value); if (p.kind !== "project_update" && p.kind !== "checkin")
+    throw Error(); return { kind: p.kind, id: id(p.id), summary: str(p.summary, 120), ...(p.project_id === undefined ? {} : { project_id: id(p.project_id) }) }; }); if (items.length > total)
+    throw Error(); return { date: r.date, total, items }; }
+function step(value) { const r = record(value); return { id: id(r.id), project_id: id(r.project_id), summary: str(r.summary, 120), created_at: str(r.created_at, 64) }; }
+function gap(value) { const r = record(value), section = key(r.section); if (typeof r.reason !== "string" || !["capability_disabled", "read_failed", "community_disabled", "record_failed"].includes(r.reason))
+    throw Error(); if (r.reason === "record_failed" && (section !== "calendar_start" || r.required_capability !== "read_workbench"))
+    throw Error(); if (section === "calendar_start" && (r.required_capability !== "read_workbench" || !["capability_disabled", "record_failed"].includes(r.reason)))
+    throw Error(); return { section, ...(r.required_capability === undefined ? {} : { required_capability: key(r.required_capability) }), reason: r.reason }; }
+function official(value) { const r = record(value), total = count(r.unread_count), title = str(r.latest_title, 120); if ((total === 0 && title !== "") || (total > 0 && !title))
+    throw Error(); return { unread_count: total, latest_title: title }; }
+// Project the bounded wire fields rather than forwarding unknown content or
+// treating a missing section as empty. Unknown account truth wins over empty.
+export function verifiedHabit(value, start) {
+    try {
+        const r = record(value);
+        if (!start) {
+            if (r.limit !== 20 || r.max_chars !== 200)
+                return;
+            return { items: list(r.items, 20).map(rule), limit: 20, max_chars: 200 };
+        }
+        if (typeof r.partial !== "boolean" || !(typeof r.account_empty === "boolean" || r.account_empty === null))
+            return;
+        const rules = r.rules === null ? null : list(r.rules, 20).map(rule), p = r.pending === null ? null : pending(r.pending), days = r.recent_days === null ? null : list(r.recent_days, 3).map(day), next = r.next_step === null ? null : step(r.next_step), gaps = list(r.missing_sections, 32).map(gap);
+        const owner = typeof r.owner_id === "string" && /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}(?![\s\S])/i.test(r.owner_id) ? r.owner_id : undefined;
+        const schedules = r.schedule_items === undefined ? undefined : r.schedule_items === null ? null : verifiedScheduleStart(r.schedule_items);
+        const summary = r.last_daily_summary === undefined ? undefined : r.last_daily_summary === null ? null : dailySummaryResult(r.last_daily_summary);
+        const incomplete = rules === null || p === null || days === null || schedules === null || gaps.some(g => g.reason !== "community_disabled" && g.reason !== "record_failed");
+        const onlyStartRecordGap = gaps.length > 0 && gaps.every(g => g.section === "calendar_start" && g.reason === "record_failed");
+        if ((incomplete || gaps.length > 0) && !r.partial)
+            return;
+        const contradicted = r.account_empty === true && (!!rules?.length || !!p?.total || !!days?.length || !!next || !!schedules?.total_stored || !!summary);
+        return { ...(owner ? { owner_id: owner } : {}), ...(r.official_notices === undefined ? {} : { official_notices: r.official_notices === null ? null : official(r.official_notices) }), rules, pending: p, recent_days: days, next_step: next,
+            ...(schedules === undefined ? {} : { schedule_items: schedules }), ...(summary === undefined ? {} : { last_daily_summary: summary }), account_empty: !owner || (r.partial && !onlyStartRecordGap) || incomplete || contradicted ? null : r.account_empty, partial: r.partial, missing_sections: gaps };
+    }
+    catch {
+        return undefined;
+    }
+}
+import { verifiedScheduleStart } from "./schedule-start-wire.js";
+// A closed content switch is diagnosed only from an exact, non-conflicting
+// start receipt; bare 403 and unrelated capabilities remain unknown.
+export function habitWorkbenchDisabled(value) {
+    const body = record(value);
+    if (!body)
+        return false;
+    const code = body.code ?? body.error;
+    return code === "capability_disabled" && (body.code === undefined || body.code === code) && (body.error === undefined || body.error === code)
+        && body.required_capability === "read_workbench" && (!Object.hasOwn(body, "missing_sections") || Array.isArray(body.missing_sections) && body.missing_sections.length === 0);
+}
+// Derived only from validated protocol metadata; upstream free text is ignored.
+export function calendarStartNotice(value) {
+    const body = record(value), rows = body?.missing_sections;
+    if (!Array.isArray(rows))
+        return "";
+    const reasons = new Set(rows.slice(0, 32).filter(v => record(v)?.section === "calendar_start" && record(v)?.required_capability === "read_workbench").map(v => record(v)?.reason));
+    if (reasons.size !== 1)
+        return "";
+    if (reasons.has("record_failed"))
+        return "这次没记上开工时间，已读内容仍可使用；不自动重试。";
+    if (reasons.has("capability_disabled"))
+        return "读取工作台开关未开启，这次未记录开工时间；其余内容按原权限返回。";
+    return "";
+}

package/dist/http.js

@@ -0,0 +1,211 @@
+import { CliError, validToken, networkFailure } from "./errors.js";
+import { isPagedQueryPath, isQueryParameterError, isProjectIDParameterError } from "./query-validation.js";
+import { isSearchParameterError } from "./query-search.js";
+import { isDailyParameterError } from "./query-daily.js";
+import { isCreatePath } from "./create-bundle.js";
+import { isScheduleHeaderPath, scheduleHeaders } from "./schedule-contract.js";
+import { isCalendarHeaderPath, calendarHeaders } from "./calendar-contract.js";
+const maxJSONBytes = 4 * 1024 * 1024;
+const invalidResponse = () => new CliError("invalid_response", "一间草堂返回了无法确认的响应。", "请先核对网页中的实际结果，不要自动重复写入。", 7);
+const invalidRequest = () => new CliError("invalid_request", "请求参数无效。", "请检查命令帮助和输入数据。");
+async function jsonBody(response, queryPath) {
+    if (response.status === 204)
+        return null;
+    if (Number(response.headers.get("content-length")) > maxJSONBytes) {
+        await response.body?.cancel();
+        throw invalidResponse();
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        return null;
+    const chunks = [];
+    let length = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            length += value.byteLength;
+            if (length > maxJSONBytes) {
+                await reader.cancel();
+                throw invalidResponse();
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    try {
+        const value = Buffer.concat(chunks).toString("utf8");
+        if (queryPath && response.status === 400 && (isQueryParameterError(value) || isProjectIDParameterError(queryPath, value) || (queryPath.endsWith("/m1/search") && isSearchParameterError(value)) || (queryPath.endsWith("/m1/activity/daily") && isDailyParameterError(value))))
+            return value;
+        if (!value.trim()) {
+            if (response.ok)
+                throw invalidResponse();
+            return null;
+        }
+        return JSON.parse(value);
+    }
+    catch {
+        if (!response.ok)
+            return null;
+        throw invalidResponse();
+    }
+}
+function retryAfter(header) {
+    if (!header)
+        return undefined;
+    const seconds = /^\d+$/.test(header) ? Number(header) : (Date.parse(header) - Date.now()) / 1000;
+    return Number.isFinite(seconds) && seconds >= 0 ? Math.min(86400, Math.ceil(seconds)) : undefined;
+}
+export class ApiClient {
+    baseUrl;
+    fetchImpl;
+    timeoutMs;
+    secrets = new Set();
+    signal;
+    constructor(baseUrl, options = {}) {
+        try {
+            const url = new URL(baseUrl);
+            if ((url.protocol !== "https:" && !(url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))) || url.username || url.password || url.search || url.hash || url.pathname !== "/")
+                throw invalidRequest();
+            this.baseUrl = url.origin;
+        }
+        catch {
+            throw new CliError("invalid_environment", "接入环境配置无效。", "请使用默认环境或 --env test。");
+        }
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.timeoutMs = options.timeoutMs ?? 15000;
+        this.signal = options.signal;
+    }
+    outputSecrets() { return [...this.secrets]; }
+    async request(path, options = {}) {
+        let url;
+        try {
+            url = new URL(path, this.baseUrl);
+            if (!path.startsWith("/api/v1/agent/") || url.origin !== this.baseUrl || url.hash || path.split("?")[0] !== url.pathname)
+                throw invalidRequest();
+        }
+        catch {
+            throw invalidRequest();
+        }
+        const method = options.method ?? (options.body === undefined ? "GET" : "POST");
+        if (!["GET", "POST", "PATCH", "DELETE"].includes(method) || (method === "GET" && options.body !== undefined))
+            throw invalidRequest();
+        if (options.token !== undefined && (!validToken(options.token) || /^\/api\/v1\/agent\/device-auth\//.test(url.pathname)))
+            throw invalidRequest();
+        const headers = new Headers({ Accept: "application/json" });
+        if (options.token !== undefined) {
+            headers.set("Authorization", `Bearer ${options.token}`);
+            this.secrets.add(options.token);
+        }
+        if (options.body && typeof options.body === "object" && "device_code" in options.body && typeof options.body.device_code === "string")
+            this.secrets.add(options.body.device_code);
+        if (isScheduleHeaderPath(url.pathname, method)) {
+            for (const [name, value] of Object.entries(scheduleHeaders(url.pathname, method, options.headers)))
+                headers.set(name, value);
+        }
+        else if (isCalendarHeaderPath(url.pathname, method)) {
+            for (const [name, value] of Object.entries(calendarHeaders(url.pathname, method, options.headers)))
+                headers.set(name, value);
+        }
+        else if (options.headers !== undefined) {
+            if (!options.headers || Object.keys(options.headers).some((key) => key !== "Idempotency-Key"))
+                throw invalidRequest();
+            const key = options.headers["Idempotency-Key"];
+            if (key !== undefined) {
+                if (typeof key !== "string" || !/^[A-Za-z0-9._:-]{16,128}(?![\s\S])/.test(key) || method !== "POST" || (!/^\/api\/v1\/agent\/m2\/projects\/[^/]+\/updates$/.test(url.pathname) && !isCreatePath(url.pathname)))
+                    throw invalidRequest();
+                headers.set("Idempotency-Key", key);
+            }
+        }
+        let body;
+        if (options.body !== undefined) {
+            try {
+                body = JSON.stringify(options.body);
+            }
+            catch {
+                throw invalidRequest();
+            }
+            headers.set("Content-Type", "application/json");
+        }
+        return this.perform(url, { method, headers, body }, this.timeoutMs, options.signal ?? this.signal);
+    }
+    async upload(value, requiredHeaders, bytes) {
+        let url;
+        try {
+            url = new URL(value);
+            if (url.origin !== this.baseUrl || url.username || url.password || url.search || url.hash || !/^\/api\/v1\/knowledge-files\/uploads\/[A-Za-z0-9-]{1,80}$/.test(url.pathname))
+                throw invalidRequest();
+        }
+        catch {
+            throw invalidRequest();
+        }
+        if (!(bytes instanceof Uint8Array) || bytes.byteLength < 1 || bytes.byteLength > 10485760 || !requiredHeaders || Object.keys(requiredHeaders).length !== 2)
+            throw invalidRequest();
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(requiredHeaders)) {
+            if (!["content-type", "x-opc-upload-token"].includes(key.toLowerCase()) || typeof value !== "string")
+                throw invalidRequest();
+            headers.set(key, value);
+        }
+        if (headers.get("Content-Type") !== "application/pdf" || !validToken(headers.get("X-OPC-Upload-Token")))
+            throw invalidRequest();
+        this.secrets.add(headers.get("X-OPC-Upload-Token"));
+        return this.perform(url, { method: "PUT", headers, body: new Uint8Array(bytes).buffer }, 75000, this.signal);
+    }
+    async perform(url, options, timeoutMs, signal) {
+        const controller = new AbortController();
+        const networkError = (error) => networkFailure(error, options.method === "GET" || url.pathname === "/api/v1/agent/mcp-token/validate");
+        const cancelled = () => new CliError("cancelled", "操作已取消，结果可能尚未确认。", "请在网页核对，勿直接重复写入。", 130);
+        if (signal?.aborted)
+            throw cancelled();
+        let timer;
+        let onAbort;
+        const deadline = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => { controller.abort(); reject(networkError({ code: "ETIMEDOUT" })); }, timeoutMs);
+            onAbort = () => { controller.abort(); reject(cancelled()); };
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            return await Promise.race([(async () => {
+                    const response = await this.fetchImpl(url, { ...options, cache: "no-store", redirect: "manual", signal: controller.signal });
+                    let body;
+                    try {
+                        body = await jsonBody(response, options.method === "GET" && isPagedQueryPath(url.pathname) ? url.pathname : undefined);
+                        this.rememberSecrets(body);
+                    }
+                    catch (error) {
+                        if (response.ok)
+                            throw error;
+                        body = null;
+                    }
+                    const retry = retryAfter(response.headers.get("retry-after"));
+                    return { status: response.status, body, ...(retry === undefined ? {} : { retryAfterSeconds: retry }) };
+                })(), deadline]);
+        }
+        catch (error) {
+            if (error instanceof CliError)
+                throw error;
+            throw networkError(error);
+        }
+        finally {
+            clearTimeout(timer);
+            if (onAbort)
+                signal?.removeEventListener("abort", onAbort);
+        }
+    }
+    rememberSecrets(value, depth = 0) {
+        if (depth > 128)
+            throw invalidResponse();
+        if (!value || typeof value !== "object")
+            return;
+        for (const [key, item] of Object.entries(value)) {
+            if (/^(token|access_token|token_value|token_hash|device_code|upload_nonce|x-opc-upload-token)$/i.test(key) && typeof item === "string" && item.length >= 8)
+                this.secrets.add(item);
+            else if (item && typeof item === "object")
+                this.rememberSecrets(item, depth + 1);
+        }
+    }
+}

package/dist/input-validation.js

@@ -0,0 +1,76 @@
+import { asRecord, CliError } from "./errors.js";
+import { commandHelp } from "./command-help.js";
+export const trimGoSpace = (value) => value.replace(/^\p{White_Space}+|\p{White_Space}+$/gu, "");
+export function inputDetails(command, issues) {
+    const help = commandHelp(command);
+    return {
+        missing_fields: issues.missing ?? [],
+        // Even a syntactically harmless key can itself be a token or private text.
+        unknown_fields: issues.unknown ? ["<unknown_field>"] : [],
+        invalid_fields: issues.invalid ?? [],
+        allowed_fields: Object.keys(help?.fields ?? {}),
+        requirements: help?.fields ?? {},
+        ...(help ? { example: help.example } : {}),
+    };
+}
+export function invalidInput(command, issues) {
+    return new CliError("invalid_arguments", "写入参数无效，请核对列出的缺失字段、未知字段和无效字段。", ["upload", "link", "unlink"].includes(command[0])
+        ? "请按 missing_fields、unknown_fields、invalid_fields 和 requirements 核对参数，使用 example 中的固定安全命令示例；只提交本人确认的内容，不自动改写或重试。"
+        : "请按 missing_fields 补齐字段、删除 unknown_fields 对应的额外字段，并按 requirements 修正 invalid_fields；example 是固定安全示例，不含用户输入。JSON 可用 --input -；只提交本人确认的内容，不自动改写或重试。", 2, inputDetails(command, issues));
+}
+export function validateInput(value, schema, command) {
+    const body = asRecord(value);
+    if (!body)
+        throw invalidInput(command, { invalid: ["$input"] });
+    const missing = (schema.required ?? []).filter(key => !Object.hasOwn(body, key));
+    const invalid = [];
+    let unknown = false;
+    const normalized = {};
+    for (const [key, original] of Object.entries(body)) {
+        if (!Object.hasOwn(schema.fields, key)) {
+            unknown = true;
+            continue;
+        }
+        const item = schema.trimText && typeof original === "string" ? trimGoSpace(original) : original;
+        let valid = false;
+        try {
+            valid = schema.fields[key](item);
+        }
+        catch (error) {
+            if (!(error instanceof CliError) || error.code !== "invalid_arguments")
+                throw error;
+        }
+        if (!valid)
+            invalid.push(key);
+        else
+            normalized[key] = item;
+    }
+    if (!Object.keys(body).length && !missing.length)
+        invalid.push("$input");
+    if (missing.length || unknown || invalid.length)
+        throw invalidInput(command, { missing, unknown, invalid });
+    return normalized;
+}
+export function flagError(command) {
+    const help = commandHelp(command);
+    return new CliError("invalid_arguments", "这个命令不支持所给参数，或参数格式无效。", "请只使用 allowed_flags 中列出的参数，并查看该命令 --help；按名称查找请用 caotang search，不支持 projects --q。未知参数名和值不会回显。", 2, {
+        ...inputDetails(command, { unknown: true }), allowed_flags: [...(help?.options ?? []), "--agent", "--env", "--human", "--help"],
+    });
+}
+export function validateCommandArguments(command, flags) {
+    const help = commandHelp(command);
+    if (!help)
+        return;
+    if (Object.entries(flags).some(([key, value]) => value !== undefined && !help.options.includes(`--${key}`)))
+        throw flagError(command);
+    if (help.command === "context" && flags.start === true && Object.keys(flags).some(key => key !== "start" && flags[key] !== undefined))
+        throw flagError(command);
+    const count = (help.usage.match(/<[^>]+>/g) ?? []).length;
+    const words = help.command.split(" ").length;
+    const positionalCount = help.command === "upload" ? 1 : count;
+    if (command.length < words + positionalCount) {
+        throw invalidInput(command, { missing: (help.usage.match(/<[^>]+>/g) ?? []).slice(command.length - words) });
+    }
+    if (command.length > words + positionalCount && !(help.command === "search" && command.length === 2))
+        throw invalidInput(command, { invalid: ["$arguments"] });
+}