@actiondock/core 2.2.1 → 2.3.0

package/dist/profile/client.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { normalizeServerUrl } from "./manager.js";
-import { ACTION_CANCELLED, NETWORK_ERROR } from "../errors.js";
+import { ACTION_CANCELLED, ACTION_TIMEOUT, NETWORK_ERROR } from "../errors.js";
 import { isLoopbackHost } from "../server/security.js";
 /**
  * 校验在携带认证 Token 时传输层协议是否安全。
@@ -154,6 +154,9 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
     if (requestId) {
         executionPayload.requestId = requestId;
     }
+    // 组合外部取消信号与本地超时守卫：服务端僵死时仍能在 timeoutMs 内本地中断，避免永久挂起
+    let timeoutTimer;
+    let localTimedOut = false;
     try {
         const headers = {
             ...buildHeaders(token),
@@ -168,34 +171,62 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
             config: configOverrides,
             execution: Object.keys(executionPayload).length > 0 ? executionPayload : undefined,
         });
-        let res = await fetch(v2Url, {
-            method: "POST",
-            headers,
-            body: reqBody,
-            signal,
-        });
-        if (res.status === 404) {
-            try {
-                const v1Res = await fetch(`${base}/api/v1/actions/${encodeURIComponent(actionId)}/run`, {
-                    method: "POST",
-                    headers,
-                    body: reqBody,
-                    signal,
-                });
-                if (v1Res.ok || v1Res.status !== 404) {
-                    res = v1Res;
+        const controller = new AbortController();
+        const onExternalAbort = () => controller.abort(signal?.reason);
+        if (signal) {
+            if (signal.aborted) {
+                controller.abort(signal.reason);
+            }
+            else {
+                signal.addEventListener("abort", onExternalAbort, { once: true });
+            }
+        }
+        if (typeof timeoutMs === "number" && timeoutMs > 0) {
+            timeoutTimer = setTimeout(() => {
+                localTimedOut = true;
+                controller.abort();
+            }, timeoutMs);
+        }
+        let res;
+        try {
+            res = await fetch(v2Url, {
+                method: "POST",
+                headers,
+                body: reqBody,
+                signal: controller.signal,
+            });
+            if (res.status === 404) {
+                try {
+                    const v1Res = await fetch(`${base}/api/v1/actions/${encodeURIComponent(actionId)}/run`, {
+                        method: "POST",
+                        headers,
+                        body: reqBody,
+                        signal: controller.signal,
+                    });
+                    if (v1Res.ok || v1Res.status !== 404) {
+                        res = v1Res;
+                    }
                 }
+                catch { }
+            }
+        }
+        finally {
+            if (timeoutTimer !== undefined) {
+                clearTimeout(timeoutTimer);
+            }
+            if (signal) {
+                signal.removeEventListener("abort", onExternalAbort);
             }
-            catch { }
         }
         const data = (await res.json().catch(() => null));
         if (data && typeof data === "object" && typeof data.ok === "boolean") {
             return data;
         }
         if (!res.ok) {
+            // 错误信封严禁伪造 runId：与任何真实运行无关的标识会让调用方查询永远 not_found
             return {
                 ok: false,
-                runId: randomUUID(),
+                runId: "",
                 error: {
                     code: res.status === 401 ? "UNAUTHORIZED" : "REMOTE_EXECUTION_FAILED",
                     message: `Remote server HTTP ${res.status}: ${res.statusText}`,
@@ -210,10 +241,21 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
         };
     }
     catch (err) {
+        // 本地超时守卫触发时归类为超时；外部信号中止时归类为取消
+        if (localTimedOut) {
+            return {
+                ok: false,
+                runId: "",
+                error: {
+                    code: ACTION_TIMEOUT,
+                    message: `Remote execution exceeded local timeout of ${timeoutMs}ms`,
+                },
+            };
+        }
         if (err.name === "AbortError" || signal?.aborted) {
             return {
                 ok: false,
-                runId: randomUUID(),
+                runId: "",
                 error: {
                     code: ACTION_CANCELLED,
                     message: "Action execution was cancelled",
@@ -222,7 +264,7 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
         }
         return {
             ok: false,
-            runId: randomUUID(),
+            runId: "",
             error: {
                 code: NETWORK_ERROR,
                 message: `Failed to connect to remote ActionDock server at ${serverUrl}: ${err.message}`,

package/dist/project/init.js

@@ -86,10 +86,10 @@ export function initProject(targetDir, options = {}) {
             node: ">=24.12.0",
         },
         dependencies: {
-            "@actiondock/sdk": "^2.2.1",
+            "@actiondock/sdk": "^2.3.0",
         },
         devDependencies: {
-            "@actiondock/testing": "^2.2.1",
+            "@actiondock/testing": "^2.3.0",
             "@types/node": "^22.13.0",
             "tsx": "^4.19.0",
             "typescript": "^5.7.0",

package/dist/registry/registry.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from "node:fs";
 import { readFile, rename, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve, sep } from "node:path";
 import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
 import { getActionDockHome, getPackageSlug } from "../utils/index.js";
 import { withRegistryLock } from "./lock.js";
@@ -12,6 +12,13 @@ import { probeActionAsync, probeActionSync, probePlaybook, resolveEntityFlow, ru
 function emptyRegistry() {
     return { version: "2.0.0", packages: {}, workspaces: {} };
 }
+/**
+ * 判定 entryPath 是否严格位于 baseDir 目录之内（携带路径分隔符边界）。
+ * 避免裸 startsWith 前缀匹配把兄弟目录（如 /home/ws 与 /home/ws2）误判为子路径。
+ */
+function isPathWithin(entryPath, baseDir) {
+    return entryPath === baseDir || entryPath.startsWith(baseDir + sep);
+}
 /**
  * 注册表内容解析与 links 迁移（纯函数，同步与异步加载共享的唯一事实源）。
  *
@@ -304,7 +311,8 @@ export async function unlinkPackage(identifier = process.cwd(), customHome) {
             delete registry.workspaces[absPath];
             let removedCount = 0;
             for (const [id, entry] of Object.entries(registry.packages)) {
-                if (entry.workspaceRoot === absPath || entry.path.startsWith(absPath)) {
+                // 路径前缀匹配必须携带分隔符边界，避免 /home/ws 误删 /home/ws2 的记录
+                if (isPathWithin(entry.path, absPath) || entry.workspaceRoot === absPath) {
                     delete registry.packages[id];
                     removedCount++;
                 }
@@ -325,7 +333,8 @@ export async function unlinkPackage(identifier = process.cwd(), customHome) {
                     delete registry.workspaces[wsPath];
                     let removedCount = 0;
                     for (const [id, entry] of Object.entries(registry.packages)) {
-                        if (entry.workspaceRoot === wsPath || entry.path.startsWith(wsPath)) {
+                        // 路径前缀匹配必须携带分隔符边界，避免 /home/ws 误删 /home/ws2 的记录
+                        if (isPathWithin(entry.path, wsPath) || entry.workspaceRoot === wsPath) {
                             delete registry.packages[id];
                             removedCount++;
                         }

package/dist/runtime/context.d.ts

@@ -1,15 +1,16 @@
 import type { ActionContext, ActionRef, Config, Logger, ProcessAPI, ProgressReporter, StateStore } from "@actiondock/sdk";
 import type { ProjectConfig } from "../project/types.js";
 import type { RuntimeStorage } from "../storage/types.js";
+import { ProcessManager, type ProcessOwner } from "../process/index.js";
 /**
  * 生产级配置解析器实现。
  * 严格践行 5 层配置解析优先级链：
- * 1. CLI 临时参数覆写 (Overrides)
- * 2. 包级持久化存储 (Package SQLite: ~/.actiondock/data/<package-id>/runtime.db)
- * 3. 全局共享持久化存储 (Global SQLite: ~/.actiondock/global.db)
- * 4. 操作系统环境变量 (process.env: 显式绑定 / 包名前缀 / SNAKE_CASE / 类型转换)
- * 5. 项目默认配置 (actiondock.json 中的 default 字段)
- * 6. 代码级默认回退值 (fallback)
+ * - CLI 临时参数覆写 (Overrides)
+ * - 包级持久化存储 (Package SQLite: ~/.actiondock/data/<package-id>/runtime.db)
+ * - 全局共享持久化存储 (Global SQLite: ~/.actiondock/global.db)
+ * - 操作系统环境变量 (process.env: 显式绑定 / 包名前缀 / SNAKE_CASE / 类型转换)
+ * - 项目默认配置 (actiondock.json 中的 default 字段)
+ * - 代码级默认回退值 (fallback)
  */
 export declare class RuntimeConfig implements Config {
     private overrides;
@@ -73,6 +74,8 @@ export interface ContextOptions {
     callStack?: string[];
     signal?: AbortSignal;
     process?: ProcessAPI;
+    processManager?: ProcessManager;
+    owner?: ProcessOwner;
     progress?: ProgressReporter;
     logger?: Logger;
     onActionInvoke?: (action: ActionRef | string, input: unknown, parentRunId?: string) => Promise<unknown>;

package/dist/runtime/context.js

@@ -1,15 +1,15 @@
 import { randomUUID } from "node:crypto";
+import { MemoryProcessDriver, ProcessManager } from "../process/index.js";
 import { resolveEnvValue } from "./env.js";
-import { DefaultProcessExecutor } from "./process.js";
 /**
  * 生产级配置解析器实现。
  * 严格践行 5 层配置解析优先级链：
- * 1. CLI 临时参数覆写 (Overrides)
- * 2. 包级持久化存储 (Package SQLite: ~/.actiondock/data/<package-id>/runtime.db)
- * 3. 全局共享持久化存储 (Global SQLite: ~/.actiondock/global.db)
- * 4. 操作系统环境变量 (process.env: 显式绑定 / 包名前缀 / SNAKE_CASE / 类型转换)
- * 5. 项目默认配置 (actiondock.json 中的 default 字段)
- * 6. 代码级默认回退值 (fallback)
+ * - CLI 临时参数覆写 (Overrides)
+ * - 包级持久化存储 (Package SQLite: ~/.actiondock/data/<package-id>/runtime.db)
+ * - 全局共享持久化存储 (Global SQLite: ~/.actiondock/global.db)
+ * - 操作系统环境变量 (process.env: 显式绑定 / 包名前缀 / SNAKE_CASE / 类型转换)
+ * - 项目默认配置 (actiondock.json 中的 default 字段)
+ * - 代码级默认回退值 (fallback)
  */
 export class RuntimeConfig {
     overrides;
@@ -221,7 +221,30 @@ export function createActionContext(options) {
     };
     const invokerFn = (ref, input) => invoke(ref, input);
     const invoker = Object.assign(invokerFn, { invoke });
-    const processApi = options.process || new DefaultProcessExecutor();
+    const defaultOwner = {
+        tenantId: "default",
+        principalId: "default",
+        packageInstanceId: "default",
+        generationId: "default",
+    };
+    const effectiveOwner = options.owner || defaultOwner;
+    // 外部注入的可能是平台级共享 ContextProcessAPI（未绑定 runId），直接复用会让
+    // 多个 run 共享同一隔离与回收状态；此处派生 run 级实例保证隔离与自动回收均以 run 为单位
+    const injectedProcess = options.process;
+    const isSharedContextProcessApi = injectedProcess &&
+        typeof injectedProcess === "object" &&
+        typeof injectedProcess.forOwner !== "function" &&
+        injectedProcess.manager &&
+        typeof injectedProcess.manager.forOwner === "function" &&
+        injectedProcess.runScoped !== true;
+    const processApi = injectedProcess && typeof injectedProcess.forOwner === "function"
+        ? injectedProcess.forOwner(effectiveOwner, currentRunId, signal)
+        : isSharedContextProcessApi
+            ? injectedProcess.manager.forOwner(effectiveOwner, currentRunId, signal)
+            : options.process ||
+                (options.processManager
+                    ? options.processManager.forOwner(effectiveOwner, currentRunId, signal)
+                    : new ProcessManager({ driver: new MemoryProcessDriver() }).forOwner(effectiveOwner, currentRunId, signal));
     const progressApi = options.progress || {
         report() { },
     };

package/dist/runtime/process.d.ts

@@ -1,9 +1,26 @@
-import type { ProcessAPI, ProcessExecOptions, ProcessResult } from "@actiondock/sdk";
+import { type CallOptions, type ControlGrant, type OperationReceipt, type ProcessAcquireInput, type ProcessAPI, type ProcessControlInput, type ProcessExecOptions, type ProcessInfo, type ProcessListInput, type ProcessListResult, type ProcessReadInput, type ProcessResult, type ProcessRunInput, type ProcessRunResult, type ProcessStartInput, type ProcessStartResult, type ProcessStopInput, type ProcessWriteInput, type ReadResult } from "@actiondock/sdk";
+import { ProcessManager, type ProcessOwner } from "../process/index.js";
 export type ProcessExecutor = ProcessAPI;
 /**
- * 基于 Node.js 标准 child_process 实现的基础进程执行器。
+ * 基于受管进程驱动的默认基础执行器实现。
+ * 保持内核彻底解耦与平台无关，不依赖操作系统原生进程句柄与 Node 模块。
  */
 export declare class DefaultProcessExecutor implements ProcessExecutor {
+    private readonly manager;
+    private readonly owner;
+    constructor(manager?: ProcessManager, owner?: ProcessOwner);
     exec(command: string, args?: string[], options?: ProcessExecOptions): Promise<ProcessResult>;
     spawn(command: string, args?: string[], options?: ProcessExecOptions): Promise<ProcessResult>;
+    run(input: ProcessRunInput, call?: CallOptions): Promise<ProcessRunResult>;
+    start(input: ProcessStartInput, call?: CallOptions): Promise<ProcessStartResult>;
+    inspect(id: string, call?: CallOptions): Promise<ProcessInfo>;
+    list(input: ProcessListInput, call?: CallOptions): Promise<ProcessListResult>;
+    acquire(id: string, input: ProcessAcquireInput, call?: CallOptions): Promise<ControlGrant>;
+    renew(id: string, token: string, ttlMs: number, call?: CallOptions): Promise<ControlGrant>;
+    release(id: string, token: string, call?: CallOptions): Promise<void>;
+    write(id: string, input: ProcessWriteInput, call?: CallOptions): Promise<OperationReceipt>;
+    operation(id: string, requestId: string, call?: CallOptions): Promise<OperationReceipt>;
+    read(id: string, input: ProcessReadInput, call?: CallOptions): Promise<ReadResult>;
+    control(id: string, input: ProcessControlInput, call?: CallOptions): Promise<OperationReceipt>;
+    stop(id: string, input: ProcessStopInput, call?: CallOptions): Promise<ProcessInfo>;
 }

package/dist/runtime/process.js

@@ -1,146 +1,118 @@
-import { spawn } from "node:child_process";
-import { PROCESS_OUTPUT_LIMIT, PROCESS_SPAWN_ERROR } from "../errors.js";
+import { MemoryProcessDriver, ProcessManager } from "../process/index.js";
 /**
- * 基于 Node.js 标准 child_process 实现的基础进程执行器。
+ * 基于受管进程驱动的默认基础执行器实现。
+ * 保持内核彻底解耦与平台无关，不依赖操作系统原生进程句柄与 Node 模块。
  */
 export class DefaultProcessExecutor {
+    manager;
+    owner;
+    constructor(manager, owner) {
+        this.manager = manager ?? new ProcessManager({ driver: new MemoryProcessDriver() });
+        this.owner = owner ?? {
+            tenantId: "default",
+            principalId: "default",
+            packageInstanceId: "default",
+            generationId: "default",
+        };
+    }
     async exec(command, args = [], options = {}) {
         const startTime = Date.now();
-        const maxOutputBytes = options.maxOutputBytes ?? 10 * 1024 * 1024;
-        return new Promise((resolve, reject) => {
-            let stdoutBuf = "";
-            let stderrBuf = "";
-            let totalBytes = 0;
-            let timedOut = false;
-            let cancelled = false;
-            let error;
-            const cp = spawn(command, args, {
-                cwd: options.cwd,
-                env: options.env ? { ...process.env, ...options.env } : process.env,
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-            if (options.input) {
-                cp.stdin.write(options.input);
-                cp.stdin.end();
-            }
-            else {
-                cp.stdin.end();
+        try {
+            const runResult = await this.manager.run(this.owner, {
+                spec: {
+                    executable: command,
+                    args,
+                    cwd: options.cwd,
+                    env: options.env ? { inherit: "none", set: options.env } : undefined,
+                    io: { mode: "pipe" },
+                },
+                timeoutMs: options.timeoutMs ?? 0,
+                maxOutputBytes: options.maxOutputBytes ?? 10 * 1024 * 1024,
+            }, options.signal ? { signal: options.signal } : undefined);
+            let stdout = "";
+            let stderr = "";
+            for (const chunk of runResult.chunks) {
+                if (chunk.stream === "stdout") {
+                    stdout += chunk.data.data;
+                }
+                else if (chunk.stream === "stderr") {
+                    stderr += chunk.data.data;
+                }
             }
-            let timer;
-            let forceKillTimer;
-            if (options.timeoutMs && options.timeoutMs > 0) {
-                timer = setTimeout(() => {
-                    timedOut = true;
-                    cp.kill("SIGTERM");
-                    forceKillTimer = setTimeout(() => {
-                        if (!cp.killed)
-                            cp.kill("SIGKILL");
-                    }, 1000);
-                }, options.timeoutMs);
+            const durationMs = Date.now() - startTime;
+            const ok = runResult.exit.code === 0;
+            if (!ok && options.throwOnError) {
+                throw new Error(stderr || `Process exited with code ${runResult.exit.code}`);
             }
-            const onAbort = () => {
-                cancelled = true;
-                cp.kill("SIGTERM");
-                forceKillTimer = setTimeout(() => {
-                    if (!cp.killed)
-                        cp.kill("SIGKILL");
-                }, 1000);
+            return {
+                ok,
+                exitCode: runResult.exit.code,
+                signal: runResult.exit.signal ?? undefined,
+                stdout,
+                stderr,
+                raw: new Uint8Array(),
+                timedOut: false,
+                cancelled: false,
+                durationMs,
             };
-            if (options.signal) {
-                if (options.signal.aborted) {
-                    onAbort();
-                }
-                else {
-                    options.signal.addEventListener("abort", onAbort, { once: true });
-                }
+        }
+        catch (err) {
+            if (options.throwOnError) {
+                throw err;
             }
-            const cleanup = () => {
-                if (timer) {
-                    clearTimeout(timer);
-                    timer = undefined;
-                }
-                if (forceKillTimer) {
-                    clearTimeout(forceKillTimer);
-                    forceKillTimer = undefined;
-                }
-                if (options.signal) {
-                    options.signal.removeEventListener("abort", onAbort);
-                }
+            return {
+                ok: false,
+                exitCode: -1,
+                stdout: "",
+                stderr: err?.message || String(err),
+                raw: new Uint8Array(),
+                timedOut: false,
+                cancelled: false,
+                durationMs: Date.now() - startTime,
+                error: {
+                    code: err?.code || "PROCESS_FAILED",
+                    message: err?.message || String(err),
+                },
             };
-            cp.stdout?.on("data", (chunk) => {
-                totalBytes += chunk.length;
-                if (totalBytes > maxOutputBytes) {
-                    error = {
-                        code: PROCESS_OUTPUT_LIMIT,
-                        message: `Process output exceeded limit of ${maxOutputBytes} bytes`,
-                    };
-                    cp.kill("SIGKILL");
-                    return;
-                }
-                stdoutBuf += chunk.toString("utf-8");
-            });
-            cp.stderr?.on("data", (chunk) => {
-                totalBytes += chunk.length;
-                if (totalBytes > maxOutputBytes) {
-                    error = {
-                        code: PROCESS_OUTPUT_LIMIT,
-                        message: `Process output exceeded limit of ${maxOutputBytes} bytes`,
-                    };
-                    cp.kill("SIGKILL");
-                    return;
-                }
-                stderrBuf += chunk.toString("utf-8");
-            });
-            cp.on("error", (err) => {
-                cleanup();
-                const durationMs = Date.now() - startTime;
-                const res = {
-                    ok: false,
-                    exitCode: null,
-                    stdout: stdoutBuf.trim(),
-                    stderr: stderrBuf.trim() || err.message,
-                    raw: new TextEncoder().encode(stdoutBuf),
-                    timedOut,
-                    cancelled,
-                    durationMs,
-                    error: error || {
-                        code: PROCESS_SPAWN_ERROR,
-                        message: err.message,
-                    },
-                };
-                if (options.throwOnError) {
-                    reject(new Error(err.message));
-                }
-                else {
-                    resolve(res);
-                }
-            });
-            cp.on("close", (exitCode, signal) => {
-                cleanup();
-                const durationMs = Date.now() - startTime;
-                const ok = exitCode === 0 && !timedOut && !cancelled && !error;
-                const res = {
-                    ok,
-                    exitCode,
-                    signal: signal || undefined,
-                    stdout: stdoutBuf.trim(),
-                    stderr: stderrBuf.trim(),
-                    raw: new TextEncoder().encode(stdoutBuf),
-                    timedOut,
-                    cancelled,
-                    durationMs,
-                    error,
-                };
-                if (!ok && options.throwOnError) {
-                    reject(new Error(stderrBuf.trim() || `Process exited with code ${exitCode}`));
-                }
-                else {
-                    resolve(res);
-                }
-            });
-        });
+        }
     }
     async spawn(command, args = [], options = {}) {
         return this.exec(command, args, options);
     }
+    async run(input, call) {
+        return this.manager.run(this.owner, input, call);
+    }
+    async start(input, call) {
+        return this.manager.start(this.owner, input, call);
+    }
+    async inspect(id, call) {
+        return this.manager.inspect(this.owner, id, call);
+    }
+    async list(input, call) {
+        return this.manager.list(this.owner, input, call);
+    }
+    async acquire(id, input, call) {
+        return this.manager.acquire(this.owner, id, input, call);
+    }
+    async renew(id, token, ttlMs, call) {
+        return this.manager.renew(this.owner, id, token, ttlMs, call);
+    }
+    async release(id, token, call) {
+        return this.manager.release(this.owner, id, token, call);
+    }
+    async write(id, input, call) {
+        return this.manager.write(this.owner, id, input, call);
+    }
+    async operation(id, requestId, call) {
+        return this.manager.operation(this.owner, id, requestId, call);
+    }
+    async read(id, input, call) {
+        return this.manager.read(this.owner, id, input, call);
+    }
+    async control(id, input, call) {
+        return this.manager.control(this.owner, id, input, call);
+    }
+    async stop(id, input, call) {
+        return this.manager.stop(this.owner, id, input, call);
+    }
 }