@jingyi0605/codingns 0.3.6 → 0.5.0

package/dist/server/storage/sqlite/client.js

@@ -8,7 +8,10 @@ export function createDatabaseClient(databasePath) {
     const db = new Database(databasePath);
     const schemaPath = new URL("./schema.sql", import.meta.url);
     const schema = fs.readFileSync(schemaPath, "utf8");
+    ensurePreSchemaCompatibility(db);
     db.exec(schema);
+    ensureAuthTokenDeviceColumns(db);
+    ensureAuthDeviceSchema(db);
     ensureAuthLoginAttemptSchema(db);
     ensureWorkspaceRemovalColumn(db);
     ensureWorkspaceSortOrderColumn(db);
@@ -32,20 +35,117 @@ export function createDatabaseClient(databasePath) {
     ensurePortLeaseSchema(db);
     ensureRuntimeBindingSchema(db);
     ensureAiFallbackEditSchema(db);
+    ensureInstanceTailscaleConfigSchema(db);
     ensureInstanceTailscaleStatusSchema(db);
+    ensureInstanceRelayTunnelConfigSchema(db);
     ensureTerminalCommandTemplateDebugSchema(db);
     ensureTerminalInstanceDebugSchema(db);
     ensureUserPreferenceProfileSchema(db);
     ensureButlerProfileSchema(db);
     ensureButlerControlSessionSchema(db);
+    ensureButlerControlTimerSchema(db);
+    ensureAssistantAutomationSchema(db);
+    ensureAssistantSandboxSchema(db);
     ensureButlerInboxSchema(db);
     ensureButlerFollowUpTaskSchema(db);
+    ensureVerificationRunSchema(db);
     ensureButlerSessionSummarySchema(db);
     return {
         db,
         close: () => db.close()
     };
 }
+function ensurePreSchemaCompatibility(db) {
+    // 旧库还没有这些列时，schema.sql 里的索引会先炸掉，所以必须先补齐。
+    ensureAuthTokenDeviceColumns(db);
+    ensureManagedSkillScopeSchema(db);
+}
+function ensureAuthTokenDeviceColumns(db) {
+    if (!tableExists(db, "auth_tokens")) {
+        return;
+    }
+    const columns = db
+        .prepare("PRAGMA table_info(auth_tokens)")
+        .all();
+    const columnNames = new Set(columns.map((column) => column.name));
+    if (!columnNames.has("device_session_id")) {
+        db.exec("ALTER TABLE auth_tokens ADD COLUMN device_session_id TEXT");
+    }
+    if (!columnNames.has("caller_kind")) {
+        db.exec("ALTER TABLE auth_tokens ADD COLUMN caller_kind TEXT CHECK (caller_kind IN ('interactive_user', 'assistant_runtime'))");
+    }
+    db.exec("CREATE INDEX IF NOT EXISTS idx_auth_tokens_device_session_id ON auth_tokens(device_session_id)");
+}
+function tableExists(db, tableName) {
+    const row = db
+        .prepare(`SELECT name
+       FROM sqlite_master
+       WHERE type = 'table' AND name = ?`)
+        .get(tableName);
+    return row?.name === tableName;
+}
+function ensureAuthDeviceSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS auth_devices (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      client_type TEXT NOT NULL CHECK (client_type IN ('desktop', 'web', 'ios', 'android', 'unknown')),
+      client_instance_id TEXT,
+      display_name TEXT,
+      user_agent TEXT,
+      is_primary INTEGER NOT NULL DEFAULT 0 CHECK (is_primary IN (0, 1)),
+      last_source_address TEXT,
+      last_seen_at TEXT NOT NULL,
+      primary_set_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES auth_users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_auth_devices_user_id
+      ON auth_devices(user_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_auth_devices_client_lookup
+      ON auth_devices(user_id, client_type, client_instance_id);
+
+    CREATE TABLE IF NOT EXISTS auth_device_sessions (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      device_id TEXT,
+      access_token_id TEXT,
+      refresh_token_id TEXT,
+      revoked_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES auth_users(id),
+      FOREIGN KEY (device_id) REFERENCES auth_devices(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_auth_device_sessions_user_id
+      ON auth_device_sessions(user_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_auth_device_sessions_device_id
+      ON auth_device_sessions(device_id, updated_at DESC);
+
+    CREATE TABLE IF NOT EXISTS auth_login_events (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      device_id TEXT,
+      client_type TEXT NOT NULL CHECK (client_type IN ('desktop', 'web', 'ios', 'android', 'unknown')),
+      source_address TEXT,
+      occurred_at TEXT NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES auth_users(id),
+      FOREIGN KEY (device_id) REFERENCES auth_devices(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_auth_login_events_user_id
+      ON auth_login_events(user_id, occurred_at DESC);
+  `);
+    const authDeviceColumns = db
+        .prepare("PRAGMA table_info(auth_devices)")
+        .all();
+    if (!authDeviceColumns.some((column) => column.name === "user_agent")) {
+        db.exec("ALTER TABLE auth_devices ADD COLUMN user_agent TEXT");
+    }
+}
 function ensureAuthLoginAttemptSchema(db) {
     const columns = db
         .prepare("PRAGMA table_info(auth_login_attempts)")
@@ -197,10 +297,99 @@ function ensureUserPreferenceProfileSchema(db) {
     const columns = db
         .prepare("PRAGMA table_info(user_preference_profiles)")
         .all();
-    if (columns.length === 0 || columns.some((column) => column.name === "auto_theme")) {
+    if (columns.length === 0) {
         return;
     }
-    db.exec("ALTER TABLE user_preference_profiles ADD COLUMN auto_theme INTEGER NOT NULL DEFAULT 0 CHECK (auto_theme IN (0, 1))");
+    const columnNames = new Set(columns.map((column) => column.name));
+    if (!columnNames.has("auto_theme")) {
+        db.exec("ALTER TABLE user_preference_profiles ADD COLUMN auto_theme INTEGER NOT NULL DEFAULT 0 CHECK (auto_theme IN (0, 1))");
+    }
+    if (!columnNames.has("debug_port_pools_json")) {
+        db.exec(`ALTER TABLE user_preference_profiles
+      ADD COLUMN debug_port_pools_json TEXT NOT NULL DEFAULT '{"start":43000,"end":47999}'`);
+    }
+}
+function ensureManagedSkillScopeSchema(db) {
+    if (!tableExists(db, "managed_skills")) {
+        return;
+    }
+    const columns = db
+        .prepare("PRAGMA table_info(managed_skills)")
+        .all();
+    const columnNames = new Set(columns.map((column) => column.name));
+    const tableSqlRow = db
+        .prepare(`SELECT sql
+       FROM sqlite_master
+       WHERE type = 'table'
+         AND name = 'managed_skills'`)
+        .get();
+    const tableSql = tableSqlRow?.sql ?? "";
+    const needsRebuild = !columnNames.has("scope")
+        || tableSql.includes("directory_name TEXT NOT NULL UNIQUE")
+        || !tableSql.includes("UNIQUE(scope, directory_name)");
+    if (!needsRebuild) {
+        return;
+    }
+    db.exec("DROP INDEX IF EXISTS idx_managed_skills_state");
+    db.exec("PRAGMA foreign_keys = OFF");
+    try {
+        db.exec("BEGIN");
+        db.exec(`
+      CREATE TABLE managed_skills__next (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        scope TEXT NOT NULL CHECK (scope IN ('workspace', 'assistant')),
+        directory_name TEXT NOT NULL,
+        source_type TEXT NOT NULL CHECK (source_type IN ('builtin', 'local-import', 'managed-copy')),
+        source_path TEXT,
+        content_hash TEXT NOT NULL,
+        managed_state TEXT NOT NULL CHECK (managed_state IN ('active', 'conflicted', 'missing')),
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(scope, directory_name)
+      );
+    `);
+        db.exec(`
+      INSERT INTO managed_skills__next (
+        id,
+        name,
+        scope,
+        directory_name,
+        source_type,
+        source_path,
+        content_hash,
+        managed_state,
+        created_at,
+        updated_at
+      )
+      SELECT
+        id,
+        name,
+        'workspace',
+        directory_name,
+        source_type,
+        source_path,
+        content_hash,
+        managed_state,
+        created_at,
+        updated_at
+      FROM managed_skills;
+    `);
+        db.exec("DROP TABLE managed_skills");
+        db.exec("ALTER TABLE managed_skills__next RENAME TO managed_skills");
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+    finally {
+        db.exec("PRAGMA foreign_keys = ON");
+    }
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_managed_skills_state
+      ON managed_skills(scope, managed_state, updated_at DESC);
+  `);
 }
 function ensureButlerControlSessionSchema(db) {
     const columns = db
@@ -219,6 +408,306 @@ function ensureButlerControlSessionSchema(db) {
     if (!columnNames.has("source_item_id")) {
         db.exec("ALTER TABLE butler_control_sessions ADD COLUMN source_item_id TEXT");
     }
+    if (!columnNames.has("model")) {
+        db.exec("ALTER TABLE butler_control_sessions ADD COLUMN model TEXT");
+    }
+    if (!columnNames.has("reasoning_level")) {
+        db.exec("ALTER TABLE butler_control_sessions ADD COLUMN reasoning_level TEXT");
+    }
+    if (!columnNames.has("permission_mode")) {
+        db.exec("ALTER TABLE butler_control_sessions ADD COLUMN permission_mode TEXT");
+    }
+}
+function ensureButlerControlTimerSchema(db) {
+    const columns = db
+        .prepare("PRAGMA table_info(butler_control_timers)")
+        .all();
+    if (columns.length > 0) {
+        return;
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS butler_control_timers (
+      id TEXT PRIMARY KEY,
+      control_session_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      project_id TEXT,
+      target_session_id TEXT,
+      title TEXT,
+      content TEXT NOT NULL,
+      due_at TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('active', 'completed', 'cancelled', 'failed')),
+      triggered_at TEXT,
+      last_error TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      cancelled_at TEXT,
+      FOREIGN KEY (control_session_id) REFERENCES butler_control_sessions(id) ON DELETE CASCADE,
+      FOREIGN KEY (session_id) REFERENCES session_bindings(session_id) ON DELETE CASCADE,
+      FOREIGN KEY (user_id) REFERENCES auth_users(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_butler_control_timers_status_due_at
+      ON butler_control_timers(status, due_at ASC, updated_at ASC);
+    CREATE INDEX IF NOT EXISTS idx_butler_control_timers_session
+      ON butler_control_timers(control_session_id, status, updated_at DESC);
+  `);
+}
+function ensureAssistantAutomationSchema(db) {
+    const taskColumns = db
+        .prepare("PRAGMA table_info(assistant_automation_tasks)")
+        .all();
+    const runColumns = db
+        .prepare("PRAGMA table_info(assistant_automation_runs)")
+        .all();
+    if (taskColumns.length > 0 && runColumns.length > 0) {
+        return;
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS assistant_automation_tasks (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      control_session_id TEXT NOT NULL,
+      project_id TEXT,
+      title TEXT,
+      trigger_type TEXT NOT NULL CHECK (trigger_type IN ('once', 'interval', 'cron', 'condition')),
+      trigger_config_json TEXT NOT NULL,
+      action_type TEXT NOT NULL CHECK (action_type IN ('send_control_message')),
+      action_config_json TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('active', 'paused', 'completed', 'cancelled', 'failed')),
+      next_run_at TEXT,
+      last_run_at TEXT,
+      last_run_summary TEXT,
+      last_error TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      cancelled_at TEXT,
+      FOREIGN KEY (control_session_id) REFERENCES butler_control_sessions(id) ON DELETE CASCADE,
+      FOREIGN KEY (user_id) REFERENCES auth_users(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_assistant_automation_tasks_status_next_run_at
+      ON assistant_automation_tasks(status, next_run_at ASC, updated_at ASC);
+    CREATE INDEX IF NOT EXISTS idx_assistant_automation_tasks_session
+      ON assistant_automation_tasks(control_session_id, status, updated_at DESC);
+
+    CREATE TABLE IF NOT EXISTS assistant_automation_runs (
+      id TEXT PRIMARY KEY,
+      automation_id TEXT NOT NULL,
+      run_seq INTEGER NOT NULL,
+      trigger_type TEXT NOT NULL CHECK (trigger_type IN ('once', 'interval', 'cron', 'condition')),
+      trigger_snapshot_json TEXT NOT NULL,
+      action_type TEXT NOT NULL CHECK (action_type IN ('send_control_message')),
+      action_snapshot_json TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled', 'skipped')),
+      summary TEXT,
+      error TEXT,
+      scheduled_at TEXT NOT NULL,
+      started_at TEXT,
+      finished_at TEXT,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (automation_id) REFERENCES assistant_automation_tasks(id) ON DELETE CASCADE
+    );
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_assistant_automation_runs_seq
+      ON assistant_automation_runs(automation_id, run_seq);
+    CREATE INDEX IF NOT EXISTS idx_assistant_automation_runs_created_at
+      ON assistant_automation_runs(automation_id, created_at DESC);
+  `);
+}
+function ensureAssistantSandboxSchema(db) {
+    const columns = db
+        .prepare("PRAGMA table_info(assistant_sandboxes)")
+        .all();
+    if (columns.length > 0) {
+        const columnNames = new Set(columns.map((column) => column.name));
+        const tableSql = db
+            .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'assistant_sandboxes'")
+            .get()?.sql ?? "";
+        const needsStatusConstraintRebuild = !tableSql.includes("'orphaned'");
+        if (needsStatusConstraintRebuild) {
+            const hasControlSessionId = columnNames.has("control_session_id");
+            const rebuild = db.transaction(() => {
+                db.exec("ALTER TABLE assistant_sandboxes RENAME TO assistant_sandboxes_legacy");
+                db.exec(`
+          CREATE TABLE assistant_sandboxes (
+            id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            workspace_id TEXT NOT NULL UNIQUE,
+            control_session_id TEXT,
+            title TEXT NOT NULL,
+            description TEXT,
+            source_kind TEXT NOT NULL CHECK (source_kind IN ('blank', 'clone')),
+            source_ref TEXT,
+            visibility TEXT NOT NULL CHECK (visibility IN ('assistant_only', 'pinned')),
+            status TEXT NOT NULL CHECK (status IN ('active', 'archived', 'expired', 'orphaned', 'deleted')),
+            purpose TEXT,
+            expires_at TEXT,
+            promoted_at TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            FOREIGN KEY (user_id) REFERENCES auth_users(id) ON DELETE CASCADE,
+            FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE,
+            FOREIGN KEY (control_session_id) REFERENCES butler_control_sessions(id) ON DELETE SET NULL
+          );
+        `);
+                db.exec(`
+          INSERT INTO assistant_sandboxes (
+            id,
+            user_id,
+            workspace_id,
+            control_session_id,
+            title,
+            description,
+            source_kind,
+            source_ref,
+            visibility,
+            status,
+            purpose,
+            expires_at,
+            promoted_at,
+            created_at,
+            updated_at
+          )
+          SELECT
+            id,
+            user_id,
+            workspace_id,
+            ${hasControlSessionId ? "control_session_id" : "NULL"},
+            title,
+            description,
+            source_kind,
+            source_ref,
+            visibility,
+            status,
+            purpose,
+            expires_at,
+            promoted_at,
+            created_at,
+            updated_at
+          FROM assistant_sandboxes_legacy;
+        `);
+                db.exec("DROP TABLE assistant_sandboxes_legacy");
+            });
+            rebuild();
+        }
+        else if (!columnNames.has("control_session_id")) {
+            db.exec("ALTER TABLE assistant_sandboxes ADD COLUMN control_session_id TEXT");
+        }
+        db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_assistant_sandboxes_user_status
+        ON assistant_sandboxes(user_id, status, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_assistant_sandboxes_workspace
+        ON assistant_sandboxes(workspace_id, status, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_assistant_sandboxes_control_session
+        ON assistant_sandboxes(control_session_id, status, updated_at DESC);
+    `);
+        return;
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS assistant_sandboxes (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      workspace_id TEXT NOT NULL UNIQUE,
+      control_session_id TEXT,
+      title TEXT NOT NULL,
+      description TEXT,
+      source_kind TEXT NOT NULL CHECK (source_kind IN ('blank', 'clone')),
+      source_ref TEXT,
+      visibility TEXT NOT NULL CHECK (visibility IN ('assistant_only', 'pinned')),
+      status TEXT NOT NULL CHECK (status IN ('active', 'archived', 'expired', 'orphaned', 'deleted')),
+      purpose TEXT,
+      expires_at TEXT,
+      promoted_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES auth_users(id) ON DELETE CASCADE,
+      FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE,
+      FOREIGN KEY (control_session_id) REFERENCES butler_control_sessions(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_assistant_sandboxes_user_status
+      ON assistant_sandboxes(user_id, status, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_assistant_sandboxes_workspace
+      ON assistant_sandboxes(workspace_id, status, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_assistant_sandboxes_control_session
+      ON assistant_sandboxes(control_session_id, status, updated_at DESC);
+  `);
+}
+function ensureVerificationRunSchema(db) {
+    const verificationRunSql = readTableSql(db, "verification_runs");
+    if (!verificationRunSql.includes("status IN ('queued', 'running', 'passed', 'failed', 'skipped')")) {
+        return;
+    }
+    db.exec(`
+    PRAGMA foreign_keys = OFF;
+
+    CREATE TABLE verification_runs_next (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      butler_session_id TEXT,
+      source_patrol_run_id TEXT,
+      verification_type TEXT NOT NULL CHECK (
+        verification_type IN ('test', 'health', 'browser', 'visual', 'metric')
+      ),
+      status TEXT NOT NULL CHECK (
+        status IN ('queued', 'running', 'passed', 'failed', 'skipped', 'cancelled')
+      ),
+      target_ref TEXT,
+      spec_json TEXT NOT NULL,
+      artifact_refs_json TEXT NOT NULL,
+      result_json TEXT NOT NULL,
+      summary TEXT,
+      started_at TEXT,
+      finished_at TEXT,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (project_id) REFERENCES butler_projects(id) ON DELETE CASCADE,
+      FOREIGN KEY (butler_session_id) REFERENCES butler_sessions(id)
+    );
+
+    INSERT INTO verification_runs_next (
+      id,
+      project_id,
+      butler_session_id,
+      source_patrol_run_id,
+      verification_type,
+      status,
+      target_ref,
+      spec_json,
+      artifact_refs_json,
+      result_json,
+      summary,
+      started_at,
+      finished_at,
+      created_at
+    )
+    SELECT
+      id,
+      project_id,
+      butler_session_id,
+      source_patrol_run_id,
+      verification_type,
+      status,
+      target_ref,
+      spec_json,
+      artifact_refs_json,
+      result_json,
+      summary,
+      started_at,
+      finished_at,
+      created_at
+    FROM verification_runs;
+
+    DROP TABLE verification_runs;
+    ALTER TABLE verification_runs_next RENAME TO verification_runs;
+
+    CREATE INDEX IF NOT EXISTS idx_verification_runs_project_created_at
+      ON verification_runs(project_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_verification_runs_project_status
+      ON verification_runs(project_id, status, created_at DESC);
+
+    PRAGMA foreign_keys = ON;
+  `);
 }
 function ensureButlerInboxSchema(db) {
     const columns = db
@@ -246,6 +735,15 @@ function ensureButlerFollowUpTaskSchema(db) {
     if (!columnNames.has("rounds_json")) {
         db.exec("ALTER TABLE butler_follow_up_tasks ADD COLUMN rounds_json TEXT NOT NULL DEFAULT '[]'");
     }
+    if (!columnNames.has("provider_id")) {
+        db.exec("ALTER TABLE butler_follow_up_tasks ADD COLUMN provider_id TEXT NOT NULL DEFAULT 'codex'");
+    }
+    if (!columnNames.has("assistant_butler_session_id")) {
+        db.exec("ALTER TABLE butler_follow_up_tasks ADD COLUMN assistant_butler_session_id TEXT NOT NULL DEFAULT ''");
+    }
+    if (!columnNames.has("assistant_session_id")) {
+        db.exec("ALTER TABLE butler_follow_up_tasks ADD COLUMN assistant_session_id TEXT NOT NULL DEFAULT ''");
+    }
 }
 function ensureButlerSessionSummarySchema(db) {
     const columns = db
@@ -265,6 +763,40 @@ function ensureInstanceTailscaleStatusSchema(db) {
     }
     db.exec("ALTER TABLE instance_tailscale_status ADD COLUMN account_name TEXT");
 }
+function ensureInstanceTailscaleConfigSchema(db) {
+    const columns = db
+        .prepare("PRAGMA table_info(instance_tailscale_config)")
+        .all();
+    if (columns.length === 0 || columns.some((column) => column.name === "activated")) {
+        return;
+    }
+    db.exec("ALTER TABLE instance_tailscale_config ADD COLUMN activated INTEGER NOT NULL DEFAULT 0 CHECK (activated IN (0, 1))");
+    db.exec("UPDATE instance_tailscale_config SET activated = enabled");
+}
+function ensureInstanceRelayTunnelConfigSchema(db) {
+    const columns = db
+        .prepare("PRAGMA table_info(instance_relay_tunnel_config)")
+        .all();
+    if (columns.length === 0) {
+        return;
+    }
+    if (!columns.some((column) => column.name === "activated")) {
+        db.exec("ALTER TABLE instance_relay_tunnel_config ADD COLUMN activated INTEGER NOT NULL DEFAULT 0 CHECK (activated IN (0, 1))");
+        db.exec("UPDATE instance_relay_tunnel_config SET activated = enabled");
+    }
+    if (!columns.some((column) => column.name === "control_access_token_ciphertext")) {
+        db.exec("ALTER TABLE instance_relay_tunnel_config ADD COLUMN control_access_token_ciphertext TEXT");
+    }
+    if (!columns.some((column) => column.name === "control_account_email")) {
+        db.exec("ALTER TABLE instance_relay_tunnel_config ADD COLUMN control_account_email TEXT");
+    }
+    if (!columns.some((column) => column.name === "control_session_expires_at")) {
+        db.exec("ALTER TABLE instance_relay_tunnel_config ADD COLUMN control_session_expires_at TEXT");
+    }
+    if (!columns.some((column) => column.name === "local_target_source")) {
+        db.exec("ALTER TABLE instance_relay_tunnel_config ADD COLUMN local_target_source TEXT NOT NULL DEFAULT 'default' CHECK (local_target_source IN ('default', 'custom'))");
+    }
+}
 function ensureSessionProviderSchema(db) {
     const bindingSql = readTableSql(db, "session_bindings");
     const indexSql = readTableSql(db, "session_indices");