@minion-stack/db 0.2.0

package/src/schema/auth/index.ts

@@ -0,0 +1,190 @@
+/**
+ * Better Auth schema tables.
+ * Generated manually based on Better Auth 1.x field definitions.
+ * Provider: sqlite, plugins: emailAndPassword, google OAuth, jwt, organization
+ */
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+
+// ── Core: user ──────────────────────────────────────────────────────────────
+export const user = sqliteTable('user', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+  emailVerified: integer('email_verified', { mode: 'boolean' }).notNull(),
+  image: text('image'),
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+  role: text('role', { enum: ['user', 'admin'] })
+    .notNull()
+    .default('user'),
+  personalAgentId: text('personal_agent_id'),
+});
+
+// ── Core: session ────────────────────────────────────────────────────────────
+export const session = sqliteTable(
+  'session',
+  {
+    id: text('id').primaryKey(),
+    expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull(),
+    token: text('token').notNull().unique(),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+    ipAddress: text('ip_address'),
+    userAgent: text('user_agent'),
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    // Added by organization plugin
+    activeOrganizationId: text('active_organization_id'),
+  },
+  (t) => [index('idx_session_user').on(t.userId)],
+);
+
+// ── Core: account ────────────────────────────────────────────────────────────
+export const account = sqliteTable(
+  'account',
+  {
+    id: text('id').primaryKey(),
+    accountId: text('account_id').notNull(),
+    providerId: text('provider_id').notNull(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    accessToken: text('access_token'),
+    refreshToken: text('refresh_token'),
+    idToken: text('id_token'),
+    accessTokenExpiresAt: integer('access_token_expires_at', { mode: 'timestamp' }),
+    refreshTokenExpiresAt: integer('refresh_token_expires_at', { mode: 'timestamp' }),
+    scope: text('scope'),
+    password: text('password'),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+  },
+  (t) => [index('idx_account_user').on(t.userId)],
+);
+
+// ── Core: verification ────────────────────────────────────────────────────────
+export const verification = sqliteTable(
+  'verification',
+  {
+    id: text('id').primaryKey(),
+    identifier: text('identifier').notNull(),
+    value: text('value').notNull(),
+    expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+  },
+  (t) => [index('idx_verification_identifier').on(t.identifier)],
+);
+
+// ── JWT plugin: jwks ─────────────────────────────────────────────────────────
+export const jwks = sqliteTable('jwks', {
+  id: text('id').primaryKey(),
+  publicKey: text('public_key').notNull(),
+  privateKey: text('private_key').notNull(),
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+});
+
+// ── Organization plugin: organization ────────────────────────────────────────
+export const organization = sqliteTable('organization', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  slug: text('slug').unique(),
+  logo: text('logo'),
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+  metadata: text('metadata'),
+});
+
+// ── Organization plugin: member ───────────────────────────────────────────────
+export const member = sqliteTable(
+  'member',
+  {
+    id: text('id').primaryKey(),
+    organizationId: text('organization_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    role: text('role').notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+  },
+  (t) => [index('idx_member_org').on(t.organizationId), index('idx_member_user').on(t.userId)],
+);
+
+// ── Organization plugin: invitation ──────────────────────────────────────────
+export const invitation = sqliteTable(
+  'invitation',
+  {
+    id: text('id').primaryKey(),
+    organizationId: text('organization_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    email: text('email').notNull(),
+    role: text('role'),
+    status: text('status').notNull(),
+    expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull(),
+    inviterId: text('inviter_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+  },
+  (t) => [index('idx_invitation_org').on(t.organizationId)],
+);
+
+// ── OIDC provider plugin: oauthApplication ──────────────────────────────────
+export const oauthApplication = sqliteTable('oauth_application', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  icon: text('icon'),
+  metadata: text('metadata'),
+  clientId: text('client_id').notNull().unique(),
+  clientSecret: text('client_secret'),
+  redirectUrls: text('redirect_urls').notNull(),
+  type: text('type').notNull(),
+  disabled: integer('disabled', { mode: 'boolean' }).default(false),
+  userId: text('user_id').references(() => user.id, { onDelete: 'cascade' }),
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+});
+
+// ── OIDC provider plugin: oauthAccessToken ──────────────────────────────────
+export const oauthAccessToken = sqliteTable(
+  'oauth_access_token',
+  {
+    id: text('id').primaryKey(),
+    accessToken: text('access_token').notNull().unique(),
+    refreshToken: text('refresh_token').notNull().unique(),
+    accessTokenExpiresAt: integer('access_token_expires_at', { mode: 'timestamp' }).notNull(),
+    refreshTokenExpiresAt: integer('refresh_token_expires_at', { mode: 'timestamp' }).notNull(),
+    clientId: text('client_id').notNull(),
+    userId: text('user_id').references(() => user.id, { onDelete: 'cascade' }),
+    scopes: text('scopes').notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+  },
+  (t) => [
+    index('idx_oauth_access_token_client').on(t.clientId),
+    index('idx_oauth_access_token_user').on(t.userId),
+  ],
+);
+
+// ── OIDC provider plugin: oauthConsent ──────────────────────────────────────
+export const oauthConsent = sqliteTable(
+  'oauth_consent',
+  {
+    id: text('id').primaryKey(),
+    clientId: text('client_id').notNull(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    scopes: text('scopes').notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+    consentGiven: integer('consent_given', { mode: 'boolean' }).notNull(),
+  },
+  (t) => [
+    index('idx_oauth_consent_client').on(t.clientId),
+    index('idx_oauth_consent_user').on(t.userId),
+  ],
+);

package/src/schema/backup-configs.ts

@@ -0,0 +1,22 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+
+export const backupConfigs = sqliteTable(
+  'backup_configs',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    backupHost: text('backup_host'),
+    backupUser: text('backup_user').default('root'),
+    backupPort: integer('backup_port').default(22),
+    backupBasePath: text('backup_base_path').default('/mnt/agent-data/backups'),
+    schedule: text('schedule'),
+    retentionCount: integer('retention_count').default(7),
+    enabled: integer('enabled').default(0),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [index('idx_backup_configs_tenant').on(t.tenantId)],
+);

package/src/schema/bugs.ts

@@ -0,0 +1,30 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const bugs = sqliteTable(
+  'bugs',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id'),
+    errorCode: text('error_code'),
+    message: text('message').notNull(),
+    stack: text('stack'),
+    severity: text('severity', { enum: ['critical', 'high', 'medium', 'low'] })
+      .notNull()
+      .default('medium'),
+    status: text('status', { enum: ['new', 'acknowledged', 'resolved', 'ignored'] })
+      .notNull()
+      .default('new'),
+    metadata: text('metadata'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [index('idx_bugs_tenant').on(t.tenantId), index('idx_bugs_server').on(t.serverId)],
+);

package/src/schema/builder.ts

@@ -0,0 +1,151 @@
+import { sqliteTable, text, integer, real } from 'drizzle-orm/sqlite-core';
+import { servers } from './servers.js';
+import { organization } from './auth/index.js';
+
+// ── Built Skills ──────────────────────────────────────────────────────
+export const builtSkills = sqliteTable('built_skills', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  description: text('description').default(''),
+  emoji: text('emoji').default('📖'),
+  status: text('status', { enum: ['draft', 'published'] })
+    .notNull()
+    .default('draft'),
+  maxCycles: integer('max_cycles').notNull().default(3),
+  serverId: text('server_id').references(() => servers.id, { onDelete: 'cascade' }),
+  tenantId: text('tenant_id').references(() => organization.id, { onDelete: 'cascade' }),
+  createdBy: text('created_by'),
+  publishedAt: integer('published_at'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+// ── Skill Tool Pool (junction: skill → gateway tool IDs) ─────────────
+export const builtSkillTools = sqliteTable('built_skill_tools', {
+  id: text('id').primaryKey(),
+  skillId: text('skill_id')
+    .notNull()
+    .references(() => builtSkills.id, { onDelete: 'cascade' }),
+  toolId: text('tool_id').notNull(), // gateway tool ID string (e.g., 'web-search')
+});
+
+// ── Chapters (subprocess nodes in the DAG) ───────────────────────────
+export const builtChapters = sqliteTable('built_chapters', {
+  id: text('id').primaryKey(),
+  skillId: text('skill_id')
+    .notNull()
+    .references(() => builtSkills.id, { onDelete: 'cascade' }),
+  type: text('type', { enum: ['chapter', 'condition'] })
+    .notNull()
+    .default('chapter'),
+  name: text('name').notNull(),
+  description: text('description').default(''),
+  guide: text('guide').default(''), // instructions/markdown
+  context: text('context').default(''), // constraints, additional context
+  outputDef: text('output_def').default(''), // what this chapter produces
+  conditionText: text('condition_text').default(''), // binary question for condition nodes
+  positionX: real('position_x').notNull().default(0),
+  positionY: real('position_y').notNull().default(0),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+// ── Chapter Edges (DAG connections between chapters) ─────────────────
+export const builtChapterEdges = sqliteTable('built_chapter_edges', {
+  id: text('id').primaryKey(),
+  skillId: text('skill_id')
+    .notNull()
+    .references(() => builtSkills.id, { onDelete: 'cascade' }),
+  sourceChapterId: text('source_chapter_id')
+    .notNull()
+    .references(() => builtChapters.id, { onDelete: 'cascade' }),
+  targetChapterId: text('target_chapter_id')
+    .notNull()
+    .references(() => builtChapters.id, { onDelete: 'cascade' }),
+  label: text('label'),
+});
+
+// ── Chapter Tools (junction: chapter → subset of skill's tool pool) ──
+export const builtChapterTools = sqliteTable('built_chapter_tools', {
+  id: text('id').primaryKey(),
+  chapterId: text('chapter_id')
+    .notNull()
+    .references(() => builtChapters.id, { onDelete: 'cascade' }),
+  toolId: text('tool_id').notNull(), // must exist in parent skill's pool
+});
+
+// ── Built Agents ─────────────────────────────────────────────────────
+export const builtAgents = sqliteTable('built_agents', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  emoji: text('emoji').default('🤖'),
+  description: text('description').default(''),
+  model: text('model'),
+  systemPrompt: text('system_prompt').default(''),
+  temperature: real('temperature').default(0.7),
+  maxTokens: integer('max_tokens').default(4096),
+  retryPolicy: text('retry_policy').default('{}'), // JSON
+  fallbackAgentId: text('fallback_agent_id'),
+  status: text('status', { enum: ['draft', 'published'] })
+    .notNull()
+    .default('draft'),
+  serverId: text('server_id').references(() => servers.id, { onDelete: 'cascade' }),
+  tenantId: text('tenant_id').references(() => organization.id, { onDelete: 'cascade' }),
+  createdBy: text('created_by'),
+  publishedAt: integer('published_at'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+// ── Agent Skill Slots (junction: agent → skill with order) ───────────
+export const builtAgentSkills = sqliteTable('built_agent_skills', {
+  id: text('id').primaryKey(),
+  agentId: text('agent_id')
+    .notNull()
+    .references(() => builtAgents.id, { onDelete: 'cascade' }),
+  skillId: text('skill_id')
+    .notNull()
+    .references(() => builtSkills.id, { onDelete: 'cascade' }),
+  position: integer('position').notNull().default(0),
+  configOverrides: text('config_overrides').default('{}'), // JSON
+});
+
+// ── Agent Built Skills (junction: gateway agent → built skill) ────────
+export const agentBuiltSkills = sqliteTable('agent_built_skills', {
+  id: text('id').primaryKey(),
+  gatewayAgentId: text('gateway_agent_id').notNull(),
+  serverId: text('server_id')
+    .notNull()
+    .references(() => servers.id, { onDelete: 'cascade' }),
+  tenantId: text('tenant_id')
+    .notNull()
+    .references(() => organization.id, { onDelete: 'cascade' }),
+  skillId: text('skill_id')
+    .notNull()
+    .references(() => builtSkills.id, { onDelete: 'cascade' }),
+  position: integer('position').notNull().default(0),
+  createdAt: integer('created_at').notNull(),
+});
+
+// ── Built Tools (admin-only playground) ──────────────────────────────
+export const builtTools = sqliteTable('built_tools', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  description: text('description').default(''),
+  scriptCode: text('script_code').default(''),
+  scriptLang: text('script_lang', { enum: ['javascript', 'python', 'bash'] })
+    .notNull()
+    .default('javascript'),
+  envVars: text('env_vars').default('{}'), // JSON key-value
+  validationRules: text('validation_rules').default('{}'), // JSON input schema
+  executionConfig: text('execution_config').default('{}'), // JSON timeout, retries
+  status: text('status', { enum: ['draft', 'published'] })
+    .notNull()
+    .default('draft'),
+  serverId: text('server_id').references(() => servers.id, { onDelete: 'cascade' }),
+  tenantId: text('tenant_id').references(() => organization.id, { onDelete: 'cascade' }),
+  createdBy: text('created_by'),
+  publishedAt: integer('published_at'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/src/schema/channel-assignments.ts

@@ -0,0 +1,23 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { channels } from './channels.js';
+
+export const channelAssignments = sqliteTable(
+  'channel_assignments',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    channelId: text('channel_id')
+      .notNull()
+      .references(() => channels.id, { onDelete: 'cascade' }),
+    targetType: text('target_type', { enum: ['user', 'session'] }).notNull(),
+    targetId: text('target_id').notNull(),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    index('idx_channel_assign_channel').on(t.channelId),
+    uniqueIndex('channel_assign_uniq').on(t.channelId, t.targetType, t.targetId),
+  ],
+);

package/src/schema/channel-identities.ts

@@ -0,0 +1,25 @@
+import { sqliteTable, text, integer, uniqueIndex, index } from 'drizzle-orm/sqlite-core';
+import { user } from './auth/index.js';
+
+/**
+ * Maps channel sender IDs (e.g. telegram:12345, discord:67890) to hub users.
+ * Used by the gateway to resolve user identity from channel messages.
+ */
+export const channelIdentities = sqliteTable(
+  'channel_identities',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    channel: text('channel').notNull(),
+    channelUserId: text('channel_user_id').notNull(),
+    displayName: text('display_name'),
+    verifiedAt: integer('verified_at'),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    uniqueIndex('idx_channel_identity_unique').on(t.channel, t.channelUserId),
+    index('idx_channel_identity_user').on(t.userId),
+  ],
+);

package/src/schema/channels.ts

@@ -0,0 +1,30 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const channels = sqliteTable(
+  'channels',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    type: text('type', { enum: ['discord', 'whatsapp', 'telegram'] }).notNull(),
+    label: text('label').notNull(),
+    credentials: text('credentials').notNull().default(''),
+    credentialsIv: text('credentials_iv').notNull().default(''),
+    credentialsMeta: text('credentials_meta').notNull().default('{}'),
+    status: text('status', { enum: ['active', 'inactive', 'pairing'] })
+      .notNull()
+      .default('inactive'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    index('idx_channels_tenant_server').on(t.tenantId, t.serverId),
+    uniqueIndex('channels_uniq_type_label').on(t.tenantId, t.serverId, t.type, t.label),
+  ],
+);

package/src/schema/chat-messages.ts

@@ -0,0 +1,27 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const chatMessages = sqliteTable(
+  'chat_messages',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id').notNull(),
+    sessionKey: text('session_key').notNull(),
+    role: text('role', { enum: ['user', 'assistant'] }).notNull(),
+    content: text('content').notNull(),
+    runId: text('run_id'),
+    timestamp: integer('timestamp').notNull(),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    index('idx_chat_tenant').on(t.tenantId),
+    index('idx_chat_by_agent').on(t.agentId, t.sessionKey, t.timestamp),
+  ],
+);

package/src/schema/config-snapshots.ts

@@ -0,0 +1,20 @@
+import { sqliteTable, text, integer, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const configSnapshots = sqliteTable(
+  'config_snapshots',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    configJson: text('config_json').notNull(),
+    configHash: text('config_hash').notNull(),
+    fetchedAt: integer('fetched_at').notNull(),
+  },
+  (t) => [uniqueIndex('idx_config_snapshots_server').on(t.serverId)],
+);

package/src/schema/connection-events.ts

@@ -0,0 +1,26 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const connectionEvents = sqliteTable(
+  'connection_events',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    eventType: text('event_type').notNull(),
+    hostName: text('host_name'),
+    hostUrl: text('host_url'),
+    durationMs: integer('duration_ms'),
+    reason: text('reason'),
+    occurredAt: integer('occurred_at').notNull(),
+  },
+  (t) => [
+    index('idx_conn_events_tenant').on(t.tenantId),
+    index('idx_conn_events_server').on(t.serverId),
+  ],
+);

package/src/schema/credential-health.ts

@@ -0,0 +1,23 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const credentialHealthSnapshots = sqliteTable(
+  'credential_health_snapshots',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    snapshotJson: text('snapshot_json').notNull(),
+    capturedAt: integer('captured_at').notNull(),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    index('idx_cred_health_server_time').on(t.serverId, t.capturedAt),
+    index('idx_cred_health_tenant').on(t.tenantId),
+  ],
+);

package/src/schema/device-identities.ts

@@ -0,0 +1,14 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+
+export const deviceIdentities = sqliteTable('device_identities', {
+  id: text('id').primaryKey(),
+  tenantId: text('tenant_id')
+    .notNull()
+    .references(() => organization.id, { onDelete: 'cascade' })
+    .unique(),
+  deviceId: text('device_id').notNull(),
+  publicKeyPem: text('public_key_pem').notNull(),
+  privateKeyPem: text('private_key_pem').notNull(),
+  createdAt: integer('created_at').notNull(),
+});

package/src/schema/files.ts

@@ -0,0 +1,20 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization, user } from './auth/index.js';
+
+export const files = sqliteTable(
+  'files',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    uploadedBy: text('uploaded_by').references(() => user.id, { onDelete: 'set null' }),
+    b2FileKey: text('b2_file_key').notNull(),
+    fileName: text('file_name').notNull(),
+    contentType: text('content_type').notNull(),
+    sizeBytes: integer('size_bytes').notNull(),
+    category: text('category').notNull().default('general'),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [index('idx_files_tenant').on(t.tenantId)],
+);

package/src/schema/flows.ts

@@ -0,0 +1,12 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+
+export const flows = sqliteTable('flows', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  nodes: text('nodes').notNull().default('[]'), // JSON string of FlowNode[]
+  edges: text('edges').notNull().default('[]'), // JSON string of FlowEdge[]
+  userId: text('user_id'), // owner — null for pre-migration rows (treated as shared)
+  tenantId: text('tenant_id'), // tenant scope — null for pre-migration rows
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/src/schema/gateway-heartbeats.ts

@@ -0,0 +1,27 @@
+import { sqliteTable, text, integer, real, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const gatewayHeartbeats = sqliteTable(
+  'gateway_heartbeats',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    uptimeMs: integer('uptime_ms').notNull(),
+    activeSessions: integer('active_sessions').notNull(),
+    activeAgents: integer('active_agents').notNull(),
+    memoryRssMb: real('memory_rss_mb'),
+    credentialSummaryJson: text('credential_summary_json'),
+    channelStatusJson: text('channel_status_json'),
+    capturedAt: integer('captured_at').notNull(),
+  },
+  (t) => [
+    index('idx_gw_heartbeats_server_time').on(t.serverId, t.capturedAt),
+    index('idx_gw_heartbeats_tenant').on(t.tenantId),
+  ],
+);