go-api-route-compliance

Answer

Root cause: openapi.yaml declared 6 routes (POST /cron/jobs/{job_id}/enable|disable + POST /workspaces/{id}/config/opencode/validate|apply|rollback|repair) that the Go backend never registered — a spec-audit gap. The fix registers all 6 as thin adapters over existing machinery: the cron routes are backward-compatible aliases of the existing job handler, and the 4 opencode handlers reuse pkg/opencode (ValidateConfig/MergeConfigs/DefaultBaselineConfig) plus the existing ConfigStore — no new persistence (no new tables, no new repos).

Route registration (method-scoped patterns, Go 1.22+ http.ServeMux):

func registerRoutes(mux *http.ServeMux, deps Deps) {
    oc := newOpencodeHandler(deps.Configs, deps.Workspaces, deps.Audit)
    cron := newCronHandler(deps.Jobs)

    // openapi-spec routes added by SPEC-GAP-002 fix
    mux.HandleFunc("POST /workspaces/{id}/config/opencode/validate", oc.validateConfig)
    mux.HandleFunc("POST /workspaces/{id}/config/opencode/apply", oc.applyConfig)
    mux.HandleFunc("POST /workspaces/{id}/config/opencode/rollback", oc.rollbackConfig)
    mux.HandleFunc("POST /workspaces/{id}/config/opencode/repair", oc.repairConfig)

    // backward-compat cron routes: spec path + legacy path → same handler
    mux.HandleFunc("POST /cron/jobs/{job_id}/enable", cron.enableJob)
    mux.HandleFunc("POST /cron/jobs/{job_id}/disable", cron.disableJob)
    mux.HandleFunc("POST /jobs/{job_id}/enable", cron.enableJob)   // legacy alias
    mux.HandleFunc("POST /jobs/{job_id}/disable", cron.disableJob) // legacy alias
}

Handler pattern — one opencodeHandler reusing pkg/opencode; e.g. apply (validate → merge → push history → persist via existing store) and the rollback/repair fallbacks:

func (h *opencodeHandler) applyConfig(w http.ResponseWriter, r *http.Request) {
    wsID := r.PathValue("id")
    if !h.workspace.Exists(r.Context(), wsID) {
        httpx.NotFound(w, "workspace not found: "+wsID); return
    }
    cfg, err := decodeConfig(r)
    if err != nil { httpx.BadRequest(w, err.Error()); return }
    if problems := opencode.ValidateConfig(cfg); len(problems) > 0 {
        httpx.WriteJSON(w, http.StatusUnprocessableEntity,
            map[string]any{"valid": false, "problems": problems, "applied": false})
        return
    }
    current, err := h.configs.Get(r.Context(), wsID, configKind)
    if err != nil && !errors.Is(err, store.ErrNotFound) {
        httpx.WriteJSON(w, http.StatusInternalServerError, map[string]any{"error": "read current config"})
        return
    }
    next := opencode.MergeConfigs(current, cfg) // existing merge machinery
    if !errors.Is(err, store.ErrNotFound) {
        _ = h.configs.Push(r.Context(), wsID, configKind, current) // snapshot for rollback
    }
    if err := h.configs.Set(r.Context(), wsID, configKind, next); err != nil {
        httpx.WriteJSON(w, http.StatusInternalServerError, map[string]any{"error": "persist config"})
        return
    }
    _ = h.audit.Record(r.Context(), wsID, "opencode.apply", summary(next))
    httpx.WriteJSON(w, http.StatusOK, map[string]any{"applied": true, "config": next})
}

Key semantics: validate is pure (never persists); apply pushes the previous document onto rollback history before overwriting; rollback is LIFO with DefaultBaselineConfig() fallback when history is empty; repair rewrites a broken stored doc by merging over DefaultBaselineConfig(), sanitizing rules (drop empty id/path, dedupe), and re-validating the merge — falling back to baseline scalars for any field that still fails (this was a real bug my own test caught: a blind merge keeps non-empty-but-invalid models). Body is capped at 1 MiB with a deterministic 400.