@stalfh233/omc-cli 0.4.18 → 0.4.19

package/dist/cli.js

@@ -1375,6 +1375,24 @@ async function main() {
         const rest = [tool, ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.args !== undefined ? ["--args", options.args] : []), ...(options.argsFile !== undefined ? ["--args-file", options.argsFile] : []), ...(options.maxOutputBytes !== undefined ? ["--max-output-bytes", options.maxOutputBytes] : []), ...(options.requestId ? ["--request-id", options.requestId] : []), ...(options.timeoutMs ? ["--timeout-ms", options.timeoutMs] : []), ...(options.wait !== undefined ? ["--wait", options.wait] : []), ...(options.dryRun ? ["--dry-run"] : [])];
         commandExitCode = await cmdCall(new ConfigStore(defaultPaths()), rest);
     });
+    command.command("script [file]").option("--env <environment>", "行内无 env 时的默认环境").option("--continue", "某行失败后继续执行剩余行（默认停在首个失败）").description("NDJSON 多调脚本：每行 {\"tool\":\"<名称>\",\"args\":{...},\"env\":\"<环境>\",\"dryRun\":true}（# 注释/空行忽略；file 为 - 读 stdin）；一个进程一次会话跑完全部，逐行输出 {index,tool,exitCode,result}").action(async (file, options) => {
+        const { runScript, parseScript, readScriptInput } = await import("./script.js");
+        let lines;
+        try {
+            lines = parseScript(readScriptInput(file ?? "-"));
+        }
+        catch (error) {
+            console.error(String(error instanceof Error ? error.message : error));
+            commandExitCode = CLI_EXIT_CODES.invalidInput;
+            return;
+        }
+        if (lines.length === 0) {
+            console.error("脚本为空：每行一个 {\"tool\":\"<名称>\",\"args\":{...}} 调用");
+            commandExitCode = CLI_EXIT_CODES.invalidInput;
+            return;
+        }
+        commandExitCode = await runScript(lines, { defaultEnv: options.env, continueOnError: options.continue === true });
+    });
     command.command("artifact").command("get <id>").option("--jq <path>").option("--path-only").option("--summary").option("--keys [a,b]").option("--max-output-bytes <bytes>").action(async (id, options) => {
         commandExitCode = await withTransport(options, request, (transport) => cmdArtifactGet(id, transport, { ...(options.jq ? { jq: options.jq } : {}), pathOnly: options.pathOnly === true, summary: options.summary === true || options.keys === true, ...(typeof options.keys === "string" ? { keys: options.keys } : {}) }));
     });

package/dist/lanes/b2-registration.js

@@ -158,9 +158,15 @@ export function registerB2Lane(tools) {
         description: B2_TOOLS["service.get"].description,
         inputSchema: { environment: environmentArg, serviceCode: z.string(), capability: capabilityArg },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // F5: the service row and its method list are independent reads keyed
+            // by the same serviceCode — fire both at once. The absent path
+            // short-circuits AFTER the pair settles (the method read's result is
+            // simply discarded; absence is a fact either way).
+            const serviceRead = wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+            const methodRead = wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } }).catch((error) => error);
             let service;
             try {
-                service = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+                service = await serviceRead;
             }
             catch (error) {
                 // A deleted service answers the wire-business error 500001; reading a
@@ -173,19 +179,25 @@ export function registerB2Lane(tools) {
             const serviceRow = service.data;
             let methods = null;
             let methodsError = null;
-            try {
-                methods = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data).map((row) => ({
-                    code: row.code,
-                    name: row.name,
-                    serviceCode: row.serviceCode ?? args.serviceCode,
-                    configJson: maskServiceConfigSecrets(normalizeMethodConfigReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.configJson))),
-                    inputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.inputParametersJson)),
-                    outputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.outputParametersJson)),
-                    referenced: row.referenced === true,
-                }));
+            const methodOutcome = await methodRead;
+            if (methodOutcome instanceof Error) {
+                methodsError = methodOutcome.message;
             }
