@actiondock/core 2.0.0

package/README.md

@@ -0,0 +1,50 @@
+# @actiondock/core
+
+The core engine and domain kernel of ActionDock 2.0.
+
+[![Bun](https://img.shields.io/badge/Bun-%3E%3D1.2-black?logo=bun)](https://bun.sh/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+`@actiondock/core` provides the project loader, runtime execution engine (`ActionRunner`), native SQLite persistence, standalone binary compiler, remote HTTP server/client, and Agent Skill exporter.
+
+> **Role & Usage Context**:
+> - **Authoring Actions**: Use [`@actiondock/sdk`](../sdk) for defining actions, testing with in-memory harness, and zero-dependency action packages.
+> - **CLI Toolchain**: Use [`@actiondock/cli`](../cli) (`ac`) for command-line workflows.
+> - **Engine & Embedding**: Use `@actiondock/core` when you need programmatic access to the ActionRunner engine, project loader, or custom server integrations.
+>
+> **Runtime requirement**: [Bun](https://bun.sh/) >= 1.2.0 is required (`@actiondock/core` leverages native `bun:sqlite` and Bun runtime APIs).
+
+---
+
+## Installation
+
+```bash
+bun add @actiondock/core
+```
+
+---
+
+## Key Modules
+
+- **Project Loader** (`loadProjectConfig`, `loadActions`, `loadPlaybooks`, `initProject`): Discovers and parses Action Packages.
+- **Runtime Execution** (`ActionRunner`, `createActionContext`, `createStandaloneRuntime`): Manages the full action execution lifecycle, schema validation, cycle detection, timeouts, and JSON envelopes.
+- **Storage** (`SqliteRuntimeStorage`, `createStorage`, `createGlobalStorage`): Native SQLite KV store with namespaces, TTL, and WAL mode.
+- **Standalone Builder** (`buildProject`): Uses Bun's native bundler to compile actions into a single standalone binary.
+- **Skill Exporter** (`exportSkill`): Generates self-contained Agent Skills with Playbook SOPs.
+- **Profile & Remote Runner** (`ProfileManager`, `ActionServer`, `executeRemoteAction`): Multi-cloud remote execution with token authentication.
+
+---
+
+## 📖 Documentation
+
+- [Runtime Architecture](https://github.com/team4u/actiondock/blob/main/docs/architecture/runtime.md)
+- [Storage & Persistence Guide](https://github.com/team4u/actiondock/blob/main/docs/guides/storage.md)
+- [Standalone Binary Build](https://github.com/team4u/actiondock/blob/main/docs/guides/standalone-build.md)
+- [HTTP Server & Remote Dispatch](https://github.com/team4u/actiondock/blob/main/docs/guides/http-server.md)
+
+---
+
+## License
+
+[Apache-2.0](LICENSE) © team4u

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@actiondock/core",
+  "version": "2.0.0",
+  "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
+  "type": "module",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@actiondock/sdk": "^2.0.0",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "keywords": ["actiondock", "core", "runtime", "storage", "builder"],
+  "author": "team4u",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/team4u/actiondock.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/team4u/actiondock#readme",
+  "bugs": {
+    "url": "https://github.com/team4u/actiondock/issues"
+  }
+}

package/src/build/builder.ts

@@ -0,0 +1,205 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { loadActionFileMap, loadActions, loadProjectConfig } from "../project/loader";
+import type { ProjectConfig } from "../project/types";
+import { getPackageSlug } from "../utils";
+import { type ActionImport, generateStandaloneEntrypoint } from "./templates";
+
+/**
+ * 独立二进制可执行文件构建选项。
+ */
+export interface BuildOptions {
+  /** 目标项目根目录 */
+  projectRoot: string;
+  /** 目标架构（如 "bun-linux-x64", "bun-darwin-arm64", "bun-windows-x64" 等） */
+  target?: string;
+  /** 输出可执行文件的目标路径（默认输出到 dist/ 目录） */
+  outfile?: string;
+  /** 是否开启代码压缩混淆（默认 true） */
+  minify?: boolean;
+  /** 是否编译为 V8/JavaScriptCore 字节码（默认 false） */
+  bytecode?: boolean;
+  /** 显式挑选打包的 Action ID 清单（用于按需子集打包） */
+  actions?: string[];
+}
+
+/**
+ * 独立二进制构建完成后的元数据结果对象。
+ */
+export interface BuildResult {
+  /** 所属 Package ID */
+  packageId: string;
+  /** 打包的项目版本号 */
+  version: string;
+  /** 编译的目标平台架构 */
+  target: string;
+  /** 生成的独立二进制可执行文件绝对路径 */
+  executablePath: string;
+  /** 生成的 sidecar 元数据 JSON 文件绝对路径 */
+  metadataPath: string;
+  /** 打包内置的 Action ID 列表 */
+  actions: string[];
+}
+
+/**
+ * 调用 Bun 原生编译引擎（Bun.build --compile）将 Action Package 打包为零外部依赖的独立二进制可执行文件。
+ * 
+ * 构建过程：
+ * 1. 动态生成 Standalone 入口点代码（包含 StandaloneRuntime 与 Action 注册）。
+ * 2. 生成 sidecar metadata 文件（.actiondock-meta.json），包含 Package 元数据与 sha256 校验和。
+ * 3. 执行 Bun.build({ compile: true, target, minify, bytecode })。
+ * 
+ * @param options 构建参数
+ * @returns 构建产物结果元数据
+ */
+export async function buildProject(options: BuildOptions): Promise<BuildResult> {
+  const root = resolve(options.projectRoot);
+  const config = loadProjectConfig(root);
+  const actionsMap = await loadActions(root, config.actionsDir);
+
+  if (actionsMap.size === 0) {
+    throw new Error(`No valid actions found in ${join(root, config.actionsDir || "actions")}`);
+  }
+
+  if (options.actions && options.actions.length > 0) {
+    const requestedActions = new Set(options.actions);
+    for (const reqId of requestedActions) {
+      if (!actionsMap.has(reqId)) {
+        throw new Error(`Action '${reqId}' requested in build options not found in project`);
+      }
+    }
+    for (const id of Array.from(actionsMap.keys())) {
+      if (!requestedActions.has(id)) {
+        actionsMap.delete(id);
+      }
+    }
+  }
+
+  // Action imports list
+  const actionFileMap = await loadActionFileMap(root, config.actionsDir);
+  const actionImports: ActionImport[] = [];
+
+  for (const [id, entry] of actionFileMap.entries()) {
+    if (actionsMap.has(id)) {
+      actionImports.push({
+        id,
+        filePath: entry.filePath,
+      });
+    }
+  }
+
+  if (actionImports.length === 0) {
+    throw new Error("Could not map any action files for build");
+  }
+
+  // Create build dir
+  const buildDir = join(root, ".actiondock", ".build");
+  mkdirSync(buildDir, { recursive: true });
+
+  const entryCode = generateStandaloneEntrypoint(
+    config.id,
+    config.version,
+    config.description,
+    actionImports,
+    config.config
+  );
+  const entryPath = join(buildDir, "entry.ts");
+  writeFileSync(entryPath, entryCode, "utf-8");
+
+  // Determine target and outfile
+  const target = options.target || "bun";
+  const binaryName = getPackageSlug(config.id);
+
+  const defaultOutfile = join(root, "dist", binaryName);
+  const outfile = resolve(options.outfile || defaultOutfile);
+
+  mkdirSync(dirname(outfile), { recursive: true });
+
+  // Run bun build --compile --bytecode --minify
+  const buildArgs = [
+    "bun",
+    "build",
+    entryPath,
+    "--compile",
+    "--outfile",
+    outfile,
+  ];
+
+  if (options.bytecode !== false) {
+    buildArgs.push("--bytecode");
+  }
+
+  if (options.minify !== false) {
+    buildArgs.push("--minify");
+  }
+
+  if (options.target && options.target !== "bun" && options.target !== "host") {
+    // e.g. bun-linux-x64 or linux-x64
+    const formattedTarget = options.target.startsWith("bun-")
+      ? options.target
+      : `bun-${options.target}`;
+    buildArgs.push(`--target=${formattedTarget}`);
+  }
+
+  const proc = Bun.spawnSync(buildArgs, {
+    cwd: root,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  if (proc.exitCode !== 0) {
+    const errText = proc.stderr.toString() || proc.stdout.toString();
+    throw new Error(`Bun compile failed (exit code ${proc.exitCode}):\n${errText}`);
+  }
+
+  // Compile artifact resolution (on Windows bun compile automatically appends .exe)
+  let artifactPath = outfile;
+  if (!existsSync(artifactPath)) {
+    const withExe = outfile + ".exe";
+    if (existsSync(withExe)) {
+      artifactPath = withExe;
+    }
+  }
+
+  // Calculate build hash
+  const binaryBuffer = readFileSync(artifactPath);
+  const buildHash = createHash("sha256").update(binaryBuffer).digest("hex").slice(0, 16);
+
+  // Calculate lockHash
+  let lockHash = "none";
+  const lockFiles = ["bun.lock", "bun.lockb", "package.json"];
+  for (const lf of lockFiles) {
+    const p = join(root, lf);
+    if (existsSync(p)) {
+      lockHash = createHash("sha256").update(readFileSync(p)).digest("hex").slice(0, 16);
+      break;
+    }
+  }
+
+  // Generate artifact.json metadata
+  const metadata = {
+    packageId: config.id,
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    target: options.target || "host",
+    actions: actionImports.map((a) => a.id),
+    bunVersion: Bun.version,
+    lockHash,
+    buildHash,
+    createdAt: new Date().toISOString(),
+  };
+
+  const metadataPath = join(dirname(artifactPath), "artifact.json");
+  writeFileSync(metadataPath, JSON.stringify(metadata, null, 2) + "\n", "utf-8");
+
+  return {
+    packageId: config.id,
+    version: config.version,
+    target: options.target || "host",
+    executablePath: artifactPath,
+    metadataPath,
+    actions: metadata.actions,
+  };
+}

package/src/build/index.ts

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

package/src/build/templates.ts

@@ -0,0 +1,59 @@
+import { resolve } from "node:path";
+
+/**
+ * 构建时 Action 导入映射。
+ */
+export interface ActionImport {
+  /** Action 唯一标识符 */
+  id: string;
+  /** Action 源码文件物理路径 */
+  filePath: string;
+}
+
+/**
+ * 动态生成 Standalone 独立可执行文件的 TypeScript 入口文件源码。
+ * 
+ * @param packageId 所属 Package ID
+ * @param version 版本号
+ * @param description 描述
+ * @param actions 待打包 Action 列表
+ * @param configDefs 声明的配置定义字典
+ */
+export function generateStandaloneEntrypoint(
+  packageId: string,
+  version: string,
+  description: string | undefined,
+  actions: ActionImport[],
+  configDefs?: Record<string, unknown>
+): string {
+  // Resolve path to standalone runtime inside @actiondock/cli
+  const standaloneRuntimePath = resolve(__dirname, "../runtime/standalone");
+
+  const imports = actions
+    .map((a, idx) => `import action_${idx} from ${JSON.stringify(a.filePath)};`)
+    .join("\n");
+
+  const actionArray = actions
+    .map((_, idx) => `action_${idx}`)
+    .join(",\n    ");
+
+  return `// AUTO-GENERATED ENTRYPOINT BY ACTIONDOCK BUILDER. DO NOT EDIT.
+import { createStandaloneRuntime } from ${JSON.stringify(standaloneRuntimePath)};
+${imports}
+
+const app = createStandaloneRuntime({
+  packageId: ${JSON.stringify(packageId)},
+  version: ${JSON.stringify(version)},
+  description: ${JSON.stringify(description || "")},
+  config: ${JSON.stringify(configDefs || {})},
+  actions: [
+    ${actionArray}
+  ],
+});
+
+app.run(process.argv.slice(2)).catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});
+`;
+}

package/src/doctor/doctor.ts

@@ -0,0 +1,332 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { findProjectRoot, loadActions, loadPlaybooks, loadProjectConfig } from "../project/loader";
+import { getRegistryStatus } from "../registry/registry";
+import { createGlobalStorage, createStorage } from "../storage";
+import { getActionDockHome } from "../utils";
+import type { DoctorCheckItem, DoctorReport } from "./types";
+
+function compareSemver(v1: string, v2: string): number {
+  const p1 = v1.replace(/^v/, "").split(".").map(Number);
+  const p2 = v2.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < Math.max(p1.length, p2.length); i++) {
+    const num1 = p1[i] || 0;
+    const num2 = p2[i] || 0;
+    if (num1 > num2) return 1;
+    if (num1 < num2) return -1;
+  }
+  return 0;
+}
+
+export async function runDoctorChecks(options?: {
+  cwd?: string;
+  packageIdOrPath?: string;
+  customHome?: string;
+}): Promise<DoctorReport> {
+  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;
+  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",
+      });
+    }
+  } else {
+    checks.push({
+      id: "runtime.bun",
+      category: "runtime",
+      name: "Bun Runtime",
+      status: "error",
+      message: "Bun runtime not detected",
+      fix: "Install Bun via 'npm install bun -g'",
+    });
+  }
+
+  // 2. Check CLI in PATH
+  let acPath: string | null = null;
+  try {
+    acPath = typeof Bun !== "undefined" && Bun.which ? Bun.which("ac") : null;
+  } catch {
+    // ignore
+  }
+
+  if (acPath) {
+    checks.push({
+      id: "runtime.cli",
+      category: "runtime",
+      name: "CLI Executable",
+      status: "ok",
+      message: `Found 'ac' in PATH at ${acPath}`,
+    });
+  } else {
+    checks.push({
+      id: "runtime.cli",
+      category: "runtime",
+      name: "CLI Executable",
+      status: "warn",
+      message: "'ac' command not found in PATH",
+      fix: "Run 'bun add -g @actiondock/cli' or in SDK workspace run 'cd packages/cli && bun link'",
+    });
+  }
+
+  // 3. Check Global Storage
+  const globalHome = getActionDockHome(options?.customHome);
+  try {
+    const globalStorage = createGlobalStorage(options?.customHome);
+    await globalStorage.setConfig("_doctor_probe_", "ok");
+    await globalStorage.deleteConfig("_doctor_probe_");
+    globalStorage.close();
+
+    checks.push({
+      id: "storage.global",
+      category: "storage",
+      name: "Global Storage",
+      status: "ok",
+      message: `Database writable at ${join(globalHome, ".actiondock", "global.db")}`,
+    });
+  } catch (err: any) {
+    checks.push({
+      id: "storage.global",
+      category: "storage",
+      name: "Global Storage",
+      status: "error",
+      message: `Failed to write global database: ${err.message}`,
+      fix: `Check write permissions for directory '${join(globalHome, ".actiondock")}'`,
+    });
+  }
+
+  // 4. Check Global Registry Health
+  try {
+    const regStatus = getRegistryStatus(options?.customHome);
+    if (regStatus.staleCount > 0) {
+      checks.push({
+        id: "registry.global",
+        category: "registry",
+        name: "Global Registry",
+        status: "warn",
+        message: `${regStatus.totalPackagesCount} package(s), ${regStatus.workspaces.length} workspace(s), but ${regStatus.staleCount} stale path(s) detected`,
+        fix: "Run 'ac unlink --prune' to clean up stale entries from registry",
+      });
+    } else {
+      checks.push({
+        id: "registry.global",
+        category: "registry",
+        name: "Global Registry",
+        status: "ok",
+        message: `${regStatus.totalPackagesCount} linked package(s), ${regStatus.workspaces.length} workspace(s) (0 stale)`,
+      });
+    }
+  } catch (err: any) {
+    checks.push({
+      id: "registry.global",
+      category: "registry",
+      name: "Global Registry",
+      status: "error",
+      message: `Failed to read registry: ${err.message}`,
+    });
+  }
+
+  // 5. Check Project Context
+  let projectRoot: string | null = null;
+  if (options?.packageIdOrPath) {
+    projectRoot = findProjectRoot(options.packageIdOrPath);
+  } else {
+    projectRoot = findProjectRoot(cwd);
+  }
+
+  let packageId: string | undefined;
+
+  if (projectRoot) {
+    try {
+      const config = loadProjectConfig(projectRoot);
+      packageId = config.id;
+
+      // Project Config Check
+      checks.push({
+        id: "project.config",
+        category: "project",
+        name: "Project Configuration",
+        status: "ok",
+        message: `Valid (${config.id} v${config.version})`,
+      });
+
+      // SDK Resolution Check
+      const hasSdkInNodeModules =
+        existsSync(join(projectRoot, "node_modules", "@actiondock", "sdk")) ||
+        existsSync(join(projectRoot, "node_modules", "@actiondock", "sdk", "package.json"));
+
+      if (hasSdkInNodeModules) {
+        checks.push({
+          id: "project.sdk",
+          category: "project",
+          name: "SDK Dependency",
+          status: "ok",
+          message: "Resolved @actiondock/sdk in node_modules",
+        });
+      } else {
+        checks.push({
+          id: "project.sdk",
+          category: "project",
+          name: "SDK Dependency",
+          status: "warn",
+          message: "@actiondock/sdk not found in project node_modules",
+          fix: "Run 'bun link @actiondock/sdk' or 'bun install' in project directory",
+        });
+      }
+
+      // Project Runtime Database Check
+      try {
+        const projectStorage = createStorage(config.id, { projectRoot });
+        await projectStorage.setConfig("_doctor_probe_", "ok");
+        await projectStorage.deleteConfig("_doctor_probe_");
+        projectStorage.close();
+
+        checks.push({
+          id: "project.storage",
+          category: "project",
+          name: "Project Database",
+          status: "ok",
+          message: `Database writable at ${join(projectRoot, ".actiondock", "runtime.db")}`,
+        });
+      } catch (err: any) {
+        checks.push({
+          id: "project.storage",
+          category: "project",
+          name: "Project Database",
+          status: "error",
+          message: `Failed to write project runtime database: ${err.message}`,
+          fix: `Check write permissions for '${join(projectRoot, ".actiondock")}'`,
+        });
+      }
+
+      // Actions Check
+      try {
+        const actions = await loadActions(projectRoot, config.actionsDir);
+        if (actions.size === 0) {
+          checks.push({
+            id: "project.actions",
+            category: "project",
+            name: "Actions",
+            status: "warn",
+            message: `No actions found in '${config.actionsDir || "actions"}'`,
+            fix: "Run 'ac action create <id>' to create your first action",
+          });
+        } else {
+          checks.push({
+            id: "project.actions",
+            category: "project",
+            name: "Actions",
+            status: "ok",
+            message: `${actions.size} action(s) valid and loaded`,
+          });
+        }
+      } catch (err: any) {
+        checks.push({
+          id: "project.actions",
+          category: "project",
+          name: "Actions",
+          status: "error",
+          message: `Failed to load actions: ${err.message}`,
+        });
+      }
+
+      // Playbooks Check
+      try {
+        const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
+        checks.push({
+          id: "project.playbooks",
+          category: "project",
+          name: "Playbooks",
+          status: "ok",
+          message: `${playbooks.size} playbook(s) valid`,
+        });
+      } catch (err: any) {
+        checks.push({
+          id: "project.playbooks",
+          category: "project",
+          name: "Playbooks",
+          status: "warn",
+          message: `Playbooks issue: ${err.message}`,
+        });
+      }
+
+      // Config readiness check
+      if (config.config && Object.keys(config.config).length > 0) {
+        const missingKeys: string[] = [];
+        const projectStorage = createStorage(config.id, { projectRoot });
+        for (const [key, def] of Object.entries(config.config)) {
+          const inStorage = await projectStorage.getConfig(key);
+          const envNames = Array.isArray(def.env) ? def.env : def.env ? [def.env] : [key];
+          const inEnv = envNames.some((e) => process.env[e] !== undefined);
+          const isRequired = (def as any).required || (def.default === undefined && def.secret);
+          if ((isRequired || def.default === undefined) && inStorage === undefined && !inEnv) {
+            missingKeys.push(key);
+          }
+        }
+        projectStorage.close();
+
+        if (missingKeys.length > 0) {
+          checks.push({
+            id: "project.config_readiness",
+            category: "project",
+            name: "Config Readiness",
+            status: "warn",
+            message: `Required config item(s) missing: ${missingKeys.join(", ")}`,
+            fix: `Run 'ac config set <KEY> <VALUE>' to configure missing keys`,
+          });
+        } else {
+          checks.push({
+            id: "project.config_readiness",
+            category: "project",
+            name: "Config Readiness",
+            status: "ok",
+            message: "All declared configuration dependencies satisfied",
+          });
+        }
+      }
+    } catch (err: any) {
+      checks.push({
+        id: "project.config",
+        category: "project",
+        name: "Project Configuration",
+        status: "error",
+        message: `Invalid actiondock.json: ${err.message}`,
+      });
+    }
+  }
+
+  const okCount = checks.filter((c) => c.status === "ok").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const errorCount = checks.filter((c) => c.status === "error").length;
+
+  return {
+    ok: errorCount === 0,
+    hasProject: !!projectRoot,
+    projectRoot: projectRoot || undefined,
+    packageId,
+    summary: {
+      total: checks.length,
+      ok: okCount,
+      warn: warnCount,
+      error: errorCount,
+    },
+    checks,
+  };
+}