@actiondock/core 2.10.0 → 2.12.0

package/dist/runtime/run-persistence.js

@@ -3,7 +3,7 @@ import { ActionDockError, RUN_PERSISTENCE_FAILED, RUN_REPOSITORY_UNAVAILABLE } f
  * 构建运行初始记录（RunRecord 组装单一事实源）。
  */
 export function buildInitialRunRecord(params, status, error) {
-    const { runId, rootRunId, parentRunId, ownerId, hostSessionId, packageInstanceId, generationId, targetPackageId, targetActionId, startedAt, input, runnerPackageId, runnerPackageInstanceId, runnerGenerationId, runnerHostSessionId, } = params;
+    const { runId, rootRunId, parentRunId, ownerId, hostSessionId, hostPid, packageInstanceId, generationId, targetPackageId, targetActionId, startedAt, input, runnerPackageId, runnerPackageInstanceId, runnerGenerationId, runnerHostSessionId, } = params;
     const record = {
         id: runId,
         rootRunId,
@@ -14,6 +14,7 @@ export function buildInitialRunRecord(params, status, error) {
         generationId: generationId || (runnerPackageId === targetPackageId ? runnerGenerationId : "1"),
         ownerId: ownerId || "local",
         hostSessionId: hostSessionId || runnerHostSessionId,
+        hostPid,
         status,
         error,
         startedAt,

package/dist/runtime/standalone-commands.d.ts

@@ -0,0 +1,18 @@
+import type { ActionDockService } from "../service/types.js";
+import { type StandaloneDispatcherOptions } from "./standalone.js";
+export interface CommandContext {
+    service: ActionDockService;
+    options: StandaloneDispatcherOptions;
+    writeOut: (msg: string) => void;
+    writeErr: (msg: string) => void;
+    emitError: (isJson: boolean, code: string, message: string, exitCode: number, options?: {
+        textMessage?: string;
+        details?: unknown;
+        hint?: string;
+    }) => number;
+}
+export declare function handleList(ctx: CommandContext, subArgs: string[]): Promise<number>;
+export declare function handleDescribe(ctx: CommandContext, subArgs: string[]): Promise<number>;
+export declare function handleRun(ctx: CommandContext, subArgs: string[], actionArgs: string[], signal?: AbortSignal): Promise<number>;
+export declare function handleConfig(ctx: CommandContext, subArgs: string[]): Promise<number>;
+export declare function handleState(ctx: CommandContext, subArgs: string[]): Promise<number>;

package/dist/runtime/standalone-commands.js

@@ -0,0 +1,466 @@
+import { decodeStateKey } from "@actiondock/sdk";
+import { filterWithFallbackInfo } from "../utils/intent.js";
+import { resolveExecutionHint } from "../errors.js";
+import { resolveActionInput, formatActionDetail, buildActionDescribePayload, mapInputValidationFailure, } from "../input/index.js";
+import { validateActionInputValue } from "../value-validator.js";
+import { parseDuration } from "../utils/index.js";
+import { ExitCode } from "./standalone.js";
+export async function handleList(ctx, subArgs) {
+    const isJson = subArgs.includes("--json");
+    const noFallback = subArgs.includes("--no-fallback");
+    let intent;
+    const positionalPatterns = [];
+    for (let i = 0; i < subArgs.length; i++) {
+        const arg = subArgs[i];
+        if (arg === "--intent" || arg === "-i") {
+            if (i + 1 < subArgs.length)
+                intent = subArgs[++i];
+        }
+        else if (arg.startsWith("--intent=")) {
+            intent = arg.slice(9);
+        }
+        else if (arg.startsWith("-i=")) {
+            intent = arg.slice(3);
+        }
+        else if (!arg.startsWith("-")) {
+            positionalPatterns.push(arg);
+        }
+    }
+    const effectiveIntent = intent || (positionalPatterns.length > 0 ? positionalPatterns.join("|") : undefined);
+    const actions = await ctx.service.discovery.listActions();
+    const list = actions.map((a) => ({
+        id: a.id,
+        description: a.description || "",
+    }));
+    const filterRes = filterWithFallbackInfo(list, effectiveIntent, [(a) => a.id, (a) => a.description], !noFallback);
+    const hints = [
+        "Tip: For composite or multi-step tasks, check 'ad playbook list' for standard operating procedures.",
+    ];
+    if (isJson) {
+        ctx.writeOut(JSON.stringify({ items: filterRes.items, hints }, null, 2));
+    }
+    else {
+        let text = `Actions in ${ctx.options.packageId} (v${ctx.options.version}):\n\n`;
+        for (const a of filterRes.items) {
+            text += `  ${a.id.padEnd(28)} ${a.description}\n`;
+        }
+        ctx.writeOut(text.trimEnd());
+    }
+    return ExitCode.SUCCESS;
+}
+export async function handleDescribe(ctx, subArgs) {
+    const id = subArgs.find((a) => !a.startsWith("-"));
+    const isJson = subArgs.includes("--json");
+    if (!id) {
+        return ctx.emitError(isJson, "INVALID_ARGUMENT", "Action ID is required for describe", ExitCode.INVALID_ARGUMENT);
+    }
+    let action;
+    try {
+        action = await ctx.service.discovery.describeAction(id);
+    }
+    catch {
+        const hint = "Tip: Run 'ad list' to discover available actions.";
+        return ctx.emitError(isJson, "INVALID_ARGUMENT", `Action '${id}' not found`, ExitCode.INVALID_ARGUMENT, {
+            textMessage: `Error: Action '${id}' not found\n${hint}`,
+            hint,
+        });
+    }
+    const payload = buildActionDescribePayload(action, {
+        packageId: ctx.options.packageId,
+    });
+    if (isJson) {
+        ctx.writeOut(JSON.stringify(payload, null, 2));
+    }
+    else {
+        ctx.writeOut(formatActionDetail(payload));
+    }
+    return ExitCode.SUCCESS;
+}
+export async function handleRun(ctx, subArgs, actionArgs, signal) {
+    const isJson = subArgs.includes("--json");
+    const id = subArgs.find((a) => !a.startsWith("-"));
+    if (!id) {
+        return ctx.emitError(isJson, "INVALID_ARGUMENT", "Error: Action ID is required for run", ExitCode.INVALID_ARGUMENT, { textMessage: "Error: Action ID is required for run" });
+    }
+    let inputStr;
+    let inputFile;
+    let timeoutMs;
+    const recognizedFlags = new Set(["--json", "--async"]);
+    for (let i = 0; i < subArgs.length; i++) {
+        const arg = subArgs[i];
+        if (arg === id || recognizedFlags.has(arg)) {
+            continue;
+        }
+        if (arg === "--timeout" && i + 1 < subArgs.length) {
+            try {
+                timeoutMs = parseDuration(subArgs[++i]);
+            }
+            catch (err) {
+                return ctx.emitError(isJson, "INVALID_ARGUMENT", `Invalid timeout format: ${err?.message || err}`, ExitCode.INVALID_ARGUMENT);
+            }
+        }
+        else if (arg.startsWith("--timeout=")) {
+            try {
+                timeoutMs = parseDuration(arg.slice(10));
+            }
+            catch (err) {
+                return ctx.emitError(isJson, "INVALID_ARGUMENT", `Invalid timeout format: ${err?.message || err}`, ExitCode.INVALID_ARGUMENT);
+            }
+        }
+        else if (arg === "--input" && i + 1 < subArgs.length) {
+            inputStr = subArgs[++i];
+        }
+        else if (arg.startsWith("--input=")) {
+            inputStr = arg.slice(8);
+        }
+        else if (arg === "-i" && i + 1 < subArgs.length) {
+            inputStr = subArgs[++i];
+        }
+        else if (arg.startsWith("-i=")) {
+            inputStr = arg.slice(3);
+        }
+        else if (arg === "--input-file" && i + 1 < subArgs.length) {
+            inputFile = subArgs[++i];
+        }
+        else if (arg.startsWith("--input-file=")) {
+            inputFile = arg.slice(13);
+        }
+        else if (arg === "-f" && i + 1 < subArgs.length) {
+            inputFile = subArgs[++i];
+        }
+        else if (arg.startsWith("-f=")) {
+            inputFile = arg.slice(3);
+        }
+        else if (arg.startsWith("-")) {
+            const hint = "Hint: Separate action inputs from CLI options using '--', e.g.: ad run <id> [options] -- <param>=<val> or <param>:=<json>.";
+            return ctx.emitError(isJson, "INVALID_ARGUMENT", `error: unknown option '${arg}'`, ExitCode.INVALID_ARGUMENT, {
+                textMessage: `error: unknown option '${arg}'\n${hint}`,
+                hint,
+            });
+        }
+    }
+    let input;
+    try {
+        input = await resolveActionInput({
+            input: inputStr,
+            inputFile,
+            flatArgs: actionArgs.length > 0 ? actionArgs : undefined,
+            stdin: process.stdin,
+        });
+        const check = validateActionInputValue(input);
+        if (!check.valid) {
+            throw mapInputValidationFailure("cli-pre-target", check);
+        }
+    }
+    catch (err) {
+        return ctx.emitError(isJson, err?.code || "INVALID_ARGUMENT", err?.message || String(err), ExitCode.INVALID_ARGUMENT, {
+            details: err?.details,
+        });
+    }
+    const result = await ctx.service.execution.run(id, input, {
+        signal,
+        timeoutMs,
+    });
+    if (isJson) {
+        if (!result.ok) {
+            const errorObj = result.error;
+            const hint = resolveExecutionHint(id, errorObj);
+            const machineOutput = hint !== undefined ? { ...result, hint } : result;
+            ctx.writeOut(JSON.stringify(machineOutput, null, 2));
+        }
+        else {
+            ctx.writeOut(JSON.stringify(result, null, 2));
+        }
+    }
+    else {
+        if (result.ok) {
+            const data = result.data;
+            let rawText;
+            let metaInfo;
+            if (typeof data === "string") {
+                rawText = data;
+            }
+            else if (data !== null && typeof data === "object") {
+                if ("content" in data && data.content !== undefined) {
+                    rawText =
+                        typeof data.content === "object" && data.content !== null
+                            ? JSON.stringify(data.content, null, 2)
+                            : String(data.content);
+                    const { content, ...rest } = data;
+                    if (Object.keys(rest).length > 0) {
+                        metaInfo = rest;
+                    }
+                }
+                else if ("text" in data && typeof data.text === "string") {
+                    rawText = data.text;
+                    const { text, ...rest } = data;
+                    if (Object.keys(rest).length > 0) {
+                        metaInfo = rest;
+                    }
+                }
+                else if ("message" in data && typeof data.message === "string") {
+                    rawText = data.message;
+                    const { message, ...rest } = data;
+                    if (Object.keys(rest).length > 0) {
+                        metaInfo = rest;
+                    }
+                }
+                else {
+                    rawText = JSON.stringify(data, null, 2);
+                }
+            }
+            else if (data !== undefined) {
+                rawText = String(data);
+            }
+            else {
+                rawText = "";
+            }
+            if (metaInfo) {
+                const parts = [];
+                const title = metaInfo.path ? String(metaInfo.path) : id;
+                parts.push(title);
+                if (metaInfo.startLine !== undefined && metaInfo.endLine !== undefined) {
+                    parts.push(`lines ${metaInfo.startLine}-${metaInfo.endLine}`);
+                }
+                else if (metaInfo.line !== undefined) {
+                    parts.push(`line ${metaInfo.line}`);
+                }
+                if (metaInfo.hasMore !== undefined) {
+                    parts.push(`hasMore: ${metaInfo.hasMore}`);
+                }
+                if (metaInfo.truncated) {
+                    parts.push("truncated: true");
+                }
+                const handled = new Set(["path", "startLine", "endLine", "line", "hasMore", "truncated"]);
+                for (const [k, v] of Object.entries(metaInfo)) {
+                    if (!handled.has(k) && v !== undefined) {
+                        parts.push(`${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`);
+                    }
+                }
+                if (parts.length > 0) {
+                    ctx.writeErr(`[${parts.join(" | ")}]`);
+                }
+            }
+            ctx.writeOut(rawText);
+        }
+        else {
+            const errorObj = result.error;
+            ctx.writeErr(`Error [${errorObj.code}]: ${errorObj.message}`);
+            if (errorObj.details) {
+                ctx.writeErr(typeof errorObj.details === "string"
+                    ? errorObj.details
+                    : JSON.stringify(errorObj.details, null, 2));
+            }
+            const hint = resolveExecutionHint(id, errorObj);
+            if (hint) {
+                ctx.writeErr(hint);
+            }
+        }
+    }
+    return result.ok ? ExitCode.SUCCESS : ExitCode.FAILURE;
+}
+function isServiceCapabilityError(err) {
+    const code = String(err?.code || "");
+    return (code === "CAPABILITY_UNAVAILABLE" ||
+        code === "TARGET_CAPABILITY_UNAVAILABLE");
+}
+export async function handleConfig(ctx, subArgs) {
+    const sub = subArgs[0] || "list";
+    if (!ctx.service.management) {
+        ctx.writeErr("Error: management port is not enabled on this service");
+        return ExitCode.FAILURE;
+    }
+    if (sub === "list") {
+        const views = await ctx.service.management.config.list(ctx.options.packageId);
+        const dict = {};
+        for (const v of views) {
+            if (v.configured && v.value !== undefined) {
+                dict[v.key] = v.value;
+            }
+        }
+        ctx.writeOut(JSON.stringify(dict, null, 2));
+        return ExitCode.SUCCESS;
+    }
+    if (sub === "get") {
+        const key = subArgs[1];
+        if (!key) {
+            ctx.writeErr("Error: config key required");
+            return ExitCode.INVALID_ARGUMENT;
+        }
+        try {
+            const item = await ctx.service.management.config.get(ctx.options.packageId, key);
+            ctx.writeOut(item.configured ? JSON.stringify(item.value) : "undefined");
+            return ExitCode.SUCCESS;
+        }
+        catch (err) {
+            if (isServiceCapabilityError(err)) {
+                ctx.writeOut("undefined");
+                return ExitCode.SUCCESS;
+            }
+            ctx.writeErr(`Error reading config '${key}': ${err?.message || String(err)}`);
+            return ExitCode.FAILURE;
+        }
+    }
+    if (sub === "set") {
+        const key = subArgs[1];
+        const rawVal = subArgs[2];
+        if (!key || rawVal === undefined) {
+            ctx.writeErr("Error: key and value required");
+            return ExitCode.INVALID_ARGUMENT;
+        }
+        let parsed = rawVal;
+        try {
+            parsed = JSON.parse(rawVal);
+        }
+        catch {
+            parsed = rawVal;
+        }
+        await ctx.service.management.config.set(ctx.options.packageId, key, parsed);
+        ctx.writeOut(`Config '${key}' updated`);
+        return ExitCode.SUCCESS;
+    }
+    if (sub === "delete") {
+        const key = subArgs[1];
+        if (!key) {
+            ctx.writeErr("Error: config key required");
+            return ExitCode.INVALID_ARGUMENT;
+        }
+        await ctx.service.management.config.delete(ctx.options.packageId, key);
+        ctx.writeOut(`Config '${key}' deleted`);
+        return ExitCode.SUCCESS;
+    }
+    ctx.writeErr(`Unknown config subcommand: '${sub}'`);
+    return ExitCode.INVALID_ARGUMENT;
+}
+function decodeStateKeyArg(key) {
+    try {
+        return decodeStateKey(key);
+    }
+    catch {
+        return { namespace: "", key };
+    }
+}
+export async function handleState(ctx, subArgs) {
+    const sub = subArgs[0] || "list";
+    let namespace;
+    let isAll = false;
+    let isJson = false;
+    if (!ctx.service.management) {
+        ctx.writeErr("Error: management port is not enabled on this service");
+        return ExitCode.FAILURE;
+    }
+    for (let i = 1; i < subArgs.length; i++) {
+        if ((subArgs[i] === "-n" || subArgs[i] === "--namespace") && i + 1 < subArgs.length) {
+            namespace = subArgs[++i];
+        }
+        else if (subArgs[i].startsWith("--namespace=")) {
+            namespace = subArgs[i].slice(12);
+        }
+        else if (subArgs[i] === "-a" || subArgs[i] === "--all") {
+            isAll = true;
+        }
+        else if (subArgs[i] === "--json") {
+            isJson = true;
+        }
+    }
+    if (sub === "list") {
+        const prefix = subArgs[1] && !subArgs[1].startsWith("-") ? subArgs[1] : "";
+        const keys = await ctx.service.management.state.list(ctx.options.packageId, "", {
+            namespace: (namespace !== undefined ? namespace : null),
+            prefix: prefix || undefined,
+            all: isAll,
+        });
+        ctx.writeOut(JSON.stringify(keys, null, 2));
+        return ExitCode.SUCCESS;
+    }
+    if (sub === "get") {
+        const key = subArgs[1] && !subArgs[1].startsWith("-") ? subArgs[1] : subArgs[2];
+        if (!key) {
+            ctx.writeErr("Error: state key required");
+            return ExitCode.INVALID_ARGUMENT;
+        }
+        let ns = namespace;
+        let actualKey = key;
+        if (ns === undefined) {
+            const decoded = decodeStateKeyArg(key);
+            ns = decoded.namespace || undefined;
+            actualKey = decoded.key;
+        }
+        const val = await ctx.service.management.state.get(ctx.options.packageId, "", actualKey, { namespace: ns });
+        if (isJson) {
+            ctx.writeOut(JSON.stringify({ key, value: val }, null, 2));
+        }
+        else {
+            ctx.writeOut(val !== undefined ? JSON.stringify(val) : "undefined");
+        }
+        return ExitCode.SUCCESS;
+    }
+    if (sub === "set") {
+        const key = subArgs[1];
+        const rawVal = subArgs[2];
+        if (!key || rawVal === undefined) {
+            ctx.writeErr("Error: key and value required");
+            return ExitCode.INVALID_ARGUMENT;
+        }
+        let ns = namespace || "";
+        let actualKey = key;
+        if (namespace === undefined) {
+            const decoded = decodeStateKeyArg(key);
+            ns = decoded.namespace;
+            actualKey = decoded.key;
+        }
+        let parsed = rawVal;
+        try {
+            parsed = JSON.parse(rawVal);
+        }
+        catch {
+            parsed = rawVal;
+        }
+        let ttl;
+        for (let i = 3; i < subArgs.length; i++) {
+            if (subArgs[i] === "--ttl" && i + 1 < subArgs.length) {
+                ttl = parseInt(subArgs[++i], 10);
+            }
+            else if (subArgs[i].startsWith("--ttl=")) {
+                ttl = parseInt(subArgs[i].slice(6), 10);
+            }
+        }
+        await ctx.service.management.state.set(ctx.options.packageId, "", actualKey, parsed, { namespace: ns, ttl });
+        const displayKey = ns ? `${ns}:${actualKey}` : actualKey;
+        ctx.writeOut(`State '${displayKey}' updated`);
+        return ExitCode.SUCCESS;
+    }
+    if (sub === "delete" || sub === "rm") {
+        const key = subArgs[1] && !subArgs[1].startsWith("-") ? subArgs[1] : subArgs[2];
+        if (!key) {
+            ctx.writeErr("Error: state key required");
+            return ExitCode.INVALID_ARGUMENT;
+        }
+        let ns = namespace;
+        let actualKey = key;
+        if (ns === undefined) {
+            const decoded = decodeStateKeyArg(key);
+            ns = decoded.namespace || undefined;
+            actualKey = decoded.key;
+        }
+        const deleted = await ctx.service.management.state.delete(ctx.options.packageId, "", actualKey, { namespace: ns });
+        if (deleted) {
+            ctx.writeOut(`State '${key}' deleted`);
+            return ExitCode.SUCCESS;
+        }
+        ctx.writeErr(`Error: State key '${key}' not found`);
+        return ExitCode.FAILURE;
+    }
+    if (sub === "clear" || sub === "clean") {
+        const prefix = subArgs[1] && !subArgs[1].startsWith("-") ? subArgs[1] : "";
+        const count = await ctx.service.management.state.clear(ctx.options.packageId, "", {
+            namespace,
+            all: isAll,
+            prefix: prefix || undefined,
+        });
+        ctx.writeOut(`Cleared ${count} state entry(s)`);
+        return ExitCode.SUCCESS;
+    }
+    ctx.writeErr(`Unknown state subcommand: '${sub}'`);
+    return ExitCode.INVALID_ARGUMENT;
+}

package/dist/runtime/standalone-help.d.ts

@@ -0,0 +1,20 @@
+export interface ParsedArgs {
+    controlArgs: string[];
+    actionArgs: string[];
+    filteredArgs: string[];
+    dataDir?: string;
+    configOverrides: Record<string, unknown>;
+    command: string;
+    subArgs: string[];
+}
+export declare function parseStandaloneArgs(argv: string[]): ParsedArgs;
+export declare function printHelp(writeOut: (msg: string) => void, options: {
+    packageId: string;
+    version: string;
+    description?: string;
+}): void;
+export declare function emitError(writeOut: (msg: string) => void, writeErr: (msg: string) => void, isJson: boolean, code: string, message: string, exitCode: number, options?: {
+    textMessage?: string;
+    details?: unknown;
+    hint?: string;
+}): number;

package/dist/runtime/standalone-help.js

@@ -0,0 +1,72 @@
+export function parseStandaloneArgs(argv) {
+    const separator = argv.indexOf("--");
+    const controlArgs = separator >= 0 ? argv.slice(0, separator) : argv;
+    const actionArgs = separator >= 0 ? argv.slice(separator + 1) : [];
+    let dataDir;
+    const configOverrides = {};
+    const filteredArgs = [];
+    for (let i = 0; i < controlArgs.length; i++) {
+        const arg = controlArgs[i];
+        if (arg === "--data-dir" && i + 1 < controlArgs.length) {
+            dataDir = controlArgs[++i];
+        }
+        else if (arg.startsWith("--data-dir=")) {
+            dataDir = arg.slice(11);
+        }
+        else if (arg === "--config" && i + 1 < controlArgs.length) {
+            const pair = controlArgs[++i];
+            const [k, ...v] = pair.split("=");
+            if (k)
+                configOverrides[k] = v.join("=");
+        }
+        else if (arg.startsWith("--config=")) {
+            const pair = arg.slice(9);
+            const [k, ...v] = pair.split("=");
+            if (k)
+                configOverrides[k] = v.join("=");
+        }
+        else {
+            filteredArgs.push(arg);
+        }
+    }
+    const command = filteredArgs[0] || "help";
+    const subArgs = filteredArgs.slice(1);
+    return { controlArgs, actionArgs, filteredArgs, dataDir, configOverrides, command, subArgs };
+}
+export function printHelp(writeOut, options) {
+    writeOut(`${options.packageId} (v${options.version})`);
+    if (options.description)
+        writeOut(`${options.description}\n`);
+    writeOut("Usage:");
+    writeOut("  <cmd> list [--json]                         List available actions");
+    writeOut("  <cmd> describe <id> [--json]                Show action details and schemas");
+    writeOut("  <cmd> run <id> [--input '<json>']           Execute action (raw text output by default)");
+    writeOut("  <cmd> run <id> [--json]                     Output standard execution result in JSON format");
+    writeOut("  <cmd> config list/get/set/delete            Manage package configuration");
+    writeOut("  <cmd> state list/get/set/delete             Manage shared state store");
+    writeOut("\nGlobal options:");
+    writeOut("  --data-dir <path>                           Custom runtime database directory");
+    writeOut("  --config <KEY=val>                          Temporary config override");
+}
+export function emitError(writeOut, writeErr, isJson, code, message, exitCode, options) {
+    if (isJson) {
+        const details = options?.details;
+        const hint = options?.hint ??
+            (details && typeof details === "object" && typeof details.hint === "string"
+                ? details.hint
+                : undefined);
+        writeOut(JSON.stringify({
+            ok: false,
+            error: {
+                code,
+                message,
+                ...(details !== undefined ? { details } : {}),
+            },
+            ...(hint !== undefined ? { hint } : {}),
+        }, null, 2));
+    }
+    else {
+        writeErr(options?.textMessage ?? `Error: ${message}`);
+    }
+    return exitCode;
+}

package/dist/runtime/standalone.d.ts

@@ -65,22 +65,9 @@ export declare class StandaloneDispatcher {
     constructor(options: StandaloneDispatcherOptions);
     private writeOut;
     private writeErr;
-    /**
-     * 统一错误输出辅助方法。
-     *
-     * JSON 模式向 stdout 输出两空格缩进的标准错误结构；
-     * 纯文本模式向 stderr 输出单行错误消息（默认携带 Error: 前缀）。
-     * 消息文本与退出码由调用方逐字给定，输出字节严格保持不变。
-     *
-     * @param isJson 是否处于 JSON 输出模式
-     * @param code 错误码
-     * @param message JSON 模式错误消息（兼作纯文本默认消息主体）
-     * @param exitCode 调用方应返回的退出状态码
-     * @param options 可选项：textMessage 覆盖纯文本消息全文；details 为 JSON 模式可选结构化详情
-     * @returns 透传 exitCode 供调用方直接返回
-     */
     private emitError;
     private createLocalService;
+    private printHelp;
     /**
      * 解析命令行参数并分发执行对应子命令。
      *
@@ -89,37 +76,7 @@ export declare class StandaloneDispatcher {
      * @returns 退出状态码（0: 成功, 1: 失败, 2: 参数错误, 130: 中断）
      */
     dispatch(argv: string[], control?: InvocationControl): Promise<number>;
-    private handleList;
-    private handleDescribe;
-    private handleRun;
-    private handleConfig;
-    private handleState;
-    /**
-     * 判定配置读取异常是否为服务能力缺失（键未配置语义）而非内部故障。
-     */
-    private isServiceCapabilityError;
-    /**
-     * 解析携带命名空间前缀的状态键参数：委托 sdk 单一事实源 decodeStateKey。
-     *
-     * 解析失败（如存在多个未转义冒号的歧义键）时按纯键处理，交由存储层兜底。
-     */
-    private decodeStateKeyArg;
-    private printHelp;
-}
-/**
- * 独立二进制可执行文件运行时（兼容门面包装）。
- */
-export interface StandaloneRuntimeOptions extends StandaloneDispatcherOptions {
-}
-export declare class StandaloneRuntime {
-    private dispatcher;
-    constructor(options: StandaloneRuntimeOptions);
-    run(argv: string[]): Promise<void>;
 }
-/**
- * 工厂函数：创建独立运行时实例。
- */
-export declare function createStandaloneRuntime(options: StandaloneRuntimeOptions): StandaloneRuntime;
 /**
  * 独立二进制进程入口适配器。
  * 仅在命令行可执行入口调用，负责全局 SIGINT 监听与退出状态码写入。