@repo-os/repoos 0.5.45

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

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

package/dist/server/routes/transcribe.js

@@ -0,0 +1,124 @@
+import { json } from "./utils.js";
+async function transcribeWithGroq(apiKey, audioBuffer, mimeType) {
+    const formData = new FormData();
+    const blob = new Blob([new Uint8Array(audioBuffer)], { type: mimeType });
+    const extension = mimeType.split("/")[1] || "webm";
+    formData.append("file", blob, `audio.${extension}`);
+    formData.append("model", "whisper-large-v3");
+    const response = await fetch("https://api.groq.com/openai/v1/audio/transcriptions", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Groq transcription failed: ${response.status} ${error}`);
+    }
+    const result = (await response.json());
+    return result.text || "";
+}
+async function transcribeWithOpenAI(apiKey, audioBuffer, mimeType) {
+    const formData = new FormData();
+    const blob = new Blob([new Uint8Array(audioBuffer)], { type: mimeType });
+    const extension = mimeType.split("/")[1] || "webm";
+    formData.append("file", blob, `audio.${extension}`);
+    formData.append("model", "whisper-1");
+    const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`OpenAI transcription failed: ${response.status} ${error}`);
+    }
+    const result = (await response.json());
+    return result.text || "";
+}
+function parseMultipart(buffer, boundary) {
+    const parts = new Map();
+    const bufferStr = buffer.toString("binary");
+    const delimiter = `--${boundary}`;
+    const sections = bufferStr.split(delimiter);
+    for (const section of sections) {
+        if (!section.trim() || section.trim() === "--")
+            continue;
+        const headerEnd = section.indexOf("\r\n\r\n");
+        if (headerEnd === -1)
+            continue;
+        const headers = section.slice(0, headerEnd);
+        const body = section.slice(headerEnd + 4); // skip \r\n\r\n
+        // Remove trailing \r\n-- if present
+        const cleanBody = body.replace(/\r\n--$/, "");
+        const nameMatch = headers.match(/name="([^"]+)"/);
+        if (!nameMatch)
+            continue;
+        const name = nameMatch[1];
+        const mimeMatch = headers.match(/Content-Type:\s*([^\r\n]+)/i);
+        const mimeType = mimeMatch ? mimeMatch[1].trim() : undefined;
+        parts.set(name, {
+            data: Buffer.from(cleanBody, "binary"),
+            mimeType,
+        });
+    }
+    return parts;
+}
+export const transcribe = async (ctx, req, res) => {
+    const { config } = ctx;
+    // Check if whisper is configured
+    const provider = config.whisper?.provider || "none";
+    const apiKey = config.whisper?.apiKey || "";
+    if (!provider || provider === "none" || !apiKey) {
+        return json(res, 400, { error: "Voice transcription not configured" });
+    }
+    // Parse multipart form data
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(chunk);
+    }
+    try {
+        const buffer = Buffer.concat(chunks);
+        const contentType = req.headers["content-type"] || "";
+        const boundaryMatch = contentType.match(/boundary=([^;]+)/);
+        const boundary = boundaryMatch ? boundaryMatch[1] : "";
+        let audioBuffer = null;
+        let mimeType = "audio/webm";
+        if (boundary) {
+            const parts = parseMultipart(buffer, boundary);
+            const audioPart = parts.get("audio");
+            if (audioPart) {
+                audioBuffer = audioPart.data;
+                if (audioPart.mimeType)
+                    mimeType = audioPart.mimeType;
+            }
+        }
+        else {
+            // If no boundary, assume the entire body is audio
+            audioBuffer = buffer;
+        }
+        if (!audioBuffer || audioBuffer.length === 0) {
+            return json(res, 400, { error: "No audio data provided" });
+        }
+        let text = "";
+        if (provider === "groq") {
+            text = await transcribeWithGroq(apiKey, audioBuffer, mimeType);
+        }
+        else if (provider === "openai") {
+            text = await transcribeWithOpenAI(apiKey, audioBuffer, mimeType);
+        }
+        else {
+            return json(res, 400, { error: `Unknown provider: ${provider}` });
+        }
+        return json(res, 200, { text: text || "" });
+    }
+    catch (err) {
+        console.error("Transcription error:", err);
+        return json(res, 500, {
+            error: `Transcription failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+};

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

@@ -0,0 +1,68 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RepoOSConfig, Task, Status } from "../../core/types.js";
+import type { RepoOS } from "../../core/repoos.js";
+import type { LiveIndex, RepoEvent } from "../live-index.js";
+import type { AgentRunner } from "../agents.js";
+import type { PreviewManager } from "../preview.js";
+import type { ReviewManager } from "../review.js";
+import type { CTOManager } from "../cto.js";
+import type { CloseOutLock } from "../done.js";
+import type { RootLock } from "../repo-lock.js";
+import type { ReloadManager } from "../reload.js";
+import type { JobCoordinator } from "../integration-job.js";
+import type { Logger } from "../../core/logger.js";
+import type { DoneStep } from "../done.js";
+import type { RemoteValidator } from "../remote-validation.js";
+export interface SyncResult {
+    ok: boolean;
+    conflicts: string[];
+    reason?: string;
+}
+export interface RouteContext {
+    config: RepoOSConfig;
+    index: LiveIndex;
+    /**
+     * Resolves once the full background index build finishes on server boot
+     * (the `refreshAllAsync` kicked off in `startServer`). Index-reading routes
+     * (board, tasks, index) await this so a request racing the boot-time
+     * asynchronous reindex — the exact shape that left the board showing a
+     * stale/partial snapshot after a reload handoff (0285) — can never answer
+     * against a half-built index.
+     */
+    indexReady: Promise<void>;
+    runner: AgentRunner;
+    previews: PreviewManager;
+    reviews: ReviewManager;
+    cto: CTOManager;
+    repoos: RepoOS;
+    logger: Logger;
+    emitEvent: (e: RepoEvent) => void;
+    closeOutLock: CloseOutLock;
+    rootLock: RootLock;
+    jobCoordinator: JobCoordinator;
+    /** Remote Validation Runner (docs/remote-validation.md). Undefined when not configured. */
+    remoteValidator?: RemoteValidator;
+    /**
+     * Live progress step last reported by the close-out orchestrator for each
+     * in-flight task (the same map `emitIntegration`'s SSE push uses) — keyed
+     * by task id. A route that builds a pipeline snapshot for an
+     * ALREADY-in-flight job (the GET hydration endpoint) must read this rather
+     * than pass `{}`, or the stage shown falls back to a coarse per-phase
+     * guess (e.g. "validating" always reads as "merge", even mid-test-run)
+     * until the next SSE event happens to correct it — misleading on a page
+     * refresh mid-pipeline (0207 follow-up).
+     */
+    reportedStages: Record<string, DoneStep>;
+    triggerJobProcessing: () => void;
+    pendingReview: Set<string>;
+    uiDir: string | null;
+    reload: ReloadManager | null;
+    syncTaskBranch: (task: Task) => Promise<SyncResult>;
+    onServerStatusChange: (task: Task, prev: Status, next: Status) => void;
+}
+export type RouteHandler = (ctx: RouteContext, req: IncomingMessage, res: ServerResponse, params: Record<string, string>) => Promise<void> | void;
+export interface Route {
+    method: string;
+    path: string | RegExp;
+    handler: RouteHandler;
+}

