@hexabot-ai/types 3.0.2-alpha.9 → 3.0.2-beta.1

package/src/index.test.ts

@@ -31,6 +31,7 @@ import {
   IncomingMessageType,
   labelFullSchema,
   labelSchema,
+  mcpTokenSchema,
   mcpServerFullSchema,
   mcpServerSchema,
   memoryRecordFullSchema,
@@ -56,6 +57,9 @@ import {
   userFullSchema,
   userSchema,
   workflowFullSchema,
+  workflowExportBundleSchema,
+  workflowExportBundleV1Schema,
+  workflowImportResultSchema,
   workflowRunFullSchema,
   workflowRunSchema,
   workflowVersionFullSchema,
@@ -682,6 +686,25 @@ describe("@hexabot-ai/types schemas", () => {
     expect("value" in credential).toBe(false);
   });
 
+  it("keeps MCP token outputs free of token hashes", () => {
+    const token = mcpTokenSchema.parse({
+      id: "mt_1",
+      createdAt: now,
+      updatedAt: now,
+      name: "Codex",
+      tokenPrefix: "hbt_mcp_abcd",
+      tokenHash: "secret-hash",
+      ownerId: "u_1",
+      expiresAt: null,
+      lastUsedAt: null,
+      revokedAt: null,
+    });
+
+    expect(token.name).toBe("Codex");
+    expect(token.owner).toBe("u_1");
+    expect("tokenHash" in token).toBe(false);
+  });
+
   it("computes workflow derived fields via parser bridge", () => {
     const parser = jest.fn((yml: string) => ({
       defs: {},
@@ -757,6 +780,300 @@ describe("@hexabot-ai/types schemas", () => {
     expect(parser).toHaveBeenCalledTimes(1);
   });
 
+  it("parses workflow export bundles without credential secrets", () => {
+    const bundle = workflowExportBundleSchema.parse({
+      kind: "hexabot.workflow.bundle",
+      schemaVersion: 1,
+      exportedAt: now,
+      workflow: {
+        exportId: "wf_1",
+        name: "Main",
+        description: null,
+        type: WorkflowType.conversational,
+        schedule: null,
+        inputSchema: {},
+        layout: {
+          x: 0,
+          y: 0,
+          zoom: 1,
+          direction: "horizontal",
+        },
+      },
+      version: {
+        number: 3,
+        checksum: "sha",
+        message: null,
+        exportedVersionId: "wfv_1",
+      },
+      definitionYml: "defs: {}\nflow: []\noutputs: {}",
+      resources: {
+        memoryDefinitions: [
+          {
+            exportId: "mem_1",
+            name: "Profile",
+            slug: "profile",
+            scope: MemoryScope.workflow,
+            schema: { type: "object" },
+            ttlSeconds: null,
+          },
+        ],
+        mcpServers: [
+          {
+            exportId: "mcp_1",
+            name: "Search",
+            enabled: true,
+            transport: McpServerTransport.http,
+            url: "https://mcp.example.com",
+            command: null,
+            args: null,
+            cwd: null,
+            credentialExportId: "cred_1",
+          },
+        ],
+        credentials: [
+          {
+            exportId: "cred_1",
+            name: "Search API",
+            exportedOwnerId: "u_1",
+          },
+        ],
+        contentTypes: [
+          {
+            exportId: "ct_1",
+            name: "Article",
+            schema: { type: "object" },
+          },
+        ],
+        labelGroups: [
+          {
+            exportId: "lg_1",
+            name: "Status",
+          },
+        ],
+        labels: [
+          {
+            exportId: "label_1",
+            title: "Qualified",
+            name: "QUALIFIED",
+            description: null,
+            groupExportId: "lg_1",
+          },
+        ],
+        workflows: [
+          {
+            exportId: "wf_child",
+            workflow: {
+              name: "Child",
+              description: "Called child workflow",
+              type: WorkflowType.conversational,
+              schedule: null,
+              inputSchema: {},
+              layout: {
+                x: 10,
+                y: 20,
+                zoom: 1,
+                direction: "horizontal",
+              },
+            },
+            version: {
+              number: 2,
+              checksum: "child-sha",
+              message: "Child version",
+              exportedVersionId: "wfv_child",
+            },
+            definitionYml: "defs: {}\nflow: []\noutputs: {}",
+          },
+        ],
+        knowledgeBases: [
+          {
+            exportId: "kb_1",
+            name: "Docs",
+            config: { index: "docs" },
+          },
+        ],
+      },
+    });
+
+    expect(bundle.resources.credentials[0]).toEqual({
+      exportId: "cred_1",
+      name: "Search API",
+      exportedOwnerId: "u_1",
+    });
+    expect(bundle.workflow.exportId).toBe("wf_1");
+    expect(bundle.resources.contentTypes[0]?.name).toBe("Article");
+    expect(bundle.resources.labelGroups[0]?.name).toBe("Status");
+    expect(bundle.resources.labels[0]).toMatchObject({
+      exportId: "label_1",
+      groupExportId: "lg_1",
+    });
+    expect(bundle.resources.workflows[0]).toMatchObject({
+      exportId: "wf_child",
+      workflow: { name: "Child" },
+      version: { exportedVersionId: "wfv_child" },
+    });
+    expect(bundle.resources.knowledgeBases).toEqual([
+      {
+        exportId: "kb_1",
+        name: "Docs",
+        config: { index: "docs" },
+      },
+    ]);
+  });
+
+  it("defaults new workflow bundle resource arrays for older bundles", () => {
+    const bundle = workflowExportBundleSchema.parse({
+      kind: "hexabot.workflow.bundle",
+      schemaVersion: 1,
+      exportedAt: now,
+      workflow: {
+        name: "Main",
+        description: null,
+        type: WorkflowType.conversational,
+        schedule: null,
+        inputSchema: {},
+        layout: {
+          x: 0,
+          y: 0,
+          zoom: 1,
+          direction: "horizontal",
+        },
+      },
+      version: {
+        number: 1,
+        checksum: "sha",
+        message: null,
+        exportedVersionId: "wfv_1",
+      },
+      definitionYml: "defs: {}\nflow: []\noutputs: {}",
+      resources: {
+        memoryDefinitions: [],
+        mcpServers: [],
+        credentials: [],
+      },
+    });
+
+    expect(bundle.resources.contentTypes).toEqual([]);
+    expect(bundle.resources.labelGroups).toEqual([]);
+    expect(bundle.resources.labels).toEqual([]);
+    expect(bundle.resources.workflows).toEqual([]);
+  });
+
+  it("rejects non-array custom workflow bundle resource buckets", () => {
+    expect(() =>
+      workflowExportBundleV1Schema.parse({
+        kind: "hexabot.workflow.bundle",
+        schemaVersion: 1,
+        exportedAt: now,
+        workflow: {
+          name: "Main",
+          description: null,
+          type: WorkflowType.conversational,
+          schedule: null,
+          inputSchema: {},
+          layout: {
+            x: 0,
+            y: 0,
+            zoom: 1,
+            direction: "horizontal",
+          },
+        },
+        version: {
+          number: 1,
+          checksum: "sha",
+          message: null,
+          exportedVersionId: "wfv_1",
+        },
+        definitionYml: "defs: {}\nflow: []\noutputs: {}",
+        resources: {
+          memoryDefinitions: [],
+          mcpServers: [],
+          credentials: [],
+          knowledgeBases: {
+            exportId: "kb_1",
+          },
+        },
+      }),
+    ).toThrow();
+  });
+
+  it("rejects credential values in workflow export bundles", () => {
+    expect(() =>
+      workflowExportBundleV1Schema.parse({
+        kind: "hexabot.workflow.bundle",
+        schemaVersion: 1,
+        exportedAt: now,
+        workflow: {
+          name: "Main",
+          description: null,
+          type: WorkflowType.conversational,
+          schedule: null,
+          inputSchema: {},
+          layout: {
+            x: 0,
+            y: 0,
+            zoom: 1,
+            direction: "horizontal",
+          },
+        },
+        version: {
+          number: 1,
+          checksum: "sha",
+          message: null,
+          exportedVersionId: "wfv_1",
+        },
+        definitionYml: "defs: {}\nflow: []\noutputs: {}",
+        resources: {
+          memoryDefinitions: [],
+          mcpServers: [],
+          credentials: [
+            {
+              exportId: "cred_1",
+              name: "Search API",
+              value: "secret",
+            },
+          ],
+        },
+      }),
+    ).toThrow();
+  });
+
+  it("parses workflow import results", () => {
+    const result = workflowImportResultSchema.parse({
+      workflow: {
+        id: "wf_1",
+        createdAt: now,
+        updatedAt: now,
+        name: "Imported",
+        description: null,
+        type: WorkflowType.conversational,
+        schedule: null,
+        inputSchema: {},
+        builtin: false,
+        x: 0,
+        y: 0,
+        zoom: 1,
+        direction: "horizontal",
+        currentVersion: "wfv_1",
+        publishedVersion: null,
+        createdBy: "u_1",
+        runAfterMs: 0,
+      },
+      resources: [
+        {
+          kind: "knowledgeBase",
+          exportId: "kb_1",
+          localId: "kb_local",
+          name: "Docs",
+          action: "reused",
+        },
+      ],
+      warnings: ["Credential placeholder created."],
+    });
+
+    expect(result.resources[0]?.action).toBe("reused");
+    expect(result.resources[0]?.kind).toBe("knowledgeBase");
+  });
+
   it("computes workflow run duration and mixed triggeredBy coercion", () => {
     const run = workflowRunSchema.parse({
       id: "run_1",
@@ -768,6 +1085,7 @@ describe("@hexabot-ai/types schemas", () => {
       workflowVersionId: "wfv_1",
       triggeredById: "s_1",
       threadId: "t_1",
+      parentRun: "parent_run_1",
       finishedAt: "2026-01-01T00:02:00.000Z",
     });
     const full = workflowRunFullSchema.parse({
@@ -817,10 +1135,23 @@ describe("@hexabot-ai/types schemas", () => {
         avatar: null,
       },
       thread: null,
+      parentRun: {
+        id: "parent_run_1",
+        createdAt: now,
+        updatedAt: now,
+        status: "suspended",
+        context: {},
+        workflowId: "parent_wf_1",
+        workflowVersionId: null,
+        triggeredById: null,
+        parentRun: null,
+      },
     });
 
     expect(run.duration).toBe(120000);
+    expect(run.parentRun).toBe("parent_run_1");
     expect(full.triggeredBy?.id).toBe("s_1");
+    expect(full.parentRun?.workflow).toBe("parent_wf_1");
     expect(typeof resolveRunDurationMs(run)).toBe("number");
   });
 

package/src/user/index.ts

@@ -76,3 +76,12 @@ export {
   type CredentialFull,
   type CredentialStub,
 } from "./credential";
+
+export {
+  mcpTokenFullSchema,
+  mcpTokenSchema,
+  mcpTokenStubSchema,
+  type McpToken,
+  type McpTokenFull,
+  type McpTokenStub,
+} from "./mcp-token";

package/src/user/mcp-token.ts

@@ -0,0 +1,53 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+
+import { userSchema } from "./user";
+
+const nullableDateSchema = preprocess(
+  (value) => (value == null ? null : value),
+  z.coerce.date().nullable(),
+);
+const mcpTokenAliasMap = {
+  ownerId: "owner",
+} as const;
+const mcpTokenStubObjectSchema = baseStubSchema.extend({
+  name: z.string(),
+  tokenPrefix: z.string(),
+  expiresAt: nullableDateSchema,
+  lastUsedAt: nullableDateSchema,
+  revokedAt: nullableDateSchema,
+});
+
+export const mcpTokenStubSchema = mcpTokenStubObjectSchema;
+
+export const mcpTokenSchema = preprocess(
+  (value) => withAliases(value, mcpTokenAliasMap),
+  mcpTokenStubObjectSchema.extend({
+    owner: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+  }),
+);
+
+export const mcpTokenFullSchema = mcpTokenStubObjectSchema.extend({
+  owner: preprocess(
+    (value) => (value == null ? null : value),
+    z.lazy(() => userSchema).nullable(),
+  ),
+});
+
+export type McpTokenStub = z.infer<typeof mcpTokenStubSchema>;
+
+export type McpToken = z.infer<typeof mcpTokenSchema>;
+
+export type McpTokenFull = z.infer<typeof mcpTokenFullSchema>;

package/src/workflow/index.ts

@@ -68,3 +68,33 @@ export {
   type McpServerFull,
   type McpServerStub,
 } from "./mcp-server";
+
+export {
+  WORKFLOW_EXPORT_BUNDLE_KIND,
+  WORKFLOW_TRANSFER_RESOURCE_KIND_PATTERN,
+  workflowExportBundleContentTypeSchema,
+  workflowExportBundleCredentialSchema,
+  workflowExportBundleLabelGroupSchema,
+  workflowExportBundleLabelSchema,
+  workflowExportBundleMcpServerSchema,
+  workflowExportBundleMemoryDefinitionSchema,
+  workflowExportBundleSchema,
+  workflowExportBundleV1Schema,
+  workflowExportBundleWorkflowDependencySchema,
+  workflowImportResourceActionSchema,
+  workflowImportResourceResultSchema,
+  workflowImportResultSchema,
+  workflowTransferResourceKindSchema,
+  type WorkflowExportBundle,
+  type WorkflowExportBundleContentType,
+  type WorkflowExportBundleCredential,
+  type WorkflowExportBundleLabel,
+  type WorkflowExportBundleLabelGroup,
+  type WorkflowExportBundleMcpServer,
+  type WorkflowExportBundleMemoryDefinition,
+  type WorkflowExportBundleV1,
+  type WorkflowExportBundleWorkflowDependency,
+  type WorkflowImportResourceAction,
+  type WorkflowImportResourceResult,
+  type WorkflowImportResult,
+} from "./workflow-transfer";

package/src/workflow/workflow-run.ts

@@ -68,6 +68,7 @@ const workflowRunAliasMap = {
   workflowVersionId: "workflowVersion",
   triggeredById: "triggeredBy",
   threadId: "thread",
+  parentRunId: "parentRun",
 } as const;
 const workflowRunStubObjectSchema = baseStubSchema.extend({
   status: workflowRunStatusSchema,
@@ -133,6 +134,10 @@ export const workflowRunSchema = preprocess(
       (value) => (value == null ? null : asId(value)),
       z.string().nullable(),
     ),
+    parentRun: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
   }),
 );
 
@@ -146,6 +151,10 @@ export const workflowRunFullSchema = preprocess(
       .optional(),
     triggeredBy: nullableUserOrSubscriberSchema,
     thread: threadSchema.nullable().optional(),
+    parentRun: z
+      .lazy(() => workflowRunSchema)
+      .nullable()
+      .optional(),
   }),
 );
 

package/src/workflow/workflow-transfer.ts

@@ -0,0 +1,190 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import {
+  directionTypeSchema,
+  mcpServerTransportSchema,
+  memoryScopeSchema,
+  workflowTypeSchema,
+} from "./domain";
+import { workflowSchema } from "./workflow";
+
+export const WORKFLOW_EXPORT_BUNDLE_KIND = "hexabot.workflow.bundle";
+
+export const WORKFLOW_TRANSFER_RESOURCE_KIND_PATTERN =
+  /^[a-z][A-Za-z0-9]*(?:[._-][A-Za-z0-9]+)*$/;
+
+export const workflowTransferResourceKindSchema = z
+  .string()
+  .min(1)
+  .regex(WORKFLOW_TRANSFER_RESOURCE_KIND_PATTERN);
+
+const workflowExportBundleLayoutSchema = z.strictObject({
+  x: z.coerce.number(),
+  y: z.coerce.number(),
+  zoom: z.coerce.number(),
+  direction: directionTypeSchema,
+});
+const workflowExportBundleWorkflowSchema = z.strictObject({
+  exportId: z.string().min(1).optional(),
+  name: z.string().min(1),
+  description: z.string().nullable(),
+  type: workflowTypeSchema,
+  schedule: z.string().nullable(),
+  inputSchema: z.any(),
+  layout: workflowExportBundleLayoutSchema,
+});
+const workflowExportBundleVersionSchema = z.strictObject({
+  number: z.coerce.number(),
+  checksum: z.string(),
+  message: z.string().nullable(),
+  exportedVersionId: z.string().min(1),
+});
+
+export const workflowExportBundleMemoryDefinitionSchema = z.strictObject({
+  exportId: z.string().min(1),
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  scope: memoryScopeSchema,
+  schema: z.any(),
+  ttlSeconds: z.coerce.number().nullable().optional(),
+});
+
+export const workflowExportBundleCredentialSchema = z.strictObject({
+  exportId: z.string().min(1),
+  name: z.string().min(1),
+  exportedOwnerId: z.string().optional(),
+});
+
+export const workflowExportBundleMcpServerSchema = z.strictObject({
+  exportId: z.string().min(1),
+  name: z.string().min(1),
+  enabled: z.coerce.boolean(),
+  transport: mcpServerTransportSchema,
+  url: z.string().nullable(),
+  command: z.string().nullable(),
+  args: z.array(z.string()).nullable(),
+  cwd: z.string().nullable(),
+  credentialExportId: z.string().nullable().optional(),
+});
+
+export const workflowExportBundleContentTypeSchema = z.strictObject({
+  exportId: z.string().min(1),
+  name: z.string().min(1),
+  schema: z.any(),
+});
+
+export const workflowExportBundleLabelGroupSchema = z.strictObject({
+  exportId: z.string().min(1),
+  name: z.string().min(1),
+});
+
+export const workflowExportBundleLabelSchema = z.strictObject({
+  exportId: z.string().min(1),
+  title: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().nullable(),
+  groupExportId: z.string().nullable(),
+});
+
+export const workflowExportBundleWorkflowDependencySchema = z.strictObject({
+  exportId: z.string().min(1),
+  workflow: workflowExportBundleWorkflowSchema.omit({ exportId: true }),
+  version: workflowExportBundleVersionSchema,
+  definitionYml: z.string().min(1),
+});
+
+const workflowExportBundleResourcesSchema = z
+  .object({
+    memoryDefinitions: z.array(workflowExportBundleMemoryDefinitionSchema),
+    mcpServers: z.array(workflowExportBundleMcpServerSchema),
+    credentials: z.array(workflowExportBundleCredentialSchema),
+    contentTypes: z.array(workflowExportBundleContentTypeSchema).default([]),
+    labelGroups: z.array(workflowExportBundleLabelGroupSchema).default([]),
+    labels: z.array(workflowExportBundleLabelSchema).default([]),
+    workflows: z
+      .array(workflowExportBundleWorkflowDependencySchema)
+      .default([]),
+  })
+  .catchall(z.array(z.unknown()));
+
+export const workflowExportBundleV1Schema = z.strictObject({
+  kind: z.literal(WORKFLOW_EXPORT_BUNDLE_KIND),
+  schemaVersion: z.literal(1),
+  exportedAt: z.iso.datetime(),
+  workflow: workflowExportBundleWorkflowSchema,
+  version: workflowExportBundleVersionSchema,
+  definitionYml: z.string().min(1),
+  resources: workflowExportBundleResourcesSchema,
+});
+
+export const workflowExportBundleSchema = workflowExportBundleV1Schema;
+
+export const workflowImportResourceActionSchema = z.enum([
+  "created",
+  "reused",
+  "placeholder_created",
+]);
+
+export const workflowImportResourceResultSchema = z.strictObject({
+  kind: workflowTransferResourceKindSchema,
+  exportId: z.string().min(1),
+  localId: z.string().min(1),
+  name: z.string().min(1),
+  action: workflowImportResourceActionSchema,
+});
+
+export const workflowImportResultSchema = z.strictObject({
+  workflow: workflowSchema,
+  resources: z.array(workflowImportResourceResultSchema),
+  warnings: z.array(z.string()),
+});
+
+export type WorkflowExportBundleMemoryDefinition = z.infer<
+  typeof workflowExportBundleMemoryDefinitionSchema
+>;
+
+export type WorkflowExportBundleCredential = z.infer<
+  typeof workflowExportBundleCredentialSchema
+>;
+
+export type WorkflowExportBundleMcpServer = z.infer<
+  typeof workflowExportBundleMcpServerSchema
+>;
+
+export type WorkflowExportBundleContentType = z.infer<
+  typeof workflowExportBundleContentTypeSchema
+>;
+
+export type WorkflowExportBundleLabelGroup = z.infer<
+  typeof workflowExportBundleLabelGroupSchema
+>;
+
+export type WorkflowExportBundleLabel = z.infer<
+  typeof workflowExportBundleLabelSchema
+>;
+
+export type WorkflowExportBundleWorkflowDependency = z.infer<
+  typeof workflowExportBundleWorkflowDependencySchema
+>;
+
+export type WorkflowExportBundleV1 = z.infer<
+  typeof workflowExportBundleV1Schema
+>;
+
+export type WorkflowExportBundle = z.infer<typeof workflowExportBundleSchema>;
+
+export type WorkflowImportResourceAction = z.infer<
+  typeof workflowImportResourceActionSchema
+>;
+
+export type WorkflowImportResourceResult = z.infer<
+  typeof workflowImportResourceResultSchema
+>;
+
+export type WorkflowImportResult = z.infer<typeof workflowImportResultSchema>;