@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/utils/__tests__/local-a2a-runtime.test.ts

@@ -1,77 +0,0 @@
-import type { LocalRuntimeConfig } from "@axiom-lattice/protocols";
-import {
-  getAgentCardPort,
-  validateLocalRuntimeCommand,
-  validateLocalRuntimePort,
-} from "../local-a2a-runtime";
-
-function runtime(args: string[]): LocalRuntimeConfig {
-  return {
-    agentCardUrl: "http://localhost:4301/.well-known/agent-card.json",
-    command: {
-      executable: "node",
-      args,
-    },
-  };
-}
-
-describe("validateLocalRuntimePort", () => {
-  it.each([
-    ["localhost", "http://localhost:4301/.well-known/agent-card.json"],
-    ["127.0.0.1", "http://127.0.0.1:4301/.well-known/agent-card.json"],
-    ["ipv6 loopback", "http://[::1]:4301/.well-known/agent-card.json"],
-  ])("detects port mismatches for %s", (_label, agentCardUrl) => {
-    const result = validateLocalRuntimePort(runtime(["--port=4302"]), agentCardUrl);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toContain("command port (4302) does not match agentCardUrl port (4301)");
-    }
-  });
-
-  it.each([
-    ["--port next arg", ["--port", "4301"]],
-    ["--port inline", ["--port=4301"]],
-    ["-p next arg", ["-p", "4301"]],
-    ["-p inline", ["-p=4301"]],
-  ])("accepts matching %s", (_label, args) => {
-    expect(validateLocalRuntimePort(runtime(args), "http://localhost:4301/.well-known/agent-card.json")).toEqual({ ok: true });
-  });
-
-  it("does not block remote URLs or commands without parseable ports", () => {
-    expect(validateLocalRuntimePort(runtime(["--port=4302"]), "https://example.com:4301/.well-known/agent-card.json")).toEqual({ ok: true });
-    expect(validateLocalRuntimePort(runtime(["--listen", "4302"]), "http://localhost:4301/.well-known/agent-card.json")).toEqual({ ok: true });
-  });
-});
-
-describe("validateLocalRuntimeCommand", () => {
-  it.each(["", "   "])("rejects executable %j", (executable) => {
-    const result = validateLocalRuntimeCommand({
-      ...runtime([]),
-      command: { executable, args: [] },
-    });
-
-    expect(result).toEqual({
-      ok: false,
-      error: "Local managed A2A command executable is required",
-    });
-  });
-
-  it("accepts a complete command", () => {
-    expect(validateLocalRuntimeCommand(runtime(["cli.js"]))).toEqual({
-      ok: true,
-    });
-  });
-});
-
-describe("getAgentCardPort", () => {
-  it.each([
-    ["explicit localhost port", "http://localhost:4301/.well-known/agent-card.json", 4301],
-    ["explicit 127 port", "http://127.0.0.1:4302/.well-known/agent-card.json", 4302],
-    ["default http port", "http://localhost/.well-known/agent-card.json", 80],
-    ["default https port", "https://localhost/.well-known/agent-card.json", 443],
-    ["invalid URL", "not a url", null],
-  ])("returns %s", (_label, agentCardUrl, expected) => {
-    expect(getAgentCardPort(agentCardUrl)).toBe(expected);
-  });
-});

package/src/utils/__tests__/path-containment.test.ts

@@ -1,35 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import {
-  isPathWithinRoot,
-  PathOutsideRootError,
-  resolvePathWithinRoot,
-} from "../path-containment";
-
-describe("path containment", () => {
-  it("does not accept a sibling with the same path prefix", () => {
-    expect(isPathWithinRoot("/Users/alice", "/Users/alice-other")).toBe(false);
-  });
-
-  it("accepts the root and its descendants", () => {
-    expect(isPathWithinRoot("/Users/alice", "/Users/alice")).toBe(true);
-    expect(isPathWithinRoot("/Users/alice", "/Users/alice/project")).toBe(true);
-  });
-
-  it("rejects a symlink that resolves outside the root", async () => {
-    const testRoot = await fs.mkdtemp(path.join(os.tmpdir(), "path-root-"));
-    const outside = await fs.mkdtemp(path.join(os.tmpdir(), "path-outside-"));
-    const linkPath = path.join(testRoot, "outside-link");
-    await fs.symlink(outside, linkPath, "dir");
-
-    try {
-      await expect(resolvePathWithinRoot(testRoot, linkPath)).rejects.toBeInstanceOf(
-        PathOutsideRootError,
-      );
-    } finally {
-      await fs.rm(testRoot, { recursive: true, force: true });
-      await fs.rm(outside, { recursive: true, force: true });
-    }
-  });
-});

package/src/utils/a2a-url.ts

@@ -1,20 +0,0 @@
-const AGENT_CARD_PATH = "/.well-known/agent-card.json";
-
-export function normalizeA2AAgentCardUrl(
-  value: string | undefined,
-  defaultProtocol: "http://" | "https://" = "https://"
-): string {
-  const raw = value?.trim() ?? "";
-  if (!raw) return "";
-
-  const withProtocol = /^https?:\/\//i.test(raw)
-    ? raw
-    : `${defaultProtocol}${raw.replace(/^\/+/, "")}`;
-  const trimmed = withProtocol.replace(/\/+$/, "");
-
-  if (trimmed.endsWith(AGENT_CARD_PATH)) {
-    return trimmed;
-  }
-
-  return `${trimmed}${AGENT_CARD_PATH}`;
-}

package/src/utils/local-a2a-runtime.ts

