@axiom-lattice/gateway 2.1.112 → 2.1.113

package/src/export_registrations/menu.registration.ts

@@ -0,0 +1,91 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { MenuRegistry } from '@axiom-lattice/protocols';
+
+function getStore(): MenuRegistry {
+  return getStoreLattice('default', 'menu').store as unknown as MenuRegistry;
+}
+
+export const menuRegistration: ExportableEntityDefinition = {
+  entityType: 'menu',
+  label: 'Menu(菜单)',
+  category: 'core',
+  dependsOn: ['agent'],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const menus = await store.list({ tenantId });
+    return menus.map((m) => ({
+      _exportId: '',
+      data: {
+        id: m.id,
+        menuTarget: m.menuTarget,
+        group: m.group,
+        name: m.name,
+        icon: m.icon,
+        sortOrder: m.sortOrder,
+        contentType: m.contentType,
+        contentConfig: m.contentConfig,
+        enabled: m.enabled,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.list({ tenantId });
+    const existingIds = new Set(existing.map((m) => m.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: 'menu',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (d.name as string) || id,
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'menu',
+          name: (d.name as string) || id,
+        });
+      }
+    }
+
+    return { conflicts, insertions, errors: [] };
+  },
+
+  async applyImport(tenantId, entity, resolution) {
+    const store = getStore();
+    const d = entity.data as Record<string, unknown>;
+    const id = resolution.action === 'rename' && resolution.newId ? resolution.newId : d.id as string;
+
+    if (resolution.action === 'overwrite') {
+      try { await store.delete(id); } catch { /* may not exist */ }
+    }
+
+    await store.create({
+      tenantId,
+      menuTarget: d.menuTarget as 'sidebar' | 'workspace',
+      group: d.group as string | undefined,
+      name: d.name as string,
+      icon: d.icon as string | undefined,
+      sortOrder: d.sortOrder as number | undefined,
+      contentType: d.contentType as 'agent' | 'html' | 'custom',
+      contentConfig: d.contentConfig as any,
+    });
+
+    return { newId: undefined };
+  },
+};

package/src/export_registrations/metrics-config.registration.ts

@@ -0,0 +1,94 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { MetricsServerConfigStore } from '@axiom-lattice/protocols';
+
+function getStore(): MetricsServerConfigStore {
+  return getStoreLattice('default', 'metrics').store as unknown as MetricsServerConfigStore;
+}
+
+export const metricsConfigRegistration: ExportableEntityDefinition = {
+  entityType: 'metrics_config',
+  label: 'Metrics Config(指标配置)',
+  category: 'core',
+  dependsOn: [],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const configs = await store.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: '',
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+
+    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;
+      const key = d.key as string;
+
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'metrics_config',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (d.name as string) || key,
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'metrics_config',
+          conflictType: 'unique_constraint',
+          existingName: (d.name as string) || key,
+          field: 'key',
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'metrics_config',
+          name: (d.name as string) || key,
+        });
+      }
+    }
+
+    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.deleteConfig(tenantId, id); } catch { /* may not exist */ }
+    }
+
+    await store.createConfig(tenantId, id, {
+      key: data.key as string,
+      name: data.name as string | undefined,
+      description: data.description as string | undefined,
+      config: data.config as any,
+    });
+
+    return { newId: id };
+  },
+};

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,6 +8,7 @@ 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";
@@ -399,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) {

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,
@@ -575,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,
+  );
 };