switchboard/core
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Releases 9 Wiki Activity

step 5 (partial): strip dropped packages from production code

Browse Source 
Removed all references to dropped packages in non-test code.
Zero dropped imports, store refs, or model types remaining.

Major removals:
  - scheduler/ package (entire dir) — tasks moved to extension track
  - taskutil/ package (entire dir)
  - health/ package (entire dir) — provider/tool health
  - sandbox/provider_module.go — provider.complete module
  - handlers: workflow_entry, workflow_instances, workflow_forms,
    workflow_assignments, workflow_monitor, health_admin (6 files)
  - auth/session.go, middleware/session_auth.go
  - store/{postgres,sqlite}/sessions.go, tasks.go

Rewrites:
  - store/{postgres,sqlite}/health.go — kernel-only Prune
    (ws_tickets, rate_limit_counters, stale presence)
  - handlers/admin.go: 847→467 lines (stripped provider CRUD)
  - handlers/teams.go: 520→411 lines (stripped model listing)
  - sandbox/runner.go: removed ProviderResolver
  - sandbox/workflow_module.go: 216→83 lines (definition-only)
  - main.go: 1579→1325 lines (stripped dropped package init)
  - pages/pages.go: stripped channel/session lookups
  - events/types.go: stripped chat/channel/workspace event routes
  - models: stripped stale types, constants, notification types

Store interface cleanup:
  - Removed SessionStore, TaskStore from Stores struct
  - Stripped workflow assignment methods from WorkflowStore iface
  - Stripped assignment methods from PG+SQLite workflow stores
  - Updated testhelper.go table list to kernel-only

Migrations: removed 008_tasks.sql (both dialects)

-9665/+69 lines across 51 files.
This commit is contained in:
Jeffrey Smith
2026-03-25 21:13:01 -04:00
parent ebea16344c
commit e4b7ee98a5
55 changed files with 95 additions and 9981 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
server/store/postgres/health.go
View File

