@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/call.js

@@ -0,0 +1,153 @@
+import { openSync, readSync, closeSync } from "node:fs";
+import { resolve } from "node:path";
+import { buildToolRegistry, makeToolContext } from "./tools.js";
+import { SessionManager } from "./session-manager.js";
+import { ConfigStore, defaultPaths } from "./config-store.js";
+import { redact } from "./redact.js";
+import { assertSafeInputPath } from "./artifacts.js";
+import { parseToolInput, ToolInputError } from "./tool-types.js";
+import { absencePointer } from "./capability-absences.js";
+export const CALL_EXIT_CODES = { ok: 0, failed: 1, unknownTool: 2, invalidInput: 10 };
+export const CLI_ARGS_MAX_BYTES = 1024 * 1024;
+function readBounded(fd, label) {
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const remaining = CLI_ARGS_MAX_BYTES + 1 - total;
+            if (remaining <= 0)
+                throw new Error(`${label} exceeds ${CLI_ARGS_MAX_BYTES} bytes`);
+            const chunk = Buffer.alloc(Math.min(64 * 1024, remaining));
+            const bytes = readSync(fd, chunk, 0, chunk.length, null);
+            if (bytes === 0)
+                break;
+            total += bytes;
+            if (total > CLI_ARGS_MAX_BYTES)
+                throw new Error(`${label} exceeds ${CLI_ARGS_MAX_BYTES} bytes`);
+            chunks.push(chunk.subarray(0, bytes));
+        }
+    }
+    finally {
+        if (fd !== 0)
+            closeSync(fd);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function parseJsonArgs(text, label) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`${label} must be a JSON object`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function readStdinArgs() {
+    return parseJsonArgs(readBounded(0, "--args -"), "--args -");
+}
+export function readArgsFile(path, root = resolve(process.env.OMC_CONFIG_HOME ?? process.cwd())) {
+    const safePath = assertSafeInputPath(root, path, "--args-file");
+    const fd = openSync(safePath, "r");
+    return parseJsonArgs(readBounded(fd, "--args-file"), "--args-file");
+}
+export async function runToolCall(toolName, options = {}) {
+    const print = options.print ?? ((line) => console.log(line));
+    const context = options.context ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+    const registry = buildToolRegistry();
+    const tool = registry.find((definition) => definition.name === toolName);
+    if (!tool) {
+        // Round 4: return the closest candidates, not the whole inventory. A live
+        // run burned a call on `model.exists` and then received every tool name.
+        const names = registry.map((definition) => definition.name);
+        const segment = toolName.split(".")[0] ?? toolName;
+        const candidates = names.filter((name) => name === segment || name.startsWith(`${segment}.`) || name.includes(toolName)).slice(0, 8);
+        // A requested operation the PLATFORM itself does not expose (e.g.
+        // dictionary.delete) must not read as an OMC gap: name the real recovery
+        // path and the documented absence instead of only the nearest tools.
+        const absence = absencePointer(toolName);
+        const result = {
+            status: "unknown-tool",
+            tool: toolName,
+            ...(candidates.length > 0 ? { candidates } : {}),
+            ...(absence ? { platformAbsence: absence.replace(/^；/, "") } : {}),
+            hint: "工具名见 `omc commands --json --compact --lane <lane>`；用 next/recipe 定位",
+        };
+        print(JSON.stringify(result, null, 2));
+        return { exitCode: CALL_EXIT_CODES.unknownTool, result };
+    }
+    let args = { ...(options.args ?? {}) };
+    if (options.environment && args.environment === undefined)
+        args.environment = options.environment;
+    if (options.requestId)
+        args.requestId = options.requestId;
+    if (options.dryRun)
+        args.dryRun = true;
+    try {
+        args = parseToolInput(tool, args);
+    }
+    catch (error) {
+        const result = error instanceof ToolInputError ? error.payload : { status: "error", message: error instanceof Error ? error.message : String(error) };
+        print(redact(result, []));
+        return { exitCode: CALL_EXIT_CODES.invalidInput, result };
+    }
+    const invoke = async () => {
+        try {
+            return (await tool.handler(context, args, tool));
+        }
+        catch (error) {
+            const payload = error.payload;
+            if (payload)
+                return payload;
+            return { status: "error", message: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const result = options.timeoutMs === undefined
+        ? await invoke()
+        : await Promise.race([
+            invoke(),
+            new Promise((resolve) => setTimeout(() => resolve({ status: "uncertain", blocker: "cli-timeout", nextAction: "read back the requestId before retrying; retry only after the outcome is established", retryable: true }), options.timeoutMs)),
+        ]);
+    // The stderr line is a human diagnostic, NOT a second copy of the result: the
+    // stdout envelope is the single machine truth. Dumping the whole result here
+    // doubled every call's payload on stderr (unbounded and un-sanitized — it also
+    // leaked the raw `detailFile` path; live 2026-09-25). Print the short summary a
+    // write already carries, or the (small) error payload; stay silent on a bare
+    // successful read.
+    const humanLine = humanResultLine(result);
+    if (humanLine !== null)
+        print(humanLine);
+    const status = String(result?.status ?? "ok");
+    const exitCode = status === "ok" ? CALL_EXIT_CODES.ok : result?.blocker === "tool-input-invalid" ? CALL_EXIT_CODES.invalidInput : CALL_EXIT_CODES.failed;
+    return { exitCode, result };
+}
+/**
+ * The single stderr diagnostic line for a call result, or null when the result
+ * is a bare success (the envelope already carries it). Errors keep their payload
+ * because it is small and useful; a write's `summary` is the human-facing line.
+ */
+function humanResultLine(result) {
+    if (typeof result.summary === "string" && result.summary.trim().length > 0)
+        return result.summary;
+    const status = String(result?.status ?? "ok");
+    if (status !== "ok")
+        return redact(result, []);
+    return null;
+}
+export function validateAgentPaths(args) {
+    const root = resolve(process.env.OMC_CONFIG_HOME ?? process.cwd());
+    const visit = (value, key) => {
+        if (key === "zipPath" && typeof value === "string")
+            assertSafeInputPath(root, value, "zipPath");
+        if (Array.isArray(value))
+            for (const entry of value)
+                visit(entry);
+        else if (value && typeof value === "object")
+            for (const [entryKey, entry] of Object.entries(value))
+                visit(entry, entryKey);
+    };
+    visit(args);
+}
+//# sourceMappingURL=call.js.map

package/dist/capability-absences.js

@@ -0,0 +1,23 @@
+const ABSENCES = [
+    {
+        requested: "dictionary.delete",
+        recovery: "omc call dictionary.status --args '{\"target\":\"dictionary\",\"id\":\"<dictionaryId>\",\"status\":false}'，再对每条记录 dictionary.status target=record（停用后运行时 getEnableRecords* 返回空）",
+        evidence: "DataDictionaryController (cloudpivot-engine-8.6.26) 只有 saveDictionary / updateDictionaryStatus / deleteDictionaryClass(Batch)；DictionaryFacade 的 deleteDictionaryRecord 无任何 controller 接线；apppackage/physically_delete 的 NodeType 分派只处理 Page/CustomPage/BizModel/Report，不含 DATA_DICTIONARY。管理端 UI 对字典本身只有「禁用」",
+        message: "平台没有删除数据字典的操作（只有启用/停用）。字典的清理手段是 dictionary.status 停用字典与记录",
+    },
+];
+const BY_REQUESTED = new Map(ABSENCES.map((entry) => [entry.requested, entry]));
+/** The absence entry for a requested tool name, or undefined. Aliases resolve by exact name. */
+export function capabilityAbsence(requested) {
+    const direct = BY_REQUESTED.get(requested);
+    if (direct)
+        return direct;
+    // Tolerate a family wildcard the caller may write loosely (dictionary.deleteDictionary, delete.dictionary…).
+    return ABSENCES.find((entry) => requested.includes(entry.requested) || (requested.startsWith("dictionary.") && requested.includes("delete")));
+}
+/** A `；…` suffix for an error message, or "" when the request names no known absence. */
+export function absencePointer(requested) {
+    const entry = capabilityAbsence(requested);
+    return entry ? `；${entry.message}。改用 \`${entry.recovery}\`。证据：${entry.evidence}` : "";
+}
+//# sourceMappingURL=capability-absences.js.map