@axiom-lattice/gateway 2.1.20 → 2.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.20",
+  "version": "2.1.22",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -17,9 +17,12 @@
   "description": "API Gateway for LangGraph agent-based applications",
   "dependencies": {
     "@fastify/cors": "^11.0.0",
+    "@fastify/http-proxy": "^9.5.0",
+    "@fastify/reply-from": "^12.5.0",
     "@fastify/sensible": "^6.0.3",
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
+    "@fastify/websocket": "^11.0.1",
     "@langchain/core": "1.1.4",
     "@langchain/langgraph": "1.0.4",
     "@supabase/supabase-js": "^2.49.1",
@@ -32,15 +35,16 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.15",
-    "@axiom-lattice/protocols": "2.1.9",
-    "@axiom-lattice/queue-redis": "1.0.8"
+    "@axiom-lattice/core": "2.1.17",
+    "@axiom-lattice/protocols": "2.1.11",
+    "@axiom-lattice/queue-redis": "1.0.10"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/lodash": "^4.17.16",
     "@types/node": "^20.17.23",
     "@types/uuid": "^9.0.8",
+    "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
     "eslint": "^8.57.0",

package/src/controllers/sandbox.ts

@@ -0,0 +1,150 @@
+import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+// import { WebSocket, createWebSocketStream } from "ws";
+import { pipeline } from "stream/promises";
+import { sandboxService } from "../services/sandbox_service";
+const SANDBOX_BASE_URL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
+
+interface SandboxParams {
+  assistantId: string;
+  threadId: string;
+}
+
+interface ProxyParams extends SandboxParams {
+  "*": string;
+}
+
+interface ResourceParams extends SandboxParams {
+  resourcePath: string;
+}
+
+export async function registerSandboxProxyRoutes(app: FastifyInstance): Promise<void> {
+  app.get<{ Params: SandboxParams }>(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox",
+    async (request, reply) => {
+      const { assistantId, threadId } = request.params;
+
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        const errorHtml = sandboxService.generateErrorHtml(
+          assistantId,
+          threadId,
+          "unknown",
+          `Assistant ${assistantId} not found`
+        );
+        return reply.status(404).type("text/html").send(errorHtml);
+      }
+
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+
+      try {
+        const html = await sandboxService.getVncHtml(sandboxName);
+        const rewrittenHtml = sandboxService.rewriteHtml(html, assistantId, threadId);
+        return reply.type("text/html").send(rewrittenHtml);
+      } catch (error: any) {
+        const errorHtml = sandboxService.generateErrorHtml(
+          assistantId,
+          threadId,
+          isolatedLevel,
+          error.message || "Failed to connect to sandbox"
+        );
+        return reply.status(502).type("text/html").send(errorHtml);
+      }
+    }
+  );
+
+
+
+  // app.get<{ Params: SandboxParams }>(
+  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/websockify",
+  //   { websocket: true },
+
+  //   (connection, request) => {
+
+  //     const url = (connection?.url) as string;
+  //     console.log(`[WebSocket] Received connection from URL: ${url}`);
+
+  //     const urlMatch = url.match(/\/api\/assistants\/([^/]+)\/threads\/([^/]+)\/sandbox\/websockify/);
+  //     if (!urlMatch) {
+  //       console.error(`[WebSocket] Failed to parse params from URL: ${url}`);
+  //       connection.close(1008, "Invalid URL format");
+  //       return;
+  //     }
+
+  //     const assistantId = urlMatch[1];
+  //     const threadId = urlMatch[2];
+  //     console.log(`[WebSocket] Parsed params - assistantId: ${assistantId}, threadId: ${threadId}`);
+
+  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+  //     if (!sandboxConfig) {
+  //       console.error(`[WebSocket] Assistant ${assistantId} not found`);
+  //       connection.close(1008, "Assistant not found");
+  //       return;
+  //     }
+
+  //     const { isolatedLevel } = sandboxConfig;
+  //     const sandboxName = sandboxService.computeSandboxName(
+  //       assistantId,
+  //       threadId,
+  //       isolatedLevel
+  //     );
+
+  //     const targetUrl = sandboxService.getTargetUrl(sandboxName);
+  //     const targetWsUrl = targetUrl.replace(/^http/, "ws").replace(/^https/, "wss") + "/websockify";
+
+  //     console.log(`[WebSocket] Connecting to target: ${targetWsUrl}`);
+
+  //     const targetSocket = new WebSocket(targetWsUrl);
+  //     const clientStream = createWebSocketStream(connection, { encoding: "utf8" });
+
+  //     const targetStream = createWebSocketStream(targetSocket, { encoding: "utf8" });
+
+  //     const forward = pipeline(clientStream, targetStream);
+  //     const backward = pipeline(targetStream, clientStream);
+
+  //     Promise.all([forward, backward]).catch((err) => {
+  //       console.error(`[WebSocket] Proxy pipeline failed:`, err.message);
+  //       targetSocket.terminate();
+  //       connection.terminate();
+  //     });
+  //   }
+  // );
+
+  app.get<{ Params: ProxyParams }>(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox/vnc/*",
+    async (request, reply) => {
+      const { assistantId, threadId, "*": restPath } = request.params;
+
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        return reply.status(404).send("Assistant not found");
+      }
+
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+
+      const targetPath = restPath ? `/vnc/${restPath}` : "/vnc/";
+      const targetUrl = `${sandboxService.getTargetUrl(sandboxName)}${targetPath}`;
+
+      try {
+        const response = await fetch(targetUrl);
+        const contentType = response.headers.get("content-type") || "application/octet-stream";
+
+        const body = await response.arrayBuffer();
+        reply.status(response.status).type(contentType).send(Buffer.from(body));
+      } catch (error: any) {
+        reply.status(502).send(`Proxy error: ${error.message}`);
+      }
+    }
+  );
+
+
+}

package/src/controllers/skills.ts

@@ -0,0 +1,474 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { getStoreLattice } from "@axiom-lattice/core";
+import { validateSkillName } from "@axiom-lattice/core";
+import type {
+  Skill,
+  CreateSkillRequest,
+} from "@axiom-lattice/protocols";
+
+/**
+ * Skills Controller
+ * Handles skill-related CRUD operations
+ */
+
+/**
+ * Skill list response interface
+ */
+interface SkillListResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: Skill[];
+    total: number;
+  };
+}
+
+/**
+ * Skill response interface
+ */
+interface SkillResponse {
+  success: boolean;
+  message: string;
+  data?: Skill;
+}
+
+/**
+ * Skill update request body interface
+ */
+interface SkillUpdateBody {
+  name?: string;
+  description?: string;
+  license?: string;
+  compatibility?: string;
+  metadata?: Record<string, string>;
+  content?: string;
+  subSkills?: string[];
+}
+
+/**
+ * Serialize Skill object for JSON response
+ * Converts Date objects to ISO strings
+ * Explicitly creates a plain object to ensure all fields are serializable
+ */
+function serializeSkill(skill: Skill): any {
+  // Explicitly create a plain object with all fields
+  // This ensures Fastify can properly serialize the response
+  const serialized: any = {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    license: skill.license,
+    compatibility: skill.compatibility,
+    metadata: skill.metadata || {},
+    content: skill.content,
+    subSkills: skill.subSkills,
+    createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : (skill.createdAt ? new Date(skill.createdAt).toISOString() : new Date().toISOString()),
+    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : (skill.updatedAt ? new Date(skill.updatedAt).toISOString() : new Date().toISOString()),
+  };
+
+  // Remove undefined fields to avoid serialization issues
+  Object.keys(serialized).forEach((key) => {
+    if (serialized[key] === undefined) {
+      delete serialized[key];
+    }
+  });
+
+  return serialized;
+}
+
+/**
+ * Get list of all skills
+ */
+export async function getSkillList(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  try {
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.getAllSkills();
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully retrieved skill list",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Get a single skill by ID
+ */
+export async function getSkill(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<SkillResponse> {
+  try {
+    const { id } = request.params;
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skill = await skillStore.getSkillById(id);
+
+    if (!skill) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    return {
+      success: true,
+      message: "Successfully retrieved skill",
+      data: serializeSkill(skill),
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Create a new skill
+ */
+export async function createSkill(
+  request: FastifyRequest<{ Body: CreateSkillRequest }>,
+  reply: FastifyReply
+): Promise<SkillResponse> {
+  try {
+    const data = request.body;
+
+    // Validate required fields
+    if (!data.name) {
+      return reply.status(400).send({
+        success: false,
+        message: "name is required",
+      });
+    }
+
+    if (!data.description) {
+      return reply.status(400).send({
+        success: false,
+        message: "description is required",
+      });
+    }
+
+    // Validate name format
+    try {
+      validateSkillName(data.name);
+    } catch (error: any) {
+      return reply.status(400).send({
+        success: false,
+        message: error.message || "Invalid skill name format",
+      });
+    }
+
+    // ID must equal name (name is used for path addressing)
+    const id = (request.body as any).id || data.name;
+    
+    if (id !== data.name) {
+      return reply.status(400).send({
+        success: false,
+        message: `id "${id}" must equal name "${data.name}" (name is used for path addressing)`,
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill already exists
+    const exists = await skillStore.hasSkill(id);
+    if (exists) {
+      return reply.status(409).send({
+        success: false,
+        message: `Skill with id "${id}" already exists`,
+      });
+    }
+
+    // Create skill
+    const newSkill = await skillStore.createSkill(id, data);
+
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created skill",
+      data: serializeSkill(newSkill),
+    });
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to create skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Update an existing skill by ID
+ */
+export async function updateSkill(
+  request: FastifyRequest<{
+    Params: { id: string };
+    Body: SkillUpdateBody;
+  }>,
+  reply: FastifyReply
+): Promise<SkillResponse> {
+  try {
+    const { id } = request.params;
+    const updates = request.body;
+
+    // Validate name format if name is being updated
+    if (updates.name !== undefined) {
+      try {
+        validateSkillName(updates.name);
+      } catch (error: any) {
+        return reply.status(400).send({
+          success: false,
+          message: error.message || "Invalid skill name format",
+        });
+      }
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill exists
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    // Update skill
+    const updatedSkill = await skillStore.updateSkill(id, updates);
+
+    if (!updatedSkill) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to update skill",
+      });
+    }
+
+    return {
+      success: true,
+      message: "Successfully updated skill",
+      data: serializeSkill(updatedSkill),
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to update skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Delete a skill by ID
+ */
+export async function deleteSkill(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; message: string }> {
+  try {
+    const { id } = request.params;
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill exists
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    // Delete the skill
+    const deleted = await skillStore.deleteSkill(id);
+
+    if (!deleted) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to delete skill",
+      });
+    }
+
+    return {
+      success: true,
+      message: "Successfully deleted skill",
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to delete skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Search skills by metadata
+ */
+export async function searchSkillsByMetadata(
+  request: FastifyRequest<{
+    Querystring: { key: string; value: string };
+  }>,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  try {
+    const { key, value } = request.query;
+
+    if (!key || !value) {
+      return reply.status(400).send({
+        success: false,
+        message: "key and value query parameters are required",
+        data: {
+          records: [],
+          total: 0,
+        },
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.searchByMetadata(key, value);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully searched skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to search skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter skills by compatibility
+ */
+export async function filterSkillsByCompatibility(
+  request: FastifyRequest<{
+    Querystring: { compatibility: string };
+  }>,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  try {
+    const { compatibility } = request.query;
+
+    if (!compatibility) {
+      return reply.status(400).send({
+        success: false,
+        message: "compatibility query parameter is required",
+        data: {
+          records: [],
+          total: 0,
+        },
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByCompatibility(compatibility);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter skills by license
+ */
+export async function filterSkillsByLicense(
+  request: FastifyRequest<{
+    Querystring: { license: string };
+  }>,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  try {
+    const { license } = request.query;
+
+    if (!license) {
+      return reply.status(400).send({
+        success: false,
+        message: "license query parameter is required",
+        data: {
+          records: [],
+          total: 0,
+        },
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByLicense(license);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}