@hexabot-ai/api 3.2.2-alpha.9 → 3.2.2-beta.1

package/src/transfer/adapters/credential-transfer.adapter.ts

@@ -0,0 +1,158 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  type WorkflowExportBundleCredential,
+  type WorkflowImportResourceResult,
+} from '@hexabot-ai/types';
+import { ConflictException, Injectable } from '@nestjs/common';
+import { In } from 'typeorm';
+
+import { CredentialOrmEntity } from '@/user/entities/credential.entity';
+import { CredentialService } from '@/user/services/credential.service';
+
+import {
+  WorkflowTransferAdapter,
+  WorkflowTransferExportContext,
+  WorkflowTransferImportContext,
+  WorkflowTransferResourceAdapter,
+} from '../workflow-transfer-resource-adapter';
+import {
+  assertFoundAll,
+  buildPostCreateEvent,
+  buildResourceResult,
+  PLACEHOLDER_CREDENTIAL_VALUE,
+  uniqueResourceIds,
+  type WorkflowTransferImportAdapterResult,
+} from '../workflow-transfer.types';
+
+@WorkflowTransferAdapter()
+@Injectable()
+export class CredentialTransferAdapter extends WorkflowTransferResourceAdapter {
+  override readonly kind = 'credential';
+
+  override readonly resourceKeys = ['credentials'];
+
+  constructor(private readonly credentialService: CredentialService) {
+    super();
+  }
+
+  override async buildExportResources(
+    ctx: WorkflowTransferExportContext,
+  ): Promise<Record<string, WorkflowExportBundleCredential[]>> {
+    return {
+      credentials: await this.buildCredentialExportResources(
+        ctx.getRefs(this.kind),
+      ),
+    };
+  }
+
+  private async buildCredentialExportResources(
+    ids: string[],
+  ): Promise<WorkflowExportBundleCredential[]> {
+    const uniqueIds = uniqueResourceIds(ids);
+    if (uniqueIds.length === 0) {
+      return [];
+    }
+
+    const credentials = await this.credentialService.find({
+      where: { id: In(uniqueIds) },
+    });
+    assertFoundAll(
+      'credential',
+      uniqueIds,
+      credentials.map((credential) => credential.id),
+    );
+
+    return credentials.map((credential) => ({
+      exportId: credential.id,
+      name: credential.name,
+      exportedOwnerId: credential.owner,
+    }));
+  }
+
+  override async importResources(
+    ctx: WorkflowTransferImportContext,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const credentials =
+      ctx.getResources<WorkflowExportBundleCredential>('credentials');
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const warnings: string[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+    const placeholderExportIds = new Set<string>();
+
+    for (const credential of credentials) {
+      const existingByName = await ctx.manager.findOne(CredentialOrmEntity, {
+        where: { name: credential.name },
+        relations: ['owner'],
+      });
+
+      if (existingByName) {
+        const existingOwnerId =
+          existingByName.owner && typeof existingByName.owner === 'object'
+            ? existingByName.owner.id
+            : null;
+        if (existingOwnerId !== ctx.ownerId) {
+          throw new ConflictException(
+            `Credential "${credential.name}" already exists for another user`,
+          );
+        }
+
+        idMap[credential.exportId] = existingByName.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'credential',
+            exportId: credential.exportId,
+            localId: existingByName.id,
+            name: credential.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      const payload = {
+        name: credential.name,
+        value: PLACEHOLDER_CREDENTIAL_VALUE,
+        owner: { id: ctx.ownerId },
+      };
+      const created = await ctx.manager.save(
+        CredentialOrmEntity,
+        ctx.manager.create(CredentialOrmEntity, payload),
+      );
+
+      idMap[credential.exportId] = created.id;
+      placeholderExportIds.add(credential.exportId);
+      resources.push(
+        buildResourceResult({
+          kind: 'credential',
+          exportId: credential.exportId,
+          localId: created.id,
+          name: credential.name,
+          action: 'placeholder_created',
+        }),
+      );
+      postCreateEvents.push(
+        buildPostCreateEvent('credential', created, payload),
+      );
+      warnings.push(
+        `Credential "${credential.name}" was imported as a placeholder and must be updated before use.`,
+      );
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings,
+      postCreateEvents,
+      metadata: {
+        placeholderExportIds,
+      },
+    };
+  }
+}

package/src/transfer/adapters/label-transfer.adapter.ts

@@ -0,0 +1,291 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  type WorkflowExportBundle,
+  type WorkflowExportBundleLabel,
+  type WorkflowExportBundleLabelGroup,
+  type WorkflowImportResourceResult,
+} from '@hexabot-ai/types';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+} from '@nestjs/common';
+import { EntityManager, In } from 'typeorm';
+
+import { LabelGroupOrmEntity } from '@/chat/entities/label-group.entity';
+import { LabelOrmEntity } from '@/chat/entities/label.entity';
+import { LabelService } from '@/chat/services/label.service';
+
+import {
+  WorkflowTransferAdapter,
+  WorkflowTransferExportContext,
+  WorkflowTransferImportContext,
+  WorkflowTransferResourceAdapter,
+} from '../workflow-transfer-resource-adapter';
+import {
+  assertFoundAll,
+  buildPostCreateEvent,
+  buildResourceResult,
+  uniqueResourceIds,
+  type WorkflowTransferImportAdapterResult,
+} from '../workflow-transfer.types';
+
+type LabelExportResources = {
+  labelGroups: WorkflowExportBundleLabelGroup[];
+  labels: WorkflowExportBundleLabel[];
+};
+
+@WorkflowTransferAdapter()
+@Injectable()
+export class LabelTransferAdapter extends WorkflowTransferResourceAdapter {
+  override readonly kind = 'label';
+
+  override readonly resourceKeys = ['labels', 'labelGroups'];
+
+  constructor(private readonly labelService: LabelService) {
+    super();
+  }
+
+  override async buildExportResources(
+    ctx: WorkflowTransferExportContext,
+  ): Promise<Record<string, unknown[]>> {
+    return this.buildLabelExportResources(ctx.getRefs(this.kind));
+  }
+
+  private async buildLabelExportResources(
+    ids: string[],
+  ): Promise<LabelExportResources> {
+    const uniqueIds = uniqueResourceIds(ids);
+    if (uniqueIds.length === 0) {
+      return { labelGroups: [], labels: [] };
+    }
+
+    const labels = await this.labelService.findAndPopulate({
+      where: { id: In(uniqueIds) },
+    });
+    assertFoundAll(
+      'label',
+      uniqueIds,
+      labels.map((label) => label.id),
+    );
+
+    const groupsById = new Map<string, WorkflowExportBundleLabelGroup>();
+    for (const label of labels) {
+      if (label.group?.id) {
+        groupsById.set(label.group.id, {
+          exportId: label.group.id,
+          name: label.group.name,
+        });
+      }
+    }
+
+    return {
+      labelGroups: Array.from(groupsById.values()),
+      labels: labels.map((label) => ({
+        exportId: label.id,
+        title: label.title,
+        name: label.name,
+        description: label.description ?? null,
+        groupExportId: label.group?.id ?? null,
+      })),
+    };
+  }
+
+  override async importResources(
+    ctx: WorkflowTransferImportContext,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const labelGroups =
+      ctx.getResources<
+        WorkflowExportBundle['resources']['labelGroups'][number]
+      >('labelGroups');
+    const labels =
+      ctx.getResources<WorkflowExportBundle['resources']['labels'][number]>(
+        'labels',
+      );
+    const groupResult = await this.importLabelGroups(ctx.manager, labelGroups);
+    const labelResult = await this.importLabels(
+      ctx.manager,
+      labels,
+      groupResult.idMap,
+    );
+
+    return {
+      idMap: labelResult.idMap,
+      resources: [...groupResult.resources, ...labelResult.resources],
+      warnings: [],
+      postCreateEvents: [
+        ...groupResult.postCreateEvents,
+        ...labelResult.postCreateEvents,
+      ],
+    };
+  }
+
+  private async importLabelGroups(
+    manager: EntityManager,
+    labelGroups: WorkflowExportBundle['resources']['labelGroups'],
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+
+    for (const labelGroup of labelGroups) {
+      const existing = await manager.findOne(LabelGroupOrmEntity, {
+        where: { name: labelGroup.name },
+      });
+
+      if (existing) {
+        idMap[labelGroup.exportId] = existing.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'labelGroup',
+            exportId: labelGroup.exportId,
+            localId: existing.id,
+            name: labelGroup.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      const payload = {
+        name: labelGroup.name,
+      };
+      const created = await manager.save(
+        LabelGroupOrmEntity,
+        manager.create(LabelGroupOrmEntity, payload),
+      );
+
+      idMap[labelGroup.exportId] = created.id;
+      resources.push(
+        buildResourceResult({
+          kind: 'labelGroup',
+          exportId: labelGroup.exportId,
+          localId: created.id,
+          name: labelGroup.name,
+          action: 'created',
+        }),
+      );
+      postCreateEvents.push(
+        buildPostCreateEvent('labelGroup', created, payload),
+      );
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings: [],
+      postCreateEvents,
+    };
+  }
+
+  private async importLabels(
+    manager: EntityManager,
+    labels: WorkflowExportBundle['resources']['labels'],
+    labelGroupIdMap: Record<string, string>,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+
+    for (const label of labels) {
+      const groupId = label.groupExportId
+        ? labelGroupIdMap[label.groupExportId]
+        : null;
+
+      if (label.groupExportId && !groupId) {
+        throw new BadRequestException(
+          `Workflow bundle is missing label group "${label.groupExportId}" required by label "${label.name}"`,
+        );
+      }
+
+      const existingByName = await manager.findOne(LabelOrmEntity, {
+        where: { name: label.name },
+        relations: ['group'],
+      });
+
+      if (existingByName) {
+        if (!this.isEquivalentLabel(existingByName, label, groupId)) {
+          throw new ConflictException(
+            `Label "${label.name}" already exists with different configuration`,
+          );
+        }
+
+        idMap[label.exportId] = existingByName.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'label',
+            exportId: label.exportId,
+            localId: existingByName.id,
+            name: label.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      const existingByTitle = await manager.findOne(LabelOrmEntity, {
+        where: { title: label.title },
+      });
+      if (existingByTitle) {
+        throw new ConflictException(
+          `Label title "${label.title}" already exists with a different name`,
+        );
+      }
+
+      const payload = {
+        title: label.title,
+        name: label.name,
+        description: label.description ?? null,
+        group: groupId ? { id: groupId } : null,
+        builtin: false,
+      };
+      const created = await manager.save(
+        LabelOrmEntity,
+        manager.create(LabelOrmEntity, payload),
+      );
+
+      idMap[label.exportId] = created.id;
+      resources.push(
+        buildResourceResult({
+          kind: 'label',
+          exportId: label.exportId,
+          localId: created.id,
+          name: label.name,
+          action: 'created',
+        }),
+      );
+      postCreateEvents.push(buildPostCreateEvent('label', created, payload));
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings: [],
+      postCreateEvents,
+    };
+  }
+
+  private isEquivalentLabel(
+    existing: LabelOrmEntity,
+    imported: WorkflowExportBundle['resources']['labels'][number],
+    importedGroupId: string | null,
+  ): boolean {
+    const existingGroupId =
+      existing.group && typeof existing.group === 'object'
+        ? existing.group.id
+        : null;
+
+    return (
+      existing.title === imported.title &&
+      (existing.description ?? null) === (imported.description ?? null) &&
+      existingGroupId === importedGroupId
+    );
+  }
+}

package/src/transfer/adapters/mcp-server-transfer.adapter.ts

@@ -0,0 +1,255 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { isDeepStrictEqual } from 'node:util';
+
+import {
+  type WorkflowExportBundle,
+  type WorkflowExportBundleMcpServer,
+  type WorkflowImportResourceResult,
+} from '@hexabot-ai/types';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+} from '@nestjs/common';
+import { In } from 'typeorm';
+
+import { CredentialOrmEntity } from '@/user/entities/credential.entity';
+import { McpServerOrmEntity } from '@/workflow/entities/mcp-server.entity';
+import { McpServerService } from '@/workflow/services/mcp-server.service';
+import { McpServerTransport } from '@/workflow/types';
+
+import {
+  WorkflowTransferAdapter,
+  WorkflowTransferExportContext,
+  WorkflowTransferImportContext,
+  WorkflowTransferResourceAdapter,
+} from '../workflow-transfer-resource-adapter';
+import {
+  assertFoundAll,
+  buildPostCreateEvent,
+  buildResourceResult,
+  uniqueResourceIds,
+  type WorkflowTransferImportAdapterResult,
+} from '../workflow-transfer.types';
+
+type McpServerExportResources = {
+  credentialIds: string[];
+  mcpServers: WorkflowExportBundleMcpServer[];
+};
+
+@WorkflowTransferAdapter()
+@Injectable()
+export class McpServerTransferAdapter extends WorkflowTransferResourceAdapter {
+  override readonly kind = 'mcpServer';
+
+  override readonly resourceKeys = ['mcpServers'];
+
+  override readonly dependsOn = ['credential'];
+
+  constructor(private readonly mcpServerService: McpServerService) {
+    super();
+  }
+
+  override async buildExportResources(
+    ctx: WorkflowTransferExportContext,
+  ): Promise<Record<string, WorkflowExportBundleMcpServer[]>> {
+    const resources = await this.buildMcpServerExportResources(
+      ctx.getRefs(this.kind),
+    );
+    ctx.addResourceRefs('credential', resources.credentialIds);
+
+    return {
+      mcpServers: resources.mcpServers,
+    };
+  }
+
+  private async buildMcpServerExportResources(
+    ids: string[],
+  ): Promise<McpServerExportResources> {
+    const uniqueIds = uniqueResourceIds(ids);
+    if (uniqueIds.length === 0) {
+      return { credentialIds: [], mcpServers: [] };
+    }
+
+    const servers = await this.mcpServerService.findAndPopulate({
+      where: { id: In(uniqueIds) },
+    });
+    assertFoundAll(
+      'MCP server',
+      uniqueIds,
+      servers.map((server) => server.id),
+    );
+
+    return {
+      credentialIds: servers
+        .map((server) => server.credential?.id)
+        .filter((id): id is string => typeof id === 'string' && !!id),
+      mcpServers: servers.map((server) => ({
+        exportId: server.id,
+        name: server.name,
+        enabled: server.enabled,
+        transport: server.transport,
+        url: server.url ?? null,
+        command: server.command ?? null,
+        args: server.args ?? null,
+        cwd: server.cwd ?? null,
+        credentialExportId: server.credential?.id ?? null,
+      })),
+    };
+  }
+
+  override async importResources(
+    ctx: WorkflowTransferImportContext,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const servers =
+      ctx.getResources<WorkflowExportBundle['resources']['mcpServers'][number]>(
+        'mcpServers',
+      );
+    const credentialIdMap = ctx.getIdMap('credential');
+    const placeholderCredentialExportIds =
+      this.getPlaceholderCredentialExportIds(ctx);
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const warnings: string[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+
+    for (const server of servers) {
+      const credentialId = server.credentialExportId
+        ? credentialIdMap[server.credentialExportId]
+        : null;
+      const credential = credentialId
+        ? await ctx.manager.findOne(CredentialOrmEntity, {
+            where: { id: credentialId },
+          })
+        : null;
+      const importedCredential = server.credentialExportId
+        ? credentialId
+          ? credential
+          : null
+        : null;
+      const shouldDisable =
+        Boolean(server.credentialExportId) &&
+        placeholderCredentialExportIds.has(server.credentialExportId!);
+      const existing = await ctx.manager.findOne(McpServerOrmEntity, {
+        where: { name: server.name },
+        relations: ['credential'],
+      });
+
+      if (existing) {
+        if (!this.isEquivalentMcpServer(existing, server, importedCredential)) {
+          throw new ConflictException(
+            `MCP server "${server.name}" already exists with different configuration`,
+          );
+        }
+
+        idMap[server.exportId] = existing.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'mcpServer',
+            exportId: server.exportId,
+            localId: existing.id,
+            name: server.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      if (server.credentialExportId && !credentialId) {
+        throw new BadRequestException(
+          `Workflow bundle is missing credential "${server.credentialExportId}" required by MCP server "${server.name}"`,
+        );
+      }
+
+      const payload = {
+        name: server.name,
+        enabled: shouldDisable ? false : server.enabled,
+        transport: server.transport,
+        url: server.url,
+        command: server.command,
+        args: server.args,
+        cwd: server.cwd,
+        credential:
+          credentialId && server.transport === McpServerTransport.http
+            ? { id: credentialId }
+            : null,
+      };
+      const created = await ctx.manager.save(
+        McpServerOrmEntity,
+        ctx.manager.create(McpServerOrmEntity, payload),
+      );
+
+      idMap[server.exportId] = created.id;
+      resources.push(
+        buildResourceResult({
+          kind: 'mcpServer',
+          exportId: server.exportId,
+          localId: created.id,
+          name: server.name,
+          action: 'created',
+        }),
+      );
+      postCreateEvents.push(
+        buildPostCreateEvent('mcpServer', created, payload),
+      );
+
+      if (shouldDisable) {
+        warnings.push(
+          `MCP server "${server.name}" was disabled because it depends on an imported placeholder credential.`,
+        );
+      }
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings,
+      postCreateEvents,
+    };
+  }
+
+  private getPlaceholderCredentialExportIds(
+    ctx: WorkflowTransferImportContext,
+  ): Set<string> {
+    const placeholderExportIds =
+      ctx.getDependencyResult('credential')?.metadata?.placeholderExportIds;
+    if (placeholderExportIds instanceof Set) {
+      return placeholderExportIds as Set<string>;
+    }
+
+    return Array.isArray(placeholderExportIds)
+      ? new Set(
+          placeholderExportIds.filter(
+            (id): id is string => typeof id === 'string',
+          ),
+        )
+      : new Set<string>();
+  }
+
+  private isEquivalentMcpServer(
+    existing: McpServerOrmEntity,
+    imported: WorkflowExportBundleMcpServer,
+    importedCredential: CredentialOrmEntity | null,
+  ): boolean {
+    const existingCredentialName =
+      existing.credential && typeof existing.credential === 'object'
+        ? existing.credential.name
+        : null;
+    const importedCredentialName = importedCredential?.name ?? null;
+
+    return (
+      existing.transport === imported.transport &&
+      (existing.url ?? null) === (imported.url ?? null) &&
+      (existing.command ?? null) === (imported.command ?? null) &&
+      isDeepStrictEqual(existing.args ?? null, imported.args ?? null) &&
+      (existing.cwd ?? null) === (imported.cwd ?? null) &&
+      existingCredentialName === importedCredentialName
+    );
+  }
+}