@@ -1,107 +0,0 @@
-import type { LocalRuntimeConfig } from "@axiom-lattice/protocols";
-
-export type LocalRuntimeValidationResult =
-  | { ok: true }
-  | { ok: false; error: string };
-
-export function validateLocalRuntimeCommand(
-  localRuntime: LocalRuntimeConfig,
-): LocalRuntimeValidationResult {
-  const runtime = localRuntime as unknown as {
-    command?: { executable?: unknown; args?: unknown };
-  };
-  const executable = runtime.command?.executable;
-  if (typeof executable !== "string" || executable.trim().length === 0) {
-    return {
-      ok: false,
-      error: "Local managed A2A command executable is required",
-    };
-  }
-
-  const args = runtime.command?.args;
-  if (!Array.isArray(args) || !args.every((arg) => typeof arg === "string")) {
-    return {
-      ok: false,
-      error: "Local managed A2A command args must be an array of strings",
-    };
-  }
-
-  return { ok: true };
-}
-
-export function getAgentCardPort(agentCardUrl: string): number | null {
-  let url: URL;
-  try {
-    url = new URL(agentCardUrl);
-  } catch {
-    return null;
-  }
-
-  if (url.port) {
-    const port = Number(url.port);
-    return Number.isInteger(port) ? port : null;
-  }
-
-  if (url.protocol === "http:") return 80;
-  if (url.protocol === "https:") return 443;
-  return null;
-}
-
-function parseCommandPort(args: string[]): number | null {
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    const match = /^(--port|-p)(?:[=\s]+(\d+))?$/.exec(arg);
-    if (!match) continue;
-
-    const inlinePort = match[2];
-    if (inlinePort) return Number(inlinePort);
-
-    const nextArg = args[index + 1];
-    if (nextArg && /^\d+$/.test(nextArg)) {
-      return Number(nextArg);
-    }
-  }
-
-  return null;
-}
-
-function isLoopbackHost(hostname: string): boolean {
-  const normalized = hostname.toLowerCase();
-  return (
-    normalized === "localhost" ||
-    normalized === "127.0.0.1" ||
-    normalized === "::1" ||
-    normalized === "[::1]"
-  );
-}
-
-export function validateLocalRuntimePort(
-  localRuntime: LocalRuntimeConfig,
-  agentCardUrl: string,
-): LocalRuntimeValidationResult {
-  let url: URL;
-  try {
-    url = new URL(agentCardUrl);
-  } catch {
-    return { ok: true };
-  }
-
-  if (!isLoopbackHost(url.hostname) || !url.port) {
-    return { ok: true };
-  }
-
-  const commandPort = parseCommandPort(localRuntime.command.args);
-  if (commandPort === null) {
-    return { ok: true };
-  }
-
-  const agentCardPort = Number(url.port);
-  if (commandPort === agentCardPort) {
-    return { ok: true };
-  }
-
-  return {
-    ok: false,
-    error: `Local managed A2A command port (${commandPort}) does not match agentCardUrl port (${agentCardPort}). Update the command args or Agent Card URL so they use the same port.`,
-  };
-}

package/src/utils/mime.ts

@@ -1,44 +0,0 @@
-const EXT_TO_MIME: Record<string, string> = {
-  ".txt": "text/plain",
-  ".md": "text/markdown",
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".css": "text/css",
-  ".js": "application/javascript",
-  ".mjs": "application/javascript",
-  ".json": "application/json",
-  ".pdf": "application/pdf",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".zip": "application/zip",
-  ".csv": "text/csv",
-  ".xml": "application/xml",
-  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  ".xls": "application/vnd.ms-excel",
-  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  ".ppt": "application/vnd.ms-powerpoint",
-  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  ".doc": "application/msword",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg",
-};
-
-export function getContentTypeFromFilename(filename: string): string {
-  const ext = filename.includes(".")
-    ? filename.slice(filename.lastIndexOf(".")).toLowerCase()
-    : "";
-  return EXT_TO_MIME[ext] ?? "application/octet-stream";
-}
-
-export function getFilenameFromPath(path: string): string {
-  const segments = path.replace(/\/+$/, "").split("/");
-  return segments[segments.length - 1] || "download";
-}

package/src/utils/path-containment.ts

@@ -1,38 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-
-export class PathOutsideRootError extends Error {
-  constructor(
-    public readonly rootPath: string,
-    public readonly targetPath: string,
-  ) {
-    super(`Path is outside the allowed root: ${targetPath}`);
-    this.name = "PathOutsideRootError";
-  }
-}
-
-export function isPathWithinRoot(rootPath: string, targetPath: string): boolean {
-  const relative = path.relative(rootPath, targetPath);
-  return (
-    relative === "" ||
-    (relative !== ".." &&
-      !relative.startsWith(`..${path.sep}`) &&
-      !path.isAbsolute(relative))
-  );
-}
-
-export async function resolvePathWithinRoot(
-  rootPath: string,
-  targetPath: string,
-): Promise<{ rootPath: string; targetPath: string }> {
-  const [resolvedRoot, resolvedTarget] = await Promise.all([
-    fs.realpath(rootPath),
-    fs.realpath(targetPath),
-  ]);
-
-  if (!isPathWithinRoot(resolvedRoot, resolvedTarget)) {
-    throw new PathOutsideRootError(resolvedRoot, resolvedTarget);
-  }
-
-  return { rootPath: resolvedRoot, targetPath: resolvedTarget };
-}

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "preserve",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "moduleResolution": "Bundler",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "types": ["node", "jest"],
-    "paths": {
-      "@*": ["./src/*"]
-    },
-    "sourceMap": true,
-    "incremental": true, // 确保启用增量编译
-    "tsBuildInfoFile": "./.tsbuildinfo" // 指定构建信息文件位置
-  },
-  "include": ["src/index.ts"],
-  "exclude": ["node_modules", "dist"]
-}