@repo-os/repoos 0.5.45

package/dist/server/routes/models.js

@@ -0,0 +1,36 @@
+import { json, readBody } from "./utils.js";
+import { AGENT_CLIS } from "../../core/config.js";
+import { listModelSources } from "../../core/models.js";
+import { testModelCombination } from "../model-test.js";
+export const listModels = async (ctx, req, res) => {
+    const { config } = ctx;
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const refresh = url.searchParams.get("refresh") === "1";
+    let byCli = {};
+    try {
+        byCli = await listModelSources({ refresh, cwd: config.root });
+    }
+    catch {
+        byCli = {};
+    }
+    return json(res, 200, { byCli, at: new Date().toISOString() });
+};
+export const testModel = async (ctx, _req, res) => {
+    const { config } = ctx;
+    try {
+        const body = (await readBody(_req));
+        if (typeof body.cli !== "string" ||
+            !AGENT_CLIS.includes(body.cli)) {
+            return json(res, 400, { error: "cli must be a supported coding agent" });
+        }
+        if (typeof body.model !== "string" || !body.model.trim() || body.model.length > 120) {
+            return json(res, 400, { error: "model must be a non-empty string" });
+        }
+        const result = await testModelCombination(body.cli, body.model, { cwd: config.root });
+        return json(res, 200, { result, at: new Date().toISOString() });
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        return json(res, 500, { error: `Model compatibility test failed: ${reason}` });
+    }
+};

package/dist/server/routes/notify.d.ts

@@ -0,0 +1,2 @@
+import type { RouteHandler } from "./types.js";
+export declare const testNotification: RouteHandler;

package/dist/server/routes/notify.js

@@ -0,0 +1,17 @@
+import { basename } from "node:path";
+import { json } from "./utils.js";
+import { publish } from "../ntfy.js";
+export const testNotification = (ctx, _req, res) => {
+    const { config } = ctx;
+    if (!config.ntfyEnabled) {
+        return json(res, 400, { error: "ntfy notifications are disabled" });
+    }
+    const topic = (config.ntfyTopic ?? "").trim();
+    if (!topic) {
+        return json(res, 400, { error: "ntfy topic is empty" });
+    }
+    const repoName = basename(config.root);
+    const message = `Hello from RepoOS at ${repoName}!`;
+    publish(config, message);
+    return json(res, 200, { ok: true });
+};

package/dist/server/routes/playground.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Model Playground routes (0313): serves the curated "worth trying" catalog
+ * (GET) and runs a stateless chat turn against a chosen model (POST).
+ *
+ * The chat turn reuses the same `opencode run --model <id>` one-shot path
+ * every other role (PM, reviewer, freeform doc) already goes through — the
+ * playground's `runId` (`${providerId}/${modelId}`) is exactly the model id
+ * opencode expects, so no new API-key handling is needed: opencode's own
+ * provider auth on the server machine covers it, keeping keys out of the
+ * client entirely.
+ */
+import type { RouteHandler } from "./types.js";
+/** Exported for tests. */
+export declare function isKnownRunId(runId: string): boolean;
+export declare const getPlaygroundModels: RouteHandler;
+export interface PlaygroundChatMessage {
+    role: "user" | "assistant";
+    text: string;
+}
+/** Trim/validate the client-supplied history into a safe, bounded turn list. Exported for tests. */
+export declare function sanitizePlaygroundHistory(raw: unknown): PlaygroundChatMessage[];
+/**
+ * Build a one-shot prompt carrying the whole visible conversation: opencode's
+ * `run` command is stateless per-invocation, so multi-turn context has to be
+ * folded into the prompt text itself rather than resumed via a session id.
+ * Exported for tests.
+ */
+export declare function buildPlaygroundPrompt(runId: string, history: PlaygroundChatMessage[]): string;
+export declare const sendPlaygroundMessage: RouteHandler;

package/dist/server/routes/playground.js

