Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

12.3 KB
Raw Blame
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import {
  BotId,
  EventId,
  GroupId,
  IsoDateTime,
  MessageId,
  NonNegativeInt,
  ProjectId,
  ThreadId,
  TrimmedNonEmptyString,
} from "./baseSchemas.ts";
import { ThreadEnvMode } from "./environment.ts";
import { McpServerConfiguration, McpServerId, McpServerInstructions } from "./mcpServer.ts";
import {
  BotAvatar,
  BotEngine,
  BotPersonalityTone,
  BotSandboxBrowserSharing,
  PersistedBotSandbox,
  GroupBotMembership,
} from "./orchestration/roster.ts";
import {
  ModelSelection,
  ProviderInteractionMode,
  RuntimeMode,
} from "./orchestration/modelSelection.ts";
import { OrchestrationMessageRole, OrchestrationProposedPlanId } from "./orchestration/thread.ts";
import { ImageProviderId } from "./imageGeneration.ts";
import {
  BackgroundActivityProfile,
  BackgroundActivityProfileSelection,
  ServerSettings,
} from "./settings/server.ts";

export const AKERU_ARCHIVE_FORMAT = "akeru.archive" as const;

export const AKERU_ARCHIVE_VERSION = 1 as const;

export const PORTABILITY_ARCHIVE_MAX_CHARS = 20 * 1024 * 1024;

const PortabilityBackgroundActivityOverrides = Schema.Struct({
  automaticGitFetchIntervalMs: Schema.optional(NonNegativeInt),
  providerHealthRefreshIntervalMs: Schema.optional(NonNegativeInt),
  hostPowerMonitorActiveIntervalMs: Schema.optional(NonNegativeInt),
  hostPowerMonitorIdleIntervalMs: Schema.optional(NonNegativeInt),
  idleClientTtlMs: Schema.optional(NonNegativeInt),
  pauseWhenHostLocked: Schema.optional(Schema.Boolean),
  pauseWhenHostLowPower: Schema.optional(Schema.Boolean),
  pauseWhenClientLowPower: Schema.optional(Schema.Boolean),
  pauseWhenOnBattery: Schema.optional(Schema.Boolean),
});

const PortabilityBackgroundActivitySettings = Schema.Struct({
  schemaVersion: Schema.Literal(1),
  profile: BackgroundActivityProfileSelection,
  baseProfile: Schema.optional(BackgroundActivityProfile),
  overrides: PortabilityBackgroundActivityOverrides,
});

export const PortabilitySafeServerSettings = Schema.Struct({
  enableLegacyTokenStreaming: ServerSettings.fields.enableLegacyTokenStreaming,
  enableProviderUpdateChecks: ServerSettings.fields.enableProviderUpdateChecks,
  enableAgentBrowserAccess: ServerSettings.fields.enableAgentBrowserAccess,
  // Do not decode a missing v1 field to a default. That would invalidate its signed record.
  botSandboxBrowserSharing: Schema.optionalKey(BotSandboxBrowserSharing),
  backgroundActivity: PortabilityBackgroundActivitySettings,
  automaticGitFetchIntervalMs: NonNegativeInt,
  providerHealthRefreshIntervalMs: NonNegativeInt,
  backgroundActivityProfile: ServerSettings.fields.backgroundActivityProfile,
  defaultThreadEnvMode: ServerSettings.fields.defaultThreadEnvMode,
  newWorktreesStartFromOrigin: ServerSettings.fields.newWorktreesStartFromOrigin,
  textGenerationModelSelection: ServerSettings.fields.textGenerationModelSelection,
  sourceControlWritingStyle: ServerSettings.fields.sourceControlWritingStyle,
  sourceControlWriterModelSelection: ServerSettings.fields.sourceControlWriterModelSelection,
});

export type PortabilitySafeServerSettings = typeof PortabilitySafeServerSettings.Type;

const ArchiveChecksum = Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/));

const ArchiveRecordBase = {
  id: TrimmedNonEmptyString,
  updatedAt: IsoDateTime,
  checksum: ArchiveChecksum,
};

export const PortabilityBotData = Schema.Struct({
  name: TrimmedNonEmptyString,
  title: TrimmedNonEmptyString,
  label: Schema.NullOr(TrimmedNonEmptyString),
  description: Schema.NullOr(Schema.String),
  disabledMcpServerIds: Schema.Array(McpServerId),
  avatar: BotAvatar,
  engine: Schema.NullOr(BotEngine),
  sandbox: PersistedBotSandbox,
  runtimeMode: RuntimeMode,
  /**
   * The retired token hard stop. Archives exported before its removal still
   * carry it and sign it, so it decodes as-is to keep their checksums valid;
   * import ignores it and new exports omit it.
   */
  usageCap: Schema.optionalKey(
    Schema.NullOr(Schema.Struct({ unit: Schema.Literal("tokens"), limit: Schema.Number })),
  ),
  imageProvider: Schema.NullOr(ImageProviderId).pipe(
    Schema.withDecodingDefault(Effect.succeed(null)),
  ),
  personalityTone: Schema.optionalKey(BotPersonalityTone),
  voiceEnabled: Schema.Boolean,
  archived: Schema.Boolean,
});