-            catch (error) {
-                methodsError = error instanceof Error ? error.message : String(error);
+            else {
+                try {
+                    methods = wireRows(methodOutcome.data).map((row) => ({
+                        code: row.code,
+                        name: row.name,
+                        serviceCode: row.serviceCode ?? args.serviceCode,
+                        configJson: maskServiceConfigSecrets(normalizeMethodConfigReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.configJson))),
+                        inputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.inputParametersJson)),
+                        outputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.outputParametersJson)),
+                        referenced: row.referenced === true,
+                    }));
+                }
+                catch (error) {
+                    methodsError = error instanceof Error ? error.message : String(error);
+                }
             }
             return {
                 serviceCode: args.serviceCode,

package/dist/lanes/field.js

@@ -12,6 +12,7 @@ import { defineTool, ToolRefusalError } from "../tool-types.js";
 import { wireCall, wireRows, WireError } from "../wire.js";
 import { executeFormDraftWrite, executeFormPublishWrite } from "../form-support.js";
 import { FIELD_LANE_CONTRACT } from "./field-contract.js";
+import { mapBounded } from "../support.js";
 const FIELD_LANE = FIELD_LANE_CONTRACT.lane;
 const FIELD_TOOLS = FIELD_LANE_CONTRACT.tools;
 /** Parse a raw options JSON string for readback; policy: non-strings and unparseable strings pass through verbatim. */
@@ -304,24 +305,26 @@ export async function executeFieldPublish(session, args) {
         .map((row) => [codeOf(row), { name: String(row.name ?? ""), propertyType: Number(row.type ?? row.propertyType) }]));
     const verifyFieldDetails = async (targets) => {
         const bounded = targets.slice(0, 25);
-        const mismatches = [];
-        for (const code of bounded) {
+        const checked = await mapBounded(bounded, 5, async (code) => {
             const expected = draftSnapshot.get(code);
             if (!expected)
-                continue;
-            let detail;
+                return { kind: "skip" };
             try {
-                detail = (await wireCall(session, { path: ENDPOINTS.fieldGet, query: { schemaCode: args.schemaCode, propertyCode: code } })).data;
+                const detail = (await wireCall(session, { path: ENDPOINTS.fieldGet, query: { schemaCode: args.schemaCode, propertyCode: code } })).data;
+                const actual = { name: String(detail.name ?? ""), propertyType: Number(detail.propertyType ?? detail.type) };
+                if (actual.name !== expected.name || actual.propertyType !== expected.propertyType)
+                    return { kind: "mismatch", code, expected, actual };
+                return { kind: "ok" };
             }
             catch {
                 // The detail endpoint is optional across builds: report the
                 // verification as unavailable rather than failing the publish.
-                return { mode: "unavailable", verified: false, note: "bizproperty/get 不可用，字段详情未核对（仅列表面存在性）" };
+                return { kind: "unavailable" };
             }
-            const actual = { name: String(detail.name ?? ""), propertyType: Number(detail.propertyType ?? detail.type) };
-            if (actual.name !== expected.name || actual.propertyType !== expected.propertyType)
-                mismatches.push({ code, expected, actual });
-        }
+        });
+        if (checked.some((entry) => entry.kind === "unavailable"))
+            return { mode: "unavailable", verified: false, note: "bizproperty/get 不可用，字段详情未核对（仅列表面存在性）" };
+        const mismatches = checked.filter((entry) => entry.kind === "mismatch");
         return { mode: "detail", verified: true, checked: bounded.length, ok: mismatches.length === 0, ...(mismatches.length > 0 ? { mismatches } : {}) };
     };
     const preRead = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });

package/dist/lanes/model.js

@@ -3,6 +3,7 @@ import { ENDPOINTS } from "../endpoints.js";
 import { assertFieldFamilyAllowed, choicesArg, fieldOptionsArg, nameI18nJson, propertyTypeArg, relationTargetOf, relativeCodeArg, SYSTEM_FIELD_CODES, subFieldArg, } from "../field-families.js";
 import { fieldChangeWireBody, prepareFieldChange, sameFieldChange } from "../field-change.js";
 import { executeFormDraftWrite, executeFormPublishWrite } from "../form-support.js";
+import { mapBounded } from "../support.js";
 import { validateBusinessCode } from "../code-rules.js";
 import { writeSummary } from "../human-summary.js";
 import { capabilityArg, environmentArg } from "../args.js";
