@actiondock/core 2.0.9 → 2.0.11-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/core",
-  "version": "2.0.9",
+  "version": "2.0.11-beta.0",
   "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
   "type": "module",
   "main": "./src/index.ts",
@@ -27,7 +27,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@actiondock/sdk": "^2.0.9",
+    "@actiondock/sdk": "2.0.11-beta.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "yaml": "^2.7.0"

package/src/build/index.ts

@@ -1,2 +1 @@
-export * from "./builder";
 export * from "./templates";

package/src/build/templates.ts

@@ -27,7 +27,7 @@ export function generateStandaloneEntrypoint(
   configDefs?: Record<string, unknown>
 ): string {
   // Resolve path to standalone runtime inside @actiondock/cli
-  const standaloneRuntimePath = resolve(__dirname, "../runtime/standalone");
+  const standaloneRuntimePath = resolve(import.meta.dirname, "../runtime/standalone");
 
   const imports = actions
     .map((a, idx) => `import action_${idx} from ${JSON.stringify(a.filePath)};`)

package/src/catalog/types.ts

@@ -72,12 +72,4 @@ export interface IndexedAction {
   projectRoot: string;
 }
 
-/**
- * 模块加载器接口。
- */
-export interface ModuleLoader {
-  load<T>(file: string, options: {
-    projectRoot: string;
-    tsconfigPath?: string;
-  }): Promise<T>;
-}
+export type { ModuleLoader } from "../runtime/module-loader";

package/src/doctor/doctor.ts

@@ -1,9 +1,10 @@
-import { existsSync } from "node:fs";
-import { delimiter, join } from "node:path";
-import { findProjectRoot, loadActions, loadPlaybooks, loadProjectConfig } from "../project/loader";
+import { existsSync, statSync } from "node:fs";
+import { delimiter, join, relative } from "node:path";
+import { discoverActionFiles, findProjectRoot, loadActions, loadPlaybooks, loadProjectConfig } from "../project/loader";
+import { loadManifest, MANIFEST_FILE_NAME } from "../project/manifest";
 import { getRegistryStatus } from "../registry/registry";
 import { createGlobalStorage, createStorage } from "../storage";
-import { getActionDockHome } from "../utils";
+import { findExecutable, getActionDockHome } from "../utils";
 import type { DoctorCheckItem, DoctorReport } from "./types";
 
 function compareSemver(v1: string, v2: string): number {
@@ -18,36 +19,6 @@ 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;
@@ -244,15 +215,23 @@ export async function runDoctorChecks(options?: {
 
       // Actions Check
       try {
-        const actions = await loadActions(projectRoot, config.actionsDir);
-        if (actions.size === 0) {
+        const manifest = loadManifest(projectRoot);
+        let actionsCount = 0;
+        if (manifest?.actions) {
+          actionsCount = Object.keys(manifest.actions).length;
+        } else {
+          const actions = await loadActions(projectRoot, config.actionsDir, { autoInstall: false });
+          actionsCount = actions.size;
+        }
+
+        if (actionsCount === 0) {
           checks.push({
             id: "project.actions",
             category: "project",
             name: "Actions",
             status: "warn",
             message: `No actions found in '${config.actionsDir || "actions"}'`,
-            fix: "Run 'ad action create <id>' to create your first action",
+            fix: "Run 'ad action new <id>' to create your first action",
           });
         } else {
           checks.push({
@@ -260,7 +239,7 @@ export async function runDoctorChecks(options?: {
             category: "project",
             name: "Actions",
             status: "ok",
-            message: `${actions.size} action(s) valid and loaded`,
+            message: `${actionsCount} action(s) valid and loaded`,
           });
         }
       } catch (err: any) {
@@ -273,6 +252,88 @@ export async function runDoctorChecks(options?: {
         });
       }
 
+      // Project Manifest Check (Lightweight Static Detection)
+      try {
+        const manifestPath = join(projectRoot, MANIFEST_FILE_NAME);
+        const manifest = loadManifest(projectRoot);
+        const actionFiles = discoverActionFiles(projectRoot, config.actionsDir || "actions");
+
+        if (!existsSync(manifestPath)) {
+          if (actionFiles.length > 0) {
+            checks.push({
+              id: "project.manifest",
+              category: "project",
+              name: "Action Manifest",
+              status: "warn",
+              message: `${MANIFEST_FILE_NAME} not found (${actionFiles.length} action source file(s) exist)`,
+              fix: "Run 'ad action sync' to generate manifest",
+            });
+          }
+        } else if (manifest && manifest.actions) {
+          const missingFiles = Object.entries(manifest.actions)
+            .filter(([_, item]) => !existsSync(join(projectRoot, item.entry)))
+            .map(([id, item]) => `${id} (${item.entry})`);
+
+          const manifestEntries = new Set(
+            Object.values(manifest.actions).map((a) => a.entry.replace(/\\/g, "/"))
+          );
+          const untracked = actionFiles
+            .map((f) => relative(projectRoot, f).replace(/\\/g, "/"))
+            .filter((rel) => !manifestEntries.has(rel));
+
+          if (missingFiles.length > 0) {
+            checks.push({
+              id: "project.manifest",
+              category: "project",
+              name: "Action Manifest",
+              status: "warn",
+              message: `${missingFiles.length} action(s) in manifest point to missing files: ${missingFiles.join(", ")}`,
+              fix: "Run 'ad action sync' to synchronize manifest",
+            });
+          } else if (untracked.length > 0) {
+            checks.push({
+              id: "project.manifest",
+              category: "project",
+              name: "Action Manifest",
+              status: "warn",
+              message: `${untracked.length} action file(s) not declared in manifest: ${untracked.join(", ")}`,
+              fix: "Run 'ad action sync' to synchronize manifest",
+            });
+          } else {
+            const manifestStat = statSync(manifestPath);
+            const newerFiles = actionFiles.filter(
+              (f) => statSync(f).mtimeMs > manifestStat.mtimeMs + 2000
+            );
+            if (newerFiles.length > 0) {
+              checks.push({
+                id: "project.manifest",
+                category: "project",
+                name: "Action Manifest",
+                status: "ok",
+                message: `Manifest valid (Note: ${newerFiles.length} action file(s) modified after manifest; run 'ad action sync' if definitions changed)`,
+              });
+            } else {
+              checks.push({
+                id: "project.manifest",
+                category: "project",
+                name: "Action Manifest",
+                status: "ok",
+                message: "Manifest synchronized with action files",
+              });
+            }
+          }
+        }
+      } catch (err: any) {
+        checks.push({
+          id: "project.manifest",
+          category: "project",
+          name: "Action Manifest",
+          status: "error",
+          message: `Failed to inspect manifest: ${err.message}`,
+        });
+      }
+
+
       // Playbooks Check
       try {
         const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);

package/src/execution/service.ts

@@ -5,6 +5,7 @@ import type {
   ExecutionEvent,
   ExecutionResult,
   JsonValue,
+  Logger,
   ProgressReporter,
   RunRecord,
   RunStatus,
@@ -159,6 +160,7 @@ export class DefaultExecutionService implements ExecutionService {
       }
     }
 
+    const runId = randomUUID();
     let sequence = 0;
     type EventPayload =
       | { type: "log"; level: "debug" | "info" | "warn" | "error"; message: string; data?: JsonValue }
@@ -166,16 +168,11 @@ export class DefaultExecutionService implements ExecutionService {
       | { 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,
+        runId,
+        rootRunId: runId,
         sequence: sequence++,
         timestamp: new Date().toISOString(),
       };
@@ -193,6 +190,49 @@ export class DefaultExecutionService implements ExecutionService {
       },
     };
 
+    const executionLogger: Logger = {
+      debug(message: string, data?: unknown) {
+        emitEvent({
+          type: "log",
+          level: "debug",
+          message,
+          data: data as JsonValue | undefined,
+        });
+      },
+      info(message: string, data?: unknown) {
+        emitEvent({
+          type: "log",
+          level: "info",
+          message,
+          data: data as JsonValue | undefined,
+        });
+      },
+      warn(message: string, data?: unknown) {
+        emitEvent({
+          type: "log",
+          level: "warn",
+          message,
+          data: data as JsonValue | undefined,
+        });
+      },
+      error(message: string, data?: unknown) {
+        emitEvent({
+          type: "log",
+          level: "error",
+          message,
+          data: data as JsonValue | undefined,
+        });
+      },
+    };
+
+    const handle = this.runner.start(action, input, {
+      runId,
+      signal: controller.signal,
+      timeoutMs: options.timeoutMs,
+      progress: progressReporter,
+      logger: executionLogger,
+    });
+
     const activeItem: ActiveRun = {
       runId: handle.runId,
       handle,

package/src/export/index.ts

@@ -1,2 +1 @@
-export * from "./skill";
 export * from "./templates";