@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/channels/wechat/wechat-client.ts

@@ -1,162 +0,0 @@
-import { randomBytes } from "crypto";
-
-const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
-
-function getBaseUrl(): string {
-  return process.env.WECHAT_ILINK_BASE_URL || DEFAULT_BASE_URL;
-}
-
-function generateWechatUin(): string {
-  const buf = Buffer.alloc(4);
-  buf.writeUInt32BE(Math.floor(Math.random() * 0xffffffff), 0);
-  return buf.toString("base64url");
-}
-
-async function apiGet<T>(path: string, extraHeaders?: Record<string, string>): Promise<T> {
-  const url = `${getBaseUrl()}${path}`;
-  const headers: Record<string, string> = { ...extraHeaders };
-  const res = await fetch(url, { headers });
-  if (!res.ok) {
-    throw new Error(`iLink GET ${path} failed: ${res.status} ${res.statusText}`);
-  }
-  return res.json() as Promise<T>;
-}
-
-async function apiGetAuth<T>(path: string, botToken: string, extraHeaders?: Record<string, string>): Promise<T> {
-  const url = `${getBaseUrl()}${path}`;
-  const headers: Record<string, string> = {
-    "AuthorizationType": "ilink_bot_token",
-    "X-WECHAT-UIN": generateWechatUin(),
-    "Authorization": `Bearer ${botToken}`,
-    ...extraHeaders,
-  };
-  const res = await fetch(url, { headers });
-  if (!res.ok) {
-    throw new Error(`iLink GET ${path} failed: ${res.status} ${res.statusText}`);
-  }
-  return res.json() as Promise<T>;
-}
-
-async function apiPost<T>(path: string, body: unknown, botToken: string, signal?: AbortSignal): Promise<T> {
-  const url = `${getBaseUrl()}${path}`;
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    "AuthorizationType": "ilink_bot_token",
-    "X-WECHAT-UIN": generateWechatUin(),
-    "Authorization": `Bearer ${botToken}`,
-  };
-
-  const res = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-    signal,
-  });
-  if (!res.ok) {
-    throw new Error(`iLink POST ${path} failed: ${res.status} ${res.statusText}`);
-  }
-  return res.json() as Promise<T>;
-}
-
-export async function getUpdates(
-  botToken: string,
-  syncBuffer: string,
-  signal?: AbortSignal,
-): Promise<{ msgs: Array<{
-  message_type?: number;
-  from_user_id?: string;
-  client_id?: string;
-  item_list?: Array<{ type?: number; text_item?: { text?: string } }>;
-  context_token?: string;
-  create_time_ms?: number;
-}>; syncBuffer: string }> {
-  const data = await apiPost<{
-    ret?: number;
-    errcode?: number;
-    errmsg?: string;
-    msgs?: Array<{
-      message_type?: number;
-      from_user_id?: string;
-      client_id?: string;
-      item_list?: Array<{ type?: number; text_item?: { text?: string } }>;
-      context_token?: string;
-      create_time_ms?: number;
-    }>;
-    get_updates_buf?: string;
-  }>("/ilink/bot/getupdates", {
-    get_updates_buf: syncBuffer,
-    base_info: { channel_version: "1.0.2" },
-  }, botToken, signal);
-
-  // Check API-level error codes (HTTP 200 can still be an error)
-  if ((data.ret !== undefined && data.ret !== 0) || (data.errcode !== undefined && data.errcode !== 0)) {
-    throw new Error(`iLink getUpdates error: ret=${data.ret} errcode=${data.errcode} errmsg=${data.errmsg ?? ""}`);
-  }
-
-  return {
-    msgs: data.msgs ?? [],
-    syncBuffer: data.get_updates_buf ?? syncBuffer,
-  };
-}
-
-function generateClientId(): string {
-  return `axiom-wechat:${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-}
-
-export async function sendMessage(
-  botToken: string,
-  toUserId: string,
-  text: string,
-  contextToken: string,
-): Promise<void> {
-  await apiPost<unknown>("/ilink/bot/sendmessage", {
-    msg: {
-      from_user_id: "",
-      to_user_id: toUserId,
-      client_id: generateClientId(),
-      message_type: 2, // MSG_TYPE_BOT
-      message_state: 2, // MSG_STATE_FINISH
-      item_list: [{ type: 1, text_item: { text } }],
-      context_token: contextToken,
-    },
-    base_info: { channel_version: "1.0.2" },
-  }, botToken);
-}
-
-export async function getQrCode(): Promise<{ qrcode: string; qrcodeImgUrl: string }> {
-  const data = await apiGet<{ qrcode?: string; qrcode_img_content?: string }>(
-    "/ilink/bot/get_bot_qrcode?bot_type=3",
-  );
-  if (!data.qrcode || !data.qrcode_img_content) {
-    throw new Error("Failed to get WeChat QR code");
-  }
-  return { qrcode: data.qrcode, qrcodeImgUrl: data.qrcode_img_content };
-}
-
-export async function getQrCodeStatus(
-  qrcode: string,
-  signal?: AbortSignal,
-): Promise<{
-  status: "wait" | "scaned" | "confirmed" | "expired";
-  botToken?: string;
-  uin?: string;
-  botId?: string;
-  baseUrl?: string;
-}> {
-  const data = await apiGet<{
-    status?: string;
-    bot_token?: string;
-    ilink_bot_id?: string;
-    ilink_user_id?: string;
-    baseurl?: string;
-  }>(`/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, {
-    "iLink-App-ClientVersion": "1",
-  });
-  return {
-    status: (data.status as "wait" | "scaned" | "confirmed" | "expired") || "wait",
-    botToken: data.bot_token,
-    uin: data.ilink_user_id,
-    botId: data.ilink_bot_id,
-    baseUrl: data.baseurl,
-  };
-}