@@ -2,191 +2,42 @@ package postgres
import (
"context"
"database/sql"
"time"
"switchboard-core/models"
"switchboard-core/database"
)
// HealthStore implements health.Store for Postgres.
type HealthStore struct {
db *sql.DB
}
// ── HealthStore ─────────────────────────────
func NewHealthStore(db *sql.DB) *HealthStore {
return &HealthStore{db: db}
}
type HealthStore struct{}
func (s *HealthStore) UpsertWindow(ctx context.Context, w *models.ProviderHealthWindow) error {
_, err := s.db.ExecContext(ctx, `
INSERT INTO provider_health (provider_config_id, window_start,
request_count, error_count, timeout_count, rate_limit_count,
total_latency_ms, max_latency_ms, last_error, last_error_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, now())
ON CONFLICT (provider_config_id, window_start) DO UPDATE SET
request_count = provider_health.request_count + EXCLUDED.request_count,
error_count = provider_health.error_count + EXCLUDED.error_count,
timeout_count = provider_health.timeout_count + EXCLUDED.timeout_count,
rate_limit_count = provider_health.rate_limit_count + EXCLUDED.rate_limit_count,
total_latency_ms = provider_health.total_latency_ms + EXCLUDED.total_latency_ms,
max_latency_ms = GREATEST(provider_health.max_latency_ms, EXCLUDED.max_latency_ms),
last_error = COALESCE(EXCLUDED.last_error, provider_health.last_error),
last_error_at = COALESCE(EXCLUDED.last_error_at, provider_health.last_error_at),
updated_at = now()
`, w.ProviderConfigID, w.WindowStart,
w.RequestCount, w.ErrorCount, w.TimeoutCount, w.RateLimitCount,
w.TotalLatencyMs, w.MaxLatencyMs, w.LastError, w.LastErrorAt,
)
return err
}
func (s *HealthStore) GetCurrentWindow(ctx context.Context, providerConfigID string) (*models.ProviderHealthWindow, error) {
windowStart := time.Now().UTC().Truncate(time.Hour)
var w models.ProviderHealthWindow
err := s.db.QueryRowContext(ctx, `
SELECT id, provider_config_id, window_start,
request_count, error_count, timeout_count, rate_limit_count,
total_latency_ms, max_latency_ms, last_error, last_error_at
FROM provider_health
WHERE provider_config_id = $1 AND window_start = $2
`, providerConfigID, windowStart).Scan(
&w.ID, &w.ProviderConfigID, &w.WindowStart,
&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
)
if err == sql.ErrNoRows {
return nil, nil
}
return &w, err
}
func (s *HealthStore) ListWindows(ctx context.Context, providerConfigID string, hours int) ([]models.ProviderHealthWindow, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id, provider_config_id, window_start,
request_count, error_count, timeout_count, rate_limit_count,
total_latency_ms, max_latency_ms, last_error, last_error_at
FROM provider_health
WHERE provider_config_id = $1
ORDER BY window_start DESC
LIMIT $2
`, providerConfigID, hours)
if err != nil {
return nil, err
}
defer rows.Close()
var result []models.ProviderHealthWindow
for rows.Next() {
var w models.ProviderHealthWindow
if err := rows.Scan(
&w.ID, &w.ProviderConfigID, &w.WindowStart,
&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
); err != nil {
return nil, err
}
result = append(result, w)
}
return result, rows.Err()
}
func (s *HealthStore) ListAllCurrent(ctx context.Context) ([]models.ProviderHealthWindow, error) {
windowStart := time.Now().UTC().Truncate(time.Hour)
rows, err := s.db.QueryContext(ctx, `
SELECT id, provider_config_id, window_start,
request_count, error_count, timeout_count, rate_limit_count,
total_latency_ms, max_latency_ms, last_error, last_error_at
FROM provider_health
WHERE window_start = $1
ORDER BY provider_config_id
`, windowStart)
if err != nil {
return nil, err
}
defer rows.Close()
var result []models.ProviderHealthWindow
for rows.Next() {
var w models.ProviderHealthWindow
if err := rows.Scan(
&w.ID, &w.ProviderConfigID, &w.WindowStart,
&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
); err != nil {
return nil, err
}
result = append(result, w)
}
return result, rows.Err()
}
func NewHealthStore() *HealthStore { return &HealthStore{} }
// Prune deletes stale kernel data older than the given time.
// Cleans: expired ws_tickets, old rate_limit_counters, stale presence.
func (s *HealthStore) Prune(ctx context.Context, before time.Time) (int64, error) {
result, err := s.db.ExecContext(ctx, `
DELETE FROM provider_health WHERE window_start < $1
`, before)
if err != nil {
return 0, err
var total int64
res, _ := database.DB.ExecContext(ctx,
`DELETE FROM ws_tickets WHERE expires_at < $1`, before)
if res != nil {
n, _ := res.RowsAffected()
total += n
}
// Also prune tool health
s.db.ExecContext(ctx, `DELETE FROM tool_health WHERE window_start < $1`, before)
return result.RowsAffected()
}
// ── Tool Health (v0.22.4) ────────────────────
func (s *HealthStore) UpsertToolWindow(ctx context.Context, w *models.ToolHealthWindow) error {
_, err := s.db.ExecContext(ctx, `
INSERT INTO tool_health (tool_name, window_start,
request_count, error_count, total_latency_ms, max_latency_ms,
last_error, last_error_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, now())
ON CONFLICT (tool_name, window_start) DO UPDATE SET
request_count = tool_health.request_count + EXCLUDED.request_count,
error_count = tool_health.error_count + EXCLUDED.error_count,
total_latency_ms = tool_health.total_latency_ms + EXCLUDED.total_latency_ms,
max_latency_ms = GREATEST(tool_health.max_latency_ms, EXCLUDED.max_latency_ms),
last_error = COALESCE(EXCLUDED.last_error, tool_health.last_error),
last_error_at = COALESCE(EXCLUDED.last_error_at, tool_health.last_error_at),
updated_at = now()
`, w.ToolName, w.WindowStart,
w.RequestCount, w.ErrorCount, w.TotalLatencyMs, w.MaxLatencyMs,
w.LastError, w.LastErrorAt,
)
return err
}
func (s *HealthStore) ListAllToolCurrent(ctx context.Context) ([]models.ToolHealthWindow, error) {
windowStart := time.Now().UTC().Truncate(time.Hour)
rows, err := s.db.QueryContext(ctx, `
SELECT id, tool_name, window_start,
request_count, error_count, total_latency_ms, max_latency_ms,
last_error, last_error_at
FROM tool_health
WHERE window_start = $1
ORDER BY tool_name
`, windowStart)
if err != nil {
return nil, err
res, _ = database.DB.ExecContext(ctx,
`DELETE FROM rate_limit_counters WHERE window_start < $1`, before)
if res != nil {
n, _ := res.RowsAffected()
total += n
}
defer rows.Close()
var result []models.ToolHealthWindow
for rows.Next() {
var w models.ToolHealthWindow
if err := rows.Scan(
&w.ID, &w.ToolName, &w.WindowStart,
&w.RequestCount, &w.ErrorCount, &w.TotalLatencyMs, &w.MaxLatencyMs,
&w.LastError, &w.LastErrorAt,
); err != nil {
return nil, err
}
result = append(result, w)
res, _ = database.DB.ExecContext(ctx,
`DELETE FROM user_presence WHERE last_seen < $1 AND status = 'offline'`, before)
if res != nil {
n, _ := res.RowsAffected()
total += n
}
return result, rows.Err()
}
// DeactivateProvider marks a provider config as inactive (for auto-disable).
func (s *HealthStore) DeactivateProvider(ctx context.Context, configID string) error {
_, err := s.db.ExecContext(ctx, `UPDATE provider_configs SET is_active = false WHERE id = $1`, configID)
return err
return total, nil
}

112
server/store/postgres/sessions.go
View File

@@ -1,112 +0,0 @@
package postgres
import (
"context"
"database/sql"
"time"
"switchboard-core/models"
)
// ── SessionStore ───────────────────────────
type SessionStore struct{}
func NewSessionStore() *SessionStore { return &SessionStore{} }
func (s *SessionStore) Create(ctx context.Context, sp *models.SessionParticipant) error {
return DB.QueryRowContext(ctx, `
INSERT INTO session_participants (session_token, channel_id, display_name, fingerprint)
VALUES ($1, $2, $3, $4)
RETURNING id, created_at`,
sp.SessionToken, sp.ChannelID, sp.DisplayName, nullText(sp.Fingerprint),
).Scan(&sp.ID, &sp.CreatedAt)
}
func (s *SessionStore) GetByToken(ctx context.Context, token string) (*models.SessionParticipant, error) {
sp := &models.SessionParticipant{}
err := DB.QueryRowContext(ctx, `
SELECT id, session_token, channel_id, display_name, COALESCE(fingerprint, ''), created_at
FROM session_participants WHERE session_token = $1`, token,
).Scan(&sp.ID, &sp.SessionToken, &sp.ChannelID, &sp.DisplayName, &sp.Fingerprint, &sp.CreatedAt)
if err != nil {
return nil, err
}
return sp, nil
}
func (s *SessionStore) GetByID(ctx context.Context, id string) (*models.SessionParticipant, error) {
sp := &models.SessionParticipant{}
err := DB.QueryRowContext(ctx, `
SELECT id, session_token, channel_id, display_name, COALESCE(fingerprint, ''), created_at
FROM session_participants WHERE id = $1`, id,
).Scan(&sp.ID, &sp.SessionToken, &sp.ChannelID, &sp.DisplayName, &sp.Fingerprint, &sp.CreatedAt)
if err != nil {
return nil, err
}
return sp, nil
}
func (s *SessionStore) ListForChannel(ctx context.Context, channelID string) ([]models.SessionParticipant, error) {
rows, err := DB.QueryContext(ctx, `
SELECT id, session_token, channel_id, display_name, COALESCE(fingerprint, ''), created_at
FROM session_participants WHERE channel_id = $1
ORDER BY created_at ASC`, channelID)
if err != nil {
return nil, err
}
defer rows.Close()
var result []models.SessionParticipant
for rows.Next() {
var sp models.SessionParticipant
if err := rows.Scan(&sp.ID, &sp.SessionToken, &sp.ChannelID, &sp.DisplayName, &sp.Fingerprint, &sp.CreatedAt); err != nil {
return nil, err
}
result = append(result, sp)
}
return result, rows.Err()
}
func (s *SessionStore) CountForChannel(ctx context.Context, channelID string) (int, error) {
var count int
err := DB.QueryRowContext(ctx, `
SELECT COUNT(*) FROM session_participants WHERE channel_id = $1`, channelID,
).Scan(&count)
return count, err
}
func (s *SessionStore) Delete(ctx context.Context, id string) error {
res, err := DB.ExecContext(ctx, `DELETE FROM session_participants WHERE id = $1`, id)
if err != nil {
return err
}
n, _ := res.RowsAffected()
if n == 0 {
return sql.ErrNoRows
}
return nil
}
// DeleteExpired removes sessions created before olderThan whose channel
// has no messages. Returns the count of deleted rows.
func (s *SessionStore) DeleteExpired(ctx context.Context, olderThan time.Time) (int64, error) {
res, err := DB.ExecContext(ctx, `
DELETE FROM session_participants sp
WHERE sp.created_at < $1
AND NOT EXISTS (
SELECT 1 FROM messages m WHERE m.channel_id = sp.channel_id
)`, olderThan)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
// nullText returns nil for empty strings.
func nullText(s string) interface{} {
if s == "" {
return nil
}
return s
}

2
server/store/postgres/stores.go
View File

@@ -19,14 +19,12 @@ func NewStores(db *sql.DB) store.Stores {
ResourceGrants: NewResourceGrantStore(),
Notifications: NewNotificationStore(),
NotifPrefs: NewNotificationPreferenceStore(),
Sessions: NewSessionStore(),
Presence: NewPresenceStore(),
Health: NewHealthStore(db),
Connections: NewConnectionStore(),
Dependencies: NewDependencyStore(),
Packages: NewPackageStore(),
Workflows: NewWorkflowStore(),
Tasks: NewTaskStore(),
ExtPermissions: NewExtensionPermissionStore(db),
ExtData: NewExtDataStore(db),
Tickets: NewTicketStore(),

325
server/store/postgres/tasks.go
View File

@@ -1,325 +0,0 @@
package postgres
import (
"context"
"fmt"
"switchboard-core/models"
)
type TaskStore struct{}
func NewTaskStore() *TaskStore { return &TaskStore{} }
// ── Full column list (single source of truth) ──────────────────
// Used by GetByID, GetByTriggerToken, and list(). Every query must
// SELECT and Scan the same columns in the same order to prevent drift.
//
// scanTask is the ONLY function that maps columns → struct fields.
// If a column is added or reordered, update taskColumns + scanTask.
// taskColumns is the canonical SELECT list for tasks.
// COALESCE wraps nullable columns that scan into non-pointer Go types
// (string, json.RawMessage). database/sql returns "unsupported Scan,
// storing driver.Value type <nil>" for these without COALESCE.
const taskColumns = `id, owner_id, team_id, name, description, scope,
task_type, COALESCE(system_function, '') AS system_function,
persona_id, model_id, system_prompt, user_prompt,
workflow_id, COALESCE(tool_grants, '[]'::jsonb) AS tool_grants,
schedule, timezone, is_active,
COALESCE(trigger_token, '') AS trigger_token,
max_tokens, max_tool_calls, max_wall_clock, output_mode,
output_channel_id,
COALESCE(webhook_url, '') AS webhook_url,
COALESCE(webhook_secret, '') AS webhook_secret,
provider_config_id,
notify_on_complete, notify_on_failure,
last_run_at, next_run_at, run_count, created_at, updated_at`
// scanTask maps one row from taskColumns into a Task struct.
// Single source of truth — used by GetByID, GetByTriggerToken, and list().
func scanTask(scanner interface{ Scan(...interface{}) error }, t *models.Task) error {
return scanner.Scan(
&t.ID, &t.OwnerID, &t.TeamID, &t.Name, &t.Description, &t.Scope,
&t.TaskType, &t.SystemFunction,
&t.PersonaID, &t.ModelID, &t.SystemPrompt, &t.UserPrompt,
&t.WorkflowID, &t.ToolGrants, &t.Schedule, &t.Timezone, &t.IsActive,
&t.TriggerToken,
&t.MaxTokens, &t.MaxToolCalls, &t.MaxWallClock, &t.OutputMode,
&t.OutputChannelID, &t.WebhookURL, &t.WebhookSecret, &t.ProviderConfigID,
&t.NotifyOnComplete, &t.NotifyOnFailure,
&t.LastRunAt, &t.NextRunAt, &t.RunCount, &t.CreatedAt, &t.UpdatedAt,
)
}
// ── CRUD ───────────────────────────────────────
func (s *TaskStore) Create(ctx context.Context, t *models.Task) error {
toolGrants := jsonOrNull(t.ToolGrants)
return DB.QueryRowContext(ctx, `
INSERT INTO tasks (owner_id, team_id, name, description, scope,
task_type, system_function,
persona_id, model_id, system_prompt, user_prompt,
workflow_id, tool_grants, schedule, timezone, is_active,
trigger_token,
max_tokens, max_tool_calls, max_wall_clock, output_mode,
output_channel_id, webhook_url, webhook_secret, provider_config_id,
notify_on_complete, notify_on_failure, next_run_at)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28)
RETURNING id, created_at, updated_at`,
t.OwnerID, t.TeamID, t.Name, t.Description, t.Scope,
t.TaskType, t.SystemFunction,
t.PersonaID, t.ModelID, t.SystemPrompt, t.UserPrompt,
t.WorkflowID, toolGrants, t.Schedule, t.Timezone, t.IsActive,
nilIfEmpty(t.TriggerToken),
t.MaxTokens, t.MaxToolCalls, t.MaxWallClock, t.OutputMode,
t.OutputChannelID, t.WebhookURL, t.WebhookSecret, t.ProviderConfigID,
t.NotifyOnComplete, t.NotifyOnFailure, t.NextRunAt,
).Scan(&t.ID, &t.CreatedAt, &t.UpdatedAt)
}
func (s *TaskStore) GetByID(ctx context.Context, id string) (*models.Task, error) {
t := &models.Task{}
row := DB.QueryRowContext(ctx,
`SELECT `+taskColumns+` FROM tasks WHERE id = $1`, id,
)
if err := scanTask(row, t); err != nil {
return nil, err
}
return t, nil
}
func (s *TaskStore) GetByTriggerToken(ctx context.Context, token string) (*models.Task, error) {
t := &models.Task{}
row := DB.QueryRowContext(ctx,
`SELECT `+taskColumns+` FROM tasks WHERE trigger_token = $1`, token,
)
if err := scanTask(row, t); err != nil {
return nil, err
}
return t, nil
}
func (s *TaskStore) Update(ctx context.Context, id string, p models.TaskPatch) error {
// Dynamic PATCH: only update non-nil fields
q := "UPDATE tasks SET updated_at = NOW()"
args := []interface{}{}
i := 1
if p.Name != nil { q += comma(i, "name"); args = append(args, *p.Name); i++ }
if p.Description != nil { q += comma(i, "description"); args = append(args, *p.Description); i++ }
if p.PersonaID != nil { q += comma(i, "persona_id"); args = append(args, *p.PersonaID); i++ }
if p.ModelID != nil { q += comma(i, "model_id"); args = append(args, *p.ModelID); i++ }
if p.SystemPrompt != nil { q += comma(i, "system_prompt"); args = append(args, *p.SystemPrompt); i++ }
if p.UserPrompt != nil { q += comma(i, "user_prompt"); args = append(args, *p.UserPrompt); i++ }
if p.WorkflowID != nil { q += comma(i, "workflow_id"); args = append(args, *p.WorkflowID); i++ }
if p.ToolGrants != nil { q += comma(i, "tool_grants"); args = append(args, jsonOrNull(*p.ToolGrants)); i++ }
if p.Schedule != nil { q += comma(i, "schedule"); args = append(args, *p.Schedule); i++ }
if p.Timezone != nil { q += comma(i, "timezone"); args = append(args, *p.Timezone); i++ }
if p.IsActive != nil { q += comma(i, "is_active"); args = append(args, *p.IsActive); i++ }
if p.MaxTokens != nil { q += comma(i, "max_tokens"); args = append(args, *p.MaxTokens); i++ }
if p.MaxToolCalls != nil { q += comma(i, "max_tool_calls"); args = append(args, *p.MaxToolCalls); i++ }
if p.MaxWallClock != nil { q += comma(i, "max_wall_clock"); args = append(args, *p.MaxWallClock); i++ }
if p.OutputMode != nil { q += comma(i, "output_mode"); args = append(args, *p.OutputMode); i++ }
if p.OutputChannelID != nil { q += comma(i, "output_channel_id"); args = append(args, *p.OutputChannelID); i++ }
if p.WebhookURL != nil { q += comma(i, "webhook_url"); args = append(args, *p.WebhookURL); i++ }
if p.ProviderConfigID != nil { q += comma(i, "provider_config_id"); args = append(args, *p.ProviderConfigID); i++ }
if p.NotifyOnComplete != nil { q += comma(i, "notify_on_complete"); args = append(args, *p.NotifyOnComplete); i++ }
if p.NotifyOnFailure != nil { q += comma(i, "notify_on_failure"); args = append(args, *p.NotifyOnFailure); i++ }
q += pgWhere(i, "id")
args = append(args, id)
_, err := DB.ExecContext(ctx, q, args...)
return err
}
func (s *TaskStore) Delete(ctx context.Context, id string) error {
_, err := DB.ExecContext(ctx, `DELETE FROM tasks WHERE id = $1`, id)
return err
}
func (s *TaskStore) ListByOwner(ctx context.Context, ownerID string) ([]models.Task, error) {
return s.list(ctx, `WHERE owner_id = $1 ORDER BY created_at DESC`, ownerID)
}
func (s *TaskStore) ListByTeam(ctx context.Context, teamID string) ([]models.Task, error) {
return s.list(ctx, `WHERE team_id = $1 ORDER BY created_at DESC`, teamID)
}
func (s *TaskStore) ListAll(ctx context.Context) ([]models.Task, error) {
return s.list(ctx, `ORDER BY created_at DESC`)
}
func (s *TaskStore) ClaimDueTask(ctx context.Context) (*models.Task, error) {
t := &models.Task{}
row := DB.QueryRowContext(ctx, `
UPDATE tasks SET next_run_at = NULL
WHERE id = (
SELECT id FROM tasks
WHERE is_active = true AND next_run_at <= NOW()
ORDER BY next_run_at ASC
LIMIT 1
FOR UPDATE SKIP LOCKED
)
RETURNING `+taskColumns)
if err := scanTask(row, t); err != nil {
return nil, err
}
return t, nil
}
// ── Scheduler bookkeeping ──────────────────────
func (s *TaskStore) SetNextRun(ctx context.Context, id string, nextRun interface{}) error {
_, err := DB.ExecContext(ctx, `UPDATE tasks SET next_run_at = $1, updated_at = NOW() WHERE id = $2`, nextRun, id)
return err
}
func (s *TaskStore) SetLastRun(ctx context.Context, id string) error {
_, err := DB.ExecContext(ctx, `UPDATE tasks SET last_run_at = NOW(), updated_at = NOW() WHERE id = $1`, id)
return err
}
func (s *TaskStore) IncrementRunCount(ctx context.Context, id string) error {
_, err := DB.ExecContext(ctx, `UPDATE tasks SET run_count = run_count + 1, updated_at = NOW() WHERE id = $1`, id)
return err
}
// ── Run History ─────────────────────────────────
func (s *TaskStore) CreateRun(ctx context.Context, r *models.TaskRun) error {
triggerPayload := nilIfEmpty(r.TriggerPayload)
return DB.QueryRowContext(ctx, `
INSERT INTO task_runs (task_id, channel_id, status, trigger_payload)
VALUES ($1, $2, $3, $4) RETURNING id, started_at`,
r.TaskID, r.ChannelID, r.Status, triggerPayload,
).Scan(&r.ID, &r.StartedAt)
}
func (s *TaskStore) CreateRunExclusive(ctx context.Context, taskID string) (*models.TaskRun, error) {
r := &models.TaskRun{}
err := DB.QueryRowContext(ctx, `
INSERT INTO task_runs (task_id, status)
SELECT $1, 'running'
WHERE NOT EXISTS (
SELECT 1 FROM task_runs
WHERE task_id = $1 AND status IN ('running', 'queued')
)
RETURNING id, started_at`, taskID,
).Scan(&r.ID, &r.StartedAt)
if err != nil {
return nil, err
}
r.TaskID = taskID
r.Status = "running"
return r, nil
}
func (s *TaskStore) UpdateRun(ctx context.Context, id, status string, tokensUsed, toolCalls, wallClock int, errMsg string) error {
_, err := DB.ExecContext(ctx, `
UPDATE task_runs SET status = $1, tokens_used = $2, tool_calls = $3,
wall_clock = $4, error = $5, completed_at = NOW()
WHERE id = $6`, status, tokensUsed, toolCalls, wallClock, errMsg, id)
return err
}
func (s *TaskStore) TransitionRunStatus(ctx context.Context, id string, status string) error {
_, err := DB.ExecContext(ctx, `UPDATE task_runs SET status = $1 WHERE id = $2`, status, id)
return err
}
func (s *TaskStore) GetActiveRun(ctx context.Context, taskID string) (*models.TaskRun, error) {
r := &models.TaskRun{}
err := DB.QueryRowContext(ctx, `
SELECT id, task_id, channel_id, status, COALESCE(trigger_payload, ''), started_at
FROM task_runs WHERE task_id = $1 AND status = 'running'
LIMIT 1`, taskID,
).Scan(&r.ID, &r.TaskID, &r.ChannelID, &r.Status, &r.TriggerPayload, &r.StartedAt)
if err != nil {
return nil, err
}
return r, nil
}
func (s *TaskStore) GetQueuedRun(ctx context.Context, taskID string) (*models.TaskRun, error) {
r := &models.TaskRun{}
err := DB.QueryRowContext(ctx, `
SELECT id, task_id, channel_id, status, COALESCE(trigger_payload, ''), started_at
FROM task_runs WHERE task_id = $1 AND status = 'queued'
ORDER BY started_at ASC LIMIT 1`, taskID,
).Scan(&r.ID, &r.TaskID, &r.ChannelID, &r.Status, &r.TriggerPayload, &r.StartedAt)
if err != nil {
return nil, err
}
return r, nil
}
func (s *TaskStore) ListRuns(ctx context.Context, taskID string, limit int) ([]models.TaskRun, error) {
rows, err := DB.QueryContext(ctx, `
SELECT id, task_id, channel_id, status, COALESCE(trigger_payload, ''),
started_at, completed_at, tokens_used, tool_calls, wall_clock,
COALESCE(error, '')
FROM task_runs WHERE task_id = $1
ORDER BY started_at DESC LIMIT $2`, taskID, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var runs []models.TaskRun
for rows.Next() {
var r models.TaskRun
if err := rows.Scan(&r.ID, &r.TaskID, &r.ChannelID, &r.Status, &r.TriggerPayload,
&r.StartedAt, &r.CompletedAt, &r.TokensUsed, &r.ToolCalls, &r.WallClock,
&r.Error); err != nil {
continue
}
runs = append(runs, r)
}
return runs, nil
}
// ── list helper (single source of truth for SELECT + Scan) ─────
func (s *TaskStore) list(ctx context.Context, where string, args ...interface{}) ([]models.Task, error) {
q := `SELECT ` + taskColumns + ` FROM tasks ` + where
rows, err := DB.QueryContext(ctx, q, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var tasks []models.Task
for rows.Next() {
var t models.Task
if err := scanTask(rows, &t); err != nil {
continue
}
tasks = append(tasks, t)
}
return tasks, nil
}
// ── Helpers ─────────────────────────────────────
// comma builds ", column = $N"
func comma(i int, col string) string {
return ", " + col + " = " + pgArg(i)
}
// pgArg returns "$N"
func pgArg(i int) string {
return fmt.Sprintf("$%d", i)
}
// pgWhere returns " WHERE col = $N"
func pgWhere(i int, col string) string {
return " WHERE " + col + " = " + pgArg(i)
}
// nilIfEmpty returns nil for empty strings (prevents empty-string vs NULL issues).
func nilIfEmpty(s string) interface{} {
if s == "" {
return nil
}
return s
}

205
server/store/postgres/workflows.go
View File

@@ -220,7 +220,7 @@ func (s *WorkflowStore) CreateStage(ctx context.Context, st *models.WorkflowStag
transRules := jsonOrEmpty(st.TransitionRules)
stageMode := st.StageMode
if stageMode == "" {
stageMode = models.StageModeChatOnly
stageMode = models.StageModeCustom
}
return DB.QueryRowContext(ctx, `
INSERT INTO workflow_stages (workflow_id, ordinal, name, persona_id, assignment_team_id,
@@ -267,7 +267,7 @@ func (s *WorkflowStore) UpdateStage(ctx context.Context, st *models.WorkflowStag
transRules := jsonOrEmpty(st.TransitionRules)
stageMode := st.StageMode
if stageMode == "" {
stageMode = models.StageModeChatOnly
stageMode = models.StageModeCustom
}
_, err := DB.ExecContext(ctx, `
UPDATE workflow_stages
@@ -377,207 +377,6 @@ func nullIfEmpty(s string) interface{} {
// ── Assignments (v0.29.0-cs3) ───────────────────────────────────────────
func (s *WorkflowStore) CreateAssignment(ctx context.Context, a *store.WorkflowAssignment) error {
a.ID = store.NewID()
_, err := DB.ExecContext(ctx, `
INSERT INTO workflow_assignments (id, channel_id, stage, team_id)
VALUES ($1, $2, $3, $4)
`, a.ID, a.ChannelID, a.Stage, a.TeamID)
return err
}
func (s *WorkflowStore) ListAssignmentsForTeam(ctx context.Context, teamID, status string) ([]store.WorkflowAssignment, error) {
rows, err := DB.QueryContext(ctx, `
SELECT id, channel_id, stage, team_id, assigned_to, status,
created_at, claimed_at, completed_at
FROM workflow_assignments
WHERE team_id = $1 AND status = $2
ORDER BY created_at DESC
`, teamID, status)
if err != nil {
return nil, err
}
defer rows.Close()
return scanAssignments(rows)
}
func (s *WorkflowStore) ListAssignmentsMine(ctx context.Context, userID string) ([]store.WorkflowAssignment, error) {
rows, err := DB.QueryContext(ctx, `
SELECT DISTINCT wa.id, wa.channel_id, wa.stage, wa.team_id, wa.assigned_to, wa.status,
wa.created_at, wa.claimed_at, wa.completed_at
FROM workflow_assignments wa
LEFT JOIN team_members tm ON tm.team_id = wa.team_id AND tm.user_id = $1
WHERE (wa.assigned_to = $2 AND wa.status = 'claimed')
OR (wa.status = 'unassigned' AND tm.user_id IS NOT NULL)
ORDER BY wa.created_at DESC
`, userID, userID)
if err != nil {
return nil, err
}
defer rows.Close()
return scanAssignments(rows)
}
func (s *WorkflowStore) ClaimAssignment(ctx context.Context, assignmentID, userID string) (int64, error) {
res, err := DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET assigned_to = $1, status = 'claimed', claimed_at = $2
WHERE id = $3 AND status = 'unassigned'
`, userID, time.Now().UTC(), assignmentID)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
func (s *WorkflowStore) CompleteAssignment(ctx context.Context, assignmentID string) (int64, error) {
res, err := DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET status = 'completed', completed_at = $1
WHERE id = $2 AND status = 'claimed'
`, time.Now().UTC(), assignmentID)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
func (s *WorkflowStore) GetAssignmentChannelID(ctx context.Context, assignmentID string) (string, error) {
var channelID string
err := DB.QueryRowContext(ctx,
`SELECT channel_id FROM workflow_assignments WHERE id = $1`, assignmentID).Scan(&channelID)
return channelID, err
}
// ── Lifecycle operations (v0.37.15) ──
func (s *WorkflowStore) CancelAssignmentsForChannel(ctx context.Context, channelID string) (int64, error) {
res, err := DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET status = 'cancelled'
WHERE channel_id = $1 AND status IN ('unassigned', 'claimed')
`, channelID)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
func (s *WorkflowStore) UnclaimAssignment(ctx context.Context, assignmentID string) (int64, error) {
res, err := DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET status = 'unassigned', assigned_to = NULL, claimed_at = NULL
WHERE id = $1 AND status = 'claimed'
`, assignmentID)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
func (s *WorkflowStore) ReassignAssignment(ctx context.Context, assignmentID, newUserID string) (int64, error) {
res, err := DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET assigned_to = $1, claimed_at = $2
WHERE id = $3 AND status = 'claimed'
`, newUserID, time.Now().UTC(), assignmentID)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
func (s *WorkflowStore) CancelAssignment(ctx context.Context, assignmentID string) (int64, error) {
res, err := DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET status = 'cancelled'
WHERE id = $1 AND status IN ('unassigned', 'claimed')
`, assignmentID)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
func (s *WorkflowStore) TryRoundRobin(ctx context.Context, teamID, assignmentID string) (string, error) {
// Find least-recently-assigned team member
rows, err := DB.QueryContext(ctx, `
SELECT m.user_id, COALESCE(MAX(wa.claimed_at), '1970-01-01T00:00:00Z') as last_claim
FROM team_members m
LEFT JOIN workflow_assignments wa ON wa.assigned_to = m.user_id AND wa.team_id = $1
WHERE m.team_id = $2
GROUP BY m.user_id
ORDER BY last_claim ASC
LIMIT 1
`, teamID, teamID)
if err != nil {
return "", err
}
defer rows.Close()
if !rows.Next() {
return "", nil // no team members
}
var userID, lastClaim string
if err := rows.Scan(&userID, &lastClaim); err != nil {
return "", err
}
// Claim for that user
_, err = DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET assigned_to = $1, status = 'claimed', claimed_at = $2
WHERE id = $3 AND status = 'unassigned'
`, userID, time.Now().UTC(), assignmentID)
if err != nil {
return "", err
}
return userID, nil
}
func scanAssignments(rows *sql.Rows) ([]store.WorkflowAssignment, error) {
var result []store.WorkflowAssignment
for rows.Next() {
var a store.WorkflowAssignment
if err := rows.Scan(&a.ID, &a.ChannelID, &a.Stage, &a.TeamID,
&a.AssignedTo, &a.Status, &a.CreatedAt, &a.ClaimedAt, &a.CompletedAt); err != nil {
return nil, err
}
result = append(result, a)
}
if result == nil {
result = []store.WorkflowAssignment{}
}
return result, rows.Err()
}
// ── Review Comments (v0.35.0) ───────────────────────────
func (s *WorkflowStore) GetAssignmentByID(ctx context.Context, id string) (*store.WorkflowAssignment, error) {
var a store.WorkflowAssignment
var rc []byte
err := DB.QueryRowContext(ctx, `
SELECT id, channel_id, stage, team_id, assigned_to, status,
review_comments, created_at, claimed_at, completed_at
FROM workflow_assignments WHERE id = $1
`, id).Scan(&a.ID, &a.ChannelID, &a.Stage, &a.TeamID, &a.AssignedTo, &a.Status,
&rc, &a.CreatedAt, &a.ClaimedAt, &a.CompletedAt)
if err != nil {
return nil, err
}
a.ReviewComments = rc
return &a, nil
}
func (s *WorkflowStore) AddReviewComment(ctx context.Context, assignmentID string, comment store.ReviewComment) error {
commentJSON, err := json.Marshal(comment)
if err != nil {
return err
}
_, err = DB.ExecContext(ctx, `
UPDATE workflow_assignments
SET review_comments = review_comments || $1::jsonb
WHERE id = $2
`, "["+string(commentJSON)+"]", assignmentID)
return err
}