@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/online-js-layout.js

@@ -0,0 +1,58 @@
+const PLATFORM_STYLE_ELEMENT = Object.freeze({ tagName: "style", innerHTML: "\n", id: null, attrs: [] });
+const PLATFORM_TOOLBAR_SECTION = Object.freeze({ tagName: "section", id: "toolbar", attrs: [{ name: "id", value: "toolbar" }] });
+const PLATFORM_TEMPLATE_SECTION = Object.freeze({
+    tagName: "section",
+    id: "template",
+    attrs: [
+        { name: "type", value: "template" },
+        { name: "id", value: "template" },
+    ],
+});
+function platformScriptElement(id, innerHTML) {
+    return { tagName: "script", id, innerHTML, attrs: [] };
+}
+export function composeLayoutElements(existingElements, source) {
+    const styleIndex = existingElements.findIndex((element) => element.tagName === "style");
+    const styleElement = styleIndex >= 0 ? existingElements[styleIndex] : { ...PLATFORM_STYLE_ELEMENT, attrs: [] };
+    const toolbarElement = existingElements.find((element) => element.id === "toolbar") ?? { ...PLATFORM_TOOLBAR_SECTION, attrs: [...PLATFORM_TOOLBAR_SECTION.attrs] };
+    const templateElement = existingElements.find((element) => element.id === "template") ?? { ...PLATFORM_TEMPLATE_SECTION, attrs: [...PLATFORM_TEMPLATE_SECTION.attrs] };
+    const others = existingElements.filter((element, index) => index !== styleIndex &&
+        element.id !== "customScript" &&
+        element.id !== "beforeCustomScript" &&
+        element.id !== "afterCustomScript" &&
+        element.id !== "toolbar" &&
+        element.id !== "template");
+    const beforeElement = existingElements.find((element) => element.id === "beforeCustomScript") ?? platformScriptElement("beforeCustomScript", "");
+    const afterElement = existingElements.find((element) => element.id === "afterCustomScript") ?? platformScriptElement("afterCustomScript", "");
+    const customScriptElement = platformScriptElement("customScript", source);
+    return [styleElement, toolbarElement, templateElement, ...others, beforeElement, customScriptElement, afterElement];
+}
+export function assertPlatformOnlineJsLayout() {
+    const source = "(function(form){ form.on('onLoad', function(){}); })";
+    const empty = composeLayoutElements([], source);
+    const ids = empty.map((element) => element.id);
+    if (empty.length !== 6)
+        throw new Error("empty layout must produce six platform elements");
+    if (JSON.stringify(ids) !== JSON.stringify([null, "toolbar", "template", "beforeCustomScript", "customScript", "afterCustomScript"]))
+        throw new Error("empty layout has the wrong platform element order");
+    if (!empty.every((element) => Array.isArray(element.attrs)))
+        throw new Error("platform layout elements must have array attrs");
+    const customScript = empty.find((element) => element.id === "customScript");
+    if (customScript?.tagName !== "script" || customScript.innerHTML !== source)
+        throw new Error("customScript payload has the wrong canonical shape");
+    const style = { tagName: "style", innerHTML: ".x{}", id: null, attrs: [{ name: "data-style", value: "1" }] };
+    const toolbar = { tagName: "section", id: "toolbar", attrs: [{ name: "id", value: "toolbar" }, { name: "data-toolbar", value: "1" }] };
+    const template = { tagName: "section", id: "template", attrs: [{ name: "type", value: "template" }, { name: "id", value: "template" }] };
+    const before = { tagName: "script", id: "beforeCustomScript", innerHTML: "before", attrs: [] };
+    const after = { tagName: "script", id: "afterCustomScript", innerHTML: "after", attrs: [] };
+    const control = { tagName: "div", id: "control", attrs: [], type: 1 };
+    const existing = [style, toolbar, template, control, before, { tagName: "script", id: "customScript", innerHTML: "old", attrs: [] }, after];
+    const updated = composeLayoutElements(existing, source);
+    if (JSON.stringify(updated[0]) !== JSON.stringify(style) || JSON.stringify(updated[1]) !== JSON.stringify(toolbar) || JSON.stringify(updated[2]) !== JSON.stringify(template))
+        throw new Error("existing platform sections were not preserved");
+    if (JSON.stringify(updated.find((element) => element.id === "control")) !== JSON.stringify(control))
+        throw new Error("existing control was not preserved");
+    if (updated.find((element) => element.id === "customScript")?.innerHTML !== source)
+        throw new Error("customScript was not replaced in the payload");
+}
+//# sourceMappingURL=online-js-layout.js.map