package/src/config/local-a2a-templates.ts

@@ -1,59 +0,0 @@
-import { cliA2AEntryPath } from "@axiom-lattice/cli-a2a/cli-path";
-import type { LocalA2ATemplateDefinition } from "@axiom-lattice/protocols";
-
-type LocalProviderKey = "claude" | "codex" | "opencode";
-
-function buildCliA2ACommand(
-  provider: LocalProviderKey,
-  agentName: string,
-  agentDescription: string,
-): LocalA2ATemplateDefinition["command"] {
-  return {
-    executable: process.execPath,
-    args: [
-      cliA2AEntryPath,
-      "--provider",
-      provider,
-      "--hostname",
-      "localhost",
-      "--advertise-host",
-      "localhost",
-      "--agent-name",
-      agentName,
-      "--agent-description",
-      agentDescription,
-      "--log-level",
-      "info",
-    ],
-  };
-}
-
-export const LOCAL_A2A_TEMPLATES: LocalA2ATemplateDefinition[] = [
-  {
-    key: "claude",
-    name: "Claude Code",
-    command: buildCliA2ACommand(
-      "claude",
-      "Claude Code",
-      "Local Claude Code wrapper exposed through A2A.",
-    ),
-  },
-  {
-    key: "codex",
-    name: "Codex",
-    command: buildCliA2ACommand(
-      "codex",
-      "Codex",
-      "Local Codex wrapper exposed through A2A.",
-    ),
-  },
-  {
-    key: "opencode",
-    name: "OpenCode",
-    command: buildCliA2ACommand(
-      "opencode",
-      "OpenCode",
-      "Local OpenCode wrapper exposed through A2A.",
-    ),
-  },
-];

package/src/config.ts