@@ -188,16 +189,25 @@ export function registerModelLane(tools) {
                 }
             };
             const inspectOne = async (schemaCode) => {
-                const fieldFace = await face("field.list", { schemaCode, published: true, ...(all ? { all: true } : {}) });
+                // F5: the six read faces are INDEPENDENT wire reads; fan them out in
+                // parallel (bounded) instead of paying six sequential round-trips. Only
+                // workflow.get_published stays chained (it needs workflowCode from the
+                // draft face). Output ordering is unchanged (results land by index).
+                const [fieldFace, formFace, listviewFace, ruleFace, dataruleFace, draftFace] = await mapBounded([
+                    () => face("field.list", { schemaCode, published: true, ...(all ? { all: true } : {}) }),
+                    () => face("form.get", { schemaCode }),
+                    () => face("listview.get", { schemaCode }),
+                    () => face("rule.list", { schemaCode }),
+                    () => face("datarule.list", { schemaCode }),
+                    () => face("workflow.get_draft", { schemaCode }),
+                ], 6, (task) => task());
                 const fieldRows = Array.isArray(fieldFace?.fields) ? fieldFace.fields : [];
                 const fields = fieldRows
                     .filter((field) => all || !SYSTEM_FIELD_CODES.has(String(field.code)))
                     .map((field) => ({ code: field.code, type: field.type, ...(field.typeName !== undefined ? { typeName: field.typeName } : {}), name: field.name, ...(field.conditions ? { conditions: field.conditions } : {}) }));
-                const formFace = await face("form.get", { schemaCode });
                 const form = formFace && formFace.present !== undefined
                     ? { present: formFace.present === true, published: formFace.published === true, controlCount: Array.isArray(formFace.draftControlCodes) ? formFace.draftControlCodes.length : 0 }
                     : undefined;
-                const listviewFace = await face("listview.get", { schemaCode });
                 const listviewColumns = Array.isArray(listviewFace?.columns) ? listviewFace.columns : [];
                 // Round 13: the default view is platform-generated and lists the system
                 // columns (createdTime/creater/name/sequenceNo/…). In a design-time survey
@@ -208,14 +218,12 @@ export function registerModelLane(tools) {
                 const listview = listviewFace && listviewFace.columns
                     ? { code: listviewFace.code ?? schemaCode, columnCount: visibleColumns.length, columns: visibleColumns.map((column) => ({ propertyCode: column.propertyCode, propertyType: column.propertyType, visible: column.visible })) }
                     : undefined;
-                const ruleFace = await face("rule.list", { schemaCode });
                 const ruleRows = Array.isArray(ruleFace?.rules) ? ruleFace.rules : [];
                 // All rules are kept: the platform pre-creates trigger rows (Create/Update/
                 // …) but user logic is AUTHORED INTO them, so `defaultRule` cannot be used
                 // to hide "system" rules without dropping authored ones. `defaultRule` is
                 // reported per rule so a caller can decide.
                 const rules = ruleRows.map((rule) => ({ code: rule.code, name: rule.name, enabled: rule.enabled, status: rule.status, ruleVersion: rule.ruleVersion, defaultRule: rule.defaultRule }));
-                const dataruleFace = await face("datarule.list", { schemaCode });
                 const dataruleRows = Array.isArray(dataruleFace?.rules) ? dataruleFace.rules : [];
                 const datarules = dataruleRows.map((rule) => ({ propertyCode: rule.propertyCode, propertyCodes: rule.propertyCodes, dataRuleType: rule.dataRuleType, name: rule.name, checkType: rule.checkType }));
                 // Workflow summary: use the PUBLISHED face for the `published` flag. The
@@ -224,7 +232,6 @@ export function registerModelLane(tools) {
                 // `published` from get_draft reported published:false forever (live round
                 // 10: an agent's flow read as published:false while get_published was
                 // templateType:PUBLISH). Activities come from whichever face exists.
-                const draftFace = await face("workflow.get_draft", { schemaCode });
                 const workflowCode = draftFace?.workflowSummary?.workflowCode ?? draftFace?.workflowCode;
                 const publishedFace = workflowCode ? await face("workflow.get_published", { schemaCode }) : undefined;
                 const draftSummary = draftFace?.workflowSummary;

package/dist/script.js

@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { ConfigStore, defaultPaths } from "./config-store.js";
+import { SessionManager } from "./session-manager.js";
+import { makeToolContext } from "./tools.js";
+import { runToolCall } from "./call.js";
+export function parseScript(text) {
+    const lines = [];
+    const raw = text.split("\n");
+    for (const [index, untrimmed] of raw.entries()) {
+        const line = untrimmed.trim();
+        if (line.length === 0 || line.startsWith("#"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`第 ${index + 1} 行不是合法 JSON：${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed) || typeof parsed.tool !== "string") {
+            throw new Error(`第 ${index + 1} 行必须是 {"tool":"<名称>","args":{...},"env":"<环境>","dryRun":true} 形状（tool 必填）`);
+        }
+        const entry = parsed;
+        if (entry.args !== undefined && (entry.args === null || typeof entry.args !== "object" || Array.isArray(entry.args)))
+            throw new Error(`第 ${index + 1} 行 args 必须是 JSON 对象`);
+        lines.push({
+            tool: entry.tool,
+            ...(typeof entry.args === "object" && entry.args !== null ? { args: entry.args } : {}),
+            ...(typeof entry.env === "string" ? { env: entry.env } : {}),
+            ...(entry.dryRun === true ? { dryRun: true } : {}),
+        });
+    }
+    return lines;
+}
+export async function runScript(lines, options = {}) {
+    const print = options.print ?? ((line) => console.log(line));
+    const context = options.context ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+    let failed = false;
+    for (const [index, line] of lines.entries()) {
+        const { exitCode, result } = await runToolCall(line.tool, {
+            args: line.args,
+            environment: line.env ?? options.defaultEnv,
+            dryRun: line.dryRun === true,
+            requestId: randomUUID(),
+            context,
+            print: () => undefined,
+        });
+        print(JSON.stringify({ index, tool: line.tool, exitCode, result }));
+        if (exitCode !== 0) {
+            failed = true;
+            if (options.continueOnError !== true) {
+                print(JSON.stringify({ index, tool: line.tool, stopped: true, note: `第 ${index + 1} 行失败，后续 ${lines.length - index - 1} 行未执行；加 --continue 跑完全部` }));
+                return exitCode;
+            }
+        }
+    }
+    return failed ? 1 : 0;
+}
+export function readScriptInput(path) {
+    if (path === "-")
+        return readFileSync(0, "utf8");
+    return readFileSync(path, "utf8");
+}
+//# sourceMappingURL=script.js.map

package/dist/support.js

@@ -95,4 +95,26 @@ export function flattenTreeRows(rows) {
         visit(row);
     return flat;
 }
+/**
+ * F5 (r10-friction): order-preserving map with BOUNDED concurrency. The read
+ * lanes fan out independent wire faces (model.inspect's six faces, field
+ * publish verification's detail reads) that used to pay full per-call
+ * latency sequentially. The bound keeps the fan-out polite to the small
+ * environments (ticket 79 documented DB contention under 30 parallel
+ * publishes; reads are lighter but still bounded).
+ */
+export async function mapBounded(items, limit, worker) {
+    const results = new Array(items.length);
+    let next = 0;
+    const runners = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+        while (true) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            results[index] = await worker(items[index], index);
+        }
+    });
+    await Promise.all(runners);
+    return results;
+}
 //# sourceMappingURL=support.js.map

package/package.json

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

package/skills/omc-start-here.md

@@ -37,6 +37,7 @@ Run in a **clean project directory** (not the OMC dev repo). Start from the goal
 omc next "<目标>"                          # goal → ordered route (offline)
 omc doctor                                  # environment name and readiness
 omc call discover_environment --args '{}'   # 单环境项目（.omc-env 在位）可省 --env；多环境才显式传
+omc script - --env <env> <<< '{"tool":"model.list"}'   # 多调链：NDJSON 每行一调，一进程一次会话跑完
 omc capability <selected-id>               # only the selected capability
 omc describe <tool> --example <recipe-id>   # recipe first; default describe otherwise
 omc help <topic> --section "<heading>"       # one methodology section, not all