@axiom-lattice/gateway 2.1.39 → 2.1.41

package/src/__tests__/data-query.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach, jest } from "@jest/globals";
+import { FastifyRequest, FastifyReply } from "fastify";
+import { executeDataQuery } from "../controllers/data-query";
+
+// Mock @axiom-lattice/core
+jest.mock("@axiom-lattice/core", () => ({
+  getStoreLattice: jest.fn(),
+  metricsServerManager: {
+    hasServer: jest.fn(),
+    registerServer: jest.fn(),
+  },
+  SemanticMetricsClient: jest.fn(),
+}));
+
+describe("Data Query Controller", () => {
+  let mockRequest: Partial<FastifyRequest>;
+  let mockReply: Partial<FastifyReply>;
+
+  beforeEach(() => {
+    mockRequest = {
+      headers: { "x-tenant-id": "test-tenant" },
+      body: {},
+    };
+    mockReply = {
+      code: jest.fn().mockReturnThis(),
+    };
+  });
+
+  describe("Request validation", () => {
+    it("should return 400 if neither serverKey nor datasourceId is provided", async () => {
+      mockRequest.body = {};
+      
+      const result = await executeDataQuery(
+        mockRequest as FastifyRequest,
+        mockReply as FastifyReply
+      );
+
+      expect(mockReply.code).toHaveBeenCalledWith(400);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("serverKey or datasourceId");
+    });
+
+    it("should return 400 if neither metrics nor customSql is provided", async () => {
+      mockRequest.body = {
+        serverKey: "test-server",
+        datasourceId: "1",
+      };
+
+      const result = await executeDataQuery(
+        mockRequest as FastifyRequest,
+        mockReply as FastifyReply
+      );
+
+      expect(mockReply.code).toHaveBeenCalledWith(400);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("metrics (for semantic query) or customSql (for SQL query)");
+    });
+
+    it("should return 400 if both metrics and customSql are provided", async () => {
+      mockRequest.body = {
+        serverKey: "test-server",
+        datasourceId: "1",
+        metrics: ["test_metric"],
+        customSql: "SELECT * FROM test",
+      };
+
+      const result = await executeDataQuery(
+        mockRequest as FastifyRequest,
+        mockReply as FastifyReply
+      );
+
+      expect(mockReply.code).toHaveBeenCalledWith(400);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("Cannot provide both");
+    });
+  });
+});

package/src/controllers/data-query.ts