export type PortabilityBotData = typeof PortabilityBotData.Type;

export const PortabilityGroupData = Schema.Struct({
  name: TrimmedNonEmptyString,
  bossBotId: Schema.NullOr(BotId),
  members: Schema.Array(GroupBotMembership),
});

export type PortabilityGroupData = typeof PortabilityGroupData.Type;

export const PortabilityMcpServerData = Schema.Struct({
  catalogId: Schema.optional(TrimmedNonEmptyString),
  configuration: McpServerConfiguration,
  instructions: Schema.optional(McpServerInstructions),
});

export type PortabilityMcpServerData = typeof PortabilityMcpServerData.Type;

export const PortabilityProjectData = Schema.Struct({
  title: TrimmedNonEmptyString,
  workspaceName: TrimmedNonEmptyString,
  repository: Schema.optional(
    Schema.Struct({
      displayName: Schema.optional(TrimmedNonEmptyString),
      provider: Schema.optional(TrimmedNonEmptyString),
      owner: Schema.optional(TrimmedNonEmptyString),
      name: Schema.optional(TrimmedNonEmptyString),
    }),
  ),
  defaultModelSelection: Schema.NullOr(ModelSelection),
  defaultThreadEnvMode: Schema.optional(Schema.NullOr(ThreadEnvMode)),
});

export type PortabilityProjectData = typeof PortabilityProjectData.Type;

export const PortabilityThreadData = Schema.Struct({
  projectId: ProjectId,
  botId: Schema.optional(Schema.NullOr(BotId)),
  groupId: Schema.optional(Schema.NullOr(GroupId)),
  title: TrimmedNonEmptyString,
  modelSelection: ModelSelection,
  runtimeMode: RuntimeMode,
  interactionMode: ProviderInteractionMode,
  createdAt: IsoDateTime,
  archivedAt: Schema.NullOr(IsoDateTime),
  settledOverride: Schema.NullOr(Schema.Literals(["settled", "active"])),
  settledAt: Schema.NullOr(IsoDateTime),
  snoozedUntil: Schema.NullOr(IsoDateTime),
  snoozedAt: Schema.NullOr(IsoDateTime),
  pinnedAt: Schema.optional(Schema.NullOr(IsoDateTime)),
  pinOrderKey: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
  messages: Schema.Array(
    Schema.Struct({
      id: MessageId,
      role: OrchestrationMessageRole,
      text: Schema.String,
      respondingBotId: Schema.optional(Schema.NullOr(BotId)),
      createdAt: IsoDateTime,
      updatedAt: IsoDateTime,
    }),
  ),
  proposedPlans: Schema.Array(
    Schema.Struct({
      id: OrchestrationProposedPlanId,
      planMarkdown: TrimmedNonEmptyString,
      implementedAt: Schema.NullOr(IsoDateTime),
      implementationThreadId: Schema.NullOr(ThreadId),
      createdAt: IsoDateTime,
      updatedAt: IsoDateTime,
    }),
  ),
  approvalHistory: Schema.Array(
    Schema.Struct({
      id: EventId,
      originalKind: Schema.Literals([
        "approval.requested",
        "approval.resolved",
        "provider.approval.respond.failed",
      ]),
      summary: TrimmedNonEmptyString,
      requestId: Schema.optional(TrimmedNonEmptyString),
      requestKind: Schema.optional(TrimmedNonEmptyString),
      requestType: Schema.optional(TrimmedNonEmptyString),
      decision: Schema.optional(TrimmedNonEmptyString),
      actor: Schema.optional(TrimmedNonEmptyString),
      target: Schema.optional(TrimmedNonEmptyString),
      action: Schema.optional(TrimmedNonEmptyString),
      outcome: Schema.optional(TrimmedNonEmptyString),
      provider: TrimmedNonEmptyString,
      createdAt: IsoDateTime,
    }),
  ),
});

export type PortabilityThreadData = typeof PortabilityThreadData.Type;

export const PortabilityArchiveRecord = Schema.Union([
  Schema.Struct({
    ...ArchiveRecordBase,
    type: Schema.Literal("server-settings"),
    id: Schema.Literal("server-settings"),
    data: PortabilitySafeServerSettings,
  }),
  Schema.Struct({
    ...ArchiveRecordBase,
    type: Schema.Literal("mcp-server"),
    data: PortabilityMcpServerData,
  }),
  Schema.Struct({
    ...ArchiveRecordBase,
    type: Schema.Literal("bot"),
    data: PortabilityBotData,
  }),
  Schema.Struct({
    ...ArchiveRecordBase,
    type: Schema.Literal("group"),
    data: PortabilityGroupData,
  }),
  Schema.Struct({
    ...ArchiveRecordBase,
    type: Schema.Literal("project"),
    data: PortabilityProjectData,
  }),
  Schema.Struct({
    ...ArchiveRecordBase,
    type: Schema.Literal("thread"),
    data: PortabilityThreadData,
  }),
]);

