@actiondock/core 2.0.9 → 2.0.10

package/src/project/manifest.ts

@@ -1,9 +1,39 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { ActionDockManifest, ActionManifestEntry } from "./types";
+import { join, relative } from "node:path";
+import { loadActionFileMap, loadProjectConfig } from "./loader";
+import type {
+  ActionDockManifest,
+  ActionManifestEntry,
+  ManifestSyncChange,
+  ManifestSyncResult,
+  SyncManifestOptions,
+} from "./types";
 
 export const MANIFEST_FILE_NAME = "actiondock.manifest.json";
 
+function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const arrB = b as unknown[];
+    if (a.length !== arrB.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], arrB[i])) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a as Record<string, unknown>);
+  const keysB = Object.keys(b as Record<string, unknown>);
+  if (keysA.length !== keysB.length) return false;
+  for (const k of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+    if (!deepEqual((a as Record<string, unknown>)[k], (b as Record<string, unknown>)[k])) return false;
+  }
+  return true;
+}
+
 /**
  * 读取并解析项目的声明式清单文件。
  * 若文件不存在则返回 null。
@@ -94,3 +124,176 @@ export function createManifestEntry(options: {
     annotations: options.annotations,
   };
 }
+
+/**
+ * 依据动作源码目录中的 Action 定义，增量同步或校验 actiondock.manifest.json 文件。
+ * 
+ * @param projectRoot 项目根目录绝对路径
+ * @param options 同步选项（包括 actionsDir、check、prune、autoInstall）
+ * @returns 同步变更结果报告
+ */
+export async function syncManifest(
+  projectRoot: string,
+  options: SyncManifestOptions = {}
+): Promise<ManifestSyncResult> {
+  const manifestPath = join(projectRoot, MANIFEST_FILE_NAME);
+
+  // 1. 确定 actions 目录
+  let actionsDir = options.actionsDir;
+  if (!actionsDir) {
+    try {
+      const config = loadProjectConfig(projectRoot);
+      actionsDir = config.actionsDir || "actions";
+    } catch {
+      actionsDir = "actions";
+    }
+  }
+
+  // 2. 加载现有清单，不存在则初始化基准结构
+  const existingManifest = loadManifest(projectRoot);
+  const manifest: ActionDockManifest = existingManifest
+    ? {
+        schemaVersion: existingManifest.schemaVersion || 1,
+        actions: { ...existingManifest.actions },
+        assets: existingManifest.assets ? [...existingManifest.assets] : [],
+      }
+    : {
+        schemaVersion: 1,
+        actions: {},
+        assets: [],
+      };
+
+  // 3. 动态加载所有 Action 源码定义
+  const actionFileMap = await loadActionFileMap(projectRoot, actionsDir, {
+    autoInstall: options.autoInstall !== false,
+    strict: true,
+  });
+
+  const changes: ManifestSyncChange[] = [];
+  const added: string[] = [];
+  const updated: string[] = [];
+  const removed: string[] = [];
+  const unchanged: string[] = [];
+
+  const scannedActionIds = new Set<string>();
+
+  // 4. 比对源码中的每个 Action 与现有清单项
+  for (const [actionId, fileEntry] of actionFileMap.entries()) {
+    scannedActionIds.add(actionId);
+    const relEntry = relative(projectRoot, fileEntry.filePath).replace(/\\/g, "/");
+    const act = fileEntry.action;
+
+    const newManifestEntry: ActionManifestEntry = {
+      entry: relEntry,
+      description: act.description ?? "",
+      inputSchema: act.inputSchema ?? {},
+      outputSchema: act.outputSchema ?? {},
+      uses: Array.isArray(act.uses) ? [...act.uses] : [],
+      tags: Array.isArray(act.tags) ? [...act.tags] : [],
+    };
+    if (act.annotations && typeof act.annotations === "object") {
+      newManifestEntry.annotations = act.annotations;
+    }
+
+    const oldManifestEntry = manifest.actions[actionId];
+
+    if (!oldManifestEntry) {
+      changes.push({
+        actionId,
+        type: "added",
+        entry: relEntry,
+      });
+      added.push(actionId);
+      if (!options.check) {
+        manifest.actions[actionId] = newManifestEntry;
+      }
+    } else {
+      const changedFields: string[] = [];
+
+      if (oldManifestEntry.entry !== newManifestEntry.entry) {
+        changedFields.push("entry");
+      }
+      if ((oldManifestEntry.description ?? "") !== (newManifestEntry.description ?? "")) {
+        changedFields.push("description");
+      }
+      if (!deepEqual(oldManifestEntry.inputSchema ?? {}, newManifestEntry.inputSchema ?? {})) {
+        changedFields.push("inputSchema");
+      }
+      if (!deepEqual(oldManifestEntry.outputSchema ?? {}, newManifestEntry.outputSchema ?? {})) {
+        changedFields.push("outputSchema");
+      }
+      if (!deepEqual(oldManifestEntry.uses ?? [], newManifestEntry.uses ?? [])) {
+        changedFields.push("uses");
+      }
+      if (!deepEqual(oldManifestEntry.tags ?? [], newManifestEntry.tags ?? [])) {
+        changedFields.push("tags");
+      }
+      if (!deepEqual(oldManifestEntry.annotations ?? {}, newManifestEntry.annotations ?? {})) {
+        changedFields.push("annotations");
+      }
+
+      if (changedFields.length > 0) {
+        changes.push({
+          actionId,
+          type: "updated",
+          entry: relEntry,
+          changedFields,
+        });
+        updated.push(actionId);
+        if (!options.check) {
+          manifest.actions[actionId] = newManifestEntry;
+        }
+      } else {
+        changes.push({
+          actionId,
+          type: "unchanged",
+          entry: relEntry,
+        });
+        unchanged.push(actionId);
+      }
+    }
+  }
+
+  // 5. 检查清单中存在但源码中已不存在的废弃动作
+  for (const [actionId, item] of Object.entries(manifest.actions)) {
+    if (!scannedActionIds.has(actionId)) {
+      changes.push({
+        actionId,
+        type: "removed",
+        entry: item.entry,
+      });
+      removed.push(actionId);
+      if (!options.check && options.prune !== false) {
+        delete manifest.actions[actionId];
+      }
+    }
+  }
+
+  const inSync = added.length === 0 && updated.length === 0 && removed.length === 0;
+
+  // 6. 如果存在变更且非仅检查模式，保存清单文件
+  if (!options.check && !inSync) {
+    saveManifest(projectRoot, manifest);
+  }
+
+  return {
+    inSync,
+    manifestPath,
+    changes,
+    added,
+    updated,
+    removed,
+    unchanged,
+  };
+}
+
+/**
+ * 校验当前 actiondock.manifest.json 是否与动作源码定义保持一致（只读检查）。
+ */
+export async function checkManifestSync(
+  projectRoot: string,
+  options: Omit<SyncManifestOptions, "check"> = {}
+): Promise<ManifestSyncResult> {
+  return syncManifest(projectRoot, { ...options, check: true });
+}
+