package/dist/server/routes/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import type { RouteHandler } from "./types.js";
+export declare const serveManifest: RouteHandler;
+export declare const serveStaticFile: RouteHandler;
+export declare function setIconRenderer(fn: (size: number, color?: string) => Buffer): void;
+export declare const serveIcon: RouteHandler;

package/dist/server/routes/ui.js

@@ -0,0 +1,81 @@
+import { basename } from "node:path";
+import { serveStaticUi } from "./helpers.js";
+/** Read the optional repo color from the `c` query param, or null when absent/invalid. */
+function colorFromUrl(req) {
+    const url = req.url ? new URL(req.url, "http://localhost") : null;
+    const c = url?.searchParams.get("c");
+    return c && /^#[0-9a-f]{6}$/i.test(c) ? c.toLowerCase() : null;
+}
+export const serveManifest = (ctx, req, res) => {
+    const { config } = ctx;
+    const name = basename(config.root) || "repoos";
+    const c = colorFromUrl(req);
+    const suffix = c ? `?c=${c}` : "";
+    const manifest = JSON.stringify({
+        id: "/",
+        name: `RepoOS · ${name}`,
+        short_name: `RepoOS · ${name}`,
+        description: `Repo-native task tracking for ${name}`,
+        start_url: "/",
+        scope: "/",
+        display: "standalone",
+        orientation: "portrait-primary",
+        background_color: "#070a12",
+        theme_color: "#070a12",
+        icons: [
+            { src: `/icons/icon-192.png${suffix}`, sizes: "192x192", type: "image/png" },
+            { src: `/icons/icon-512.png${suffix}`, sizes: "512x512", type: "image/png" },
+            {
+                src: `/icons/icon-512.png${suffix}`,
+                sizes: "512x512",
+                type: "image/png",
+                purpose: "maskable",
+            },
+        ],
+    }, null, 2);
+    res.writeHead(200, {
+        "Content-Type": "application/manifest+json; charset=utf-8",
+        "Cache-Control": "no-cache",
+        "Access-Control-Allow-Origin": "*",
+    });
+    res.end(manifest);
+};
+export const serveStaticFile = (ctx, _req, res, params) => {
+    const { uiDir } = ctx;
+    if (!uiDir) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("UI not found");
+        return;
+    }
+    const urlPath = params.path ?? "/";
+    if (!serveStaticUi(res, uiDir, urlPath)) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+    }
+};
+// Icon rendering function - will be called from main server with SVG generation logic
+let renderIconFn = null;
+export function setIconRenderer(fn) {
+    renderIconFn = fn;
+}
+export const serveIcon = (_ctx, req, res, params) => {
+    if (!renderIconFn) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Icon renderer not initialized");
+        return;
+    }
+    const size = params.param1 ? parseInt(params.param1, 10) : 0;
+    if (!size || (size !== 192 && size !== 512)) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Invalid icon size");
+        return;
+    }
+    const color = colorFromUrl(req);
+    const png = renderIconFn(size, color ?? undefined);
+    res.writeHead(200, {
+        "Content-Type": "image/png",
+        "Cache-Control": "max-age=86400",
+        "Access-Control-Allow-Origin": "*",
+    });
+    res.end(png);
+};

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

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function json(res: ServerResponse, status: number, body: unknown): void;
+export declare function readBody(req: IncomingMessage): Promise<unknown>;

