@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/read.js

@@ -0,0 +1,144 @@
+import { assertWithinCoverage } from "./coverage.js";
+import { wireErrorKind, isUncertainWireError, jsonBytes, refusalFromCoverage, sha256, summarizeValue, writeArtifact } from "./support.js";
+import { plannableArgsRaw } from "./plan.js";
+import { WireError } from "./wire.js";
+/**
+ * `full:true` used to bypass every diet gate and inline the raw platform body.
+ * For `workflow.get_draft` that is a 30–75 KB native blob (btnConfigList,
+ * propertyPermissions, eight lifecycle callbacks, geometry, a duplicated
+ * originateActivity) of which the editable shape is <1.5 KB. Round 9 (sandbox
+ * 40): 8 `workflow.get_* full:true` calls were 147 KB = 24% of the task, and the
+ * blob is re-read on every later turn.
+ *
+ * So the raw body is only inlined below this ceiling. Above it the caller gets
+ * the tool's compact semantic projection (which holds everything an edit needs)
+ * plus the artifact reference and a targeted-fetch hint. This does NOT change
+ * any platform write: write tools read the stored row server-side, never from
+ * the agent's readback (workflow.update/publish, field.update, form.publish,
+ * onlinejs.compose, service.update/method.update all self-read).
+ */
+const FULL_INLINE_CEILING_BYTES = 8192;
+/**
+ * Run composed sibling reads without the `unchanged` short-circuit, so a
+ * composite tool (model.inspect) receives their real payloads even after an
+ * identical standalone read primed the cache. Re-entrant via a counter, so
+ * nesting is safe. Only the short-circuit is skipped; results are still cached
+ * normally, and the cache is process-local (a fresh CLI process starts empty).
+ */
+export async function withoutReadbackCache(ctx, run) {
+    ctx.readbackCacheBypass += 1;
+    try {
+        return await run();
+    }
+    finally {
+        ctx.readbackCacheBypass -= 1;
+    }
+}
+export async function governedRead(ctx, tool, args, execute, options = {}) {
+    const lane = args.capability ?? tool.lane;
+    if (lane) {
+        try {
+            assertWithinCoverage(ctx.manifest, lane, tool.scope ?? "");
+        }
+        catch (error) {
+            return refusalFromCoverage(error);
+        }
+    }
+    try {
+        const session = await ctx.sessions.session(args.environment);
+        const environmentFingerprint = safeFingerprint(session);
+        const result = await execute(session);
+        if (result.status === "refused" || result.status === "uncertain")
+            return { ...result, environmentFingerprint };
+        const target = options.target ?? `${tool.name}:${JSON.stringify(plannableArgsRaw(args))}`;
+        const targetFingerprint = sha256(result);
+        const cached = ctx.readbackCache.get(target);
+        if (ctx.readbackCacheBypass === 0 && cached && cached.environmentFingerprint === environmentFingerprint && cached.targetFingerprint === targetFingerprint && options.full !== true)
+            return { status: "ok", unchanged: true, detailFile: cached.detailFile, detailSha256: cached.detailSha256, environmentFingerprint };
+        const detail = { status: "ok", ...result, environmentFingerprint };
+        const large = jsonBytes(result) > 4096;
+        const fileName = `${tool.name.replace(/[^a-zA-Z0-9._-]/g, "_")}-${sha256(target).slice(0, 16)}.json`;
+        const artifactRef = writeArtifact(ctx, fileName, detail);
+        ctx.readbackCache.set(target, { environmentFingerprint, targetFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 });
+        if (options.full === true) {
+            const rawBytes = jsonBytes(result);
+            // Small raw bodies keep the old inline behaviour; large ones are dieted
+            // (see FULL_INLINE_CEILING_BYTES). The raw body stays fully reachable via
+            // the artifact, so no capability is lost — only the inline copy is skipped.
+            if (rawBytes <= FULL_INLINE_CEILING_BYTES)
+                return { ...detail, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
+            const compact = options.compact ? options.compact(result, session) : compactReadback(result);
+            return {
+                status: "ok",
+                ...passthroughScalars(result),
+                ...compact,
+                full: true,
+                fullOmitted: true,
+                fullBytes: rawBytes,
+                fullArtifactHint: `--full 的原生正文 ${rawBytes}B 超过内联上限 ${FULL_INLINE_CEILING_BYTES}B，已外置到 artifact；上面的语义投影含编辑所需字段，需要原生字段用 \`omc artifact get <detailArtifactId>\`（可 --jq <path> / --keys）定向取回，勿全量读入。`,
+                environmentFingerprint,
+                detailFile: artifactRef.detailFile,
+                detailSha256: artifactRef.detailSha256,
+            };
+        }
+        if (!large)
+            return { status: "ok", ...result, environmentFingerprint };
+        const compact = options.compact ? options.compact(result, session) : compactReadback(result);
+        return { status: "ok", ...passthroughScalars(result), ...compact, environmentFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
+    }
+    catch (error) {
+        if (isUncertainWireError(error))
+            return { status: "uncertain", frozen: true, reason: `wire-transport:${wireErrorKind(error)}`, detail: error.message };
+        if (error instanceof WireError)
+            return { status: "refused", blocker: `wire-${error.kind}`, errcode: error.errcode, message: error.message, ...(error.diagnostic ? { diagnostic: error.diagnostic } : {}) };
+        throw error;
+    }
+}
+function compactReadback(result) {
+    const compact = {};
+    for (const [key, value] of Object.entries(result)) {
+        if (BULKY_READ_KEYS.has(key)) {
+            compact[`${key}Count`] = Array.isArray(value) ? value.length : value && typeof value === "object" ? Object.keys(value).length : 0;
+        }
+        else {
+            compact[key] = summarizeValue(value);
+        }
+    }
+    return compact;
+}
+/**
+ * Keys whose values are the bulk a compact projection replaces with a count.
+ * Everything else is a small facet identity/decision fields (workflowCode,
+ * exists, published, id, code, schemaCode, note, …).
+ */
+const BULKY_READ_KEYS = new Set(["data", "nodes", "routes", "items", "rules", "applications", "foldersAndModels", "models"]);
+/**
+ * Carry the handler's small top-level facets through a compact projection.
+ *
+ * A lane's compact function reduces the result to its own summary shape and can
+ * drop scalar identity/decision keys the handler set at the top level — e.g.
+ * `workflow.get_draft` returns `{ workflowCode, exists, published, data }`, but
+ * `workflowCompactProjection` emitted only `workflowSummary`, so a caller reading
+ * `result.workflowCode` got `undefined` (round 10: live demo). Pass the scalar
+ * (non-bulky) top-level keys through; the compact's own keys still win.
+ */
+function passthroughScalars(result) {
+    const carried = {};
+    for (const [key, value] of Object.entries(result)) {
+        if (key === "status" || BULKY_READ_KEYS.has(key))
+            continue;
+        const type = typeof value;
+        if (value === null || type === "string" || type === "number" || type === "boolean")
+            carried[key] = value;
+    }
+    return carried;
+}
+function safeFingerprint(session) {
+    try {
+        return session.environmentFingerprint();
+    }
+    catch {
+        return "unavailable";
+    }
+}
+//# sourceMappingURL=read.js.map

package/dist/redact.js

@@ -0,0 +1,28 @@
+const PLACEHOLDER = "[REDACTED]";
+export function redact(value, secrets) {
+    let text = JSON.stringify(value ?? null);
+    for (const secret of secrets) {
+        if (!secret.value)
+            continue;
+        text = text.split(secret.value).join(PLACEHOLDER);
+    }
+    return text;
+}
+export function redactText(text, secrets) {
+    let out = text;
+    for (const secret of secrets) {
+        if (!secret.value)
+            continue;
+        out = out.split(secret.value).join(PLACEHOLDER);
+    }
+    return out;
+}
+/** Error messages must never embed secret material either. */
+export function redactError(error, secrets) {
+    const message = redactText(error instanceof Error ? error.message : String(error), secrets);
+    const redacted = new Error(message);
+    if (error instanceof Error && error.stack)
+        redacted.stack = redactText(error.stack, secrets);
+    return redacted;
+}
+//# sourceMappingURL=redact.js.map