@actiondock/core 2.0.1 → 2.0.3

package/src/catalog/types.ts

@@ -0,0 +1,83 @@
+import type { ActionContract, ActionDefinition, ActionRef, ResolvedActionRef } from "@actiondock/sdk";
+import type { ProjectConfig } from "../project/types";
+
+/**
+ * 注册的位置条目类型。
+ */
+export type LocationType = "package" | "workspace";
+
+/**
+ * 位置注册表中的单条链接记录。
+ */
+export interface LocationLink {
+  /** 位置类型：单包或工作区 */
+  type: LocationType;
+  /** 目录绝对物理路径 */
+  path: string;
+  /** 注册时间（ISO 8601） */
+  linkedAt: string;
+  /** 扫描最大深度（工作区模式有效，默认 3） */
+  depth?: number;
+}
+
+/**
+ * 物理位置注册表文件（~/.actiondock/registry.json）格式。
+ */
+export interface LocationRegistryData {
+  schemaVersion: 1;
+  links: LocationLink[];
+}
+
+/**
+ * 解析后的包实例快照。
+ */
+export interface CatalogPackageEntry {
+  /** 逻辑包标识 */
+  id: string;
+  /** 包物理实例唯一标识 */
+  packageInstanceId: string;
+  /** 项目根目录绝对路径 */
+  projectRoot: string;
+  /** 项目配置 */
+  config: ProjectConfig;
+  /** 是否来自工作区自动发现 */
+  isWorkspaceChild?: boolean;
+}
+
+/**
+ * 运行时目录与包快照。
+ */
+export interface CatalogSnapshot {
+  /** 快照代次唯一标识 */
+  generationId: string;
+  /** 生成快照时间 */
+  createdAt: string;
+  /** 已发现的包集合（按 packageId 索引） */
+  packages: Map<string, CatalogPackageEntry>;
+}
+
+/**
+ * 索引中的 Action 描述符。
+ */
+export interface IndexedAction {
+  /** 所属逻辑包 ID */
+  packageId: string;
+  /** 动作 ID */
+  actionId: string;
+  /** 契约元数据 */
+  contract: ActionContract;
+  /** 实现入口相对路径 */
+  entry: string;
+  /** 包根目录绝对路径 */
+  projectRoot: string;
+}
+
+/**
+ * 模块加载器接口。
+ */
+export interface ModuleLoader {
+  load<T>(file: string, options: {
+    projectRoot: string;
+    tsconfigPath?: string;
+  }): Promise<T>;
+}

package/src/doctor/doctor.ts

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import { findProjectRoot, loadActions, loadPlaybooks, loadProjectConfig } from "../project/loader";
 import { getRegistryStatus } from "../registry/registry";
 import { createGlobalStorage, createStorage } from "../storage";
@@ -18,6 +18,36 @@ function compareSemver(v1: string, v2: string): number {
   return 0;
 }
 