package/src/project/types.ts

@@ -90,3 +90,52 @@ export interface ActionDockManifest {
   actions: Record<string, ActionManifestEntry>;
   assets?: string[];
 }
+
+/**
+ * 清单同步操作选项。
+ */
+export interface SyncManifestOptions {
+  /** 自定义 actions 源码目录（默认为工程配置中的 actionsDir 或 "actions"） */
+  actionsDir?: string;
+  /** 是否仅检查同步状态而不保存写入文件（默认 false） */
+  check?: boolean;
+  /** 是否自动移除源码中已不存在的 Action（默认 true） */
+  prune?: boolean;
+  /** 缺失依赖时是否自动执行安装（默认 true） */
+  autoInstall?: boolean;
+}
+
+/**
+ * 单个 Action 的清单同步变更项。
+ */
+export interface ManifestSyncChange {
+  /** Action 标识符 */
+  actionId: string;
+  /** 变更类型：新增、更新、删除或未变 */
+  type: "added" | "updated" | "removed" | "unchanged";
+  /** 源码入口文件相对路径 */
+  entry?: string;
+  /** 发生变更的字段列表（例如 ["description", "inputSchema"]） */
+  changedFields?: string[];
+}
+
+/**
+ * 清单同步执行结果。
+ */
+export interface ManifestSyncResult {
+  /** 清单当前是否已与源码完全一致 */
+  inSync: boolean;
+  /** 清单文件的物理绝对路径 */
+  manifestPath: string;
+  /** 所有 Action 的变更详情列表 */
+  changes: ManifestSyncChange[];
+  /** 新增的 Action 标识列表 */
+  added: string[];
+  /** 更新的 Action 标识列表 */
+  updated: string[];
+  /** 移除的 Action 标识列表 */
+  removed: string[];
+  /** 未改变的 Action 标识列表 */
+  unchanged: string[];
+}
+

