@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/export_registrations/skill.registration.ts

@@ -1,88 +0,0 @@
-import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
-import { getStoreLattice } from '@axiom-lattice/core';
-import type { SkillStore } from '@axiom-lattice/protocols';
-
-function getStore(): SkillStore {
-  return getStoreLattice('default', 'skill').store as unknown as SkillStore;
-}
-
-export const skillRegistration: ExportableEntityDefinition = {
-  entityType: 'skill',
-  label: 'Skill(技能)',
-  category: 'core',
-  dependsOn: [],
-  cascadeParents: [],
-
-  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
-    const store = getStore();
-    const skills = await store.getAllSkills(tenantId);
-    return skills.map((s) => ({
-      _exportId: '',
-      data: {
-        id: s.id,
-        name: s.name,
-        description: s.description,
-        license: s.license,
-        compatibility: s.compatibility,
-        metadata: s.metadata,
-        content: s.content,
-        subSkills: s.subSkills,
-      },
-    }));
-  },
-
-  async previewImport(
-    tenantId: string,
-    entities: ExportableEntity[],
-  ): Promise<ImportPreviewResult> {
-    const store = getStore();
-    const existing = await store.getAllSkills(tenantId);
-    const existingIds = new Set(existing.map((s) => s.id));
-
-    const conflicts: ImportPreviewResult['conflicts'] = [];
-    const insertions: ImportPreviewResult['insertions'] = [];
-
-    for (const entity of entities) {
-      const id = entity.data.id as string;
-      if (existingIds.has(id)) {
-        conflicts.push({
-          _exportId: entity._exportId,
-          entityType: 'skill',
-          conflictType: 'id_exists',
-          existingId: id,
-          existingName: (entity.data.name as string) || id,
-        });
-      } else {
-        insertions.push({
-          _exportId: entity._exportId,
-          entityType: 'skill',
-          name: (entity.data.name as string) || id,
-        });
-      }
-    }
-
-    return { conflicts, insertions, errors: [] };
-  },
-
-  async applyImport(tenantId, entity, resolution) {
-    const store = getStore();
-    const data = entity.data as Record<string, unknown>;
-    const id = resolution.action === 'rename' && resolution.newId ? resolution.newId : data.id as string;
-
-    if (resolution.action === 'overwrite') {
-      try { await store.deleteSkill(tenantId, id); } catch { /* may not exist */ }
-    }
-
-    await store.createSkill(tenantId, id, {
-      name: data.name as string,
-      description: data.description as string,
-      license: data.license as string | undefined,
-      compatibility: data.compatibility as string | undefined,
-      metadata: data.metadata as Record<string, string> | undefined,
-      content: data.content as string | undefined,
-      subSkills: data.subSkills as string[] | undefined,
-    });
-
-    return { newId: id };
-  },
-};

package/src/export_registrations/task.registration.ts

@@ -1,99 +0,0 @@
-import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
-import { getStoreLattice } from '@axiom-lattice/core';
-import type { TaskStore } from '@axiom-lattice/protocols';
-
-function getStore(): TaskStore {
-  return getStoreLattice('default', 'task').store as unknown as TaskStore;
-}
-
-export const taskRegistration: ExportableEntityDefinition = {
-  entityType: 'task',
-  label: 'Task(任务)',
-  category: 'core',
-  dependsOn: ['agent'],
-  cascadeParents: [],
-  referenceFields: { ownerId: 'agent', parentId: 'task' },
-
-  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
-    const store = getStore();
-    const tasks = await store.list({ tenantId, limit: 10000, offset: 0 });
-    return tasks.map((t) => ({
-      _exportId: '',
-      data: {
-        id: t.id,
-        title: t.title,
-        description: t.description,
-        status: t.status,
-        priority: t.priority,
-        dueDate: t.dueDate,
-        ownerType: t.ownerType,
-        ownerId: t.ownerId,
-        metadata: t.metadata,
-        parentId: t.parentId,
-        sourceId: t.sourceId,
-        context: t.context,
-      },
-    }));
-  },
-
-  async previewImport(
-    tenantId: string,
-    entities: ExportableEntity[],
-  ): Promise<ImportPreviewResult> {
-    const store = getStore();
-    const existing = await store.list({ tenantId, limit: 10000, offset: 0 });
-    const existingIds = new Set(existing.map((t) => t.id));
-
-    const conflicts: ImportPreviewResult['conflicts'] = [];
-    const insertions: ImportPreviewResult['insertions'] = [];
-
-    for (const entity of entities) {
-      const d = entity.data as Record<string, unknown>;
-      const id = d.id as string;
-      if (existingIds.has(id)) {
-        conflicts.push({
-          _exportId: entity._exportId,
-          entityType: 'task',
-          conflictType: 'id_exists',
-          existingId: id,
-          existingName: (d.title as string) || id,
-        });
-      } else {
-        insertions.push({
-          _exportId: entity._exportId,
-          entityType: 'task',
-          name: (d.title as string) || id,
-        });
-      }
-    }
-
-    return { conflicts, insertions, errors: [] };
-  },
-
-  async applyImport(tenantId, entity, resolution) {
-    const store = getStore();
-    const data = entity.data as Record<string, unknown>;
-    const id = resolution.action === 'rename' && resolution.newId ? resolution.newId : data.id as string;
-
-    if (resolution.action === 'overwrite') {
-      try { await store.delete(tenantId, id); } catch { /* may not exist */ }
-    }
-
-    await store.create({
-      tenantId,
-      ownerType: (data.ownerType as 'user' | 'agent') || 'user',
-      ownerId: data.ownerId as string || '',
-      title: data.title as string,
-      description: data.description as string | undefined,
-      status: data.status as 'pending' | 'in_progress' | 'completed' | 'cancelled' | undefined,
-      priority: data.priority as 'low' | 'medium' | 'high' | undefined,
-      dueDate: data.dueDate as string | undefined,
-      metadata: data.metadata as Record<string, unknown> | undefined,
-      parentId: data.parentId as string | undefined,
-      sourceId: data.sourceId as string | undefined,
-      context: data.context as Record<string, unknown> | undefined,
-    });
-
-    return { newId: id };
-  },
-};

