@actiondock/core 2.0.8 → 2.0.10

package/src/runtime/runner.ts

@@ -4,6 +4,7 @@ import type {
   ActionDefinition,
   ExecutionResult,
   JsonValue,
+  Logger,
   ProcessAPI,
   ProgressReporter,
   RuntimeError,
@@ -12,8 +13,7 @@ import type {
 import type { ProjectConfig } from "../project/types";
 import { validateSchema } from "../schema/validator";
 import type { RuntimeStorage, TerminalRunStatus } from "../storage/types";
-import { RuntimeConfig, RuntimeStateStore, StderrLogger } from "./context";
-import { getProcessExecutor } from "./process";
+import { createActionContext, StderrLogger } from "./context";
 
 /**
  * ActionRunner 初始化配置选项。
@@ -37,6 +37,8 @@ export interface RunnerOptions {
  * 启动 Action 执行时的可选控制参数。
  */
 export interface ExecutionStartOptions {
+  /** 显式指定的运行 ID */
+  runId?: string;
   /** 根运行 ID */
   rootRunId?: string;
   /** 父级运行 ID（嵌套调用场景下建立调用链树） */
@@ -57,6 +59,8 @@ export interface ExecutionStartOptions {
   process?: ProcessAPI;
   /** 外部注入的进度报告器 */
   progress?: ProgressReporter;
+  /** 外部注入的日志记录器 */
+  logger?: Logger;
 }
 
 /**
@@ -134,7 +138,7 @@ export class ActionRunner {
     input: unknown = {},
     options: ExecutionStartOptions = {}
   ): ExecutionHandle {
-    const runId = randomUUID();
+    const runId = options.runId || randomUUID();
     const startedAt = new Date().toISOString();
     const callStack = [...(options.callStack || [])];
 
@@ -243,26 +247,26 @@ export class ActionRunner {
     };
 
     // 5. 构建 ActionContext 运行时上下文
-    const config = new RuntimeConfig(
-      this.storage,
-      this.configOverrides,
-      this.projectConfig
-    );
-    const state = new RuntimeStateStore(this.storage);
-    const log = new StderrLogger(action.id);
-
-    const invoker = {
-      invoke: async <I, O>(
-        childAction: ActionDefinition<I, O>,
-        childInput: I
-      ): Promise<O> => {
+    const ctx = createActionContext({
+      storage: this.storage,
+      overrides: this.configOverrides,
+      projectConfig: this.projectConfig,
+      runId,
+      rootRunId: initialRun.rootRunId,
+      parentRunId: options.parentRunId,
+      signal: controller.signal,
+      process: options.process,
+      progress: options.progress,
+      logger: options.logger || new StderrLogger(action.id),
+      onActionInvoke: async (childAction, childInput, parentRunId) => {
         const childResult = await this.execute(childAction, childInput, {
           rootRunId: initialRun.rootRunId,
-          parentRunId: runId,
+          parentRunId,
           callStack,
           signal: controller.signal,
           process: options.process,
           progress: options.progress,
+          logger: options.logger,
         });
         if (!childResult.ok) {
           const err = new Error(childResult.error.message);
@@ -270,26 +274,9 @@ export class ActionRunner {
           (err as any).details = childResult.error.details;
           throw err;
         }
-        return childResult.data as O;
+        return childResult.data;
       },
-    };
-
-    const ctx: ActionContext = {
-      config,
-      state,
-      actions: invoker,
-      process: options.process || getProcessExecutor(),
-      log,
-      progress: options.progress || {
-        report() {},
-      },
-      signal: controller.signal,
-      run: {
-        id: runId,
-        rootId: initialRun.rootRunId,
-        parentId: options.parentRunId,
-      },
-    };
+    });
 
     // 6. 执行 Action 业务逻辑并与取消/超时信号进行竞态
     const abortPromise = new Promise<never>((_, reject) => {

package/src/server/index.ts

@@ -2,5 +2,6 @@ export * from "./types";
 export * from "./security";
 export * from "./body";
 export * from "./runtime-registry";
+export * from "./routes";
 export * from "./server";
 

package/src/server/routes/actions.ts

@@ -0,0 +1,262 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { filterByIntent } from "../../filter";
+import { loadActions, loadProjectConfig } from "../../project/loader";
+import { listLinkedPackages, resolveActionProject } from "../../registry/registry";
+import { ActionRunner } from "../../runtime/runner";
+import { InvalidJsonError, readJsonBody, RequestTooLargeError } from "../body";
+import { type RouteContext, jsonResponse } from "./common";
+
+/**
+ * 处理 Action 列表、详情查询及同步/异步运行接口。
+ */
+export async function handleActionsRoutes(ctx: RouteContext): Promise<Response | null> {
+  const { req, url, pathname, corsHeaders, projectRoot, customHome, runtimeRegistry, options } = ctx;
+
+  // 1. Actions List: GET /api/v1/actions
+  if (pathname === "/api/v1/actions" && req.method === "GET") {
+    try {
+      const actionList: Array<{
+        id: string;
+        description: string;
+        packageId?: string;
+      }> = [];
+
+      if (projectRoot) {
+        const config = loadProjectConfig(projectRoot);
+        const actions = await loadActions(projectRoot, config.actionsDir);
+        for (const [id, a] of actions.entries()) {
+          actionList.push({
+            id,
+            description: a.description || "",
+            packageId: config.id,
+          });
+        }
+      }
+
+      const linked = listLinkedPackages(customHome);
+      for (const pkg of linked) {
+        if (projectRoot && pkg.path === projectRoot) continue;
+        if (!existsSync(pkg.path)) continue;
+        try {
+          const config = loadProjectConfig(pkg.path);
+          const actions = await loadActions(pkg.path, config.actionsDir);
+          for (const [id, a] of actions.entries()) {
+            actionList.push({
+              id,
+              description: a.description || "",
+              packageId: pkg.id,
+            });
+          }
+        } catch {
+          // 忽略故障包
+        }
+      }
+
+      const intent = url.searchParams.get("intent");
+      const targetPkg = url.searchParams.get("package");
+
+      let filtered = targetPkg
+        ? actionList.filter((a) => a.packageId === targetPkg)
+        : actionList;
+
+      if (intent) {
+        filtered = filterByIntent(
+          filtered,
+          intent,
+          [(a) => a.id, (a) => a.description, (a) => a.packageId],
+          false
+        );
+      }
+
+      return jsonResponse(filtered, 200, corsHeaders);
+    } catch (err: any) {
+      return jsonResponse(
+        {
+          ok: false,
+          error: { code: "ACTIONS_LIST_ERROR", message: err.message },
+        },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  // 2. Action Show: GET /api/v1/actions/:id
+  const actionShowMatch = pathname.match(/^\/api\/v1\/actions\/([^/]+)$/);
+  if (actionShowMatch && req.method === "GET") {
+    const actionId = decodeURIComponent(actionShowMatch[1]);
+    try {
+      const resolved = await resolveActionProject(
+        actionId,
+        projectRoot || process.cwd(),
+        customHome
+      );
+      const config = loadProjectConfig(resolved.projectRoot);
+      const actions = await loadActions(resolved.projectRoot, config.actionsDir);
+      const action = actions.get(resolved.actionId);
+      if (!action) {
+        return jsonResponse(
+          {
+            ok: false,
+            error: {
+              code: "ACTION_NOT_FOUND",
+              message: `Action '${resolved.actionId}' not found in package '${resolved.packageId}'`,
+            },
+          },
+          404,
+          corsHeaders
+        );
+      }
+
+      return jsonResponse(
+        {
+          id: action.id,
+          packageId: resolved.packageId,
+          description: action.description || "",
+          inputSchema: action.inputSchema || null,
+          outputSchema: action.outputSchema || null,
+        },
+        200,
+        corsHeaders
+      );
+    } catch (err: any) {
+      return jsonResponse(
+        {
+          ok: false,
+          error: { code: "ACTION_NOT_FOUND", message: err.message },
+        },
+        404,
+        corsHeaders
+      );
+    }
+  }
+
+  // 3. Action Run: POST /api/v1/actions/:id/run
+  const actionRunMatch = pathname.match(/^\/api\/v1\/actions\/([^/]+)\/run$/);
+  if (actionRunMatch && req.method === "POST") {
+    const actionId = decodeURIComponent(actionRunMatch[1]);
+    let body: any = {};
+    try {
+      body = await readJsonBody(req, { maxBytes: options.maxBodyBytes });
+    } catch (err: any) {
+      if (err instanceof RequestTooLargeError) {
+        return jsonResponse(
+          {
+            ok: false,
+            runId: randomUUID(),
+            error: { code: "REQUEST_TOO_LARGE", message: err.message },
+          },
+          413,
+          corsHeaders
+        );
+      }
+      if (err instanceof InvalidJsonError) {
+        return jsonResponse(
+          {
+            ok: false,
+            runId: randomUUID(),
+            error: { code: "INVALID_JSON", message: err.message },
+          },
+          400,
+          corsHeaders
+        );
+      }
+      return jsonResponse(
+        {
+          ok: false,
+          runId: randomUUID(),
+          error: { code: "INVALID_JSON", message: `Failed to parse request body: ${err.message}` },
+        },
+        400,
+        corsHeaders
+      );
+    }
+
+    try {
+      const resolved = await resolveActionProject(
+        actionId,
+        projectRoot || process.cwd(),
+        customHome
+      );
+      const config = loadProjectConfig(resolved.projectRoot);
+      const actions = await loadActions(resolved.projectRoot, config.actionsDir);
+      const storage = runtimeRegistry.getStorage(config.id, resolved.projectRoot);
+
+      const runner = new ActionRunner({
+        packageId: config.id,
+        storage,
+        projectConfig: config,
+        configOverrides: body?.config || {},
+        actions,
+      });
+
+      const isAsync = body?.execution?.mode === "async" || body?.async === true;
+      const timeoutMs =
+        typeof body?.execution?.timeoutMs === "number" && body.execution.timeoutMs > 0
+          ? body.execution.timeoutMs
+          : undefined;
+
+      if (isAsync) {
+        const handle = runner.start(resolved.actionId, body?.input || {}, {
+          timeoutMs,
+        });
+        runtimeRegistry.executionManager.register(handle);
+
+        // 监听结算以广播 SSE 完成事件
+        handle.result
+          .then((res) => {
+            runtimeRegistry.emit(handle.runId, { type: "finish", data: res });
+          })
+          .catch((err) => {
+            runtimeRegistry.emit(handle.runId, {
+              type: "finish",
+              data: {
+                ok: false,
+                error: {
+                  code: "ACTION_EXECUTION_ERROR",
+                  message: err?.message || String(err),
+                },
+              },
+            });
+          });
+
+        return jsonResponse(
+          {
+            ok: true,
+            runId: handle.runId,
+            status: "running",
+            streamUrl: `/api/v1/runs/${handle.runId}/stream`,
+          },
+          202,
+          corsHeaders
+        );
+      }
+
+      // 同步执行模式
+      const handle = runner.start(resolved.actionId, body?.input || {}, {
+        signal: req.signal,
+        timeoutMs,
+      });
+      runtimeRegistry.executionManager.register(handle);
+      const result = await handle.result;
+
+      return jsonResponse(result, 200, corsHeaders);
+    } catch (err: any) {
+      return jsonResponse(
+        {
+          ok: false,
+          runId: randomUUID(),
+          error: {
+            code: "ACTION_EXECUTION_ERROR",
+            message: err.message || String(err),
+          },
+        },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  return null;
+}

package/src/server/routes/common.ts

@@ -0,0 +1,126 @@
+import { existsSync } from "node:fs";
+import { loadProjectConfig } from "../../project/loader";
+import { listLinkedPackages, resolvePackageRoot } from "../../registry/registry";
+import type { RuntimeStorage } from "../../storage/types";
+import type { RunRecord } from "@actiondock/sdk";
+import type { ServerRuntimeRegistry } from "../runtime-registry";
+import type { ServerOptions } from "../types";
+
+/**
+ * 路由处理统一上下文对象。
+ */
+export interface RouteContext {
+  req: Request;
+  url: URL;
+  pathname: string;
+  corsHeaders: Record<string, string>;
+  projectRoot: string | null;
+  customHome?: string;
+  runtimeRegistry: ServerRuntimeRegistry;
+  options: ServerOptions;
+}
+
+/**
+ * 辅助函数：构造带 CORS 头的标准 JSON HTTP 响应。
+ */
+export function jsonResponse(
+  data: unknown,
+  status = 200,
+  corsHeaders: Record<string, string> = {}
+): Response {
+  return new Response(JSON.stringify(data, null, 2), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      ...corsHeaders,
+    },
+  });
+}
+
+/**
+ * 依据 package 参数或项目上下文解析目标 Storage 实例与根目录。
+ */
+export function resolveStorageForPackage(
+  packageIdOrPath: string | undefined,
+  runtimeRegistry: ServerRuntimeRegistry,
+  projectRoot?: string | null,
+  customHome?: string
+): { packageId: string; storage: RuntimeStorage; projectRoot?: string } {
+  if (packageIdOrPath) {
+    const root = resolvePackageRoot(packageIdOrPath, customHome);
+    if (root) {
+      const config = loadProjectConfig(root);
+      return {
+        packageId: config.id,
+        storage: runtimeRegistry.getStorage(config.id, root),
+        projectRoot: root,
+      };
+    }
+    return {
+      packageId: packageIdOrPath,
+      storage: runtimeRegistry.getStorage(packageIdOrPath),
+    };
+  }
+
+  if (projectRoot) {
+    const config = loadProjectConfig(projectRoot);
+    return {
+      packageId: config.id,
+      storage: runtimeRegistry.getStorage(config.id, projectRoot),
+      projectRoot,
+    };
+  }
+
+  const linked = listLinkedPackages(customHome);
+  if (linked.length > 0) {
+    const first = linked[0];
+    return {
+      packageId: first.id,
+      storage: runtimeRegistry.getStorage(first.id, first.path),
+      projectRoot: first.path,
+    };
+  }
+
+  return {
+    packageId: "default",
+    storage: runtimeRegistry.getStorage("default"),
+  };
+}
+
+/**
+ * 跨活跃连接与所有已知持久化存储全局检索指定 runId 的运行记录。
+ */
+export function findRunAcrossStorages(
+  runId: string,
+  runtimeRegistry: ServerRuntimeRegistry,
+  projectRoot?: string | null,
+  customHome?: string
+): { storage: RuntimeStorage; run: RunRecord } | null {
+  const inMemory = runtimeRegistry.findRun(runId);
+  if (inMemory) return inMemory as { storage: RuntimeStorage; run: RunRecord };
+
+  if (projectRoot) {
+    try {
+      const config = loadProjectConfig(projectRoot);
+      const storage = runtimeRegistry.getStorage(config.id, projectRoot);
+      const run = storage.getRun(runId);
+      if (run) return { storage, run };
+    } catch {
+      // 忽略读取错误
+    }
+  }
+
+  try {
+    const linked = listLinkedPackages(customHome);
+    for (const pkg of linked) {
+      if (!existsSync(pkg.path)) continue;
+      const storage = runtimeRegistry.getStorage(pkg.id, pkg.path);
+      const run = storage.getRun(runId);
+      if (run) return { storage, run };
+    }
+  } catch {
+    // 忽略读取错误
+  }
+
+  return null;
+}

package/src/server/routes/config.ts

@@ -0,0 +1,147 @@
+import { loadProjectConfig } from "../../project/loader";
+import { readJsonBody } from "../body";
+import { type RouteContext, jsonResponse, resolveStorageForPackage } from "./common";
+
+/**
+ * 处理配置元数据与当前值读取、更新及删除接口。
+ */
+export async function handleConfigRoutes(ctx: RouteContext): Promise<Response | null> {
+  const { req, url, pathname, corsHeaders, projectRoot, customHome, runtimeRegistry, options } = ctx;
+
+  // 1. Config Env Check: GET /api/v1/config/env
+  if (pathname === "/api/v1/config/env" && req.method === "GET") {
+    try {
+      const pkgParam = url.searchParams.get("package") || undefined;
+      const { packageId, projectRoot: root } = resolveStorageForPackage(
+        pkgParam,
+        runtimeRegistry,
+        projectRoot,
+        customHome
+      );
+      if (!root) {
+        return jsonResponse({ ok: true, packageId, envChecks: [] }, 200, corsHeaders);
+      }
+      const cfg = loadProjectConfig(root);
+      const declared = cfg.config || {};
+      const envChecks: any[] = [];
+      for (const [k, def] of Object.entries(declared)) {
+        const envKeys = [
+          k,
+          `ACTIONDOCK_${k}`,
+          `${packageId.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_${k}`,
+        ];
+        const foundEnv = envKeys.find((ek) => process.env[ek] !== undefined);
+        envChecks.push({
+          key: k,
+          required: def.default === undefined,
+          satisfied: Boolean(foundEnv || def.default !== undefined),
+          matchedEnv: foundEnv || null,
+          hasDefault: def.default !== undefined,
+          secret: Boolean(def.secret),
+        });
+      }
+      return jsonResponse({ ok: true, packageId, envChecks }, 200, corsHeaders);
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "CONFIG_ENV_ERROR", message: err.message } },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  // 2. Config Query: GET /api/v1/config
+  if (pathname === "/api/v1/config" && req.method === "GET") {
+    try {
+      const pkgParam = url.searchParams.get("package") || undefined;
+      const { packageId, storage, projectRoot: root } = resolveStorageForPackage(
+        pkgParam,
+        runtimeRegistry,
+        projectRoot,
+        customHome
+      );
+      const stored = storage.listConfig();
+      let declared: Record<string, any> = {};
+      if (root) {
+        try {
+          const cfg = loadProjectConfig(root);
+          declared = cfg.config || {};
+        } catch {}
+      }
+      const maskedValues: Record<string, any> = {};
+      for (const [k, v] of Object.entries(stored)) {
+        if (declared[k]?.secret) {
+          maskedValues[k] = "******";
+        } else {
+          maskedValues[k] = v;
+        }
+      }
+      return jsonResponse(
+        { ok: true, packageId, declared, values: maskedValues },
+        200,
+        corsHeaders
+      );
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "CONFIG_LIST_ERROR", message: err.message } },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  // 3. Config Update: PUT / POST /api/v1/config
+  if (pathname === "/api/v1/config" && (req.method === "PUT" || req.method === "POST")) {
+    try {
+      const body = await readJsonBody(req, { maxBytes: options.maxBodyBytes });
+      const pkgParam = url.searchParams.get("package") || body.package || undefined;
+      const { packageId, storage } = resolveStorageForPackage(
+        pkgParam,
+        runtimeRegistry,
+        projectRoot,
+        customHome
+      );
+      const key = body.key;
+      if (!key) {
+        return jsonResponse(
+          { ok: false, error: { code: "INVALID_ARGUMENT", message: "Config 'key' is required" } },
+          400,
+          corsHeaders
+        );
+      }
+      storage.setConfig(key, body.value);
+      return jsonResponse({ ok: true, packageId, key, message: "updated" }, 200, corsHeaders);
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "CONFIG_SET_ERROR", message: err.message } },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  // 4. Config Delete: DELETE /api/v1/config/:key
+  const configKeyMatch = pathname.match(/^\/api\/v1\/config\/([^/]+)$/);
+  if (configKeyMatch && req.method === "DELETE") {
+    try {
+      const key = decodeURIComponent(configKeyMatch[1]);
+      const pkgParam = url.searchParams.get("package") || undefined;
+      const { packageId, storage } = resolveStorageForPackage(
+        pkgParam,
+        runtimeRegistry,
+        projectRoot,
+        customHome
+      );
+      const deleted = storage.deleteConfig(key);
+      return jsonResponse({ ok: true, packageId, key, deleted }, 200, corsHeaders);
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "CONFIG_DELETE_ERROR", message: err.message } },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  return null;
+}

package/src/server/routes/doctor.ts

@@ -0,0 +1,29 @@
+import { runDoctorChecks } from "../../doctor/doctor";
+import { type RouteContext, jsonResponse } from "./common";
+
+/**
+ * 处理环境与依赖诊断接口（GET /api/v1/doctor）。
+ */
+export async function handleDoctorRoute(ctx: RouteContext): Promise<Response | null> {
+  const { req, url, pathname, corsHeaders, projectRoot, customHome } = ctx;
+
+  if (pathname !== "/api/v1/doctor" || req.method !== "GET") {
+    return null;
+  }
+
+  try {
+    const targetPkg = url.searchParams.get("package") || undefined;
+    const report = await runDoctorChecks({
+      cwd: projectRoot || process.cwd(),
+      packageIdOrPath: targetPkg,
+      customHome,
+    });
+    return jsonResponse({ ok: true, report }, 200, corsHeaders);
+  } catch (err: any) {
+    return jsonResponse(
+      { ok: false, error: { code: "DOCTOR_ERROR", message: err.message } },
+      500,
+      corsHeaders
+    );
+  }
+}