@@ -0,0 +1,236 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import {
+  getStoreLattice,
+  metricsServerManager,
+  SemanticMetricsClient,
+} from "@axiom-lattice/core";
+import type {
+  MetricsServerConfigStore,
+  SemanticMetricsServerConfig,
+  SemanticMetricsFilter,
+} from "@axiom-lattice/protocols";
+
+/**
+ * Get tenant ID from request headers
+ */
+function getTenantId(request: FastifyRequest): string {
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+/**
+ * Data query request body
+ */
+interface DataQueryRequest {
+  serverKey?: string;
+  datasourceId?: string;
+  metrics?: string[];
+  groupBy?: string[];
+  filters?: Array<{
+    dimension: string;
+    operator: string;
+    values: (string | number | boolean)[];
+  }>;
+  customSql?: string;
+  params?: Record<string, string | number | boolean>;
+  limit?: number;
+}
+
+/**
+ * Data query response - 只返回原始数据
+ */
+interface DataQueryResponse {
+  success: boolean;
+  message: string;
+  data?: {
+    // 语义查询结果
+    semanticModel?: string;
+    columns: Array<{ name: string; type: string }>;
+    rows?: Array<Array<unknown>>;
+    rowsObject?: Array<Record<string, unknown>>;
+    // SQL 查询结果
+    tableName?: string;
+    executedSql?: string;
+    // 通用元数据
+    metadata: {
+      rowCount: number;
+      executionTimeMs?: number;
+    };
+  };
+}
+
+/**
+ * Execute data query (semantic or SQL)
+ */
+export async function executeDataQuery(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<DataQueryResponse> {
+  const tenantId = getTenantId(request);
+  const body = request.body as DataQueryRequest;
+
+  try {
+    // Validate request
+    if (!body.serverKey && !body.datasourceId) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Either serverKey or datasourceId must be provided",
+      };
+    }
+
+    // Determine query type
+    const isSemanticQuery = body.metrics && body.metrics.length > 0;
+    const isSqlQuery = body.customSql && body.customSql.trim().length > 0;
+
+    if (!isSemanticQuery && !isSqlQuery) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Either metrics (for semantic query) or customSql (for SQL query) must be provided",
+      };
+    }
+
+    if (isSemanticQuery && isSqlQuery) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Cannot provide both metrics and customSql. Use one query type only.",
+      };
+    }
+
+    // Get server config
+    const storeLattice = getStoreLattice("default", "metrics");
+    const store: MetricsServerConfigStore = storeLattice.store;
+
+    if (!body.serverKey) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "serverKey is required",
+      };
+    }
+
+    const config = await store.getConfigByKey(tenantId, body.serverKey);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: `Metrics server configuration not found: ${body.serverKey}`,
+      };
+    }
+
+    if (config.config.type !== "semantic") {
+      reply.code(400);
+      return {
+        success: false,
+        message: "This endpoint only supports semantic metrics servers",
+      };
+    }
+
+    if (!body.datasourceId) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "datasourceId is required",
+      };
+    }
+
+    // Check if server is registered
+    if (!metricsServerManager.hasServer(tenantId, body.serverKey)) {
+      reply.code(400);
+      return {
+        success: false,
+        message: `Metrics server not registered: ${body.serverKey}. Please register the server first.`,
+      };
+    }
+
+    // Get client from manager (read-only, no registration)
+    const client = metricsServerManager.getClient(tenantId, body.serverKey) as SemanticMetricsClient;
+
+    // Execute query based on type
+    if (isSemanticQuery) {
+      return await executeSemanticQuery(client, body, reply);
+    } else {
+      return await executeSqlQuery(client, body, reply);
+    }
+  } catch (error) {
+    console.error("Failed to execute data query:", error);
+    reply.code(500);
+    return {
+      success: false,
+      message: `Failed to execute data query: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Execute semantic query
+ */
+async function executeSemanticQuery(
+  client: SemanticMetricsClient,
+  body: DataQueryRequest,
+  reply: FastifyReply
+): Promise<DataQueryResponse> {
+  const semanticFilters: SemanticMetricsFilter[] = (body.filters || []).map(f => ({
+    dimension: f.dimension,
+    operator: f.operator,
+    values: f.values,
+  }));
+
+  const result = await client.semanticQuery({
+    datasourceId: body.datasourceId!,
+    metrics: body.metrics!,
+    groupBy: body.groupBy,
+    filters: semanticFilters,
+    limit: body.limit || 1000,
+  });
+
+  // 直接返回原始数据，不做 ECharts 转换
+  return {
+    success: true,
+    message: "Semantic query executed successfully",
+    data: {
+      semanticModel: result.semanticModel,
+      columns: result.columns,
+      rows: result.rows,
+      rowsObject: result.rowsObject,
+      metadata: {
+        rowCount: result.rowCount,
+        executionTimeMs: result.executionTimeMs,
+      },
+    },
+  };
+}
+
+/**
+ * Execute SQL query
+ */
+async function executeSqlQuery(
+  client: SemanticMetricsClient,
+  body: DataQueryRequest,
+  reply: FastifyReply
+): Promise<DataQueryResponse> {
+  const result = await client.executeSqlQuery({
+    datasourceId: body.datasourceId!,
+    customSql: body.customSql!,
+    params: body.params,
+    limit: body.limit || 100,
+  });
+
+  // 直接返回原始数据，不做 ECharts 转换
+  return {
+    success: true,
+    message: "SQL query executed successfully",
+    data: {
+      tableName: result.tableName,
+      columns: result.columns.map(name => ({ name, type: 'unknown' })),
+      rows: result.rows,
+      rowsObject: result.rowsObject,
+      executedSql: result.executedSql,
+      metadata: {
+        rowCount: result.rowCount,
+        executionTimeMs: result.executionTimeMs,
+      },
+    },
+  };
+}

package/src/controllers/metrics-configs.ts

@@ -220,17 +220,16 @@ interface SemanticQueryResponse {
   success: boolean;
   message: string;
   data?: {
-    datasourceId: string | number;
-    metrics: string[];
+    semanticModel: string;
+    columns: string[];
     dataPoints: Array<{
       timestamp?: number;
       value: number;
-      metricName?: string;
       labels?: Record<string, string>;
     }>;
     metadata?: {
       rowCount?: number;
-      queryTimeMs?: number;
+      columnCount?: number;
     };
   };
 }
@@ -857,40 +856,45 @@ export async function querySemanticMetrics(
     const result = await client.semanticQuery(body);
 
     // Transform SemanticMetricsQueryResponse to response format
-    // The response contains results array with metric data
+    // The response contains columns and rows arrays
+    const columnNames = result.columns.map(col => col.name);
     const allDataPoints: Array<{
       timestamp?: number;
       value: number;
-      metricName?: string;
       labels?: Record<string, string>;
     }> = [];
-    const metricNames: string[] = [];
-
-    for (const metricResult of result.results) {
-      metricNames.push(metricResult.metricName);
-      for (const row of metricResult.rows) {
-        allDataPoints.push({
-          timestamp: row.timestamp ? new Date(row.timestamp as string).getTime() : undefined,
-          value: typeof row.value === 'number' ? row.value : 0,
-          metricName: metricResult.metricName,
-          labels: Object.fromEntries(
-            Object.entries(row).filter(([k]) => k !== 'value' && k !== 'timestamp')
-              .map(([k, v]) => [k, String(v)])
-          ),
-        });
-      }
+
+    // Find timestamp column and value column indices
+    const timestampColIdx = columnNames.findIndex(col => 
+      col.toLowerCase().includes('date') || col.toLowerCase().includes('time')
+    );
+    const valueColIdx = columnNames.findIndex(col => 
+      col.toLowerCase().includes('value') || col.toLowerCase().includes('rate') || col.toLowerCase().includes('amt')
+    );
+
+    for (const row of result.rows) {
+      const timestamp = timestampColIdx >= 0 ? row[timestampColIdx] : undefined;
+      const value = valueColIdx >= 0 ? row[valueColIdx] : row[row.length - 1];
+      
+      allDataPoints.push({
+        timestamp: timestamp ? new Date(String(timestamp)).getTime() : undefined,
+        value: typeof value === 'number' ? value : Number(value) || 0,
+        labels: Object.fromEntries(
+          columnNames.map((col, idx) => [col, String(row[idx] ?? '')])
+        ),
+      });
     }
 
     return {
       success: true,
       message: "Semantic query executed successfully",
       data: {
-        datasourceId: result.datasourceId,
-        metrics: metricNames,
+        semanticModel: result.semanticModel,
+        columns: columnNames,
         dataPoints: allDataPoints,
         metadata: {
-          rowCount: allDataPoints.length,
-          queryTimeMs: result.totalExecutionTimeMs,
+          rowCount: result.rows.length,
+          columnCount: result.columns.length,
         },
       },
     };

package/src/controllers/workspace.ts

@@ -457,6 +457,46 @@ export class WorkspaceController {
           const webStream = body.stream();
           const nodeStream = Readable.fromWeb(webStream);
           const contentType = body.contentType ?? inferredContentType;
+          console.log(`[viewFile] Sandbox returned stream, contentType: ${contentType}, filename: ${filename}`);
+          
+          // Check if it's HTML and needs context injection
+          const isHtml = contentType?.toLowerCase().includes("text/html") || 
+                         filename.toLowerCase().endsWith(".html") || 
+                         filename.toLowerCase().endsWith(".htm");
+          
+          if (isHtml) {
+            console.log(`[viewFile] HTML stream detected, collecting for context injection`);
+            // Collect stream content
+            const chunks: Buffer[] = [];
+            for await (const chunk of nodeStream) {
+              chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            let content = Buffer.concat(chunks).toString("utf-8");
+            const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
+              tenantId,
+              workspaceId,
+              projectId,
+              timestamp: Date.now()
+            })};</script>`;
+            
+            if (content.toLowerCase().includes("</head>")) {
+              content = content.replace(/<\/head>/i, `${contextScript}</head>`);
+              console.log(`[viewFile] Context script injected before </head> (stream)`);
+            } else if (content.toLowerCase().includes("<html>")) {
+              content = content.replace(/<html>/i, `<html>${contextScript}`);
+              console.log(`[viewFile] Context script injected after <html> (stream)`);
+            } else {
+              content = contextScript + content;
+              console.log(`[viewFile] Context script prepended to content (stream)`);
+            }
+            
+            return reply
+              .status(200)
+              .type(contentType)
+              .header("Content-Disposition", "inline")
+              .send(Buffer.from(content, "utf-8"));
+          }
+          
           // inline for viewing, not attachment for download
           return reply
             .status(200)
@@ -487,6 +527,33 @@ export class WorkspaceController {
           return reply.status(502).send({ success: false, error: "Unexpected view response format" });
         }
 
+        // Inject AI2APP context script for HTML files (sandbox storage)
+        const isHtml = contentType?.toLowerCase().includes("text/html") || 
+                       filename.toLowerCase().endsWith(".html") || 
+                       filename.toLowerCase().endsWith(".htm");
+        if (isHtml) {
+          console.log(`[viewFile] Injecting AI2APP context for sandbox HTML file: ${filename}, tenantId: ${tenantId}, contentType: ${contentType}`);
+          let content = buf.toString("utf-8");
+          const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
+            tenantId,
+            workspaceId,
+            projectId,
+            timestamp: Date.now()
+          })};</script>`;
+          
+          if (content.toLowerCase().includes("</head>")) {
+            content = content.replace(/<\/head>/i, `${contextScript}</head>`);
+            console.log(`[viewFile] Context script injected before </head>`);
+          } else if (content.toLowerCase().includes("<html>")) {
+            content = content.replace(/<html>/i, `<html>${contextScript}`);
+            console.log(`[viewFile] Context script injected after <html>`);
+          } else {
+            content = contextScript + content;
+            console.log(`[viewFile] Context script prepended to content`);
+          }
+          buf = Buffer.from(content, "utf-8");
+        }
+
         return reply
           .status(200)
           .type(contentType)
@@ -498,7 +565,34 @@ export class WorkspaceController {
       const content = await backend.read(resolvedPath, 0, Infinity);
       const filename = this.getFilenameFromPath(resolvedPath);
       const mimeType = this.getMimeType(filename);
-      const buffer = Buffer.from(content, "utf-8");
+
+      // Inject AI2APP context script for HTML files
+      let finalContent = content;
+      const isHtmlFs = mimeType?.toLowerCase().includes("text/html") || 
+                       filename.toLowerCase().endsWith(".html") || 
+                       filename.toLowerCase().endsWith(".htm");
+      if (isHtmlFs) {
+        console.log(`[viewFile] Injecting AI2APP context for filesystem HTML file: ${filename}, tenantId: ${tenantId}, mimeType: ${mimeType}`);
+        const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
+          tenantId,
+          workspaceId,
+          projectId,
+          timestamp: Date.now()
+        })};</script>`;
+        // Insert before </head> or </html>
+        if (content.toLowerCase().includes("</head>")) {
+          finalContent = content.replace(/<\/head>/i, `${contextScript}</head>`);
+          console.log(`[viewFile] Context script injected before </head>`);
+        } else if (content.toLowerCase().includes("</html>")) {
+          finalContent = content.replace(/<\/html>/i, `${contextScript}</html>`);
+          console.log(`[viewFile] Context script injected before </html>`);
+        } else {
+          finalContent = content + contextScript;
+          console.log(`[viewFile] Context script appended to content`);
+        }
+      }
+
+      const buffer = Buffer.from(finalContent, "utf-8");
 
       return reply
         .status(200)