@@ -1,124 +0,0 @@
-/**
- * Configuration service
- * Manages environment variables and supports dynamic updates
- */
-
-export interface GatewayConfig {
-  port?: number;
-  queueServiceType?: string;
-  redisUrl?: string;
-  redisPassword?: string;
-  queueName?: string;
-  [key: string]: any; // Allow additional config keys
-}
-
-/**
- * Get configuration from environment variables
- * Supports dynamic updates via updateConfig method
- */
-class ConfigService {
-  private config: GatewayConfig;
-
-  constructor() {
-    this.config = this.loadFromEnv();
-  }
-
-  /**
-   * Load configuration from environment variables
-   */
-  private loadFromEnv(): GatewayConfig {
-    return {
-      port: process.env.PORT ? Number(process.env.PORT) : undefined,
-      queueServiceType: process.env.QUEUE_SERVICE_TYPE,
-      redisUrl: process.env.REDIS_URL,
-      redisPassword: process.env.REDIS_PASSWORD,
-      queueName: process.env.QUEUE_NAME,
-    };
-  }
-
-  /**
-   * Update configuration from JSON object
-   * This will update both the internal config and process.env
-   */
-  updateConfig(jsonConfig: Record<string, any>): void {
-    // Update process.env for all provided keys
-    for (const [key, value] of Object.entries(jsonConfig)) {
-      if (value !== null && value !== undefined) {
-        // Convert nested objects to environment variable format
-        if (typeof value === "object" && !Array.isArray(value)) {
-          // Handle nested objects like supabase: { url: "...", key: "..." }
-          for (const [nestedKey, nestedValue] of Object.entries(value)) {
-            const envKey = `${key.toUpperCase()}_${nestedKey.toUpperCase()}`;
-            process.env[envKey] = String(nestedValue);
-          }
-        } else {
-          // Handle flat keys
-          process.env[key.toUpperCase()] = String(value);
-        }
-      }
-    }
-
-    // Reload config from updated environment variables
-    this.config = this.loadFromEnv();
-
-    // Deep merge the JSON config into our config object
-    this.config = this.deepMerge(this.config, jsonConfig);
-  }
-
-  /**
-   * Deep merge two objects
-   */
-  private deepMerge(target: any, source: any): any {
-    const output = { ...target };
-    if (this.isObject(target) && this.isObject(source)) {
-      Object.keys(source).forEach((key) => {
-        if (this.isObject(source[key])) {
-          if (!(key in target)) {
-            Object.assign(output, { [key]: source[key] });
-          } else {
-            output[key] = this.deepMerge(target[key], source[key]);
-          }
-        } else {
-          Object.assign(output, { [key]: source[key] });
-        }
-      });
-    }
-    return output;
-  }
-
-  /**
-   * Check if value is a plain object
-   */
-  private isObject(item: any): boolean {
-    return item && typeof item === "object" && !Array.isArray(item);
-  }
-
-  /**
-   * Get current configuration
-   */
-  getConfig(): GatewayConfig {
-    return { ...this.config };
-  }
-}
-
-// Export singleton instance
-export const configService = new ConfigService();
-
-// Export config getter for backward compatibility
-export const config = {
-  get port() {
-    return configService.getConfig().port;
-  },
-  get queueServiceType() {
-    return configService.getConfig().queueServiceType;
-  },
-  get redisUrl() {
-    return configService.getConfig().redisUrl;
-  },
-  get redisPassword() {
-    return configService.getConfig().redisPassword;
-  },
-  get queueName() {
-    return configService.getConfig().queueName;
-  },
-};

package/src/controllers/__tests__/assistant-local-a2a.test.ts

@@ -1,147 +0,0 @@
-import type { FastifyReply, FastifyRequest } from "fastify";
-import { AgentType } from "@axiom-lattice/protocols";
-
-const mockGetStoreLattice = jest.fn();
-const mockPublish = jest.fn();
-
-jest.mock("@axiom-lattice/core", () => ({
-  agentInstanceManager: {},
-  agentLatticeManager: {
-    getAllAgentConfigsByTenant: jest.fn(),
-    getAgentConfigWithTenant: jest.fn(),
-  },
-  eventBus: {
-    publish: (...args: unknown[]) => mockPublish(...args),
-  },
-  getStoreLattice: (...args: unknown[]) => mockGetStoreLattice(...args),
-}));
-
-describe("createAssistant local A2A validation", () => {
-  let createAssistant: typeof import("../assistant").createAssistant;
-
-  beforeEach(async () => {
-    jest.clearAllMocks();
-    ({ createAssistant } = await import("../assistant"));
-  });
-
-  function mockReply(): FastifyReply {
-    return {
-      status: jest.fn().mockReturnThis(),
-      send: jest.fn(),
-    } as unknown as FastifyReply;
-  }
-
-  it("rejects an empty local runtime executable before upsert", async () => {
-    const reply = mockReply();
-    const request = {
-      headers: { "x-tenant-id": "tenant-1" },
-      body: {
-        name: "Incomplete Local A2A",
-        graphDefinition: {
-          key: "incomplete-local-a2a",
-          name: "Incomplete Local A2A",
-          type: AgentType.A2A_REMOTE,
-          agentCardUrl: "http://localhost:4301/.well-known/agent-card.json",
-          localRuntime: {
-            agentCardUrl: "http://localhost:4301/.well-known/agent-card.json",
-            command: { executable: "   ", args: [] },
-          },
-        },
-      },
-    } as unknown as FastifyRequest;
-
-    await createAssistant(request as Parameters<typeof createAssistant>[0], reply);
-
-    expect(reply.status).toHaveBeenCalledWith(400);
-    expect(reply.send).toHaveBeenCalledWith({
-      success: false,
-      message: "Local managed A2A command executable is required",
-    });
-    expect(mockGetStoreLattice).not.toHaveBeenCalled();
-  });
-
-  it("rejects local runtime port mismatches before upsert", async () => {
-    const reply = mockReply();
-    const request = {
-      headers: { "x-tenant-id": "tenant-1" },
-      body: {
-        name: "Bad Local A2A",
-        graphDefinition: {
-          key: "bad-local-a2a",
-          name: "Bad Local A2A",
-          type: AgentType.A2A_REMOTE,
-          agentCardUrl: "http://localhost:4301/.well-known/agent-card.json",
-          localRuntime: {
-            agentCardUrl: "http://localhost:4301/.well-known/agent-card.json",
-            command: {
-              executable: "node",
-              args: ["--port", "4302"],
-            },
-          },
-        },
-      },
-    } as unknown as FastifyRequest;
-
-    await createAssistant(request as Parameters<typeof createAssistant>[0], reply);
-
-    expect(reply.status).toHaveBeenCalledWith(400);
-    expect(reply.send).toHaveBeenCalledWith({
-      success: false,
-      message: expect.stringContaining("command port (4302) does not match agentCardUrl port (4301)"),
-    });
-    expect(mockGetStoreLattice).not.toHaveBeenCalled();
-  });
-
-  it("rejects local runtime port collisions across assistants", async () => {
-    const reply = mockReply();
-    const getAllAssistants = jest.fn().mockResolvedValue([
-      {
-        id: "existing-local-a2a",
-        name: "Existing Local A2A",
-        graphDefinition: {
-          type: AgentType.A2A_REMOTE,
-          agentCardUrl: "http://127.0.0.1:4301/.well-known/agent-card.json",
-          localRuntime: {
-            agentCardUrl: "http://127.0.0.1:4301/.well-known/agent-card.json",
-            command: {
-              executable: "node",
-              args: ["packages/cli-a2a/dist/cli.js", "--provider", "codex", "--port", "4301"],
-            },
-          },
-        },
-      },
-    ]);
-    mockGetStoreLattice.mockReturnValueOnce({
-      store: { getAllAssistants },
-    });
-
-    const request = {
-      headers: { "x-tenant-id": "tenant-1" },
-      body: {
-        name: "New Local A2A",
-        graphDefinition: {
-          key: "new-local-a2a",
-          name: "New Local A2A",
-          type: AgentType.A2A_REMOTE,
-          agentCardUrl: "http://localhost:4301/custom-agent-card",
-          localRuntime: {
-            agentCardUrl: "http://localhost:4301/custom-agent-card",
-            command: {
-              executable: "node",
-              args: ["packages/cli-a2a/dist/cli.js", "--provider", "claude", "--port", "4301"],
-            },
-          },
-        },
-      },
-    } as unknown as FastifyRequest;
-
-    await createAssistant(request as Parameters<typeof createAssistant>[0], reply);
-
-    expect(getAllAssistants).toHaveBeenCalledWith("tenant-1");
-    expect(reply.status).toHaveBeenCalledWith(409);
-    expect(reply.send).toHaveBeenCalledWith({
-      success: false,
-      message: expect.stringContaining("port 4301"),
-    });
-  });
-});