package/dist/online-js-source.js

@@ -0,0 +1,276 @@
+import { ToolRefusalError } from "./tool-types.js";
+/**
+ * The platform's default Online-JS scaffold — the exact body the CloudPivot
+ * form designer shows in the Online Editor (cpdocs
+ * `form-online-js/references/default-lifecycle-8.5.x.js`, matched against the
+ * live editor 2026-09-17). The runtime invokes this as a function and supplies
+ * `form`; that is why every registration must live INSIDE the wrapper.
+ *
+ * History: `onlinejs.compose` used to write `source` verbatim as the whole
+ * customScript. A caller who supplied a bare `form.on('onRendered', ...)`
+ * (or, worse, `export function …`) produced a script with no wrapper and no
+ * `form` in scope — the form page then rendered BLANK. The default form is
+ * validly EMPTY (live: a freshly published form stores customScript == ""), so
+ * the fix is to seed this scaffold and merge the caller's code into it, never
+ * to replace it.
+ */
+export const PLATFORM_LIFECYCLE_WRAPPER_MARKER = "(function(form)";
+export const PLATFORM_DEFAULT_LIFECYCLE_SCRIPT = `/**
+ * 用户自定义JS区域;
+ * 注：外部链接的JS统一放置在HTML中，原有script标签下的js统一放置在当前编码区域
+ * 使用环境变量，可通过"$env("唤醒提示框，并通过$env(分类名称.变量名称)的方式使用
+ */
+(function(form){
+    /**
+     * 事件绑定，form.on
+     * @param eventType 事件类型
+     * @params function 事件
+     * @param  cover    true, false 是否覆盖root的生命周期 默认不覆盖 
+     */
+    //数据加载后，渲染之前，this为window
+    form.on('onLoad',function(data, dataPermission){},'cover');
+    //渲染完成后
+    form.on('onRendered',function(data){});
+    //内置校验完成后，返回false阻止提交
+    form.on('onValidate',function(action,data){});
+    //操作前（包含自定义按钮）执行，返回false阻止按钮操作
+    form.on('onPreAction',function(action,data){});
+    //自定义按钮执行
+    form.on('onCustomAction',function(action,data){});
+    //操作完成后执行
+    form.on('onActionDone',function(action,data,httpRes){});
+    //表单字段打印数据格式扩展，可自行定义调用打印模板时，表单字段对应所打印数据的内容
+    form.on('onPrintFormDataHandle',function(vm, printData, sourceData, formValues, key, locale, printTemplateCode, control, dataType, sheetData){});
+    //流程日志打印数据格式扩展，可自行定义调用打印模板时，流程日志对应所打印数据的内容
+    form.on('onPrintWorkflowLogDataHandle',function(vm, sourceData, printData, locale, printTemplateCode){});
+})`;
+/** The lifecycle events the platform dispatches; anything else is a typo the runtime silently drops (or throws on). */
+export const ONLINE_JS_EVENTS = new Set([
+    "onLoad",
+    "onRendered",
+    "onValidate",
+    "onPreAction",
+    "onCustomAction",
+    "onActionDone",
+    "onPrintFormDataHandle",
+    "onPrintWorkflowLogDataHandle",
+]);
+const WRAPPER_OPEN = /\(\s*function\s*\(\s*form\s*\)/;
+const WRAPPER_CLOSE = "})";
+const EVENT_AT = /form\.on\(\s*['"]([^'"]+)['"]/g;
+/** True when the script already carries the platform's `(function(form){ … })` scaffold. */
+export function hasLifecycleWrapper(script) {
+    return WRAPPER_OPEN.test(script) && /\}\s*\)\s*;?\s*$/.test(script);
+}
+/**
+ * Refuse a source that cannot run in the form's script slot BEFORE any wire
+ * call — the exact class of mistake that blanked the form:
+ *  - `export` / `import`: the slot is not an ES module, so a top-level
+ *    `export function` is a SyntaxError that kills the whole form render;
+ *  - an unknown `form.on('<event>', …)`: the event never fires (or throws).
+ */
+/** The platform's lifecycle names; a `form.<name>(…)` CALL (not `form.on('<name>')`) is a fatal typo. */
+const LIFECYCLE_CALL = /\bform\.(onLoad|onRendered|onValidate|onPreAction|onCustomAction|onActionDone|onPrintFormDataHandle|onPrintWorkflowLogDataHandle)\s*\(/;
+/** Strip `//` line comments and `/* … *\/` blocks so a scan does not trip on prose. */
+function stripComments(source) {
+    return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+export function lintOnlineJsSource(source) {
+    const esm = source.match(/^\s*(export|import)\b/m);
+    if (esm !== null)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "onlinejs-source-invalid",
+            message: `在线 JS 脚本槽不是 ES 模块，顶层 \`${esm[1]}\` 会让整个表单渲染失败（SyntaxError）。请改为平台生命周期形式：form.on('onLoad', function(data, dataPermission){…})；脚本必须位于 (function(form){ … }) 模板内`,
+        });
+    for (const match of source.matchAll(EVENT_AT)) {
+        const event = match[1];
+        if (!ONLINE_JS_EVENTS.has(event))
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "onlinejs-source-invalid",
+                message: `未知的在线 JS 事件 form.on('${event}')。平台事件：${[...ONLINE_JS_EVENTS].join(" / ")}。常见误用：beforeSubmit → 应为 onValidate；submit → onPreAction/onValidate`,
+            });
+    }
+    // Live 2026-09-24 (bench36): `form.onLoad(fn)` is NOT an API — the platform
+    // exposes `form.on('<name>', fn[, cover])` for registration and calls a
+    // top-level `function <name>(form){}` for the lifecycle. Calling
+    // `form.<name>(…)` throws inside the custom-script IIFE, so the ENTIRE portal
+    // form fails to load and renders as /shared/empty. Refuse it before any wire.
+    const lifecycleCall = stripComments(source).match(LIFECYCLE_CALL);
+    if (lifecycleCall !== null)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "onlinejs-source-invalid",
+            message: `form.${lifecycleCall[1]}(...) 不是平台 API，调用会在自定义脚本里抛错、让整个表单渲染成空白页（复现 bench36）。注册生命周期用 form.on('${lifecycleCall[1]}', function(…){}[, 'cover'])，或写顶层 function ${lifecycleCall[1]}(form){ … }`,
+        });
+}
+/**
+ * Index just past the `)` matching the `(` at `openIndex`, skipping string
+ * literals (single/double/backtick) and line comments so a `)` inside a string
+ * or a `//` does not unbalance the scan.
+ */
+function matchingParenEnd(text, openIndex) {
+    let depth = 0;
+    let quote = null;
+    for (let i = openIndex; i < text.length; i += 1) {
+        const ch = text[i];
+        if (quote !== null) {
+            if (ch === "\\") {
+                i += 1;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"' || ch === "`") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "/" && text[i + 1] === "/") {
+            const newline = text.indexOf("\n", i);
+            if (newline < 0)
+                return text.length;
+            i = newline;
+            continue;
+        }
+        if (ch === "(")
+            depth += 1;
+        else if (ch === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    return text.length;
+}
+/** Split source into top-level `form.on(...)` registrations plus any residual raw code. */
+function splitRegistrations(source) {
+    const blocks = [];
+    let cursor = 0;
+    let searchFrom = 0;
+    const pattern = /form\.on\(/g;
+    for (;;) {
+        pattern.lastIndex = searchFrom;
+        const match = pattern.exec(source);
+        if (match === null)
+            break;
+        const openParen = match.index + "form.on".length;
+        const end = matchingParenEnd(source, openParen);
+        let stop = end;
+        while (stop < source.length && /[;\s]/.test(source[stop]))
+            stop += 1;
+        const lead = source.slice(cursor, match.index);
+        if (lead.trim() !== "")
+            blocks.push({ event: null, text: lead.trim() });
+        const eventMatch = /^form\.on\(\s*['"]([^'"]+)['"]/.exec(source.slice(match.index, end));
+        blocks.push({ event: eventMatch?.[1] ?? null, text: source.slice(match.index, stop).trim() });
+        cursor = stop;
+        searchFrom = stop;
+    }
+    const tail = source.slice(cursor);
+    if (tail.trim() !== "")
+        blocks.push({ event: null, text: tail.trim() });
+    return blocks;
+}
+/** Remove every top-level `form.on('<event>', …)` registration from `script`. */
+function removeRegistration(script, event) {
+    let result = script;
+    for (;;) {
+        const match = new RegExp(`form\\.on\\(\\s*['"]${event.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`).exec(result);
+        if (match === null)
+            return result;
+        const openParen = match.index + "form.on".length;
+        const end = matchingParenEnd(result, openParen);
+        let stop = end;
+        while (stop < result.length && /[;\s]/.test(result[stop]))
+            stop += 1;
+        result = result.slice(0, match.index) + result.slice(stop);
+    }
+}
+/** Insert `body` at the end of the `(function(form){ … })` body, before its closing `})`. */
+function insertIntoLifecycleBody(script, body) {
+    const marker = script.lastIndexOf(WRAPPER_CLOSE);
+    return `${script.slice(0, marker).trimEnd()}\n\n${body}\n${script.slice(marker)}`;
+}
+/** Seed the platform scaffold and place `body` inside it. */
+function wrapInLifecycle(body) {
+    return insertIntoLifecycleBody(PLATFORM_DEFAULT_LIFECYCLE_SCRIPT, body);
+}
+/**
+ * Build the customScript the platform stores.
+ *
+ * mode "merge" (default) is the INCREMENTAL write:
+ *  - a `.on('<event>', …)` registration in `source` SUPERSEDES the script's
+ *    existing registration for that same event (including the platform's empty
+ *    default stub), so re-running updates that event instead of stacking a
+ *    duplicate — this is what a human does when they fill in the editor's stub;
+ *  - anything else in `source` is appended inside the lifecycle body;
+ *  - an empty existing script (the platform default) is seeded with the
+ *    platform scaffold first, and a wrapper-less existing script is wrapped.
+ *
+ * mode "replace" is the explicit escape hatch: `source` IS the script.
+ */
+export function composeCustomScript(existing, incoming, mode) {
+    lintOnlineJsSource(incoming);
+    if (mode === "replace") {
+        if (!hasLifecycleWrapper(incoming))
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "onlinejs-source-invalid",
+                message: "replace 模式必须传入完整的 (function(form){…}) 脚本，不能以裸代码覆盖平台生命周期模板",
+            });
+        return incoming;
+    }
+    const trimmedExisting = existing.trim();
+    // A caller-supplied complete wrapper cannot be merged into an existing script
+    // without nesting wrappers and silently dropping one side — require the
+    // explicit replace intent instead of guessing.
+    if (hasLifecycleWrapper(incoming))
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "onlinejs-source-invalid",
+            message: "merge 模式下传入的是完整的 (function(form){…}) 脚本——无法与既有脚本增量合并且不丢内容。若确要以它整体覆盖，请传 replace:true；若只想追加逻辑，请只传要加入生命周期内的代码片段",
+        });
+    if (trimmedExisting === "") {
+        let base = PLATFORM_DEFAULT_LIFECYCLE_SCRIPT;
+        for (const block of splitRegistrations(incoming)) {
+            if (block.event !== null)
+                base = removeRegistration(base, block.event);
+            base = insertIntoLifecycleBody(base, block.text);
+        }
+        return base;
+    }
+    // Merge into a lifecycle body: seed one when the existing script has none.
+    let base = hasLifecycleWrapper(trimmedExisting) ? existing : wrapInLifecycle(existing);
+    for (const block of splitRegistrations(incoming)) {
+        if (block.event !== null)
+            base = removeRegistration(base, block.event);
+        base = insertIntoLifecycleBody(base, block.text);
+    }
+    return base;
+}
+export function assertPlatformOnlineJsComposition() {
+    const source = "form.on('onLoad', function(){});";
+    const composed = composeCustomScript("", source, "merge");
+    if (!hasLifecycleWrapper(composed))
+        throw new Error("composition must retain the platform lifecycle wrapper");
+    if (!composed.includes(source))
+        throw new Error("composition must retain the caller registration");
+    const updated = composeCustomScript(composed, "form.on('onLoad', function(){ updated(); });", "merge");
+    if (updated.includes(source))
+        throw new Error("incremental composition must supersede the existing event registration");
+    if (!updated.includes("form.on('onLoad', function(){ updated(); });"))
+        throw new Error("incremental composition must retain the replacement registration");
+    let refused = false;
+    try {
+        composeCustomScript("", source, "replace");
+    }
+    catch {
+        refused = true;
+    }
+    if (!refused)
+        throw new Error("replace composition must refuse a wrapper-less script");
+}
+//# sourceMappingURL=online-js-source.js.map