package/src/index.ts

@@ -3,6 +3,8 @@ import cors from "@fastify/cors";
 import multipart from "@fastify/multipart";
 import sensible from "@fastify/sensible";
 import websocket from "@fastify/websocket";
+import staticPlugin from "@fastify/static";
+import path from "path";
 import { registerLatticeRoutes } from "./routes";
 import { configureSwagger } from "./swagger";
 import {
@@ -122,6 +124,12 @@ app.register(multipart, {
 });
 app.register(websocket);
 
+// Register static file serving for SDK
+app.register(staticPlugin, {
+  root: path.join(__dirname, "../public"),
+  prefix: "/",
+});
+
 // Error handler
 app.setErrorHandler((error, request, reply) => {
   // Convert headers to strings (Fastify headers can be string | string[])
@@ -197,6 +205,9 @@ const start = async (config?: LatticeGatewayConfig) => {
     // Access via: request.server.loggerLattice or app.loggerLattice
     app.decorate("loggerLattice", loggerLattice);
 
+    // Register all routes
+    registerLatticeRoutes(app);
+
     // Register sandbox manager if not already registered
     if (!sandboxLatticeManager.hasLattice("default")) {
       const sandboxBaseURL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";

package/src/routes/index.ts

@@ -12,6 +12,7 @@ import * as modelsController from "../controllers/models";
 import * as healthController from "../controllers/health";
 import * as skillsController from "../controllers/skills";
 import * as toolsController from "../controllers/tools";
+import * as dataQueryController from "../controllers/data-query";
 import {
   createRunSchema,
   getAllMemoryItemsSchema,
@@ -27,6 +28,7 @@ import {
   getConfigSchema,
   getHealthSchema,
   getSandboxUrlSchema,
+  dataQuerySchema,
 } from "../schemas";
 import { registerSandboxProxyRoutes } from "../controllers/sandbox";
 import { registerWorkspaceRoutes } from "../controllers/workspace";
@@ -307,6 +309,15 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
 
   registerMetricsServerConfigRoutes(app);
 
+  // Data query route
+  app.post<{
+    Body: any;
+  }>(
+    "/api/data/query",
+    { schema: dataQuerySchema },
+    dataQueryController.executeDataQuery
+  );
+
   registerMcpServerConfigRoutes(app);
 
   registerUserRoutes(app);

package/src/schemas/data-query.ts

@@ -0,0 +1,69 @@
+import { FastifySchema } from "fastify";
+
+export const dataQuerySchema: FastifySchema = {
+  description: "Execute data query (semantic or SQL)",
+  tags: ["Data Query"],
+  summary: "Query Data",
+  body: {
+    type: "object",
+    properties: {
+      serverKey: { 
+        type: "string", 
+        description: "Target semantic metrics server key (optional if configured in runConfig)" 
+      },
+      datasourceId: { 
+        type: "string", 
+        description: "Data source ID (optional if configured in runConfig)" 
+      },
+      // Semantic query parameters
+      metrics: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of metric names for semantic query"
+      },
+      groupBy: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional array of dimensions to group by"
+      },
+      filters: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            dimension: { type: "string" },
+            operator: { type: "string" },
+            values: {
+              type: "array",
+              items: { type: ["string", "number", "boolean"] }
+            }
+          },
+          required: ["dimension", "operator", "values"]
+        },
+        description: "Optional array of filters"
+      },
+      // SQL query parameters
+      customSql: {
+        type: "string",
+        description: "Custom SQL query string with named parameters"
+      },
+      params: {
+        type: "object",
+        additionalProperties: { type: ["string", "number", "boolean"] },
+        description: "Optional parameters for SQL query"
+      },
+      // Common parameters
+      limit: {
+        type: "number",
+        description: "Maximum number of results (default: 1000)"
+      },
+      format: {
+        type: "string",
+        enum: ["echarts", "raw"],
+        description: "Response format (default: echarts)"
+      }
+    }
+  },
+  // Response schema temporarily removed - format not yet finalized
+  // TODO: Add proper response schema once data format is confirmed
+};

package/src/schemas/index.ts

@@ -847,3 +847,6 @@ export const getSandboxUrlSchema: FastifySchema = {
     },
   },
 };
+
+// Data Query Schema
+export { dataQuerySchema } from "./data-query";

package/src/services/agent_task_consumer.ts

@@ -55,6 +55,8 @@ const handleAgentTask = async (
       headers: {
         "Content-Type": "application/json",
         "x-tenant-id": tenant_id,
+        "x-workspace-id": runConfig?.workspaceId as string,
+        "x-project-id": runConfig?.projectId as string,
       },
     }).catch((err) => {
       console.error(`fetch请求失败: ${err.message || String(err)}`);