@@ -0,0 +1,81 @@
+import { json, readBody } from "./utils.js";
+import { listPlaygroundModels, PLAYGROUND_PROVIDERS } from "../../core/providers/index.js";
+import { runPrompt, recordOneShotSession } from "../agents.js";
+/**
+ * `runId` is `${providerId}/${modelId}`, forwarded verbatim as an opencode
+ * `--model` argv value (see `promptCommand` in agents.ts) — safe from shell
+ * injection since it's spawned via argv, never a shell string, but still
+ * worth constraining to the character set real provider/model ids use and to
+ * a provider we've actually registered, so a malformed client payload fails
+ * fast with a clear 400 instead of reaching the CLI at all.
+ */
+const RUN_ID_PATTERN = /^[a-zA-Z0-9][\w.-]*\/[\w.:/~-]+$/;
+/** Exported for tests. */
+export function isKnownRunId(runId) {
+    if (!RUN_ID_PATTERN.test(runId))
+        return false;
+    const providerId = runId.slice(0, runId.indexOf("/"));
+    return PLAYGROUND_PROVIDERS.some((p) => p.id === providerId);
+}
+export const getPlaygroundModels = async (_ctx, req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const refresh = url.searchParams.get("refresh") === "1";
+    const providers = await listPlaygroundModels({ refresh });
+    return json(res, 200, { providers, at: new Date().toISOString() });
+};
+const MAX_HISTORY_MESSAGES = 20;
+const MAX_MESSAGE_LEN = 8000;
+/** Trim/validate the client-supplied history into a safe, bounded turn list. Exported for tests. */
+export function sanitizePlaygroundHistory(raw) {
+    const list = Array.isArray(raw) ? raw : [];
+    return list
+        .slice(-MAX_HISTORY_MESSAGES)
+        .map((m) => ({
+        role: m.role === "assistant" ? "assistant" : "user",
+        text: typeof m.text === "string" ? m.text.slice(0, MAX_MESSAGE_LEN).trim() : "",
+    }))
+        .filter((m) => m.text.length > 0);
+}
+/**
+ * Build a one-shot prompt carrying the whole visible conversation: opencode's
+ * `run` command is stateless per-invocation, so multi-turn context has to be
+ * folded into the prompt text itself rather than resumed via a session id.
+ * Exported for tests.
+ */
+export function buildPlaygroundPrompt(runId, history) {
+    const turns = history
+        .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text}`)
+        .join("\n\n");
+    return [
+        `You are the model ${runId}, being tried out in a quick chat playground. Answer the user's latest message directly and concisely.`,
+        turns,
+        "Assistant:",
+    ].join("\n\n");
+}
+export const sendPlaygroundMessage = async (ctx, req, res) => {
+    const { config } = ctx;
+    const body = (await readBody(req));
+    const runId = typeof body.runId === "string" ? body.runId.trim() : "";
+    if (!runId || runId.length > 200 || !isKnownRunId(runId)) {
+        return json(res, 400, { error: "runId must be a known provider/model id" });
+    }
+    const history = sanitizePlaygroundHistory(body.messages);
+    if (!history.length || history[history.length - 1].role !== "user") {
+        return json(res, 400, { error: "the last message must be a non-empty user message" });
+    }
+    const agent = { name: "playground", cli: "opencode", model: runId, enabled: true };
+    const prompt = buildPlaygroundPrompt(runId, history);
+    const result = await runPrompt(agent, prompt, { cwd: config.root });
+    recordOneShotSession(config.root, agent, result, { sessionType: "playground", taskId: null });
+    if (!result.ok || !result.output) {
+        return json(res, 502, { error: result.error ?? "the model returned no output" });
+    }
+    return json(res, 200, {
+        ok: true,
+        text: result.output,
+        elapsedMs: result.elapsedMs,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        costUsd: result.costUsd,
+    });
+};

package/dist/server/routes/release.d.ts

