devchain-cli 0.23.4 → 0.24.0

package/dist/server/modules/storage/local/delegates/project-replica.delegate.js

@@ -0,0 +1,759 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectReplicaStorageDelegate = void 0;
+const skill_source_switches_1 = require("../helpers/skill-source-switches");
+const skills_settings_delegate_1 = require("../../../settings/local/delegates/skills-settings.delegate");
+const node_crypto_1 = require("node:crypto");
+const shared_1 = require("@devchain/shared");
+const error_types_1 = require("../../../../common/errors/error-types");
+const logger_1 = require("../../../../common/logging/logger");
+const storage_helpers_1 = require("../helpers/storage-helpers");
+const base_storage_delegate_1 = require("./base-storage.delegate");
+const logger = (0, logger_1.createLogger)('ProjectReplicaStorageDelegate');
+class ProjectReplicaStorageDelegate extends base_storage_delegate_1.BaseStorageDelegate {
+    dependencies;
+    constructor(context, dependencies) {
+        super(context);
+        this.dependencies = dependencies;
+    }
+    async applyProjectReplica(replica, mode, eventFactory, options = {}) {
+        const parsed = shared_1.ProjectReplicaV1Schema.safeParse(replica);
+        if (!parsed.success) {
+            const issue = parsed.error.issues[0];
+            throw new error_types_1.ReplicaApplyError('payload', issue?.path.join('.') ?? '', 'invalid payload');
+        }
+        return this.txRunner.runImmediateQueued(() => {
+            if (options.requireNewProjects)
+                this.assertProjectsAreNew(parsed.data);
+            const summaries = new ReplicaApplyRun(this.rawClient, parsed.data, mode, options).execute();
+            for (const summary of summaries) {
+                this.dependencies.appendEvent(eventFactory(summary));
+            }
+            logger.info({
+                mode,
+                scope: parsed.data.scope,
+                projects: summaries.map(({ projectId, changedEpicIds, deletedEpicIds }) => ({
+                    projectId,
+                    changed: changedEpicIds.length,
+                    deleted: deletedEpicIds.length,
+                })),
+            }, 'Applied project replica');
+            return summaries;
+        });
+    }
+    assertProjectsAreNew(replica) {
+        for (const { id } of replica.tables.projects) {
+            if (this.rawClient.prepare('SELECT 1 FROM projects WHERE id = ?').get(id)) {
+                throw new error_types_1.ConflictError('Project already exists on this instance.', {
+                    code: 'PROJECT_EXISTS',
+                    projectId: id,
+                });
+            }
+        }
+    }
+}
+exports.ProjectReplicaStorageDelegate = ProjectReplicaStorageDelegate;
+class ReplicaApplyRun {
+    db;
+    replica;
+    tables;
+    projectIds;
+    full;
+    now = new Date().toISOString();
+    statements = new Map();
+    providerIdMap = new Map();
+    changedEpicIds = new Set();
+    skippedUnknownSkillCountByProject = new Map();
+    resolvedTagIds = new Set();
+    idSets;
+    keepInstanceConfig;
+    frozenAt;
+    constructor(db, replica, mode, options) {
+        this.db = db;
+        this.replica = replica;
+        this.idSets = options.idSets;
+        this.keepInstanceConfig = options.keepInstanceConfig === true;
+        this.frozenAt = options.frozenAt;
+        this.tables = replica.tables;
+        this.projectIds = replica.tables.projects.map((project) => project.id);
+        this.full = mode === 'full';
+    }
+    execute() {
+        const t = this.tables;
+        this.checkWorkspaceName();
+        this.mapProviders();
+        this.upsertWorkspace();
+        if (t.paired_device_workspace_grants !== undefined && !this.keepInstanceConfig) {
+            this.applyWorkspaceGrants(t.paired_device_workspace_grants, t.authorityKids ?? []);
+        }
+        this.upsertAll('projects', t.projects);
+        if (this.frozenAt)
+            this.freezeProjects(this.frozenAt);
+        this.applyStatuses();
+        this.upsertAll('tags', t.tags);
+        if (t.prompts) {
+            this.upsertAll('prompts', t.prompts);
+            this.reconcileJunction('prompt_tags', 'prompt_id', 'tag_id', t.prompts, t.prompt_tags ?? []);
+        }
+        this.applyProfiles();
+        this.applyProviderConfigs();
+        this.applyAgents();
+        if (t.teams)
+            this.applyTeams();
+        if (t.terminal_watchers) {
+            this.upsertAll('terminal_watchers', t.terminal_watchers.map((row) => this.mapWatcher(row)));
+        }
+        this.upsertAll('automation_subscribers', t.automation_subscribers);
+        if (t.project_settings)
+            this.applySettings(t.project_settings);
+        if (t.instance_settings && !this.keepInstanceConfig)
+            this.applyInstanceSettings(t.instance_settings);
+        if (!this.keepInstanceConfig)
+            this.applyInstanceProviderConfig();
+        if (t.project_provider_plugin_overrides)
+            this.applyProjectPluginOverrides(t.project_provider_plugin_overrides);
+        this.applyEpics();
+        this.applyEpicTags();
+        this.upsertAll('epic_comments', t.epic_comments, (row) => this.changedEpicIds.add(row.epic_id));
+        this.applyRelations();
+        this.upsertAll('scheduled_epics', t.scheduled_epics);
+        if (t.reviews)
+            this.applyReviews();
+        if (t.skill_project_disabled && t.sender_skill_slugs) {
+            this.applySkillProjectDisabled(t.skill_project_disabled, t.sender_skill_slugs);
+        }
+        if (t.source_project_enabled)
+            this.applySourceProjectEnabled(t.source_project_enabled);
+        this.upsertAll('epic_time_segments', t.epic_time_segments);
+        if (t.sessions)
+            this.applySessions(t.sessions);
+        this.upsertAll('epic_time_session_watermarks', t.epic_time_session_watermarks, undefined, [
+            'session_id',
+        ]);
+        const deletedEpicIds = this.deleteMissing();
+        const epicProject = new Map(t.epics.map((epic) => [epic.id, epic.project_id]));
+        return this.projectIds.map((projectId) => {
+            return {
+                projectId,
+                changedEpicIds: [...this.changedEpicIds]
+                    .filter((id) => epicProject.get(id) === projectId)
+                    .sort(),
+                deletedEpicIds: deletedEpicIds
+                    .filter((row) => row.project_id === projectId)
+                    .map((row) => row.id)
+                    .sort(),
+                skippedUnknownSkillCount: this.skippedUnknownSkillCountByProject.get(projectId) ?? 0,
+            };
+        });
+    }
+    freezeProjects(frozenAt) {
+        for (const projectId of this.projectIds) {
+            this.write('projects', projectId, () => this.run('UPDATE projects SET frozen_at = ? WHERE id = ?', frozenAt, projectId));
+        }
+    }
+    applyWorkspaceGrants(rows, authorityKids) {
+        const workspaceId = this.replica.workspace.id;
+        this.write('paired_device_workspace_grants', workspaceId, () => {
+            let changed = 0;
+            const incoming = new Set(rows.map((row) => row.device_kid));
+            const remove = this.db.prepare('DELETE FROM paired_device_workspace_grants WHERE device_kid = ? AND workspace_id = ?');
+            for (const kid of authorityKids) {
+                if (!incoming.has(kid))
+                    changed += remove.run(kid, workspaceId).changes;
+            }
+            const insert = this.db.prepare('INSERT INTO paired_device_workspace_grants (device_kid, workspace_id) VALUES (?, ?) ON CONFLICT DO NOTHING');
+            for (const row of rows)
+                changed += insert.run(row.device_kid, workspaceId).changes;
+            return changed;
+        });
+    }
+    checkWorkspaceName() {
+        const { id, name } = this.replica.workspace;
+        const clash = this.get('SELECT id FROM project_workspaces WHERE lower(name) = lower(?) AND id != ?', name, id);
+        if (clash) {
+            throw new error_types_1.ReplicaApplyError('project_workspaces', id, `workspace name is already used by workspace ${clash.id}`);
+        }
+    }
+    mapProviders() {
+        for (const provider of this.tables.providers ?? []) {
+            const target = this.get('SELECT id FROM providers WHERE name = ?', provider.name);
+            if (!target) {
+                throw new error_types_1.ReplicaApplyError('providers', provider.id, `provider "${provider.name}" is not installed`);
+            }
+            this.providerIdMap.set(provider.id, target.id);
+        }
+    }
+    upsertWorkspace() {
+        const { id, name } = this.replica.workspace;
+        this.write('project_workspaces', id, () => this.run(`INSERT INTO project_workspaces (id, name, is_default, position, created_at, updated_at)
+         VALUES (?, ?, 0, (SELECT COALESCE(MAX(position) + 1, 0) FROM project_workspaces), ?, ?)
+         ON CONFLICT(id) DO UPDATE SET name = excluded.name, updated_at = excluded.updated_at
+         WHERE project_workspaces.name IS NOT excluded.name`, id, name, this.now, this.now));
+    }
+    applyStatuses() {
+        this.inProjects('UPDATE statuses SET position = -rowid - 1 WHERE project_id IN');
+        this.upsertAll('statuses', this.tables.statuses);
+    }
+    applyProfiles() {
+        this.inProjects('UPDATE agent_profiles SET name = name || char(0) || id, family_slug = NULL WHERE project_id IN');
+        const profiles = this.tables.agent_profiles ?? [];
+        this.upsertAll('agent_profiles', profiles);
+        if (this.tables.agent_profile_prompts) {
+            this.reconcileJunction('agent_profile_prompts', 'profile_id', 'prompt_id', profiles, this.tables.agent_profile_prompts);
+        }
+    }
+    applyProviderConfigs() {
+        const configs = this.tables.profile_provider_configs ?? [];
+        const payloadIds = configs.map((config) => config.id);
+        const park = 'UPDATE profile_provider_configs SET position = -rowid - 1, name = name || char(0) || id WHERE ';
+        this.inIds(`${park}id IN`, payloadIds);
+        this.inProjects(`${park}profile_id IN (SELECT id FROM agent_profiles WHERE project_id IN`, ')');
+        this.upsertAll('profile_provider_configs', configs.map((config) => ({ ...config, provider_id: this.targetProviderId(config) })));
+    }
+    applyAgents() {
+        this.inProjects('UPDATE agents SET is_project_owner = 0 WHERE project_id IN');
+        this.upsertAll('agents', this.tables.agents);
+    }
+    applyTeams() {
+        const teams = this.tables.teams ?? [];
+        this.inProjects('UPDATE teams SET name = name || char(0) || id WHERE project_id IN');
+        this.upsertAll('teams', teams);
+        const teamIds = new Set(teams.map((team) => team.id));
+        const configs = this.tables.team_profile_configs ?? [];
+        const keep = new Set(configs.map((row) => `${row.team_id}|${row.profile_id}|${row.provider_config_id}`));
+        for (const row of this.inIdsAll('SELECT team_id, profile_id, provider_config_id FROM team_profile_configs WHERE team_id IN', [...teamIds])) {
+            if (!keep.has(`${row.team_id}|${row.profile_id}|${row.provider_config_id}`)) {
+                this.write('team_profile_configs', row.team_id, () => this.run('DELETE FROM team_profile_configs WHERE team_id = ? AND profile_id = ? AND provider_config_id = ?', row.team_id, row.profile_id, row.provider_config_id));
+            }
+        }
+        this.reconcileTeamPairs('team_profiles', 'profile_id', teamIds, this.tables.team_profiles ?? []);
+        this.reconcileTeamPairs('team_members', 'agent_id', teamIds, this.tables.team_members ?? []);
+        this.upsertAll('team_profile_configs', configs, undefined, [
+            'team_id',
+            'profile_id',
+            'provider_config_id',
+        ]);
+    }
+    reconcileTeamPairs(table, column, teamIds, rows) {
+        const keep = new Set(rows.map((row) => `${row.team_id}|${row[column]}`));
+        for (const row of this.inIdsAll(`SELECT team_id, ${column} FROM ${table} WHERE team_id IN`, [...teamIds])) {
+            const other = String(row[column]);
+            if (!keep.has(`${row.team_id}|${other}`)) {
+                this.write(table, row.team_id, () => this.run(`DELETE FROM ${table} WHERE team_id = ? AND ${column} = ?`, row.team_id, other));
+            }
+        }
+        this.upsertAll(table, rows, undefined, ['team_id', column]);
+    }
+    mapWatcher(row) {
+        if (row.scope !== 'provider' || !row.scope_filter_id)
+            return row;
+        return {
+            ...row,
+            scope_filter_id: this.providerIdMap.get(row.scope_filter_id) ?? row.scope_filter_id,
+        };
+    }
+    applySettings(entries) {
+        for (const key of shared_1.PROJECT_REPLICA_SETTING_KEYS) {
+            const row = this.get('SELECT value FROM settings WHERE key = ?', key);
+            let map = {};
+            if (row) {
+                const parsed = parseJsonObject(row.value);
+                if (!parsed)
+                    throw new error_types_1.ReplicaApplyError('settings', key, 'stored value is not a JSON object');
+                map = parsed;
+            }
+            const next = { ...map };
+            for (const projectId of this.projectIds) {
+                const entry = entries.find((item) => item.project_id === projectId && item.key === key);
+                if (entry)
+                    next[projectId] = entry.value;
+                else
+                    delete next[projectId];
+            }
+            const encoded = JSON.stringify(next);
+            const unchanged = row ? encoded === JSON.stringify(map) : Object.keys(next).length === 0;
+            if (unchanged)
+                continue;
+            this.write('settings', key, () => this.run(`INSERT INTO settings (id, key, value, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`, (0, node_crypto_1.randomUUID)(), key, encoded, this.now, this.now));
+        }
+    }
+    applyInstanceSettings(settings) {
+        const entries = [
+            ['messagePool.enabled', String(settings.messagePool.enabled)],
+            ['messagePool.delayMs', String(settings.messagePool.delayMs)],
+            ['messagePool.maxWaitMs', String(settings.messagePool.maxWaitMs)],
+            ['messagePool.maxMessages', String(settings.messagePool.maxMessages)],
+            ['messagePool.separator', JSON.stringify(settings.messagePool.separator)],
+            ['events.epicAssigned.template', JSON.stringify(settings.eventsEpicAssignedTemplate)],
+            [
+                'skills.sources',
+                JSON.stringify((0, skill_source_switches_1.mergeSourceSwitches)(settings.skillsSources, new skills_settings_delegate_1.SkillsSettingsDelegate({ sqlite: this.db }).getStoredSkillSourcesEnabled())),
+            ],
+            ['activity.idleTimeoutMs', String(settings.activityIdleTimeoutMs)],
+            ['terminal.scrollback.lines', String(settings.terminal.scrollbackLines)],
+            ['terminal.seeding.maxBytes', String(settings.terminal.seedingMaxBytes)],
+            ['terminal.inputMode', settings.terminal.inputMode],
+            ['terminal.suppressCtrlCWithSelection', String(settings.terminal.suppressCtrlCWithSelection)],
+            ['skills.syncOnStartup', String(settings.skillsSyncOnStartup)],
+            ['messaging.followNote', String(settings.messagingFollowNote)],
+        ];
+        for (const [key, value] of entries) {
+            const row = this.get('SELECT value FROM settings WHERE key = ?', key);
+            if (row?.value === value)
+                continue;
+            this.write('settings', key, () => this.run(`INSERT INTO settings (id, key, value, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`, (0, node_crypto_1.randomUUID)(), key, value, this.now, this.now));
+        }
+    }
+    applySkillProjectDisabled(entries, senderSkillSlugs) {
+        const keep = new Set();
+        const senderSkills = new Set(senderSkillSlugs);
+        for (const entry of entries) {
+            const skill = this.get('SELECT id FROM skills WHERE slug = ?', entry.skill_slug);
+            if (!skill) {
+                this.skippedUnknownSkillCountByProject.set(entry.project_id, (this.skippedUnknownSkillCountByProject.get(entry.project_id) ?? 0) + 1);
+                continue;
+            }
+            keep.add(`${entry.project_id}\0${skill.id}`);
+            const id = this.localSwitchId('skill_project_disabled', entry.project_id, 'skill_id', skill.id, entry.id);
+            this.upsertAll('skill_project_disabled', [{ id, project_id: entry.project_id, skill_id: skill.id, created_at: entry.created_at }], undefined, ['project_id', 'skill_id']);
+        }
+        for (const row of this.inProjectsAll(`SELECT disabled.id, disabled.project_id, disabled.skill_id, skill.slug AS skill_slug
+        FROM skill_project_disabled disabled
+        JOIN skills skill ON skill.id = disabled.skill_id
+        WHERE project_id IN`)) {
+            if (senderSkills.has(row.skill_slug) && !keep.has(`${row.project_id}\0${row.skill_id}`)) {
+                this.write('skill_project_disabled', row.id, () => this.run('DELETE FROM skill_project_disabled WHERE id = ?', row.id));
+            }
+        }
+    }
+    applySourceProjectEnabled(entries) {
+        const keep = new Set();
+        for (const entry of entries) {
+            keep.add(`${entry.project_id}\0${entry.source_name}`);
+            const id = this.localSwitchId('source_project_enabled', entry.project_id, 'source_name', entry.source_name, entry.id);
+            this.upsertAll('source_project_enabled', [{ ...entry, id }], undefined, [
+                'project_id',
+                'source_name',
+            ]);
+        }
+        for (const row of this.inProjectsAll('SELECT id, project_id, source_name FROM source_project_enabled WHERE project_id IN')) {
+            if (!keep.has(`${row.project_id}\0${row.source_name}`)) {
+                this.write('source_project_enabled', row.id, () => this.run('DELETE FROM source_project_enabled WHERE id = ?', row.id));
+            }
+        }
+    }
+    localSwitchId(table, projectId, keyColumn, keyValue, replicaId) {
+        const existing = this.get(`SELECT id FROM ${table} WHERE project_id = ? AND ${keyColumn} = ?`, projectId, keyValue);
+        if (existing)
+            return existing.id;
+        return this.get(`SELECT id FROM ${table} WHERE id = ?`, replicaId)
+            ? (0, node_crypto_1.randomUUID)()
+            : replicaId;
+    }
+    reconcileProviderEnv(rows) {
+        const vmProjectIds = new Set(this.all('SELECT id FROM projects').map((row) => row.id));
+        for (const row of rows) {
+            const provider = this.providerIdByName(row.providerName);
+            const env = Object.create(null);
+            const retainedScopes = new Map();
+            for (const [key, value] of Object.entries(row.env ?? {})) {
+                const homeScopes = Object.hasOwn(row.envScopes, key) ? row.envScopes[key] : [];
+                const scopes = new Set(homeScopes.filter((id) => vmProjectIds.has(id)));
+                if (homeScopes.length > 0 && scopes.size === 0)
+                    continue;
+                env[key] = value;
+                retainedScopes.set(key, scopes);
+                for (const projectId of scopes) {
+                    this.write('provider_env_scopes', `${provider.id}:${key}`, () => this.run('INSERT INTO provider_env_scopes (provider_id, env_key, project_id, created_at) VALUES (?, ?, ?, ?) ON CONFLICT DO NOTHING', provider.id, key, projectId, this.now));
+                }
+            }
+            for (const scope of this.all('SELECT env_key, project_id FROM provider_env_scopes WHERE provider_id = ?', provider.id)) {
+                if (retainedScopes.get(scope.env_key)?.has(scope.project_id))
+                    continue;
+                this.write('provider_env_scopes', `${provider.id}:${scope.env_key}`, () => this.run('DELETE FROM provider_env_scopes WHERE provider_id = ? AND env_key = ? AND project_id = ?', provider.id, scope.env_key, scope.project_id));
+            }
+            const envJson = (0, storage_helpers_1.normalizeEnvForStorage)(env);
+            this.write('providers', provider.id, () => this.run('UPDATE providers SET env = ?, updated_at = ? WHERE id = ? AND env IS NOT ?', envJson, this.now, provider.id, envJson));
+        }
+    }
+    applyInstanceProviderConfig() {
+        if (this.tables.provider_settings) {
+            this.applyProviderSettings(this.tables.provider_settings);
+            this.reconcileProviderEnv(this.tables.provider_settings);
+        }
+        if (this.tables.provider_models) {
+            this.applyProviderCatalog('provider_models', this.tables.provider_models);
+        }
+        if (this.tables.provider_efforts) {
+            this.applyProviderCatalog('provider_efforts', this.tables.provider_efforts);
+        }
+        if (this.tables.provider_plugin_defaults) {
+            this.applyProviderPluginDefaults(this.tables.provider_plugin_defaults);
+        }
+    }
+    applyProviderSettings(rows) {
+        for (const row of rows) {
+            const provider = this.providerIdByName(row.providerName);
+            const current = this.get('SELECT auto_compact_threshold, claude_launch_settings_json FROM providers WHERE id = ?', provider.id);
+            if (!current) {
+                throw new error_types_1.ReplicaApplyError('providers', provider.id, 'provider row is missing');
+            }
+            const invalidLaunch = row.claude_launch_settings_json !== null &&
+                !(0, shared_1.validateClaudeLaunchSettingsJson)(row.claude_launch_settings_json).valid;
+            if (invalidLaunch) {
+                logger.warn({ provider: row.providerName }, 'Skipped invalid Claude launch settings JSON from replica');
+            }
+            const launchToStore = invalidLaunch
+                ? current.claude_launch_settings_json
+                : row.claude_launch_settings_json;
+            if (row.auto_compact_threshold === current.auto_compact_threshold &&
+                launchToStore === current.claude_launch_settings_json) {
+                continue;
+            }
+            this.write('providers', provider.id, () => this.run('UPDATE providers SET auto_compact_threshold = ?, claude_launch_settings_json = ?, updated_at = ? WHERE id = ?', row.auto_compact_threshold, launchToStore, this.now, provider.id));
+        }
+    }
+    applyProviderCatalog(table, rows) {
+        for (const row of rows) {
+            const provider = this.providerIdByName(row.providerName);
+            this.write(table, `${provider.id}:${row.name}`, () => this.run(`INSERT INTO ${table} (id, provider_id, name, position, created_at, updated_at)
+           VALUES (?, ?, ?, (SELECT COALESCE(MAX(position) + 1, 0) FROM ${table} WHERE provider_id = ?), ?, ?)
+           ON CONFLICT DO NOTHING`, (0, node_crypto_1.randomUUID)(), provider.id, row.name, provider.id, row.created_at, this.now));
+        }
+    }
+    applyProviderPluginDefaults(rows) {
+        const byProvider = new Map();
+        for (const provider of this.tables.providers) {
+            const targetId = this.providerIdMap.get(provider.id);
+            if (targetId)
+                byProvider.set(provider.name, { id: targetId, plugins: new Set() });
+        }
+        for (const row of rows) {
+            const entry = byProvider.get(row.providerName);
+            if (!entry) {
+                throw new error_types_1.ReplicaApplyError('provider_plugin_defaults', row.providerName, 'provider is not in the payload');
+            }
+            entry.plugins.add(row.plugin_id);
+            this.upsertAll('provider_plugin_defaults', [
+                {
+                    provider_id: entry.id,
+                    plugin_id: row.plugin_id,
+                    enabled: row.enabled,
+                    created_at: row.created_at,
+                    updated_at: row.updated_at,
+                },
+            ], undefined, ['provider_id', 'plugin_id']);
+        }
+        for (const [providerName, entry] of byProvider) {
+            for (const { plugin_id } of this.all('SELECT plugin_id FROM provider_plugin_defaults WHERE provider_id = ?', entry.id)) {
+                if (!entry.plugins.has(plugin_id)) {
+                    this.write('provider_plugin_defaults', `${providerName}:${plugin_id}`, () => this.run('DELETE FROM provider_plugin_defaults WHERE provider_id = ? AND plugin_id = ?', entry.id, plugin_id));
+                }
+            }
+        }
+    }
+    providerIdByName(providerName) {
+        const provider = this.get('SELECT id FROM providers WHERE name = ?', providerName);
+        if (!provider) {
+            throw new error_types_1.ReplicaApplyError('providers', providerName, 'provider is not installed');
+        }
+        return provider;
+    }
+    applyProjectPluginOverrides(rows) {
+        this.upsertAll('project_provider_plugin_overrides', rows.map((row) => {
+            const target = this.providerIdMap.get(row.provider_id);
+            if (!target) {
+                throw new error_types_1.ReplicaApplyError('project_provider_plugin_overrides', `${row.project_id}:${row.plugin_id}`, 'provider is not in the payload');
+            }
+            return { ...row, provider_id: target };
+        }), undefined, ['project_id', 'provider_id', 'plugin_id']);
+    }
+    applyEpics() {
+        this.upsertAll('epics', parentsFirst(this.tables.epics, 'parent_id'), (row) => this.changedEpicIds.add(row.id));
+    }
+    applyEpicTags() {
+        const payloadTags = this.tables.tags;
+        const wanted = new Map();
+        for (const epic of this.tables.epics)
+            wanted.set(epic.id, new Map());
+        const projectOf = new Map(this.tables.epics.map((epic) => [epic.id, epic.project_id]));
+        for (const entry of this.tables.epic_tags) {
+            const projectId = projectOf.get(entry.epic_id);
+            if (!projectId) {
+                throw new error_types_1.ReplicaApplyError('epic_tags', entry.epic_id, 'epic is not in the payload');
+            }
+            const tagId = this.resolveTagId(entry.tag_name, projectId, payloadTags);
+            wanted.get(entry.epic_id)?.set(tagId, entry.created_at);
+        }
+        for (const [epicId, tags] of wanted) {
+            const existing = this.all('SELECT tag_id FROM epic_tags WHERE epic_id = ?', epicId).map((row) => row.tag_id);
+            let changed = false;
+            for (const tagId of existing) {
+                if (!tags.has(tagId)) {
+                    this.write('epic_tags', epicId, () => this.run('DELETE FROM epic_tags WHERE epic_id = ? AND tag_id = ?', epicId, tagId));
+                    changed = true;
+                }
+            }
+            for (const [tagId, createdAt] of tags) {
+                if (!existing.includes(tagId)) {
+                    this.write('epic_tags', epicId, () => this.run('INSERT INTO epic_tags (epic_id, tag_id, created_at) VALUES (?, ?, ?)', epicId, tagId, createdAt));
+                    changed = true;
+                }
+            }
+            if (changed)
+                this.changedEpicIds.add(epicId);
+        }
+    }
+    resolveTagId(name, projectId, payloadTags) {
+        const fromPayload = payloadTags.find((tag) => tag.name === name && tag.project_id === projectId) ??
+            payloadTags.find((tag) => tag.name === name && tag.project_id === null);
+        const found = fromPayload?.id ??
+            this.get(`SELECT id FROM tags WHERE name = ? AND (project_id = ? OR project_id IS NULL)
+         ORDER BY project_id IS NULL, id LIMIT 1`, name, projectId)?.id;
+        if (found) {
+            this.resolvedTagIds.add(found);
+            return found;
+        }
+        const id = (0, node_crypto_1.randomUUID)();
+        this.write('tags', id, () => this.run('INSERT INTO tags (id, project_id, name, created_at, updated_at) VALUES (?, ?, ?, ?, ?)', id, projectId, name, this.now, this.now));
+        this.resolvedTagIds.add(id);
+        return id;
+    }
+    applyRelations() {
+        for (const relation of this.tables.epic_relations) {
+            const stale = this.get('SELECT id FROM epic_relations WHERE left_epic_id = ? AND right_epic_id = ? AND id != ?', relation.left_epic_id, relation.right_epic_id, relation.id);
+            if (stale) {
+                this.write('epic_relations', stale.id, () => this.run('DELETE FROM epic_relations WHERE id = ?', stale.id));
+            }
+        }
+        this.upsertAll('epic_relations', this.tables.epic_relations);
+    }
+    applyReviews() {
+        this.inProjects("UPDATE reviews SET status = 'closed' WHERE status != 'closed' AND project_id IN");
+        this.upsertAll('reviews', this.tables.reviews);
+        this.upsertAll('review_comments', parentsFirst(this.tables.review_comments ?? [], 'parent_id'));
+    }
+    applySessions(sessions) {
+        const payloadProjects = this.projectIds.map(() => '?').join(', ');
+        this.upsertAll('sessions', sessions.map((session) => {
+            if (session.epic_id) {
+                return this.get('SELECT 1 FROM epics WHERE id = ?', session.epic_id)
+                    ? session
+                    : { ...session, epic_id: null };
+            }
+            const kept = this.get(`SELECT s.epic_id FROM sessions s JOIN epics e ON e.id = s.epic_id
+           WHERE s.id = ? AND e.project_id NOT IN (${payloadProjects})`, session.id, ...this.projectIds);
+            return kept ? { ...session, epic_id: kept.epic_id } : session;
+        }));
+    }
+    deleteMissing() {
+        const t = this.tables;
+        const ids = (rows) => new Set((rows ?? []).map((row) => row.id));
+        const keepOf = (rows, table) => {
+            if (this.full)
+                return ids(rows);
+            if (!this.idSets)
+                return null;
+            return new Set([...this.idSets[table], ...ids(rows)]);
+        };
+        const keepSegments = keepOf(t.epic_time_segments, 'epic_time_segments');
+        if (keepSegments) {
+            this.deleteNotIn('epic_time_segments', `SELECT id FROM epic_time_segments
+         WHERE closed_at IS NOT NULL AND team_batch_id IS NULL AND project_id IN`, keepSegments);
+        }
+        if (t.review_comments) {
+            this.deleteNotIn('review_comments', 'SELECT c.id FROM review_comments c JOIN reviews r ON r.id = c.review_id WHERE r.project_id IN', ids(t.review_comments));
+        }
+        if (t.reviews)
+            this.deleteNotIn('reviews', 'SELECT id FROM reviews WHERE project_id IN', ids(t.reviews));
+        if (t.scheduled_epics) {
+            this.deleteNotIn('scheduled_epics', 'SELECT id FROM scheduled_epics WHERE project_id IN', ids(t.scheduled_epics));
+        }
+        const placeholders = this.projectIds.map(() => '?').join(', ');
+        this.deleteNotIn('epic_relations', `SELECT r.id FROM epic_relations r
+       JOIN epics le ON le.id = r.left_epic_id
+       JOIN epics re ON re.id = r.right_epic_id
+       WHERE le.project_id IN (${placeholders}) AND re.project_id IN`, ids(t.epic_relations), this.projectIds);
+        let deletedEpics = [];
+        const keepComments = keepOf(t.epic_comments, 'epic_comments');
+        const keep = keepOf(t.epics, 'epics');
+        if (keepComments && keep) {
+            this.deleteNotIn('epic_comments', 'SELECT c.id FROM epic_comments c JOIN epics e ON e.id = c.epic_id WHERE e.project_id IN', keepComments);
+            deletedEpics = this.inProjectsAll('SELECT id, project_id FROM epics WHERE project_id IN').filter((row) => !keep.has(row.id));
+            for (const row of deletedEpics) {
+                this.write('epics', row.id, () => this.run('DELETE FROM epics WHERE id = ?', row.id));
+            }
+        }
+        if (t.automation_subscribers) {
+            this.deleteNotIn('automation_subscribers', 'SELECT id FROM automation_subscribers WHERE project_id IN', ids(t.automation_subscribers));
+        }
+        if (t.terminal_watchers) {
+            this.deleteNotIn('terminal_watchers', 'SELECT id FROM terminal_watchers WHERE project_id IN', ids(t.terminal_watchers));
+        }
+        if (t.teams)
+            this.deleteNotIn('teams', 'SELECT id FROM teams WHERE project_id IN', ids(t.teams));
+        if (t.project_provider_plugin_overrides) {
+            this.deleteMissingPluginOverrides(t.project_provider_plugin_overrides);
+        }
+        this.deleteAgents(ids(t.agents));
+        this.deleteNotIn('profile_provider_configs', `SELECT c.id FROM profile_provider_configs c
+       JOIN agent_profiles p ON p.id = c.profile_id WHERE p.project_id IN`, ids(t.profile_provider_configs));
+        this.deleteNotIn('agent_profiles', 'SELECT id FROM agent_profiles WHERE project_id IN', ids(t.agent_profiles));
+        if (t.prompts)
+            this.deleteNotIn('prompts', 'SELECT id FROM prompts WHERE project_id IN', ids(t.prompts));
+        this.deleteNotIn('tags', 'SELECT id FROM tags WHERE project_id IN', new Set([...ids(t.tags), ...this.resolvedTagIds]));
+        this.deleteNotIn('statuses', 'SELECT id FROM statuses WHERE project_id IN', ids(t.statuses));
+        return deletedEpics;
+    }
+    deleteMissingPluginOverrides(rows) {
+        const keep = new Set(rows.map((row) => `${row.project_id}|${this.providerIdMap.get(row.provider_id) ?? row.provider_id}|${row.plugin_id}`));
+        for (const row of this.inProjectsAll('SELECT project_id, provider_id, plugin_id FROM project_provider_plugin_overrides WHERE project_id IN')) {
+            if (keep.has(`${row.project_id}|${row.provider_id}|${row.plugin_id}`))
+                continue;
+            this.write('project_provider_plugin_overrides', `${row.project_id}:${row.provider_id}:${row.plugin_id}`, () => this.run('DELETE FROM project_provider_plugin_overrides WHERE project_id = ? AND provider_id = ? AND plugin_id = ?', row.project_id, row.provider_id, row.plugin_id));
+        }
+    }
+    deleteAgents(keep) {
+        const gone = this.inProjectsAll('SELECT id FROM agents WHERE project_id IN')
+            .map((row) => row.id)
+            .filter((id) => !keep.has(id));
+        for (const agentId of gone) {
+            this.write('sessions', agentId, () => this.run('DELETE FROM sessions WHERE agent_id = ?', agentId));
+            this.write('agents', agentId, () => this.run('DELETE FROM agents WHERE id = ?', agentId));
+        }
+    }
+    deleteNotIn(table, select, keep, leadingParams = []) {
+        const rows = this.all(`${select} (${this.projectIds.map(() => '?').join(', ')})`, ...leadingParams, ...this.projectIds);
+        for (const { id } of rows) {
+            if (!keep.has(id)) {
+                this.write(table, id, () => this.run(`DELETE FROM ${table} WHERE id = ?`, id));
+            }
+        }
+    }
+    targetProviderId(config) {
+        const target = this.providerIdMap.get(config.provider_id);
+        if (!target) {
+            throw new error_types_1.ReplicaApplyError('profile_provider_configs', config.id, 'provider is not in the payload');
+        }
+        return target;
+    }
+    reconcileJunction(table, parentColumn, childColumn, parents, rows) {
+        const wanted = new Map();
+        for (const parent of parents)
+            wanted.set(parent.id, new Map());
+        for (const row of rows) {
+            wanted.get(String(row[parentColumn]))?.set(String(row[childColumn]), row.created_at);
+        }
+        for (const [parentId, children] of wanted) {
+            const existing = this.all(`SELECT ${childColumn} FROM ${table} WHERE ${parentColumn} = ?`, parentId).map((row) => String(row[childColumn]));
+            for (const childId of existing) {
+                if (!children.has(childId)) {
+                    this.write(table, parentId, () => this.run(`DELETE FROM ${table} WHERE ${parentColumn} = ? AND ${childColumn} = ?`, parentId, childId));
+                }
+            }
+            for (const [childId, createdAt] of children) {
+                if (!existing.includes(childId)) {
+                    this.write(table, parentId, () => this.run(`INSERT INTO ${table} (${parentColumn}, ${childColumn}, created_at) VALUES (?, ?, ?)`, parentId, childId, createdAt));
+                }
+            }
+        }
+    }
+    upsertAll(table, rows, onChange, key = ['id']) {
+        for (const row of rows ?? []) {
+            const columns = Object.keys(row);
+            const update = columns.filter((column) => !key.includes(column));
+            const conflict = update.length
+                ? `DO UPDATE SET ${update.map((c) => `${c} = excluded.${c}`).join(', ')}
+           WHERE (${update.map((c) => `${table}.${c}`).join(', ')}) IS NOT (${update
+                    .map((c) => `excluded.${c}`)
+                    .join(', ')})`
+                : 'DO NOTHING';
+            const sql = `INSERT INTO ${table} (${columns.join(', ')})
+        VALUES (${columns.map(() => '?').join(', ')})
+        ON CONFLICT(${key.join(', ')}) ${conflict}`;
+            const rowId = key.map((column) => String(row[column])).join(':');
+            const changes = this.write(table, rowId, () => this.run(sql, ...columns.map((column) => row[column])));
+            if (changes > 0)
+                onChange?.(row);
+        }
+    }
+    inProjects(sqlPrefix, suffix = '') {
+        this.inIds(sqlPrefix, this.projectIds, suffix);
+    }
+    inIds(sqlPrefix, ids, suffix = '') {
+        if (ids.length === 0)
+            return;
+        this.write(tableOf(sqlPrefix), 'park', () => this.run(`${sqlPrefix} (${ids.map(() => '?').join(', ')})${suffix}`, ...ids));
+    }
+    inProjectsAll(sqlPrefix) {
+        return this.inIdsAll(sqlPrefix, this.projectIds);
+    }
+    inIdsAll(sqlPrefix, ids) {
+        if (ids.length === 0)
+            return [];
+        return this.all(`${sqlPrefix} (${ids.map(() => '?').join(', ')})`, ...ids);
+    }
+    write(table, rowId, fn) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            if (error instanceof error_types_1.ReplicaApplyError)
+                throw error;
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new error_types_1.ReplicaApplyError(table, rowId, reason);
+        }
+    }
+    run(sql, ...params) {
+        return this.statement(sql).run(...params).changes;
+    }
+    get(sql, ...params) {
+        return this.statement(sql).get(...params);
+    }
+    all(sql, ...params) {
+        return this.statement(sql).all(...params);
+    }
+    statement(sql) {
+        let statement = this.statements.get(sql);
+        if (!statement) {
+            statement = this.db.prepare(sql);
+            this.statements.set(sql, statement);
+        }
+        return statement;
+    }
+}
+function parentsFirst(rows, parentKey) {
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    const ordered = [];
+    const state = new Map();
+    const visit = (row) => {
+        if (state.get(row.id))
+            return;
+        state.set(row.id, 'visiting');
+        const parentId = row[parentKey];
+        const parent = typeof parentId === 'string' ? byId.get(parentId) : undefined;
+        if (parent)
+            visit(parent);
+        state.set(row.id, 'done');
+        ordered.push(row);
+    };
+    rows.forEach(visit);
+    return ordered;
+}
+function parseJsonObject(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tableOf(sql) {
+    return /^UPDATE\s+(\w+)/i.exec(sql)?.[1] ?? 'unknown';
+}
+//# sourceMappingURL=project-replica.delegate.js.map