package/dist/package-tool.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { capabilityArg, confirmProductionArg, environmentArg, WRITE_PROTOCOL } from "./args.js";
+import { executePackage } from "./package.js";
+import { plannableArgs } from "./plan.js";
+import { writeSummary } from "./human-summary.js";
+import { defineTool } from "./tool-types.js";
+/**
+ * Shared package construction for high-level write tools (`configure_model`,
+ * `configure_form`, `configure_rule`, and the batch entry `apply_changes`).
+ * One call site builds the plan (every action runs through `plannableArgs` so
+ * the whole package participates in the fingerprint), then delegates the
+ * coverage gate, write permission gate, production confirmation, write lease,
+ * and artifact recording to `executePackage`.
+ *
+ * A preset supplies: its identity (name/lane/scope/description), its input
+ * schema (environment/confirmProduction/capability appended in canonical order),
+ * a `plan` derived from the real arguments, a sequential `executor` reusing
+ * the proven low-level write paths, and a `summarize` hook so the plan card
+ * (即将…) and the result (已…) come from ONE human-summary source.
+ */
+export function registerPackageTool(tools, spec) {
+    tools.push(defineTool({
+        name: spec.name,
+        layer: "high",
+        kind: "write",
+        lane: spec.lane,
+        scope: spec.scope,
+        description: `${spec.description} ${WRITE_PROTOCOL}`,
+        inputSchema: { environment: environmentArg, ...spec.inputSchema, confirmProduction: confirmProductionArg, dryRun: z.boolean().optional(), capability: capabilityArg },
+        handler: async (ctx, args, self) => {
+            spec.preflight?.(args);
+            const planned = spec.plan(args);
+            const plan = {
+                environment: "",
+                environmentFingerprint: "",
+                summary: planned.summary,
+                actions: planned.actions.map((action) => ({ tool: action.tool, args: plannableArgs(action.tool, action.args) })),
+            };
+            return executePackage(ctx, plan, { lane: spec.lane, scope: spec.scope }, args, async (session) => {
+                const outcome = await spec.execute(session, args);
+                const summary = spec.summarize ? spec.summarize(args, outcome, "done") : undefined;
+                return summary === undefined ? outcome : { ...outcome, summary };
+            });
+        },
+    }));
+}
+/** Convenience: a preset's human summary from the shared source (single import site). */
+export function packageSummary(tool, args, phase) {
+    return writeSummary(tool, args, undefined, phase);
+}
+//# sourceMappingURL=package-tool.js.map

