package store import ( "context" "database/sql" "encoding/json" "errors" "fmt" "strings" "time" "github.com/google/uuid" "github.com/jmoiron/sqlx" "go.uber.org/zap" "github.com/kandev/kandev/internal/agent/settings/models" "github.com/kandev/kandev/internal/agent/settings/profileconfig" "github.com/kandev/kandev/internal/common/logger" "github.com/kandev/kandev/internal/db" "github.com/kandev/kandev/internal/db/dialect" ) type sqliteRepository struct { db *sqlx.DB // writer ro *sqlx.DB // reader ownsDB bool log *logger.Logger migrate *db.MigrateLogger } var _ Repository = (*sqliteRepository)(nil) func newSQLiteRepositoryWithDB(writer, reader *sqlx.DB, log *logger.Logger) (*sqliteRepository, error) { return newSQLiteRepository(writer, reader, log, false) } func newSQLiteRepository(writer, reader *sqlx.DB, log *logger.Logger, ownsDB bool) (*sqliteRepository, error) { repo := &sqliteRepository{ db: writer, ro: reader, ownsDB: ownsDB, log: log, migrate: db.NewRequiredMigrateLogger(writer, log), } if err := repo.initSchema(); err != nil { if ownsDB { if closeErr := writer.Close(); closeErr != nil { return nil, fmt.Errorf("failed to close database after schema error: %w", closeErr) } } return nil, fmt.Errorf("failed to initialize schema: %w", err) } return repo, nil } func (r *sqliteRepository) initSchema() error { schema := ` CREATE TABLE IF NOT EXISTS agents ( id TEXT PRIMARY KEY, name TEXT NOT NULL, workspace_id TEXT DEFAULT NULL, supports_mcp INTEGER NOT NULL DEFAULT 0, mcp_config_path TEXT DEFAULT '', created_at TIMESTAMP NOT NULL, updated_at TIMESTAMP NOT NULL ); CREATE TABLE IF NOT EXISTS agent_profiles ( id TEXT PRIMARY KEY, agent_id TEXT NOT NULL, name TEXT NOT NULL, agent_display_name TEXT NOT NULL, model TEXT NOT NULL DEFAULT '', mode TEXT DEFAULT NULL, migrated_from TEXT DEFAULT NULL, auto_approve INTEGER NOT NULL DEFAULT 0, dangerously_skip_permissions INTEGER NOT NULL DEFAULT 0, allow_indexing INTEGER NOT NULL DEFAULT 1, cli_passthrough INTEGER NOT NULL DEFAULT 0, enabled INTEGER NOT NULL DEFAULT 1, user_modified INTEGER NOT NULL DEFAULT 0, plan TEXT DEFAULT '', cli_flags TEXT DEFAULT NULL, env_vars TEXT NOT NULL DEFAULT '[]', created_at TIMESTAMP NOT NULL, updated_at TIMESTAMP NOT NULL, deleted_at TIMESTAMP, workspace_id TEXT NOT NULL DEFAULT '', role TEXT NOT NULL DEFAULT '', icon TEXT NOT NULL DEFAULT '', reports_to TEXT NOT NULL DEFAULT '', skill_ids TEXT NOT NULL DEFAULT '[]', desired_skills TEXT NOT NULL DEFAULT '[]', custom_prompt TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'idle' CHECK (status IN ('idle','working','paused','stopped','pending_approval')), pause_reason TEXT NOT NULL DEFAULT '', working_run_id TEXT NOT NULL DEFAULT '', last_run_finished_at TIMESTAMP, max_concurrent_sessions INTEGER NOT NULL DEFAULT 1, cooldown_sec INTEGER NOT NULL DEFAULT 0, skip_idle_runs INTEGER NOT NULL DEFAULT 0, consecutive_failures INTEGER NOT NULL DEFAULT 0, failure_threshold INTEGER NOT NULL DEFAULT 3, executor_preference TEXT NOT NULL DEFAULT '', budget_monthly_cents INTEGER NOT NULL DEFAULT 0, settings TEXT NOT NULL DEFAULT '{}', permissions TEXT NOT NULL DEFAULT '{}', command_prefix TEXT NOT NULL DEFAULT '', FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE ); CREATE TABLE IF NOT EXISTS agent_profile_mcp_configs ( profile_id TEXT PRIMARY KEY, enabled INTEGER NOT NULL DEFAULT 0, servers_json TEXT NOT NULL DEFAULT '{}', meta_json TEXT NOT NULL DEFAULT '{}', created_at TIMESTAMP NOT NULL, updated_at TIMESTAMP NOT NULL, FOREIGN KEY (profile_id) REFERENCES agent_profiles(id) ON DELETE CASCADE ); CREATE TABLE IF NOT EXISTS dynamic_agent_profiles ( profile_id TEXT PRIMARY KEY, version INTEGER NOT NULL DEFAULT 1, created_at TIMESTAMP NOT NULL, updated_at TIMESTAMP NOT NULL, FOREIGN KEY (profile_id) REFERENCES agent_profiles(id) ON DELETE CASCADE ); CREATE TABLE IF NOT EXISTS dynamic_agent_routes ( dynamic_profile_id TEXT NOT NULL, position INTEGER NOT NULL, execution_profile_id TEXT NOT NULL, enabled INTEGER NOT NULL DEFAULT 1, rules_json TEXT NOT NULL DEFAULT '{}', PRIMARY KEY (dynamic_profile_id, position), FOREIGN KEY (dynamic_profile_id) REFERENCES dynamic_agent_profiles(profile_id) ON DELETE CASCADE, FOREIGN KEY (execution_profile_id) REFERENCES agent_profiles(id) ON DELETE RESTRICT ); DROP INDEX IF EXISTS idx_agents_name; CREATE UNIQUE INDEX IF NOT EXISTS idx_agents_name ON agents(name); CREATE INDEX IF NOT EXISTS idx_agent_profiles_agent_id ON agent_profiles(agent_id); CREATE INDEX IF NOT EXISTS idx_dynamic_agent_routes_execution_profile ON dynamic_agent_routes(execution_profile_id); ` // Note: indexes on new office-enrichment columns (workspace_id, role, // reports_to) are created later in migrateOfficeEnrichmentColumns — // after the columns themselves are added — so legacy databases don't // fail at CREATE INDEX before the ALTER TABLE statements have run. _, err := r.db.Exec(schema) if err != nil { return err } r.migrate.Apply("agents.tui_config", `ALTER TABLE agents ADD COLUMN tui_config TEXT DEFAULT NULL`) r.migrate.Apply("agent_profiles.mode", `ALTER TABLE agent_profiles ADD COLUMN mode TEXT DEFAULT NULL`) r.migrate.Apply("agent_profiles.migrated_from", `ALTER TABLE agent_profiles ADD COLUMN migrated_from TEXT DEFAULT NULL`) // Rows where cli_flags IS NULL are backfilled on first read - see scanAgentProfile. r.migrate.Apply("agent_profiles.cli_flags", `ALTER TABLE agent_profiles ADD COLUMN cli_flags TEXT DEFAULT NULL`) r.migrate.Apply("agent_profiles.env_vars", `ALTER TABLE agent_profiles ADD COLUMN env_vars TEXT NOT NULL DEFAULT '[]'`) // Rows backfill to enabled=1 via the column default; disabling is an // explicit user action through the settings UI. r.migrate.Apply("agent_profiles.enabled", `ALTER TABLE agent_profiles ADD COLUMN enabled INTEGER NOT NULL DEFAULT 1`) // Migration: drop CHECK(model != '') constraint from agent_profiles. // // The ACP-first model means models and modes are populated from the host // utility probe cache at boot. An empty model is valid — it means "use the // agent's default". SQLite does not support ALTER COLUMN or DROP CONSTRAINT, // so we must recreate the table. This is idempotent: we check whether the // old CHECK constraint still exists before doing anything. if err := r.migrateDropModelCheckConstraint(); err != nil { return fmt.Errorf("failed to migrate agent_profiles model constraint: %w", err) } // Migration: ADR 0005 Wave A — enrich agent_profiles with office columns. // Duplicate-column errors are the only replay result tolerated by the // required migration logger. if err := r.migrateOfficeEnrichmentColumns(); err != nil { return fmt.Errorf("failed to migrate agent profile office columns: %w", err) } // command_prefix is added after the table-recreation migration above so a // legacy DB that recreates agent_profiles (to drop the model CHECK) still // ends up with the column — the recreation copies only pre-existing // columns, so an ADD COLUMN that ran before it would be lost. r.migrate.Apply("agent_profiles.command_prefix", `ALTER TABLE agent_profiles ADD COLUMN command_prefix TEXT NOT NULL DEFAULT ''`) // No-silent-model-fallback: added after the table-recreation migration // above for the same reason as command_prefix — a legacy DB that // recreates agent_profiles would otherwise lose columns added before it. r.migrate.Apply("agent_profiles.fallback_model", `ALTER TABLE agent_profiles ADD COLUMN fallback_model TEXT NOT NULL DEFAULT ''`) r.migrate.Apply("agent_profiles.auto_fallback", `ALTER TABLE agent_profiles ADD COLUMN auto_fallback INTEGER NOT NULL DEFAULT 0`) if err := r.migrate.Err(); err != nil { return fmt.Errorf("required agent settings migration: %w", err) } return nil } // migrateOfficeEnrichmentColumns adds the office-enrichment columns introduced // in ADR 0005 Wave A. Each ALTER is idempotent: only errors raised when the // column already exists are tolerated. func (r *sqliteRepository) migrateOfficeEnrichmentColumns() error { type migration struct { name string stmt string } migrations := []migration{ {"agent_profiles.workspace_id", `ALTER TABLE agent_profiles ADD COLUMN workspace_id TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.role", `ALTER TABLE agent_profiles ADD COLUMN role TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.icon", `ALTER TABLE agent_profiles ADD COLUMN icon TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.reports_to", `ALTER TABLE agent_profiles ADD COLUMN reports_to TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.skill_ids", `ALTER TABLE agent_profiles ADD COLUMN skill_ids TEXT NOT NULL DEFAULT '[]'`}, {"agent_profiles.desired_skills", `ALTER TABLE agent_profiles ADD COLUMN desired_skills TEXT NOT NULL DEFAULT '[]'`}, {"agent_profiles.custom_prompt", `ALTER TABLE agent_profiles ADD COLUMN custom_prompt TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.status", `ALTER TABLE agent_profiles ADD COLUMN status TEXT NOT NULL DEFAULT 'idle'`}, {"agent_profiles.pause_reason", `ALTER TABLE agent_profiles ADD COLUMN pause_reason TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.working_run_id", `ALTER TABLE agent_profiles ADD COLUMN working_run_id TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.last_run_finished_at", `ALTER TABLE agent_profiles ADD COLUMN last_run_finished_at TIMESTAMP`}, {"agent_profiles.max_concurrent_sessions", `ALTER TABLE agent_profiles ADD COLUMN max_concurrent_sessions INTEGER NOT NULL DEFAULT 1`}, {"agent_profiles.cooldown_sec", `ALTER TABLE agent_profiles ADD COLUMN cooldown_sec INTEGER NOT NULL DEFAULT 0`}, {"agent_profiles.skip_idle_runs", `ALTER TABLE agent_profiles ADD COLUMN skip_idle_runs INTEGER NOT NULL DEFAULT 0`}, {"agent_profiles.consecutive_failures", `ALTER TABLE agent_profiles ADD COLUMN consecutive_failures INTEGER NOT NULL DEFAULT 0`}, {"agent_profiles.failure_threshold", `ALTER TABLE agent_profiles ADD COLUMN failure_threshold INTEGER NOT NULL DEFAULT 3`}, {"agent_profiles.executor_preference", `ALTER TABLE agent_profiles ADD COLUMN executor_preference TEXT NOT NULL DEFAULT ''`}, {"agent_profiles.budget_monthly_cents", `ALTER TABLE agent_profiles ADD COLUMN budget_monthly_cents INTEGER NOT NULL DEFAULT 0`}, {"agent_profiles.settings", `ALTER TABLE agent_profiles ADD COLUMN settings TEXT NOT NULL DEFAULT '{}'`}, {"agent_profiles.permissions", `ALTER TABLE agent_profiles ADD COLUMN permissions TEXT NOT NULL DEFAULT '{}'`}, } for _, m := range migrations { if err := r.migrate.Apply(m.name, m.stmt); err != nil { return err } } // Indexes are idempotent via IF NOT EXISTS, but the partial-index variant // required for role/reports_to needs the column to exist first - so create // here after the ALTERs to handle databases upgraded from older schemas. if err := r.migrate.Apply("idx_agent_profiles_workspace", `CREATE INDEX IF NOT EXISTS idx_agent_profiles_workspace ON agent_profiles(workspace_id)`); err != nil { return err } if err := r.migrate.Apply("idx_agent_profiles_role", `CREATE INDEX IF NOT EXISTS idx_agent_profiles_role ON agent_profiles(workspace_id, role) WHERE role != ''`); err != nil { return err } if err := r.migrate.Apply("idx_agent_profiles_reports_to", `CREATE INDEX IF NOT EXISTS idx_agent_profiles_reports_to ON agent_profiles(reports_to) WHERE reports_to != ''`); err != nil { return err } return nil } // migrateDropModelCheckConstraint recreates agent_profiles without the legacy // non-empty-model CHECK constraint. Existing databases created before the // ACP-first migration carry this constraint, which prevents empty model // values. New databases (created by the CREATE TABLE IF NOT EXISTS above) // never have it. // // The migration is idempotent: it inspects sqlite_master for the CHECK keyword // and only proceeds when the constraint is present. func (r *sqliteRepository) migrateDropModelCheckConstraint() error { if dialect.IsPostgres(r.db.DriverName()) { return nil } var tableDDL string err := r.db.QueryRow( `SELECT sql FROM sqlite_master WHERE type='table' AND name='agent_profiles'`, ).Scan(&tableDDL) if errors.Is(err, sql.ErrNoRows) { // Table doesn't exist yet (fresh DB, CREATE TABLE IF NOT EXISTS // hasn't run or was a no-op) — nothing to migrate. return nil } if err != nil { return fmt.Errorf("query agent_profiles DDL: %w", err) } // Only migrate if the old model CHECK constraint is still present. // Use a targeted match to avoid false-positives from unrelated future // CHECK constraints on the same table. if !strings.Contains(tableDDL, "CHECK(model") { return nil } if err := r.recreateAgentProfilesWithoutModelCheck(); err != nil { return err } if r.log != nil { r.log.Info("migration applied", zap.String("name", "agent_profiles.recreate_drop_model_check")) } return nil } // recreateAgentProfilesWithoutModelCheck performs the actual SQLite table // recreation: copy data into a new table without the CHECK constraint, drop // the old table, rename the new one. Wrapped in a transaction so a crash // mid-migration doesn't leave the DB without the agent_profiles table. func (r *sqliteRepository) recreateAgentProfilesWithoutModelCheck() error { // Disable FK enforcement during the recreation: the DB is opened with // _foreign_keys=on, and agent_profile_mcp_configs references // agent_profiles(id). This matches the pattern in task/repository. if _, err := r.db.Exec(`PRAGMA foreign_keys=OFF`); err != nil { return fmt.Errorf("disable foreign keys for migration: %w", err) } defer func() { _, _ = r.db.Exec(`PRAGMA foreign_keys=ON`) }() tx, err := r.db.Begin() if err != nil { return fmt.Errorf("begin migration tx: %w", err) } defer func() { _ = tx.Rollback() }() // The old table does not have cli_flags/env_vars yet (the ADD COLUMN ran earlier in // initSchema but on the old table, which is about to be dropped). So we // include it in the copy only when it exists on the source table. srcHasCLIFlags := columnExists(tx, "agent_profiles", "cli_flags") srcHasEnvVars := columnExists(tx, "agent_profiles", "env_vars") srcHasEnabled := columnExists(tx, "agent_profiles", "enabled") srcCols := `id, agent_id, name, agent_display_name, model, mode, migrated_from, auto_approve, dangerously_skip_permissions, allow_indexing, cli_passthrough, user_modified, plan, created_at, updated_at, deleted_at` dstCols := srcCols if srcHasCLIFlags { srcCols += ", cli_flags" dstCols += ", cli_flags" } if srcHasEnvVars { srcCols += ", env_vars" dstCols += ", env_vars" } if srcHasEnabled { srcCols += ", enabled" dstCols += ", enabled" } if _, err := tx.Exec(`CREATE TABLE agent_profiles_new ( id TEXT PRIMARY KEY, agent_id TEXT NOT NULL, name TEXT NOT NULL, agent_display_name TEXT NOT NULL, model TEXT NOT NULL DEFAULT '', mode TEXT DEFAULT NULL, migrated_from TEXT DEFAULT NULL, auto_approve INTEGER NOT NULL DEFAULT 0, dangerously_skip_permissions INTEGER NOT NULL DEFAULT 0, allow_indexing INTEGER NOT NULL DEFAULT 1, cli_passthrough INTEGER NOT NULL DEFAULT 0, enabled INTEGER NOT NULL DEFAULT 1, user_modified INTEGER NOT NULL DEFAULT 0, plan TEXT DEFAULT '', cli_flags TEXT DEFAULT NULL, env_vars TEXT NOT NULL DEFAULT '[]', created_at TIMESTAMP NOT NULL, updated_at TIMESTAMP NOT NULL, deleted_at TIMESTAMP, FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE )`); err != nil { return fmt.Errorf("create new table: %w", err) } if _, err := tx.Exec( `INSERT INTO agent_profiles_new (` + dstCols + `) SELECT ` + srcCols + ` FROM agent_profiles`, ); err != nil { return fmt.Errorf("copy data: %w", err) } if _, err := tx.Exec(`DROP TABLE agent_profiles`); err != nil { return fmt.Errorf("drop old table: %w", err) } if _, err := tx.Exec(`ALTER TABLE agent_profiles_new RENAME TO agent_profiles`); err != nil { return fmt.Errorf("rename new table: %w", err) } if _, err := tx.Exec( `CREATE INDEX IF NOT EXISTS idx_agent_profiles_agent_id ON agent_profiles(agent_id)`, ); err != nil { return fmt.Errorf("recreate index: %w", err) } return tx.Commit() } func (r *sqliteRepository) Close() error { if !r.ownsDB { return nil } return r.db.Close() } // marshalTUIConfig renders a TUI config for the nullable tui_config column. // Shared by CreateAgent and UpdateAgent so the two writers cannot drift — the // column being absent from one of them is exactly how an editable field was // lost on save. func marshalTUIConfig(cfg *models.TUIConfigJSON) (*string, error) { if cfg == nil { return nil, nil } data, err := json.Marshal(cfg) if err != nil { return nil, fmt.Errorf("failed to marshal tui_config: %w", err) } s := string(data) return &s, nil } func (r *sqliteRepository) CreateAgent(ctx context.Context, agent *models.Agent) error { if agent.ID == "" { agent.ID = uuid.New().String() } now := time.Now().UTC() agent.CreatedAt = now agent.UpdatedAt = now tuiConfigJSON, err := marshalTUIConfig(agent.TUIConfig) if err != nil { return err } _, err = r.db.ExecContext(ctx, r.db.Rebind(` INSERT INTO agents (id, name, workspace_id, supports_mcp, mcp_config_path, tui_config, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?) `), agent.ID, agent.Name, agent.WorkspaceID, dialect.BoolToInt(agent.SupportsMCP), agent.MCPConfigPath, tuiConfigJSON, agent.CreatedAt, agent.UpdatedAt) return err } func (r *sqliteRepository) GetAgent(ctx context.Context, id string) (*models.Agent, error) { row := r.ro.QueryRowContext(ctx, r.ro.Rebind(` SELECT id, name, workspace_id, supports_mcp, mcp_config_path, tui_config, created_at, updated_at FROM agents WHERE id = ? `), id) return scanAgent(row) } func (r *sqliteRepository) GetAgentByName(ctx context.Context, name string) (*models.Agent, error) { row := r.ro.QueryRowContext(ctx, r.ro.Rebind(` SELECT id, name, workspace_id, supports_mcp, mcp_config_path, tui_config, created_at, updated_at FROM agents WHERE name = ? `), name) return scanAgent(row) } func (r *sqliteRepository) UpdateAgent(ctx context.Context, agent *models.Agent) error { agent.UpdatedAt = time.Now().UTC() // tui_config is written here as well as in CreateAgent: a custom TUI agent's // MCP strategy is editable after creation, and omitting the column silently // discarded that edit — the row kept supports_mcp while the strategy it was // derived from reverted on the next boot. tuiConfigJSON, err := marshalTUIConfig(agent.TUIConfig) if err != nil { return err } result, err := r.db.ExecContext(ctx, r.db.Rebind(` UPDATE agents SET workspace_id = ?, supports_mcp = ?, mcp_config_path = ?, tui_config = ?, updated_at = ? WHERE id = ? `), agent.WorkspaceID, dialect.BoolToInt(agent.SupportsMCP), agent.MCPConfigPath, tuiConfigJSON, agent.UpdatedAt, agent.ID) if err != nil { return err } rows, _ := result.RowsAffected() if rows == 0 { return fmt.Errorf("agent not found: %s", agent.ID) } return nil } func (r *sqliteRepository) DeleteAgent(ctx context.Context, id string) error { result, err := r.db.ExecContext(ctx, r.db.Rebind(`DELETE FROM agents WHERE id = ?`), id) if err != nil { return err } rows, _ := result.RowsAffected() if rows == 0 { return fmt.Errorf("agent not found: %s", id) } return nil } func (r *sqliteRepository) ListAgents(ctx context.Context) ([]*models.Agent, error) { return r.listAgentsWhere(ctx, "1=1") } func (r *sqliteRepository) GetAgentProfileMcpConfig(ctx context.Context, profileID string) (*models.AgentProfileMcpConfig, error) { row := r.ro.QueryRowContext(ctx, r.ro.Rebind(` SELECT profile_id, enabled, servers_json, meta_json, created_at, updated_at FROM agent_profile_mcp_configs WHERE profile_id = ? `), profileID) return scanAgentProfileMcpConfig(row) } func scanAgentProfileMcpConfig(scanner interface { Scan(dest ...any) error }) (*models.AgentProfileMcpConfig, error) { var config models.AgentProfileMcpConfig var enabled int var serversJSON string var metaJSON string if err := scanner.Scan(&config.ProfileID, &enabled, &serversJSON, &metaJSON, &config.CreatedAt, &config.UpdatedAt); err != nil { return nil, err } config.Enabled = enabled == 1 if err := json.Unmarshal([]byte(serversJSON), &config.Servers); err != nil { return nil, fmt.Errorf("failed to parse MCP servers JSON: %w", err) } if err := json.Unmarshal([]byte(metaJSON), &config.Meta); err != nil { return nil, fmt.Errorf("failed to parse MCP meta JSON: %w", err) } return &config, nil } // UpdateAgentProfileMcpConfigPatch updates only the requested MCP columns in // one database statement. The upsert keeps the other document columns intact, // including when two callers update different fields concurrently. // //nolint:cyclop // The transaction validates ownership, builds the partial SQL update, and returns the row. func (r *sqliteRepository) UpdateAgentProfileMcpConfigPatch( ctx context.Context, profileID string, enabled *bool, servers *map[string]interface{}, ) (*models.AgentProfileMcpConfig, error) { if profileID == "" { return nil, fmt.Errorf("profile ID is required") } if enabled == nil && servers == nil { return nil, fmt.Errorf("MCP config patch is empty") } tx, err := r.db.BeginTxx(ctx, nil) if err != nil { return nil, err } defer func() { _ = tx.Rollback() }() var supportsMCP int if err := tx.QueryRowContext(ctx, tx.Rebind(` SELECT a.supports_mcp FROM agent_profiles p JOIN agents a ON a.id = p.agent_id WHERE p.id = ? AND p.deleted_at IS NULL `), profileID).Scan(&supportsMCP); err != nil { return nil, err } if supportsMCP != 1 { return nil, fmt.Errorf("mcp not supported by agent") } const emptyJSON = "{}" enabledValue := 0 if enabled != nil && *enabled { enabledValue = 1 } serversJSON := emptyJSON if servers != nil { encoded, marshalErr := json.Marshal(*servers) if marshalErr != nil { return nil, fmt.Errorf("failed to serialize MCP servers: %w", marshalErr) } serversJSON = string(encoded) } updates := make([]string, 0, 3) if enabled != nil { updates = append(updates, "enabled = excluded.enabled") } if servers != nil { updates = append(updates, "servers_json = excluded.servers_json") } updates = append(updates, "updated_at = excluded.updated_at") now := time.Now().UTC() _, err = tx.ExecContext(ctx, tx.Rebind(` INSERT INTO agent_profile_mcp_configs (profile_id, enabled, servers_json, meta_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(profile_id) DO UPDATE SET `+strings.Join(updates, ",\n\t\t\t")+ ` `), profileID, enabledValue, serversJSON, emptyJSON, now, now) if err != nil { return nil, err } config, err := scanAgentProfileMcpConfig(tx.QueryRowxContext(ctx, tx.Rebind(` SELECT profile_id, enabled, servers_json, meta_json, created_at, updated_at FROM agent_profile_mcp_configs WHERE profile_id = ? `), profileID)) if err != nil { return nil, err } if err := tx.Commit(); err != nil { return nil, err } return config, nil } func (r *sqliteRepository) UpsertAgentProfileMcpConfig(ctx context.Context, config *models.AgentProfileMcpConfig) error { if config.ProfileID == "" { return fmt.Errorf("profile ID is required") } return r.upsertAgentProfileMcpConfig(ctx, r.db, config) } // upsertAgentProfileMcpConfig inserts or replaces the MCP config row for a // profile, running against the caller-supplied execer so the duplicate can // commit it in the same transaction as the profile row. Defaults nil maps and // fills timestamps on the passed config in place. func (r *sqliteRepository) upsertAgentProfileMcpConfig(ctx context.Context, execer profileExecer, config *models.AgentProfileMcpConfig) error { if config.Servers == nil { config.Servers = map[string]interface{}{} } if config.Meta == nil { config.Meta = map[string]interface{}{} } now := time.Now().UTC() if config.CreatedAt.IsZero() { config.CreatedAt = now } config.UpdatedAt = now serversJSON, err := json.Marshal(config.Servers) if err != nil { return fmt.Errorf("failed to serialize MCP servers: %w", err) } metaJSON, err := json.Marshal(config.Meta) if err != nil { return fmt.Errorf("failed to serialize MCP meta: %w", err) } _, err = execer.ExecContext(ctx, execer.Rebind(` INSERT INTO agent_profile_mcp_configs (profile_id, enabled, servers_json, meta_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(profile_id) DO UPDATE SET enabled = excluded.enabled, servers_json = excluded.servers_json, meta_json = excluded.meta_json, updated_at = excluded.updated_at `), config.ProfileID, dialect.BoolToInt(config.Enabled), string(serversJSON), string(metaJSON), config.CreatedAt, config.UpdatedAt) return err } func (r *sqliteRepository) CreateAgentProfile(ctx context.Context, profile *models.AgentProfile) error { if profile.ID == "" { profile.ID = uuid.New().String() } now := time.Now().UTC() profile.CreatedAt = now profile.UpdatedAt = now // New profiles are created enabled — the DB column default is 1 and // nothing creates a profile pre-disabled. Setting the field here keeps // callers' in-memory copy consistent with the row. profile.Enabled = true return r.insertAgentProfile(ctx, r.db, profile) } var _ DynamicProfileRepository = (*sqliteRepository)(nil) // CreateDynamicAgentProfile writes the dynamic document and its ordered route // rows in one transaction. The parent agent_profiles row is created by the // controller first; this transaction is the optimistic-routing document's // atomic unit. func (r *sqliteRepository) CreateDynamicAgentProfile( ctx context.Context, profile *models.DynamicAgentProfile, routes []models.DynamicAgentRoute, ) error { if profile == nil || profile.ProfileID == "" { return fmt.Errorf("dynamic profile ID is required") } if profile.Version <= 0 { profile.Version = 1 } now := time.Now().UTC() if profile.CreatedAt.IsZero() { profile.CreatedAt = now } profile.UpdatedAt = now tx, err := r.db.BeginTxx(ctx, nil) if err != nil { return err } defer func() { _ = tx.Rollback() }() if _, err := tx.ExecContext(ctx, tx.Rebind(` INSERT INTO dynamic_agent_profiles (profile_id, version, created_at, updated_at) VALUES (?, ?, ?, ?) `), profile.ProfileID, profile.Version, profile.CreatedAt, profile.UpdatedAt); err != nil { return err } if err := insertDynamicRoutes(ctx, tx, profile.ProfileID, routes); err != nil { return err } return tx.Commit() } func insertDynamicRoutes(ctx context.Context, execer profileExecer, profileID string, routes []models.DynamicAgentRoute) error { for _, route := range routes { if _, err := execer.ExecContext(ctx, execer.Rebind(` INSERT INTO dynamic_agent_routes (dynamic_profile_id, position, execution_profile_id, enabled, rules_json) VALUES (?, ?, ?, ?, ?) `), profileID, route.Position, route.ExecutionProfileID, dialect.BoolToInt(route.Enabled), route.RulesJSON); err != nil { return err } } return nil } func (r *sqliteRepository) GetDynamicAgentProfile( ctx context.Context, profileID string, ) (*models.DynamicAgentProfile, []models.DynamicAgentRoute, error) { profile := &models.DynamicAgentProfile{} if err := r.ro.QueryRowContext(ctx, r.ro.Rebind(` SELECT profile_id, version, created_at, updated_at FROM dynamic_agent_profiles WHERE profile_id = ? `), profileID).Scan(&profile.ProfileID, &profile.Version, &profile.CreatedAt, &profile.UpdatedAt); err != nil { return nil, nil, err } rows, err := r.ro.QueryxContext(ctx, r.ro.Rebind(` SELECT dynamic_profile_id, position, execution_profile_id, enabled, rules_json FROM dynamic_agent_routes WHERE dynamic_profile_id = ? ORDER BY position ASC `), profileID) if err != nil { return nil, nil, err } defer func() { _ = rows.Close() }() routes := make([]models.DynamicAgentRoute, 0) for rows.Next() { var route models.DynamicAgentRoute var enabled int if err := rows.Scan(&route.DynamicProfileID, &route.Position, &route.ExecutionProfileID, &enabled, &route.RulesJSON); err != nil { return nil, nil, err } route.Enabled = enabled != 0 routes = append(routes, route) } if err := rows.Err(); err != nil { return nil, nil, err } return profile, routes, nil } // UpdateDynamicAgentProfile replaces the complete route document only when // expectedVersion still owns the row. The new version and route replacement // commit together, so readers never observe a partially edited candidate list. func (r *sqliteRepository) UpdateDynamicAgentProfile( ctx context.Context, profile *models.DynamicAgentProfile, expectedVersion int64, routes []models.DynamicAgentRoute, ) error { if profile == nil || profile.ProfileID == "" { return fmt.Errorf("dynamic profile ID is required") } tx, err := r.db.BeginTxx(ctx, nil) if err != nil { return err } defer func() { _ = tx.Rollback() }() if err := r.updateDynamicAgentProfileTx(ctx, tx, profile, expectedVersion, routes); err != nil { return err } return tx.Commit() } func (r *sqliteRepository) updateDynamicAgentProfileTx( ctx context.Context, execer profileExecer, profile *models.DynamicAgentProfile, expectedVersion int64, routes []models.DynamicAgentRoute, ) error { now := time.Now().UTC() result, err := execer.ExecContext(ctx, execer.Rebind(` UPDATE dynamic_agent_profiles SET version = version + 1, updated_at = ? WHERE profile_id = ? AND version = ? `), now, profile.ProfileID, expectedVersion) if err != nil { return err } rowsAffected, err := result.RowsAffected() if err != nil { return err } if rowsAffected == 0 { return ErrDynamicProfileVersionConflict } if _, err := execer.ExecContext(ctx, execer.Rebind( `DELETE FROM dynamic_agent_routes WHERE dynamic_profile_id = ?`), profile.ProfileID); err != nil { return err } if err := insertDynamicRoutes(ctx, execer, profile.ProfileID, routes); err != nil { return err } profile.Version = expectedVersion + 1 profile.UpdatedAt = now return nil } // UpdateAgentProfileWithDynamic commits the ordinary profile fields and the // versioned dynamic route document together. A version conflict rolls back // both writes, so a stale editor cannot persist a partial base-profile change. func (r *sqliteRepository) UpdateAgentProfileWithDynamic( ctx context.Context, profile *models.AgentProfile, dynamic *models.DynamicAgentProfile, expectedVersion int64, routes []models.DynamicAgentRoute, ) error { if profile == nil || dynamic == nil || profile.ID == "" || dynamic.ProfileID != profile.ID { return fmt.Errorf("profile and dynamic profile IDs are required") } tx, err := r.db.BeginTxx(ctx, nil) if err != nil { return err } defer func() { _ = tx.Rollback() }() if err := r.updateAgentProfile(ctx, tx, profile); err != nil { return err } if err := r.updateDynamicAgentProfileTx(ctx, tx, dynamic, expectedVersion, routes); err != nil { return err } if err := tx.Commit(); err != nil { return err } return nil } func (r *sqliteRepository) ListDynamicProfileReferencesByExecutionProfile( ctx context.Context, profileID string, ) ([]models.DynamicProfileReference, error) { rows, err := r.ro.QueryxContext(ctx, r.ro.Rebind(` SELECT p.id, p.name, p.deleted_at FROM dynamic_agent_routes r JOIN agent_profiles p ON p.id = r.dynamic_profile_id WHERE r.execution_profile_id = ? ORDER BY p.name, p.id `), profileID) if err != nil { return nil, err } defer func() { _ = rows.Close() }() refs := make([]models.DynamicProfileReference, 0) seen := make(map[string]struct{}) for rows.Next() { var ref models.DynamicProfileReference if err := rows.Scan(&ref.ProfileID, &ref.Name, &ref.DeletedAt); err != nil { return nil, err } if _, ok := seen[ref.ProfileID]; ok { continue } seen[ref.ProfileID] = struct{}{} refs = append(refs, ref) } return refs, rows.Err() } // DuplicateAgentProfile creates an independent copy of a profile in a single // transaction: the row is inserted with the caller-provided Enabled state (a // duplicate of a disabled profile must not become briefly selectable) and the // MCP config row is upserted when non-nil. A failure rolls back and leaves no // partial copy, so retrying after an error cannot create a duplicate row. // // The source rows are re-read inside the transaction and must still carry the // revisions the copy was built from; otherwise ErrProfileChanged is returned // and nothing is created. Combined with WAL snapshot isolation (a concurrent // commit after this transaction's first read aborts its write with a busy // error), the copy always reflects one consistent snapshot of the source. func (r *sqliteRepository) DuplicateAgentProfile(ctx context.Context, input DuplicateAgentProfileInput) error { if input.Profile.ID == "" { input.Profile.ID = uuid.New().String() } tx, err := r.db.BeginTxx(ctx, nil) if err != nil { return err } defer func() { _ = tx.Rollback() }() if err := r.verifySourceSnapshot(ctx, tx, input); err != nil { return err } now := time.Now().UTC() input.Profile.CreatedAt = now input.Profile.UpdatedAt = now if err := r.insertAgentProfile(ctx, tx, input.Profile); err != nil { return err } if input.McpConfig != nil { input.McpConfig.ProfileID = input.Profile.ID if err := r.upsertAgentProfileMcpConfig(ctx, tx, input.McpConfig); err != nil { return err } } return tx.Commit() } // verifySourceSnapshot checks, inside the duplicate transaction, that the // source rows still match the revisions the caller built the copy from. A // mismatch means a concurrent writer changed the source between the caller's // read and this transaction — duplicating anyway would produce a copy mixing // two points in time. func (r *sqliteRepository) verifySourceSnapshot(ctx context.Context, tx *sqlx.Tx, input DuplicateAgentProfileInput) error { var sourceUpdated time.Time err := tx.QueryRowContext(ctx, tx.Rebind( `SELECT updated_at FROM agent_profiles WHERE id = ? AND deleted_at IS NULL`), input.Source.ID).Scan(&sourceUpdated) if errors.Is(err, sql.ErrNoRows) { return ErrSourceProfileNotFound } if err != nil { return err } if !sourceUpdated.Equal(input.Source.UpdatedAt) { return ErrProfileChanged } if input.SourceMcp == nil { // The caller's snapshot had no MCP row: verify one was not created in // the meantime, otherwise the copy would silently drop it. Missing is // the unchanged case; an existing row means the snapshot is stale. var exists int err = tx.QueryRowContext(ctx, tx.Rebind( `SELECT 1 FROM agent_profile_mcp_configs WHERE profile_id = ?`), input.Source.ID).Scan(&exists) if err == nil { return ErrProfileChanged } if !errors.Is(err, sql.ErrNoRows) { return err } return nil } var mcpUpdated time.Time err = tx.QueryRowContext(ctx, tx.Rebind( `SELECT updated_at FROM agent_profile_mcp_configs WHERE profile_id = ?`), input.Source.ID).Scan(&mcpUpdated) if errors.Is(err, sql.ErrNoRows) { return ErrProfileChanged } if err != nil { return err } if !mcpUpdated.Equal(input.SourceMcp.UpdatedAt) { return ErrProfileChanged } return nil } // profileExecer is the subset of *sqlx.DB / *sqlx.Tx the shared insert and // upsert helpers need, so one code path serves both single-statement and // transactional writes. type profileExecer interface { ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) Rebind(query string) string } // insertAgentProfile writes the profile row through the caller-supplied // execer, sharing one SQL statement between CreateAgentProfile and the // transactional duplicate path. The profile's Enabled value is written as-is. func (r *sqliteRepository) insertAgentProfile(ctx context.Context, execer profileExecer, profile *models.AgentProfile) error { cliFlagsJSON, err := cliFlagsToJSON(profile.CLIFlags) if err != nil { return err } envVarsJSON, err := envVarsToJSON(profile.EnvVars) if err != nil { return err } enrich, err := enrichmentValues(profile) if err != nil { return err } _, err = execer.ExecContext(ctx, execer.Rebind(` INSERT INTO agent_profiles ( id, agent_id, name, agent_display_name, model, mode, migrated_from, auto_approve, dangerously_skip_permissions, allow_indexing, cli_passthrough, enabled, user_modified, plan, cli_flags, env_vars, created_at, updated_at, deleted_at, workspace_id, role, icon, reports_to, skill_ids, desired_skills, custom_prompt, status, pause_reason, last_run_finished_at, max_concurrent_sessions, cooldown_sec, skip_idle_runs, consecutive_failures, failure_threshold, executor_preference, budget_monthly_cents, settings, permissions, command_prefix, fallback_model, auto_fallback ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) `), profile.ID, profile.AgentID, profile.Name, profile.AgentDisplayName, profile.Model, nullableString(profile.Mode), nullableString(profile.MigratedFrom), dialect.BoolToInt(profile.AutoApprove), dialect.BoolToInt(profile.DangerouslySkipPermissions), dialect.BoolToInt(profile.AllowIndexing), dialect.BoolToInt(profile.CLIPassthrough), dialect.BoolToInt(profile.Enabled), dialect.BoolToInt(profile.UserModified), cliFlagsJSON, envVarsJSON, profile.CreatedAt, profile.UpdatedAt, profile.DeletedAt, enrich.workspaceID, enrich.role, enrich.icon, enrich.reportsTo, enrich.skillIDs, enrich.desiredSkills, enrich.customPrompt, enrich.status, enrich.pauseReason, profile.LastRunFinishedAt, enrich.maxConcurrentSessions, profile.CooldownSec, dialect.BoolToInt(profile.SkipIdleRuns), profile.ConsecutiveFailures, enrich.failureThreshold, enrich.executorPreference, profile.BudgetMonthlyCents, enrich.settings, enrich.permissions, profile.CommandPrefix, profile.FallbackModel, dialect.BoolToInt(profile.AutoFallback), ) return err } // defaultAgentProfileStatus is the canonical "idle" status default used when // a profile is created or read without an explicit status. Hoisted to a // constant so the goconst linter has a single shared source of truth. const defaultAgentProfileStatus = "idle" // profileEnrichmentValues holds the marshalled / defaulted office-enrichment // values that the Insert + Update statements share. Centralising this keeps // the SQL-bind ordering in one place and avoids duplicated default-fill logic. type profileEnrichmentValues struct { workspaceID string role string icon string reportsTo string skillIDs string desiredSkills string customPrompt string status string pauseReason string maxConcurrentSessions int failureThreshold int executorPreference string settings string permissions string } // enrichmentValues fills in defaults for the office-enrichment columns. The // JSON-array fields (SkillIDs, DesiredSkills) are stored verbatim — empty // values normalise to "[]" so the NOT NULL constraint is satisfied. func enrichmentValues(profile *models.AgentProfile) (profileEnrichmentValues, error) { status := string(profile.Status) if status == "" { status = defaultAgentProfileStatus } maxSessions := profile.MaxConcurrentSessions if maxSessions <= 0 { maxSessions = 1 } settings := profile.Settings if settings == "" { settings = "{}" } settings, err := settingsWithConfigOptions(settings, profile.ConfigOptions) if err != nil { return profileEnrichmentValues{}, err } permissions := profile.Permissions if permissions == "" { permissions = "{}" } return profileEnrichmentValues{ workspaceID: profile.WorkspaceID, role: string(profile.Role), icon: profile.Icon, reportsTo: profile.ReportsTo, skillIDs: normalizeJSONArray(profile.SkillIDs), desiredSkills: normalizeJSONArray(profile.DesiredSkills), customPrompt: profile.CustomPrompt, status: status, pauseReason: profile.PauseReason, maxConcurrentSessions: maxSessions, failureThreshold: failureThresholdToColumn(profile.FailureThreshold), executorPreference: profile.ExecutorPreference, settings: settings, permissions: permissions, }, nil } const profileSettingsConfigOptionsKey = "config_options" func settingsWithConfigOptions(raw string, options map[string]string) (string, error) { raw = strings.TrimSpace(raw) if raw == "" { raw = "{}" } var settings map[string]json.RawMessage if err := json.Unmarshal([]byte(raw), &settings); err != nil { return "", fmt.Errorf("parse profile settings: %w", err) } if settings == nil { settings = map[string]json.RawMessage{} } clean := profileconfig.SanitizeConfigOptions(options) if len(clean) == 0 { delete(settings, profileSettingsConfigOptionsKey) } else { data, err := json.Marshal(clean) if err != nil { return "", fmt.Errorf("marshal profile config options: %w", err) } settings[profileSettingsConfigOptionsKey] = data } data, err := json.Marshal(settings) if err != nil { return "", fmt.Errorf("marshal profile settings: %w", err) } return string(data), nil } func configOptionsFromSettings(raw string) map[string]string { raw = strings.TrimSpace(raw) if raw == "" { return nil } var payload struct { ConfigOptions map[string]string `json:"config_options"` } if err := json.Unmarshal([]byte(raw), &payload); err != nil { return nil } return profileconfig.SanitizeConfigOptions(payload.ConfigOptions) } // normalizeJSONArray returns "[]" for empty values; otherwise the input. Used // to satisfy the NOT NULL DEFAULT '[]' constraint on JSON-array TEXT columns // (skill_ids, desired_skills) without mandating callers always set a value. func normalizeJSONArray(s string) string { s = strings.TrimSpace(s) if s == "" { return "[]" } return s } // failureThresholdToColumn maps the *int (NULL = use workspace default) onto // the merged column's INTEGER NOT NULL DEFAULT 3 semantics. We store 0 as // "use workspace default" and round-trip it back to nil on read; non-zero // values flow through verbatim. func failureThresholdToColumn(p *int) int { if p == nil { return 0 } return *p } // nullableString converts an empty string to sql.NullString zero-value so the // column is written as NULL rather than "". Keeps nullable columns clean. func nullableString(s string) sql.NullString { if s == "" { return sql.NullString{} } return sql.NullString{String: s, Valid: true} } // columnExists reports whether a column is present on a SQLite table. Used by // the table-recreation migration to gracefully handle databases where ALTER // TABLE ADD COLUMN ran but the recreation is running for the first time. type sqlQueryer interface { Query(query string, args ...any) (*sql.Rows, error) } func columnExists(q sqlQueryer, table, column string) bool { rows, err := q.Query(`PRAGMA table_info(` + table + `)`) if err != nil { return false } defer func() { _ = rows.Close() }() for rows.Next() { var ( cid int name string ctype string notnull int dflt sql.NullString pk int ) if err := rows.Scan(&cid, &name, &ctype, ¬null, &dflt, &pk); err != nil { return false } if name == column { return true } } return false } // cliFlagsToJSON marshals the profile's CLIFlags list into a JSON string // suitable for the cli_flags TEXT column. Empty or nil slices serialise to // "[]" so we can distinguish an empty-but-known list (skip backfill) from a // never-written NULL (trigger backfill on read). func cliFlagsToJSON(flags []models.CLIFlag) (string, error) { if flags == nil { flags = []models.CLIFlag{} } data, err := json.Marshal(flags) if err != nil { return "", fmt.Errorf("marshal cli_flags: %w", err) } return string(data), nil } func envVarsToJSON(envVars []models.ProfileEnvVar) (string, error) { if envVars == nil { envVars = []models.ProfileEnvVar{} } data, err := json.Marshal(envVars) if err != nil { return "", fmt.Errorf("marshal env_vars: %w", err) } return string(data), nil } func (r *sqliteRepository) UpdateAgentProfile(ctx context.Context, profile *models.AgentProfile) error { return r.updateAgentProfile(ctx, r.db, profile) } func (r *sqliteRepository) updateAgentProfile(ctx context.Context, execer profileExecer, profile *models.AgentProfile) error { profile.UpdatedAt = time.Now().UTC() cliFlagsJSON, err := cliFlagsToJSON(profile.CLIFlags) if err != nil { return err } envVarsJSON, err := envVarsToJSON(profile.EnvVars) if err != nil { return err } enrich, err := enrichmentValues(profile) if err != nil { return err } result, err := execer.ExecContext(ctx, execer.Rebind(` UPDATE agent_profiles SET agent_id = ?, name = ?, agent_display_name = ?, model = ?, mode = ?, migrated_from = ?, auto_approve = ?, dangerously_skip_permissions = ?, allow_indexing = ?, cli_passthrough = ?, enabled = ?, user_modified = ?, cli_flags = ?, env_vars = ?, updated_at = ?, workspace_id = ?, role = ?, icon = ?, reports_to = ?, skill_ids = ?, desired_skills = ?, custom_prompt = ?, status = CASE WHEN (status = 'working' AND working_run_id <> '') OR ? = 'working' THEN status ELSE ? END, pause_reason = CASE WHEN (status = 'working' AND working_run_id <> '') OR ? = 'working' THEN pause_reason ELSE ? END, working_run_id = CASE WHEN status = 'working' AND working_run_id <> '' THEN working_run_id ELSE '' END, last_run_finished_at = ?, max_concurrent_sessions = ?, cooldown_sec = ?, skip_idle_runs = ?, consecutive_failures = ?, failure_threshold = ?, executor_preference = ?, budget_monthly_cents = ?, settings = ?, permissions = ?, command_prefix = ?, fallback_model = ?, auto_fallback = ? WHERE id = ? AND deleted_at IS NULL `), profile.AgentID, profile.Name, profile.AgentDisplayName, profile.Model, nullableString(profile.Mode), nullableString(profile.MigratedFrom), dialect.BoolToInt(profile.AutoApprove), dialect.BoolToInt(profile.DangerouslySkipPermissions), dialect.BoolToInt(profile.AllowIndexing), dialect.BoolToInt(profile.CLIPassthrough), dialect.BoolToInt(profile.Enabled), dialect.BoolToInt(profile.UserModified), cliFlagsJSON, envVarsJSON, profile.UpdatedAt, enrich.workspaceID, enrich.role, enrich.icon, enrich.reportsTo, enrich.skillIDs, enrich.desiredSkills, enrich.customPrompt, enrich.status, enrich.status, enrich.status, enrich.pauseReason, profile.LastRunFinishedAt, enrich.maxConcurrentSessions, profile.CooldownSec, dialect.BoolToInt(profile.SkipIdleRuns), profile.ConsecutiveFailures, enrich.failureThreshold, enrich.executorPreference, profile.BudgetMonthlyCents, enrich.settings, enrich.permissions, profile.CommandPrefix, profile.FallbackModel, dialect.BoolToInt(profile.AutoFallback), profile.ID) if err != nil { return err } rows, _ := result.RowsAffected() if rows == 0 { return fmt.Errorf("agent profile not found: %s", profile.ID) } return nil } // UpdateAgentProfileEnabled changes only the selection flag. Keeping this // update narrow avoids a settings-page toggle overwriting fields that were // read by another profile editor before its save completed. func (r *sqliteRepository) UpdateAgentProfileEnabled(ctx context.Context, id string, enabled bool) (time.Time, error) { now := time.Now().UTC() result, err := r.db.ExecContext(ctx, r.db.Rebind(` UPDATE agent_profiles SET enabled = ?, user_modified = 1, updated_at = ? WHERE id = ? AND deleted_at IS NULL `), dialect.BoolToInt(enabled), now, id) if err != nil { return time.Time{}, err } rows, _ := result.RowsAffected() if rows == 0 { return time.Time{}, fmt.Errorf("agent profile not found: %s", id) } return now, nil } func (r *sqliteRepository) DeleteAgentProfile(ctx context.Context, id string) error { now := time.Now().UTC() result, err := r.db.ExecContext(ctx, r.db.Rebind(` UPDATE agent_profiles SET deleted_at = ?, updated_at = ? WHERE id = ? AND deleted_at IS NULL `), now, now, id) if err != nil { return err } rows, _ := result.RowsAffected() if rows == 0 { return fmt.Errorf("agent profile not found: %s", id) } return nil } // agentProfileSelectColumns is the SELECT projection used by every // AgentProfile read path. Extracted once so the next column added to // agent_profiles only has to land here — duplicating the list across // GetAgentProfile / GetAgentProfileIncludingDeleted / ListAgentProfiles // risks the soft-delete path silently scanning zero values for a freshly // added column, which is the same shape of bug this package fixes in // another layer (orphaned watchers vs. stale projection drift). const agentProfileSelectColumns = ` SELECT id, agent_id, name, agent_display_name, model, mode, migrated_from, auto_approve, dangerously_skip_permissions, allow_indexing, cli_passthrough, enabled, user_modified, plan, cli_flags, COALESCE(env_vars, '[]'), created_at, updated_at, deleted_at, COALESCE(workspace_id, ''), COALESCE(role, ''), COALESCE(icon, ''), COALESCE(reports_to, ''), COALESCE(skill_ids, '[]'), COALESCE(desired_skills, '[]'), COALESCE(custom_prompt, ''), COALESCE(status, 'idle'), COALESCE(pause_reason, ''), last_run_finished_at, COALESCE(max_concurrent_sessions, 1), COALESCE(cooldown_sec, 0), COALESCE(skip_idle_runs, 0), COALESCE(consecutive_failures, 0), COALESCE(failure_threshold, 3), COALESCE(executor_preference, ''), COALESCE(budget_monthly_cents, 0), COALESCE(settings, '{}'), COALESCE(permissions, '{}'), COALESCE(command_prefix, ''), COALESCE(fallback_model, ''), COALESCE(auto_fallback, 0) FROM agent_profiles` func (r *sqliteRepository) GetAgentProfile(ctx context.Context, id string) (*models.AgentProfile, error) { row := r.ro.QueryRowContext(ctx, r.ro.Rebind(agentProfileSelectColumns+` WHERE id = ? AND deleted_at IS NULL`), id) profile, err := scanAgentProfile(row) if err != nil { return nil, err } return r.applyLegacyBackfill(ctx, profile), nil } // GetAgentProfileIncludingDeleted returns the row even when soft-deleted. // Resolver and watcher self-heal callers use this to disambiguate // "row removed" (recoverable: orphan reference) from "row never existed". func (r *sqliteRepository) GetAgentProfileIncludingDeleted(ctx context.Context, id string) (*models.AgentProfile, error) { row := r.ro.QueryRowContext(ctx, r.ro.Rebind(agentProfileSelectColumns+` WHERE id = ?`), id) profile, err := scanAgentProfile(row) if err != nil { return nil, err } return r.applyLegacyBackfill(ctx, profile), nil } func (r *sqliteRepository) ListAgentProfiles(ctx context.Context, agentID string) ([]*models.AgentProfile, error) { rows, err := r.ro.QueryContext(ctx, r.ro.Rebind(agentProfileSelectColumns+` WHERE agent_id = ? AND deleted_at IS NULL ORDER BY created_at DESC`), agentID) if err != nil { return nil, err } defer func() { _ = rows.Close() }() var result []*models.AgentProfile for rows.Next() { profile, err := scanAgentProfile(rows) if err != nil { return nil, err } result = append(result, r.applyLegacyBackfill(ctx, profile)) } return result, rows.Err() } // HasDeletedAgentProfiles reports whether the agent has any soft-deleted // profile rows (deleted_at IS NOT NULL). It is the "has been provisioned // before" signal the boot-time seeders consult before recreating a default // profile, so a profile the user deleted is not silently resurrected. func (r *sqliteRepository) HasDeletedAgentProfiles(ctx context.Context, agentID string) (bool, error) { var exists int err := r.ro.QueryRowContext(ctx, r.ro.Rebind(`SELECT 1 FROM agent_profiles WHERE agent_id = ? AND deleted_at IS NOT NULL LIMIT 1`), agentID).Scan(&exists) if errors.Is(err, sql.ErrNoRows) { return false, nil } if err != nil { return false, err } return true, nil } // applyLegacyBackfill returns the profile with CLIFlags populated from the // legacy allow_indexing column for Auggie rows that predate the cli_flags // column. The backfill is scoped to auggie only so a legacy Claude/Codex/ // Copilot row (possible via the column's DEFAULT 1) never gains an // unsupported --allow-indexing flag. scanAgentProfile leaves CLIFlags nil // when the stored JSON is absent; we resolve the agent name lazily via a // small lookup here rather than JOINing in the main SELECT (keeps the // read query unchanged and avoids cross-test flakiness). func (r *sqliteRepository) applyLegacyBackfill(ctx context.Context, profile *models.AgentProfile) *models.AgentProfile { if profile == nil || profile.CLIFlags != nil { return profile } if !profile.AllowIndexing { profile.CLIFlags = []models.CLIFlag{} return profile } agent, err := r.GetAgent(ctx, profile.AgentID) profile.CLIFlags = legacyCLIFlagsForAgent(agent, err) return profile } // legacyCLIFlagsForAgent is applyLegacyBackfill/applyLegacyBackfillTx's // shared decision: only a resolved "auggie" agent backfills the // --allow-indexing flag; a lookup failure, a missing agent, or any other // agent name backfills an empty list instead. func legacyCLIFlagsForAgent(agent *models.Agent, err error) []models.CLIFlag { if err != nil || agent == nil || agent.Name != "auggie" { return []models.CLIFlag{} } return []models.CLIFlag{{ Description: "Allow workspace indexing without confirmation", Flag: "--allow-indexing", Enabled: true, }} } func (r *sqliteRepository) ListTUIAgents(ctx context.Context) ([]*models.Agent, error) { return r.listAgentsWhere(ctx, "tui_config IS NOT NULL") } func (r *sqliteRepository) listAgentsWhere(ctx context.Context, where string) ([]*models.Agent, error) { rows, err := r.ro.QueryContext(ctx, `SELECT id, name, workspace_id, supports_mcp, mcp_config_path, tui_config, created_at, updated_at FROM agents WHERE `+where+` ORDER BY created_at DESC`, ) if err != nil { return nil, err } defer func() { _ = rows.Close() }() var result []*models.Agent for rows.Next() { agent, scanErr := scanAgent(rows) if scanErr != nil { return nil, scanErr } result = append(result, agent) } return result, rows.Err() } func scanAgent(scanner interface { Scan(dest ...any) error }) (*models.Agent, error) { agent := &models.Agent{} var supportsMCP int var workspaceID sql.NullString var tuiConfigRaw sql.NullString if err := scanner.Scan( &agent.ID, &agent.Name, &workspaceID, &supportsMCP, &agent.MCPConfigPath, &tuiConfigRaw, &agent.CreatedAt, &agent.UpdatedAt, ); err != nil { return nil, err } if workspaceID.Valid { agent.WorkspaceID = &workspaceID.String } agent.SupportsMCP = supportsMCP == 1 if tuiConfigRaw.Valid { var cfg models.TUIConfigJSON if err := json.Unmarshal([]byte(tuiConfigRaw.String), &cfg); err != nil { return nil, fmt.Errorf("failed to parse tui_config: %w", err) } agent.TUIConfig = &cfg } return agent, nil } func scanAgentProfile(scanner interface { Scan(dest ...any) error }) (*models.AgentProfile, error) { profile := &models.AgentProfile{} var mode sql.NullString var migratedFrom sql.NullString var autoApprove int var skipPermissions int var allowIndexing int var cliPassthrough int var enabled int var userModified int var plan string // unused, kept for backwards compatibility var cliFlagsRaw sql.NullString var envVarsRaw sql.NullString var role, status string var skipIdleRuns int var failureThreshold int var autoFallback int if err := scanner.Scan( &profile.ID, &profile.AgentID, &profile.Name, &profile.AgentDisplayName, &profile.Model, &mode, &migratedFrom, &autoApprove, &skipPermissions, &allowIndexing, &cliPassthrough, &enabled, &userModified, &plan, &cliFlagsRaw, &envVarsRaw, &profile.CreatedAt, &profile.UpdatedAt, &profile.DeletedAt, &profile.WorkspaceID, &role, &profile.Icon, &profile.ReportsTo, &profile.SkillIDs, &profile.DesiredSkills, &profile.CustomPrompt, &status, &profile.PauseReason, &profile.LastRunFinishedAt, &profile.MaxConcurrentSessions, &profile.CooldownSec, &skipIdleRuns, &profile.ConsecutiveFailures, &failureThreshold, &profile.ExecutorPreference, &profile.BudgetMonthlyCents, &profile.Settings, &profile.Permissions, &profile.CommandPrefix, &profile.FallbackModel, &autoFallback, ); err != nil { return nil, err } if mode.Valid { profile.Mode = mode.String } if migratedFrom.Valid { profile.MigratedFrom = migratedFrom.String } profile.AutoApprove = autoApprove == 1 profile.DangerouslySkipPermissions = skipPermissions == 1 profile.AllowIndexing = allowIndexing == 1 profile.CLIPassthrough = cliPassthrough == 1 profile.Enabled = enabled == 1 profile.UserModified = userModified == 1 profile.SkipIdleRuns = skipIdleRuns == 1 profile.AutoFallback = autoFallback == 1 profile.Role = models.AgentRole(role) profile.Status = models.AgentStatus(status) profile.ConfigOptions = configOptionsFromSettings(profile.Settings) if failureThreshold > 0 { ft := failureThreshold profile.FailureThreshold = &ft } if cliFlagsRaw.Valid && cliFlagsRaw.String != "" { if err := json.Unmarshal([]byte(cliFlagsRaw.String), &profile.CLIFlags); err != nil { return nil, fmt.Errorf("failed to parse cli_flags for profile %s: %w", profile.ID, err) } } if envVarsRaw.Valid && envVarsRaw.String != "" { if err := json.Unmarshal([]byte(envVarsRaw.String), &profile.EnvVars); err != nil { return nil, fmt.Errorf("failed to parse env_vars for profile %s: %w", profile.ID, err) } } // When cli_flags is NULL the caller (GetAgentProfile / ListAgentProfiles) // runs applyLegacyBackfill to seed the list scoped to the owning agent. // Leaving CLIFlags as nil here is deliberate: non-nil vs nil discriminates // "stored empty list" from "never written". applyLegacyBackfill rewrites // nil → []CLIFlag{} so downstream code never sees a nil slice. return profile, nil }