looply-cli 0.0.0-stage → 0.2.0

package/dist/observation-inventory.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBSERVATIONS_STORE = void 0;
+exports.inventoryObservations = inventoryObservations;
+exports.observationFacts = observationFacts;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const core_1 = require("@looply/core");
+const session_observation_store_1 = require("./session-observation-store");
+/**
+ * OBSERVATIONS, AS ARTIFACTS THE RETENTION POLICY CAN SEE.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE ROOT EXISTED AND NOTHING WAS POINTED AT IT.
+ * `session-observation-store.ts` says so itself: *"its own root, one file per
+ * watch, and a root a retention policy can be pointed at — this product already
+ * decided how disposable artifacts are removed (D5), and an observation is
+ * exactly that kind of artifact."* `looply evidence` inventoried two folders and
+ * listed `observations/` under *uninventoried*. That is honest reporting of an
+ * unbounded store, and `OWNER_CHARTER.md` §5 D5 asks for more than honesty:
+ * *"Also cover the named compile/tool/rejected stores or report exact
+ * unclassified entries; do not claim complete retention from an inventory of
+ * only two folders."*
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * ⚠️ THE UNIT IS ONE WATCH, NOT ONE SESSION. A session directory holds a file
+ * per watch, taken at different times and ending in different ways — a
+ * directory-level decision would either keep a year-old complete account
+ * because a recent watch sits beside it, or expire a record that is still
+ * running. So the artifact id is `<sessionId>/<file>`, which is also the path
+ * under the store, so `pathOf` resolves without a second convention.
+ *
+ * 🔴 AND NOTHING UNREADABLE BECOMES AN ARTIFACT. *"Missing/unreadable/unknown
+ * is never deletion permission."* A file that cannot be parsed, a link, a
+ * `coversFrom` that is not a time — each is NAMED here and left out of the
+ * plan, which is the only way a policy can be wrong about it in the safe
+ * direction.
+ */
+exports.OBSERVATIONS_STORE = 'observations';
+/** `<sessionId>/<file>.json`, and nothing that could leave the store. */
+const ID = /^[^\\/.][^\\/]*\/[^\\/.][^\\/]*\.json$/;
+function sizeOf(path) {
+    try {
+        const st = (0, node_fs_1.statSync)(path);
+        return st.isFile() ? st.size : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Every watch on file, classified.
+ *
+ * ⚠️ `createdAtMs` IS `coversFrom`, NOT THE FILE'S MTIME. The record is written
+ * twice — once at attach and once at the close — so its mtime is the moment the
+ * watch ENDED, and a long watch would look hours younger than it is. What the
+ * age window is about is when the observation began.
+ */
+function inventoryObservations(stateDir) {
+    const root = (0, session_observation_store_1.observationPaths)(stateDir, '').root;
+    let sessions;
+    try {
+        sessions = (0, node_fs_1.readdirSync)(root, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        // No root at all: nothing has ever been watched here. Not an error, and
+        // not an unreadable entry either.
+        return { artifacts: [], unreadable: [] };
+    }
+    const artifacts = [];
+    const unreadable = [];
+    for (const sessionId of sessions) {
+        const paths = (0, session_observation_store_1.observationPaths)(stateDir, sessionId);
+        const read = (0, session_observation_store_1.readObservations)(paths);
+        for (const why of read.unreadable)
+            unreadable.push(`${sessionId}/${why}`);
+        for (const stored of read.observations) {
+            const name = stored.file.slice(paths.session.length + 1);
+            const id = `${sessionId}/${name}`;
+            const createdAtMs = Date.parse(stored.record.coversFrom);
+            if (!Number.isFinite(createdAtMs)) {
+                unreadable.push(`${id} has no readable coversFrom, so its age could not be established`);
+                continue;
+            }
+            const bytes = sizeOf(stored.file);
+            if (bytes === null) {
+                unreadable.push(`${id} could not be sized`);
+                continue;
+            }
+            const d = (0, core_1.observationDisposition)(stored.record);
+            artifacts.push({
+                id,
+                store: exports.OBSERVATIONS_STORE,
+                bytes,
+                createdAtMs,
+                class: d.class,
+                // 🔴 Asserted only for files under THIS project's own observations
+                // root, written by this product's own watcher. Nothing outside it is
+                // claimed — an unowned artifact is untouchable, and the value of that
+                // rule is that ownership is not handed out loosely.
+                owned: true,
+                pinned: d.pinned,
+            });
+        }
+    }
+    return { artifacts, unreadable };
+}
+/**
+ * The re-check `--apply` makes immediately before removing one.
+ *
+ * 🔴 D5: *"check identity, ownership, current policy eligibility, pins,
+ * references and path boundaries AGAIN before removal."* The plan was made from
+ * a walk that may be minutes old; a watch that has since been re-opened, or a
+ * record replaced by something that is not one, must not be removed on the
+ * strength of what was true then.
+ *
+ * `null` means "this is not an observation this inventory owns" — an id that
+ * could leave the store, a session with no such file, a file that no longer
+ * parses. The caller must treat that as a refusal, never as permission.
+ */
+function observationFacts(stateDir, id) {
+    if (!ID.test(id))
+        return null;
+    const cut = id.indexOf('/');
+    const sessionId = id.slice(0, cut);
+    const name = id.slice(cut + 1);
+    const paths = (0, session_observation_store_1.observationPaths)(stateDir, sessionId);
+    // The whole path, not a suffix: `a.json` is a suffix of `extra.json`.
+    const want = (0, node_path_1.join)(paths.session, name);
+    const hit = (0, session_observation_store_1.readObservations)(paths).observations.find((o) => o.file === want);
+    if (hit === undefined)
+        return null;
+    const d = (0, core_1.observationDisposition)(hit.record);
+    return { owned: true, pinned: d.pinned, class: d.class };
+}
+//# sourceMappingURL=observation-inventory.js.map

package/dist/observation-inventory.js.map

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

package/dist/owned-children.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The child processes this run started, and is therefore responsible for.
+ *
+ * A run spawns a coding agent per round, with a generous timeout — 45 minutes
+ * for the implementer. If the runner goes away during one, nothing stops the
+ * agent: measured on this machine, hard-killing the runner leaves the leaf
+ * process alive and still writing files into the repository, with no parent to
+ * notice. The next run then finds a tree being edited by nobody.
+ *
+ * This is the in-process half of closing that, and it is deliberately only that
+ * half. Killing an orphan *after* the fact would mean proving the pid we are
+ * about to kill is still the process we spawned, and pids are reused. The one
+ * portable identity a parent has is the handle it is already holding, so this
+ * keeps handles and uses them while the process that owns them is alive.
+ *
+ * What that covers: an ordinary exit, a thrown error, a Ctrl-C, a `looply stop`.
+ * What it cannot: SIGKILL, a power cut, or a taskkill /F on the runner. Those
+ * leave an orphan, and no amount of bookkeeping in this process changes that —
+ * the honest response is to report it during recovery rather than to claim a
+ * guarantee that does not exist.
+ */
+export interface OwnedChild {
+    /** For the message. The kill goes through the handle, never through this. */
+    pid: number | undefined;
+    /** What this child was for, so a report can name it. */
+    label: string;
+    kill(): void;
+}
+export declare class OwnedChildren {
+    private readonly children;
+    /** Take ownership. The returned function gives it back when the child ends. */
+    adopt(child: OwnedChild): () => void;
+    size(): number;
+    /** What is still running, for a message rather than for a decision. */
+    describe(): string[];
+    /**
+     * Stop everything this process started.
+     *
+     * Every child is attempted even if one throws: a registry that gives up on
+     * the first failure would leave the rest running, which is the situation it
+     * exists to prevent. Returns how many it tried, so a caller can say so.
+     */
+    killAll(): number;
+}
+//# sourceMappingURL=owned-children.d.ts.map

package/dist/owned-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owned-children.d.ts","sourceRoot":"","sources":["../src/owned-children.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAC7E,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;CACd;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAElD,+EAA+E;IAC/E,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,IAAI;IAOpC,IAAI,IAAI,MAAM;IAId,uEAAuE;IACvE,QAAQ,IAAI,MAAM,EAAE;IAIpB;;;;;;OAMG;IACH,OAAO,IAAI,MAAM;CAalB"}

package/dist/owned-children.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * The child processes this run started, and is therefore responsible for.
+ *
+ * A run spawns a coding agent per round, with a generous timeout — 45 minutes
+ * for the implementer. If the runner goes away during one, nothing stops the
+ * agent: measured on this machine, hard-killing the runner leaves the leaf
+ * process alive and still writing files into the repository, with no parent to
+ * notice. The next run then finds a tree being edited by nobody.
+ *
+ * This is the in-process half of closing that, and it is deliberately only that
+ * half. Killing an orphan *after* the fact would mean proving the pid we are
+ * about to kill is still the process we spawned, and pids are reused. The one
+ * portable identity a parent has is the handle it is already holding, so this
+ * keeps handles and uses them while the process that owns them is alive.
+ *
+ * What that covers: an ordinary exit, a thrown error, a Ctrl-C, a `looply stop`.
+ * What it cannot: SIGKILL, a power cut, or a taskkill /F on the runner. Those
+ * leave an orphan, and no amount of bookkeeping in this process changes that —
+ * the honest response is to report it during recovery rather than to claim a
+ * guarantee that does not exist.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnedChildren = void 0;
+class OwnedChildren {
+    children = new Set();
+    /** Take ownership. The returned function gives it back when the child ends. */
+    adopt(child) {
+        this.children.add(child);
+        return () => {
+            this.children.delete(child);
+        };
+    }
+    size() {
+        return this.children.size;
+    }
+    /** What is still running, for a message rather than for a decision. */
+    describe() {
+        return [...this.children].map((c) => `${c.label}${c.pid === undefined ? '' : ` (pid ${c.pid})`}`);
+    }
+    /**
+     * Stop everything this process started.
+     *
+     * Every child is attempted even if one throws: a registry that gives up on
+     * the first failure would leave the rest running, which is the situation it
+     * exists to prevent. Returns how many it tried, so a caller can say so.
+     */
+    killAll() {
+        const all = [...this.children];
+        this.children.clear();
+        for (const child of all) {
+            try {
+                child.kill();
+            }
+            catch {
+                // Already gone is the goal state; anything else is not worth failing a
+                // shutdown over.
+            }
+        }
+        return all.length;
+    }
+}
+exports.OwnedChildren = OwnedChildren;
+//# sourceMappingURL=owned-children.js.map

package/dist/owned-children.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"owned-children.js","sourceRoot":"","sources":["../src/owned-children.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAUH,MAAa,aAAa;IACP,QAAQ,GAAG,IAAI,GAAG,EAAc,CAAC;IAElD,+EAA+E;IAC/E,KAAK,CAAC,KAAiB;QACrB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACzB,OAAO,GAAG,EAAE;YACV,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC,CAAC;IACJ,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC5B,CAAC;IAED,uEAAuE;IACvE,QAAQ;QACN,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC;IACpG,CAAC;IAED;;;;;;OAMG;IACH,OAAO;QACL,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,KAAK,MAAM,KAAK,IAAI,GAAG,EAAE,CAAC;YACxB,IAAI,CAAC;gBACH,KAAK,CAAC,IAAI,EAAE,CAAC;YACf,CAAC;YAAC,MAAM,CAAC;gBACP,uEAAuE;gBACvE,iBAAiB;YACnB,CAAC;QACH,CAAC;QACD,OAAO,GAAG,CAAC,MAAM,CAAC;IACpB,CAAC;CACF;AAxCD,sCAwCC"}

package/dist/packet-for-goal.d.ts

@@ -0,0 +1,19 @@
+import { type Goal, type PacketSource, type TaskPacket } from '@looply/core';
+/**
+ * THE PACKET FOR A RUN'S GOAL — the sources read, the packet assembled.
+ *
+ * One read per linked source, through whatever `read` the composition root
+ * hands over (the server client in a run; a service or a fake in a test). A
+ * read that fails puts that source's links under `missing`: a source the
+ * server cannot answer right now is a line in the packet, never a reason to
+ * refuse a run and never a reason to invent text. Assembly itself is pure —
+ * `taskPacketFor` in core — so what the compiler is told is a function of
+ * the records, not of this file.
+ */
+export declare function packetForGoal(goal: Pick<Goal, 'id' | 'version' | 'text' | 'requirements'>, read: (sourceId: string) => Promise<PacketSource>, 
+/** The programme's other goals, so the packet can name what they own (F19). Absent: nothing named. */
+siblings?: readonly Pick<Goal, 'id' | 'state' | 'requirements'>[]): Promise<{
+    packet: TaskPacket;
+    unreadable: string[];
+}>;
+//# sourceMappingURL=packet-for-goal.d.ts.map

package/dist/packet-for-goal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet-for-goal.d.ts","sourceRoot":"","sources":["../src/packet-for-goal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,IAAI,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAE5F;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC,EAC5D,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC;AACjD,sGAAsG;AACtG,QAAQ,GAAE,SAAS,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,GAAG,cAAc,CAAC,EAAO,GACpE,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAYvD"}

package/dist/packet-for-goal.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packetForGoal = packetForGoal;
+const core_1 = require("@looply/core");
+/**
+ * THE PACKET FOR A RUN'S GOAL — the sources read, the packet assembled.
+ *
+ * One read per linked source, through whatever `read` the composition root
+ * hands over (the server client in a run; a service or a fake in a test). A
+ * read that fails puts that source's links under `missing`: a source the
+ * server cannot answer right now is a line in the packet, never a reason to
+ * refuse a run and never a reason to invent text. Assembly itself is pure —
+ * `taskPacketFor` in core — so what the compiler is told is a function of
+ * the records, not of this file.
+ */
+async function packetForGoal(goal, read, 
+/** The programme's other goals, so the packet can name what they own (F19). Absent: nothing named. */
+siblings = []) {
+    const ids = [...new Set((goal.requirements ?? []).map((l) => l.sourceId))].sort();
+    const sources = new Map();
+    const unreadable = [];
+    for (const id of ids) {
+        try {
+            sources.set(id, await read(id));
+        }
+        catch {
+            unreadable.push(id);
+        }
+    }
+    return { packet: (0, core_1.taskPacketFor)(goal, sources, siblings), unreadable };
+}
+//# sourceMappingURL=packet-for-goal.js.map

package/dist/packet-for-goal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet-for-goal.js","sourceRoot":"","sources":["../src/packet-for-goal.ts"],"names":[],"mappings":";;AAaA,sCAiBC;AA9BD,uCAA4F;AAE5F;;;;;;;;;;GAUG;AACI,KAAK,UAAU,aAAa,CACjC,IAA4D,EAC5D,IAAiD;AACjD,sGAAsG;AACtG,WAAmE,EAAE;IAErE,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAClF,MAAM,OAAO,GAAG,IAAI,GAAG,EAAwB,CAAC;IAChD,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC;YACH,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACP,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,IAAA,oBAAa,EAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAC;AACxE,CAAC"}

package/dist/pair-cmd.d.ts

@@ -0,0 +1,85 @@
+import type { MachineStore } from './machine-store';
+import { ServerClient } from './server-client';
+/**
+ * `looply pair`.
+ *
+ * The machine asks the server for a code, shows it, and waits for a phone to
+ * claim it. The code rotates every thirty seconds, so this loop re-issues rather
+ * than displaying a dead one — a code on screen that expired ninety seconds ago
+ * is worse than no code, because the person typing it has no way to tell.
+ */
+export interface PairOptions {
+    serverUrl: string;
+    machineName: string;
+    store: MachineStore;
+    client: ServerClient;
+    /** Overall budget before giving up. */
+    timeoutMs?: number;
+    /** How often to ask whether a phone has claimed the current code. */
+    pollMs?: number;
+    /** Re-issue the code slightly before the server expires it. */
+    reissueMs?: number;
+    log: (line: string) => void;
+    render: (info: {
+        pairCode: string;
+        qrPayload: string;
+        expiresAt: string;
+    }, secondsLeft?: number) => void;
+    sleep(ms: number): Promise<void>;
+    now(): number;
+}
+export interface PairResult {
+    machineId: string;
+    paired: boolean;
+    reason?: string;
+}
+export declare function runPair(opts: PairOptions): Promise<PairResult>;
+/**
+ * The code, big enough to read across a desk.
+ *
+ * Drawn with block characters rather than printed small, because this is a
+ * number somebody reads off one screen and types into another — often at arm's
+ * length, sometimes read aloud to someone else holding the phone.
+ *
+ * Grouped three and three: that is how a six-digit code is spoken, and a solid
+ * block of six is measurably harder to type without losing your place.
+ */
+export declare function renderPairCode(info: {
+    pairCode: string;
+    qrPayload: string;
+    expiresAt: string;
+}, secondsLeft?: number): string;
+/**
+ * The same code as a square.
+ *
+ * The server has always sent `qrPayload` and nothing ever drew it, so the
+ * camera path existed in the design and in the API and nowhere a person could
+ * reach. Six digits typed at arm's length is still the primitive — this is the
+ * faster path when the phone is already in your hand.
+ */
+export declare function qrLines(payload: string): string[];
+export declare function bigDigits(text: string): string[];
+/**
+ * The reissue interval in words, DERIVED from the interval itself.
+ *
+ * 🔴 THIS SENTENCE IS PRINTED TO EVERY USER ON THE FIRST DRAW OF EVERY CODE, and
+ * it said "every 25 seconds" while `DEFAULT_REISSUE_MS` was 150_000 — six times
+ * wrong, telling somebody their code had already rotated four times when it had
+ * not moved. 25s was true against the old 30s TTL; both numbers moved and the
+ * copy did not.
+ *
+ * ⚠️ IT IS COMPUTED, NOT WRITTEN DOWN. A second hardcoded number is a second
+ * thing to forget: the only way this can disagree with the behaviour again is if
+ * somebody changes what the words mean, not what the interval is.
+ */
+export declare function reissueWording(ms?: number): string;
+/**
+ * How long this code has left.
+ *
+ * A static "it changes every N seconds" cannot tell you whether the code in
+ * front of you is nine seconds old or twenty-nine — and typing a six-digit
+ * number takes long enough for that to be the difference between pairing and
+ * "the code is invalid no matter what I do".
+ */
+export declare function freshness(secondsLeft?: number): string;
+//# sourceMappingURL=pair-cmd.d.ts.map

package/dist/pair-cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pair-cmd.d.ts","sourceRoot":"","sources":["../src/pair-cmd.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAe,MAAM,iBAAiB,CAAC;AAI5D;;;;;;;GAOG;AAEH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,MAAM,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,WAAW,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzG,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,GAAG,IAAI,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAcD,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CA2DpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CA6B7H;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CASjD;AAsBD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAUhD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAAE,GAAE,MAA2B,GAAG,MAAM,CAKtE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtD"}

package/dist/pair-cmd.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPair = runPair;
+exports.renderPairCode = renderPairCode;
+exports.qrLines = qrLines;
+exports.bigDigits = bigDigits;
+exports.reissueWording = reissueWording;
+exports.freshness = freshness;
+const server_client_1 = require("./server-client");
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const ui_1 = require("./ui");
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_POLL_MS = 2000;
+/**
+ * Reissue comfortably INSIDE the server TTL (180s), not at its edge.
+ *
+ * At 25s against a 30s TTL the two were almost the same number, so the code on
+ * screen was routinely dead-or-dying while being read: a claim 8 seconds after
+ * an issue could still fail because the digits belonged to the previous cycle.
+ * A wide margin means the code you are looking at is the code that works.
+ */
+const DEFAULT_REISSUE_MS = 150_000;
+async function runPair(opts) {
+    const deadline = opts.now() + (opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const pollMs = opts.pollMs ?? DEFAULT_POLL_MS;
+    const reissueMs = opts.reissueMs ?? DEFAULT_REISSUE_MS;
+    // Re-pairing is allowed but never silent: the existing token stops being the
+    // one the server knows, and a person who did not mean to do that should hear
+    // about it here rather than when the app goes quiet.
+    const existing = opts.store.load();
+    if (existing) {
+        opts.log(`note    : this machine is already paired as ${existing.machineId}.`);
+        opts.log('          pairing again replaces that identity.');
+    }
+    let machineId = '';
+    while (opts.now() < deadline) {
+        const started = await opts.client.pairStart(opts.machineName);
+        machineId = started.machineId;
+        opts.render(started);
+        const codeDies = opts.now() + reissueMs;
+        while (opts.now() < codeDies && opts.now() < deadline) {
+            await opts.sleep(pollMs);
+            // Redrawn every poll so the countdown moves. Without it the block is
+            // static for a whole reissue interval and there is no way to tell a live code from
+            // one that died while you were looking at it.
+            opts.render(started, Math.max(0, Math.ceil((codeDies - opts.now()) / 1000)));
+            let polled;
+            try {
+                polled = await opts.client.pairPoll(machineId);
+            }
+            catch (e) {
+                // A blip while waiting is not a failure to pair; the code is still live
+                // on the server and the next poll will find it.
+                if (e instanceof server_client_1.ServerError && e.isOffline)
+                    continue;
+                throw e;
+            }
+            if (polled.status === 'claimed' && polled.machineToken) {
+                opts.store.save({
+                    machineId,
+                    token: polled.machineToken,
+                    serverUrl: opts.serverUrl,
+                    pairedAt: new Date(opts.now()).toISOString(),
+                });
+                opts.log('');
+                opts.log(`paired  : ${machineId}`);
+                opts.log('          token stored in ~/.looply/machine.json — outside this repo, so a');
+                opts.log('          discarded round cannot delete it.');
+                return { machineId, paired: true };
+            }
+        }
+        // No line here announcing the reissue: the block is redrawn in place, so
+        // an extra line would shift the cursor maths and leave a half-erased box
+        // above the live one. The code changing IS the announcement.
+    }
+    return { machineId, paired: false, reason: 'nobody claimed the code in time' };
+}
+/**
+ * The code, big enough to read across a desk.
+ *
+ * Drawn with block characters rather than printed small, because this is a
+ * number somebody reads off one screen and types into another — often at arm's
+ * length, sometimes read aloud to someone else holding the phone.
+ *
+ * Grouped three and three: that is how a six-digit code is spoken, and a solid
+ * block of six is measurably harder to type without losing your place.
+ */
+function renderPairCode(info, secondsLeft) {
+    const code = info.pairCode;
+    const grouped = `${code.slice(0, 3)}  ${code.slice(3)}`;
+    // The box holds the number and nothing else. Instructions inside it compete
+    // with the thing being read, and this is read at a glance from across a desk —
+    // whatever shares the frame steals from that.
+    return [
+        '',
+        (0, ui_1.box)(
+        // Indented so the digits sit inside the frame rather than against it; the
+        // box sizes to its widest line, so the padding lands on both sides.
+        ['', '', ...bigDigits(grouped).map((l) => `   ${(0, ui_1.volt)(l)}   `), '', ''], { title: 'pairing code', tone: ui_1.volt }),
+        '',
+        `  ${(0, ui_1.grey)('type this into looply on your phone, or scan the square below')}`,
+        `  ${(0, ui_1.dim)(freshness(secondsLeft))}`,
+        '',
+        ...qrLines(info.qrPayload).map((l) => `  ${l}`),
+        '',
+        // Said here because this is the screen an agent is most likely to be
+        // driving. A pairing code only works if a HUMAN can see it: run it inside
+        // the session so the output lands in front of the person, not in some
+        // other terminal they are not looking at.
+        `  ${(0, ui_1.dim)('driving this from an agent? keep it in the session — nobody can read')}`,
+        `  ${(0, ui_1.dim)('a code that printed into a window they cannot see.')}`,
+        '',
+    ].join('\n');
+}
+/**
+ * The same code as a square.
+ *
+ * The server has always sent `qrPayload` and nothing ever drew it, so the
+ * camera path existed in the design and in the API and nowhere a person could
+ * reach. Six digits typed at arm's length is still the primitive — this is the
+ * faster path when the phone is already in your hand.
+ */
+function qrLines(payload) {
+    let out = '';
+    // Low correction: the payload is short and the square is read off a screen a
+    // foot away, not a poster. Smaller is easier to fit in a terminal.
+    qrcode_terminal_1.default.setErrorLevel('L');
+    qrcode_terminal_1.default.generate(payload, { small: true }, (code) => {
+        out = code;
+    });
+    return out.replace(/\s+$/, '').split('\n');
+}
+/**
+ * Seven-segment-ish digits from block characters.
+ *
+ * Three rows rather than five: tall enough to read across a room, short enough
+ * that the whole pairing screen still fits above the fold in a small terminal.
+ */
+const GLYPHS = {
+    '0': ['█▀█', '█ █', '█▄█'],
+    '1': [' ▀█', '  █', '  █'],
+    '2': ['▀▀█', '▄▀ ', '█▄▄'],
+    '3': ['▀▀█', ' ▀█', '▄▄█'],
+    '4': ['█ █', '▀▀█', '  █'],
+    '5': ['█▀▀', '▀▀█', '▄▄█'],
+    '6': ['█▀▀', '█▀█', '█▄█'],
+    '7': ['▀▀█', '  █', '  █'],
+    '8': ['█▀█', '█▀█', '█▄█'],
+    '9': ['█▀█', '▀▀█', '▄▄█'],
+    ' ': ['  ', '  ', '  '],
+};
+function bigDigits(text) {
+    const rows = ['', '', ''];
+    for (const ch of text) {
+        const glyph = GLYPHS[ch];
+        // An unknown character falls back to itself rather than vanishing — a code
+        // that renders wrong is still typeable, a code that renders as nothing is not.
+        const cell = glyph ?? [ch, ch, ch];
+        for (let i = 0; i < 3; i++)
+            rows[i] += `${cell[i]} `;
+    }
+    return rows.map((r) => r.trimEnd());
+}
+/**
+ * The reissue interval in words, DERIVED from the interval itself.
+ *
+ * 🔴 THIS SENTENCE IS PRINTED TO EVERY USER ON THE FIRST DRAW OF EVERY CODE, and
+ * it said "every 25 seconds" while `DEFAULT_REISSUE_MS` was 150_000 — six times
+ * wrong, telling somebody their code had already rotated four times when it had
+ * not moved. 25s was true against the old 30s TTL; both numbers moved and the
+ * copy did not.
+ *
+ * ⚠️ IT IS COMPUTED, NOT WRITTEN DOWN. A second hardcoded number is a second
+ * thing to forget: the only way this can disagree with the behaviour again is if
+ * somebody changes what the words mean, not what the interval is.
+ */
+function reissueWording(ms = DEFAULT_REISSUE_MS) {
+    const s = Math.round(ms / 1000);
+    if (s < 120)
+        return `${s} seconds`;
+    const mins = s / 60;
+    return `${Number.isInteger(mins) ? mins : mins.toFixed(1)} minutes`;
+}
+/**
+ * How long this code has left.
+ *
+ * A static "it changes every N seconds" cannot tell you whether the code in
+ * front of you is nine seconds old or twenty-nine — and typing a six-digit
+ * number takes long enough for that to be the difference between pairing and
+ * "the code is invalid no matter what I do".
+ */
+function freshness(secondsLeft) {
+    if (secondsLeft === undefined) {
+        return `a new code appears every ${reissueWording()} — leave this running`;
+    }
+    if (secondsLeft <= 0)
+        return 'expired — a new one is coming';
+    if (secondsLeft <= 6)
+        return `${secondsLeft}s left — wait for the next one rather than rushing this`;
+    return `${secondsLeft}s left`;
+}
+//# sourceMappingURL=pair-cmd.js.map

package/dist/pair-cmd.js.map

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