@@ -0,0 +1,20 @@
+import type { RouteHandler } from "./types.js";
+import { type ReleasePhase } from "../release.js";
+export interface ReleaseRun {
+    state: "idle" | "running" | "succeeded" | "failed";
+    phase: ReleasePhase | null;
+    message: string;
+    startedAt: string | null;
+    updatedAt: string | null;
+}
+export declare const getRelease: RouteHandler;
+export declare const getReleaseRun: RouteHandler;
+export declare const runRelease: RouteHandler;
+/**
+ * Draft release notes from the commits since the last release (full history
+ * when there is none) with the repo's one-shot LLM plumbing. This never cuts a
+ * release — it only returns text for the modal to drop into its optional notes
+ * field, where the operator can edit it before confirming the cut. A failure
+ * here is reported to the caller and has no effect on the cut flow.
+ */
+export declare const generateReleaseNotes: RouteHandler;

package/dist/server/routes/release.js

@@ -0,0 +1,86 @@
+import { json, readBody } from "./utils.js";
+import { collectReleaseCommits, cutNewRelease, getReleaseStatus, releaseNotesPrompt, } from "../release.js";
+import { extractOneShotReportText, pmCommand, recordOneShotSession, resolveEngineer, resolvePmAgent, runPrompt, } from "../agents.js";
+/**
+ * Which agent drafts release notes. The PM owns authoring, so prefer it; fall
+ * back to the engineer when a repo has the PM disabled. Null means neither is
+ * enabled and the generate button should report that rather than fail opaquely.
+ */
+function releaseNotesAgent(config) {
+    return resolvePmAgent(config) ?? resolveEngineer(config);
+}
+let run = { state: "idle", phase: null, message: "", startedAt: null, updatedAt: null };
+function updateRun(phase, message, state = "running") {
+    run = {
+        state,
+        phase,
+        message,
+        startedAt: run.startedAt ?? new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+}
+export const getRelease = async (ctx, _req, res) => json(res, 200, await getReleaseStatus(ctx.config));
+export const getReleaseRun = (_ctx, _req, res) => json(res, 200, run);
+export const runRelease = async (ctx, req, res) => {
+    const body = (await readBody(req));
+    if (typeof body.version !== "string" || typeof body.confirmTag !== "string")
+        return json(res, 400, { error: "version and confirmTag are required" });
+    if (run.state === "running")
+        return json(res, 409, { error: "A release is already running", run });
+    const notes = typeof body.notes === "string" && body.notes.trim() ? body.notes : undefined;
+    run = {
+        state: "running",
+        phase: "preparing",
+        message: "Starting release…",
+        startedAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    void cutNewRelease(ctx.config, body.version, body.confirmTag, undefined, (phase, message) => updateRun(phase, message), ctx.remoteValidator, notes)
+        // Keep the phase that was in flight when it failed, so the UI can say
+        // "failed during checking" rather than a bare "failed".
+        .then((result) => updateRun(result.ok ? null : run.phase, result.output, result.ok ? "succeeded" : "failed"))
+        .catch(() => updateRun(null, "Release runner stopped unexpectedly. Check the repository state before retrying.", "failed"));
+    return json(res, 202, { ok: true, run });
+};
+/**
+ * Draft release notes from the commits since the last release (full history
+ * when there is none) with the repo's one-shot LLM plumbing. This never cuts a
+ * release — it only returns text for the modal to drop into its optional notes
+ * field, where the operator can edit it before confirming the cut. A failure
+ * here is reported to the caller and has no effect on the cut flow.
+ */
+export const generateReleaseNotes = async (ctx, req, res) => {
+    const { config } = ctx;
+    const body = (await readBody(req));
+    const version = typeof body.version === "string" && body.version.trim() ? body.version : null;
+    const agent = releaseNotesAgent(config);
+    if (!agent) {
+        return json(res, 400, {
+            error: "No agent is enabled to draft release notes — enable the PM or Engineer agent.",
+        });
+    }
+    const { commits, sinceTag, truncated } = await collectReleaseCommits(config);
+    if (!commits.length) {
+        // Nothing new to summarize is not an error: the cut can still proceed.
+        return json(res, 200, { notes: "", sinceTag, commitCount: 0, truncated });
+    }
+    const prompt = releaseNotesPrompt(commits, { sinceTag, version, truncated });
+    const result = await runPrompt(agent, prompt, {
+        cwd: config.root,
+        // Structured output so extractUsage records real tokens/cost for this
+        // board-level call (house rule: every one-shot LLM call is recorded).
+        command: pmCommand(agent, prompt, config.root),
+    });
+    recordOneShotSession(config.root, agent, result, {
+        sessionType: "release-notes",
+        taskId: null,
+    });
+    if (!result.ok || !result.output) {
+        return json(res, 502, { error: result.error ?? "The agent returned no release notes." });
+    }
+    const notes = extractOneShotReportText(agent.cli, result.output);
+    if (!notes) {
+        return json(res, 502, { error: "The agent returned no usable release notes." });
+    }
+    return json(res, 200, { notes, sinceTag, commitCount: commits.length, truncated });
+};

package/dist/server/routes/router.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext, RouteHandler } from "./types.js";
+export interface RouterEntry {
+    method: string;
+    pattern: string | RegExp;
+    handler: RouteHandler;
+}
+export declare class Router {
+    private routes;
+    register(method: string, pattern: string | RegExp, handler: RouteHandler): void;
+    dispatch(ctx: RouteContext, method: string, path: string, req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+}

package/dist/server/routes/router.js

@@ -0,0 +1,32 @@
+export class Router {
+    routes = [];
+    register(method, pattern, handler) {
+        this.routes.push({ method, pattern, handler });
+    }
+    async dispatch(ctx, method, path, req, res) {
+        for (const route of this.routes) {
+            if (route.method !== method)
+                continue;
+            let match = null;
+            if (typeof route.pattern === "string") {
+                if (route.pattern !== path)
+                    continue;
+                match = null;
+            }
+            else {
+                match = path.match(route.pattern);
+                if (!match)
+                    continue;
+            }
+            const params = {};
+            if (match) {
+                for (let i = 1; i < match.length; i++) {
+                    params[`param${i}`] = match[i];
+                }
+            }
+            await route.handler(ctx, req, res, params);
+            return true;
+        }
+        return false;
+    }
+}

package/dist/server/routes/skill-registry.d.ts

@@ -0,0 +1,5 @@
+import type { RouteHandler } from "./types.js";
+export declare const getRegistryCurated: RouteHandler;
+export declare const searchRegistry: RouteHandler;
+export declare const getRegistryDetail: RouteHandler;
+export declare const installRegistry: RouteHandler;

package/dist/server/routes/skill-registry.js

@@ -0,0 +1,51 @@
+import { json, readBody } from "./utils.js";
+import { curatedRegistrySkills, installRegistrySkill, registryAudit, registryDetail, searchRegistrySkills, } from "../../core/skills-registry.js";
+export const getRegistryCurated = async (_ctx, _req, res) => {
+    try {
+        return json(res, 200, { skills: await curatedRegistrySkills() });
+    }
+    catch (error) {
+        return json(res, 502, {
+            error: error instanceof Error ? error.message : "Skills.sh unavailable",
+        });
+    }
+};
+export const searchRegistry = async (_ctx, req, res) => {
+    const q = new URL(req.url ?? "/", "http://localhost").searchParams.get("q") ?? "";
+    try {
+        return json(res, 200, { skills: await searchRegistrySkills(q) });
+    }
+    catch (error) {
+        return json(res, 502, {
+            error: error instanceof Error ? error.message : "Skills.sh unavailable",
+        });
+    }
+};
+export const getRegistryDetail = async (_ctx, req, res) => {
+    const id = new URL(req.url ?? "/", "http://localhost").searchParams.get("id") ?? "";
+    try {
+        const [detail, audit] = await Promise.all([registryDetail(id), registryAudit(id)]);
+        return json(res, 200, { detail, audit });
+    }
+    catch (error) {
+        return json(res, 400, { error: error instanceof Error ? error.message : "Skill unavailable" });
+    }
+};
+export const installRegistry = async (ctx, req, res) => {
+    const body = (await readBody(req));
+    if (typeof body.id !== "string")
+        return json(res, 400, { error: "id is required" });
+    try {
+        const detail = await registryDetail(body.id);
+        return json(res, 201, {
+            ok: true,
+            ...installRegistrySkill(ctx.config, detail),
+            hash: detail.hash,
+        });
+    }
+    catch (error) {
+        return json(res, 400, {
+            error: error instanceof Error ? error.message : "Could not install skill",
+        });
+    }
+};

package/dist/server/routes/tasks.d.ts

@@ -0,0 +1,58 @@
+import type { RouteHandler } from "./types.js";
+export declare const getTasks: RouteHandler;
+export declare const createTask: RouteHandler;
+export declare const createFreeformTask: RouteHandler;
+export declare const getTask: RouteHandler;
+export declare const patchTask: RouteHandler;
+export declare const deleteTask: RouteHandler;
+export declare const getScreenshot: RouteHandler;
+export declare const uploadScreenshot: RouteHandler;
+export declare const getTaskLogs: RouteHandler;
+export declare const getTaskOutput: RouteHandler;
+export declare const taskAction: RouteHandler;
+export declare const startPreview: RouteHandler;
+export declare const stopPreview: RouteHandler;
+export declare const getTaskReview: RouteHandler;
+export declare const reviewAgain: RouteHandler;
+export declare const reviewMessage: RouteHandler;
+export declare const getCTO: RouteHandler;
+export declare const ctoMessage: RouteHandler;
+/** Interrupt a running CTO response. Idempotent. */
+export declare const ctoInterrupt: RouteHandler;
+/**
+ * Build the "newly attached screenshots" fragment appended to the PM's task
+ * context (#0382). Each entry surfaces the API URL and the repo-relative
+ * path so the PM can either link them or quote them when editing the spec.
+ * Empty/missing url+path combos are silently dropped. Returns an empty
+ * string when there are no usable screenshots, leaving the prompt unchanged
+ * for plain text messages.
+ */
+export declare function buildPmShotContext(incoming: ReadonlyArray<unknown>): string;
+export declare const pmMessage: RouteHandler;
+/**
+ * Interrupt a running PM response about a task. Resolves the same per-user PM
+ * session id as `pmMessage` and stops the in-flight agent turn. Idempotent.
+ */
+export declare const pmInterrupt: RouteHandler;
+export declare const getIntegrationJob: RouteHandler;
+export declare const getIntegrationJobs: RouteHandler;
+/**
+ * Full integration-pipeline snapshot for the pinned status bar (0207).
+ * Reads the same live `reportedStages` map the SSE push path uses, so a
+ * page refresh mid-pipeline shows the job's actual current sub-step (e.g.
+ * "check", mid-test-run) rather than falling back to a coarse per-phase
+ * guess (0207 follow-up — see RouteContext.reportedStages).
+ */
+export declare const getIntegrationPipeline: RouteHandler;
+/**
+ * Retry a failed integration job (0207). Reuses the coordinator's existing
+ * retry path: `enqueue` re-enqueues a `failed` job as a fresh queued job
+ * (see integration-job.ts), then processing resumes from the queue.
+ */
+export declare const retryIntegration: RouteHandler;
+export declare const getTaskStats: RouteHandler;
+export declare const getSessionTypeStats: RouteHandler;
+export declare const getBoardStats: RouteHandler;
+export declare const getDailyTotals: RouteHandler;
+export declare const getDiffStatsForTask: RouteHandler;
+export declare const getDiffForTask: RouteHandler;