+function findExecutable(command: string): string | null {
+  if (typeof (globalThis as any).Bun !== "undefined" && typeof (globalThis as any).Bun.which === "function") {
+    try {
+      const bPath = (globalThis as any).Bun.which(command);
+      if (bPath) return bPath;
+    } catch {}
+  }
+  const hasPathSep = command.includes("/") || command.includes("\\");
+  if (hasPathSep) {
+    return existsSync(command) ? command : null;
+  }
+  const pathEnv = process.env.PATH || "";
+  const dirs = pathEnv.split(delimiter);
+  const isWindows = process.platform === "win32";
+  const pathext = isWindows
+    ? (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";")
+    : [""];
+
+  for (const dir of dirs) {
+    if (!dir) continue;
+    for (const ext of pathext) {
+      const candidate = join(dir, isWindows && !command.includes(".") ? command + ext : command);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+
 export async function runDoctorChecks(options?: {
   cwd?: string;
   packageIdOrPath?: string;
@@ -26,46 +56,42 @@ export async function runDoctorChecks(options?: {
   const cwd = options?.cwd || process.cwd();
   const checks: DoctorCheckItem[] = [];
 
-  // 1. Check Bun Runtime
-  const bunVersion = (typeof Bun !== "undefined" && Bun.version) || (process.versions as any).bun;
+  // 1. Check Node.js Runtime
+  const nodeVersion = process.versions.node;
+  if (nodeVersion) {
+    const isGte22 = compareSemver(nodeVersion, "22.12.0") >= 0;
+    checks.push({
+      id: "runtime.node",
+      category: "runtime",
+      name: "Node.js Runtime",
+      status: isGte22 ? "ok" : "warn",
+      message: `v${nodeVersion} (${isGte22 ? ">= 22.12.0 supported" : ">= 22.12.0 recommended"})`,
+      fix: isGte22 ? undefined : "Upgrade Node.js to v22.12.0 or higher",
+    });
+  }
+
+  // 2. Check Bun Runtime (Optional compiler for standalone binaries)
+  const bunVersion = (typeof (globalThis as any).Bun !== "undefined" && (globalThis as any).Bun.version) || (process.versions as any).bun;
   if (bunVersion) {
-    const isGte12 = compareSemver(bunVersion, "1.2.0") >= 0;
-    if (isGte12) {
-      checks.push({
-        id: "runtime.bun",
-        category: "runtime",
-        name: "Bun Runtime",
-        status: "ok",
-        message: `v${bunVersion} (>= 1.2.0 required)`,
-      });
-    } else {
-      checks.push({
-        id: "runtime.bun",
-        category: "runtime",
-        name: "Bun Runtime",
-        status: "error",
-        message: `v${bunVersion} is too old (>= 1.2.0 required)`,
-        fix: "Run 'bun upgrade' to update Bun",
-      });
-    }
+    checks.push({
+      id: "runtime.bun",
+      category: "runtime",
+      name: "Bun Runtime",
+      status: "ok",
+      message: `v${bunVersion} (available for standalone binary compilation)`,
+    });
   } else {
     checks.push({
       id: "runtime.bun",
       category: "runtime",
       name: "Bun Runtime",
-      status: "error",
-      message: "Bun runtime not detected",
-      fix: "Install Bun via 'npm install -g bun'",
+      status: "ok",
+      message: "Bun compiler not detected (optional, required only for 'ad build' standalone binaries)",
     });
   }
 
-  // 2. Check CLI in PATH
-  let adPath: string | null = null;
-  try {
-    adPath = typeof Bun !== "undefined" && Bun.which ? Bun.which("ad") : null;
-  } catch {
-    // ignore
-  }
+  // 3. Check CLI in PATH
+  const adPath = findExecutable("ad");
 
   if (adPath) {
     checks.push({
@@ -82,7 +108,7 @@ export async function runDoctorChecks(options?: {
       name: "CLI Executable",
       status: "warn",
       message: "'ad' command not found in PATH",
-      fix: "Run 'npm install -g @actiondock/cli' or in SDK workspace run 'cd packages/cli && bun link'",
+      fix: "Run 'npm install -g @actiondock/cli' or in SDK workspace run 'cd packages/cli && npm link'",
     });
   }
 

package/src/execution/index.ts

@@ -0,0 +1,2 @@
+export * from "./service";
+export * from "./types";

package/src/execution/service.ts

@@ -0,0 +1,282 @@
+import { randomUUID } from "node:crypto";
+import type {
+  ActionDefinition,
+  ActionRef,
+  ExecutionEvent,
+  ExecutionResult,
+  JsonValue,
+  ProgressReporter,
+  RunRecord,
+  RunStatus,
+} from "@actiondock/sdk";
+import type { ProjectConfig } from "../project/types";
+import { type EventSink, getDefaultEventSink } from "../runtime/events";
+import { ActionRunner, type ExecutionHandle } from "../runtime/runner";
+import type { RuntimeStorage } from "../storage/types";
+import type {
+  CancelResult,
+  ExecuteOptions,
+  ExecutionService,
+  ExecutionTicket,
+} from "./types";
+
+export interface ExecutionServiceOptions {
+  packageId: string;
+  storage: RuntimeStorage;
+  projectConfig?: ProjectConfig;
+  eventSink?: EventSink;
+  maxActiveRuns?: number;
+  ownerId?: string;
+  actionResolver?: (ref: ActionRef) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
+}
+
+interface ActiveRun {
+  runId: string;
+  handle: ExecutionHandle;
+  controller: AbortController;
+  status: RunStatus;
+  startedAt: string;
+}
+
+/**
+ * 统一执行协调服务实现。
+ */
+export class DefaultExecutionService implements ExecutionService {
+  private packageId: string;
+  private storage: RuntimeStorage;
+  private projectConfig?: ProjectConfig;
+  private eventSink: EventSink;
+  private maxActiveRuns: number;
+  private ownerId: string;
+  private runner: ActionRunner;
+  private actionResolver?: (ref: ActionRef) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
+  private activeRuns = new Map<string, ActiveRun>();
+  private isClosing = false;
+
+  constructor(options: ExecutionServiceOptions) {
+    this.packageId = options.packageId;
+    this.storage = options.storage;
+    this.projectConfig = options.projectConfig;
+    this.eventSink = options.eventSink || getDefaultEventSink();
+    this.maxActiveRuns = options.maxActiveRuns || 32;
+    this.ownerId = options.ownerId || `host-${randomUUID().slice(0, 8)}`;
+    this.actionResolver = options.actionResolver;
+
+    this.runner = new ActionRunner({
+      packageId: this.packageId,
+      storage: this.storage,
+      projectConfig: this.projectConfig,
+    });
+  }
+
+  public registerAction(action: ActionDefinition): void {
+    this.runner.registerAction(action);
+  }
+
+  private async resolveTargetAction(ref: ActionRef): Promise<ActionDefinition | undefined> {
+    const fromRunner = this.runner.getAction(ref.actionId);
+    if (fromRunner) return fromRunner;
+    if (this.actionResolver) {
+      return this.actionResolver(ref);
+    }
+    return undefined;
+  }
+
+  async execute(
+    ref: ActionRef,
+    input: JsonValue,
+    options: ExecuteOptions = {}
+  ): Promise<ExecutionResult> {
+    const ticket = await this.start(ref, input, options);
+    const active = this.activeRuns.get(ticket.runId);
+    if (!active) {
+      const record = await this.get(ticket.runId);
+      if (record && record.status === "success") {
+        return { ok: true, runId: ticket.runId, data: record.output ?? null };
+      }
+      return {
+        ok: false,
+        runId: ticket.runId,
+        error: record?.error || {
+          code: "RUN_TERMINATED_EARLY",
+          message: `Run ${ticket.runId} terminated without result`,
+        },
+      };
+    }
+    return active.handle.result;
+  }
+
+  async start(
+    ref: ActionRef,
+    input: JsonValue,
+    options: ExecuteOptions = {}
+  ): Promise<ExecutionTicket> {
+    if (this.isClosing) {
+      throw new Error("ExecutionService is closing: new tasks rejected");
+    }
+
+    if (this.activeRuns.size >= this.maxActiveRuns) {
+      throw new Error(
+        `Concurrency limit reached: ${this.activeRuns.size}/${this.maxActiveRuns} active runs`
+      );
+    }
+
+    const action = await this.resolveTargetAction(ref);
+    if (!action) {
+      const runId = randomUUID();
+      const errEvt: ExecutionEvent = {
+        runId,
+        rootRunId: runId,
+        sequence: 0,
+        timestamp: new Date().toISOString(),
+        type: "finish",
+        result: {
+          ok: false,
+          runId,
+          error: {
+            code: "ACTION_NOT_FOUND",
+            message: `Action '${ref.actionId}' not found in package '${ref.packageId || this.packageId}'`,
+          },
+        },
+      };
+      this.eventSink.emit(errEvt);
+      return {
+        runId,
+        status: "failed",
+      };
+    }
+
+    const controller = new AbortController();
+    if (options.signal) {
+      if (options.signal.aborted) {
+        controller.abort(options.signal.reason);
+      } else {
+        options.signal.addEventListener(
+          "abort",
+          () => controller.abort(options.signal?.reason),
+          { once: true }
+        );
+      }
+    }
+
+    let sequence = 0;
+    type EventPayload =
+      | { type: "log"; level: "debug" | "info" | "warn" | "error"; message: string; data?: JsonValue }
+      | { type: "progress"; current?: number; total?: number; message?: string }
+      | { type: "status"; status: RunStatus }
+      | { type: "finish"; result: ExecutionResult };
+
+    const handle = this.runner.start(action, input, {
+      signal: controller.signal,
+      timeoutMs: options.timeoutMs,
+    });
+
+    const emitEvent = (payload: EventPayload) => {
+      const evt: ExecutionEvent = {
+        ...payload,
+        runId: handle.runId,
+        rootRunId: handle.runId,
+        sequence: sequence++,
+        timestamp: new Date().toISOString(),
+      };
+      this.eventSink.emit(evt);
+    };
+
+    const progressReporter: ProgressReporter = {
+      report(current: number, total?: number, message?: string) {
+        emitEvent({
+          type: "progress",
+          current,
+          total,
+          message,
+        });
+      },
+    };
+
+    const activeItem: ActiveRun = {
+      runId: handle.runId,
+      handle,
+      controller,
+      status: "running",
+      startedAt: new Date().toISOString(),
+    };
+
+    this.activeRuns.set(handle.runId, activeItem);
+    emitEvent({ type: "status", status: "running" });
+
+    handle.result
+      .then((result: ExecutionResult) => {
+        activeItem.status = result.ok ? "success" : "failed";
+        emitEvent({ type: "finish", result });
+      })
+      .catch((err: any) => {
+        activeItem.status = "failed";
+        emitEvent({
+          type: "finish",
+          result: {
+            ok: false,
+            runId: handle.runId,
+            error: {
+              code: "UNHANDLED_EXECUTION_ERROR",
+              message: err?.message || String(err),
+            },
+          },
+        });
+      })
+      .finally(() => {
+        this.activeRuns.delete(handle.runId);
+      });
+
+    return {
+      runId: handle.runId,
+      status: "running",
+    };
+  }
+
+  async get(runId: string): Promise<RunRecord | undefined> {
+    const record = this.storage.getRun(runId);
+    return record || undefined;
+  }
+
+  async cancel(runId: string, reason?: string): Promise<CancelResult> {
+    const active = this.activeRuns.get(runId);
+    if (!active) {
+      const record = await this.get(runId);
+      if (record) {
+        return { outcome: "already_terminal", runId, status: record.status };
+      }
+      return { outcome: "not_found", runId };
+    }
+
+    active.controller.abort(new Error(reason || "Execution cancelled"));
+    active.handle.cancel(reason);
+    return { outcome: "requested", runId };
+  }
+
+  events(
+    runId: string,
+    options: { after?: number; signal?: AbortSignal } = {}
+  ): AsyncIterable<ExecutionEvent> {
+    return this.eventSink.subscribe(runId, options);
+  }
+
+  async close(options: { graceMs?: number } = {}): Promise<void> {
+    this.isClosing = true;
+    const graceMs = options.graceMs ?? 5000;
+
+    for (const [_, active] of this.activeRuns) {
+      active.controller.abort(new Error("Service shutting down"));
+      active.handle.cancel("Service shutting down");
+    }
+
+    if (this.activeRuns.size > 0) {
+      const waitPromise = Promise.all(
+        Array.from(this.activeRuns.values()).map((a) => a.handle.result.catch(() => {}))
+      );
+      const timeoutPromise = new Promise((resolve) => setTimeout(resolve, graceMs));
+      await Promise.race([waitPromise, timeoutPromise]);
+    }
+
+    this.activeRuns.clear();
+  }
+}

package/src/execution/types.ts

@@ -0,0 +1,73 @@
+import type {
+  ActionRef,
+  ExecutionEvent,
+  ExecutionResult,
+  JsonValue,
+  RunRecord,
+  RunStatus,
+} from "@actiondock/sdk";
+
+/**
+ * 执行参数选项。
+ */
+export interface ExecuteOptions {
+  /** 外部取消信号 */
+  signal?: AbortSignal;
+  /** 超时时间（毫秒） */
+  timeoutMs?: number;
+  /** 配置临时覆盖字典 */
+  config?: Record<string, JsonValue>;
+}
+
+/**
+ * 异步任务执行票据。
+ */
+export interface ExecutionTicket {
+  /** 运行标识 */
+  runId: string;
+  /** 当前状态 */
+  status: RunStatus;
+}
+
+/**
+ * 取消操作结果枚举。
+ */
+export type CancelResult =
+  | { outcome: "requested"; runId: string }
+  | { outcome: "already_terminal"; runId: string; status: RunStatus }
+  | { outcome: "not_found"; runId: string }
+  | { outcome: "not_owner"; runId: string };
+
+/**
+ * 统一执行协调服务接口。
+ */
+export interface ExecutionService {
+  /** 同步执行 Action 并等待终态结果 */
+  execute(
+    ref: ActionRef,
+    input: JsonValue,
+    options?: ExecuteOptions
+  ): Promise<ExecutionResult>;
+
+  /** 异步启动 Action 并立即返回任务票据 */
+  start(
+    ref: ActionRef,
+    input: JsonValue,
+    options?: ExecuteOptions
+  ): Promise<ExecutionTicket>;
+
+  /** 根据 ID 获取运行记录 */
+  get(runId: string): Promise<RunRecord | undefined>;
+
+  /** 取消指定的在运行任务 */
+  cancel(runId: string, reason?: string): Promise<CancelResult>;
+
+  /** 订阅执行事件流 */
+  events(
+    runId: string,
+    options?: { after?: number; signal?: AbortSignal }
+  ): AsyncIterable<ExecutionEvent>;
+
+  /** 优雅关闭服务并等待活跃任务收尾 */
+  close(options?: { graceMs?: number }): Promise<void>;
+}

package/src/export/skill.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { buildProject } from "../build/builder";
@@ -319,17 +320,17 @@ export async function exportSkill(
   if (options.archive) {
     const zipName = `${skillFolderName}.zip`;
     archivePath = join(dirname(skillDir), zipName);
-    const zipProc = Bun.spawnSync(
-      ["zip", "-r", archivePath, basename(skillDir)],
+    const zipProc = spawnSync(
+      "zip",
+      ["-r", archivePath, basename(skillDir)],
       {
         cwd: dirname(skillDir),
-        stdout: "pipe",
-        stderr: "pipe",
+        stdio: "pipe",
       }
     );
-    if (zipProc.exitCode !== 0) {
+    if (zipProc.status !== 0) {
       console.warn(
-        `[WARN] Failed to create zip archive: ${zipProc.stderr.toString()}`
+        `[WARN] Failed to create zip archive: ${zipProc.stderr?.toString() || "zip command failed"}`
       );
       archivePath = undefined;
     }

package/src/export/templates.ts

@@ -163,7 +163,7 @@ ad state get KEY --package ${pkgId}
 
 - **源码本地开发模式**（若在本地源码仓库中贡献或开发）：
   \`\`\`bash
-  cd packages/cli && bun link
+  cd packages/cli && npm link
   cd ../sdk && bun link
   \`\`\`
 

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from "./build";
+export * from "./catalog";
 export * from "./doctor";
+export * from "./execution";
 export * from "./export";
 export * from "./filter";
 export * from "./profile";