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.

5.9 KB
Raw Blame
import type { MessageKey } from "@akeru/client-runtime/i18n";
import type {
  ProviderInstanceEnvironmentVariable,
  SandboxProvider,
  SandboxSettings,
} from "@akeru/contracts";

export type CloudSandboxProvider = Exclude<SandboxProvider, "local">;

export interface SandboxCredentialField {
  readonly name: string;
  readonly label: MessageKey;
  readonly secret: boolean;
}

export interface SandboxProviderDefinition {
  readonly id: CloudSandboxProvider;
  readonly label: string;
  readonly description: MessageKey;
  readonly fields: ReadonlyArray<SandboxCredentialField>;
}

const SANDBOX_PROVIDER_DEFINITION_BY_ID: Readonly<
  Record<CloudSandboxProvider, SandboxProviderDefinition>
> = {
  e2b: {
    id: "e2b",
    label: "E2B",
    description: "Cloud workspaces managed by E2B. Requires an API key.",
    fields: [{ name: "E2B_API_KEY", label: "API key", secret: true }],
  },
  daytona: {
    id: "daytona",
    label: "Daytona",
    description: "Cloud workspaces managed by Daytona. Requires an API key.",
    fields: [{ name: "DAYTONA_API_KEY", label: "API key", secret: true }],
  },
  vercel: {
    id: "vercel",
    label: "Vercel Sandbox",
    description: "Cloud workspaces in your Vercel team and project.",
    fields: [
      { name: "VERCEL_TOKEN", label: "Token", secret: true },
      { name: "VERCEL_TEAM_ID", label: "Team ID", secret: false },
      { name: "VERCEL_PROJECT_ID", label: "Project ID", secret: false },
    ],
  },
  upstash: {
    id: "upstash",
    label: "Upstash Box",
    description: "Cloud workspaces managed by Upstash Box. Requires an API key.",
    fields: [{ name: "UPSTASH_BOX_API_KEY", label: "API key", secret: true }],
  },
  ascii: {
    id: "ascii",
    label: "Ascii Box",
    description: "Run bots in a persistent Linux VM. Public previews are enabled by default.",
    fields: [{ name: "BOX_API_KEY", label: "API key", secret: true }],
  },
  railway: {
    id: "railway",
    label: "Railway",
    description:
      "Run bots in a durable Railway VM. Idle VMs keep running and can incur charges. Previews require a Railway CLI tunnel.",
    fields: [
      { name: "RAILWAY_API_TOKEN", label: "API token", secret: true },
      { name: "RAILWAY_ENVIRONMENT_ID", label: "Environment ID", secret: false },
    ],
  },
  tenki: {
    id: "tenki",
    label: "Tenki",
    description: "Cloud workspaces managed by Tenki. Requires an API key.",
    fields: [{ name: "TENKI_API_KEY", label: "API key", secret: true }],
  },
};

export const SANDBOX_PROVIDER_DEFINITIONS = Object.values(SANDBOX_PROVIDER_DEFINITION_BY_ID);

export function sandboxProviderDefinition(provider: CloudSandboxProvider) {
  return SANDBOX_PROVIDER_DEFINITION_BY_ID[provider];
}

export function isSandboxProviderConnected(
  settings: SandboxSettings,
  provider: CloudSandboxProvider,
): boolean {
  const environment = settings.providers[provider].environment;

  return sandboxProviderDefinition(provider).fields.every((field) => {
    const variable = environment.find((candidate) => candidate.name === field.name);

    return Boolean(variable && (variable.value.trim().length > 0 || variable.valueRedacted));
  });
}

export function selectableSandboxProviders(settings: SandboxSettings) {
  return [
    "local" as const,
    ...SANDBOX_PROVIDER_DEFINITIONS.flatMap((definition) =>
      isSandboxProviderConnected(settings, definition.id) ? [definition.id] : [],
    ),
  ];
}

export function sandboxConnectionDraft(
  settings: SandboxSettings,
  provider: CloudSandboxProvider,
): Readonly<Record<string, string>> {
  return Object.fromEntries(
    sandboxProviderDefinition(provider).fields.map((field) => [
      field.name,
      settings.providers[provider].environment.find((variable) => variable.name === field.name)
        ?.value ?? "",
    ]),
  );
}

export function canSaveSandboxProviderConnection(input: {
  readonly settings: SandboxSettings;
  readonly provider: CloudSandboxProvider;
  readonly draft: Readonly<Record<string, string>>;
}): boolean {
  const existing = input.settings.providers[input.provider].environment;

  return sandboxProviderDefinition(input.provider).fields.every((field) => {
    if ((input.draft[field.name] ?? "").trim().length > 0) return true;
    const variable = existing.find((candidate) => candidate.name === field.name);

    return field.secret && variable?.valueRedacted === true;
  });
}

export function saveSandboxProviderConnection(input: {
  readonly settings: SandboxSettings;
  readonly provider: CloudSandboxProvider;
  readonly draft: Readonly<Record<string, string>>;
}): SandboxSettings {
  const currentEnvironment = input.settings.providers[input.provider].environment;

  const environment = sandboxProviderDefinition(input.provider).fields.map((field) => {
    const value = (input.draft[field.name] ?? "").trim();
    const current = currentEnvironment.find((variable) => variable.name === field.name);

    if (field.secret && value.length === 0 && current?.valueRedacted) return current;

    return {
      name: field.name,
      value,
      sensitive: field.secret,
    } satisfies ProviderInstanceEnvironmentVariable;
  });

  return {
    ...input.settings,
    providers: {
      ...input.settings.providers,
      [input.provider]: { environment },
    },
  };
}

export function disconnectSandboxProvider(
  settings: SandboxSettings,
  provider: CloudSandboxProvider,
): SandboxSettings {
  return {
    ...settings,
    defaultProvider: settings.defaultProvider === provider ? "local" : settings.defaultProvider,
    providers: { ...settings.providers, [provider]: { environment: [] } },
  };
}

export type RailwayConnectionChange =
  | { readonly kind: "disconnect" }
  | { readonly kind: "save"; readonly draft: Readonly<Record<string, string>> };

export function applyRailwayConnectionChange(
  settings: SandboxSettings,
  change: RailwayConnectionChange,
) {
  return change.kind === "disconnect"
    ? disconnectSandboxProvider(settings, "railway")
    : saveSandboxProviderConnection({ settings, provider: "railway", draft: change.draft });
}