@yijiancaotang/cli 0.0.0-stage → 1.0.0

package/dist/http.js

@@ -0,0 +1,201 @@
+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";
+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 (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"] });
+}