@dfsramos/foreman 0.0.0-stage → 0.3.0

package/dist/db.js

@@ -0,0 +1,467 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { DEFAULT_IGNORED_AUTHORS, REVIEW_MODES } from './projects.js';
+export const RUN_STATUSES = ['running', 'succeeded', 'failed', 'aborted', 'blocked'];
+function median(values) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+export function summariseAgents(rows) {
+    const byAgent = new Map();
+    for (const row of rows)
+        byAgent.set(row.agent, [...(byAgent.get(row.agent) ?? []), row]);
+    return Object.fromEntries([...byAgent].map(([agent, runs]) => {
+        const work = runs.filter((run) => run.kind === 'work');
+        const count = (status) => work.filter((run) => run.status === status).length;
+        return [
+            agent,
+            {
+                work: work.length,
+                succeeded: count('succeeded'),
+                failed: count('failed'),
+                blocked: count('blocked'),
+                aborted: count('aborted'),
+                reviewRounds: runs.length - work.length,
+                costUsd: runs.reduce((sum, run) => sum + (run.costUsd ?? 0), 0),
+                medianMinutes: median(work.map((run) => run.minutes)),
+            },
+        ];
+    }));
+}
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  issue_id TEXT NOT NULL,
+  identifier TEXT NOT NULL,
+  title TEXT NOT NULL,
+  url TEXT NOT NULL,
+  branch TEXT,
+  worktree_path TEXT,
+  status TEXT NOT NULL,
+  step TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  pr_url TEXT,
+  failure_reason TEXT,
+  cost_usd REAL,
+  num_turns INTEGER,
+  agent_pid INTEGER,
+  agent TEXT NOT NULL DEFAULT 'claude',
+  usage_delta TEXT,
+  project_id INTEGER,
+  project_name TEXT,
+  kind TEXT NOT NULL DEFAULT 'work',
+  round INTEGER
+);
+CREATE TABLE IF NOT EXISTS reviews (
+  issue_id TEXT PRIMARY KEY,
+  handled_until TEXT NOT NULL,
+  rounds INTEGER NOT NULL,
+  handed_over INTEGER NOT NULL DEFAULT 0,
+  conflict_head TEXT,
+  conflict_at TEXT,
+  agent_reviewed_head TEXT,
+  agent_findings TEXT,
+  ci_head TEXT,
+  ci_reruns INTEGER NOT NULL DEFAULT 0,
+  ci_pending_since TEXT,
+  ci_handled INTEGER NOT NULL DEFAULT 0,
+  approval_head TEXT,
+  ci_not_code TEXT
+);
+CREATE TABLE IF NOT EXISTS projects (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  priority TEXT NOT NULL,
+  source_type TEXT NOT NULL,
+  source_settings TEXT NOT NULL,
+  repo_path TEXT NOT NULL UNIQUE,
+  worktree_root TEXT NOT NULL,
+  poll_interval_seconds INTEGER NOT NULL,
+  agent_timeout_minutes INTEGER NOT NULL,
+  agents TEXT NOT NULL,
+  autostart INTEGER NOT NULL,
+  created_at TEXT NOT NULL,
+  review_max_rounds INTEGER NOT NULL DEFAULT 5,
+  review_ignore_authors TEXT,
+  review_mode TEXT NOT NULL DEFAULT 'none',
+  wait_for_ci INTEGER NOT NULL DEFAULT 1
+);
+CREATE TABLE IF NOT EXISTS import_connections (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  type TEXT NOT NULL,
+  settings TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id INTEGER NOT NULL REFERENCES runs(id),
+  ts TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  text TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS events_run_id ON events (run_id, id);
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+`;
+const PATCH_COLUMNS = {
+    branch: 'branch',
+    worktreePath: 'worktree_path',
+    step: 'step',
+    prUrl: 'pr_url',
+    costUsd: 'cost_usd',
+    numTurns: 'num_turns',
+    agentPid: 'agent_pid',
+    usageDelta: 'usage_delta',
+};
+function toRun(row) {
+    return {
+        id: Number(row.id),
+        issueId: row.issue_id,
+        identifier: row.identifier,
+        title: row.title,
+        url: row.url,
+        branch: row.branch,
+        worktreePath: row.worktree_path,
+        status: row.status,
+        step: row.step,
+        startedAt: row.started_at,
+        finishedAt: row.finished_at,
+        prUrl: row.pr_url,
+        failureReason: row.failure_reason,
+        costUsd: row.cost_usd,
+        numTurns: row.num_turns,
+        agentPid: row.agent_pid,
+        agent: row.agent,
+        usageDelta: row.usage_delta ? JSON.parse(row.usage_delta) : null,
+        projectId: row.project_id === null || row.project_id === undefined ? null : Number(row.project_id),
+        projectName: row.project_name ?? null,
+        kind: row.kind ?? 'work',
+        round: row.round === null || row.round === undefined ? null : Number(row.round),
+    };
+}
+function toImportConnection(row) {
+    return {
+        id: Number(row.id),
+        name: row.name,
+        type: row.type,
+        settings: JSON.parse(row.settings),
+        createdAt: row.created_at,
+    };
+}
+function toProject(row) {
+    return {
+        id: Number(row.id),
+        name: row.name,
+        priority: row.priority,
+        sourceType: row.source_type,
+        sourceSettings: JSON.parse(row.source_settings),
+        repoPath: row.repo_path,
+        worktreeRoot: row.worktree_root,
+        pollIntervalSeconds: Number(row.poll_interval_seconds),
+        agentTimeoutMinutes: Number(row.agent_timeout_minutes),
+        agents: JSON.parse(row.agents),
+        autostart: Number(row.autostart) === 1,
+        reviewMaxRounds: row.review_max_rounds === undefined || row.review_max_rounds === null ? 5 : Number(row.review_max_rounds),
+        // Null for a project saved before the setting existed: the defaults apply.
+        reviewIgnoreAuthors: row.review_ignore_authors ? JSON.parse(row.review_ignore_authors) : [...DEFAULT_IGNORED_AUTHORS],
+        reviewMode: REVIEW_MODES.includes(row.review_mode) ? row.review_mode : 'none',
+        waitForCi: row.wait_for_ci === undefined || row.wait_for_ci === null ? true : Number(row.wait_for_ci) === 1,
+        createdAt: row.created_at,
+    };
+}
+const projectValues = (input) => [
+    input.name,
+    input.priority,
+    input.sourceType,
+    JSON.stringify(input.sourceSettings),
+    input.repoPath,
+    input.worktreeRoot,
+    input.pollIntervalSeconds,
+    input.agentTimeoutMinutes,
+    JSON.stringify(input.agents),
+    input.autostart ? 1 : 0,
+    input.reviewMaxRounds,
+    JSON.stringify(input.reviewIgnoreAuthors),
+    input.reviewMode,
+    input.waitForCi ? 1 : 0,
+];
+function toEvent(row) {
+    return {
+        id: Number(row.id),
+        runId: Number(row.run_id),
+        ts: row.ts,
+        kind: row.kind,
+        text: row.text,
+    };
+}
+export function openDb(file, now = () => new Date()) {
+    if (file !== ':memory:') {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+    }
+    const sqlite = new DatabaseSync(file);
+    if (file !== ':memory:') {
+        // The database holds tracker credentials: keep it readable by its owner only.
+        fs.chmodSync(file, 0o600);
+        sqlite.exec('PRAGMA journal_mode = WAL');
+    }
+    sqlite.exec(SCHEMA);
+    // Databases created before agent_pid existed.
+    const columns = sqlite.prepare('PRAGMA table_info(runs)').all();
+    if (!columns.some((column) => column.name === 'agent_pid')) {
+        sqlite.exec('ALTER TABLE runs ADD COLUMN agent_pid INTEGER');
+    }
+    // Runs recorded before other agents existed were all claude's.
+    if (!columns.some((column) => column.name === 'agent')) {
+        sqlite.exec("ALTER TABLE runs ADD COLUMN agent TEXT NOT NULL DEFAULT 'claude'");
+    }
+    if (!columns.some((column) => column.name === 'usage_delta')) {
+        sqlite.exec('ALTER TABLE runs ADD COLUMN usage_delta TEXT');
+    }
+    if (!columns.some((column) => column.name === 'project_id')) {
+        sqlite.exec('ALTER TABLE runs ADD COLUMN project_id INTEGER');
+        sqlite.exec('ALTER TABLE runs ADD COLUMN project_name TEXT');
+    }
+    if (!columns.some((column) => column.name === 'kind')) {
+        sqlite.exec("ALTER TABLE runs ADD COLUMN kind TEXT NOT NULL DEFAULT 'work'");
+        sqlite.exec('ALTER TABLE runs ADD COLUMN round INTEGER');
+    }
+    const reviewColumns = sqlite.prepare('PRAGMA table_info(reviews)').all();
+    if (!reviewColumns.some((column) => column.name === 'handed_over')) {
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN handed_over INTEGER NOT NULL DEFAULT 0');
+    }
+    if (!reviewColumns.some((column) => column.name === 'conflict_head')) {
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN conflict_head TEXT');
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN conflict_at TEXT');
+    }
+    if (!reviewColumns.some((column) => column.name === 'agent_reviewed_head')) {
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN agent_reviewed_head TEXT');
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN agent_findings TEXT');
+    }
+    if (!reviewColumns.some((column) => column.name === 'ci_head')) {
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN ci_head TEXT');
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN ci_reruns INTEGER NOT NULL DEFAULT 0');
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN ci_pending_since TEXT');
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN ci_handled INTEGER NOT NULL DEFAULT 0');
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN approval_head TEXT');
+        sqlite.exec('ALTER TABLE reviews ADD COLUMN ci_not_code TEXT');
+    }
+    const projectColumns = sqlite.prepare('PRAGMA table_info(projects)').all();
+    if (!projectColumns.some((column) => column.name === 'review_max_rounds')) {
+        sqlite.exec('ALTER TABLE projects ADD COLUMN review_max_rounds INTEGER NOT NULL DEFAULT 5');
+    }
+    if (!projectColumns.some((column) => column.name === 'review_ignore_authors')) {
+        sqlite.exec('ALTER TABLE projects ADD COLUMN review_ignore_authors TEXT');
+    }
+    if (!projectColumns.some((column) => column.name === 'review_mode')) {
+        sqlite.exec("ALTER TABLE projects ADD COLUMN review_mode TEXT NOT NULL DEFAULT 'none'");
+    }
+    if (!projectColumns.some((column) => column.name === 'wait_for_ci')) {
+        sqlite.exec('ALTER TABLE projects ADD COLUMN wait_for_ci INTEGER NOT NULL DEFAULT 1');
+    }
+    const requireRun = (id) => {
+        const run = db.getRun(id);
+        if (!run)
+            throw new Error(`Run ${id} not found`);
+        return run;
+    };
+    const db = {
+        createRun(issue, agent, project, review) {
+            const result = sqlite
+                .prepare(`INSERT INTO runs (issue_id, identifier, title, url, status, step, started_at, agent, project_id, project_name, kind, round, branch)
+           VALUES (?, ?, ?, ?, 'running', 'claim', ?, ?, ?, ?, ?, ?, ?)`)
+                .run(issue.id, issue.identifier, issue.title, issue.url, now().toISOString(), agent, project?.id ?? null, project?.name ?? null, review ? (review.kind ?? 'review') : 'work', review?.round ?? null, review?.branch ?? null);
+            return requireRun(Number(result.lastInsertRowid));
+        },
+        updateRun(id, patch) {
+            const entries = Object.entries(patch).filter(([, value]) => value !== undefined);
+            if (entries.length > 0) {
+                const assignments = entries.map(([key]) => `${PATCH_COLUMNS[key]} = ?`).join(', ');
+                const values = entries.map(([, value]) => (typeof value === 'object' && value !== null ? JSON.stringify(value) : (value ?? null)));
+                sqlite.prepare(`UPDATE runs SET ${assignments} WHERE id = ?`).run(...values, id);
+            }
+            return requireRun(id);
+        },
+        finishRun(id, status, failureReason) {
+            sqlite
+                .prepare('UPDATE runs SET status = ?, finished_at = ?, failure_reason = ? WHERE id = ?')
+                .run(status, now().toISOString(), failureReason ?? null, id);
+            return requireRun(id);
+        },
+        getRun(id) {
+            const row = sqlite.prepare('SELECT * FROM runs WHERE id = ?').get(id);
+            return row ? toRun(row) : undefined;
+        },
+        listRuns({ status, projectId, limit, offset }) {
+            const conditions = [];
+            const params = [];
+            if (status) {
+                conditions.push('status = ?');
+                params.push(status);
+            }
+            if (projectId !== undefined) {
+                conditions.push('project_id = ?');
+                params.push(projectId);
+            }
+            const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+            const rows = sqlite
+                .prepare(`SELECT * FROM runs ${where} ORDER BY id DESC LIMIT ? OFFSET ?`)
+                .all(...params, limit, offset);
+            const count = sqlite.prepare(`SELECT COUNT(*) AS total FROM runs ${where}`).get(...params);
+            return { runs: rows.map(toRun), total: Number(count.total) };
+        },
+        listRunning() {
+            const rows = sqlite.prepare("SELECT * FROM runs WHERE status = 'running' ORDER BY id").all();
+            return rows.map(toRun);
+        },
+        countRuns() {
+            const counts = { running: 0, succeeded: 0, failed: 0, aborted: 0, blocked: 0 };
+            const rows = sqlite.prepare('SELECT status, COUNT(*) AS total FROM runs GROUP BY status').all();
+            for (const row of rows)
+                counts[row.status] = Number(row.total);
+            return counts;
+        },
+        agentStats() {
+            const rows = sqlite
+                .prepare(`SELECT agent, kind, status, cost_usd AS costUsd,
+                  (julianday(finished_at) - julianday(started_at)) * 1440 AS minutes
+           FROM runs WHERE status != 'running' AND finished_at IS NOT NULL`)
+                .all();
+            return summariseAgents(rows.map((row) => ({ ...row, minutes: Math.round(Number(row.minutes)) })));
+        },
+        addEvent(runId, kind, text) {
+            const ts = now().toISOString();
+            const result = sqlite
+                .prepare('INSERT INTO events (run_id, ts, kind, text) VALUES (?, ?, ?, ?)')
+                .run(runId, ts, kind, text);
+            return { id: Number(result.lastInsertRowid), runId, ts, kind, text };
+        },
+        listEvents(runId, afterId = 0) {
+            const rows = sqlite
+                .prepare('SELECT * FROM events WHERE run_id = ? AND id > ? ORDER BY id')
+                .all(runId, afterId);
+            return rows.map(toEvent);
+        },
+        getReview(issueId) {
+            const row = sqlite.prepare('SELECT * FROM reviews WHERE issue_id = ?').get(issueId);
+            return row
+                ? {
+                    issueId,
+                    handledUntil: row.handled_until,
+                    rounds: Number(row.rounds),
+                    handedOver: Number(row.handed_over) === 1,
+                    conflictHead: row.conflict_head ?? null,
+                    conflictAt: row.conflict_at ?? null,
+                    agentReviewedHead: row.agent_reviewed_head ?? null,
+                    agentFindings: row.agent_findings ?? null,
+                    ciHead: row.ci_head ?? null,
+                    ciReruns: Number(row.ci_reruns ?? 0),
+                    ciPendingSince: row.ci_pending_since ?? null,
+                    ciHandled: Number(row.ci_handled) === 1,
+                    approvalHead: row.approval_head ?? null,
+                    ciNotCode: row.ci_not_code ?? null,
+                }
+                : undefined;
+        },
+        saveReview(progress) {
+            sqlite
+                .prepare(`INSERT INTO reviews (issue_id, handled_until, rounds, handed_over, conflict_head, conflict_at, agent_reviewed_head, agent_findings,
+             ci_head, ci_reruns, ci_pending_since, ci_handled, approval_head, ci_not_code)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(issue_id) DO UPDATE SET handled_until = excluded.handled_until, rounds = excluded.rounds,
+             handed_over = excluded.handed_over, conflict_head = excluded.conflict_head, conflict_at = excluded.conflict_at,
+             agent_reviewed_head = excluded.agent_reviewed_head, agent_findings = excluded.agent_findings,
+             ci_head = excluded.ci_head, ci_reruns = excluded.ci_reruns, ci_pending_since = excluded.ci_pending_since,
+             ci_handled = excluded.ci_handled, approval_head = excluded.approval_head, ci_not_code = excluded.ci_not_code`)
+                .run(progress.issueId, progress.handledUntil, progress.rounds, progress.handedOver ? 1 : 0, progress.conflictHead ?? null, progress.conflictAt ?? null, progress.agentReviewedHead ?? null, progress.agentFindings ?? null, progress.ciHead ?? null, progress.ciReruns ?? 0, progress.ciPendingSince ?? null, progress.ciHandled ? 1 : 0, progress.approvalHead ?? null, progress.ciNotCode ?? null);
+        },
+        authorAgent(issueId) {
+            const row = sqlite
+                .prepare("SELECT agent FROM runs WHERE issue_id = ? AND kind = 'work' AND status = 'succeeded' ORDER BY id DESC LIMIT 1")
+                .get(issueId);
+            return row?.agent ?? null;
+        },
+        lastRunFinishedAt(issueId) {
+            const row = sqlite.prepare("SELECT MAX(finished_at) AS at FROM runs WHERE issue_id = ? AND status = 'succeeded'").get(issueId);
+            return row?.at ?? null;
+        },
+        listProjects() {
+            return sqlite.prepare('SELECT * FROM projects ORDER BY id').all().map(toProject);
+        },
+        getProject(id) {
+            const row = sqlite.prepare('SELECT * FROM projects WHERE id = ?').get(id);
+            return row ? toProject(row) : undefined;
+        },
+        createProject(input) {
+            const result = sqlite
+                .prepare(`INSERT INTO projects (name, priority, source_type, source_settings, repo_path, worktree_root,
+             poll_interval_seconds, agent_timeout_minutes, agents, autostart, review_max_rounds, review_ignore_authors, review_mode, wait_for_ci, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(...projectValues(input), now().toISOString());
+            return toProject(sqlite.prepare('SELECT * FROM projects WHERE id = ?').get(Number(result.lastInsertRowid)));
+        },
+        updateProject(id, input) {
+            sqlite
+                .prepare(`UPDATE projects SET name = ?, priority = ?, source_type = ?, source_settings = ?, repo_path = ?, worktree_root = ?,
+             poll_interval_seconds = ?, agent_timeout_minutes = ?, agents = ?, autostart = ?, review_max_rounds = ?, review_ignore_authors = ?, review_mode = ?, wait_for_ci = ? WHERE id = ?`)
+                .run(...projectValues(input), id);
+            const project = db.getProject(id);
+            if (!project)
+                throw new Error(`Project ${id} not found`);
+            return project;
+        },
+        deleteProject(id) {
+            sqlite.prepare('DELETE FROM projects WHERE id = ?').run(id);
+        },
+        listImportConnections() {
+            return sqlite.prepare('SELECT * FROM import_connections ORDER BY id').all().map(toImportConnection);
+        },
+        getImportConnection(id) {
+            const row = sqlite.prepare('SELECT * FROM import_connections WHERE id = ?').get(id);
+            return row ? toImportConnection(row) : undefined;
+        },
+        createImportConnection(input) {
+            const result = sqlite
+                .prepare('INSERT INTO import_connections (name, type, settings, created_at) VALUES (?, ?, ?, ?)')
+                .run(input.name, input.type, JSON.stringify(input.settings), now().toISOString());
+            return db.getImportConnection(Number(result.lastInsertRowid));
+        },
+        updateImportConnection(id, input) {
+            sqlite.prepare('UPDATE import_connections SET name = ?, type = ?, settings = ? WHERE id = ?').run(input.name, input.type, JSON.stringify(input.settings), id);
+            const connection = db.getImportConnection(id);
+            if (!connection)
+                throw new Error(`Import connection ${id} not found`);
+            return connection;
+        },
+        deleteImportConnection(id) {
+            sqlite.prepare('DELETE FROM import_connections WHERE id = ?').run(id);
+        },
+        adoptRuns(project) {
+            const result = sqlite.prepare('UPDATE runs SET project_id = ?, project_name = ? WHERE project_id IS NULL').run(project.id, project.name);
+            return Number(result.changes);
+        },
+        getSetting(key) {
+            const row = sqlite.prepare('SELECT value FROM settings WHERE key = ?').get(key);
+            return row ? JSON.parse(row.value) : undefined;
+        },
+        setSetting(key, value) {
+            sqlite
+                .prepare('INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value')
+                .run(key, JSON.stringify(value));
+        },
+        deleteSetting(key) {
+            sqlite.prepare('DELETE FROM settings WHERE key = ?').run(key);
+        },
+        close() {
+            sqlite.close();
+        },
+    };
+    return db;
+}

