@axiom-lattice/gateway 2.1.111 → 2.1.113

package/src/export_registrations/skill.registration.ts

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -8,14 +8,16 @@ 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 } from "@axiom-lattice/core";
+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,
@@ -387,6 +389,8 @@ const start = async (config?: LatticeGatewayConfig) => {
       });
     }
 
+    setEvalRunService(evalRunner);
+
     // Initialize MenuRegistry for custom menu items
     try {
       const menuStore = getStoreLattice("default", "menu").store;
@@ -396,6 +400,9 @@ const start = async (config?: LatticeGatewayConfig) => {
       // 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) {
@@ -466,13 +473,16 @@ const start = async (config?: LatticeGatewayConfig) => {
     }
 
     // Restore agent instances with pending messages (fire-and-forget to avoid blocking startup)
-    agentInstanceManager.restore()
-      .then((stats) => {
-        logger.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
-      })
-      .catch((error) => {
-        logger.error("Agent recovery failed", { error });
-      });
+    // 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) => {

package/src/routes/index.ts

@@ -19,6 +19,7 @@ import * as dataQueryController from "../controllers/data-query";
 import * as workflowTrackingController from "../controllers/workflow-tracking";
 import * as paController from "../controllers/personal-assistant";
 import * as tasksController from "../controllers/tasks";
+import * as exportImportController from "../controllers/export-import";
 import { middlewareTypesRoutes } from "../controllers/middleware-types";
 import {
   createRunSchema,
@@ -510,7 +511,9 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
     workflowTrackingController.getAllWorkflowRuns
   );
 
-  app.get(
+  app.get<{
+    Querystring: { page?: string; pageSize?: string };
+  }>(
     "/api/workflows/inbox",
     workflowTrackingController.getInboxItems
   );
@@ -546,6 +549,11 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
     Params: { runId: string };
   }>("/api/workflows/runs/:runId/tasks", workflowTrackingController.getRunTasks);
 
+  // Abort a running workflow — stops graph + all sub-agents
+  app.post<{
+    Params: { runId: string };
+  }>("/api/workflows/runs/:runId/abort", workflowTrackingController.abortWorkflowRun);
+
   // 简化的 Inbox 任务回复接口（后台 streaming 执行，立即返回）
   app.post<{
     Body: { runId: string; answers: Array<{ questionIndex: number; selectedOptions: string[] }> };
@@ -568,4 +576,37 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
     "/api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id",
     removePendingMessageHandler
   );
+
+  // Export/Import endpoints
+  app.get("/api/tenants/exportable-types", exportImportController.getExportableTypes);
+
+  app.post<{ Params: { tenantId: string }; Body: { entityTypes: string[]; entityIds?: Record<string, string[]> } }>(
+    "/api/tenants/:tenantId/export",
+    exportImportController.exportConfig,
+  );
+
+  app.post<{ Params: { tenantId: string }; Body: { entityTypes: string[]; entityIds?: Record<string, string[]> } }>(
+    "/api/tenants/:tenantId/export/confirm",
+    exportImportController.exportConfigConfirm,
+  );
+
+  app.post<{ Params: { tenantId: string }; Body: { entityTypes: string[] } }>(
+    "/api/tenants/:tenantId/export/entities",
+    exportImportController.previewEntities,
+  );
+
+  app.get<{ Params: { tenantId: string; jobId: string } }>(
+    "/api/tenants/:tenantId/export/:jobId/download",
+    exportImportController.downloadExport,
+  );
+
+  app.post<{ Params: { tenantId: string }; Body: { bundle: any } }>(
+    "/api/tenants/:tenantId/import/preview",
+    exportImportController.importPreview,
+  );
+
+  app.post<{ Params: { tenantId: string }; Body: { bundle: any; resolutions: Record<string, any> } }>(
+    "/api/tenants/:tenantId/import/apply",
+    exportImportController.importApply,
+  );
 };

package/src/services/ExportImportService.ts

@@ -0,0 +1,296 @@
+/**
+ * Core orchestration service for tenant configuration export and import.
+ *
+ * @module @axiom-lattice/gateway/services/ExportImportService
+ */
+
+import { ExportableEntityRegistry, DependencyResolver, IdRemapper } from '@axiom-lattice/core';
+import type {
+  ExportBundle,
+  ExportableEntity,
+  ImportPreviewResult,
+  Resolution,
+  ImportApplyResult,
+  ImportEntityResult,
+} from '@axiom-lattice/core';
+import { randomUUID } from 'crypto';
+
+interface JobEntry {
+  bundle: ExportBundle;
+  tenantId: string;
+  createdAt: number;
+}
+
+/** Ephemeral in-memory job store (jobs expire after TTL). */
+const exportJobs = new Map<string, JobEntry>();
+
+/** TTL: 1 hour */
+const JOB_TTL_MS = 60 * 60 * 1000;
+
+function cleanExpiredJobs(): void {
+  const now = Date.now();
+  for (const [id, entry] of exportJobs) {
+    if (now - entry.createdAt > JOB_TTL_MS) {
+      exportJobs.delete(id);
+    }
+  }
+}
+
+export class ExportImportService {
+  private registry = ExportableEntityRegistry.getInstance();
+
+  /**
+   * Preview an export: check which types would be auto-included, which dependencies are missing.
+   */
+  async exportPreview(
+    tenantId: string,
+    selectedTypes: string[],
+  ): Promise<{ missingDependencies: string[]; cascadeAdditions: string[] }> {
+    const allDefs = this.registry.getAll();
+
+    const expanded = DependencyResolver.expandCascade(allDefs, selectedTypes);
+    const cascadeAdditions = expanded.filter((t) => !selectedTypes.includes(t));
+
+    const deps = DependencyResolver.computeDependencies(allDefs, expanded);
+    const registeredTypes = new Set(allDefs.map((d) => d.entityType));
+    const missingDependencies = deps.missing.filter((t) => registeredTypes.has(t));
+
+    return { missingDependencies, cascadeAdditions };
+  }
+
+  /**
+   * Generate a full ExportBundle for the given tenant and entity types.
+   * Stores the bundle in-memory and returns a jobId for download.
+   */
+  async export(
+    tenantId: string,
+    entityTypes: string[],
+    entityIds?: Record<string, string[]>,
+  ): Promise<{ jobId: string; bundle: ExportBundle }> {
+    const allDefs = this.registry.getAll();
+    const expanded = DependencyResolver.expandCascade(allDefs, entityTypes);
+    const finalTypes = [...new Set([...expanded, ...entityTypes])];
+
+    const dependencyOrder = DependencyResolver.resolveOrder(
+      finalTypes.map((t) => this.registry.get(t)),
+    );
+
+    const entities: Record<string, ExportableEntity[]> = {};
+    let exportCounter = 0;
+
+    for (const type of dependencyOrder) {
+      const def = this.registry.get(type);
+      let raw = await def.listForExport(tenantId);
+
+      if (entityIds && entityIds[type] && entityIds[type].length > 0) {
+        const idSet = new Set(entityIds[type]);
+        raw = raw.filter((e) => idSet.has(e.data.id as string));
+      }
+
+      entities[type] = raw.map((e) => ({
+        ...e,
+        _exportId: `exp-${type}-${String(++exportCounter).padStart(3, '0')}`,
+        data: this.sanitizeEntityData(e.data),
+      }));
+    }
+
+    // Build reverse map: raw entity ID → _exportId
+    const rawIdToExportId = new Map<string, string>();
+    for (const [, entityList] of Object.entries(entities)) {
+      for (const entity of entityList) {
+        const rawId = entity.data.id as string;
+        if (rawId) {
+          rawIdToExportId.set(rawId, entity._exportId);
+        }
+      }
+    }
+
+    // Rewrite reference fields to @type/exportId format
+    for (const [type, entityList] of Object.entries(entities)) {
+      const def = this.registry.get(type);
+      const refFields = def.referenceFields || {};
+      for (const entity of entityList) {
+        for (const [fieldName, refEntityType] of Object.entries(refFields)) {
+          const rawValue = entity.data[fieldName];
+          if (typeof rawValue === 'string' && rawValue) {
+            const exportId = rawIdToExportId.get(rawValue);
+            if (exportId) {
+              entity.data[fieldName] = `@${refEntityType}/${exportId}`;
+            }
+          }
+        }
+      }
+    }
+
+    const bundle: ExportBundle = {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      sourceTenantId: tenantId,
+      entities,
+      dependencyOrder,
+      _warning: 'This file contains plaintext secrets (passwords, API keys, tokens). Store it securely and delete after import.',
+    };
+
+    const jobId = randomUUID();
+    exportJobs.set(jobId, { bundle, tenantId, createdAt: Date.now() });
+
+    return { jobId, bundle };
+  }
+
+  /**
+   * Retrieve a previously generated export bundle by jobId with tenant validation.
+   */
+  getExportJob(jobId: string, tenantId: string): ExportBundle | undefined {
+    cleanExpiredJobs();
+    const entry = exportJobs.get(jobId);
+    if (!entry || entry.tenantId !== tenantId) return undefined;
+    return entry.bundle;
+  }
+
+  /**
+   * Preview import: validate bundle and detect conflicts.
+   */
+  async previewImport(
+    tenantId: string,
+    bundle: ExportBundle,
+  ): Promise<ImportPreviewResult> {
+    this.validateBundle(bundle);
+
+    const allConflicts: ImportPreviewResult['conflicts'] = [];
+    const allInsertions: ImportPreviewResult['insertions'] = [];
+    const allErrors: ImportPreviewResult['errors'] = [];
+
+    for (const [entityType, entities] of Object.entries(bundle.entities)) {
+      if (entities.length === 0) continue;
+
+      try {
+        const def = this.registry.get(entityType);
+        const result = await def.previewImport(tenantId, entities);
+
+        allConflicts.push(...result.conflicts);
+        allInsertions.push(...result.insertions);
+        allErrors.push(...result.errors);
+      } catch (err) {
+        for (const entity of entities) {
+          allErrors.push({
+            _exportId: entity._exportId,
+            entityType,
+            error: `Preview failed: ${(err as Error).message}`,
+          });
+        }
+      }
+    }
+
+    return { conflicts: allConflicts, insertions: allInsertions, errors: allErrors };
+  }
+
+  /**
+   * Apply import: create entities in dependency order with ID remapping.
+   */
+  async applyImport(
+    tenantId: string,
+    bundle: ExportBundle,
+    resolutions: Record<string, Resolution>,
+  ): Promise<ImportApplyResult> {
+    this.validateBundle(bundle);
+
+    const results: ImportEntityResult[] = [];
+    const idMap: Record<string, string> = {};
+    // Track skill old id → new id for agent graphDefinition implicit refs
+    const skillIdRemap: Record<string, string> = {};
+
+    for (const entityType of bundle.dependencyOrder) {
+      const entities = bundle.entities[entityType];
+      if (!entities || entities.length === 0) continue;
+
+      const def = this.registry.get(entityType);
+      const remapper = new IdRemapper(idMap);
+
+      for (const entity of entities) {
+        const resolution = resolutions[entity._exportId];
+
+        if (resolution?.action === 'skip') {
+          results.push({ _exportId: entity._exportId, entityType, status: 'skipped' });
+          continue;
+        }
+
+        try {
+          const remappedData = remapper.remapReferences(entity.data) as Record<string, unknown>;
+
+          // Remap implicit skill references in agent graphDefinition.skillIds
+          if (entityType === 'agent' && Object.keys(skillIdRemap).length > 0) {
+            const skillRemapper = new IdRemapper({});
+            remappedData.graphDefinition = skillRemapper.remapSkillIds(
+              (remappedData.graphDefinition as Record<string, unknown>) || {},
+              skillIdRemap,
+            );
+          }
+
+          if (resolution?.action === 'rename' && resolution.newId) {
+            remappedData.id = resolution.newId;
+          }
+
+          const entityWithRemappedData = { ...entity, data: remappedData };
+          const { newId } = await def.applyImport(
+            tenantId,
+            entityWithRemappedData,
+            resolution ?? { _exportId: entity._exportId, action: 'overwrite' },
+          );
+
+          if (newId) {
+            idMap[entity._exportId] = newId;
+            // Track skill ID renames for agent graphDefinition remapping
+            if (entityType === 'skill' && newId) {
+              const oldSkillId = remappedData.id as string;
+              if (oldSkillId !== newId) {
+                skillIdRemap[oldSkillId] = newId;
+              }
+            }
+            results.push({
+              _exportId: entity._exportId,
+              entityType,
+              status: resolution?.action === 'overwrite' ? 'updated' : 'created',
+              newId,
+            });
+          }
+        } catch (err) {
+          results.push({
+            _exportId: entity._exportId,
+            entityType,
+            status: 'failed',
+            error: (err as Error).message,
+          });
+        }
+      }
+    }
+
+    return { results, idMap };
+  }
+
+  /**
+   * List all registered exportable types (for frontend).
+   */
+  listExportableTypes() {
+    return this.registry.listTypes();
+  }
+
+  private validateBundle(bundle: ExportBundle): void {
+    if (bundle.version !== 1) {
+      throw new Error(`Unsupported bundle version: ${bundle.version}. Expected: 1`);
+    }
+    if (!bundle.entities || typeof bundle.entities !== 'object') {
+      throw new Error('Invalid bundle: missing entities');
+    }
+    if (!Array.isArray(bundle.dependencyOrder)) {
+      throw new Error('Invalid bundle: missing dependencyOrder');
+    }
+  }
+
+  private sanitizeEntityData(data: Record<string, unknown>): Record<string, unknown> {
+    const sanitized = { ...data };
+    delete sanitized.tenantId;
+    delete sanitized.createdAt;
+    delete sanitized.updatedAt;
+    return sanitized;
+  }
+}