@stalfh233/omc-cli 0.6.17 → 0.6.19

package/dist/residue.js

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { ENDPOINTS } from "./endpoints.js";
+import { wireCall, wireRows } from "./wire.js";
+import { flattenTreeRows } from "./support.js";
+import { ConfigStore, defaultPaths } from "./config-store.js";
+import { SessionManager } from "./session-manager.js";
+import { makeToolContext } from "./context.js";
+import { emitInvalid, emitResult } from "./command-transport.js";
+const MAX_ITEMS = 20;
+function face(faceName, rows, extra = {}) {
+    return { face: faceName, ...extra, count: rows.length, items: rows.slice(0, MAX_ITEMS) };
+}
+function codeOf(row) {
+    return String(row.code ?? row.schemaCode ?? row.bizSchemaCode ?? "");
+}
+function nameOf(row, code) {
+    return String(row.name ?? row.displayName ?? row.title ?? code);
+}
+function codeStarts(row, prefix) {
+    return codeOf(row).startsWith(prefix);
+}
+function folderStarts(row, prefix) {
+    return codeStarts(row, prefix) || String(row.name ?? "").startsWith(prefix);
+}
+function scriptPresent(raw) {
+    if (typeof raw !== "string")
+        return false;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return false;
+        return parsed.some((element) => {
+            const row = element;
+            return row.id === "customScript" && typeof row.innerHTML === "string" && row.innerHTML.trim() !== "";
+        });
+    }
+    catch {
+        return false;
+    }
+}
+async function tree(session, app) {
+    return flattenTreeRows(wireRows((await wireCall(session, { path: ENDPOINTS.applicationTree, query: { appCode: app } })).data));
+}
+async function modelRows(session, app) {
+    return (await tree(session, app)).filter((row) => row.type === "BizModel");
+}
+async function customPages(session, appSet) {
+    const rows = wireRows((await wireCall(session, { path: ENDPOINTS.customPageList, query: { modeType: "VUE_MODE" } })).data);
+    return rows.filter((row) => appSet.has(String(row.appCode ?? "")));
+}
+async function deepFaces(session, model) {
+    const schemaCode = codeOf(model);
+    const rules = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } })).data);
+    const datarules = wireRows((await wireCall(session, { path: ENDPOINTS.dataRuleList, query: { schemaCode } })).data);
+    let online = [];
+    try {
+        const sheet = (await wireCall(session, { path: ENDPOINTS.sheetGet, query: { schemaCode, sheetCode: schemaCode } })).data;
+        if (sheet && (scriptPresent(sheet.draftHtmlJson) || scriptPresent(sheet.publishedHtmlJson))) {
+            const raw = typeof sheet.publishedHtmlJson === "string" && scriptPresent(sheet.publishedHtmlJson) ? sheet.publishedHtmlJson : sheet.draftHtmlJson;
+            online = [{ present: true, ...(typeof raw === "string" ? { sha256: createHash("sha256").update(raw).digest("hex") } : {}) }];
+        }
+    }
+    catch {
+        // A missing form is an absent online-js face, not a scan failure.
+    }
+    return [
+        face("rule", rules.map((row) => ({ code: codeOf(row), name: nameOf(row, codeOf(row)) })), { model: schemaCode }),
+        face("datarule", datarules.map((row) => ({ code: codeOf(row), name: nameOf(row, codeOf(row)) })), { model: schemaCode }),
+        face("onlinejs", online, { model: schemaCode }),
+    ];
+}
+export async function scanResidues(session, prefix, options = {}) {
+    const apps = wireRows((await wireCall(session, { path: ENDPOINTS.applicationList, query: {} })).data)
+        .map((row) => String(row.appCode ?? row.code ?? ""))
+        .filter(Boolean);
+    const selected = options.apps && options.apps !== "all" ? options.apps.split(",").map((app) => app.trim()).filter(Boolean) : apps;
+    const appSet = new Set(selected);
+    const faces = [];
+    const models = [];
+    for (const app of selected) {
+        const rows = await tree(session, app);
+        const matchingModels = rows.filter((row) => row.type === "BizModel" && codeStarts(row, prefix));
+        models.push(...matchingModels.map((row) => ({ ...row, appCode: app })));
+        faces.push(face("model", matchingModels.map((row) => ({ code: codeOf(row), name: nameOf(row, codeOf(row)) })), { app }));
+        faces.push(face("folder", rows.filter((row) => row.type === "Folder" && folderStarts(row, prefix)).map((row) => ({ code: codeOf(row), name: nameOf(row, codeOf(row)) })), { app }));
+    }
+    const pages = (await customPages(session, appSet)).filter((row) => codeStarts(row, prefix));
+    for (const app of selected) {
+        faces.push(face("custompage", pages.filter((row) => String(row.appCode ?? "") === app).map((row) => ({ code: codeOf(row), name: nameOf(row, codeOf(row)) })), { app }));
+    }
+    if (options.deep !== false) {
+        for (const model of models)
+            faces.push(...await deepFaces(session, model));
+    }
+    const totalResidues = faces.reduce((sum, item) => sum + item.count, 0);
+    return {
+        prefix,
+        faces,
+        totalResidues,
+        clean: totalResidues === 0,
+        note: "report 面暂停维护未扫描；workflow 模板跟模型走（模型删即删）",
+    };
+}
+export async function cmdResidue(prefix, options, transport) {
+    if (!prefix || prefix.trim() === "")
+        return emitInvalid(transport, { message: "residue 的 prefix 必填" });
+    try {
+        const context = makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+        const session = await context.sessions.session(options.env);
+        return emitResult(await scanResidues(session, prefix, { apps: options.apps, deep: options.noDeep !== true }), transport);
+    }
+    catch (error) {
+        return emitResult({ status: "error", blocker: "residue-scan-failed", message: error instanceof Error ? error.message : String(error) }, transport);
+    }
+}
+//# sourceMappingURL=residue.js.map

