@actiondock/core 2.0.0

package/src/filter/intent.ts

@@ -0,0 +1,154 @@
+/**
+ * 从对象中提取待过滤字段的提取器函数类型。
+ */
+export type Extractor<T> = (item: T) => unknown;
+
+/**
+ * 安全地将模式字符串、数组或现有正则编译为不区分大小写的 RegExp 正则表达式。
+ * 若正则语法不合法，自动对特殊字符进行转义并降级为字面量匹配正则，保证零 Crash。
+ * 
+ * @param intent 意图关键词、正则或数组
+ */
+export function compileIntentRegex(
+  intent?: string | string[] | RegExp | null
+): RegExp | null {
+  if (!intent) return null;
+  if (intent instanceof RegExp) return intent;
+
+  let patternStr: string;
+  if (Array.isArray(intent)) {
+    const valid = intent.map((s) => s.trim()).filter(Boolean);
+    if (valid.length === 0) return null;
+    patternStr = valid.join("|");
+  } else {
+    patternStr = intent.trim();
+    if (!patternStr) return null;
+  }
+
+  try {
+    return new RegExp(patternStr, "i");
+  } catch {
+    const escaped = patternStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(escaped, "i");
+  }
+}
+
+/**
+ * 递归检查某个值（包括嵌套的数组或对象结构）是否匹配给定的正则表达式。
+ * 
+ * @param value 待检测的任意数据类型
+ * @param regex 正则表达式
+ */
+export function matchIntent(value: unknown, regex: RegExp): boolean {
+  if (value === undefined || value === null) return false;
+
+  if (typeof value === "string") {
+    return regex.test(value);
+  }
+
+  if (typeof value === "number" || typeof value === "boolean") {
+    return regex.test(String(value));
+  }
+
+  if (Array.isArray(value)) {
+    for (const elem of value) {
+      if (matchIntent(elem, regex)) return true;
+    }
+    return false;
+  }
+
+  if (typeof value === "object") {
+    try {
+      return regex.test(JSON.stringify(value));
+    } catch {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+export interface FilterResult<T> {
+  items: T[];
+  isFallback: boolean;
+  matchedCount: number;
+}
+
+/**
+ * Filters a collection of items based on an intent pattern across specified extractor functions.
+ * Returns detailed result including whether a fallback was triggered when 0 items matched.
+ */
+export function filterWithFallbackInfo<T>(
+  items: T[],
+  intent?: string | string[] | RegExp | null,
+  extractors?: Extractor<T>[],
+  fallback = true
+): FilterResult<T> {
+  if (!intent) {
+    return {
+      items,
+      isFallback: false,
+      matchedCount: items.length,
+    };
+  }
+
+  const regex = compileIntentRegex(intent);
+  if (!regex) {
+    return {
+      items,
+      isFallback: false,
+      matchedCount: items.length,
+    };
+  }
+
+  const defaultExtractors: Extractor<T>[] = [
+    (item: any) =>
+      typeof item === "string"
+        ? item
+        : item?.id || item?.name || item?.key || String(item),
+  ];
+
+  const effectiveExtractors =
+    extractors && extractors.length > 0 ? extractors : defaultExtractors;
+
+  const matched = items.filter((item) => {
+    for (const extractor of effectiveExtractors) {
+      try {
+        const val = extractor(item);
+        if (matchIntent(val, regex)) {
+          return true;
+        }
+      } catch {
+        // Ignore extraction error
+      }
+    }
+    return false;
+  });
+
+  if (matched.length === 0 && fallback) {
+    return {
+      items,
+      isFallback: true,
+      matchedCount: 0,
+    };
+  }
+
+  return {
+    items: matched,
+    isFallback: false,
+    matchedCount: matched.length,
+  };
+}
+
+/**
+ * Filters a collection of items based on an intent pattern across specified extractor functions.
+ * When fallback is enabled (default), returns the full list if no items match the intent.
+ */
+export function filterByIntent<T>(
+  items: T[],
+  intent?: string | string[] | RegExp | null,
+  extractors?: Extractor<T>[],
+  fallback = true
+): T[] {
+  return filterWithFallbackInfo(items, intent, extractors, fallback).items;
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from "./build";
+export * from "./doctor";
+export * from "./export";
+export * from "./filter";
+export * from "./profile";
+export * from "./project";
+export * from "./registry";
+export * from "./runtime";
+export * from "./schema/validator";
+export * from "./server";
+export * from "./storage";
+export * from "./utils";
+

package/src/profile/client.ts

@@ -0,0 +1,302 @@
+import { randomUUID } from "node:crypto";
+import type { ExecutionResult, RuntimeError, RunRecord } from "@actiondock/sdk";
+import { normalizeServerUrl } from "./manager";
+import type { RemoteHealthResult } from "./types";
+
+function buildHeaders(token?: string): Record<string, string> {
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+  };
+  if (token && token.trim()) {
+    headers.Authorization = `Bearer ${token.trim()}`;
+  }
+  return headers;
+}
+
+/**
+ * 调用远端 ActionDock 服务端执行 Action 时的选项参数。
+ */
+export interface RemoteExecuteOptions {
+  /** 动态配置覆盖 */
+  configOverrides?: Record<string, unknown>;
+  /** 鉴权 Bearer Token */
+  token?: string;
+  /** 超时毫秒数 */
+  timeoutMs?: number;
+  /** 中断信号 */
+  signal?: AbortSignal;
+  /** 是否异步触发（202 Accepted 立即返回 runId） */
+  async?: boolean;
+}
+
+/**
+ * 远端 Action 执行结果信封对象。
+ */
+export type RemoteExecutionResult<T = unknown> = ExecutionResult<T> & {
+  status?: string;
+};
+
+/**
+ * 探测指定远端 ActionDock 服务的健康状态与网络延迟。
+ * 
+ * @param serverUrl 目标服务端地址
+ * @param token 鉴权 Token（可选）
+ * @param timeoutMs 探测超时时间（默认 5000ms）
+ */
+export async function checkRemoteHealth(
+  serverUrl: string,
+  token?: string,
+  timeoutMs: number = 5000
+): Promise<RemoteHealthResult> {
+  const base = normalizeServerUrl(serverUrl);
+  const url = `${base}/api/v1/health`;
+  const startTime = Date.now();
+
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+    const res = await fetch(url, {
+      method: "GET",
+      headers: buildHeaders(token),
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+
+    const latencyMs = Date.now() - startTime;
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return {
+        ok: false,
+        latencyMs,
+        error: `Server responded with status ${res.status}: ${text || res.statusText}`,
+      };
+    }
+
+    const data = (await res.json().catch(() => ({}))) as any;
+    return {
+      ok: true,
+      status: data.status || "ok",
+      version: data.version,
+      uptime: data.uptime,
+      latencyMs,
+    };
+  } catch (err: any) {
+    const latencyMs = Date.now() - startTime;
+    return {
+      ok: false,
+      latencyMs,
+      error: err.name === "AbortError" ? "Connection timed out" : err.message,
+    };
+  }
+}
+
+export async function executeRemoteAction<T = unknown>(
+  serverUrl: string,
+  actionId: string,
+  input: unknown = {},
+  configOverridesOrOptions?: Record<string, unknown> | RemoteExecuteOptions,
+  tokenArg?: string
+): Promise<RemoteExecutionResult<T>> {
+  const base = normalizeServerUrl(serverUrl);
+  const url = `${base}/api/v1/actions/${encodeURIComponent(actionId)}/run`;
+
+  // Parse options / backwards compatibility
+  let configOverrides: Record<string, unknown> | undefined;
+  let token: string | undefined = tokenArg;
+  let timeoutMs: number | undefined;
+  let signal: AbortSignal | undefined;
+  let isAsync = false;
+
+  if (configOverridesOrOptions && typeof configOverridesOrOptions === "object") {
+    if (
+      "token" in configOverridesOrOptions ||
+      "timeoutMs" in configOverridesOrOptions ||
+      "signal" in configOverridesOrOptions ||
+      "async" in configOverridesOrOptions ||
+      "configOverrides" in configOverridesOrOptions
+    ) {
+      const opts = configOverridesOrOptions as RemoteExecuteOptions;
+      configOverrides = opts.configOverrides;
+      token = opts.token ?? tokenArg;
+      timeoutMs = opts.timeoutMs;
+      signal = opts.signal;
+      isAsync = Boolean(opts.async);
+    } else {
+      configOverrides = configOverridesOrOptions as Record<string, unknown>;
+    }
+  }
+
+  const executionPayload: Record<string, unknown> = {};
+  if (isAsync) {
+    executionPayload.mode = "async";
+  }
+  if (typeof timeoutMs === "number" && timeoutMs > 0) {
+    executionPayload.timeoutMs = timeoutMs;
+  }
+
+  try {
+    const headers = {
+      ...buildHeaders(token),
+      "Content-Type": "application/json",
+    };
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        input,
+        config: configOverrides,
+        execution: Object.keys(executionPayload).length > 0 ? executionPayload : undefined,
+      }),
+      signal,
+    });
+
+    const data = (await res.json().catch(() => null)) as any;
+
+    if (data && typeof data === "object" && typeof data.ok === "boolean") {
+      return data;
+    }
+
+    if (!res.ok) {
+      return {
+        ok: false,
+        runId: randomUUID(),
+        error: {
+          code: res.status === 401 ? "UNAUTHORIZED" : "REMOTE_EXECUTION_FAILED",
+          message: `Remote server HTTP ${res.status}: ${res.statusText}`,
+          details: data,
+        },
+      };
+    }
+
+    return {
+      ok: true,
+      runId: randomUUID(),
+      data,
+    };
+  } catch (err: any) {
+    if (err.name === "AbortError" || signal?.aborted) {
+      return {
+        ok: false,
+        runId: randomUUID(),
+        error: {
+          code: "ACTION_CANCELLED",
+          message: "Action execution was cancelled",
+        },
+      };
+    }
+    return {
+      ok: false,
+      runId: randomUUID(),
+      error: {
+        code: "NETWORK_ERROR",
+        message: `Failed to connect to remote ActionDock server at ${serverUrl}: ${err.message}`,
+      },
+    };
+  }
+}
+
+async function fetchRemoteJson<T = any>(
+  serverUrl: string,
+  path: string,
+  token?: string,
+  options: { method?: string; body?: unknown; errorPrefix?: string } = {}
+): Promise<T> {
+  const base = normalizeServerUrl(serverUrl);
+  const url = `${base}${path.startsWith("/") ? path : `/${path}`}`;
+  const method = options.method || "GET";
+  const headers: Record<string, string> = {
+    ...buildHeaders(token),
+  };
+  if (options.body !== undefined) {
+    headers["Content-Type"] = "application/json";
+  }
+
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+  });
+
+  const data = (await res.json().catch(() => ({}))) as any;
+
+  if (!res.ok || (options.method === "POST" && data && data.ok === false)) {
+    const errorPrefix = options.errorPrefix || "Remote request failed";
+    const msg = data?.error?.message || `${errorPrefix} (${res.status}): ${res.statusText}`;
+    throw new Error(msg);
+  }
+
+  return data as T;
+}
+
+export async function fetchRemoteRun(
+  serverUrl: string,
+  runId: string,
+  token?: string
+): Promise<RunRecord> {
+  return fetchRemoteJson<RunRecord>(
+    serverUrl,
+    `/api/v1/runs/${encodeURIComponent(runId)}`,
+    token,
+    { errorPrefix: `Failed to fetch remote run '${runId}'` }
+  );
+}
+
+export async function cancelRemoteRun(
+  serverUrl: string,
+  runId: string,
+  token?: string,
+  reason?: string
+): Promise<{ ok: boolean; runId: string; status: string }> {
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/runs/${encodeURIComponent(runId)}/cancel`,
+    token,
+    {
+      method: "POST",
+      body: { reason },
+      errorPrefix: `Failed to cancel remote run '${runId}'`,
+    }
+  );
+}
+
+export async function fetchRemoteActions(
+  serverUrl: string,
+  token?: string,
+  intent?: string
+): Promise<Array<{ id: string; description: string; packageId?: string }>> {
+  const query = intent ? `?intent=${encodeURIComponent(intent)}` : "";
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/actions${query}`,
+    token,
+    { errorPrefix: "Failed to fetch remote actions" }
+  );
+}
+
+export async function fetchRemoteActionShow(
+  serverUrl: string,
+  actionId: string,
+  token?: string
+): Promise<any> {
+  return fetchRemoteJson(
+    serverUrl,
+    `/api/v1/actions/${encodeURIComponent(actionId)}`,
+    token,
+    { errorPrefix: `Failed to fetch remote action '${actionId}'` }
+  );
+}
+
+export async function fetchRemoteInfo(
+  serverUrl: string,
+  token?: string
+): Promise<any> {
+  return fetchRemoteJson(
+    serverUrl,
+    "/api/v1/info",
+    token,
+    { errorPrefix: "Failed to fetch remote info" }
+  );
+}

package/src/profile/index.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./manager";
+export * from "./client";