package/src/controllers/__tests__/local-a2a-templates.test.ts

@@ -1,112 +0,0 @@
-import fastify, { FastifyInstance } from "fastify";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { getLocalA2ATemplates } from "../local-a2a-templates";
-
-describe("Local A2A templates (static config)", () => {
-  let app: FastifyInstance;
-
-  beforeEach(() => {
-    app = fastify();
-    app.get("/api/local-a2a/templates", getLocalA2ATemplates);
-  });
-
-  afterEach(async () => {
-    await app.close();
-  });
-
-  it("returns 3 static templates", async () => {
-    const response = await app.inject({
-      method: "GET",
-      url: "/api/local-a2a/templates",
-    });
-
-    expect(response.statusCode).toBe(200);
-    const body = JSON.parse(response.body);
-    expect(body.success).toBe(true);
-    expect(body.data.records).toHaveLength(3);
-    expect(body.data.total).toBe(3);
-    expect(body.data.records.map((template: { key: string }) => template.key).sort()).toEqual([
-      "claude",
-      "codex",
-      "opencode",
-    ]);
-  });
-
-  it("each template has key, name, and command properties", async () => {
-    const response = await app.inject({
-      method: "GET",
-      url: "/api/local-a2a/templates",
-    });
-
-    const body = JSON.parse(response.body);
-    for (const template of body.data.records) {
-      expect(template).toHaveProperty("key");
-      expect(typeof template.key).toBe("string");
-      expect(template).toHaveProperty("name");
-      expect(typeof template.name).toBe("string");
-      expect(template).toHaveProperty("command");
-      expect(template.command).toHaveProperty("executable");
-      expect(Array.isArray(template.command.args)).toBe(true);
-    }
-  });
-
-  it("starts the cli-a2a wrapper instead of provider CLIs directly", async () => {
-    const response = await app.inject({
-      method: "GET",
-      url: "/api/local-a2a/templates",
-    });
-
-    const body = JSON.parse(response.body);
-    const packagePath = createRequire(__filename).resolve(
-      "@axiom-lattice/cli-a2a/package.json",
-    );
-    const expectedEntryPath = join(dirname(packagePath), "dist", "cli.js");
-    for (const template of body.data.records) {
-      expect(template.command.executable).toBe(process.execPath);
-      expect(template.command.args[0]).toBe(expectedEntryPath);
-      expect(template.command.args).toEqual(expect.arrayContaining([
-        "--provider",
-        template.key,
-      ]));
-      expect(template.command.args).not.toContain("--serve");
-    }
-  });
-
-  it("does not include agentCardUrl or port in any template", async () => {
-    const response = await app.inject({
-      method: "GET",
-      url: "/api/local-a2a/templates",
-    });
-
-    const body = JSON.parse(response.body);
-    for (const template of body.data.records) {
-      expect(template).not.toHaveProperty("agentCardUrl");
-      expect(template).not.toHaveProperty("port");
-      expect(template).not.toHaveProperty("template");
-      expect(template).not.toHaveProperty("id");
-      expect(template.command).not.toHaveProperty("port");
-      // args should not contain a port flag
-      const hasPortFlag = template.command.args.some(
-        (arg: string) => arg === "--port" || arg === "-p" || /^--port=/.test(arg) || /^-p=/.test(arg),
-      );
-      expect(hasPortFlag).toBe(false);
-    }
-  });
-
-  it("response shape matches expected structure", async () => {
-    const response = await app.inject({
-      method: "GET",
-      url: "/api/local-a2a/templates",
-    });
-
-    const body = JSON.parse(response.body);
-    expect(body).toEqual({
-      success: true,
-      data: {
-        records: expect.any(Array),
-        total: 3,
-      },
-    });
-  });
-});