package/dist/rollback.js

@@ -8,6 +8,7 @@ import { readJournal, resolveJournalEntry, laterWritesOnTarget } from "./journal
 import { canonicalForVerify, deepDiff, pruneNullish } from "./rollback-spec.js";
 import { sha256 } from "./support.js";
 import { emitTransportResult } from "./command-transport.js";
+import { acquireWriteLock } from "./write-lock.js";
 /** Pure runtime assembly: an injected context (tests) or the default one. */
 function runtime(context) {
     return context ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
@@ -191,25 +192,53 @@ export async function applyRollback(ref, options, context) {
         };
     }
     const results = [];
-    for (const [index, call] of plan.inverse.calls.entries()) {
-        const { exitCode, result } = await runToolCall(call.tool, {
-            args: { ...call.args, environment: entry.environment, ...(options.confirmProduction ? { confirmProduction: true } : {}) },
-            requestId: `omc-rollback-${entry.seq}-${index + 1}`,
-            context: ctx,
-            print: () => undefined,
-        });
-        results.push({
-            tool: call.tool,
-            exitCode,
-            status: result.status,
-            ...(result.deliveryState ? { deliveryState: result.deliveryState } : {}),
-            ...(result.summary ? { summary: result.summary } : {}),
-            // r55: exit-code-only results hid the reason a restore call failed
-            // (input-invalid showed as a bare "status=error"). Surface the shape.
-            ...(exitCode === 0 ? {} : { blocker: result.blocker ?? null, message: result.message ?? null, ...(result.issues !== undefined ? { issues: result.issues } : {}), ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}) }),
-        });
-        if (exitCode !== 0)
-            return { status: "stopped", rollbackOf: { seq: entry.seq, tool: entry.tool }, step: index + 1, results, message: `恢复调用 ${call.tool} 未成功（status=${result.status}）；已执行的调用已各自记 journal，可对已完成步骤再 plan` };
+    // The inverse plan is intentionally kept as the seam for future inverse
+    // extensions (for example onlinejs.compose remove:true): all new restore
+    // shapes still become governed calls here, without changing the evidence
+    // or lock protocol.
+    const waitMs = options.waitMs ?? 0;
+    const deadline = Date.now() + waitMs;
+    let lock;
+    for (;;) {
+        lock = await acquireWriteLock(entry.environment);
+        if (lock.held)
+            break;
+        if (Date.now() >= deadline) {
+            return {
+                status: "refused",
+                blocker: "write-lock-held",
+                rollbackOf: { seq: entry.seq, tool: entry.tool },
+                waitMs,
+                lockOwner: lock.owner ?? null,
+                message: `回滚写锁被占用；已等待 ${waitMs}ms。可用 --wait <ms> 有界排队后重试`,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.min(200, Math.max(0, deadline - Date.now()))));
+    }
+    try {
+        for (const [index, call] of plan.inverse.calls.entries()) {
+            const { exitCode, result } = await runToolCall(call.tool, {
+                args: { ...call.args, environment: entry.environment, ...(options.confirmProduction ? { confirmProduction: true } : {}) },
+                requestId: `omc-rollback-${entry.seq}-${index + 1}`,
+                context: ctx,
+                print: () => undefined,
+            });
+            results.push({
+                tool: call.tool,
+                exitCode,
+                status: result.status,
+                ...(result.deliveryState ? { deliveryState: result.deliveryState } : {}),
+                ...(result.summary ? { summary: result.summary } : {}),
+                // r55: exit-code-only results hid the reason a restore call failed
+                // (input-invalid showed as a bare "status=error"). Surface the shape.
+                ...(exitCode === 0 ? {} : { blocker: result.blocker ?? null, message: result.message ?? null, ...(result.issues !== undefined ? { issues: result.issues } : {}), ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}) }),
+            });
+            if (exitCode !== 0)
+                return { status: "stopped", rollbackOf: { seq: entry.seq, tool: entry.tool }, step: index + 1, results, message: `恢复调用 ${call.tool} 未成功（status=${result.status}）；已执行的调用已各自记 journal，可对已完成步骤再 plan` };
+        }
+    }
+    finally {
+        await lock.release();
     }
     // Authoritative verify: re-read the target and compare against the
     // canonicalized before. "restored" tolerates the write pipeline
