@actiondock/core 2.0.9 → 2.0.11-beta.0

package/src/server/routes/info.ts

@@ -0,0 +1,221 @@
+import { existsSync } from "node:fs";
+import { filterWithFallbackInfo } from "../../filter";
+import { loadActions, loadPlaybooks, loadProjectConfig } from "../../project/loader";
+import { getRegistryStatus, listLinkedPackages } from "../../registry/registry";
+import { type RouteContext, jsonResponse } from "./common";
+
+/**
+ * 处理系统探索与自省接口（GET /api/v1/info）。
+ */
+export async function handleInfoRoute(ctx: RouteContext): Promise<Response | null> {
+  const { req, url, pathname, corsHeaders, projectRoot, customHome, options } = ctx;
+
+  if (pathname !== "/api/v1/info" || req.method !== "GET") {
+    return null;
+  }
+
+  try {
+    const isTree = url.searchParams.get("tree") === "true";
+    if (isTree) {
+      const status = getRegistryStatus(customHome);
+      return jsonResponse(
+        { ok: true, type: "tree", ...status },
+        200,
+        corsHeaders
+      );
+    }
+
+    const intent = url.searchParams.get("intent") || undefined;
+    const targetPkg = url.searchParams.get("package") || undefined;
+
+    // 收集所有候选包全量元数据
+    const aggregatedPackages: any[] = [];
+
+    if (projectRoot) {
+      try {
+        const config = loadProjectConfig(projectRoot);
+        const actions = await loadActions(projectRoot, config.actionsDir);
+        const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
+        aggregatedPackages.push({
+          id: config.id,
+          name: config.name,
+          version: config.version,
+          description: config.description || "",
+          path: projectRoot,
+          actionsCount: actions.size,
+          playbooksCount: playbooks.size,
+          actions: Array.from(actions.entries()).map(([id, a]) => ({
+            id,
+            description: a.description || "",
+            inputSchema: a.inputSchema || null,
+            outputSchema: a.outputSchema || null,
+          })),
+          playbooks: Array.from(playbooks.entries()).map(([id, p]) => ({
+            id,
+            description: p.description || "",
+            actions: p.actions || [],
+          })),
+          configDeclared: config.config || {},
+        });
+      } catch {
+        // 忽略解析异常
+      }
+    } else {
+      const linked = listLinkedPackages(customHome);
+      for (const pkg of linked) {
+        if (!existsSync(pkg.path)) continue;
+        try {
+          const config = loadProjectConfig(pkg.path);
+          const actions = await loadActions(pkg.path, config.actionsDir);
+          const playbooks = loadPlaybooks(pkg.path, config.playbooksDir);
+          aggregatedPackages.push({
+            id: config.id,
+            name: config.name,
+            version: config.version,
+            description: config.description || "",
+            path: pkg.path,
+            actionsCount: actions.size,
+            playbooksCount: playbooks.size,
+            actions: Array.from(actions.entries()).map(([id, a]) => ({
+              id,
+              description: a.description || "",
+              inputSchema: a.inputSchema || null,
+              outputSchema: a.outputSchema || null,
+            })),
+            playbooks: Array.from(playbooks.entries()).map(([id, p]) => ({
+              id,
+              description: p.description || "",
+              actions: p.actions || [],
+            })),
+            configDeclared: config.config || {},
+          });
+        } catch {
+          // 忽略故障包
+        }
+      }
+    }
+
+    // 显式指定 package 详情下钻
+    if (targetPkg) {
+      const matched = aggregatedPackages.find(
+        (p) => p.id === targetPkg || p.path === targetPkg
+      );
+      if (!matched) {
+        return jsonResponse(
+          {
+            ok: false,
+            error: {
+              code: "PACKAGE_NOT_FOUND",
+              message: `Package '${targetPkg}' not found on remote server`,
+            },
+          },
+          404,
+          corsHeaders
+        );
+      }
+      return jsonResponse(
+        {
+          ok: true,
+          type: "package_detail",
+          ...matched,
+          ...(options.exposeDebugInfo ? { projectRoot: matched.path } : {}),
+        },
+        200,
+        corsHeaders
+      );
+    }
+
+    // 意图过滤与决议
+    if (intent) {
+      const filterRes = filterWithFallbackInfo(
+        aggregatedPackages,
+        intent,
+        [
+          (p) => p.id,
+          (p) => p.name,
+          (p) => p.description,
+          (p) => p.actions.map((a: any) => a.id),
+          (p) => p.actions.map((a: any) => a.description),
+          (p) => p.playbooks.map((pb: any) => pb.id),
+          (p) => p.playbooks.map((pb: any) => pb.description),
+        ],
+        true
+      );
+
+      // 唯一命中智能展开详情
+      if (filterRes.matchedCount === 1) {
+        const single = filterRes.items[0];
+        return jsonResponse(
+          {
+            ok: true,
+            type: "package_detail",
+            isSingleMatch: true,
+            ...single,
+            ...(options.exposeDebugInfo ? { projectRoot: single.path } : {}),
+          },
+          200,
+          corsHeaders
+        );
+      }
+
+      return jsonResponse(
+        {
+          ok: true,
+          type: "package_list",
+          isFallback: filterRes.isFallback,
+          packages: filterRes.items,
+        },
+        200,
+        corsHeaders
+      );
+    }
+
+    // 单包模式直接展开详情
+    if (projectRoot && aggregatedPackages.length === 1) {
+      const p = aggregatedPackages[0];
+      return jsonResponse(
+        {
+          ok: true,
+          type: "package_detail",
+          id: p.id,
+          name: p.name,
+          version: p.version,
+          description: p.description,
+          actionsCount: p.actionsCount,
+          playbooksCount: p.playbooksCount,
+          actions: p.actions.map((a: any) => a.id),
+          actionsDetail: p.actions,
+          playbooks: p.playbooks.map((pb: any) => pb.id),
+          playbooksDetail: p.playbooks,
+          configDeclared: p.configDeclared,
+          linkedPackages: listLinkedPackages(customHome),
+          ...(options.exposeDebugInfo ? { projectRoot } : {}),
+        },
+        200,
+        corsHeaders
+      );
+    }
+
+    // 全局注册表概览
+    return jsonResponse(
+      {
+        ok: true,
+        type: "package_list",
+        version: "2.0.0",
+        packages: aggregatedPackages,
+        linkedPackages: listLinkedPackages(customHome),
+      },
+      200,
+      corsHeaders
+    );
+  } catch (err: any) {
+    return jsonResponse(
+      {
+        ok: false,
+        error: { code: "INFO_ERROR", message: err.message },
+      },
+      500,
+      corsHeaders
+    );
+  }
+}