package/dist/package.js

@@ -0,0 +1,73 @@
+import { randomUUID } from "node:crypto";
+import { planFingerprint } from "./plan.js";
+import { admitGovernedWrite } from "./governed-execution.js";
+import { sha256, writeArtifact } from "./support.js";
+export function isPackageStopOutcome(outcome) {
+    return (typeof outcome === "object" &&
+        outcome !== null &&
+        outcome.status !== undefined &&
+        Array.isArray(outcome.steps) &&
+        typeof outcome.failedStep === "object");
+}
+/** Shared high-level execution: admission gate + lease + artifacts + delivery state. */
+export async function executePackage(ctx, plan, coverage, args, execute) {
+    const claims = "perAction" in coverage
+        ? coverage.perAction.map((claim) => ({ lane: claim.lane, scope: claim.scope }))
+        : [{ lane: args.capability ?? coverage.lane, scope: coverage.scope }];
+    const outcome = await admitGovernedWrite(ctx, {
+        environment: args.environment,
+        confirmProduction: args.confirmProduction,
+        dryRun: args.dryRun,
+        capability: args.capability,
+        coverage: claims,
+        plan: () => plan,
+        // A package dry-run is a TRUE preview: the environment is resolved and the
+        // exact plan is rendered, but nothing executes.
+        dryRunResult: (boundPlan) => ({
+            status: "dry-run",
+            wouldChange: true,
+            plan: boundPlan,
+            planFingerprint: planFingerprint(boundPlan),
+            ...(typeof args.requestId === "string" ? { requestId: args.requestId } : {}),
+        }),
+    });
+    if (outcome.kind === "settled")
+        return outcome.result;
+    const { session, plan: boundPlan, productionConfirmed } = outcome.admission;
+    return ctx.lease.run(session.environmentName, `${plan.actions[0]?.tool ?? "package"}:${randomUUID().slice(0, 8)}`, async () => {
+        const executed = await execute(session);
+        if (isPackageStopOutcome(executed)) {
+            // A stopped batch is never DELIVERED: report the completed steps, the
+            // failed step, and its envelope; the artifact records the stop for audit.
+            const artifact = {
+                plan: boundPlan,
+                steps: executed.steps,
+                failedStep: executed.failedStep,
+                stop: executed.envelope,
+                ...(productionConfirmed ? { productionConfirmed: true } : {}),
+                deliveryState: "STOPPED",
+                recordedAt: new Date().toISOString(),
+            };
+            const artifactRef = writeArtifact(ctx, `package-${randomUUID().slice(0, 8)}.json`, artifact);
+            return {
+                status: executed.status,
+                steps: executed.steps,
+                failedStep: executed.failedStep,
+                ...executed.envelope,
+                artifactFingerprint: artifactRef.detailSha256,
+            };
+        }
+        const { steps, readback, summary } = executed;
+        const artifact = {
+            plan: boundPlan,
+            steps,
+            readback,
+            ...(productionConfirmed ? { productionConfirmed: true } : {}),
+            deliveryState: "DELIVERED",
+            recordedAt: new Date().toISOString(),
+        };
+        writeArtifact(ctx, `package-${randomUUID().slice(0, 8)}.json`, artifact);
+        return { status: "ok", deliveryState: "DELIVERED", steps, readback, ...(productionConfirmed ? { productionConfirmed: true } : {}), ...(summary !== undefined ? { summary } : {}), artifactFingerprint: sha256(artifact) };
+    });
+}
+//# sourceMappingURL=package.js.map