package/dist/git/taskstore.js

@@ -0,0 +1,224 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { defaultExec } from './worktree.js';
+export class TaskStoreError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TaskStoreError';
+    }
+}
+const MAX_PUSH_ATTEMPTS = 5;
+/** What git says when the remote branch moved between the fetch and the push. */
+const REJECTED_PUSH = /\[rejected\]|fetch first|non-fast-forward|failed to lock|cannot lock ref/;
+const COMMIT_IDENTITY = ['-c', 'user.name=foreman', '-c', `user.email=foreman@${os.hostname()}`];
+const stores = new Map();
+/** The store for a repository and branch under a data directory: one instance per clone, shared by every project that uses it. */
+export function openTaskStore(options) {
+    const key = createHash('sha1').update(`${options.repository}\n${options.branch}`).digest('hex').slice(0, 12);
+    const dir = path.resolve(options.dataDir, 'tasks', key);
+    let store = stores.get(dir);
+    if (!store) {
+        store = createTaskStore(dir, options);
+        stores.set(dir, store);
+    }
+    return store;
+}
+const stderrOf = (error) => error.stderr?.trim() ?? '';
+const describeFailure = (args, error) => {
+    const detail = stderrOf(error) || (error instanceof Error ? error.message : String(error));
+    return `git ${args.join(' ')} failed: ${detail}`;
+};
+const errorCode = (error) => error.code;
+function createTaskStore(dir, { repository, branch, exec = defaultExec }) {
+    let queue = Promise.resolve();
+    let syncedAt = -Infinity;
+    /** Runs `work` after everything queued before it, whether that succeeded or not. */
+    const enqueue = (work) => {
+        const run = queue.then(work);
+        queue = run.then(() => undefined, () => undefined);
+        return run;
+    };
+    const run = (args, cwd) => exec('git', args, cwd ? { cwd } : undefined);
+    const git = async (args, cwd) => {
+        try {
+            return (await run(args, cwd)).stdout.trim();
+        }
+        catch (error) {
+            throw new TaskStoreError(describeFailure(args, error));
+        }
+    };
+    /** The absolute path of a file in the clone, refusing one that would leave it. */
+    const inside = (file) => {
+        const full = path.resolve(dir, file);
+        if (full !== dir && !full.startsWith(dir + path.sep))
+            throw new TaskStoreError(`${file} is outside the task store`);
+        return full;
+    };
+    const tree = {
+        read(file) {
+            try {
+                return fs.readFileSync(inside(file), 'utf8');
+            }
+            catch (error) {
+                const code = errorCode(error);
+                if (code === 'ENOENT' || code === 'EISDIR' || code === 'ENOTDIR')
+                    return null;
+                throw error;
+            }
+        },
+        list(directory) {
+            let entries;
+            try {
+                entries = fs.readdirSync(inside(directory), { withFileTypes: true });
+            }
+            catch (error) {
+                const code = errorCode(error);
+                if (code === 'ENOENT' || code === 'ENOTDIR')
+                    return [];
+                throw error;
+            }
+            return entries
+                .filter((entry) => entry.isFile())
+                .map((entry) => entry.name)
+                .sort();
+        },
+    };
+    const syncNow = async () => {
+        if (fs.existsSync(path.join(dir, '.git'))) {
+            await git(['fetch', '--quiet', 'origin', branch], dir);
+            await git(['reset', '--quiet', '--hard', 'FETCH_HEAD'], dir);
+            await git(['clean', '--quiet', '-fd'], dir);
+        }
+        else {
+            // Whatever is there is not a clone (a clone that failed half way, say) and is replaced.
+            fs.rmSync(dir, { recursive: true, force: true });
+            fs.mkdirSync(path.dirname(dir), { recursive: true });
+            await git(['clone', '--quiet', '--single-branch', '--branch', branch, '--no-tags', repository, dir]);
+        }
+        syncedAt = Date.now();
+    };
+    /** Writes the changes to the checkout and returns the paths that changed on disk. */
+    const apply = (changes) => {
+        const touched = [];
+        for (const [file, content] of Object.entries(changes)) {
+            const full = inside(file);
+            if (content === null) {
+                // git add refuses a path that matches nothing, so a deletion of what is not there is not a change.
+                if (!fs.existsSync(full))
+                    continue;
+                fs.rmSync(full);
+            }
+            else {
+                fs.mkdirSync(path.dirname(full), { recursive: true });
+                fs.writeFileSync(full, content);
+            }
+            touched.push(file);
+        }
+        return touched;
+    };
+    /** Whether the index differs from HEAD: `git diff --cached --quiet` exits 1 when it does. */
+    const staged = async () => {
+        try {
+            await run(['diff', '--cached', '--quiet'], dir);
+            return false;
+        }
+        catch (error) {
+            if (errorCode(error) === 1)
+                return true;
+            throw new TaskStoreError(describeFailure(['diff', '--cached', '--quiet'], error));
+        }
+    };
+    const push = async (source = 'HEAD') => {
+        const args = ['push', '--quiet', 'origin', `${source}:refs/heads/${branch}`];
+        try {
+            await run(args, dir);
+            return 'pushed';
+        }
+        catch (error) {
+            if (REJECTED_PUSH.test(stderrOf(error)))
+                return 'rejected';
+            throw new TaskStoreError(describeFailure(args, error));
+        }
+    };
+    /** The branch's sha on the remote, or null when it does not exist. */
+    const lsRemote = async () => {
+        const output = await git(['ls-remote', '--heads', repository, branch]);
+        for (const line of output.split('\n')) {
+            const [sha, ref] = line.split('\t');
+            // The pattern matches any ref that ends with the name, so the ref is checked in full.
+            if (sha && ref === `refs/heads/${branch}`)
+                return sha;
+        }
+        return null;
+    };
+    return {
+        dir,
+        sync() {
+            return enqueue(syncNow);
+        },
+        view(maxAgeMs = 0) {
+            return enqueue(async () => {
+                if (Date.now() - syncedAt > maxAgeMs)
+                    await syncNow();
+                return tree;
+            });
+        },
+        transact(message, fn) {
+            return enqueue(async () => {
+                for (let attempt = 1; attempt <= MAX_PUSH_ATTEMPTS; attempt += 1) {
+                    // No rebase: the reset in the sync drops the commit the last attempt made, and `fn` sees origin as it is now.
+                    await syncNow();
+                    const changes = fn(tree);
+                    if (changes === null)
+                        return false;
+                    const paths = apply(changes);
+                    if (paths.length === 0)
+                        return false;
+                    await git(['add', '-A', '--', ...paths], dir);
+                    if (!(await staged()))
+                        return false;
+                    await git([...COMMIT_IDENTITY, 'commit', '--quiet', '-m', message], dir);
+                    if ((await push()) === 'pushed')
+                        return true;
+                }
+                throw new TaskStoreError(`Gave up after ${MAX_PUSH_ATTEMPTS} rejected pushes to ${branch}`);
+            });
+        },
+        remoteBranch() {
+            return enqueue(lsRemote);
+        },
+        canPush() {
+            return enqueue(async () => {
+                // From a stale checkout the push would be refused for being behind, which proves nothing.
+                await syncNow();
+                await git(['push', '--dry-run', 'origin', `HEAD:refs/heads/${branch}`], dir);
+            });
+        },
+        createBranch(message) {
+            return enqueue(async () => {
+                if ((await lsRemote()) !== null)
+                    return 'exists';
+                if (!fs.existsSync(path.join(dir, '.git'))) {
+                    // Set up as the clone the first sync would make, which fetches the branch once it is pushed.
+                    fs.rmSync(dir, { recursive: true, force: true });
+                    fs.mkdirSync(path.dirname(dir), { recursive: true });
+                    await git(['init', '--quiet', '-b', branch, dir]);
+                    await git(['remote', 'add', '-t', branch, 'origin', repository], dir);
+                }
+                // The commit is made from an empty index with no checkout; the next sync's reset restores a clone's.
+                await git(['read-tree', '--empty'], dir);
+                syncedAt = -Infinity;
+                const tree = await git(['write-tree'], dir);
+                const commit = await git([...COMMIT_IDENTITY, 'commit-tree', tree, '-m', message], dir);
+                if ((await push(commit)) === 'pushed')
+                    return 'created';
+                // Rejected: another machine's first commit landed first, unless the branch is still not there.
+                if ((await lsRemote()) !== null)
+                    return 'exists';
+                throw new TaskStoreError(`The push creating ${branch} was rejected, but the remote still has no such branch`);
+            });
+        },
+    };
+}