laneyard 0.1.0

package/dist/src/sidecar/bridge.js

@@ -0,0 +1,44 @@
+import { execFile } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { FASTLANE_UNAVAILABLE, resolveRubyEnv } from "./ruby-env.js";
+const exec = promisify(execFile);
+const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "ruby", "introspect.rb");
+/**
+ * Runs the sidecar in the project's context.
+ * In `bundle` mode, the invocation goes through `bundle exec` to see the
+ * right version of fastlane and the plugins the project declares.
+ */
+export function makeInvoke(runtime) {
+    return async (command, cwd, fastlaneDir) => {
+        const [bin, args] = runtime === "bundle"
+            ? ["bundle", ["exec", "ruby", SCRIPT, command, "--fastlane-dir", fastlaneDir]]
+            : ["ruby", [SCRIPT, command, "--fastlane-dir", fastlaneDir]];
+        // In bundle mode, `bundle exec` already provides the right environment. In
+        // system mode, it has to be found: depending on the install, `ruby` may not see fastlane.
+        let env = process.env;
+        if (runtime === "system") {
+            const ruby = await resolveRubyEnv();
+            if (!ruby)
+                return { ok: false, error: FASTLANE_UNAVAILABLE };
+            env = ruby.env;
+        }
+        try {
+            const { stdout } = await exec(bin, args, {
+                cwd,
+                env,
+                timeout: 180_000,
+                maxBuffer: 64 * 1024 * 1024,
+            });
+            return JSON.parse(stdout);
+        }
+        catch (cause) {
+            const err = cause;
+            return {
+                ok: false,
+                error: `The Ruby sidecar failed: ${(err.stderr || err.message).trim()}`,
+            };
+        }
+    };
+}

package/dist/src/sidecar/lanes.js

@@ -0,0 +1,40 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Hash of the whole fastlane folder, not just the Fastfile:
+ * an Appfile, a Pluginfile, or an imported file change the lanes just as much.
+ */
+async function hashFastlaneDir(root, fastlaneDir) {
+    const dir = join(root, fastlaneDir);
+    const hash = createHash("sha256");
+    const entries = (await readdir(dir, { withFileTypes: true, recursive: true }))
+        .filter((e) => e.isFile())
+        .map((e) => join(e.parentPath, e.name))
+        .sort();
+    for (const file of entries) {
+        hash.update(file);
+        hash.update(await readFile(file));
+    }
+    return hash.digest("hex");
+}
+export class LaneReader {
+    cache;
+    invoke;
+    constructor(cache, invoke) {
+        this.cache = cache;
+        this.invoke = invoke;
+    }
+    async read(slug, workspacePath, fastlaneDir) {
+        const hash = await hashFastlaneDir(workspacePath, fastlaneDir);
+        const cached = this.cache.get(slug, hash);
+        if (cached)
+            return cached;
+        const res = await this.invoke("lanes", workspacePath, fastlaneDir);
+        if (!res.ok)
+            throw new Error(res.error);
+        const lanes = res["lanes"];
+        this.cache.put(slug, hash, lanes);
+        return lanes;
+    }
+}

package/dist/src/sidecar/ruby-env.js

