package pipeline import ( "context" "crypto/sha256" "database/sql" "encoding/json" "fmt" "os" "path/filepath" "slices" "strings" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) func (s *Store) initSavedSchedules() error { _, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS saved_schedules ( id INTEGER PRIMARY KEY AUTOINCREMENT, revision INTEGER NOT NULL, pipeline_id INTEGER NOT NULL, enabled INTEGER NOT NULL, deleted INTEGER NOT NULL DEFAULT 0, spec_json TEXT NOT NULL, next_due TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, legacy_version INTEGER, legacy_slot INTEGER, UNIQUE(pipeline_id,legacy_version,legacy_slot)); CREATE INDEX IF NOT EXISTS saved_schedules_pipeline ON saved_schedules(pipeline_id,deleted,enabled); CREATE TABLE IF NOT EXISTS saved_schedule_events ( schedule_id INTEGER NOT NULL, due TEXT NOT NULL, revision INTEGER NOT NULL, status TEXT NOT NULL, diagnostic TEXT NOT NULL DEFAULT '', run_id INTEGER, PRIMARY KEY(schedule_id,due)); CREATE TABLE IF NOT EXISTS run_schedule_origin ( run_id INTEGER PRIMARY KEY REFERENCES pipeline_runs(id) ON DELETE CASCADE, schedule_id INTEGER NOT NULL DEFAULT 0, name TEXT NOT NULL DEFAULT ''); CREATE TABLE IF NOT EXISTS schedule_migrations (name TEXT PRIMARY KEY); CREATE TABLE IF NOT EXISTS schedule_create_requests ( request_key TEXT PRIMARY KEY, schedule_id INTEGER NOT NULL REFERENCES saved_schedules(id), payload_hash TEXT NOT NULL);`) if err != nil { return err } return s.importLegacySchedules() } // One transaction imports only the latest old slots, but retains every old event // and derives historical provenance exclusively from actual event.run_id links. // The durable marker and tombstones prevent deletion/disable resurrection. func (s *Store) importLegacySchedules() error { ctx := context.Background() tx, err := s.db.BeginTx(ctx, nil) if err != nil { return err } defer tx.Rollback() var done int if err := tx.QueryRow(`SELECT COUNT(*) FROM schedule_migrations WHERE name='external-v1'`).Scan(&done); err != nil { return err } if done != 0 { return tx.Commit() } rows, err := tx.Query(`SELECT v.pipeline_id,v.version,p.name,v.graph_json FROM pipeline_versions v JOIN pipelines p ON p.id=v.pipeline_id WHERE v.version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=v.pipeline_id)`) if err != nil { return err } type legacy struct { id int64 version int name string graph protocol.Graph } var all []legacy for rows.Next() { var l legacy var text string if err := rows.Scan(&l.id, &l.version, &l.name, &text); err != nil { rows.Close() return err } if err := json.Unmarshal([]byte(text), &l.graph); err != nil { rows.Close() return err } all = append(all, l) } err = rows.Err() rows.Close() if err != nil { return err } now := time.Now() for _, l := range all { if l.graph.Settings == nil { continue } for slot, rule := range l.graph.Settings.Schedules { if rule.Timezone == "" { // Preserve execution-server-local semantics without capturing an // offline opener's timezone. ScheduleLocation resolves Local there. rule.Timezone = "Local" } next, err := NextSchedule(rule, now) if err != nil { return err } var due string err = tx.QueryRow(`SELECT next_due FROM schedule_state WHERE pipeline_id=? AND version=? AND slot=?`, l.id, l.version, slot).Scan(&due) if err == sql.ErrNoRows { due = next.UTC().Format(time.RFC3339Nano) } else if err != nil { return err } // Opening a store does not identify the execution server: maintenance // and offline clients can migrate it from any working directory. // Only runner startup may bind this trusted legacy exception. spec := protocol.SavedSchedule{Name: fmt.Sprintf("%s (legacy %d)", l.name, slot+1), PipelineID: l.id, Version: l.version, Enabled: true, Input: map[string]any{"prompt": l.graph.Settings.Prompt}, Rule: rule} text, err := json.Marshal(spec) if err != nil { return err } stamp := now.UTC().Format(time.RFC3339Nano) if _, err = tx.Exec(`INSERT INTO saved_schedules(revision,pipeline_id,enabled,spec_json,next_due,created_at,updated_at,legacy_version,legacy_slot) VALUES(1,?,1,?,?,?,?,?,?)`, l.id, string(text), due, stamp, stamp, l.version, slot); err != nil { return err } } } _, err = tx.Exec(`INSERT OR IGNORE INTO run_schedule_origin(run_id,schedule_id,name) SELECT e.run_id,COALESCE(s.id,0),COALESCE(json_extract(s.spec_json,'$.name'),p.name || ' (legacy schedule)') FROM schedule_events e JOIN pipeline_runs r ON r.id=e.run_id AND r.pipeline_id=e.pipeline_id AND r.version=e.version JOIN pipelines p ON p.id=e.pipeline_id LEFT JOIN saved_schedules s ON s.pipeline_id=e.pipeline_id AND s.legacy_version=e.version AND s.legacy_slot=e.slot WHERE e.run_id>0`) if err != nil { return err } if _, err = tx.Exec(`INSERT INTO schedule_migrations(name) VALUES('external-v1')`); err != nil { return err } return tx.Commit() } // BindLegacyScheduleWorkspace captures the old runtime-default workspace once, // from the execution server before admission APIs or the scheduler are available. // Store.Open never supplies it. Blank workspaces are allowed only on imported // legacy rows; normal saves always require an explicit accessible directory. // Only this missing field is filled: revisions, cadence, enabled state, tombstones, // provenance and any workspace already chosen by the operator remain untouched. func (s *Store) BindLegacyScheduleWorkspace(ctx context.Context, workspace string) error { resolved, err := ResolveRunWorkspace(workspace, true) if err != nil { return err } s.mu.Lock() defer s.mu.Unlock() _, err = s.db.ExecContext(ctx, `UPDATE saved_schedules SET spec_json=json_set(spec_json,'$.workspace',?) WHERE legacy_version IS NOT NULL AND legacy_slot IS NOT NULL AND deleted=0 AND COALESCE(json_extract(spec_json,'$.workspace'),'')=''`, resolved) return err } const savedScheduleSelect = `SELECT id,revision,spec_json,next_due,created_at,updated_at FROM saved_schedules` func scanSavedSchedule(row interface{ Scan(...any) error }) (protocol.SavedSchedule, error) { var item protocol.SavedSchedule var text, due, created, updated string var id, rev int64 err := row.Scan(&id, &rev, &text, &due, &created, &updated) if err != nil { return item, err } if err = json.Unmarshal([]byte(text), &item); err != nil { return item, err } item.ID = id item.Revision = rev item.NextDue = due item.CreatedAt = created item.UpdatedAt = updated return item, nil } func (s *Store) ListSchedules(ctx context.Context, pipelineID int64) ([]protocol.SavedSchedule, error) { rows, err := s.db.QueryContext(ctx, savedScheduleSelect+` WHERE deleted=0 AND (?=0 OR pipeline_id=?) ORDER BY id`, pipelineID, pipelineID) if err != nil { return nil, err } defer rows.Close() items := []protocol.SavedSchedule{} for rows.Next() { item, err := scanSavedSchedule(rows) if err != nil { return nil, err } items = append(items, item) } return items, rows.Err() } // SaveSchedule does not execute models or change definitions. All run configuration // is checked against the pinned graph before any durable mutation. func (s *Store) SaveSchedule(ctx context.Context, spec protocol.SavedSchedule, now time.Time, requestKeys ...string) (*protocol.SavedSchedule, error) { var requestKey string if len(requestKeys) > 0 { requestKey = requestKeys[0] } if len(requestKey) > 128 { return nil, fmt.Errorf("schedule create request key must be at most 128 bytes") } if spec.ID < 0 || spec.Revision < 0 || (spec.ID == 0) != (spec.Revision == 0) { return nil, fmt.Errorf("schedule ID and revision must both be zero for creation or positive for update") } spec.Name = strings.TrimSpace(spec.Name) if spec.Name == "" || len(spec.Name) > 200 || strings.ContainsAny(spec.Name, "\r\n\x00") { return nil, fmt.Errorf("schedule name must be 1–200 bytes without line breaks or NUL") } if spec.Version <= 0 { return nil, fmt.Errorf("schedule requires an explicit positive pipeline version") } workspace, err := ResolveRunWorkspace(spec.Workspace, true) if err != nil { return nil, err } spec.Workspace = workspace if err = ValidateRunWritePaths(workspace, spec.WritePaths); err != nil { return nil, err } if prompt, ok := spec.Input["prompt"].(string); !ok || strings.TrimSpace(prompt) == "" { return nil, fmt.Errorf("a nonempty user prompt is required in input.prompt") } if _, err = json.Marshal(spec.Input); err != nil { return nil, err } if err = protocol.ValidateOutputFormat(spec.OutputFormat); err != nil { return nil, err } if spec.NotifyMode != "" && spec.NotifyMode != "auto" && spec.NotifyMode != "on" && spec.NotifyMode != "off" { return nil, fmt.Errorf("notify_mode must be auto, on or off") } d, err := s.Get(ctx, spec.PipelineID, spec.Version) if err != nil { return nil, err } if _, err = EffectiveModels(d.Graph, spec.Model, spec.StageModels); err != nil { return nil, err } if spec.Rule.Timezone == "" { spec.Rule.Timezone = time.Local.String() } if err = ValidateSchedule(spec.Rule); err != nil { return nil, err } // Hash only normalized editable information, never a computed due time or // client-supplied server metadata. This namespace is separate from run keys. canonical := spec canonical.ID = 0 canonical.Revision = 0 canonical.NextDue = "" canonical.CreatedAt = "" canonical.UpdatedAt = "" canonical.NotifyMode = notifyMode(canonical.NotifyMode) canonical.Rule.Days = slices.Sorted(slices.Values(canonical.Rule.Days)) canonical.Rule.Times = slices.Sorted(slices.Values(canonical.Rule.Times)) payload, err := json.Marshal(canonical) if err != nil { return nil, err } payloadHash := fmt.Sprintf("%x", sha256.Sum256(payload)) next, err := NextSchedule(spec.Rule, now) if err != nil { return nil, err } s.mu.Lock() defer s.mu.Unlock() tx, err := s.db.BeginTx(ctx, nil) if err != nil { return nil, err } defer tx.Rollback() if spec.ID == 0 && requestKey != "" { var id int64 var oldHash string err := tx.QueryRowContext(ctx, `SELECT schedule_id,payload_hash FROM schedule_create_requests WHERE request_key=?`, requestKey).Scan(&id, &oldHash) if err == nil { if oldHash != payloadHash { return nil, fmt.Errorf("schedule create request key already used for different run information") } existing, err := scanSavedSchedule(tx.QueryRowContext(ctx, savedScheduleSelect+` WHERE id=? AND deleted=0`, id)) if err == sql.ErrNoRows { return nil, fmt.Errorf("schedule created by this request key was deleted; use a new key for an intentional new schedule") } if err != nil { return nil, err } if err = tx.Commit(); err != nil { return nil, err } return &existing, nil } if err != sql.ErrNoRows { return nil, err } } stamp := now.UTC().Format(time.RFC3339Nano) spec.NextDue = next.UTC().Format(time.RFC3339Nano) spec.CreatedAt = stamp spec.UpdatedAt = stamp if spec.ID != 0 { old, err := scanSavedSchedule(tx.QueryRowContext(ctx, savedScheduleSelect+` WHERE id=? AND deleted=0`, spec.ID)) if err != nil { return nil, fmt.Errorf("schedule not found: %w", err) } if old.Revision != spec.Revision { return nil, fmt.Errorf("schedule revision conflict; reload before editing") } if old.Enabled == spec.Enabled && sameScheduleRule(old.Rule, spec.Rule) { spec.NextDue = old.NextDue } spec.CreatedAt = old.CreatedAt } spec.Revision++ encoded, err := json.Marshal(spec) if err != nil { return nil, err } if spec.ID == 0 { result, err := tx.ExecContext(ctx, `INSERT INTO saved_schedules(revision,pipeline_id,enabled,spec_json,next_due,created_at,updated_at) VALUES(1,?,?,?,?,?,?)`, spec.PipelineID, spec.Enabled, string(encoded), spec.NextDue, spec.CreatedAt, stamp) if err != nil { return nil, err } spec.ID, err = result.LastInsertId() if err != nil { return nil, err } if requestKey != "" { if _, err = tx.ExecContext(ctx, `INSERT INTO schedule_create_requests(request_key,schedule_id,payload_hash) VALUES(?,?,?)`, requestKey, spec.ID, payloadHash); err != nil { return nil, err } } } else { result, err := tx.ExecContext(ctx, `UPDATE saved_schedules SET revision=?,pipeline_id=?,enabled=?,spec_json=?,next_due=?,updated_at=? WHERE id=? AND revision=? AND deleted=0`, spec.Revision, spec.PipelineID, spec.Enabled, string(encoded), spec.NextDue, stamp, spec.ID, spec.Revision-1) if err != nil { return nil, err } n, err := result.RowsAffected() if err != nil { return nil, err } if n != 1 { return nil, fmt.Errorf("schedule revision conflict") } } if err = tx.Commit(); err != nil { return nil, err } return &spec, nil } func sameScheduleRule(a, b protocol.Schedule) bool { // Omitted arrays and empty arrays mean the same rule, as does ordering a // weekday/clock set differently. Neither should reset an unchanged cadence. return a.Every == b.Every && a.Timezone == b.Timezone && slices.Equal(slices.Sorted(slices.Values(a.Days)), slices.Sorted(slices.Values(b.Days))) && slices.Equal(slices.Sorted(slices.Values(a.Times)), slices.Sorted(slices.Values(b.Times))) } func (s *Store) DeleteSchedule(ctx context.Context, id, revision int64) error { if id <= 0 || revision <= 0 { return fmt.Errorf("schedule ID and expected_revision must be positive") } s.mu.Lock() defer s.mu.Unlock() result, err := s.db.ExecContext(ctx, `UPDATE saved_schedules SET deleted=1,enabled=0,revision=revision+1,updated_at=? WHERE id=? AND revision=? AND deleted=0`, time.Now().UTC().Format(time.RFC3339Nano), id, revision) if err != nil { return err } n, err := result.RowsAffected() if err != nil { return err } if n != 1 { return fmt.Errorf("schedule revision conflict or schedule not found") } return nil } func (s *Store) ClaimSavedSchedule(ctx context.Context, item protocol.SavedSchedule, due, next time.Time, status string) (bool, error) { s.mu.Lock() defer s.mu.Unlock() tx, err := s.db.BeginTx(ctx, nil) if err != nil { return false, err } defer tx.Rollback() result, err := tx.ExecContext(ctx, `UPDATE saved_schedules SET next_due=? WHERE id=? AND revision=? AND enabled=1 AND deleted=0 AND next_due=?`, next.UTC().Format(time.RFC3339Nano), item.ID, item.Revision, due.UTC().Format(time.RFC3339Nano)) if err != nil { return false, err } n, err := result.RowsAffected() if err != nil || n == 0 { return false, err } _, err = tx.ExecContext(ctx, `INSERT INTO saved_schedule_events(schedule_id,due,revision,status) VALUES(?,?,?,?)`, item.ID, due.UTC().Format(time.RFC3339Nano), item.Revision, status) if err != nil { return false, err } return true, tx.Commit() } func (s *Store) FinishSavedSchedule(ctx context.Context, id int64, due time.Time, status, diagnostic string) error { _, err := s.db.ExecContext(ctx, `UPDATE saved_schedule_events SET status=?,diagnostic=? WHERE schedule_id=? AND due=?`, status, diagnostic, id, due.UTC().Format(time.RFC3339Nano)) return err } // ScheduleAdmission is an internal capability, never decoded from public messages. type ScheduleAdmission struct { ID, Revision int64 Due time.Time Name string } // ResolveRunWorkspace shares exactly the server's manual-run folder semantics. // Only execution-server startup may capture the old legacy default directory. func ResolveRunWorkspace(selected string, required bool) (string, error) { if selected == "" { if required { return "", fmt.Errorf("schedule workspace must be an explicit absolute directory on the execution server") } var err error selected, err = os.Getwd() if err != nil { return "", err } } if !filepath.IsAbs(selected) { return "", fmt.Errorf("run workspace must be an absolute directory") } resolved, err := filepath.EvalSymlinks(selected) if err != nil { return "", fmt.Errorf("run workspace is unavailable on the execution server: %q: %w; for Docker, mount this host directory at the same absolute path and use its owner's UID/GID", selected, err) } info, err := os.Stat(resolved) if err != nil || !info.IsDir() { return "", fmt.Errorf("run workspace %q must be an accessible directory on the execution server", selected) } return resolved, nil }