@actiondock/core 2.0.9 → 2.0.11-beta.0

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,166 @@ 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;
+  }
+}
+
+function projectHasActionSync(
+  projectRoot: string,
+  actionsDir: string | undefined,
+  actionId: string
+): boolean {
+  const manifest = loadManifest(projectRoot);
+  if (manifest?.actions && actionId in manifest.actions) {
+    return true;
+  }
+  const dir = join(projectRoot, actionsDir || "actions");
+  if (!existsSync(dir)) {
+    return false;
+  }
+  if (actionId.includes("..") || actionId.startsWith("/") || actionId.startsWith("\\")) {
+    return false;
+  }
+  if (existsSync(join(dir, `${actionId}.ts`)) || existsSync(join(dir, `${actionId}.js`))) {
+    return true;
+  }
+  const relFile = actionId.replace(/\./g, "/");
+  if (existsSync(join(dir, `${relFile}.ts`)) || existsSync(join(dir, `${relFile}.js`))) {
+    return true;
+  }
+  return false;
+}
+
+export function resolveActionProjectSync(
+  actionIdentifier: string,
+  cwd: string = process.cwd(),
+  customHome?: string
+): ResolvedActionProject {
+  // 1. Check current directory / parent project
+  const currentRoot = findProjectRoot(cwd);
+  if (currentRoot) {
+    try {
+      const config = loadProjectConfig(currentRoot);
+      if (projectHasActionSync(currentRoot, config.actionsDir, actionIdentifier)) {
+        return {
+          projectRoot: currentRoot,
+          packageId: config.id,
+          actionId: actionIdentifier,
+        };
+      }
+    } catch {
+      // Ignore and proceed to registry lookup
+    }
+  }
+
+  // 2. Check if scoped format: <package-id>/<action-id> or <package-id>:<action-id>
+  let targetPackage: string | undefined;
+  let pureActionId = actionIdentifier;
+
+  if (actionIdentifier.includes("/")) {
+    const slashIdx = actionIdentifier.lastIndexOf("/");
+    targetPackage = actionIdentifier.slice(0, slashIdx);
+    pureActionId = actionIdentifier.slice(slashIdx + 1);
+  } else if (actionIdentifier.includes(":")) {
+    const colonIdx = actionIdentifier.lastIndexOf(":");
+    targetPackage = actionIdentifier.slice(0, colonIdx);
+    pureActionId = actionIdentifier.slice(colonIdx + 1);
+  }
+
+  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 (!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(targetRoot);
+    if (!projectHasActionSync(targetRoot, config.actionsDir, pureActionId)) {
+      throw new Error(`Action '${pureActionId}' not found in package '${targetPkgId}' (${targetRoot})`);
+    }
+
+    return {
+      projectRoot: targetRoot,
+      packageId: targetPkgId,
+      actionId: pureActionId,
+    };
+  }
+
+  // 3. Search across all linked packages
+  const matches: Array<{ entry: LinkedPackageEntry; actionId: string }> = [];
+
+  for (const pkg of linkedList) {
+    if (!existsSync(pkg.path)) continue;
+    try {
+      const config = loadProjectConfig(pkg.path);
+      if (projectHasActionSync(pkg.path, config.actionsDir, actionIdentifier)) {
+        matches.push({ entry: pkg, actionId: actionIdentifier });
+      }
+    } catch {
+      // Ignore invalid linked package
+    }
+  }
+
+  if (matches.length === 1) {
+    return {
+      projectRoot: matches[0].entry.path,
+      packageId: matches[0].entry.id,
+      actionId: matches[0].actionId,
+    };
+  }
+
+  if (matches.length > 1) {
+    const pkgList = matches.map((m) => `'${m.entry.id}'`).join(", ");
+    throw new Error(
+      `Action '${actionIdentifier}' is provided by multiple linked packages: ${pkgList}. Please specify using '<package-id>/${actionIdentifier}'.`
+    );
+  }
+
+  if (currentRoot) {
+    throw new Error(`Action '${actionIdentifier}' not found in current project or any linked packages`);
+  } else {
+    throw new Error(
+      `Action '${actionIdentifier}' not found. You are not in an ActionDock project, and no linked package provides '${actionIdentifier}'. Use 'ad link' to register your package.`
+    );
+  }
+}
+
 export async function resolveActionProject(
   actionIdentifier: string,
   cwd: string = process.cwd(),
@@ -340,8 +501,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,
@@ -358,11 +518,11 @@ export async function resolveActionProject(
   let pureActionId = actionIdentifier;
 
   if (actionIdentifier.includes("/")) {
-    const slashIdx = actionIdentifier.indexOf("/");
+    const slashIdx = actionIdentifier.lastIndexOf("/");
     targetPackage = actionIdentifier.slice(0, slashIdx);
     pureActionId = actionIdentifier.slice(slashIdx + 1);
   } else if (actionIdentifier.includes(":")) {
-    const colonIdx = actionIdentifier.indexOf(":");
+    const colonIdx = actionIdentifier.lastIndexOf(":");
     targetPackage = actionIdentifier.slice(0, colonIdx);
     pureActionId = actionIdentifier.slice(colonIdx + 1);
   }
@@ -370,25 +530,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 +576,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 +613,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 +719,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

@@ -3,6 +3,7 @@ import type {
   ActionContext,
   ActionDefinition,
   ActionInvoker,
+  ActionRef,
   Config,
   Logger,
   ProcessAPI,
@@ -194,8 +195,9 @@ export interface ContextOptions {
   signal?: AbortSignal;
   process?: ProcessAPI;
   progress?: ProgressReporter;
+  logger?: Logger;
   onActionInvoke?: (
-    action: ActionDefinition,
+    action: ActionDefinition | ActionRef | string,
     input: unknown,
     parentRunId?: string
   ) => Promise<unknown>;
@@ -214,13 +216,16 @@ 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;
 
   const invoker: ActionInvoker = {
-    async invoke<I, O>(action: ActionDefinition<I, O>, input: I): Promise<O> {
+    async invoke<I, O>(
+      action: ActionDefinition<I, O> | ActionRef | string,
+      input?: I
+    ): Promise<O> {
       if (options.onActionInvoke) {
         return (await options.onActionInvoke(
           action as any,