package/src/server/routes/playbooks.ts

@@ -0,0 +1,109 @@
+import { existsSync } from "node:fs";
+import { filterByIntent } from "../../filter";
+import { loadPlaybooks, loadProjectConfig } from "../../project/loader";
+import { listLinkedPackages, resolvePlaybookProject } from "../../registry/registry";
+import { type RouteContext, jsonResponse } from "./common";
+
+/**
+ * 处理 Playbook 列表与 SOP 详情接口。
+ */
+export async function handlePlaybooksRoutes(ctx: RouteContext): Promise<Response | null> {
+  const { req, url, pathname, corsHeaders, projectRoot, customHome } = ctx;
+
+  // 1. Playbooks List: GET /api/v1/playbooks
+  if (pathname === "/api/v1/playbooks" && req.method === "GET") {
+    try {
+      const pbList: Array<{
+        id: string;
+        description: string;
+        actions: string[];
+        packageId: string;
+        filePath: string;
+      }> = [];
+
+      const targetPkg = url.searchParams.get("package");
+      const intent = url.searchParams.get("intent");
+
+      const roots: Array<{ root: string; packageId: string }> = [];
+      if (projectRoot) {
+        const cfg = loadProjectConfig(projectRoot);
+        roots.push({ root: projectRoot, packageId: cfg.id });
+      }
+      const linked = listLinkedPackages(customHome);
+      for (const pkg of linked) {
+        if (projectRoot && pkg.path === projectRoot) continue;
+        if (!existsSync(pkg.path)) continue;
+        roots.push({ root: pkg.path, packageId: pkg.id });
+      }
+
+      for (const item of roots) {
+        if (targetPkg && item.packageId !== targetPkg && item.root !== targetPkg) continue;
+        try {
+          const cfg = loadProjectConfig(item.root);
+          const pbs = loadPlaybooks(item.root, cfg.playbooksDir);
+          for (const [id, pb] of pbs.entries()) {
+            pbList.push({
+              id,
+              description: pb.description || "",
+              actions: pb.actions || [],
+              packageId: item.packageId,
+              filePath: pb.filePath,
+            });
+          }
+        } catch {}
+      }
+
+      const filtered = intent
+        ? filterByIntent(
+            pbList,
+            intent,
+            [(p) => p.id, (p) => p.description, (p) => p.packageId, (p) => p.actions],
+            false
+          )
+        : pbList;
+
+      return jsonResponse(filtered, 200, corsHeaders);
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "PLAYBOOKS_LIST_ERROR", message: err.message } },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  // 2. Playbook Show: GET /api/v1/playbooks/:id
+  const pbShowMatch = pathname.match(/^\/api\/v1\/playbooks\/([^/]+)$/);
+  if (pbShowMatch && req.method === "GET") {
+    const pbId = decodeURIComponent(pbShowMatch[1]);
+    try {
+      const resolved = resolvePlaybookProject(
+        pbId,
+        projectRoot || process.cwd(),
+        customHome
+      );
+      const pb = resolved.playbook;
+      return jsonResponse(
+        {
+          ok: true,
+          id: pb.id,
+          packageId: resolved.packageId,
+          description: pb.description || "",
+          actions: pb.actions || [],
+          filePath: pb.filePath,
+          content: pb.content,
+        },
+        200,
+        corsHeaders
+      );
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "PLAYBOOK_NOT_FOUND", message: err.message } },
+        404,
+        corsHeaders
+      );
+    }
+  }
+
+  return null;
+}