package/dist/server/routes/utils.js

@@ -0,0 +1,23 @@
+export function json(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET,POST,PATCH,PUT,OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+    });
+    res.end(payload);
+}
+export async function readBody(req) {
+    const chunks = [];
+    for await (const c of req)
+        chunks.push(c);
+    if (chunks.length === 0)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        return {};
+    }
+}

package/dist/server/serve-reaper.d.ts

@@ -0,0 +1,135 @@
+export interface ServeLockInfo {
+    pid: number;
+    port: number;
+    host: string;
+    startedAt: string;
+}
+/**
+ * Manages a single lockfile that tracks the live serve process for a repo.
+ * At startup, detects and reaps stale processes. Prevents port conflicts.
+ * Skip cleanup when spawned as a reload replacement (REPOOS_RELOAD=1) so
+ * the parent can exit gracefully through its close handler.
+ */
+export declare class ServeReaper {
+    private readonly lockPath;
+    private readonly pid;
+    private readonly repoRoot;
+    /** Ephemeral test/harness servers must never touch the control-plane lock. */
+    private readonly enabled;
+    private registered;
+    private rootWatch;
+    /**
+     * A preview child (`repoos serve --port <ephemeral>` rooted at a task
+     * worktree) is NOT the control-plane server, so the single-per-repo serve
+     * lockfile and its stale-reaping/conflict logic don't apply to it. If it ran
+     * `cleanupStale`, it would reap whatever sibling preview happens to be in the
+     * worktree's lockfile (killing a booting preview mid-health-check → "did not
+     * become ready"), and because ephemeral ports can be reused, `detectConflict`
+     * could even refuse to bind a port that is already stale in the lockfile.
+     * Disable the reaper entirely for preview children (#0183).
+     */
+    private readonly previewChild;
+    constructor(repoRoot: string, cacheDir?: string, enabled?: boolean, port?: number);
+    /**
+     * Close this server when the checkout it serves disappears.  Fixture and
+     * preview roots are frequently removed before their child process receives
+     * its normal shutdown signal; a lockfile inside that deleted root can no
+     * longer help a later startup reap it.  The watch is deliberately owned by
+     * the server process, so it also covers standalone fixture `serve` calls.
+     *
+     * A real repo root can be momentarily invisible (a rename while the dir is
+     * moved, a network-FS blip) without being gone — tearing the server down on
+     * such a transient miss would kill the live control plane.  The root must
+     * be missing for `missesRequired` consecutive checks before `onMissing`
+     * fires; a deleted fixture/preview root stays gone, so this only delays the
+     * self-close by `missesRequired × intervalMs`.
+     */
+    watchRoot(onMissing: () => void, intervalMs?: number, missesRequired?: number): () => void;
+    /**
+     * Check if a process with the given PID is still running and matches our
+     * expected serve characteristics (the repoos CLI binary in the command line).
+     * On Windows, the check is limited to existence (kill -0).
+     */
+    private isProcessAlive;
+    /**
+     * Boot-time cleanup: detect and reap stale processes from the lockfile.
+     * SKIPPED when spawned as a reload replacement (REPOOS_RELOAD=1) so the
+     * parent process can exit gracefully without being killed mid-shutdown.
+     * This is safe to call multiple times and always succeeds (best-effort).
+     */
+    cleanupStale(): void;
+    /**
+     * Reap historical fixture/preview servers whose deleted root also took their
+     * lockfile with it.  This is intentionally narrower than a generic process
+     * sweep: it requires the RepoOS CLI's `serve` command shape AND a cwd under
+     * the system temp dir that no longer exists — the exact shape of every
+     * observed orphan (`/var/folders/.../repoos-release-*`, `.../repoos-autoprev-*`).
+     * A user's live control plane, every healthy preview, and a sibling project
+     * that happens to be briefly unmounted or renamed therefore remain untouched
+     * (a real repo never lives under tmpdir).
+     *
+     * Async and best-effort so a boot full of accumulated orphans can never
+     * block serve startup: the `ps` scan and the per-process `lsof` cwd lookups
+     * run off the event loop, with the lookups capped in flight.  Returns the
+     * number of processes killed.
+     */
+    cleanupOrphanedRoots(): Promise<number>;
+    /**
+     * Detect if a port is already bound by a live serve process.
+     * Returns a human-readable error message if there's a conflict, null otherwise.
+     *
+     * Two independent signals are consulted:
+     *   1. The live port probe (new): is *something* actually listening? Consulted
+     *      first so a missing/stale/corrupt lockfile can no longer mask a live
+     *      listener — the single source of truth for "is the port taken" is the
+     *      port itself, not the lockfile (#0284).
+     *   2. The lockfile (existing): when it names a live process for this exact
+     *      port/host, that yields the most specific conflict (PID + start time).
+     *
+     * The probe matters because binding a port a lockfile-less-but-live process
+     * owns would otherwise either EADDRINUSE with a confusing error or, worse,
+     * silently steal a port mid-drain during another process's reload.
+     */
+    detectConflict(port: number, host: string): Promise<string | null>;
+    /**
+     * Register the current process as serving on the given port.
+     * Call this after successful bind. Idempotent.
+     */
+    register(port: number, host: string): void;
+    /**
+     * Unregister the current process. Call on shutdown.
+     * Idempotent: unregistering when not registered is a no-op.
+     */
+    unregister(): void;
+    private removeLock;
+    private stopWatchingRoot;
+    /** Read a process cwd from lsof's machine-readable output, best-effort. */
+    private processCwdAsync;
+    /** The command line of `pid`, or null when the process is already gone. */
+    private commandOf;
+    private killProcess;
+}
+/**
+ * True when a TCP connection can be established to host:port — i.e. some
+ * process is actually listening there. This is the ground truth for "is the
+ * port taken", consulted alongside the lockfile so a missing/stale/corrupt
+ * lockfile can't mask a live listener (#0284). Best-effort and async: any
+ * connect error (connection refused, timeout, unroutable host) resolves false,
+ * and an invalid port resolves false immediately.
+ */
+export declare function isPortListening(port: number, host: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * True when a process command line has the RepoOS CLI `serve` shape — the
+ * compiled `.../cli/index.js serve` or dev `.../src/cli/index.ts serve`.  The
+ * orphan sweep requires this shape in addition to a deleted temp-dir root, so
+ * unrelated processes are never touched.
+ */
+export declare function isOrphanServeCommand(command: string): boolean;
+/**
+ * True when `cwd` is a deleted root under the system temp dir — the exact
+ * shape of every observed orphan (fixture/preview temp dirs).  A real repo —
+ * the live control plane, a preview worktree, any sibling project — never
+ * lives under tmpdir, so a briefly-unmounted or renamed repo cannot be
+ * mistaken for an orphan and killed.  Exported for testing.
+ */
+export declare function isOrphanRoot(cwd: string): boolean;