@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/cli-contract.js

@@ -0,0 +1,70 @@
+import { randomUUID } from "node:crypto";
+export const CLI_EXIT_CODES = {
+    ok: 0,
+    invalidInput: 10,
+    authConfig: 11,
+    policyRefused: 12,
+    uncertain: 14,
+    internal: 15,
+};
+export function envelope(status, result, requestId, error = null) {
+    return { ok: error === null, status, result, requestId, error };
+}
+/**
+ * The single stdout serialization for every envelope.
+ *
+ * On zh-CN Windows, PowerShell decodes a native process's bytes with the legacy
+ * console code page and mangles UTF-8 Chinese ("付文�?"), which forces callers
+ * into a "write to file, then re-read" workaround. When `OMC_ASCII_STDOUT`
+ * resolves on, non-ASCII is escaped to `\uXXXX`: stdout stays pure ASCII and
+ * decodes identically under any code page while still parsing to the original
+ * string. It is on by default only on win32, so Linux output keeps its smaller
+ * UTF-8 bytes. Override with `OMC_ASCII_STDOUT=1|0`. Artifacts keep raw UTF-8 —
+ * they are files, not a console stream. See `CONTEXT.md` → Agent-facing CLI.
+ */
+export function asciiStdout() {
+    const override = process.env.OMC_ASCII_STDOUT;
+    if (override === "1")
+        return true;
+    if (override === "0")
+        return false;
+    return process.platform === "win32";
+}
+export function serializeEnvelope(value) {
+    const json = JSON.stringify(value);
+    const escaped = asciiStdout() ? json.replace(/[\u007f-\uffff]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`) : json;
+    return escaped + "\n";
+}
+export function requestId() {
+    return randomUUID();
+}
+export function classifyResult(result) {
+    const status = String(result.status ?? "ok");
+    if (status === "ok")
+        return { status, error: null, exitCode: CLI_EXIT_CODES.ok };
+    if (status === "dry-run")
+        return { status, error: null, exitCode: CLI_EXIT_CODES.ok };
+    if (status === "unknown-tool") {
+        const candidates = Array.isArray(result.candidates) ? result.candidates : [];
+        const suffix = candidates.length > 0 ? `；did you mean: ${candidates.join("、")}` : "；用 `omc commands --json --compact --lane <lane>` 或 `omc next` 定位工具";
+        return { status: "error", error: { code: "invalid-input", message: `unknown tool ${String(result.tool ?? "")}${suffix}`, retryable: false }, exitCode: CLI_EXIT_CODES.invalidInput };
+    }
+    if (result.blocker === "tool-input-invalid")
+        return { status: "error", error: { code: "invalid-input", message: String(result.message ?? "tool input is invalid"), retryable: false }, exitCode: CLI_EXIT_CODES.invalidInput };
+    if (status === "uncertain")
+        return { status, error: { code: "uncertain", message: String(result.message ?? result.reason ?? "outcome is uncertain"), retryable: true }, exitCode: CLI_EXIT_CODES.uncertain };
+    if (status === "refused") {
+        if (result.blocker === "write-lock-held")
+            return { status, error: { code: "policy-refused", message: String(result.message ?? "write lock held"), retryable: true }, exitCode: CLI_EXIT_CODES.policyRefused };
+        const auth = String(result.blocker ?? "").startsWith("auth") || String(result.blocker ?? "").includes("credential");
+        return { status, error: { code: auth ? "auth-config" : "policy-refused", message: String(result.message ?? result.blocker ?? "operation refused"), retryable: false }, exitCode: auth ? CLI_EXIT_CODES.authConfig : CLI_EXIT_CODES.policyRefused };
+    }
+    const message = String(result.message ?? "internal error");
+    const auth = /credential|configuration|environment|login|authentication|auth/i.test(message);
+    return { status: "error", error: { code: auth ? "auth-config" : "internal", message, retryable: false }, exitCode: auth ? CLI_EXIT_CODES.authConfig : CLI_EXIT_CODES.internal };
+}
+export function errorEnvelope(error, code, exitCode, request) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { envelope: envelope("error", {}, request, { code, message, retryable: false }), exitCode };
+}
+//# sourceMappingURL=cli-contract.js.map

package/dist/cli-output.js

@@ -0,0 +1,73 @@
+import { writeFileSync } from "node:fs";
+import { serializeEnvelope } from "./cli-contract.js";
+import { recordUsageOutput } from "./usage-log.js";
+let options = { quiet: false };
+/** Parse `--quiet` and `--out <file>` from the raw argv once, before dispatch. */
+export function configureOutput(argv) {
+    const outIndex = argv.indexOf("--out");
+    let outFile;
+    if (outIndex >= 0) {
+        const value = argv[outIndex + 1];
+        // Refuse a missing or flag-looking value rather than writing to a file named
+        // `--quiet` and silently dropping the flag. A bad `--out` is invalid input.
+        if (value === undefined || value.startsWith("--"))
+            throw new Error("--out requires a file path");
+        outFile = value;
+    }
+    options = { quiet: argv.includes("--quiet"), ...(outFile ? { outFile } : {}) };
+    return options;
+}
+/**
+ * Remove the global output flags from argv before commander parses it, so they
+ * are consumed once here instead of being declared on every subcommand.
+ */
+export function stripOutputFlags(argv) {
+    const out = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--quiet")
+            continue;
+        if (token === "--out") {
+            index += 1;
+            continue;
+        }
+        out.push(token);
+    }
+    return out;
+}
+export function outputOptions() {
+    return options;
+}
+/**
+ * Write the single stdout envelope. When `--out` is set, the identical bytes are
+ * written to that file (UTF-8) FIRST, so a bad path fails before any envelope
+ * reaches stdout — keeping the "exactly one envelope" contract even on failure.
+ * stdout and the file can never diverge.
+ */
+export function writeEnvelope(value) {
+    const text = serializeEnvelope(value);
+    if (!options.outFile) {
+        recordUsageOutput(value, Buffer.byteLength(text, "utf8"));
+        process.stdout.write(text);
+        return;
+    }
+    const pretty = `${JSON.stringify(value, null, 2)}\n`;
+    writeFileSync(options.outFile, pretty, "utf8");
+    const envelopeValue = value && typeof value === "object" ? value : {};
+    const confirmation = {
+        ok: envelopeValue.ok ?? true,
+        status: envelopeValue.status ?? "ok",
+        result: { out: options.outFile, bytes: Buffer.byteLength(pretty, "utf8") },
+        requestId: envelopeValue.requestId ?? null,
+        error: envelopeValue.error ?? null,
+    };
+    const confirmationText = serializeEnvelope(confirmation);
+    recordUsageOutput(value, Buffer.byteLength(confirmationText, "utf8"), Buffer.byteLength(pretty, "utf8"));
+    process.stdout.write(confirmationText);
+}
+/** Emit a human diagnostic on stderr, unless `--quiet` asked for none. */
+export function humanSummary(line) {
+    if (!options.quiet)
+        process.stderr.write(`${line}\n`);
+}
+//# sourceMappingURL=cli-output.js.map