export type PortabilityArchiveRecord = typeof PortabilityArchiveRecord.Type;

export type PortabilityArchiveRecordType = PortabilityArchiveRecord["type"];

export const PortabilityArchive = Schema.Struct({
  format: Schema.Literal(AKERU_ARCHIVE_FORMAT),
  version: Schema.Literal(AKERU_ARCHIVE_VERSION),
  exportedAt: IsoDateTime,
  manifest: Schema.Struct({
    recordCounts: Schema.Record(TrimmedNonEmptyString, NonNegativeInt),
    excluded: Schema.Array(TrimmedNonEmptyString),
  }),
  records: Schema.Array(PortabilityArchiveRecord),
  checksum: ArchiveChecksum,
});

export type PortabilityArchive = typeof PortabilityArchive.Type;

export const PortabilityArchiveText = Schema.String.check(
  Schema.isMaxLength(PORTABILITY_ARCHIVE_MAX_CHARS),
);

export const PortabilityImportItem = Schema.Struct({
  recordType: Schema.Literals([
    "server-settings",
    "mcp-server",
    "bot",
    "group",
    "project",
    "thread",
  ]),
  id: TrimmedNonEmptyString,
  title: TrimmedNonEmptyString,
});

export type PortabilityImportItem = typeof PortabilityImportItem.Type;

export const PortabilityProjectFolderMap = Schema.Record(ProjectId, TrimmedNonEmptyString);

export type PortabilityProjectFolderMap = typeof PortabilityProjectFolderMap.Type;

export const PortabilityProjectFolder = Schema.Struct({
  projectId: ProjectId,
  title: TrimmedNonEmptyString,
  workspaceName: TrimmedNonEmptyString,
  destination: Schema.NullOr(TrimmedNonEmptyString),
});

export type PortabilityProjectFolder = typeof PortabilityProjectFolder.Type;

export const PortabilityUnsupportedItem = Schema.Struct({
  kind: Schema.Literals([
    "project",
    "thread",
    "jobs",
    "memory",
    "routines",
    "skill-assignments",
    "usage-history",
  ]),
  count: NonNegativeInt,
  reason: TrimmedNonEmptyString,
});

export type PortabilityUnsupportedItem = typeof PortabilityUnsupportedItem.Type;

export const PortabilityImportPreview = Schema.Struct({
  snapshotSequence: NonNegativeInt,
  stateChecksum: ArchiveChecksum,
  additions: Schema.Array(PortabilityImportItem),
  changes: Schema.Array(PortabilityImportItem),
  conflicts: Schema.Array(PortabilityImportItem),
  missingProviders: Schema.Array(TrimmedNonEmptyString),
  skippedSecrets: Schema.Array(TrimmedNonEmptyString),
  projectFolders: Schema.Array(PortabilityProjectFolder).pipe(
    Schema.withDecodingDefault(Effect.succeed([])),
  ),
  unsupported: Schema.Array(PortabilityUnsupportedItem),
});

export type PortabilityImportPreview = typeof PortabilityImportPreview.Type;

export const PortabilityExportResult = Schema.Struct({
  filename: TrimmedNonEmptyString,
  contents: PortabilityArchiveText,
});

export type PortabilityExportResult = typeof PortabilityExportResult.Type;

export const PortabilityPreviewImportInput = Schema.Struct({
  contents: PortabilityArchiveText,
  projectFolders: Schema.optional(PortabilityProjectFolderMap),
});

export type PortabilityPreviewImportInput = typeof PortabilityPreviewImportInput.Type;

export const PortabilityApplyImportInput = Schema.Struct({
  contents: PortabilityArchiveText,
  projectFolders: Schema.optional(PortabilityProjectFolderMap),
  expectedSnapshotSequence: NonNegativeInt,
  expectedStateChecksum: ArchiveChecksum,
});

export type PortabilityApplyImportInput = typeof PortabilityApplyImportInput.Type;

export const PortabilityApplyImportResult = Schema.Struct({
  applied: NonNegativeInt,
  skipped: NonNegativeInt,
  failed: NonNegativeInt,
  partial: NonNegativeInt,
  failures: Schema.Array(
    Schema.Struct({
      recordType: PortabilityImportItem.fields.recordType,
      id: TrimmedNonEmptyString,
      title: TrimmedNonEmptyString,
      partial: Schema.Boolean,
      message: TrimmedNonEmptyString,
    }),
  ),
});

export type PortabilityApplyImportResult = typeof PortabilityApplyImportResult.Type;

export class PortabilityArchiveError extends Schema.TaggedErrorClass<PortabilityArchiveError>()(
  "PortabilityArchiveError",
  {
    operation: Schema.Literals(["export", "preview", "apply"]),
    message: Schema.String,
  },
) {}