package/src/registry/registry.ts

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { findProjectRoot, loadActions, loadPlaybooks, loadProjectConfig } from "../project/loader";
+import { loadManifest } from "../project/manifest";
 import { getActionDockHome, getPackageSlug } from "../utils";
 import type {
   GlobalRegistryData,
@@ -330,6 +331,23 @@ export function listLinkedWorkspaces(customHome?: string): LinkedWorkspaceEntry[
   return Object.values(registry.workspaces || {});
 }
 
+async function projectHasAction(
+  projectRoot: string,
+  actionsDir: string | undefined,
+  actionId: string
+): Promise<boolean> {
+  const manifest = loadManifest(projectRoot);
+  if (manifest?.actions && actionId in manifest.actions) {
+    return true;
+  }
+  try {
+    const actions = await loadActions(projectRoot, actionsDir, { autoInstall: false });
+    return actions.has(actionId);
+  } catch {
+    return false;
+  }
+}
+
 export async function resolveActionProject(
   actionIdentifier: string,
   cwd: string = process.cwd(),
@@ -340,8 +358,7 @@ export async function resolveActionProject(
   if (currentRoot) {
     try {
       const config = loadProjectConfig(currentRoot);
-      const actions = await loadActions(currentRoot, config.actionsDir);
-      if (actions.has(actionIdentifier)) {
+      if (await projectHasAction(currentRoot, config.actionsDir, actionIdentifier)) {
         return {
           projectRoot: currentRoot,
           packageId: config.id,
@@ -370,25 +387,41 @@ export async function resolveActionProject(
   const linkedList = listLinkedPackages(customHome);
 
   if (targetPackage) {
+    let targetRoot: string | undefined;
+    let targetPkgId = targetPackage;
+
     const pkg = linkedList.find(
       (p) => p.id === targetPackage || getPackageSlug(p.id) === targetPackage
     );
+    if (pkg && existsSync(pkg.path)) {
+      targetRoot = pkg.path;
+      targetPkgId = pkg.id;
+    } else if (currentRoot) {
+      try {
+        const config = loadProjectConfig(currentRoot);
+        if (config.id === targetPackage || getPackageSlug(config.id) === targetPackage) {
+          targetRoot = currentRoot;
+          targetPkgId = config.id;
+        }
+      } catch {
+        // Ignore
+      }
+    }
 
-    if (!pkg || !existsSync(pkg.path)) {
+    if (!targetRoot || !existsSync(targetRoot)) {
       throw new Error(
         `Linked package '${targetPackage}' not found or path no longer exists (${pkg?.path || "unregistered"}). Run 'ad link' in the package directory.`
       );
     }
 
-    const config = loadProjectConfig(pkg.path);
-    const actions = await loadActions(pkg.path, config.actionsDir);
-    if (!actions.has(pureActionId)) {
-      throw new Error(`Action '${pureActionId}' not found in package '${pkg.id}' (${pkg.path})`);
+    const config = loadProjectConfig(targetRoot);
+    if (!(await projectHasAction(targetRoot, config.actionsDir, pureActionId))) {
+      throw new Error(`Action '${pureActionId}' not found in package '${targetPkgId}' (${targetRoot})`);
     }
 
     return {
-      projectRoot: pkg.path,
-      packageId: pkg.id,
+      projectRoot: targetRoot,
+      packageId: targetPkgId,
       actionId: pureActionId,
     };
   }
@@ -400,8 +433,7 @@ export async function resolveActionProject(
     if (!existsSync(pkg.path)) continue;
     try {
       const config = loadProjectConfig(pkg.path);
-      const actions = await loadActions(pkg.path, config.actionsDir);
-      if (actions.has(actionIdentifier)) {
+      if (await projectHasAction(pkg.path, config.actionsDir, actionIdentifier)) {
         matches.push({ entry: pkg, actionId: actionIdentifier });
       }
     } catch {
@@ -438,24 +470,69 @@ export function resolvePackageRoot(
   cwd?: string,
   customHome?: string
 ): string | null {
-  if (packageIdOrPath) {
-    const directRoot = findProjectRoot(packageIdOrPath);
-    if (directRoot) return directRoot;
-
-    const linkedList = listLinkedPackages(customHome);
-    const found = linkedList.find(
-      (p) =>
-        p.id === packageIdOrPath ||
-        getPackageSlug(p.id) === packageIdOrPath ||
-        p.path === resolve(packageIdOrPath)
-    );
-    if (found) {
-      return found.path;
+  if (!packageIdOrPath) {
+    return findProjectRoot(cwd);
+  }
+
+  const baseDir = cwd || process.cwd();
+  const resolvedPath = resolve(baseDir, packageIdOrPath);
+
+  // 1. Check if packageIdOrPath is an existing directory or file path on disk
+  if (existsSync(resolvedPath)) {
+    try {
+      const stat = statSync(resolvedPath);
+      const targetDir = stat.isDirectory() ? resolvedPath : dirname(resolvedPath);
+      if (existsSync(join(targetDir, "actiondock.json"))) {
+        return targetDir;
+      }
+      const parentRoot = findProjectRoot(targetDir);
+      if (parentRoot) {
+        return parentRoot;
+      }
+    } catch {
+      // ignore
     }
+  }
+
+  // If it was explicitly a path (starts with . or / or ~ or contains / or \), and did not resolve above:
+  const isExplicitPath =
+    packageIdOrPath.startsWith(".") ||
+    packageIdOrPath.startsWith("/") ||
+    packageIdOrPath.startsWith("~") ||
+    packageIdOrPath.includes("/") ||
+    packageIdOrPath.includes("\\");
+
+  if (isExplicitPath) {
+    // An explicit path that does not exist or is not an ActionDock project must fail
     return null;
   }
 
-  return findProjectRoot(cwd);
+  // 2. Check linked packages in registry
+  const linkedList = listLinkedPackages(customHome);
+  const found = linkedList.find(
+    (p) =>
+      p.id === packageIdOrPath ||
+      getPackageSlug(p.id) === packageIdOrPath ||
+      p.path === resolvedPath
+  );
+  if (found) {
+    return found.path;
+  }
+
+  // 3. Check current project (from cwd)
+  const currentRoot = findProjectRoot(cwd);
+  if (currentRoot) {
+    try {
+      const config = loadProjectConfig(currentRoot);
+      if (config.id === packageIdOrPath || getPackageSlug(config.id) === packageIdOrPath) {
+        return currentRoot;
+      }
+    } catch {
+      // ignore broken config
+    }
+  }
+
+  return null;
 }
 
 export function resolvePlaybookProject(
@@ -499,26 +576,43 @@ export function resolvePlaybookProject(
   const linkedList = listLinkedPackages(customHome);
 
   if (targetPackage) {
+    let targetRoot: string | undefined;
+    let targetPkgId = targetPackage;
+
     const pkg = linkedList.find(
       (p) => p.id === targetPackage || getPackageSlug(p.id) === targetPackage
     );
+    if (pkg && existsSync(pkg.path)) {
+      targetRoot = pkg.path;
+      targetPkgId = pkg.id;
+    } else if (currentRoot) {
+      try {
+        const config = loadProjectConfig(currentRoot);
+        if (config.id === targetPackage || getPackageSlug(config.id) === targetPackage) {
+          targetRoot = currentRoot;
+          targetPkgId = config.id;
+        }
+      } catch {
+        // Ignore
+      }
+    }
 
-    if (!pkg || !existsSync(pkg.path)) {
+    if (!targetRoot || !existsSync(targetRoot)) {
       throw new Error(
         `Linked package '${targetPackage}' not found or path no longer exists (${pkg?.path || "unregistered"}). Run 'ad link' in the package directory.`
       );
     }
 
-    const config = loadProjectConfig(pkg.path);
-    const playbooks = loadPlaybooks(pkg.path, config.playbooksDir);
+    const config = loadProjectConfig(targetRoot);
+    const playbooks = loadPlaybooks(targetRoot, config.playbooksDir);
     const pb = playbooks.get(purePlaybookId);
     if (!pb) {
-      throw new Error(`Playbook '${purePlaybookId}' not found in package '${pkg.id}' (${pkg.path})`);
+      throw new Error(`Playbook '${purePlaybookId}' not found in package '${targetPkgId}' (${targetRoot})`);
     }
 
     return {
-      projectRoot: pkg.path,
-      packageId: pkg.id,
+      projectRoot: targetRoot,
+      packageId: targetPkgId,
       playbookId: purePlaybookId,
       playbook: pb,
     };

package/src/runtime/context.ts

@@ -194,6 +194,7 @@ export interface ContextOptions {
   signal?: AbortSignal;
   process?: ProcessAPI;
   progress?: ProgressReporter;
+  logger?: Logger;
   onActionInvoke?: (
     action: ActionDefinition,
     input: unknown,
@@ -214,7 +215,7 @@ export function createActionContext(options: ContextOptions): ActionContext {
     options.projectConfig
   );
   const state = new RuntimeStateStore(options.storage);
-  const log = new StderrLogger();
+  const log = options.logger || new StderrLogger();
   const signal = options.signal ?? new AbortController().signal;
   const currentRunId = options.runId || randomUUID();
   const currentRootRunId = options.rootRunId || options.parentRunId || currentRunId;

package/src/runtime/index.ts

@@ -6,4 +6,5 @@ export * from "./env";
 export * from "./clock";
 export * from "./process";
 export * from "./events";
+export * from "./module-loader";
 

package/src/runtime/module-loader.ts

@@ -0,0 +1,67 @@
+import { pathToFileURL } from "node:url";
+
+/**
+ * 统一源码模块加载器接口。
+ * 解耦 Action 与各类扩展模块的具体加载机制（如 ECMAScript 原生 import、tsx 动态转译加载等）。
+ */
+export interface ModuleLoader {
+  /**
+   * 解析模块标识符为绝对路径或完整 URL。
+   * 
+   * @param specifier 模块规范说明符或物理路径
+   * @param parentPath 发起解析的父级文件或目录路径
+   */
+  resolve?(specifier: string, parentPath?: string): string;
+
+  /**
+   * 动态加载模块并返回命名空间全量导出对象。
+   * 
+   * @param specifier 模块规范说明符或物理路径
+   * @param parentPath 发起加载的父级文件或目录路径
+   */
+  load<T = any>(specifier: string, parentPath?: string): Promise<T>;
+
+  /**
+   * 加载模块并解包其默认导出（default 或 action 属性）。
+   * 
+   * @param specifier 模块规范说明符或物理路径
+   * @param parentPath 发起加载的父级文件或目录路径
+   */
+  loadDefault?<T = any>(specifier: string, parentPath?: string): Promise<T>;
+}
+
+/**
+ * 基于标准 ECMAScript 动态 import 的默认模块加载器。
+ */
+export class DefaultModuleLoader implements ModuleLoader {
+  async load<T = any>(specifier: string, _parentPath?: string): Promise<T> {
+    const importSpecifier = specifier.startsWith("file://")
+      ? specifier
+      : pathToFileURL(specifier).href;
+    return (await import(importSpecifier)) as T;
+  }
+
+  async loadDefault<T = any>(specifier: string, parentPath?: string): Promise<T> {
+    const mod = await this.load<any>(specifier, parentPath);
+    return (mod?.default !== undefined ? mod.default : mod?.action !== undefined ? mod.action : mod) as T;
+  }
+}
+
+let globalModuleLoader: ModuleLoader | undefined;
+
+/**
+ * 注册全局模块加载器实现。
+ */
+export function setModuleLoader(loader: ModuleLoader): void {
+  globalModuleLoader = loader;
+}
+
+/**
+ * 获取当前全局模块加载器，若未显式注册则回退使用 DefaultModuleLoader。
+ */
+export function getModuleLoader(): ModuleLoader {
+  if (!globalModuleLoader) {
+    globalModuleLoader = new DefaultModuleLoader();
+  }
+  return globalModuleLoader;
+}

package/src/runtime/process.ts

@@ -200,23 +200,24 @@ export class DefaultProcessExecutor implements ProcessExecutor {
         }
 
         try {
-          const checkRes = await this.exec(options.command, ["--version"], {
-            timeoutMs: 1000,
-          });
-          const isReady = await options.probe(checkRes);
+          const res: DetachedProcessResult = {
+            ok: true,
+            pid: child.pid,
+            ready: true,
+            durationMs: Date.now() - startTime,
+          };
+          const isReady = await options.probe(res as any);
           if (isReady) {
-            return {
-              ok: true,
-              pid: child.pid,
-              ready: true,
-              durationMs: Date.now() - startTime,
-            };
+            return res;
           }
         } catch {
           // 探测失败继续轮询
         }
 
-        await new Promise((r) => setTimeout(r, probeInterval));
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) break;
+        const sleepTime = Math.min(probeInterval, remaining);
+        await new Promise((r) => setTimeout(r, sleepTime));
       }
 
       return {