@@ -0,0 +1,63 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+async function canRequireFastlane(env) {
+    try {
+        await exec("ruby", ["-e", 'require "fastlane"'], { env, timeout: 180_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Reconstructs the `fastlane` launcher's environment when it's a shell script.
+ *
+ * We don't run the launcher: we read back its `GEM_HOME` and `GEM_PATH`
+ * assignments and have bash evaluate them, since it knows how to expand
+ * `${HOME}` and default values. Deliberately narrow approach — two
+ * variables, nothing else.
+ */
+async function envFromLauncher() {
+    const script = `
+    shim=$(command -v fastlane) || exit 1
+    head -c 2 "$shim" | grep -q '#!' || exit 1
+    eval "$(grep -oE '(GEM_HOME|GEM_PATH)="[^"]*"' "$shim" | sed 's/^/export /')" || exit 1
+    [ -n "$GEM_HOME" ] || exit 1
+    printf '%s\\n%s\\n' "$GEM_HOME" "$GEM_PATH"
+  `;
+    try {
+        const { stdout } = await exec("bash", ["-c", script], { timeout: 30_000 });
+        const [gemHome, gemPath] = stdout.split("\n");
+        if (!gemHome)
+            return null;
+        return { ...process.env, GEM_HOME: gemHome, GEM_PATH: gemPath || gemHome };
+    }
+    catch {
+        return null;
+    }
+}
+let cached = null;
+/**
+ * Finds an environment in which `ruby` can load fastlane, or null.
+ *
+ * The result is memoized: probing costs several seconds, since fastlane is
+ * slow to load, and the install doesn't change while the process runs.
+ */
+export function resolveRubyEnv() {
+    cached ??= (async () => {
+        if (await canRequireFastlane(process.env)) {
+            return { env: process.env, source: "process" };
+        }
+        const env = await envFromLauncher();
+        if (env && (await canRequireFastlane(env))) {
+            return { env, source: "launcher" };
+        }
+        return null;
+    })();
+    return cached;
+}
+/** Single message, so the problem isn't described differently in each place. */
+export const FASTLANE_UNAVAILABLE = "Ruby cannot load fastlane. Install it for the current Ruby " +
+    "(`gem install fastlane`), or declare a Gemfile in the project and set " +
+    "the `runtime` setting to `bundle`.";

package/dist/tests/cli/add.test.js

@@ -0,0 +1,64 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { parse } from "yaml";
+import { addProjectToConfig } from "../../src/cli/add.js";
+import { tmpDir } from "../fixtures/repos.js";
+const EXISTING = `# My Laneyard configuration
+server:
+  port: 7890
+  password_hash: "scrypt$a$b"   # server password
+
+projects:
+  - slug: deja-la
+    git_url: git@example.com:a.git
+`;
+async function configAt(content) {
+    const dir = await tmpDir("laneyard-add-");
+    const path = join(dir, "config.yml");
+    await writeFile(path, content, "utf8");
+    return path;
+}
+const entry = {
+    slug: "sample-ios",
+    name: "Sample iOS",
+    git_url: "git@example.com:sample.git",
+    default_branch: "main",
+    fastlane_dir: "fastlane",
+    runtime: "system",
+    artifact_globs: ["**/*.ipa"],
+};
+describe("addProjectToConfig", () => {
+    it("adds the project without removing existing projects", async () => {
+        const path = await configAt(EXISTING);
+        await addProjectToConfig(path, entry);
+        const parsed = parse(await readFile(path, "utf8"));
+        expect(parsed.projects.map((p) => p.slug)).toEqual(["deja-la", "sample-ios"]);
+    });
+    it("preserves the file's comments", async () => {
+        const path = await configAt(EXISTING);
+        await addProjectToConfig(path, entry);
+        const raw = await readFile(path, "utf8");
+        expect(raw).toContain("# My Laneyard configuration");
+        expect(raw).toContain("# server password");
+    });
+    it("refuses an already-taken slug", async () => {
+        const path = await configAt(EXISTING);
+        await expect(addProjectToConfig(path, { ...entry, slug: "deja-la" })).rejects.toThrow(/deja-la/);
+    });
+    it("creates the file and the server section if they don't exist", async () => {
+        const dir = await tmpDir("laneyard-add-");
+        const path = join(dir, "config.yml");
+        await addProjectToConfig(path, entry);
+        const parsed = parse(await readFile(path, "utf8"));
+        expect(parsed.projects).toHaveLength(1);
+        // A password must exist, otherwise the server would refuse every connection.
+        expect(parsed.server.password_hash).toMatch(/^scrypt\$/);
+    });
+    it("adds a projects section missing from an existing file", async () => {
+        const path = await configAt('server:\n  password_hash: "scrypt$a$b"\n');
+        await addProjectToConfig(path, entry);
+        const parsed = parse(await readFile(path, "utf8"));
+        expect(parsed.projects).toHaveLength(1);
+    });
+});

package/dist/tests/cli/detect.test.js

@@ -0,0 +1,63 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { detectProject } from "../../src/cli/detect.js";
+import { makeOriginRepo, tmpDir } from "../fixtures/repos.js";
+async function projectDir(files) {
+    const dir = await tmpDir("laneyard-detect-");
+    for (const [name, content] of Object.entries(files)) {
+        await mkdir(join(dir, name, ".."), { recursive: true });
+        await writeFile(join(dir, name), content, "utf8");
+    }
+    return dir;
+}
+describe("detectProject", () => {
+    it("finds the fastlane folder at the root", async () => {
+        const dir = await projectDir({ "fastlane/Fastfile": "lane :beta do\nend\n" });
+        const d = await detectProject(dir);
+        expect(d.fastlaneDir).toBe("fastlane");
+    });
+    it("finds a fastlane folder nested in a monorepo", async () => {
+        const dir = await projectDir({ "apps/ios/fastlane/Fastfile": "lane :beta do\nend\n" });
+        const d = await detectProject(dir);
+        expect(d.fastlaneDir).toBe("apps/ios/fastlane");
+    });
+    it("reports the absence of fastlane rather than guessing", async () => {
+        const dir = await projectDir({ "README.md": "nothing" });
+        const d = await detectProject(dir);
+        expect(d.fastlaneDir).toBeNull();
+    });
+    it("chooses bundle when a Gemfile is present, system otherwise", async () => {
+        const withGemfile = await projectDir({ "fastlane/Fastfile": "", Gemfile: 'gem "fastlane"' });
+        expect((await detectProject(withGemfile)).runtime).toBe("bundle");
+        const without = await projectDir({ "fastlane/Fastfile": "" });
+        expect((await detectProject(without)).runtime).toBe("system");
+    });
+    it("proposes iOS artifact patterns on an Xcode project", async () => {
+        const dir = await projectDir({ "fastlane/Fastfile": "", "Sample.xcodeproj/project.pbxproj": "" });
+        const d = await detectProject(dir);
+        expect(d.artifactGlobs).toContain("**/*.ipa");
+        expect(d.artifactGlobs.some((g) => g.includes("dSYM"))).toBe(true);
+    });
+    it("proposes Android patterns on a Gradle project", async () => {
+        const dir = await projectDir({ "fastlane/Fastfile": "", "app/build.gradle": "" });
+        const d = await detectProject(dir);
+        expect(d.artifactGlobs).toContain("**/*.apk");
+        expect(d.artifactGlobs).toContain("**/*.aab");
+    });
+    it("reads the remote's URL and the current branch", async () => {
+        const origin = await makeOriginRepo({ "fastlane/Fastfile": "" });
+        const clone = await tmpDir("laneyard-clone-");
+        const { execFile } = await import("node:child_process");
+        const { promisify } = await import("node:util");
+        await promisify(execFile)("git", ["clone", origin, clone]);
+        const d = await detectProject(clone);
+        expect(d.gitUrl).toBe(origin);
+        expect(d.defaultBranch).toBe("main");
+    });
+    it("derives a slug from the folder name", async () => {
+        const dir = await projectDir({ "fastlane/Fastfile": "" });
+        const d = await detectProject(dir);
+        expect(d.slug).toMatch(/^[a-z0-9][a-z0-9-]*$/);
+    });
+});

package/dist/tests/config/load.test.js

@@ -0,0 +1,68 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { loadServerConfig } from "../../src/config/load.js";
+async function withConfig(yaml) {
+    const dir = await mkdtemp(join(tmpdir(), "laneyard-"));
+    const path = join(dir, "config.yml");
+    await writeFile(path, yaml, "utf8");
+    return path;
+}
+const minimal = `
+server:
+  password_hash: "scrypt$aaa$bbb"
+projects:
+  - slug: sample-ios
+    git_url: git@github.com:martin/sample.git
+`;
+describe("loadServerConfig", () => {
+    it("applies the server's default values", async () => {
+        const res = await loadServerConfig(await withConfig(minimal));
+        expect(res.ok).toBe(true);
+        if (!res.ok)
+            return;
+        expect(res.config.server.port).toBe(7890);
+        expect(res.config.server.bind).toBe("0.0.0.0");
+        expect(res.config.server.max_concurrent_runs).toBe(1);
+        expect(res.config.server.retention).toEqual({ runs: 50, artifact_days: 30 });
+    });
+    it("derives a project's name from its slug", async () => {
+        const res = await loadServerConfig(await withConfig(minimal));
+        if (!res.ok)
+            throw new Error("expected valid");
+        expect(res.config.projects[0].name).toBe("sample-ios");
+        expect(res.config.projects[0].default_branch).toBe("main");
+    });
+    it("refuses two projects sharing the same slug", async () => {
+        const res = await loadServerConfig(await withConfig(`
+server: { password_hash: "x" }
+projects:
+  - { slug: a, git_url: u1 }
+  - { slug: a, git_url: u2 }
+`));
+        expect(res.ok).toBe(false);
+        if (res.ok)
+            return;
+        expect(res.error).toMatch(/slug/i);
+    });
+    it("refuses a slug that isn't usable in a path", async () => {
+        const res = await loadServerConfig(await withConfig(`
+server: { password_hash: "x" }
+projects:
+  - { slug: "../evil", git_url: u }
+`));
+        expect(res.ok).toBe(false);
+    });
+    it("reports a readable error on invalid YAML", async () => {
+        const res = await loadServerConfig(await withConfig("server: {"));
+        expect(res.ok).toBe(false);
+        if (res.ok)
+            return;
+        expect(res.error.length).toBeGreaterThan(0);
+    });
+    it("reports a missing file without throwing", async () => {
+        const res = await loadServerConfig("/does/not/exist/config.yml");
+        expect(res.ok).toBe(false);
+    });
+});

package/dist/tests/config/resolve.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { resolveProjectSettings } from "../../src/config/resolve.js";
+const entry = (over = {}) => ({
+    slug: "p",
+    name: "p",
+    git_url: "u",
+    default_branch: "main",
+    git_auth: { kind: "none" },
+    color: "green",
+    notify_browser: true,
+    ...over,
+});
+describe("resolveProjectSettings", () => {
+    it("falls back to the defaults when nothing is set", () => {
+        const r = resolveProjectSettings(entry(), null);
+        expect(r.settings.fastlane_dir).toBe("fastlane");
+        expect(r.settings.timeout_minutes).toBe(60);
+        expect(r.provenance.fastlane_dir).toBe("default");
+    });
+    it("the project's block wins over the defaults", () => {
+        const r = resolveProjectSettings(entry({ timeout_minutes: 15 }), null);
+        expect(r.settings.timeout_minutes).toBe(15);
+        expect(r.provenance.timeout_minutes).toBe("server");
+    });
+    it("the repository wins over the project's block", () => {
+        const r = resolveProjectSettings(entry({ timeout_minutes: 15 }), { timeout_minutes: 90 });
+        expect(r.settings.timeout_minutes).toBe(90);
+        expect(r.provenance.timeout_minutes).toBe("repo");
+    });
+    it("mixes provenances field by field", () => {
+        const r = resolveProjectSettings(entry({ runtime: "system" }), {
+            artifact_globs: ["build/*.ipa"],
+        });
+        expect(r.settings.runtime).toBe("system");
+        expect(r.provenance.runtime).toBe("server");
+        expect(r.settings.artifact_globs).toEqual(["build/*.ipa"]);
+        expect(r.provenance.artifact_globs).toBe("repo");
+        expect(r.provenance.fastlane_dir).toBe("default");
+    });
+    it("treats an empty array as a defined value, not as an absence", () => {
+        const r = resolveProjectSettings(entry(), { artifact_globs: [] });
+        expect(r.provenance.artifact_globs).toBe("repo");
+    });
+});

package/dist/tests/config/store.test.js

@@ -0,0 +1,58 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { ConfigStore } from "../../src/config/store.js";
+import { tmpDir } from "../fixtures/repos.js";
+const CONFIG = (slug) => `
+server: { password_hash: "x" }
+projects:
+  - slug: ${slug}
+    git_url: u
+`;
+async function configFile(content) {
+    const dir = await tmpDir("laneyard-store-");
+    const path = join(dir, "config.yml");
+    await writeFile(path, content, "utf8");
+    return path;
+}
+describe("ConfigStore", () => {
+    it("loads the configuration at startup", async () => {
+        const store = new ConfigStore(await configFile(CONFIG("sample")));
+        await store.load();
+        expect(store.projects().map((p) => p.slug)).toEqual(["sample"]);
+    });
+    it("finds a project by its slug", async () => {
+        const store = new ConfigStore(await configFile(CONFIG("sample")));
+        await store.load();
+        expect(store.project("sample")?.git_url).toBe("u");
+        expect(store.project("unknown")).toBeNull();
+    });
+    it("takes a file change into account", async () => {
+        const path = await configFile(CONFIG("one"));
+        const store = new ConfigStore(path);
+        await store.load();
+        await writeFile(path, CONFIG("two"), "utf8");
+        await store.load();
+        expect(store.projects().map((p) => p.slug)).toEqual(["two"]);
+    });
+    it("keeps the last valid configuration if the file becomes invalid", async () => {
+        const path = await configFile(CONFIG("one"));
+        const store = new ConfigStore(path);
+        await store.load();
+        await writeFile(path, "projects: [", "utf8");
+        const res = await store.load();
+        expect(res.ok).toBe(false);
+        expect(store.projects().map((p) => p.slug)).toEqual(["one"]);
+        expect(store.lastError()).not.toBeNull();
+    });
+    it("clears the error once the file becomes valid again", async () => {
+        const path = await configFile(CONFIG("one"));
+        const store = new ConfigStore(path);
+        await store.load();
+        await writeFile(path, "projects: [", "utf8");
+        await store.load();
+        await writeFile(path, CONFIG("one"), "utf8");
+        await store.load();
+        expect(store.lastError()).toBeNull();
+    });
+});

package/dist/tests/db/runs.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { openDatabase } from "../../src/db/open.js";
+import { RunStore } from "../../src/db/runs.js";
+function store() {
+    return new RunStore(openDatabase(":memory:"));
+}
+describe("RunStore", () => {
+    it("creates a queued run and reads it back", () => {
+        const s = store();
+        const id = s.create({ projectSlug: "p", lane: "beta", platform: "ios", params: { v: "1.2" } });
+        const run = s.get(id);
+        expect(run?.status).toBe("queued");
+        expect(run?.params).toEqual({ v: "1.2" });
+        expect(run?.startedAt).toBeNull();
+    });
+    it("timestamps the transition to running and to a terminal state", () => {
+        const s = store();
+        const id = s.create({ projectSlug: "p", lane: "beta", platform: null, params: {} });
+        s.markRunning(id, { branch: "main", commitSha: "abc123" });
+        expect(s.get(id)?.startedAt).not.toBeNull();
+        expect(s.get(id)?.commitSha).toBe("abc123");
+        s.finish(id, { status: "success", exitCode: 0, errorSummary: null });
+        const done = s.get(id);
+        expect(done?.status).toBe("success");
+        expect(done?.finishedAt).not.toBeNull();
+    });
+    it("lists a project's runs from most recent to oldest", () => {
+        const s = store();
+        const a = s.create({ projectSlug: "p", lane: "a", platform: null, params: {} });
+        const b = s.create({ projectSlug: "p", lane: "b", platform: null, params: {} });
+        s.create({ projectSlug: "other", lane: "c", platform: null, params: {} });
+        expect(s.listByProject("p").map((r) => r.id)).toEqual([b, a]);
+    });
+    it("marks any run still active as interrupted", () => {
+        const s = store();
+        const id = s.create({ projectSlug: "p", lane: "a", platform: null, params: {} });
+        s.markRunning(id, { branch: "main", commitSha: "x" });
+        expect(s.interruptActive()).toBe(1);
+        expect(s.get(id)?.status).toBe("interrupted");
+        expect(s.interruptActive()).toBe(0);
+    });
+    it("records steps and artifacts attached to the run", () => {
+        const s = store();
+        const id = s.create({ projectSlug: "p", lane: "a", platform: null, params: {} });
+        s.replaceSteps(id, [
+            { idx: 0, name: "match", durationMs: 1100, status: "success", logOffset: 42, source: "report" },
+            { idx: 1, name: "build_app", durationMs: 90_000, status: "failed", logOffset: null, source: "report" },
+        ]);
+        s.addArtifact(id, { filename: "P.ipa", path: "/tmp/P.ipa", size: 10, kind: "ipa" });
+        expect(s.steps(id)).toHaveLength(2);
+        expect(s.steps(id)[1].status).toBe("failed");
+        expect(s.artifacts(id)[0].kind).toBe("ipa");
+    });
+});

package/dist/tests/e2e/full-thread.test.js

@@ -0,0 +1,65 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createServerFromConfig } from "../../src/main.js";
+import { hashPassword } from "../../src/server/auth.js";
+import { RunStore } from "../../src/db/runs.js";
+import { makeOriginRepo, tmpDir } from "../fixtures/repos.js";
+const FAKE_DIR = join(process.cwd(), "tests", "fixtures", "fake-fastlane");
+describe("full thread", () => {
+    it("declares, clones, lists, launches, follows, and retrieves the artifact", async () => {
+        const origin = await makeOriginRepo({
+            "fastlane/Fastfile": "lane :beta do\nend\n",
+            "laneyard.yml": 'runtime: system\nartifact_globs: ["build/**/*.ipa"]\n',
+            ".gitignore": "build/\n",
+        });
+        const root = await tmpDir("laneyard-e2e-");
+        await writeFile(join(root, "config.yml"), `
+server:
+  password_hash: "${hashPassword("secret")}"
+projects:
+  - slug: sample
+    name: Sample
+    git_url: ${origin}
+`, "utf8");
+        process.env["PATH"] = `${FAKE_DIR}:${process.env["PATH"]}`;
+        process.env["FAKE_FASTLANE_SCENARIO"] = "success";
+        const { app, db } = await createServerFromConfig(root);
+        const session = (await app.inject({ method: "POST", url: "/api/login", payload: { password: "secret" } })).cookies[0].value;
+        const cookies = { laneyard_session: session };
+        const projects = await app.inject({ method: "GET", url: "/api/projects", cookies });
+        expect(projects.json()).toMatchObject([{ slug: "sample" }]);
+        const created = await app.inject({
+            method: "POST",
+            url: "/api/projects/sample/runs",
+            cookies,
+            payload: { lane: "beta", params: {} },
+        });
+        expect(created.statusCode).toBe(201);
+        const { id } = created.json();
+        // The run is asynchronous: we wait for it to reach a terminal state.
+        const runs = new RunStore(db);
+        const deadline = Date.now() + 60_000;
+        while (Date.now() < deadline) {
+            const status = runs.get(id)?.status;
+            if (status === "success" || status === "failed")
+                break;
+            await new Promise((r) => setTimeout(r, 200));
+        }
+        const detail = await app.inject({ method: "GET", url: `/api/runs/${id}`, cookies });
+        const body = detail.json();
+        expect(body.status).toBe("success");
+        expect(body.steps).toHaveLength(2);
+        expect(body.artifacts[0].filename).toBe("Sample.ipa");
+        const log = await app.inject({ method: "GET", url: `/api/runs/${id}/log`, cookies });
+        expect(log.body).toContain("Step: build_app");
+        const download = await app.inject({
+            method: "GET",
+            url: `/api/runs/${id}/artifacts/${body.artifacts[0].id}`,
+            cookies,
+        });
+        expect(download.statusCode).toBe(200);
+        expect(download.body.trim()).toBe("fake binary");
+        await app.close();
+    }, 120_000);
+});

package/dist/tests/fixtures/repos.js

@@ -0,0 +1,30 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const run = promisify(execFile);
+/** Creates a local git repository serving as a "remote" in the tests. */
+export async function makeOriginRepo(files) {
+    const dir = await mkdtemp(join(tmpdir(), "laneyard-origin-"));
+    await run("git", ["init", "-q", "-b", "main"], { cwd: dir });
+    await run("git", ["config", "user.email", "test@example.com"], { cwd: dir });
+    await run("git", ["config", "user.name", "Test"], { cwd: dir });
+    for (const [name, content] of Object.entries(files)) {
+        await run("mkdir", ["-p", join(dir, name, "..")]).catch(() => { });
+        await writeFile(join(dir, name), content, "utf8");
+    }
+    await run("git", ["add", "-A"], { cwd: dir });
+    await run("git", ["commit", "-q", "-m", "initial"], { cwd: dir });
+    return dir;
+}
+export async function commitTo(repo, name, content) {
+    await writeFile(join(repo, name), content, "utf8");
+    await run("git", ["add", "-A"], { cwd: repo });
+    await run("git", ["commit", "-q", "-m", `edit ${name}`], { cwd: repo });
+    const { stdout } = await run("git", ["rev-parse", "HEAD"], { cwd: repo });
+    return stdout.trim();
+}
+export async function tmpDir(prefix = "laneyard-ws-") {
+    return mkdtemp(join(tmpdir(), prefix));
+}