package/src/index.ts

@@ -1,497 +0,0 @@
-import "dotenv/config";
-import fastify from "fastify";
-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 { fileURLToPath } from "url";
-import { registerLatticeRoutes } from "./routes";
-import { registerResourceRoutes } from "./routes/resource-routes";
-import { registerAllBuiltinEntities } from "./export_registrations";
-import type { ChannelInstallationStore, BindingRegistry } from "@axiom-lattice/protocols";
-import { MessageRouter } from "./router/MessageRouter";
-import { ChannelAdapterRegistry } from "./channels/registry";
-import { createDeduplicationMiddleware, createRateLimitMiddleware, createAuditLoggerMiddleware } from "./router/middlewares";
-import { setBindingRegistry, setMenuRegistry, setEvalRunService } from "@axiom-lattice/core";
-import { larkChannelAdapter } from "./channels/lark/LarkChannelAdapter";
-import { extractUserFromAuthHeader } from "./controllers/auth";
-import { setChannelControllerDeps } from "./controllers/channel-installations";
-import { evalRunner } from "./services/eval-runner";
-import { configureSwagger } from "./swagger";
-import {
-  setQueueServiceType,
-  QueueServiceType,
-} from "./services/queue_service";
-import { AgentTaskConsumer } from "./services/agent_task_consumer";
-import {
-  registerLoggerLattice,
-  getLoggerLattice,
-  loggerLatticeManager,
-  sandboxLatticeManager,
-  getStoreLattice,
-  agentInstanceManager,
-  createSandboxProvider,
-  type CreateSandboxProviderConfig,
-  TokenCache,
-  mcpManager,
-} from "@axiom-lattice/core";
-import {
-  LoggerType,
-  LoggerConfig,
-  PinoFileOptions,
-  McpServerConfigStore,
-} from "@axiom-lattice/protocols";
-process.on("unhandledRejection", (reason, promise) => {
-  console.error("未处理的Promise拒绝:", reason);
-  // 可以在这里进行日志记录或其他处理
-});
-
-// Default logger configuration
-const DEFAULT_LOGGER_CONFIG: LoggerConfig = {
-  name: "default",
-  description: "Default logger for lattice-gateway service",
-  type: LoggerType.PINO,
-  serviceName: "lattice/gateway",
-  loggerName: "lattice/gateway",
-};
-
-// Initialize logger with default config (can be overridden in start function)
-let loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
-let logger = loggerLattice.client;
-
-/**
- * Initialize logger lattice with given configuration
- */
-function initializeLogger(config: LoggerConfig) {
-  // Remove existing logger if it exists
-  if (loggerLatticeManager.hasLattice("default")) {
-    loggerLatticeManager.removeLattice("default");
-  }
-
-  // Register logger with provided config
-  registerLoggerLattice("default", config);
-
-  // Get and return logger lattice instance
-  return getLoggerLattice("default");
-}
-
-// 创建 Fastify 应用
-const app = fastify({
-  logger: false,
-  bodyLimit: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024,
-});
-
-// Custom content type parser to handle DELETE requests with Content-Type but no body
-// This prevents "Body cannot be empty when content-type is set to 'application/json'" error
-app.addContentTypeParser('application/json', { parseAs: 'string' }, function (request, body, done) {
-  // For DELETE requests or empty body, return empty object
-  if (request.method === 'DELETE' || !body || body.length === 0) {
-    done(null, {});
-    return;
-  }
-  try {
-    const json = JSON.parse(body as string);
-    done(null, json);
-  } catch (err) {
-    done(err as Error, undefined);
-  }
-});
-
-
-// Helper: extract single header value (Fastify headers can be string | string[])
-const getHeaderValue = (
-  header: string | string[] | undefined
-): string | undefined => {
-  if (Array.isArray(header)) {
-    return header[0];
-  }
-  return header;
-};
-
-// Routes that don't require authentication even when AUTH_REQUIRED=true
-const PUBLIC_ROUTES = ["/api/auth/login", "/api/auth/register", "/health", "/api/stt/models"];
-
-// Global auth preHandler: extract user from Authorization header
-// When AUTH_REQUIRED=true, reject unauthenticated requests (except public routes)
-app.addHook("preHandler", async (request, reply) => {
-  const user = extractUserFromAuthHeader(request.headers.authorization);
-  if (user) {
-    (request as any).user = user;
-    return;
-  }
-
-  const authRequired = process.env.AUTH_REQUIRED === "true";
-  if (!authRequired) return;
-
-  // OPTIONS preflight should always pass
-  if (request.method === "OPTIONS") return;
-
-  // Public routes don't require authentication
-  if (PUBLIC_ROUTES.some((r) => request.url === r)) return;
-
-  // Public resource shares — /s/:token and /s/:token/*
-  if (request.url.startsWith("/s/")) return;
-
-  // Allow direct URL access for iframe endpoints (viewfile, downloadfile)
-  // These carry tenant context via query params and are accessed by iframes
-  const urlPath = request.url.split("?")[0];
-  if (urlPath.includes("/viewfile") || urlPath.includes("/downloadfile") || urlPath.includes("/uploadfile")) return;
-
-  // Internal file access — auth handled by controller (Referer check)
-  if (urlPath.startsWith("/f/") || urlPath === "/f") return;
-
-  return reply.status(401).send({
-    success: false,
-    error: "Unauthorized - Missing or invalid token",
-  });
-});
-
-// Add default header values for project/workspace isolation
-app.addHook("onRequest", (request, reply, done) => {
-  if (!request.headers["x-project-id"]) {
-    request.headers["x-project-id"] = "default";
-  }
-  done();
-});
-
-// Add custom logging hooks
-app.addHook("onRequest", (request, reply, done) => {
-  const context = {
-    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
-    "x-request-id": getHeaderValue(request.headers["x-request-id"]),
-    "x-user-id": getHeaderValue(request.headers["x-user-id"]),
-  };
-  // Update logger context for this request
-  if (loggerLattice.updateContext) {
-    loggerLattice.updateContext(context);
-  }
-  done();
-});
-
-app.addHook("onResponse", (request, reply, done) => {
-  const context = {
-    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
-    "x-request-id": getHeaderValue(request.headers["x-request-id"]),
-    "x-user-id": getHeaderValue(request.headers["x-user-id"]),
-  };
-  //loggerLattice.info(`${request.method} ${request.url} - ${reply.statusCode}`);
-  done();
-});
-
-// cors
-app.register(cors, {
-  origin: true,
-  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"],
-  allowedHeaders: "*",
-  exposedHeaders: ["Content-Type"],
-  credentials: true,
-});
-app.register(sensible);
-app.register(multipart, {
-  limits: {
-    fileSize: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024,
-  },
-});
-app.register(websocket);
-
-// Register static file serving for SDK
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-app.register(staticPlugin, {
-  root: path.join(__dirname, "../public"),
-  prefix: "/",
-});
-
-// Error handler
-app.setErrorHandler((error, request, reply) => {
-  const context = {
-    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
-    "x-request-id": getHeaderValue(request.headers["x-request-id"]),
-    "x-user-id": getHeaderValue(request.headers["x-user-id"]),
-  };
-  logger.error(
-    `请求错误: ${request.method} ${request.url} error:${error.message}`,
-    {
-      ...context,
-      error: error.message,
-      stack: error.stack,
-      statusCode: error.statusCode || 500,
-    }
-  );
-  reply.status(error.statusCode || 500).send({
-    success: false,
-    error: error.message || "服务器内部错误",
-  });
-});
-
-// Logger lattice will be decorated in start() function
-
-/**
- * Logger configuration for gateway
- */
-export interface GatewayLoggerConfig {
-  name?: string;
-  description?: string;
-  type?: LoggerType;
-  serviceName?: string;
-  loggerName?: string;
-  file?: string | PinoFileOptions;
-  context?: Record<string, any>;
-}
-
-// Gateway configuration interface
-export interface LatticeGatewayConfig {
-  port?: number;
-  queueServiceConfig?: {
-    type: QueueServiceType;
-    defaultStartPollingQueue: boolean;
-  };
-  loggerConfig?: Partial<GatewayLoggerConfig>; // Optional logger configuration to override defaults
-}
-
-function getConfiguredSandboxProvider(): ReturnType<typeof createSandboxProvider> {
-  const sandboxProviderType =
-    (process.env.SANDBOX_PROVIDER_TYPE as CreateSandboxProviderConfig["type"] | undefined) ||
-    "microsandbox-remote";
-
-  return createSandboxProvider({
-    type: sandboxProviderType,
-    remoteBaseURL: process.env.SANDBOX_BASE_URL,
-    microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
-    e2bApiKey: process.env.E2B_API_KEY,
-    e2bTemplate: process.env.E2B_TEMPLATE,
-    e2bTimeoutMs: process.env.E2B_TIMEOUT_MS
-      ? parseInt(process.env.E2B_TIMEOUT_MS, 10)
-      : undefined,
-    daytonaApiKey: process.env.DAYTONA_API_KEY,
-    daytonaApiUrl: process.env.DAYTONA_API_URL,
-    daytonaTarget: process.env.DAYTONA_TARGET,
-    daytonaTimeout: process.env.DAYTONA_TIMEOUT
-      ? parseInt(process.env.DAYTONA_TIMEOUT, 10)
-      : undefined,
-    daytonaVolumeName: process.env.DAYTONA_VOLUME_NAME,
-  });
-}
-
-/**
- * Restore MCP server connections that were connected before gateway shutdown.
- * Loads configs with status "connected" from the store and reconnects them.
- */
-async function restoreMcpConnections(): Promise<void> {
-  try {
-    const storeLattice = getStoreLattice("default", "mcp");
-    const store = storeLattice.store as McpServerConfigStore;
-    if (!store) {
-      logger.info("MCP store not configured, skipping connection restoration");
-      return;
-    }
-
-    const configs = await store.getAllConfigs("default");
-    const connectedConfigs = configs.filter((c) => c.status === "connected");
-
-    if (connectedConfigs.length === 0) return;
-
-    logger.info(`Restoring ${connectedConfigs.length} MCP server connections...`);
-
-    const { convertToConnection } = await import("./controllers/mcp-configs");
-
-    for (const config of connectedConfigs) {
-      try {
-        const connection = convertToConnection(config.config);
-        mcpManager.addServer(config.key, connection);
-      } catch (err) {
-        logger.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
-      }
-    }
-
-    await mcpManager.connect();
-
-    for (const config of connectedConfigs) {
-      try {
-        await mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
-        logger.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
-      } catch (err) {
-        logger.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
-      }
-    }
-
-    logger.info(`MCP connection restoration complete: ${connectedConfigs.length} servers`);
-  } catch (err) {
-    logger.error("MCP connection restoration failed", { error: err });
-  }
-}
-
-// Start server
-const start = async (config?: LatticeGatewayConfig) => {
-  try {
-    // Initialize or update logger configuration if provided
-    if (config?.loggerConfig) {
-      const loggerConfig: LoggerConfig = {
-        ...DEFAULT_LOGGER_CONFIG,
-        ...config.loggerConfig,
-        // Merge file config if provided
-        file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file,
-      };
-      loggerLattice = initializeLogger(loggerConfig);
-      logger = loggerLattice.client;
-    }
-
-    // Decorate app with logger lattice (only once, in start function)
-    // Access via: request.server.loggerLattice or app.loggerLattice
-    app.decorate("loggerLattice", loggerLattice);
-
-    // Channel infrastructure: use stores from StoreLatticeManager.
-    // Applications (e.g. deep_research) register stores via configureStores()
-    // before calling startAsHttpEndpoint(). If no stores are registered,
-    // channel features are gracefully skipped.
-    let channelDeps: { router: MessageRouter; installationStore: ChannelInstallationStore } | undefined;
-    const adapterRegistry = new ChannelAdapterRegistry();
-    adapterRegistry.register(larkChannelAdapter);
-    const { wechatChannelAdapter } = await import("./channels/wechat/WechatChannelAdapter");
-    adapterRegistry.register(wechatChannelAdapter);
-    try {
-      const { getStoreLattice: getStore } = await import("@axiom-lattice/core");
-      const bindingStore = getStore("default", "channelBinding").store as BindingRegistry;
-      const installationStore = getStore("default", "channelInstallation").store as ChannelInstallationStore;
-
-      setBindingRegistry(bindingStore);
-
-      const router = new MessageRouter({
-        middlewares: [
-          createDeduplicationMiddleware(),
-          createRateLimitMiddleware(),
-          createAuditLoggerMiddleware(),
-        ],
-        bindingRegistry: bindingStore,
-        adapterRegistry,
-        installationStore,
-        
-      });
-
-      channelDeps = { router, installationStore };
-
-      // Initialize A2A API key store
-      try {
-        const a2aKeyStore = getStore("default", "a2aApiKey").store as import("@axiom-lattice/protocols").A2AApiKeyStore;
-        const a2a = await import("./routes/a2a");
-        a2a.setA2AKeyStore(a2aKeyStore);
-        await a2a.refreshStoreKeyMap();
-        logger.info("A2A key store initialized");
-      } catch {
-        // A2A key store optional — env-based keys still work
-      }
-    } catch (err) {
-      logger.warn("Channel infrastructure unavailable", {
-        error: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    setEvalRunService(evalRunner);
-
-    // Initialize MenuRegistry for custom menu items
-    try {
-      const menuStore = getStoreLattice("default", "menu").store;
-      setMenuRegistry(menuStore);
-      logger.info("Menu registry initialized");
-    } catch {
-      // Menu store optional — custom menus won't work without it
-    }
-
-    // Register export/import entity types before routes
-    registerAllBuiltinEntities();
-
-    // Register all routes (channel routes only active if channelDeps is set)
-    // Wire controller deps so enable/disable/delete can manage live connections
-    if (channelDeps?.router) {
-      setChannelControllerDeps({ adapterRegistry, router: channelDeps.router });
-    }
-    registerLatticeRoutes(app, channelDeps);
-
-    // Register sandbox manager if not already registered
-    if (!sandboxLatticeManager.hasLattice("default")) {
-      sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
-      logger.info("Registered sandbox manager from env configuration");
-    }
-
-    // Initialize resource share controller
-    try {
-      const { ResourceController } = await import("./controllers/resources");
-      const sharedResourceStore = getStoreLattice("default", "sharedResource").store;
-      const cache = new TokenCache();
-      const resourceController = new ResourceController({
-        store: sharedResourceStore,
-        sandboxManager: sandboxLatticeManager,
-        cache,
-        logger,
-      });
-      registerResourceRoutes(app, resourceController);
-      logger.info("Resource share routes registered");
-    } catch (err) {
-      logger.warn("Resource share infrastructure unavailable", {
-        error: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    // Connect all enabled channel installations
-    if (channelDeps && process.env.CHANNELS_ENABLED !== "false") {
-      const { connectAllChannels } = await import("@axiom-lattice/core");
-      try {
-        await connectAllChannels(
-          (channel) => adapterRegistry.get(channel),
-          { deps: { router: channelDeps.router } },
-        );
-      } catch (err) {
-        logger.error("Failed to start channel connections", {
-          error: err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-
-    const target_port = config?.port || Number(process.env.PORT) || 4001;
-
-    await app.listen({ port: target_port, host: "0.0.0.0" });
-    logger.info(`Lattice Gateway is running on port: ${target_port}`);
-
-    // Configure queue service
-    const queueServiceConfig = config?.queueServiceConfig;
-    if (queueServiceConfig) {
-      setQueueServiceType(queueServiceConfig.type);
-      if (queueServiceConfig.defaultStartPollingQueue) {
-        const agentTaskConsumer = new AgentTaskConsumer(target_port);
-        agentTaskConsumer.startPollingQueue();
-      }
-    }
-
-    // Restore agent instances with pending messages (fire-and-forget to avoid blocking startup)
-    // Temporarily disabled: do not auto-consume pending messages on startup.
-    if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
-      agentInstanceManager.restore()
-        .then((stats) => {
-          logger.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
-        })
-        .catch((error) => {
-          logger.error("Agent recovery failed", { error });
-        });
-    }
-
-    // Restore MCP server connections that were connected before shutdown
-    restoreMcpConnections().catch((error) => {
-      logger.error("MCP connection restoration failed", { error });
-    });
-  } catch (err) {
-    logger.error("Server start failed", { error: err });
-    process.exit(1);
-  }
-};
-
-const LatticeGateway = {
-  startAsHttpEndpoint: start,
-  configureSwagger,
-  registerLatticeRoutes,
-  app,
-  AgentTaskConsumer,
-};
-
-export { LatticeGateway };