package/dist/plan.js

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+import { writeSummary } from "./human-summary.js";
+import { sha256, summarizeValue } from "./support.js";
+import { environmentNotice } from "./environment-policy.js";
+function canonical(value) {
+    return JSON.stringify(sort(value));
+}
+function sort(value) {
+    if (Array.isArray(value))
+        return value.map(sort);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => [k, sort(v)]));
+    return value;
+}
+/** A stable fingerprint of the plan, recorded in audit artifacts so a run can be identified. */
+export function planFingerprint(plan) {
+    return createHash("sha256")
+        .update(canonical({
+        environment: plan.environment,
+        environmentFingerprint: plan.environmentFingerprint,
+        actions: plan.actions.map((action) => ({ tool: action.tool, args: sort(action.args) })),
+    }))
+        .digest("hex");
+}
+function summarizedArgs(tool, args) {
+    if (typeof args.summary === "string" && typeof args.fingerprint === "string")
+        return { ...args };
+    const summary = { summary: tool };
+    for (const [key, value] of Object.entries(args)) {
+        if (key === "environment" || key === "full")
+            continue;
+        if (["schemaCode", "sheetCode", "applicationCode", "modelCode", "fieldCode", "code", "id", "ruleCode", "workflowCode", "workflowInstanceId", "workItemId", "bizObjectId", "name"].includes(key)) {
+            summary[key] = summarizeValue(value);
+        }
+        else if (Array.isArray(value) || (value && typeof value === "object") || typeof value === "string") {
+            summary[`${key}Summary`] = summarizeValue(value);
+        }
+        else {
+            summary[key] = value;
+        }
+    }
+    summary.fingerprint = sha256(summary);
+    return summary;
+}
+/** The raw plan-relevant args: everything except secrets/environment/full. */
+export function plannableArgsRaw(args) {
+    const clone = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (key === "environment" || key === "full")
+            continue;
+        clone[key] = value;
+    }
+    return clone;
+}
+export function plannableArgs(tool, args) {
+    return summarizedArgs(tool, args);
+}
+export async function planFor(ctx, environment, tool, args) {
+    const session = await ctx.sessions.session(environment);
+    // The preview reads as a Chinese sentence produced by the SAME source as the
+    // result summary (即将… / 已…), from the real arguments.
+    const summary = writeSummary(tool, args, undefined, "plan");
+    return {
+        environment: session.environmentName,
+        environmentFingerprint: session.environmentFingerprint(),
+        summary,
+        environmentNotice: environmentNotice(ctx.sessions.config().resolveEnvironment(environment).profile),
+        actions: [{ tool, args: summarizedArgs(tool, args) }],
+    };
+}
+//# sourceMappingURL=plan.js.map