@actiondock/core 2.0.1 → 2.0.3

package/src/profile/client.ts

@@ -291,12 +291,262 @@ export async function fetchRemoteActionShow(
 
 export async function fetchRemoteInfo(
   serverUrl: string,
-  token?: string
+  token?: string,
+  options?: { intent?: string; package?: string; tree?: boolean }
 ): Promise<any> {
+  const params = new URLSearchParams();
+  if (options?.intent) params.set("intent", options.intent);
+  if (options?.package) params.set("package", options.package);
+  if (options?.tree) params.set("tree", "true");
+  const qs = params.toString() ? `?${params.toString()}` : "";
   return fetchRemoteJson(
     serverUrl,
-    "/api/v1/info",
+    `/api/v1/info${qs}`,
     token,
     { errorPrefix: "Failed to fetch remote info" }
   );
 }
+
+export async function fetchRemoteDoctor(
+  serverUrl: string,
+  token?: string,
+  targetPackage?: string
+): Promise<any> {
+  const query = targetPackage ? `?package=${encodeURIComponent(targetPackage)}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/doctor${query}`,
+    token,
+    { errorPrefix: "Failed to fetch remote doctor report" }
+  );
+}
+
+export async function fetchRemotePlaybooks(
+  serverUrl: string,
+  token?: string,
+  options?: { intent?: string; package?: string }
+): Promise<Array<{ id: string; description: string; actions: string[]; packageId: string; filePath: string }>> {
+  const params = new URLSearchParams();
+  if (options?.intent) params.set("intent", options.intent);
+  if (options?.package) params.set("package", options.package);
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/playbooks${qs}`,
+    token,
+    { errorPrefix: "Failed to fetch remote playbooks" }
+  );
+}
+
+export async function fetchRemotePlaybookShow(
+  serverUrl: string,
+  playbookId: string,
+  token?: string
+): Promise<any> {
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/playbooks/${encodeURIComponent(playbookId)}`,
+    token,
+    { errorPrefix: `Failed to fetch remote playbook '${playbookId}'` }
+  );
+}
+
+export async function fetchRemoteRuns(
+  serverUrl: string,
+  token?: string,
+  options?: { status?: string; actionId?: string; packageId?: string; intent?: string; limit?: number }
+): Promise<{ ok: boolean; total: number; items: RunRecord[] }> {
+  const params = new URLSearchParams();
+  if (options?.status) params.set("status", options.status);
+  if (options?.actionId) params.set("actionId", options.actionId);
+  if (options?.packageId) params.set("packageId", options.packageId);
+  if (options?.intent) params.set("intent", options.intent);
+  if (options?.limit) params.set("limit", String(options.limit));
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/runs${qs}`,
+    token,
+    { errorPrefix: "Failed to fetch remote runs" }
+  );
+}
+
+export async function clearRemoteRuns(
+  serverUrl: string,
+  token?: string,
+  options?: { packageId?: string; actionId?: string; status?: string }
+): Promise<{ ok: boolean; clearedCount: number }> {
+  return fetchRemoteJson(
+    serverUrl,
+    "/api/v1/runs/clear",
+    token,
+    {
+      method: "POST",
+      body: options || {},
+      errorPrefix: "Failed to clear remote runs",
+    }
+  );
+}
+
+export async function fetchRemoteStateList(
+  serverUrl: string,
+  token?: string,
+  options?: { package?: string; namespace?: string; prefix?: string }
+): Promise<{ ok: boolean; packageId: string; keys: string[] }> {
+  const params = new URLSearchParams();
+  if (options?.package) params.set("package", options.package);
+  if (options?.namespace !== undefined) params.set("namespace", options.namespace);
+  if (options?.prefix) params.set("prefix", options.prefix);
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/state${qs}`,
+    token,
+    { errorPrefix: "Failed to list remote state keys" }
+  );
+}
+
+export async function getRemoteStateKey(
+  serverUrl: string,
+  key: string,
+  token?: string,
+  options?: { package?: string; namespace?: string }
+): Promise<any> {
+  const params = new URLSearchParams();
+  if (options?.package) params.set("package", options.package);
+  if (options?.namespace !== undefined) params.set("namespace", options.namespace);
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/state/${encodeURIComponent(key)}${qs}`,
+    token,
+    { errorPrefix: `Failed to fetch remote state key '${key}'` }
+  );
+}
+
+export async function setRemoteStateKey(
+  serverUrl: string,
+  key: string,
+  value: unknown,
+  token?: string,
+  options?: { package?: string; namespace?: string; ttl?: number }
+): Promise<any> {
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/state/${encodeURIComponent(key)}`,
+    token,
+    {
+      method: "PUT",
+      body: {
+        value,
+        package: options?.package,
+        namespace: options?.namespace,
+        ttl: options?.ttl,
+      },
+      errorPrefix: `Failed to set remote state key '${key}'`,
+    }
+  );
+}
+
+export async function deleteRemoteStateKey(
+  serverUrl: string,
+  key: string,
+  token?: string,
+  options?: { package?: string; namespace?: string }
+): Promise<any> {
+  const params = new URLSearchParams();
+  if (options?.package) params.set("package", options.package);
+  if (options?.namespace !== undefined) params.set("namespace", options.namespace);
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/state/${encodeURIComponent(key)}${qs}`,
+    token,
+    {
+      method: "DELETE",
+      errorPrefix: `Failed to delete remote state key '${key}'`,
+    }
+  );
+}
+
+export async function clearRemoteState(
+  serverUrl: string,
+  token?: string,
+  options?: { package?: string; namespace?: string; prefix?: string; all?: boolean }
+): Promise<{ ok: boolean; packageId: string; clearedCount: number }> {
+  return fetchRemoteJson(
+    serverUrl,
+    "/api/v1/state/clear",
+    token,
+    {
+      method: "POST",
+      body: options || {},
+      errorPrefix: "Failed to clear remote state",
+    }
+  );
+}
+
+export async function fetchRemoteConfig(
+  serverUrl: string,
+  token?: string,
+  packageId?: string
+): Promise<any> {
+  const query = packageId ? `?package=${encodeURIComponent(packageId)}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/config${query}`,
+    token,
+    { errorPrefix: "Failed to fetch remote config" }
+  );
+}
+
+export async function setRemoteConfig(
+  serverUrl: string,
+  key: string,
+  value: unknown,
+  token?: string,
+  packageId?: string
+): Promise<any> {
+  return fetchRemoteJson(
+    serverUrl,
+    "/api/v1/config",
+    token,
+    {
+      method: "PUT",
+      body: { key, value, package: packageId },
+      errorPrefix: `Failed to set remote config '${key}'`,
+    }
+  );
+}
+
+export async function deleteRemoteConfig(
+  serverUrl: string,
+  key: string,
+  token?: string,
+  packageId?: string
+): Promise<any> {
+  const query = packageId ? `?package=${encodeURIComponent(packageId)}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/config/${encodeURIComponent(key)}${query}`,
+    token,
+    {
+      method: "DELETE",
+      errorPrefix: `Failed to delete remote config '${key}'`,
+    }
+  );
+}
+
+export async function fetchRemoteConfigEnv(
+  serverUrl: string,
+  token?: string,
+  packageId?: string
+): Promise<any> {
+  const query = packageId ? `?package=${encodeURIComponent(packageId)}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/config/env${query}`,
+    token,
+    { errorPrefix: "Failed to fetch remote config env checks" }
+  );
+}

package/src/project/index.ts

@@ -1,3 +1,4 @@
 export * from "./init";
 export * from "./loader";
+export * from "./manifest";
 export * from "./types";

package/src/project/init.ts

@@ -16,13 +16,14 @@ export interface InitOptions {
 /**
  * 在目标目录初始化一个完整的 ActionDock 2.0 Action Package 脚手架。
  * 生成内容包括：
- * 1. actiondock.json（项目元数据与配置声明）
- * 2. package.json（模块依赖与 bun test 脚本）
- * 3. tsconfig.json（现代 ESNext / Bundler 编译配置）
- * 4. .gitignore（排除持久化 db、node_modules、dist）
- * 5. actions/greet.ts（标准示例 Action，演示 config、state、log 使用）
- * 6. playbooks/greet-user.md（标准 SOP Playbook 演示）
- * 7. tests/greet.test.ts（基于 createTestRuntime 的零依赖单元测试）
+ * - actiondock.json（项目元数据与配置声明）
+ * - actiondock.manifest.json（声明式元数据清单事实源）
+ * - package.json（Node.js 标准脚本与依赖声明）
+ * - tsconfig.json（现代 NodeNext 模块规范）
+ * - .gitignore（排除持久化 db、node_modules、dist）
+ * - actions/greet.ts（标准示例 Action，演示 config、state、log 使用）
+ * - playbooks/greet-user.md（标准 SOP Playbook 演示）
+ * - tests/greet.test.ts（基于 node:test 与 @actiondock/testing 的测试用例）
  * 
  * @param targetDir 目标项目目录
  * @param options 初始化选项
@@ -58,20 +59,61 @@ export function initProject(targetDir: string, options: InitOptions = {}): void
     JSON.stringify(actiondockJson, null, 2) + "\n"
   );
 
-  // 2. package.json
+  // 2. actiondock.manifest.json
+  const manifestJson = {
+    schemaVersion: 1,
+    actions: {
+      "sample.greet": {
+        entry: "actions/greet.ts",
+        description: "Greeting action demonstrating basic input, config, and state usage",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Name of the person to greet",
+            },
+          },
+          required: ["name"],
+        },
+        outputSchema: {
+          type: "object",
+          properties: {
+            message: { type: "string" },
+            timesGreeted: { type: "number" },
+          },
+          required: ["message", "timesGreeted"],
+        },
+        uses: [],
+        tags: ["sample"],
+      },
+    },
+    assets: [],
+  };
+  writeFileSync(
+    join(root, "actiondock.manifest.json"),
+    JSON.stringify(manifestJson, null, 2) + "\n"
+  );
+
+  // 3. package.json
   const packageJson = {
     name: id,
     version: "0.1.0",
     description,
     type: "module",
     scripts: {
-      test: "bun test",
+      test: "node --import tsx --test tests/*.test.ts",
+    },
+    engines: {
+      node: ">=22.12.0",
     },
     dependencies: {
-      "@actiondock/sdk": "^2.0.0",
+      "@actiondock/sdk": "^2.0.3",
     },
     devDependencies: {
-      "@types/bun": "latest",
+      "@actiondock/testing": "^2.0.3",
+      "@types/node": "^22.12.0",
+      "tsx": "^4.19.0",
       "typescript": "^5.7.0",
     },
   };
@@ -80,15 +122,15 @@ export function initProject(targetDir: string, options: InitOptions = {}): void
     JSON.stringify(packageJson, null, 2) + "\n"
   );
 
-  // 3. tsconfig.json
+  // 4. tsconfig.json
   const tsconfigJson = {
     compilerOptions: {
-      target: "ESNext",
-      module: "ESNext",
-      moduleResolution: "bundler",
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
       strict: true,
       skipLibCheck: true,
-      types: ["bun-types"],
+      types: ["node"],
     },
   };
   writeFileSync(
@@ -96,16 +138,17 @@ export function initProject(targetDir: string, options: InitOptions = {}): void
     JSON.stringify(tsconfigJson, null, 2) + "\n"
   );
 
-  // 4. .gitignore
+  // 5. .gitignore
   const gitignore = `.actiondock/
 node_modules/
 dist/
-bun.lock
-*.db
+build/
+*.log
+.env
 `;
   writeFileSync(join(root, ".gitignore"), gitignore);
 
-  // 5. actions/
+  // 6. actions/
   const actionsDir = join(root, "actions");
   mkdirSync(actionsDir, { recursive: true });
 
@@ -113,12 +156,15 @@ bun.lock
 
 export default defineAction({
   id: "sample.greet",
-  description: "Greet a user with configurable greeting",
+  description: "Greeting action demonstrating basic input, config, and state usage",
 
   inputSchema: {
     type: "object",
     properties: {
-      name: { type: "string", description: "Name of person to greet" },
+      name: {
+        type: "string",
+        description: "Name of the person to greet",
+      },
     },
     required: ["name"],
   },
@@ -127,9 +173,9 @@ export default defineAction({
     type: "object",
     properties: {
       message: { type: "string" },
-      timestamp: { type: "string" },
+      timesGreeted: { type: "number" },
     },
-    required: ["message", "timestamp"],
+    required: ["message", "timesGreeted"],
   },
 
   async run(input: { name: string }, ctx) {
@@ -141,14 +187,14 @@ export default defineAction({
 
     return {
       message: \`\${greeting}, \${input.name}!\`,
-      timestamp: new Date().toISOString(),
+      timesGreeted: count,
     };
   },
 });
 `;
   writeFileSync(join(actionsDir, "greet.ts"), sampleAction);
 
-  // 6. playbooks/
+  // 7. playbooks/
   const playbooksDir = join(root, "playbooks");
   mkdirSync(playbooksDir, { recursive: true });
 
@@ -166,12 +212,13 @@ actions:
 `;
   writeFileSync(join(playbooksDir, "greet-user.md"), samplePlaybook);
 
-  // 7. tests/
+  // 8. tests/
   const testsDir = join(root, "tests");
   mkdirSync(testsDir, { recursive: true });
 
-  const sampleTest = `import { describe, expect, it } from "bun:test";
-import { createTestRuntime } from "@actiondock/sdk";
+  const sampleTest = `import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestRuntime } from "@actiondock/testing";
 import greetAction from "../actions/greet";
 
 describe("greet action", () => {
@@ -181,12 +228,12 @@ describe("greet action", () => {
     });
 
     const res1 = await runtime.run(greetAction, { name: "Alice" });
-    expect(res1.message).toBe("Hi, Alice!");
-    expect(await runtime.state.get("greet_count")).toBe(1);
+    assert.equal(res1.message, "Hi, Alice!");
+    assert.equal(await runtime.state.get("greet_count"), 1);
 
     const res2 = await runtime.run(greetAction, { name: "Bob" });
-    expect(res2.message).toBe("Hi, Bob!");
-    expect(await runtime.state.get("greet_count")).toBe(2);
+    assert.equal(res2.message, "Hi, Bob!");
+    assert.equal(await runtime.state.get("greet_count"), 2);
   });
 });
 `;

package/src/project/loader.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import YAML from "yaml";
@@ -68,29 +69,28 @@ export function loadProjectConfig(projectRoot: string): ProjectConfig {
 }
 
 /**
- * 探测宿主系统中可用的包管理工具（优先级：bun > pnpm > yarn > npm）。
+ * 探测宿主系统中可用的包管理工具（优先级：pnpm > npm > yarn > bun）。
  */
 function getInstallCommand(): string[] {
   const candidates: [string, string][] = [
-    ["bun", "install"],
     ["pnpm", "install"],
-    ["yarn", "install"],
     ["npm", "install"],
+    ["yarn", "install"],
+    ["bun", "install"],
   ];
   for (const [pm, action] of candidates) {
     try {
-      const check = Bun.spawnSync([pm, "--version"], {
-        stdout: "pipe",
-        stderr: "pipe",
+      const check = spawnSync(pm, ["--version"], {
+        stdio: "pipe",
       });
-      if (check.exitCode === 0) {
+      if (check.status === 0) {
         return [pm, action];
       }
     } catch {
       // 继续探测下一个候选包管理器
     }
   }
-  return ["bun", "install"];
+  return ["npm", "install"];
 }
 
 /**
@@ -131,13 +131,12 @@ export function ensureProjectDependencies(projectRoot: string, force = false): b
       `[actiondock] Installing dependencies using ${installCmd[0]} for '${pkg.name || basename(projectRoot)}'...\n`
     );
 
-    const proc = Bun.spawnSync(installCmd, {
+    const proc = spawnSync(installCmd[0], installCmd.slice(1), {
       cwd: projectRoot,
-      stdout: "pipe",
-      stderr: "pipe",
+      stdio: "pipe",
     });
 
-    if (proc.exitCode !== 0) {
+    if (proc.status !== 0) {
       const errText = proc.stderr?.toString() || `Unknown error during ${installCmd[0]} install`;
       process.stderr.write(`[actiondock] Warning: Dependency installation failed: ${errText}\n`);
       return false;

package/src/project/manifest.ts

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ActionDockManifest, ActionManifestEntry } from "./types";
+
+export const MANIFEST_FILE_NAME = "actiondock.manifest.json";
+
+/**
+ * 读取并解析项目的声明式清单文件。
+ * 若文件不存在则返回 null。
+ */
+export function loadManifest(projectRoot: string): ActionDockManifest | null {
+  const filePath = join(projectRoot, MANIFEST_FILE_NAME);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw) as ActionDockManifest;
+    if (!parsed || typeof parsed !== "object" || parsed.schemaVersion !== 1) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 保存声明式清单文件至项目根目录。
+ */
+export function saveManifest(projectRoot: string, manifest: ActionDockManifest): void {
+  const filePath = join(projectRoot, MANIFEST_FILE_NAME);
+  writeFileSync(filePath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+
+/**
+ * 校验清单数据结构的合法性。
+ */
+export function validateManifest(manifest: unknown): { valid: boolean; errors?: string[] } {
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, errors: ["Manifest must be an object"] };
+  }
+  const m = manifest as ActionDockManifest;
+  const errors: string[] = [];
+
+  if (m.schemaVersion !== 1) {
+    errors.push("Manifest 'schemaVersion' must be 1");
+  }
+  if (!m.actions || typeof m.actions !== "object") {
+    errors.push("Manifest 'actions' must be an object");
+  } else {
+    for (const [actionId, item] of Object.entries(m.actions)) {
+      if (!item || typeof item !== "object") {
+        errors.push(`Action entry '${actionId}' must be an object`);
+        continue;
+      }
+      if (!item.entry || typeof item.entry !== "string") {
+        errors.push(`Action '${actionId}' must specify string 'entry'`);
+      }
+      if (item.uses && !Array.isArray(item.uses)) {
+        errors.push(`Action '${actionId}' property 'uses' must be an array`);
+      }
+      if (item.tags && !Array.isArray(item.tags)) {
+        errors.push(`Action '${actionId}' property 'tags' must be an array`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors: errors.length > 0 ? errors : undefined,
+  };
+}
+
+/**
+ * 为单个 Action 构建清单项。
+ */
+export function createManifestEntry(options: {
+  entry: string;
+  description?: string;
+  inputSchema?: Record<string, unknown> | boolean;
+  outputSchema?: Record<string, unknown> | boolean;
+  uses?: string[];
+  tags?: string[];
+  annotations?: Record<string, unknown>;
+}): ActionManifestEntry {
+  return {
+    entry: options.entry,
+    description: options.description,
+    inputSchema: options.inputSchema,
+    outputSchema: options.outputSchema,
+    uses: options.uses || [],
+    tags: options.tags || [],
+    annotations: options.annotations,
+  };
+}

package/src/project/types.ts

@@ -60,3 +60,33 @@ export interface PlaybookDefinition extends PlaybookFrontmatter {
   /** Playbook 源文件的绝对物理路径 */
   filePath: string;
 }
+
+/**
+ * 单个 Action 在清单中的声明项。
+ */
+export interface ActionManifestEntry {
+  /** Action 入口文件相对路径（如 "actions/greet.ts"） */
+  entry: string;
+  /** Action 功能描述 */
+  description?: string;
+  /** 输入参数模式规范 */
+  inputSchema?: Record<string, unknown> | boolean;
+  /** 输出结果模式规范 */
+  outputSchema?: Record<string, unknown> | boolean;
+  /** 静态依赖的 Action 列表 */
+  uses?: string[];
+  /** 标签列表 */
+  tags?: string[];
+  /** 协议注解元数据 */
+  annotations?: Record<string, unknown>;
+}
+
+/**
+ * ActionDock 声明式清单（actiondock.manifest.json）规范。
+ * 作为元数据的单一事实源，实现无副作用的模块发现与构建规划。
+ */
+export interface ActionDockManifest {
+  schemaVersion: number;
+  actions: Record<string, ActionManifestEntry>;
+  assets?: string[];
+}