package/src/server/routes/runs.ts

@@ -0,0 +1,301 @@
+import { existsSync } from "node:fs";
+import { filterByIntent } from "../../filter";
+import { loadProjectConfig } from "../../project/loader";
+import { listLinkedPackages } from "../../registry/registry";
+import type { RuntimeStorage } from "../../storage/types";
+import { readJsonBody } from "../body";
+import { type RouteContext, findRunAcrossStorages, jsonResponse } from "./common";
+
+/**
+ * 处理历史运行记录检索、清理、详情及 SSE 流式日志接口。
+ */
+export async function handleRunsRoutes(ctx: RouteContext): Promise<Response | null> {
+  const { req, url, pathname, corsHeaders, projectRoot, customHome, runtimeRegistry, options } = ctx;
+
+  // 1. Runs List: GET /api/v1/runs
+  if (pathname === "/api/v1/runs" && req.method === "GET") {
+    try {
+      const status = url.searchParams.get("status") || undefined;
+      const actionId = url.searchParams.get("actionId") || undefined;
+      const packageId = url.searchParams.get("packageId") || undefined;
+      const intent = url.searchParams.get("intent") || undefined;
+      const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+
+      const allRuns: any[] = [];
+      const seenRunIds = new Set<string>();
+
+      const candidateStorages: Array<{ packageId: string; storage: RuntimeStorage }> = [];
+      if (projectRoot) {
+        try {
+          const cfg = loadProjectConfig(projectRoot);
+          candidateStorages.push({
+            packageId: cfg.id,
+            storage: runtimeRegistry.getStorage(cfg.id, projectRoot),
+          });
+        } catch {}
+      }
+      const linked = listLinkedPackages(customHome);
+      for (const pkg of linked) {
+        if (projectRoot && pkg.path === projectRoot) continue;
+        if (!existsSync(pkg.path)) continue;
+        candidateStorages.push({
+          packageId: pkg.id,
+          storage: runtimeRegistry.getStorage(pkg.id, pkg.path),
+        });
+      }
+
+      for (const item of candidateStorages) {
+        if (packageId && item.packageId !== packageId) continue;
+        try {
+          const records = item.storage.listRuns({ actionId, limit });
+          for (const r of records) {
+            if (!seenRunIds.has(r.id)) {
+              seenRunIds.add(r.id);
+              if (status && r.status !== status) continue;
+              allRuns.push(r);
+            }
+          }
+        } catch {}
+      }
+
+      allRuns.sort((a, b) => (b.startedAt || "").localeCompare(a.startedAt || ""));
+
+      const filtered = intent
+        ? filterByIntent(
+            allRuns,
+            intent,
+            [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId],
+            false
+          )
+        : allRuns;
+
+      const sliced = filtered.slice(0, limit);
+      return jsonResponse(
+        { ok: true, total: filtered.length, items: sliced },
+        200,
+        corsHeaders
+      );
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "RUNS_LIST_ERROR", message: err.message } },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  // 2. Runs Clear: POST /api/v1/runs/clear or DELETE /api/v1/runs
+  if (
+    (pathname === "/api/v1/runs/clear" && req.method === "POST") ||
+    (pathname === "/api/v1/runs" && req.method === "DELETE")
+  ) {
+    try {
+      let body: any = {};
+      if (req.method === "POST" || req.headers.get("content-type")?.includes("json")) {
+        body = await readJsonBody(req, { maxBytes: options.maxBodyBytes }).catch(() => ({}));
+      }
+      const packageId = url.searchParams.get("packageId") || body.packageId || undefined;
+      const actionId = url.searchParams.get("actionId") || body.actionId || undefined;
+      const status = url.searchParams.get("status") || body.status || undefined;
+
+      let clearedCount = 0;
+      const candidateStorages: RuntimeStorage[] = [];
+      if (projectRoot) {
+        try {
+          const cfg = loadProjectConfig(projectRoot);
+          candidateStorages.push(runtimeRegistry.getStorage(cfg.id, projectRoot));
+        } catch {}
+      }
+      const linked = listLinkedPackages(customHome);
+      for (const pkg of linked) {
+        if (projectRoot && pkg.path === projectRoot) continue;
+        if (!existsSync(pkg.path)) continue;
+        if (packageId && pkg.id !== packageId) continue;
+        candidateStorages.push(runtimeRegistry.getStorage(pkg.id, pkg.path));
+      }
+
+      for (const storage of candidateStorages) {
+        clearedCount += storage.clearRuns({ actionId, status });
+      }
+
+      return jsonResponse({ ok: true, clearedCount }, 200, corsHeaders);
+    } catch (err: any) {
+      return jsonResponse(
+        { ok: false, error: { code: "RUNS_CLEAR_ERROR", message: err.message } },
+        500,
+        corsHeaders
+      );
+    }
+  }
+
+  // 3. Run Stream (SSE): GET /api/v1/runs/:runId/stream
+  const runStreamMatch = pathname.match(/^\/api\/v1\/runs\/([^/]+)\/stream$/);
+  if (runStreamMatch && req.method === "GET") {
+    const runId = decodeURIComponent(runStreamMatch[1]);
+    const found = findRunAcrossStorages(runId, runtimeRegistry, projectRoot, customHome);
+    const activeHandle = runtimeRegistry.executionManager.get(runId);
+
+    if (!found && !activeHandle) {
+      return jsonResponse(
+        { ok: false, error: { code: "RUN_NOT_FOUND", message: `Run '${runId}' not found` } },
+        404,
+        corsHeaders
+      );
+    }
+
+    const stream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+        const sendEvent = (event: string, data: any) => {
+          try {
+            controller.enqueue(
+              encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)
+            );
+          } catch {}
+        };
+
+        if (activeHandle) {
+          sendEvent("status", { runId, status: "running" });
+          const unsubscribe = runtimeRegistry.subscribe(runId, (evt) => {
+            sendEvent(evt.type, evt.data);
+            if (evt.type === "finish") {
+              try { controller.close(); } catch {}
+            }
+          });
+
+          activeHandle.result.then(
+            (res) => {
+              sendEvent("finish", res);
+              try { controller.close(); } catch {}
+            },
+            (err) => {
+              sendEvent("finish", {
+                ok: false,
+                error: { message: err?.message || String(err) },
+              });
+              try { controller.close(); } catch {}
+            }
+          );
+
+          req.signal.addEventListener("abort", () => {
+            unsubscribe();
+            try { controller.close(); } catch {}
+          });
+        } else if (found) {
+          sendEvent("finish", found.run);
+          controller.close();
+        }
+      },
+    });
+
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        ...corsHeaders,
+      },
+    });
+  }
+
+  // 4. Run Show: GET /api/v1/runs/:runId
+  const runShowMatch = pathname.match(/^\/api\/v1\/runs\/([^/]+)$/);
+  if (runShowMatch && req.method === "GET") {
+    const runId = decodeURIComponent(runShowMatch[1]);
+    const found = findRunAcrossStorages(runId, runtimeRegistry, projectRoot, customHome);
+
+    if (!found) {
+      return jsonResponse(
+        {
+          ok: false,
+          error: {
+            code: "RUN_NOT_FOUND",
+            message: `Run '${runId}' not found`,
+          },
+        },
+        404,
+        corsHeaders
+      );
+    }
+
+    return jsonResponse(found.run, 200, corsHeaders);
+  }
+
+  // 5. Run Cancel: POST /api/v1/runs/:runId/cancel
+  const runCancelMatch = pathname.match(/^\/api\/v1\/runs\/([^/]+)\/cancel$/);
+  if (runCancelMatch && req.method === "POST") {
+    const runId = decodeURIComponent(runCancelMatch[1]);
+    let body: any = {};
+    try {
+      body = await readJsonBody(req, { maxBytes: options.maxBodyBytes });
+    } catch {
+      // Body is optional
+    }
+
+    const reason = body?.reason || "Cancelled by client request";
+
+    const activeHandle = runtimeRegistry.executionManager.get(runId);
+    if (activeHandle) {
+      const cancelled = runtimeRegistry.executionManager.cancel(runId, reason);
+      if (cancelled) {
+        return jsonResponse(
+          {
+            ok: true,
+            runId,
+            status: "cancelled",
+          },
+          200,
+          corsHeaders
+        );
+      }
+    }
+
+    const found = findRunAcrossStorages(runId, runtimeRegistry, projectRoot, customHome);
+    if (!found) {
+      return jsonResponse(
+        {
+          ok: false,
+          error: {
+            code: "RUN_NOT_FOUND",
+            message: `Run '${runId}' not found`,
+          },
+        },
+        404,
+        corsHeaders
+      );
+    }
+
+    const { storage, run } = found;
+    if (run.status === "success" || run.status === "failed" || run.status === "cancelled") {
+      return jsonResponse(
+        {
+          ok: false,
+          error: {
+            code: "RUN_ALREADY_FINISHED",
+            message: `Run '${runId}' has already finished with status '${run.status}'`,
+          },
+        },
+        409,
+        corsHeaders
+      );
+    }
+
+    storage.updateRun(runId, "cancelled", undefined, {
+      code: "ACTION_CANCELLED",
+      message: reason,
+    });
+
+    return jsonResponse(
+      {
+        ok: true,
+        runId,
+        status: "cancelled",
+      },
+      200,
+      corsHeaders
+    );
+  }
+
+  return null;
+}