@@ -232,6 +261,12 @@ export async function applyRollback(ref, options, context) {
         rollbackOf: { seq: entry.seq, tool: entry.tool, target: entry.target },
         calls: results,
         verify,
+        // Stable evidence is present on both the restored and mismatch paths.
+        // `recoveredTo` deliberately identifies the original journal target; the
+        // replay writes are separately journaled and can be rolled back again.
+        restoredSha256: restoredSha,
+        matchesBefore: verify === "restored",
+        recoveredTo: { seq: entry.seq, ts: entry.ts },
         ...(verify === "mismatch" ? { beforeSha, restoredSha, message: "恢复调用已完成但读回与 before 存在值冲突（非默认显式化）：立即人工核对目标现态（omc rollback plan <seq> 的 diff 可复看差异）" } : {}),
         hint: "本次恢复的每次调用都走了完整写闸门并已记 journal；恢复本身可再回滚（rollback plan <新 seq>）",
     };

package/dist/write.js

@@ -143,7 +143,7 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload, readOnlyEs
             const artifactRef = writeArtifact(ctx, `${tool.name}-${randomUUID().slice(0, 8)}.json`, artifact);
             return { status: executed.status, steps: executed.steps, failedStep: executed.failedStep, ...executed.envelope, ...(args.requestId ? { requestId: args.requestId } : {}), artifactFingerprint: artifactRef.detailSha256 };
         }
-        const { performed, readback, steps, halfSuccess, irreversible } = executed;
+        const { performed, readback, steps, halfSuccess, irreversible, rollbackReceipt, runtimeVerification } = executed;
         // Readback gate (live 2026-10-17): a tool that reports `readback.present:false`
         // has NOT proven its own write — the platform accepted the request but the
         // object is absent from the authoritative face. "Called without error" must
@@ -204,17 +204,21 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload, readOnlyEs
         return {
             status: "ok",
             deliveryState,
+            ...((typeof performed.applicationCode === "string" ? { applicationCode: performed.applicationCode } : typeof readback.applicationCode === "string" ? { applicationCode: readback.applicationCode } : {})),
             ...(readOnlyEscapeNote !== undefined ? { readOnlyEscape: readOnlyEscapeNote } : {}),
             performed,
             readback,
             ...(readbackWarning ? { readbackWarning } : {}),
             ...(steps !== undefined ? { steps } : {}),
             ...(halfSuccess !== undefined ? { halfSuccess } : {}),
+            ...(runtimeVerification !== undefined ? { runtimeVerification } : {}),
             ...(typeof irreversible === "string" ? { irreversible } : {}),
             // r30a F1: first write → replay:"none"; duplicate only on true replay.
             ...(args.requestId ? { requestId: args.requestId, idempotency: idempotencyDeclaration(tool.name, "none") } : {}),
             ...(productionConfirmed ? { productionConfirmed: true } : {}),
-            ...(rollbackRef ? { rollback: rollbackRef } : {}),
+            ...(rollbackRef
+                ? { rollback: { ...(rollbackReceipt ?? {}), seq: rollbackRef.seq, ...(rollbackReceipt ? {} : { hint: rollbackRef.hint }) } }
+                : {}),
             summary: writeSummary(tool.name, args, { performed, readback }, "done"),
             detailFile: artifactRef.detailFile,
             detailSha256: artifactRef.detailSha256,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.6.17",
+  "version": "0.6.19",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "omc-core": "0.6.17",
+    "omc-core": "0.6.19",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",
@@ -73,6 +73,6 @@
     "directory": "packages/omc-cli"
   },
   "optionalDependencies": {
-    "@stalfh233/omc-fake-platform": "0.6.17"
+    "@stalfh233/omc-fake-platform": "0.6.19"
   }
 }