laneyard 0.1.0

package/dist/src/db/runs.js

@@ -0,0 +1,97 @@
+/** A run is active until it reaches a terminal state. */
+const ACTIVE = ["queued", "preparing", "running"];
+const toRun = (r) => ({
+    id: r.id,
+    projectSlug: r.project_slug,
+    lane: r.lane,
+    platform: r.platform,
+    params: JSON.parse(r.params),
+    status: r.status,
+    branch: r.branch,
+    commitSha: r.commit_sha,
+    interactive: r.interactive === 1,
+    queuedAt: r.queued_at,
+    startedAt: r.started_at,
+    finishedAt: r.finished_at,
+    exitCode: r.exit_code,
+    errorSummary: r.error_summary,
+});
+const now = () => new Date().toISOString();
+export class RunStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    create(input) {
+        const res = this.db
+            .prepare(`INSERT INTO run (project_slug, lane, platform, params, status, interactive, queued_at)
+         VALUES (?, ?, ?, ?, 'queued', ?, ?)`)
+            .run(input.projectSlug, input.lane, input.platform, JSON.stringify(input.params), input.interactive ? 1 : 0, now());
+        return Number(res.lastInsertRowid);
+    }
+    get(id) {
+        const row = this.db.prepare("SELECT * FROM run WHERE id = ?").get(id);
+        return row ? toRun(row) : null;
+    }
+    listByProject(slug, limit = 50) {
+        const rows = this.db
+            .prepare("SELECT * FROM run WHERE project_slug = ? ORDER BY id DESC LIMIT ?")
+            .all(slug, limit);
+        return rows.map(toRun);
+    }
+    setStatus(id, status) {
+        this.db.prepare("UPDATE run SET status = ? WHERE id = ?").run(status, id);
+    }
+    markRunning(id, git) {
+        this.db
+            .prepare("UPDATE run SET status = 'running', started_at = ?, branch = ?, commit_sha = ? WHERE id = ?")
+            .run(now(), git.branch, git.commitSha, id);
+    }
+    finish(id, r) {
+        this.db
+            .prepare("UPDATE run SET status = ?, finished_at = ?, exit_code = ?, error_summary = ? WHERE id = ?")
+            .run(r.status, now(), r.exitCode, r.errorSummary, id);
+    }
+    /** At startup: no run can still be in progress, the process that carried it is dead. */
+    interruptActive() {
+        const placeholders = ACTIVE.map(() => "?").join(", ");
+        const res = this.db
+            .prepare(`UPDATE run SET status = 'interrupted', finished_at = ? WHERE status IN (${placeholders})`)
+            .run(now(), ...ACTIVE);
+        return res.changes;
+    }
+    replaceSteps(runId, steps) {
+        const del = this.db.prepare("DELETE FROM run_step WHERE run_id = ?");
+        const ins = this.db.prepare(`INSERT INTO run_step (run_id, idx, name, duration_ms, status, log_offset, source)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        this.db.transaction(() => {
+            del.run(runId);
+            for (const s of steps) {
+                ins.run(runId, s.idx, s.name, s.durationMs, s.status, s.logOffset, s.source);
+            }
+        })();
+    }
+    steps(runId) {
+        const rows = this.db
+            .prepare("SELECT * FROM run_step WHERE run_id = ? ORDER BY idx")
+            .all(runId);
+        return rows.map((r) => ({
+            idx: r.idx,
+            name: r.name,
+            durationMs: r.duration_ms,
+            status: r.status,
+            logOffset: r.log_offset,
+            source: r.source,
+        }));
+    }
+    addArtifact(runId, a) {
+        this.db
+            .prepare("INSERT INTO artifact (run_id, filename, path, size, kind) VALUES (?, ?, ?, ?, ?)")
+            .run(runId, a.filename, a.path, a.size, a.kind);
+    }
+    artifacts(runId) {
+        return this.db
+            .prepare("SELECT id, filename, path, size, kind FROM artifact WHERE run_id = ? ORDER BY filename")
+            .all(runId);
+    }
+}

package/dist/src/db/schema.sql

@@ -0,0 +1,45 @@
+CREATE TABLE IF NOT EXISTS run (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_slug  TEXT    NOT NULL,
+  lane          TEXT    NOT NULL,
+  platform      TEXT,
+  params        TEXT    NOT NULL DEFAULT '{}',
+  status        TEXT    NOT NULL,
+  branch        TEXT,
+  commit_sha    TEXT,
+  trigger       TEXT    NOT NULL DEFAULT 'manual',
+  interactive   INTEGER NOT NULL DEFAULT 0,
+  queued_at     TEXT    NOT NULL,
+  started_at    TEXT,
+  finished_at   TEXT,
+  exit_code     INTEGER,
+  error_summary TEXT
+);
+CREATE INDEX IF NOT EXISTS run_by_project ON run (project_slug, id DESC);
+
+CREATE TABLE IF NOT EXISTS run_step (
+  run_id      INTEGER NOT NULL REFERENCES run (id) ON DELETE CASCADE,
+  idx         INTEGER NOT NULL,
+  name        TEXT    NOT NULL,
+  duration_ms INTEGER,
+  status      TEXT    NOT NULL,
+  log_offset  INTEGER,
+  source      TEXT    NOT NULL,
+  PRIMARY KEY (run_id, idx)
+);
+
+CREATE TABLE IF NOT EXISTS artifact (
+  id       INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id   INTEGER NOT NULL REFERENCES run (id) ON DELETE CASCADE,
+  filename TEXT    NOT NULL,
+  path     TEXT    NOT NULL,
+  size     INTEGER NOT NULL,
+  kind     TEXT    NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS introspection_cache (
+  project_slug TEXT PRIMARY KEY,
+  config_hash  TEXT NOT NULL,
+  payload      TEXT NOT NULL,
+  fetched_at   TEXT NOT NULL
+);

package/dist/src/git/workspace.js

@@ -0,0 +1,106 @@
+import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+/**
+ * A clone managed by Laneyard, kept between runs.
+ * All git commands go through here to share the authentication environment.
+ */
+export class Workspace {
+    path;
+    gitUrl;
+    auth;
+    constructor(path, gitUrl, auth = { kind: "none" }) {
+        this.path = path;
+        this.gitUrl = gitUrl;
+        this.auth = auth;
+    }
+    env() {
+        // Without this, git can block on a credentials prompt and freeze the run.
+        const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+        if (this.auth.kind === "ssh_key" && this.auth.ref) {
+            env["GIT_SSH_COMMAND"] = `ssh -i ${this.auth.ref} -o IdentitiesOnly=yes -o BatchMode=yes`;
+        }
+        return env;
+    }
+    /**
+     * Replaces the repository URL with a neutral token in a piece of text.
+     *
+     * An HTTPS URL can carry a password — `https://user:token@github.com/…`
+     * is perfectly legal in `config.yml`. But git errors end up in the run's
+     * log file. General secret redaction comes at the next milestone; this
+     * particular leak comes from our own formatting, and is fixed here.
+     */
+    redact(text) {
+        return text.split(this.gitUrl).join("<repository>");
+    }
+    async git(args, cwd = this.path) {
+        try {
+            const { stdout } = await exec("git", args, { cwd, env: this.env(), maxBuffer: 32 * 1024 * 1024 });
+            return stdout.trim();
+        }
+        catch (cause) {
+            const err = cause;
+            const detail = (err.stderr || err.message).trim();
+            throw new Error(`git ${this.redact(args.join(" "))} failed: ${this.redact(detail)}`);
+        }
+    }
+    async exists() {
+        try {
+            await access(join(this.path, ".git"));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * True if there are uncommitted changes to *tracked* files.
+     *
+     * Untracked files are deliberately ignored: a build scatters them around
+     * (fastlane rewrites `fastlane/README.md` on every run, artifacts land in
+     * `build/`), and above all `git checkout` doesn't destroy them. Counting
+     * them would make every second run impossible without protecting anything.
+     */
+    async isDirty() {
+        if (!(await this.exists()))
+            return false;
+        return (await this.git(["status", "--porcelain", "--untracked-files=no"])) !== "";
+    }
+    async headSha() {
+        return this.git(["rev-parse", "HEAD"]);
+    }
+    /**
+     * Guarantees the clone is present, without touching the current branch.
+     *
+     * Needed before any read of the repository outside a run — listing lanes,
+     * reading laneyard.yml — since that information lives in the project's files.
+     */
+    async ensureCloned(onProgress) {
+        if (await this.exists())
+            return;
+        onProgress?.(`Cloning ${this.redact(this.gitUrl)}…`);
+        await this.git(["clone", this.gitUrl, this.path], process.cwd());
+    }
+    /**
+     * Brings the workspace to the requested branch, up to date.
+     * Clones on the first call, just fetches afterwards.
+     */
+    async prepare(branch, onProgress) {
+        if (!(await this.exists())) {
+            await this.ensureCloned(onProgress);
+        }
+        else {
+            if (await this.isDirty()) {
+                throw new Error("The workspace has uncommitted changes. " +
+                    "Commit them or clean the workspace before starting a run.");
+            }
+            onProgress?.("Fetching updates…");
+            await this.git(["fetch", "--prune", "origin"]);
+        }
+        onProgress?.(`Switching to ${branch}…`);
+        await this.git(["checkout", "-q", "-B", branch, `origin/${branch}`]);
+        return this.headSha();
+    }
+}

package/dist/src/heuristics/error-summary.js

@@ -0,0 +1,43 @@
+/**
+ * Extraction of a readable failure cause from a run's output.
+ *
+ * This is a heuristic: it knows fastlane by its display habits, not by a
+ * contract. It therefore lives in this isolated module, and follows the
+ * rule that applies to it — it blocks nothing, changes nothing, and only
+ * produces supplementary information. The full log remains the reference.
+ */
+const ANSI = /\x1b\[[0-9;]*m/g;
+/** Timestamp prefix that fastlane puts at the head of every line. */
+const TIMESTAMP = /^\[\d{2}:\d{2}:\d{2}\]:\s*/;
+/** Marker that fastlane reserves for a failure's final cause. */
+const FASTLANE_ERROR = /^\[!\]\s*(.+)$/;
+const NOISE = /^(fastlane finished with errors|fastlane\.tools finished)/i;
+const LOOKS_LIKE_FAILURE = /error|failed|failure|échou/i;
+/**
+ * Renders a displayable sentence next to a failed run, or a fallback sentence.
+ *
+ * The order of preference follows decreasing reliability: fastlane's explicit
+ * marker first, a line mentioning an error next, the exit code as a last
+ * resort. The generic "fastlane finished with errors" is discarded: it is
+ * always present and teaches nothing.
+ */
+export function summarizeFailure(log, exitCode) {
+    const lines = log
+        .replace(ANSI, "")
+        .split("\n")
+        .map((line) => line.replace(TIMESTAMP, "").trim())
+        .filter((line) => line.length > 0);
+    for (const line of [...lines].reverse()) {
+        const marked = FASTLANE_ERROR.exec(line);
+        if (marked?.[1])
+            return marked[1].slice(0, 500);
+    }
+    const mentioning = [...lines]
+        .reverse()
+        .find((line) => LOOKS_LIKE_FAILURE.test(line) && !NOISE.test(line));
+    if (mentioning)
+        return mentioning.slice(0, 500);
+    return exitCode === null
+        ? "The run failed with no usable message"
+        : `fastlane stopped with exit code ${exitCode}`;
+}

package/dist/src/logs/store.js

@@ -0,0 +1,66 @@
+import { createReadStream } from "node:fs";
+import { mkdir, open, readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Append-only writer for a run.
+ * `offset` counts bytes, never characters: that's what the browser-side
+ * read resumption works with, and a multi-byte character can span several bytes.
+ */
+export class LogWriter {
+    handle;
+    _offset = 0;
+    queue = Promise.resolve();
+    constructor(handle) {
+        this.handle = handle;
+    }
+    get offset() {
+        return this._offset;
+    }
+    /**
+     * Reserves the offset immediately then serializes the writes.
+     *
+     * Fragments arrive from a PTY, without waiting: if the offset were computed
+     * after the write, two concurrent fragments could claim the same position
+     * and the browser-side catch-up would duplicate or lose text.
+     */
+    async append(chunk) {
+        const buf = Buffer.from(chunk, "utf8");
+        const start = this._offset;
+        this._offset += buf.byteLength;
+        this.queue = this.queue.then(() => this.handle.write(buf)).catch(() => {
+            // The file may have been closed while the process was still finishing up.
+        });
+        await this.queue;
+        return start;
+    }
+    async close() {
+        await this.queue;
+        await this.handle.close();
+    }
+}
+export class LogStore {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    pathFor(runId) {
+        return join(this.dir, `${runId}.log`);
+    }
+    async open(runId) {
+        await mkdir(this.dir, { recursive: true });
+        return new LogWriter(await open(this.pathFor(runId), "w"));
+    }
+    async read(runId, fromOffset = 0) {
+        try {
+            const buf = await readFile(this.pathFor(runId));
+            return buf.subarray(fromOffset).toString("utf8");
+        }
+        catch {
+            return "";
+        }
+    }
+    /** For serving a large log without loading it entirely into memory. */
+    stream(runId, fromOffset = 0) {
+        return createReadStream(this.pathFor(runId), { start: fromOffset });
+    }
+}

package/dist/src/main.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runAddCommand } from "./cli/add.js";
+import { ConfigStore } from "./config/store.js";
+import { CacheStore } from "./db/cache.js";
+import { openDatabase } from "./db/open.js";
+import { RunStore } from "./db/runs.js";
+import { buildApp } from "./server/app.js";
+import { makeInvoke } from "./sidecar/bridge.js";
+import { LaneReader } from "./sidecar/lanes.js";
+export const version = "0.1.0";
+/** Assembles the server from a data folder. */
+export async function createServerFromConfig(root) {
+    const config = new ConfigStore(join(root, "config.yml"));
+    const loaded = await config.load();
+    if (!loaded.ok)
+        throw new Error(`Unreadable configuration: ${loaded.error}`);
+    const db = openDatabase(join(root, "laneyard.db"));
+    // No run can survive the shutdown of the process that carried it.
+    new RunStore(db).interruptActive();
+    const cache = new CacheStore(db);
+    const app = await buildApp({
+        config,
+        db,
+        root,
+        lanes: async (slug, workspacePath, fastlaneDir) => {
+            const resolved = await config.resolve(slug, workspacePath);
+            const reader = new LaneReader(cache, makeInvoke(resolved?.settings.runtime ?? "bundle"));
+            return reader.read(slug, workspacePath, fastlaneDir);
+        },
+    });
+    return { app, db, config };
+}
+/** Real startup, outside tests. */
+async function main() {
+    const root = process.env["LANEYARD_HOME"] ?? join(homedir(), ".laneyard");
+    const { app, config } = await createServerFromConfig(root);
+    config.watch((ok) => {
+        if (!ok)
+            console.error(`Invalid configuration, the previous one stays active: ${config.lastError()}`);
+    });
+    const server = config.server();
+    await app.listen({ port: server.port, host: server.bind });
+    console.log(`Laneyard is listening on http://localhost:${server.port}`);
+}
+/**
+ * True when this file is what the user launched, rather than something that
+ * imported it.
+ *
+ * Comparing real paths and not file names: installed globally, `laneyard` is a
+ * symlink whose name has nothing to do with this file, and a check on "main.js"
+ * would leave the command silently doing nothing.
+ */
+function invokedDirectly() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+const USAGE = `laneyard — a self-hosted web UI for fastlane
+
+  laneyard add        adopt the project in the current directory
+  laneyard            start the server
+  laneyard --version  print the version
+
+Configuration lives in ~/.laneyard/config.yml, or in $LANEYARD_HOME.
+`;
+function homeDir() {
+    return process.env["LANEYARD_HOME"] ?? join(homedir(), ".laneyard");
+}
+/** Turns a startup failure into something a newcomer can act on. */
+function explainStartupFailure(cause) {
+    const message = cause.message;
+    if (message.includes("ENOENT") && message.includes("config.yml")) {
+        return ("No configuration yet.\n\n" +
+            "  cd into a project that already uses fastlane, then run:\n" +
+            "    laneyard add\n\n" +
+            "That writes " + join(homeDir(), "config.yml") + " for you.");
+    }
+    return message;
+}
+if (invokedDirectly()) {
+    const [, , command, ...rest] = process.argv;
+    if (command === "--help" || command === "-h" || command === "help") {
+        process.stdout.write(USAGE);
+        process.exit(0);
+    }
+    if (command === "--version" || command === "-v") {
+        process.stdout.write(`${version}\n`);
+        process.exit(0);
+    }
+    if (command === "add") {
+        const home = homeDir();
+        await mkdir(home, { recursive: true });
+        const slugIndex = rest.indexOf("--slug");
+        const slug = slugIndex === -1 ? undefined : rest[slugIndex + 1];
+        try {
+            process.exit(await runAddCommand(process.cwd(), join(home, "config.yml"), slug));
+        }
+        catch (cause) {
+            // A taken slug or an unreadable file are ordinary situations. A stack
+            // trace is not an error message; it just suggests the tool is broken.
+            process.stderr.write(`${cause.message}\n`);
+            process.exit(1);
+        }
+    }
+    if (command !== undefined) {
+        process.stderr.write(`Unknown command: ${command}\n\n${USAGE}`);
+        process.exit(1);
+    }
+    main().catch((cause) => {
+        process.stderr.write(`${explainStartupFailure(cause)}\n`);
+        process.exit(1);
+    });
+}

package/dist/src/runner/artifacts.js

@@ -0,0 +1,59 @@
+import { mkdir, rename, stat } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { glob } from "tinyglobby";
+export function guessKind(filename) {
+    const name = filename.toLowerCase();
+    if (name.endsWith(".dsym.zip") || name.includes(".dsym"))
+        return "dsym";
+    switch (extname(name)) {
+        case ".ipa":
+            return "ipa";
+        case ".apk":
+            return "apk";
+        case ".aab":
+            return "aab";
+        default:
+            return "other";
+    }
+}
+/**
+ * Moves out of the workspace any file matching the configured patterns.
+ *
+ * The patterns are the only contract: Laneyard doesn't parse the run's
+ * output to guess paths. Moving — rather than copying — avoids doubling
+ * disk usage and guarantees the next build won't accidentally reuse a
+ * stale artifact.
+ */
+export async function collectArtifacts(workspacePath, patterns, destDir) {
+    if (patterns.length === 0)
+        return [];
+    const matches = await glob(patterns, {
+        cwd: workspacePath,
+        absolute: true,
+        onlyFiles: true,
+        dot: false,
+    });
+    if (matches.length === 0)
+        return [];
+    await mkdir(destDir, { recursive: true });
+    const used = new Set();
+    const collected = [];
+    for (const source of matches.sort()) {
+        let filename = basename(source);
+        if (used.has(filename)) {
+            // Two paths can produce the same name; we prefix rather than overwrite.
+            const ext = extname(filename);
+            const stem = filename.slice(0, filename.length - ext.length);
+            let n = 2;
+            while (used.has(`${stem}-${n}${ext}`))
+                n += 1;
+            filename = `${stem}-${n}${ext}`;
+        }
+        used.add(filename);
+        const dest = join(destDir, filename);
+        await rename(source, dest);
+        const info = await stat(dest);
+        collected.push({ filename, path: dest, size: info.size, kind: guessKind(filename) });
+    }
+    return collected;
+}

package/dist/src/runner/live-steps.js

@@ -0,0 +1,38 @@
+/**
+ * Spotting of step separators in fastlane's output, during the run.
+ *
+ * Fragile by nature: this is text meant for humans. We therefore keep only
+ * one thing from it, the byte offset where each step starts — the only
+ * piece of information report.xml doesn't contain. The names and durations
+ * that count come from the report at the end of the run.
+ */
+// Real form observed, ANSI sequences included:
+//   [13:14:00]: \x1b[32m--- Step: mkdir -p ../build && echo x > y.ipa ---\x1b[0m
+// The name isn't an identifier: for a `sh` action, it's the entire command,
+// spaces included. The capture is therefore lazy up to the closing dashes,
+// and definitely not `\S+`.
+const SEPARATOR = /-{2,}\s+Step:\s*(.+?)\s+-{2,}/;
+export class LiveStepTracker {
+    pending = "";
+    pendingOffset = 0;
+    found = [];
+    /** `offset` is the fragment's position in the log file. */
+    consume(chunk, offset) {
+        if (this.pending === "")
+            this.pendingOffset = offset;
+        this.pending += chunk;
+        let nl;
+        while ((nl = this.pending.indexOf("\n")) !== -1) {
+            const line = this.pending.slice(0, nl);
+            const lineOffset = this.pendingOffset;
+            this.pendingOffset += Buffer.byteLength(this.pending.slice(0, nl + 1), "utf8");
+            this.pending = this.pending.slice(nl + 1);
+            const m = SEPARATOR.exec(line);
+            if (m?.[1])
+                this.found.push({ name: m[1], logOffset: lineOffset });
+        }
+    }
+    steps() {
+        return this.found;
+    }
+}