@openfleet-tools/cli 0.0.0-stage → 0.1.0

package/dist/hooks/handlers.js

@@ -0,0 +1,363 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { actorFor, bareAgentName, candidateProjects, locatePath, roleFromAgentName, roleOf } from "../attribution.js";
+import { readCoreIndex } from "../coreindex.js";
+import { appendEvent } from "../events.js";
+import { filePatch, snapshotWorktree } from "../git.js";
+import { readState, updateState } from "../state.js";
+import { findWorkspace, projectPaths } from "../workspace.js";
+/** Hooks are a no-op unless the session is inside (or launched for) an OpenFleet workspace. */
+export function resolveContext(payload, env = process.env) {
+    const fromEnv = env.OPENFLEET_WORKSPACE ? findWorkspace(env.OPENFLEET_WORKSPACE) : undefined;
+    const ws = fromEnv ?? (payload.cwd ? findWorkspace(payload.cwd) : undefined);
+    if (!ws)
+        return undefined;
+    const project = env.OPENFLEET_PROJECT || undefined;
+    if (project && !fs.existsSync(projectPaths(ws, project).state))
+        return { ws };
+    return { ws, ...(project ? { project } : {}) };
+}
+function ts(payload) {
+    const t = payload.timestamp;
+    if (typeof t === "number")
+        return new Date(t).toISOString();
+    if (typeof t === "string" && !Number.isNaN(Date.parse(t)))
+        return new Date(t).toISOString();
+    return new Date().toISOString();
+}
+/** Single active project: explicit, or the only non-finished project in the workspace. */
+function activeProject(ctx) {
+    if (ctx.project)
+        return projectPaths(ctx.ws, ctx.project);
+    const live = candidateProjects(ctx.ws).filter((p) => {
+        try {
+            const s = readState(p).status;
+            return s !== "done" && s !== "cancelled";
+        }
+        catch {
+            return false;
+        }
+    });
+    return live.length === 1 ? live[0] : undefined;
+}
+// ---------------------------------------------------------------- session
+export function onSessionStart(ctx, payload) {
+    const p = ctx.project ? projectPaths(ctx.ws, ctx.project) : undefined;
+    if (p) {
+        appendEvent(p, {
+            ts: ts(payload),
+            actor: "coordinator",
+            type: "session.started",
+            payload: { sessionId: payload.sessionId ?? null, source: payload.source ?? null },
+        });
+    }
+    const index = readCoreIndex(ctx.ws);
+    const lines = [
+        `OpenFleet workspace root: ${ctx.ws.root}`,
+        `OpenFleet data dir: ${ctx.ws.dir}`,
+        p ? `Active OpenFleet project: ${p.name} (${p.dir})` : "No OpenFleet project is active in this session.",
+    ];
+    if (index) {
+        const slots = Object.entries(index.slots)
+            .filter(([, list]) => list.length)
+            .map(([slot, list]) => `${slot}: ${list.map((e) => e.agent).join(", ")}`);
+        lines.push(`Phase extensions — ${slots.length ? slots.join("; ") : "none"}.`);
+    }
+    return { additionalContext: lines.join("\n") };
+}
+export function onSessionEnd(ctx, payload) {
+    if (!ctx.project)
+        return {};
+    appendEvent(projectPaths(ctx.ws, ctx.project), {
+        ts: ts(payload),
+        actor: "coordinator",
+        type: "session.ended",
+        payload: { sessionId: payload.sessionId ?? null, reason: payload.reason ?? null },
+    });
+    return {};
+}
+// ---------------------------------------------------------------- subagents
+function extName(agentName) {
+    const bare = bareAgentName(agentName);
+    return bare?.startsWith("openfleet-ext-") ? bare.slice("openfleet-ext-".length) : undefined;
+}
+function pickPending(state, role) {
+    const ids = Object.entries(state.children)
+        .filter(([, c]) => c.pendingSpawn === role)
+        .map(([id]) => id);
+    return ids[0];
+}
+function childContext(p, childId, child, role) {
+    return [
+        `# OpenFleet assignment`,
+        `- project: ${p.name}`,
+        `- child: ${childId} (repo \`${child.repo}\`${child.package ? `, package \`${child.package}\`` : ""})`,
+        `- role: ${role}`,
+        child.worktree ? `- worktree (work ONLY here): ${child.worktree}` : `- worktree: not created yet`,
+        child.branch ? `- branch: ${child.branch}` : "",
+        `- spec: ${p.spec}`,
+        `- contracts: ${p.contracts}`,
+        child.plan ? `- approved plan: ${child.plan}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export function onSubagentStart(ctx, payload) {
+    const role = roleFromAgentName(payload.agentName);
+    const ext = extName(payload.agentName);
+    if (!role && !ext)
+        return {};
+    const p = activeProject(ctx);
+    if (!p)
+        return {};
+    if (ext) {
+        appendEvent(p, {
+            ts: ts(payload),
+            actor: `ext:${ext}`,
+            type: "agent.spawned",
+            payload: { agentName: payload.agentName ?? null },
+        });
+        return {};
+    }
+    if (role === "coordinator")
+        return {};
+    let childId;
+    const state = updateState(p, (s) => {
+        childId = pickPending(s, role);
+        if (!childId)
+            return;
+        const child = s.children[childId];
+        delete child.pendingSpawn;
+        child.role = role;
+    });
+    appendEvent(p, {
+        ts: ts(payload),
+        actor: actorFor(childId ?? "unknown", role),
+        type: "agent.spawned",
+        target: childId ?? null,
+        payload: { agentName: payload.agentName ?? null, agentDisplayName: payload.agentDisplayName ?? null },
+    });
+    if (!childId)
+        return {};
+    return { additionalContext: childContext(p, childId, state.children[childId], role) };
+}
+function snapshotChild(p, childId, child, actor, at) {
+    if (!child.worktree || !fs.existsSync(child.worktree))
+        return;
+    let snap;
+    try {
+        snap = snapshotWorktree(child.worktree, child.baseSha ?? "HEAD");
+    }
+    catch {
+        return;
+    }
+    const hash = crypto.createHash("sha256").update(snap.patch).digest("hex");
+    if (hash === child.lastSnapshot)
+        return;
+    appendEvent(p, {
+        ts: at,
+        actor,
+        type: "worktree.snapshot",
+        target: childId,
+        payload: {
+            worktree: child.worktree,
+            base: child.baseSha ?? "HEAD",
+            files: snap.files,
+            totals: {
+                files: snap.files.length,
+                added: snap.files.reduce((n, f) => n + f.added, 0),
+                removed: snap.files.reduce((n, f) => n + f.removed, 0),
+            },
+        },
+        patch: snap.patch,
+    });
+    updateState(p, (s) => {
+        const c = s.children[childId];
+        if (c)
+            c.lastSnapshot = hash;
+    });
+}
+export function onSubagentStop(ctx, payload) {
+    const role = roleFromAgentName(payload.agentName);
+    const ext = extName(payload.agentName);
+    if (!role && !ext)
+        return {};
+    const p = activeProject(ctx);
+    if (!p)
+        return {};
+    const at = ts(payload);
+    if (ext) {
+        appendEvent(p, {
+            ts: at,
+            actor: `ext:${ext}`,
+            type: "agent.stopped",
+            payload: { agentId: payload.agentId ?? null, agentName: payload.agentName ?? null, response: payload.response ?? "" },
+        });
+        return {};
+    }
+    if (role === "coordinator")
+        return {};
+    const state = readState(p);
+    const entries = Object.entries(state.children);
+    let match = entries.find(([, c]) => payload.agentId && c.agentIds[role] === payload.agentId);
+    if (!match) {
+        const byRole = entries.filter(([, c]) => roleOf(c) === role && c.phase !== "done");
+        if (byRole.length === 1)
+            match = byRole[0];
+    }
+    const childId = match?.[0];
+    const actor = actorFor(childId ?? "unknown", role);
+    appendEvent(p, {
+        ts: at,
+        actor,
+        type: "agent.stopped",
+        target: childId ?? null,
+        payload: { agentId: payload.agentId ?? null, agentName: payload.agentName ?? null, response: payload.response ?? "" },
+    });
+    if (childId && payload.agentId && !match[1].agentIds[role]) {
+        updateState(p, (s) => {
+            const c = s.children[childId];
+            if (c)
+                c.agentIds[role] = payload.agentId;
+        });
+    }
+    // Ground truth: diff snapshot of the attributed worktree, or every worktree when unattributed.
+    const targets = childId ? [[childId, match[1]]] : entries;
+    for (const [id, child] of targets)
+        snapshotChild(p, id, child, childId ? actor : actorFor(id, roleOf(child)), at);
+    return {};
+}
+function countLines(s) {
+    if (typeof s !== "string" || s.length === 0)
+        return 0;
+    return s.split("\n").length - (s.endsWith("\n") ? 1 : 0);
+}
+function parseArgs(args) {
+    if (typeof args === "string") {
+        const t = args.trim();
+        if (t.startsWith("{")) {
+            try {
+                return JSON.parse(t);
+            }
+            catch {
+                return args;
+            }
+        }
+    }
+    return args;
+}
+function parseApplyPatch(text) {
+    const out = [];
+    let cur;
+    for (const line of text.split("\n")) {
+        const m = /^\*\*\* (Add|Update|Delete) File: (.+)$/.exec(line);
+        if (m) {
+            cur = { path: m[2].trim(), kind: m[1] === "Add" ? "added" : m[1] === "Delete" ? "deleted" : "edited", added: 0, removed: 0 };
+            out.push(cur);
+            continue;
+        }
+        const move = /^\*\*\* Move to: (.+)$/.exec(line);
+        if (move && cur) {
+            out.push({ path: cur.path, kind: "deleted", added: 0, removed: 0 });
+            cur.path = move[1].trim();
+            cur.kind = "added";
+            continue;
+        }
+        if (!cur || line.startsWith("***"))
+            continue;
+        if (line.startsWith("+"))
+            cur.added++;
+        else if (line.startsWith("-"))
+            cur.removed++;
+    }
+    return out;
+}
+/** Extract file changes from a postToolUse payload. Only file-mutating tools are recognised. */
+export function fileChangesFromTool(toolName, rawArgs) {
+    const name = (toolName ?? "").toLowerCase();
+    const args = parseArgs(rawArgs);
+    const a = (typeof args === "object" && args !== null ? args : {});
+    const file = (a.path ?? a.file_path ?? a.filePath);
+    switch (name) {
+        case "create":
+        case "write":
+            return file ? [{ path: file, kind: "added", added: countLines(a.file_text ?? a.content), removed: 0 }] : [];
+        case "edit":
+        case "str_replace":
+        case "str_replace_editor":
+        case "multiedit":
+        case "multi_edit": {
+            if (!file)
+                return [];
+            if (a.command === "create")
+                return [{ path: file, kind: "added", added: countLines(a.file_text), removed: 0 }];
+            const edits = Array.isArray(a.edits) ? a.edits : [a];
+            let added = 0;
+            let removed = 0;
+            for (const e of edits) {
+                added += countLines(e.new_str ?? e.new_string ?? e.newString);
+                removed += countLines(e.old_str ?? e.old_string ?? e.oldString);
+            }
+            return [{ path: file, kind: "edited", added, removed }];
+        }
+        case "apply_patch": {
+            const text = typeof args === "string" ? args : (a.input ?? a.patch);
+            return typeof text === "string" ? parseApplyPatch(text) : [];
+        }
+        default:
+            return [];
+    }
+}
+export function onPostToolUse(ctx, payload) {
+    const changes = fileChangesFromTool(payload.toolName, payload.toolArgs);
+    if (!changes.length)
+        return {};
+    const cwd = payload.cwd ?? ctx.ws.root;
+    for (const change of changes) {
+        const abs = path.resolve(cwd, change.path);
+        const loc = locatePath(ctx.ws, abs, ctx.project);
+        if (!loc)
+            continue;
+        const role = roleOf(loc.child);
+        let patch = "";
+        if (change.kind !== "deleted") {
+            try {
+                patch = filePatch(loc.child.worktree, loc.rel);
+            }
+            catch {
+                patch = "";
+            }
+        }
+        appendEvent(loc.project, {
+            ts: ts(payload),
+            actor: actorFor(loc.childId, role),
+            type: `file.${change.kind}`,
+            target: loc.childId,
+            payload: {
+                path: loc.rel.split(path.sep).join("/"),
+                kind: change.kind,
+                lines: { added: change.added, removed: change.removed },
+                tool: payload.toolName ?? null,
+            },
+            patch,
+        });
+    }
+    return {};
+}
+export const HANDLERS = {
+    sessionStart: onSessionStart,
+    sessionEnd: onSessionEnd,
+    subagentStart: onSubagentStart,
+    subagentStop: onSubagentStop,
+    postToolUse: onPostToolUse,
+};
+export function runHook(event, payload, env = process.env) {
+    const handler = HANDLERS[event];
+    if (!handler)
+        return {};
+    const ctx = resolveContext(payload, env);
+    if (!ctx)
+        return {};
+    return handler(ctx, payload);
+}