package/src/controllers/__tests__/mime.test.ts

@@ -1,74 +0,0 @@
-import { getContentTypeFromFilename, getFilenameFromPath } from "../../utils/mime";
-
-describe("getContentTypeFromFilename", () => {
-  it("returns text/html for .html", () => {
-    expect(getContentTypeFromFilename("index.html")).toBe("text/html");
-  });
-
-  it("returns text/css for .css", () => {
-    expect(getContentTypeFromFilename("styles.css")).toBe("text/css");
-  });
-
-  it("returns application/javascript for .js", () => {
-    expect(getContentTypeFromFilename("app.js")).toBe("application/javascript");
-  });
-
-  it("returns application/json for .json", () => {
-    expect(getContentTypeFromFilename("data.json")).toBe("application/json");
-  });
-
-  it("returns image/png for .png", () => {
-    expect(getContentTypeFromFilename("logo.png")).toBe("image/png");
-  });
-
-  it("returns image/svg+xml for .svg", () => {
-    expect(getContentTypeFromFilename("icon.svg")).toBe("image/svg+xml");
-  });
-
-  it("returns application/pdf for .pdf", () => {
-    expect(getContentTypeFromFilename("report.pdf")).toBe("application/pdf");
-  });
-
-  it("returns Office MIME types", () => {
-    expect(getContentTypeFromFilename("sheet.xlsx")).toContain("spreadsheet");
-    expect(getContentTypeFromFilename("sheet.xls")).toContain("excel");
-  });
-
-  it("returns application/octet-stream for unknown extensions", () => {
-    expect(getContentTypeFromFilename("file.unknown")).toBe("application/octet-stream");
-  });
-
-  it("returns application/octet-stream for no extension", () => {
-    expect(getContentTypeFromFilename("README")).toBe("application/octet-stream");
-  });
-
-  it("handles paths with directory separators", () => {
-    expect(getContentTypeFromFilename("/app/static/script.js")).toBe("application/javascript");
-  });
-
-  it("handles uppercase extensions", () => {
-    expect(getContentTypeFromFilename("LOGO.PNG")).toBe("image/png");
-  });
-});
-
-describe("getFilenameFromPath", () => {
-  it("extracts filename from path", () => {
-    expect(getFilenameFromPath("/project/uploads/foo.html")).toBe("foo.html");
-  });
-
-  it("extracts filename from simple path", () => {
-    expect(getFilenameFromPath("foo.html")).toBe("foo.html");
-  });
-
-  it("handles trailing slashes", () => {
-    expect(getFilenameFromPath("/project/uploads/")).toBe("uploads");
-  });
-
-  it("returns download for empty path", () => {
-    expect(getFilenameFromPath("")).toBe("download");
-  });
-
-  it("returns download for root path", () => {
-    expect(getFilenameFromPath("/")).toBe("download");
-  });
-});