looply-cli 0.0.0-stage → 0.3.0

package/dist/surface-lease.js

@@ -0,0 +1,485 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.surfaceDir = surfaceDir;
+exports.highestIssued = highestIssued;
+exports.holderOf = holderOf;
+exports.acquireSurfaces = acquireSurfaces;
+exports.checkFence = checkFence;
+exports.releaseSurface = releaseSurface;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const core_1 = require("@looply/core");
+const git_driver_1 = require("./git-driver");
+const exclusive_lock_1 = require("./exclusive-lock");
+const run_lease_1 = require("./run-lease");
+/**
+ * A LEASE OVER A RESOURCE SURFACE, WITH A FENCE.
+ *
+ * ⚠️ THE SAME PRIMITIVE `RunLeaseStore` USES, PARAMETERISED — the recon's own
+ * words: "`RunLeaseStore` parameterised from `run.lease.json` to
+ * `leases/<surfaceKey>.json` is a resource lease with no new correctness
+ * argument." What IS new is the fence, and it is new because this lease may
+ * expire and the run lease may not.
+ *
+ * 🔴 EXPIRY EXISTS ONLY HERE, AND ONLY BECAUSE OF THE FENCE.
+ *
+ * The run lease has no expiry on purpose: a run inside a forty-five-minute
+ * model call is legitimately silent, and a lease that timed out would be
+ * reclaimed from a run that was working perfectly. A SURFACE lease can expire
+ * because a stale holder is caught at the publishing site by comparing two
+ * integers — which still works when the thing being checked has been asleep.
+ * Take the fence away and the expiry becomes exactly the hazard the run lease
+ * refuses to have.
+ */
+/** Where one surface's claims live: `<projectState>/leases/<hash>/`. */
+function surfaceDir(cwd, surface) {
+    /**
+     * ⚠️ HASHED, BECAUSE A SURFACE KEY IS A PATH PREFIX AND A PATH PREFIX IS NOT
+     * A FILENAME. `src/app` has a separator in it; `../..` has worse. Hashing is
+     * not obfuscation here, it is the doorway — the same reasoning that made the
+     * run registry validate a runId where it enters.
+     *
+     * 🔴 AND THE CANONICAL FORM IS HASHED, NOT THE RAW STRING. Seven spellings of
+     * `src/app` hashed to seven directories and took seven simultaneous leases
+     * over the same files. See `canonicalSurface`.
+     */
+    const key = (0, node_crypto_1.createHash)('sha256').update((0, core_1.canonicalSurface)(surface), 'utf8').digest('hex').slice(0, 16);
+    return (0, node_path_1.join)((0, git_driver_1.projectStateDir)(cwd), 'leases', key);
+}
+/**
+ * SERIALISE THE WHOLE CHECK-AND-CLAIM, BECAUSE OVERLAP CANNOT BE CONFIRMED
+ * AFTER THE FACT.
+ *
+ * 🔴 THE SAME-KEY RACE IS SETTLED BY READING BACK — whoever holds the lowest
+ * live ordinal won, and everyone else stands down. That works because all the
+ * contenders are comparing ONE ordered sequence.
+ *
+ * Overlapping keys have no such sequence. `src` and `src/app` are different
+ * directories with independent ordinals, so "who got there first" is not a
+ * question their contents can answer. MEASURED with the read-back in place and
+ * no mutex: eight racers over `src`, `src/app` and `src/app/api` produced FOUR
+ * simultaneous holders, three trials running.
+ *
+ * So acquisition takes a short project-wide lock. It is the right shape for
+ * this: acquiring surfaces happens once per run, takes microseconds, and is the
+ * only writer — while the READ paths (`holderOf`, `checkFence`) take nothing
+ * and stay lock-free. `queue-write-lease` settled the same discipline for the
+ * queue and for the same reason.
+ *
+ * ⚠️ AND A DEAD HOLDER'S LOCK IS BROKEN BY CONTENT MATCH, never by path. Phase
+ * 1 measured what removing a lock by path costs: a process that had already
+ * lost its claim deleted the winner's, and four processes then held one lock.
+ */
+function acquireLockPath(cwd) {
+    return (0, node_path_1.join)((0, git_driver_1.projectStateDir)(cwd), 'leases', '.acquire.lock');
+}
+/**
+ * ⚠️ THE MUTEX ITSELF NOW LIVES IN `exclusive-lock`, because the spend ledger
+ * needs the same thing for the same reason — see the docblock there. This is
+ * the surface path's name for it, and nothing about the discipline changed.
+ */
+function withAcquireLock(cwd, fn, fallback) {
+    return (0, exclusive_lock_1.withExclusiveLock)(acquireLockPath(cwd), fn, () => fallback('another process is claiming surfaces here and did not finish in time'));
+}
+/** Every surface this project currently has a lease directory for. */
+function leasedSurfaces(cwd) {
+    const root = (0, node_path_1.join)((0, git_driver_1.projectStateDir)(cwd), 'leases');
+    let dirs;
+    try {
+        dirs = (0, node_fs_1.readdirSync)(root);
+    }
+    catch {
+        return [];
+    }
+    const out = new Set();
+    for (const d of dirs) {
+        // The key is not recoverable from the hash, so it is read back off a claim.
+        // Any claim will do: every claim in a directory names the same surface.
+        let names;
+        try {
+            names = (0, node_fs_1.readdirSync)((0, node_path_1.join)(root, d));
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!name.endsWith('.json'))
+                continue;
+            const claim = readClaim((0, node_path_1.join)(root, d, name));
+            if (claim !== null) {
+                out.add(claim.surface);
+                break;
+            }
+        }
+    }
+    return [...out];
+}
+/** The highest ordinal ever issued for a surface, or null when it cannot be read. */
+function highestIssued(cwd, surface) {
+    const dir = surfaceDir(cwd, surface);
+    let names;
+    try {
+        names = (0, node_fs_1.readdirSync)(dir);
+    }
+    catch (e) {
+        // ENOENT means nobody has ever taken it: zero, not unknown.
+        return e.code === 'ENOENT' ? 0 : null;
+    }
+    let top = 0;
+    for (const name of names) {
+        if (!name.endsWith('.json'))
+            continue;
+        const n = Number.parseInt(name.slice(0, -'.json'.length), 10);
+        if (Number.isInteger(n) && n > top)
+            top = n;
+    }
+    return top;
+}
+/**
+ * A claim, or null when the file is not one.
+ *
+ * ⚠️ NULL HERE MEANS "NOT A CLAIM", NOT "NOT HELD". The difference is the whole
+ * of `stillHeld`'s unreadable branch: a file that will not parse is a claim
+ * this process cannot judge, and the caller must treat that as held.
+ */
+function readClaim(path) {
+    try {
+        const c = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+        if (typeof c.ordinal !== 'number' || typeof c.runId !== 'string')
+            return null;
+        if (typeof c.pid !== 'number' || typeof c.host !== 'string')
+            return null;
+        return c;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether a claim file exists at this ordinal, whatever its contents. */
+function claimFilePresent(dir, ordinal) {
+    return (0, node_fs_1.existsSync)((0, node_path_1.join)(dir, `${String(ordinal).padStart(4, '0')}.json`));
+}
+/**
+ * Is the claim at this ordinal still held?
+ *
+ * ⚠️ TWO WITNESSES, AS EVERYWHERE ELSE IN THIS CODEBASE: the holder's process
+ * must answer AND the lease must not have expired. Either one alone is a
+ * half-answer — a live process whose lease lapsed is a stale holder, and an
+ * unexpired lease whose process is gone is litter.
+ *
+ * ⚠️ AND A FOREIGN HOST IS NEVER JUDGED. A pid means nothing across machines.
+ */
+function stillHeld(claim, now) {
+    const lapsed = now - Date.parse(claim.acquiredAt) >= claim.ttlMs;
+    /**
+     * 🔴 A FOREIGN HOST'S CLAIM EXPIRES TOO — IT USED TO BE HELD FOR EVER.
+     *
+     * The old line returned `true` before the TTL was ever compared, so a claim
+     * written by another machine held the surface permanently: no verb cleared
+     * it, no reaper looked at it, and no amount of elapsed time changed it. On a
+     * shared checkout that is a surface lost for the life of the repository.
+     *
+     * The pid still cannot be judged across machines and is not. What CAN be
+     * judged is the clock, which is the reason this lease has a TTL at all and
+     * why the fence exists to make expiry safe: a stale holder that wakes up is
+     * caught at the publishing site by comparing two integers.
+     */
+    if (claim.host !== (0, node_os_1.hostname)())
+        return !lapsed;
+    if ((0, run_lease_1.nodeProbe)(claim.pid) !== 'dead')
+        return !lapsed;
+    return false;
+}
+/**
+ * Who holds this surface right now, if anybody.
+ *
+ * 🔴 THE LOWEST LIVE ORDINAL HOLDS IT — READING ONLY THE HIGHEST WAS A SECOND
+ * WRITER.
+ *
+ * MEASURED: run_LOW claims ordinal 1 and run_HIGH claims ordinal 2; run_HIGH
+ * releases; `holderOf` reads the top, sees it released, and answers NOBODY
+ * while run_LOW is alive and unaware. A third run then acquires ordinal 3 and
+ * two live holders write the same files.
+ *
+ * A lease is first-come-first-served, so the holder is the OLDEST claim that is
+ * still live. That composes with the fence rather than contradicting it: the
+ * fence asks "is my ordinal still the highest ever issued" at the moment of
+ * PUBLISHING, which is what catches a holder whose lease lapsed while a newer
+ * one took over.
+ *
+ * ⚠️ AND AN UNREADABLE CLAIM IS A HOLDER. `readClaim` returning null used to
+ * mean "free", which is the exact inversion of `mayPublish`'s own rule that
+ * unknown is a refusal — and it is reachable by a torn write, a full disk, or a
+ * permissions change. A surface this process cannot judge is one it must not
+ * take.
+ */
+function holderOf(cwd, surface, now = Date.now()) {
+    const top = highestIssued(cwd, surface);
+    if (top === null || top === 0)
+        return null;
+    const dir = surfaceDir(cwd, surface);
+    for (let ordinal = 1; ordinal <= top; ordinal++) {
+        if (released(dir, ordinal))
+            continue; // given back: the ordinal stands, the hold does not
+        if (!claimFilePresent(dir, ordinal))
+            continue; // an ordinal nobody ever wrote
+        const claim = readClaim((0, node_path_1.join)(dir, `${String(ordinal).padStart(4, '0')}.json`));
+        if (claim === null) {
+            // Present and unreadable. Deny is the default: report it as a holder
+            // nobody can identify rather than as free space.
+            return {
+                surface,
+                ordinal,
+                runId: '(unreadable)',
+                pid: 0,
+                host: '(unknown)',
+                acquiredAt: new Date(now).toISOString(),
+                ttlMs: 0,
+            };
+        }
+        if (stillHeld(claim, now))
+            return claim;
+    }
+    return null;
+}
+/**
+ * TAKE EVERY DECLARED SURFACE, IN ORDER, ALL OR NOTHING.
+ *
+ * 🔴 THE ORDER IS WHAT MAKES DEADLOCK UNREPRESENTABLE. Lexicographic and
+ * total, so two Runs wanting the same pair always contend on the same one
+ * first. A Run never acquires a second surface while holding a first — which is
+ * the same statement, and is why there is no detector here to write.
+ *
+ * ⚠️ AND A PARTIAL ACQUISITION IS ROLLED BACK. Holding two of three surfaces
+ * while waiting for the third is precisely the state a total order exists to
+ * make impossible; leaving one behind on a failure would reintroduce it by the
+ * back door.
+ */
+function acquireSurfaces(cwd, surfaces, who, now = Date.now()) {
+    /**
+     * ⚠️ NO DECLARATION, NO OBLIGATION. This is the compatibility guarantee, and
+     * it is the first line so nothing below it can accidentally weaken it. It is
+     * also outside the lock, so a run that declares nothing — Simple Mode, and
+     * every run that existed before surfaces did — touches no lock at all.
+     */
+    if (surfaces.length === 0)
+        return { ok: true, held: [] };
+    return withAcquireLock(cwd, () => claimAll(cwd, surfaces, who, now), (why) => ({ ok: false, because: why }));
+}
+function claimAll(cwd, surfaces, who, now) {
+    const taken = [];
+    /** Fences this run ALREADY held when it asked again. Never rolled back. */
+    const already = [];
+    const rollback = () => {
+        // ⚠️ MARKED, NOT DELETED — see `releaseSurface`. An ordinal that is handed
+        // back and then REUSED lets a revived holder from the previous generation
+        // compare equal to the current one.
+        for (const t of taken)
+            releaseSurface(cwd, t.fence, who.runId);
+    };
+    /**
+     * 🔴 A KEY THAT NAMES NOTHING IS REFUSED AT THE DOORWAY. `.` and `''` used to
+     * be accepted, took a lease that excluded nobody, and switched the trespass
+     * check off for the whole run. See `surfaceKeyTrouble`.
+     */
+    for (const surface of surfaces) {
+        const trouble = (0, core_1.surfaceKeyTrouble)(surface);
+        if (trouble !== null)
+            return { ok: false, because: trouble, blockedBy: surface };
+    }
+    for (const surface of (0, core_1.acquisitionOrder)(surfaces)) {
+        /**
+         * 🔴 OVERLAP, NOT EQUALITY — `src`, `src/app` AND `src/app/api` WERE THREE
+         * LEASES OVER ONE TREE, ALL GRANTED, ALL WRITING THE SAME FILE.
+         *
+         * The lease compared surface keys for equality and nothing else, so a run
+         * declaring the parent and a run declaring the child never contended. This
+         * asks the question the lease exists to ask: does anybody already hold a
+         * surface that contains mine, or one mine contains?
+         */
+        for (const other of leasedSurfaces(cwd)) {
+            if ((0, core_1.canonicalSurface)(other) === (0, core_1.canonicalSurface)(surface))
+                continue;
+            if (!(0, core_1.surfacesOverlap)(other, surface))
+                continue;
+            const overlapping = holderOf(cwd, other, now);
+            if (overlapping !== null && overlapping.runId !== who.runId) {
+                rollback();
+                return {
+                    ok: false,
+                    because: `${surface} overlaps ${other}, which is held by ${overlapping.runId} ` +
+                        `(pid ${overlapping.pid}, since ${overlapping.acquiredAt})`,
+                    blockedBy: surface,
+                };
+            }
+        }
+        const held = holderOf(cwd, surface, now);
+        if (held !== null && held.runId !== who.runId) {
+            rollback();
+            return {
+                ok: false,
+                because: `${surface} is held by ${held.runId} (pid ${held.pid}, since ${held.acquiredAt})`,
+                blockedBy: surface,
+            };
+        }
+        /**
+         * 🔴 A RUN THAT ALREADY HOLDS THIS SURFACE IS HANDED BACK ITS OWN FENCE —
+         * AND ASKING TWICE USED TO INVALIDATE THE FIRST ANSWER.
+         *
+         * The line above lets a run past its own claim, which is right: it is not
+         * blocked by itself. But the code then issued a NEW, HIGHER ordinal, and
+         * `checkFence` compares against "highest ever issued" — so the fence the
+         * run was already carrying stopped validating the moment it asked again.
+         *
+         * MEASURED: one run, two `acquireSurfaces` calls for `src/app`. The first
+         * fence validated before the second call and was refused after it —
+         * "src/app has been taken over — this holds fence 1 and the surface is at
+         * 2" — about a takeover by itself.
+         *
+         * Latent today because there is exactly one production call site, which is
+         * the same "no production caller" reasoning that made the fence itself a
+         * finding, pointing the other way. Idempotence is the honest answer: asking
+         * for what you already hold returns what you already hold.
+         */
+        if (held !== null && held.runId === who.runId) {
+            // ⚠️ NOT IN `taken`, so a later rollback cannot release a fence this run
+            // was already carrying before it asked. Rollback undoes what THIS call
+            // claimed; this was claimed by an earlier one.
+            already.push({ surface, ordinal: held.ordinal });
+            continue;
+        }
+        const top = highestIssued(cwd, surface);
+        if (top === null) {
+            rollback();
+            return { ok: false, because: `the holders of ${surface} could not be read`, blockedBy: surface };
+        }
+        const dir = surfaceDir(cwd, surface);
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+        let ordinal = top + 1;
+        let placed = false;
+        // Bounded: the number of claimants that could take a number between the
+        // read and the write. Far past any real machine.
+        for (; ordinal < top + 1 + 64 && !placed; ordinal++) {
+            const path = (0, node_path_1.join)(dir, `${String(ordinal).padStart(4, '0')}.json`);
+            const claim = {
+                surface,
+                ordinal,
+                runId: who.runId,
+                pid: process.pid,
+                host: (0, node_os_1.hostname)(),
+                acquiredAt: new Date(now).toISOString(),
+                ttlMs: who.ttlMs,
+            };
+            try {
+                (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(claim, null, 2)}\n`, { encoding: 'utf8', flag: 'wx' });
+                taken.push({ surface, path, fence: { surface, ordinal } });
+                placed = true;
+            }
+            catch (e) {
+                const code = e.code;
+                // Windows answers EPERM rather than EEXIST against a pending-delete file.
+                if (code !== 'EEXIST' && code !== 'EPERM') {
+                    rollback();
+                    return { ok: false, because: `${surface} could not be claimed: ${e.message}`, blockedBy: surface };
+                }
+            }
+        }
+        if (!placed) {
+            rollback();
+            return { ok: false, because: `${surface} is being claimed too fast to join`, blockedBy: surface };
+        }
+        /**
+         * 🔴 READ BACK AFTER CLAIMING — WITHOUT THIS THERE IS NO EXCLUSION AT ALL.
+         *
+         * MEASURED, eight real processes racing one surface, three trials:
+         * 8/8 acquired, 8/8 acquired, 8/8 acquired. ZERO refusals, every time.
+         *
+         * The reason is that `wx` was doing a different job from the one it looked
+         * like it was doing. Exclusive create guarantees that two writers never get
+         * the SAME ordinal — and that is all it guarantees. Process A takes ordinal
+         * 1, process B takes ordinal 2, both succeed, both believe they hold the
+         * surface. The check above ran BEFORE the write, against state that a
+         * competitor invalidates in the microsecond afterwards; nothing ever asked
+         * the question again once the claim existed.
+         *
+         * So the claim is a nomination and this is the election: whoever holds the
+         * lowest live ordinal won, and everybody else releases and reports who did.
+         * `queue-write-lease` settled this discipline for its own lock and wrote
+         * down why — "re-reads after claiming". This is the same rule, and the
+         * absence of it here is what made a whole subsystem decorative.
+         */
+        const winner = holderOf(cwd, surface, now);
+        if (winner === null || winner.runId !== who.runId) {
+            // Give back the ordinal we nominated ourselves with, then report.
+            releaseSurface(cwd, { surface, ordinal: ordinal - 1 }, who.runId);
+            rollback();
+            return {
+                ok: false,
+                because: winner === null
+                    ? `${surface} could not be confirmed after claiming it`
+                    : `${surface} is held by ${winner.runId} (pid ${winner.pid}, since ${winner.acquiredAt})`,
+                blockedBy: surface,
+            };
+        }
+    }
+    return { ok: true, held: [...already, ...taken.map((t) => t.fence)] };
+}
+/**
+ * MAY THIS HOLDER PUBLISH?
+ *
+ * The whole point of the fence, asked at the moment of the write rather than
+ * assumed at the moment of the claim.
+ */
+function checkFence(cwd, fence) {
+    return (0, core_1.mayPublish)(fence, highestIssued(cwd, fence.surface));
+}
+/**
+ * Give a surface back.
+ *
+ * 🔴 IT MARKS, IT DOES NOT DELETE — AND THE FIRST VERSION DELETED, WHICH BROKE
+ * THE FENCE OUTRIGHT. Caught by this file's own test.
+ *
+ * `highestIssued` reads the directory. Remove the claim and the count drops
+ * back, so the next acquirer is handed the SAME ordinal — and a revived holder
+ * from the previous generation then compares EQUAL to the current one and is
+ * allowed to publish. Two writers on one surface, arrived at by giving a
+ * surface back politely.
+ *
+ * "Highest ever issued" has to mean EVER. So the directory is append-only, like
+ * every other ledger in this codebase: a release adds `<NNNN>.released` beside
+ * the claim rather than taking the claim away. `highestIssued` counts claims;
+ * `holderOf` reads the marker.
+ *
+ * ⚠️ BY IDENTITY, AND BY EXCLUSIVE CREATE. Phase 1 measured what removing a
+ * claim by PATH costs: a process that had already lost its hold deleted the
+ * winner's, and four processes then held one lock.
+ */
+function releaseSurface(cwd, fence, runId) {
+    const dir = surfaceDir(cwd, fence.surface);
+    const n = String(fence.ordinal).padStart(4, '0');
+    const path = (0, node_path_1.join)(dir, `${n}.json`);
+    if (!(0, node_fs_1.existsSync)(path))
+        return false;
+    const claim = readClaim(path);
+    if (claim === null || claim.runId !== runId)
+        return false;
+    try {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, `${n}.released`), `${new Date().toISOString()}\n`, {
+            encoding: 'utf8',
+            flag: 'wx',
+        });
+        return true;
+    }
+    catch (e) {
+        // Already released is success: the surface is given back either way.
+        const code = e.code;
+        return code === 'EEXIST' || code === 'EPERM';
+    }
+}
+/** Whether the claim at this ordinal has been handed back. */
+function released(dir, ordinal) {
+    return (0, node_fs_1.existsSync)((0, node_path_1.join)(dir, `${String(ordinal).padStart(4, '0')}.released`));
+}
+//# sourceMappingURL=surface-lease.js.map

package/dist/surface-lease.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-lease.js","sourceRoot":"","sources":["../src/surface-lease.ts"],"names":[],"mappings":"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"}

package/dist/sync.d.ts

@@ -0,0 +1,54 @@
+import type { LooplyConfig } from './config';
+import { ServerClient } from './server-client';
+import { Daemon } from './daemon';
+/**
+ * Attaching a local command to the server.
+ *
+ * Both of the CLI's long jobs need this and neither should own it: a run streams
+ * its rounds, a scan streams its passes, and the code that decides whether this
+ * machine is paired at all is the same either way.
+ */
+export interface Sync {
+    daemon: Daemon;
+    /** The authenticated client, so a caller can read settings without re-pairing. */
+    client: ServerClient;
+    /** The project id the *server* knows this repo by; see the note in attachSync. */
+    projectId: string;
+    /** False once the stream has died. Reported, never thrown — see superviseStream. */
+    alive(): boolean;
+    stop(): Promise<void>;
+}
+/** A supervised daemon loop: it never rejects, and it says when it stopped. */
+export interface SupervisedStream {
+    alive(): boolean;
+    /** Resolves when the loop is over, however it ended. Never rejects. */
+    settled: Promise<void>;
+}
+/**
+ * Watch the daemon loop that runs alongside the work.
+ *
+ * `daemon.run()` is started and not awaited until the end, so a throw inside it
+ * is a rejection nobody is holding — which Node turns into a process-level
+ * unhandled rejection and, since Node 15, into a dead process. The stream exists
+ * only to report on the run; it must never be able to end it. So the rejection
+ * is caught here, in the same tick it is created, the stream is marked dead, and
+ * the failure is said out loud once instead of the phone simply going quiet.
+ *
+ * A loop that finishes normally is not dead: `alive` means "did not fail", which
+ * is what a caller wants to know after a deliberate stop.
+ */
+export declare function superviseStream(loop: Promise<unknown>, 
+/** What is being streamed, for the message. "this run", not "this". */
+what: string, log: (line: string) => void): SupervisedStream;
+/**
+ * Connect to the server, when this machine is paired.
+ *
+ * Returns null for an unpaired machine, which is a normal state rather than a
+ * failure — looply runs perfectly well with no server, and the app is something
+ * you add. Any error here degrades to the same null: local work must never fail
+ * because a relay is unreachable.
+ */
+export declare function attachSync(cwd: string, config: LooplyConfig, log: (line: string) => void, 
+/** What is being attached, for the messages. "this run stays local", not "this". */
+what?: string): Promise<Sync | null>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC;;;;;;GAMG;AAEH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,MAAM,EAAE,YAAY,CAAC;IACrB,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,KAAK,IAAI,OAAO,CAAC;IACjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,IAAI,OAAO,CAAC;IACjB,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC;AACtB,uEAAuE;AACvE,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC1B,gBAAgB,CAWlB;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;AAC3B,oFAAoF;AACpF,IAAI,SAAQ,GACX,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAsDtB"}

package/dist/sync.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superviseStream = superviseStream;
+exports.attachSync = attachSync;
+const machine_store_1 = require("./machine-store");
+const server_client_1 = require("./server-client");
+const daemon_1 = require("./daemon");
+const daemon_cmd_1 = require("./daemon-cmd");
+/**
+ * Watch the daemon loop that runs alongside the work.
+ *
+ * `daemon.run()` is started and not awaited until the end, so a throw inside it
+ * is a rejection nobody is holding — which Node turns into a process-level
+ * unhandled rejection and, since Node 15, into a dead process. The stream exists
+ * only to report on the run; it must never be able to end it. So the rejection
+ * is caught here, in the same tick it is created, the stream is marked dead, and
+ * the failure is said out loud once instead of the phone simply going quiet.
+ *
+ * A loop that finishes normally is not dead: `alive` means "did not fail", which
+ * is what a caller wants to know after a deliberate stop.
+ */
+function superviseStream(loop, 
+/** What is being streamed, for the message. "this run", not "this". */
+what, log) {
+    let failed = false;
+    const settled = loop.then(() => undefined, (e) => {
+        failed = true;
+        log(`sync    : the stream failed (${e.message}) — this ${what} is no longer streaming.`);
+        log('          It carries on locally and the ledger on disk stays complete.');
+    });
+    return { alive: () => !failed, settled };
+}
+/**
+ * Connect to the server, when this machine is paired.
+ *
+ * Returns null for an unpaired machine, which is a normal state rather than a
+ * failure — looply runs perfectly well with no server, and the app is something
+ * you add. Any error here degrades to the same null: local work must never fail
+ * because a relay is unreachable.
+ */
+async function attachSync(cwd, config, log, 
+/** What is being attached, for the messages. "this run stays local", not "this". */
+what = 'run') {
+    const store = new machine_store_1.MachineStore((0, machine_store_1.machineFilePath)());
+    let identity;
+    try {
+        identity = store.load();
+    }
+    catch (e) {
+        log(`sync    : ${e.message}`);
+        return null;
+    }
+    if (!identity) {
+        log(`sync    : not paired — this ${what} stays local. \`looply pair\` to watch it from your phone.`);
+        return null;
+    }
+    const client = new server_client_1.ServerClient({ baseUrl: identity.serverUrl }).withToken(identity.token);
+    let projectId;
+    try {
+        projectId = await (0, daemon_cmd_1.resolveProjectId)(store, client, identity.machineId, cwd, config.project.name);
+    }
+    catch (e) {
+        log(`sync    : could not reach ${identity.serverUrl} (${e.message}) — running local only.`);
+        return null;
+    }
+    const daemon = new daemon_1.Daemon({
+        client,
+        machineId: identity.machineId,
+        projectId,
+        cliVersion: daemon_cmd_1.CLI_VERSION,
+        log,
+        sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+        now: () => Date.now(),
+    });
+    // Supervised, not fire-and-forget: the loop runs alongside the work and is
+    // stopped below. Most of its failures are handled inside the daemon, but not
+    // all of them are, and the ones that are not used to take the run with them.
+    const stream = superviseStream(daemon.run(), what, log);
+    log(`sync    : streaming to ${identity.serverUrl} as ${projectId}`);
+    return {
+        daemon,
+        client,
+        projectId,
+        alive: () => stream.alive(),
+        stop: async () => {
+            daemon.stop();
+            // Never rethrows: stop() is called from a `finally`, where a throw would
+            // replace the run's result with the streamer's failure.
+            await stream.settled;
+        },
+    };
+}
+//# sourceMappingURL=sync.js.map

package/dist/sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.js","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"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"}