package/dist/hooks/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/hooks/main.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// Entry point invoked by core/hooks.json: `node lib/hooks/main.js <event>`.
+// Never fails the Copilot session: errors are logged and the hook exits 0.
+import fs from "node:fs";
+import path from "node:path";
+import { resolveContext, runHook } from "./handlers.js";
+function readStdin() {
+    try {
+        return fs.readFileSync(0, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function main() {
+    const event = process.argv[2] ?? "";
+    let payload = {};
+    try {
+        const raw = readStdin();
+        payload = raw.trim() ? JSON.parse(raw) : {};
+        const out = runHook(event, payload);
+        if (out.additionalContext)
+            process.stdout.write(JSON.stringify(out));
+    }
+    catch (err) {
+        try {
+            const ctx = resolveContext(payload);
+            if (ctx) {
+                fs.appendFileSync(path.join(ctx.ws.dir, ".hook-errors.log"), `${new Date().toISOString()} ${event}: ${err.stack ?? String(err)}\n`);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./workspace.js";
+export * from "./state.js";
+export * from "./events.js";
+export * from "./repos.js";
+export * from "./extensions.js";
+export * from "./coreindex.js";
+export { installCore, syncExtensions, packageVersion, installedCoreVersion } from "./core.js";
+export { redact, redactString } from "./redact.js";
+export { snapshotWorktree } from "./git.js";
+export { initWorkspace } from "./commands/workspace.js";
+export { createProject, findOverlaps } from "./commands/project.js";
+export { run } from "./cli.js";

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./workspace.js";
+export * from "./state.js";
+export * from "./events.js";
+export * from "./repos.js";
+export * from "./extensions.js";
+export * from "./coreindex.js";
+export { installCore, syncExtensions, packageVersion, installedCoreVersion } from "./core.js";
+export { redact, redactString } from "./redact.js";
+export { snapshotWorktree } from "./git.js";
+export { initWorkspace } from "./commands/workspace.js";
+export { createProject, findOverlaps } from "./commands/project.js";
+export { run } from "./cli.js";

package/dist/launcher.d.ts

@@ -0,0 +1,24 @@
+import { type Workspace } from "./workspace.js";
+export interface LaunchOptions {
+    ws: Workspace;
+    agent: string;
+    prompt?: string;
+    sessionId?: string;
+    name?: string;
+    project?: string;
+    /** Extra args forwarded verbatim to the host CLI (after `--`). */
+    passthrough?: string[];
+    /** Keep Copilot's per-tool permission prompts (`--ask`). Default: auto-approve tools. */
+    ask?: boolean;
+}
+/** Host CLI binary. Overridable for tests and for future hosts (e.g. `claude`). */
+export declare function hostBinary(env?: NodeJS.ProcessEnv): string;
+/**
+ * Directories the session's agents work in, passed as `--add-dir` so path verification stays on
+ * without prompting: the workspace root, the project's worktrees, cloned repos and known local repos.
+ */
+export declare function allowedDirs(ws: Workspace, project?: string): string[];
+export declare function buildCopilotArgs(opts: LaunchOptions): string[];
+export declare function launchEnv(opts: LaunchOptions, env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Launch Copilot CLI interactively in the workspace root. Returns its exit code. */
+export declare function launch(opts: LaunchOptions): number;

package/dist/launcher.js

@@ -0,0 +1,75 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { qualifiedAgentName } from "./attribution.js";
+import fs from "node:fs";
+import { isDir, realish } from "./fsutil.js";
+import { readRepos } from "./repos.js";
+import { projectPaths, UserError } from "./workspace.js";
+/** Host CLI binary. Overridable for tests and for future hosts (e.g. `claude`). */
+export function hostBinary(env = process.env) {
+    return env.OPENFLEET_COPILOT_BIN || "copilot";
+}
+/**
+ * Directories the session's agents work in, passed as `--add-dir` so path verification stays on
+ * without prompting: the workspace root, the project's worktrees, cloned repos and known local repos.
+ */
+export function allowedDirs(ws, project) {
+    const dirs = new Set();
+    const add = (p) => {
+        if (!isDir(p))
+            return;
+        dirs.add(p);
+        dirs.add(realish(p));
+    };
+    add(ws.root);
+    if (project)
+        add(projectPaths(ws, project).worktrees);
+    add(path.join(ws.dir, "repos"));
+    for (const repo of Object.values(readRepos(ws).repos)) {
+        if (repo.path)
+            add(path.resolve(ws.root, repo.path));
+    }
+    return [...dirs];
+}
+export function buildCopilotArgs(opts) {
+    const args = ["--plugin-dir", opts.ws.core, "--agent", qualifiedAgentName(opts.agent)];
+    if (opts.sessionId)
+        args.push("--session-id", opts.sessionId);
+    if (opts.name)
+        args.push("--name", opts.name);
+    // Tools run without prompts; paths stay limited to allowedDirs and URLs still prompt.
+    if (!opts.ask)
+        args.push("--allow-all-tools");
+    for (const dir of allowedDirs(opts.ws, opts.project))
+        args.push("--add-dir", dir);
+    if (opts.prompt)
+        args.push("-i", opts.prompt);
+    args.push(...(opts.passthrough ?? []));
+    return args;
+}
+export function launchEnv(opts, env = process.env) {
+    return {
+        ...env,
+        OPENFLEET_WORKSPACE: opts.ws.root,
+        ...(opts.project ? { OPENFLEET_PROJECT: opts.project } : {}),
+    };
+}
+/** Launch Copilot CLI interactively in the workspace root. Returns its exit code. */
+export function launch(opts) {
+    const bin = hostBinary();
+    // Create the worktrees dir up front so it can be passed to --add-dir before any worktree exists.
+    if (opts.project)
+        fs.mkdirSync(projectPaths(opts.ws, opts.project).worktrees, { recursive: true });
+    const res = spawnSync(bin, buildCopilotArgs(opts), {
+        cwd: opts.ws.root,
+        stdio: "inherit",
+        env: launchEnv(opts),
+    });
+    if (res.error) {
+        if (res.error.code === "ENOENT") {
+            throw new UserError(`Could not find \`${bin}\`. Install GitHub Copilot CLI (https://github.com/github/copilot-cli) and try again.`);
+        }
+        throw res.error;
+    }
+    return res.status ?? 1;
+}

package/dist/lock.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cross-process exclusive lock using an O_EXCL lock file. Synchronous so it
+ * can be used from short-lived hook processes. Stale locks (crashed holder)
+ * are broken after STALE_MS.
+ */
+export declare function withLock<T>(lockFile: string, fn: () => T): T;

package/dist/lock.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+const STALE_MS = 10_000;
+const TIMEOUT_MS = 15_000;
+function sleep(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+ * Cross-process exclusive lock using an O_EXCL lock file. Synchronous so it
+ * can be used from short-lived hook processes. Stale locks (crashed holder)
+ * are broken after STALE_MS.
+ */
+export function withLock(lockFile, fn) {
+    const start = Date.now();
+    let fd;
+    while (fd === undefined) {
+        try {
+            fd = fs.openSync(lockFile, "wx");
+            fs.writeSync(fd, String(process.pid));
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            try {
+                if (Date.now() - fs.statSync(lockFile).mtimeMs > STALE_MS) {
+                    fs.rmSync(lockFile, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() - start > TIMEOUT_MS) {
+                throw new Error(`Timed out waiting for lock ${lockFile}`);
+            }
+            sleep(5 + Math.random() * 20);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        fs.closeSync(fd);
+        fs.rmSync(lockFile, { force: true });
+    }
+}

package/dist/redact.d.ts

@@ -0,0 +1,2 @@
+export declare function redactString(input: string): string;
+export declare function redact<T>(value: T): T;

package/dist/redact.js

@@ -0,0 +1,39 @@
+const REDACTED = "[REDACTED]";
+const PATTERNS = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b/g,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+    /\bnpm_[A-Za-z0-9]{30,}\b/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g,
+    /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g,
+    /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+    /\bAIza[0-9A-Za-z_-]{35}\b/g,
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+];
+// key=value / key: value style secrets; keeps the key, redacts the value.
+const ASSIGNMENT = /\b([A-Za-z0-9_.-]*(?:password|passwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key|client[_-]?secret)[A-Za-z0-9_.-]*)(["']?\s*[:=]\s*["']?)([^\s"',;]{4,})/gi;
+const BEARER = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/g;
+// user:pass@host in URLs
+const URL_CREDS = /\b([a-z][a-z0-9+.-]*:\/\/)([^\s:/@]+):([^\s/@]+)@/gi;
+export function redactString(input) {
+    let out = input;
+    for (const re of PATTERNS)
+        out = out.replace(re, REDACTED);
+    out = out.replace(ASSIGNMENT, (_m, key, sep) => `${key}${sep}${REDACTED}`);
+    out = out.replace(BEARER, (_m, scheme) => `${scheme} ${REDACTED}`);
+    out = out.replace(URL_CREDS, (_m, scheme, user) => `${scheme}${user}:${REDACTED}@`);
+    return out;
+}
+export function redact(value) {
+    if (typeof value === "string")
+        return redactString(value);
+    if (Array.isArray(value))
+        return value.map((v) => redact(v));
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = redact(v);
+        return out;
+    }
+    return value;
+}

package/dist/repos.d.ts

@@ -0,0 +1,28 @@
+import type { Workspace } from "./workspace.js";
+export interface PackageEntry {
+    /** Path relative to the repo root. */
+    path: string;
+    build?: string;
+    test?: string;
+}
+export interface RepoEntry {
+    /** Absolute or workspace-relative path to a local checkout. */
+    path?: string;
+    /** Git URL to clone when no local checkout exists. */
+    url?: string;
+    defaultBranch?: string;
+    build?: string;
+    test?: string;
+    /** Monorepo packages, keyed by package name. */
+    packages?: Record<string, PackageEntry>;
+    description?: string;
+    /** Build/test commands were confirmed by the user. */
+    confirmed?: boolean;
+}
+export interface ReposFile {
+    v: 1;
+    repos: Record<string, RepoEntry>;
+}
+export declare function emptyRepos(): ReposFile;
+export declare function readRepos(ws: Workspace): ReposFile;
+export declare function writeRepos(ws: Workspace, repos: ReposFile): void;

package/dist/repos.js

@@ -0,0 +1,10 @@
+import { readJsonOr, writeJson } from "./fsutil.js";
+export function emptyRepos() {
+    return { v: 1, repos: {} };
+}
+export function readRepos(ws) {
+    return readJsonOr(ws.reposFile, emptyRepos());
+}
+export function writeRepos(ws, repos) {
+    writeJson(ws.reposFile, repos);
+}