@repo-os/repoos 0.5.45

package/dist/server/test-run.d.ts

@@ -0,0 +1,28 @@
+import type { RepoOSConfig } from "../core/types.js";
+export interface TestRunState {
+    running: boolean;
+    startedAt: string | null;
+    finishedAt: string | null;
+    /** Process exit code, or null while running / if the process never exited cleanly. */
+    code: number | null;
+    /** Full output so far (stdout+stderr interleaved in arrival order), capped. */
+    output: string;
+}
+export declare class TestRunManager {
+    private state;
+    private proc;
+    getState(): TestRunState;
+    /**
+     * Starts `bun run test` in `config.root`. Rejects if a run is already in
+     * progress — one at a time, so output/timing never interleaves between
+     * two runs. `onChunk` fires for every stdout/stderr chunk as it arrives;
+     * `onDone` fires once, with the exit code (null if the process itself
+     * failed to spawn or was killed by a signal).
+     */
+    start(config: RepoOSConfig, onChunk: (chunk: string) => void, onDone: (code: number | null) => void): {
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    };
+}

package/dist/server/test-run.js

@@ -0,0 +1,81 @@
+/**
+ * Runs the full `bun run test` suite as an ephemeral background process and
+ * streams its output live over SSE (Control page's "Run full test suite"
+ * button). Deliberately minimal compared to AgentRunner: no durable
+ * registry, no reload-adoption, no per-task log files — this is a one-off
+ * admin action, not a resumable session, so it doesn't need to survive a
+ * server restart. A run in progress when the server restarts is simply
+ * gone; the human just clicks the button again.
+ */
+import { spawn } from "node:child_process";
+/** Cap on retained output so a very long/noisy run can't grow this without
+ *  bound in memory — old text is dropped from the front, oldest first. */
+const MAX_BUFFERED_CHARS = 2_000_000;
+export class TestRunManager {
+    state = {
+        running: false,
+        startedAt: null,
+        finishedAt: null,
+        code: null,
+        output: "",
+    };
+    proc = null;
+    getState() {
+        return this.state;
+    }
+    /**
+     * Starts `bun run test` in `config.root`. Rejects if a run is already in
+     * progress — one at a time, so output/timing never interleaves between
+     * two runs. `onChunk` fires for every stdout/stderr chunk as it arrives;
+     * `onDone` fires once, with the exit code (null if the process itself
+     * failed to spawn or was killed by a signal).
+     */
+    start(config, onChunk, onDone) {
+        if (this.state.running) {
+            return { ok: false, reason: "a test run is already in progress" };
+        }
+        this.state = {
+            running: true,
+            startedAt: new Date().toISOString(),
+            finishedAt: null,
+            code: null,
+            output: "",
+        };
+        const proc = spawn("bun", ["run", "test"], {
+            cwd: config.root,
+            // NO_COLOR/CI suppress vitest's ANSI color codes and interactive
+            // cursor movement, which the plain <pre> log has no use for and which
+            // would otherwise show up as literal escape-sequence garbage.
+            env: { ...process.env, NO_COLOR: "1", CI: "1" },
+        });
+        this.proc = proc;
+        const handleChunk = (buf) => {
+            const text = buf.toString("utf8");
+            this.state.output += text;
+            if (this.state.output.length > MAX_BUFFERED_CHARS) {
+                this.state.output = this.state.output.slice(this.state.output.length - MAX_BUFFERED_CHARS);
+            }
+            onChunk(text);
+        };
+        proc.stdout?.on("data", handleChunk);
+        proc.stderr?.on("data", handleChunk);
+        proc.on("close", (code) => {
+            this.state.running = false;
+            this.state.finishedAt = new Date().toISOString();
+            this.state.code = code;
+            this.proc = null;
+            onDone(code);
+        });
+        proc.on("error", (err) => {
+            const text = `\n[could not start test run: ${err.message}]\n`;
+            this.state.output += text;
+            onChunk(text);
+            this.state.running = false;
+            this.state.finishedAt = new Date().toISOString();
+            this.state.code = null;
+            this.proc = null;
+            onDone(null);
+        });
+        return { ok: true };
+    }
+}

package/dist/server/watcher.d.ts

@@ -0,0 +1,21 @@
+import type { RepoOSConfig } from "../core/types.js";
+import type { LiveIndex } from "./live-index.js";
+export declare class WorkWatcher {
+    private config;
+    private index;
+    private watchers;
+    private timers;
+    private watchedDirs;
+    private pathToMtime;
+    private pollTimer;
+    constructor(config: RepoOSConfig, index: LiveIndex);
+    start(): void;
+    stop(): void;
+    private tryRecursive;
+    private watchTree;
+    private schedule;
+    private updateMtime;
+    private reconcile;
+    private scanDirectory;
+    private isTaskFile;
+}

package/dist/server/watcher.js

@@ -0,0 +1,194 @@
+/**
+ * File watcher over the work directory. Uses Node/Bun native fs.watch — no
+ * dependency. Editors and agents often emit several events for a single save
+ * (write temp file, rename, chmod), so we debounce per-path before telling the
+ * LiveIndex anything.
+ *
+ * fs.watch recursion support varies by platform (works on macOS and Windows,
+ * historically not on Linux). We try recursive first and fall back to watching
+ * each subdirectory individually, re-scanning when directories appear.
+ *
+ * fs.watch can drop events under rapid filesystem activity. To ensure the index
+ * never silently diverges from disk, we layer a low-frequency poll (every 5s) as
+ * a platform-proof fallback, comparing mtimes to catch missed content changes,
+ * new files, and deletions. fs.watch remains the primary, low-latency path.
+ */
+import { watch, existsSync, readdirSync, statSync } from "node:fs";
+import { join, extname } from "node:path";
+const DEBOUNCE_MS = 60;
+const DEFAULT_POLL_MS = 5000;
+export class WorkWatcher {
+    config;
+    index;
+    watchers = [];
+    timers = new Map();
+    watchedDirs = new Set();
+    pathToMtime = new Map();
+    pollTimer = null;
+    constructor(config, index) {
+        this.config = config;
+        this.index = index;
+    }
+    start() {
+        const workPath = join(this.config.root, this.config.workDir);
+        if (!existsSync(workPath))
+            return;
+        if (!this.tryRecursive(workPath)) {
+            this.watchTree(workPath);
+        }
+        this.pollTimer = setInterval(() => this.reconcile(), DEFAULT_POLL_MS);
+        this.pollTimer.unref?.();
+    }
+    stop() {
+        for (const w of this.watchers) {
+            try {
+                w.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.watchers = [];
+        for (const t of this.timers.values())
+            clearTimeout(t);
+        this.timers.clear();
+        this.watchedDirs.clear();
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        this.pathToMtime.clear();
+    }
+    tryRecursive(dir) {
+        try {
+            const w = watch(dir, { recursive: true }, (_event, filename) => {
+                if (!filename)
+                    return;
+                this.schedule(join(dir, filename.toString()));
+            });
+            this.watchers.push(w);
+            return true;
+        }
+        catch {
+            return false; // ENOSYS / EINVAL on platforms without recursive support
+        }
+    }
+    watchTree(dir) {
+        if (this.watchedDirs.has(dir))
+            return;
+        let w;
+        try {
+            w = watch(dir, (_event, filename) => {
+                if (!filename)
+                    return;
+                const full = join(dir, filename.toString());
+                // a new subdirectory may need its own watcher
+                try {
+                    if (existsSync(full) && statSync(full).isDirectory()) {
+                        this.watchTree(full);
+                        return;
+                    }
+                }
+                catch {
+                    /* fall through to schedule */
+                }
+                this.schedule(full);
+            });
+        }
+        catch {
+            return;
+        }
+        this.watchers.push(w);
+        this.watchedDirs.add(dir);
+        // recurse into existing subdirs
+        try {
+            for (const entry of readdirSync(dir)) {
+                if (entry.startsWith("."))
+                    continue;
+                const sub = join(dir, entry);
+                if (statSync(sub).isDirectory())
+                    this.watchTree(sub);
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    schedule(absPath) {
+        const existing = this.timers.get(absPath);
+        if (existing)
+            clearTimeout(existing);
+        this.timers.set(absPath, setTimeout(() => {
+            this.timers.delete(absPath);
+            this.updateMtime(absPath);
+            this.index.applyFileChange(absPath);
+        }, DEBOUNCE_MS));
+    }
+    updateMtime(absPath) {
+        try {
+            if (existsSync(absPath)) {
+                const stat = statSync(absPath);
+                this.pathToMtime.set(absPath, stat.mtimeMs);
+            }
+            else {
+                this.pathToMtime.delete(absPath);
+            }
+        }
+        catch {
+            /* ignore stat errors */
+        }
+    }
+    reconcile() {
+        const workPath = join(this.config.root, this.config.workDir);
+        if (!existsSync(workPath))
+            return;
+        const seenPaths = new Set();
+        this.scanDirectory(workPath, seenPaths);
+        // Check for deletions: tracked files that no longer exist
+        for (const [path] of this.pathToMtime) {
+            if (!seenPaths.has(path) && !existsSync(path)) {
+                this.pathToMtime.delete(path);
+                this.index.applyFileDelete(path);
+            }
+        }
+    }
+    scanDirectory(dir, seenPaths) {
+        try {
+            for (const entry of readdirSync(dir)) {
+                if (entry.startsWith("."))
+                    continue;
+                const fullPath = join(dir, entry);
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        this.scanDirectory(fullPath, seenPaths);
+                    }
+                    else if (this.isTaskFile(fullPath)) {
+                        seenPaths.add(fullPath);
+                        const currentMtime = stat.mtimeMs;
+                        const cachedMtime = this.pathToMtime.get(fullPath);
+                        if (cachedMtime === undefined) {
+                            // New file not yet tracked
+                            this.pathToMtime.set(fullPath, currentMtime);
+                            this.index.applyFileChange(fullPath);
+                        }
+                        else if (cachedMtime !== currentMtime) {
+                            // Content changed (mtime differs)
+                            this.pathToMtime.set(fullPath, currentMtime);
+                            this.index.applyFileChange(fullPath);
+                        }
+                    }
+                }
+                catch {
+                    /* ignore stat errors on individual entries */
+                }
+            }
+        }
+        catch {
+            /* ignore directory read errors */
+        }
+    }
+    isTaskFile(absPath) {
+        return this.config.taskExtensions.includes(extname(absPath));
+    }
+}

package/dist/server/write.d.ts

@@ -0,0 +1,94 @@
+import type { RepoOSConfig, Task, Status } from "../core/types.js";
+import { type ScreenshotMeta } from "./attachments.js";
+export interface TaskPatch {
+    status?: Status;
+    title?: string;
+    priority?: string;
+    area?: string;
+    assignedTo?: string;
+    branch?: string;
+    type?: string;
+    body?: string;
+    /** Clear (false) or set (true) the waiting-on-human flag. */
+    needsInput?: boolean;
+    /** Machine-readable reason `needsInput` was set, or null to clear it. Only meaningful alongside `needsInput: true`. */
+    needsInputReason?: string | null;
+    /** Clear (false) or set (true) the branch-drifted flag. */
+    needsMerge?: boolean;
+    /** Per-task agent name override, or null to clear. */
+    agentOverride?: string | null;
+    /** Per-task CLI override, or null to clear. */
+    cliOverride?: string | null;
+    /** Per-task model override, or null to clear. */
+    modelOverride?: string | null;
+    /** Per-task PM agent name override, or null to clear. */
+    pmAgentOverride?: string | null;
+    /** Per-task PM CLI override, or null to clear. */
+    pmCliOverride?: string | null;
+    /** Per-task PM model override, or null to clear. */
+    pmModelOverride?: string | null;
+    /** Per-task reviewer agent name override, or null to clear. */
+    reviewAgentOverride?: string | null;
+    /** Per-task reviewer CLI override, or null to clear. */
+    reviewCliOverride?: string | null;
+    /** Per-task reviewer model override, or null to clear. */
+    reviewModelOverride?: string | null;
+    /**
+     * Append one uploaded screenshot to the task's `## Screenshots` section
+     * (created before `## Activity` when absent). This is the only mutation path
+     * for that section; a body replacement in this or a later patch never drops
+     * it (see {@link PROTECTED_SECTIONS}).
+     */
+    addScreenshot?: ScreenshotMeta;
+    /**
+     * Append several screenshots in one patch (0381): the PM chat's pending
+     * images land on a freshly created task as a batch, so the section is
+     * written once with a single activity entry instead of one rewrite per
+     * image. Same section rules as `addScreenshot`.
+     */
+    addScreenshots?: ScreenshotMeta[];
+    /** Set hotfix mode (true to enable, false to disable). */
+    hotfix?: boolean;
+    /** Hotfix merge target. */
+    hotfixTarget?: "branch" | "main";
+    /**
+     * Append a short, free-form note to the task's activity log (e.g.
+     * instructions from a PM/reviewer back to the developer). The note is
+     * recorded as its own activity entry — it never rewrites the task body and
+     * can be combined with a status transition in the same patch. An empty or
+     * whitespace-only note is ignored.
+     */
+    note?: string | null;
+}
+export interface PatchTaskOptions {
+    /**
+     * Called when a patch actually changes a task's status, with the task being
+     * written and the previous/new statuses. Lets the server reap preview
+     * servers when a task leaves active/review (see preview.ts).
+     */
+    onStatusChange?: (task: Task, prev: Status, next: Status) => void;
+}
+export declare class WriteError extends Error {
+}
+/** Thrown when a delete target resolves outside the configured work dir. */
+export declare class PathGuardError extends WriteError {
+}
+/**
+ * Apply a patch to a task file safely. `absPath` is the file to edit. Returns
+ * the freshly re-parsed Task. Throws WriteError on bad input or missing file.
+ */
+export declare function patchTaskFile(config: RepoOSConfig, absPath: string, patch: TaskPatch, opts?: PatchTaskOptions): Task;
+/**
+ * Mark the successful end of the review-to-done flow in the task's existing
+ * append-only activity log. This is deliberately separate from TaskPatch so a
+ * normal status edit cannot make an unmerged task appear in release history.
+ */
+export declare function markTaskReleased(config: RepoOSConfig, absPath: string): Task;
+/**
+ * Remove a task file. `absPath` must resolve inside the configured work dir —
+ * this mirrors the `safeRepoFile` guard and prevents deleting arbitrary repo
+ * files through the API. Throws PathGuardError when the target is outside the
+ * work dir, and WriteError when the file is already gone (callers treat the
+ * latter as an idempotent 404).
+ */
+export declare function deleteTaskFile(config: RepoOSConfig, absPath: string): string;