lattris 0.1.4 → 0.2.1

package/dist/store/session-lock.js

@@ -0,0 +1,169 @@
+import { randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { sessionPath } from "./session-home.js";
+export const RENEWAL_TIMEOUT_MS = 10_000;
+const STALE_AFTER_MS = 3 * RENEWAL_TIMEOUT_MS;
+export const WAIT_AT_MOST_MS = STALE_AFTER_MS + RENEWAL_TIMEOUT_MS;
+const POLL_EVERY_MS = 50;
+const SAY_WAITING_AFTER_MS = 2_000;
+const NONCE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+export class SessionLockHeld extends Error {
+    path;
+    constructor(path) {
+        super('the session lock is held');
+        this.path = path;
+    }
+}
+const errorCode = (e) => e?.code;
+const removeQuietly = (store, path) => {
+    try {
+        store.files.unlinkSync(path);
+    }
+    catch { }
+};
+const removeLock = (store, path) => {
+    try {
+        store.files.unlinkSync(path);
+        return true;
+    }
+    catch {
+        try {
+            store.files.rmdirSync(path);
+            return true;
+        }
+        catch (e) {
+            return errorCode(e) === 'ENOENT';
+        }
+    }
+};
+const parseHolder = (text) => {
+    try {
+        const held = JSON.parse(text);
+        const whole = typeof held?.nonce === 'string' &&
+            NONCE.test(held.nonce) &&
+            Number.isSafeInteger(held.pid) &&
+            Number(held.pid) > 0 &&
+            Number.isFinite(held.since);
+        return whole ? held : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const readHolder = (store, path) => {
+    try {
+        return parseHolder(store.files.readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+};
+const isUnreadable = (store, path) => {
+    try {
+        return parseHolder(store.files.readFileSync(path, 'utf8')) === undefined;
+    }
+    catch (e) {
+        return errorCode(e) !== 'ENOENT';
+    }
+};
+const holderNow = (store) => ({
+    pid: store.pid,
+    since: store.now(),
+    nonce: randomUUID()
+});
+const isStale = (store, held) => store.now() - held.since > STALE_AFTER_MS;
+const isAbandoned = (store, held) => isStale(store, held) || held.since - store.now() > STALE_AFTER_MS || !store.alive(held.pid);
+const createWhole = (store, path, holder) => {
+    const draft = `${path}.${holder.nonce}.new`;
+    try {
+        store.files.writeFileSync(draft, JSON.stringify(holder), { mode: 0o600, flag: 'wx' });
+        store.files.linkSync(draft, path);
+        return true;
+    }
+    catch (e) {
+        if (errorCode(e) === 'EEXIST')
+            return false;
+        throw e;
+    }
+    finally {
+        removeQuietly(store, draft);
+    }
+};
+const takeOver = (store, path, claim, still) => {
+    if (!createWhole(store, claim, holderNow(store))) {
+        const taker = readHolder(store, claim);
+        if (taker && isAbandoned(store, taker))
+            removeQuietly(store, claim);
+        return false;
+    }
+    try {
+        return still() && removeLock(store, path);
+    }
+    finally {
+        removeQuietly(store, claim);
+    }
+};
+const takeOverAbandoned = (store, path) => {
+    const held = readHolder(store, path);
+    if (!held) {
+        return (isUnreadable(store, path) &&
+            takeOver(store, path, `${path}.unreadable`, () => isUnreadable(store, path)));
+    }
+    return (isAbandoned(store, held) &&
+        takeOver(store, path, `${path}.${held.nonce}`, () => readHolder(store, path)?.nonce === held.nonce));
+};
+const acquire = async (store, path, sayWaiting) => {
+    const startedAt = store.now();
+    let said = false;
+    for (;;) {
+        const mine = holderNow(store);
+        if (createWhole(store, path, mine))
+            return mine;
+        if (takeOverAbandoned(store, path))
+            continue;
+        const waited = store.now() - startedAt;
+        if (waited >= WAIT_AT_MOST_MS)
+            throw new SessionLockHeld(path);
+        if (waited > SAY_WAITING_AFTER_MS && !said) {
+            said = true;
+            sayWaiting();
+        }
+        await store.wait(POLL_EVERY_MS);
+    }
+};
+const release = (store, path, mine) => {
+    if (readHolder(store, path)?.nonce === mine.nonce)
+        removeQuietly(store, path);
+};
+const lockPath = (store) => `${sessionPath(store)}.lock`;
+export const withSessionLock = async (store, work, sayWaiting) => {
+    const path = lockPath(store);
+    const mine = await acquire(store, path, sayWaiting);
+    try {
+        return await work();
+    }
+    finally {
+        release(store, path, mine);
+    }
+};
+export const clearLeftovers = (store) => {
+    const session = sessionPath(store);
+    const lock = lockPath(store);
+    const dir = dirname(session);
+    let names;
+    try {
+        names = store.files.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const path = join(dir, name);
+        const leftover = path === lock ||
+            path.startsWith(`${lock}.`) ||
+            (path.startsWith(`${session}.`) && path.endsWith('.new'));
+        if (leftover)
+            removeLock(store, path);
+    }
+};
+//# sourceMappingURL=session-lock.js.map

package/dist/store/session.js

@@ -0,0 +1,70 @@
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { resolveSessionHome, sessionDir, sessionPath } from "./session-home.js";
+import { clearLeftovers } from "./session-lock.js";
+export const sessionIdentityWarning = (store, asFlag) => {
+    const home = resolveSessionHome(store);
+    if (!asFlag)
+        return undefined;
+    const session = loadSession(store);
+    if (!session)
+        return undefined;
+    if (!session.personId || !session.handle) {
+        return (`Warning: ${home.dir}/session.json has no recorded identity — ` +
+            `run \`lattris login\` to populate it.\n`);
+    }
+    const dirName = home.dir.split('/').filter(Boolean).at(-1) ?? '';
+    if (session.email &&
+        dirName.includes('@') &&
+        dirName.toLowerCase() !== session.email.toLowerCase()) {
+        return (`Warning: ${home.dir}/session.json records ${session.email}, but the directory is ` +
+            `keyed to ${dirName} — fix it by logging in as that identity again: \`lattris login\`.\n`);
+    }
+    return undefined;
+};
+export const notLoggedInWords = (machine) => {
+    const home = resolveSessionHome(machine);
+    if (home.bindingFile && !machine.files.existsSync(join(home.dir, 'session.json'))) {
+        return (`Bound to ${home.dir} (via ${home.bindingFile}) — no session there. ` +
+            `Run lattris login from this directory, or lattris use --clear.`);
+    }
+    return 'Not logged in.';
+};
+export const saveSession = (store, s) => {
+    const dir = sessionDir(store);
+    store.files.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    store.files.chmodSync(dir, 0o700);
+    const file = sessionPath(store);
+    const draft = `${file}.${randomUUID()}.new`;
+    try {
+        store.files.writeFileSync(draft, JSON.stringify(s, null, 2), { mode: 0o600 });
+        store.files.chmodSync(draft, 0o600);
+        store.files.renameSync(draft, file);
+    }
+    catch (e) {
+        try {
+            store.files.unlinkSync(draft);
+        }
+        catch { }
+        throw e;
+    }
+};
+export const loadSession = (store) => {
+    try {
+        return JSON.parse(store.files.readFileSync(sessionPath(store), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+};
+export const clearSession = (store) => {
+    try {
+        store.files.rmSync(sessionPath(store));
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    clearLeftovers(store);
+};
+//# sourceMappingURL=session.js.map

package/dist/store/write-identity.js

@@ -0,0 +1,153 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { EXIT, refusal } from "./exit.js";
+import { sessionDir } from "./session-home.js";
+const SESSION_ID_MAX = 128;
+const psField = (machine, pid, field) => {
+    const out = machine.run('ps', ['-o', `${field}=`, '-p', String(pid)]);
+    if (out.status !== 0)
+        return undefined;
+    const value = out.stdout.trim();
+    return value.length > 0 ? value : undefined;
+};
+const terminalKeyFrom = (input) => {
+    const tty = input.tty?.trim();
+    if (!tty || tty === '??' || tty === '-')
+        return undefined;
+    const device = tty.replace(/^\/dev\//, '');
+    const leader = input.leader();
+    if (!leader)
+        return undefined;
+    const component = (raw) => raw.replace(/[^A-Za-z0-9:]+/g, '-');
+    const shell = `leader-${leader.pid}-${component(leader.started)}`;
+    const name = `tty-${device.replace(/\//g, '_')}`;
+    for (const line of input.who.split('\n')) {
+        const columns = line.trim().split(/\s+/);
+        if (columns[1] === device) {
+            const moment = columns
+                .slice(2)
+                .filter((c) => !c.startsWith('('))
+                .join(' ');
+            if (moment.length > 0)
+                return `${name}-login-${component(moment)}-${shell}`;
+        }
+    }
+    return `${name}-${shell}`;
+};
+const terminalLeader = (machine, device) => {
+    let pid = machine.pid;
+    for (let hops = 0; hops < 64; hops += 1) {
+        const parent = Number(psField(machine, pid, 'ppid'));
+        if (!Number.isFinite(parent) || parent <= 1)
+            break;
+        const parentTty = psField(machine, parent, 'tty');
+        if (parentTty === undefined || parentTty.replace(/^\/dev\//, '') !== device)
+            break;
+        pid = parent;
+    }
+    const started = psField(machine, pid, 'lstart');
+    return started ? { pid, started } : undefined;
+};
+const terminalKey = (machine, atTerminal) => {
+    if (!atTerminal)
+        return undefined;
+    try {
+        const tty = psField(machine, machine.pid, 'tty');
+        const who = machine.run('who', []);
+        return terminalKeyFrom({
+            tty,
+            who: who.status === 0 ? who.stdout : '',
+            leader: () => (tty ? terminalLeader(machine, tty.replace(/^\/dev\//, '')) : undefined)
+        });
+    }
+    catch {
+        return undefined;
+    }
+};
+const mintTerminalIdentity = (machine, dir, key) => {
+    const { linkSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } = machine.files;
+    const file = join(dir, key);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const read = () => {
+        try {
+            const existing = readFileSync(file, 'utf8').trim();
+            return existing.length > 0 ? existing : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const already = read();
+    if (already)
+        return already;
+    if (key.includes('/') || key.includes('\0'))
+        throw new Error(`a session key is one filename: ${key}`);
+    const minted = `tty-${randomUUID()}`;
+    const temp = join(dir, `.${key}.${machine.pid}.${randomBytes(4).toString('hex')}`);
+    writeFileSync(temp, `${minted}\n`, { mode: 0o600 });
+    try {
+        linkSync(temp, file);
+        return minted;
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        const theirs = read();
+        if (theirs)
+            return theirs;
+        throw new Error(`could not read the session identity at ${file}`);
+    }
+    finally {
+        try {
+            unlinkSync(temp);
+        }
+        catch { }
+    }
+};
+export const SESSION_ID_SHAPE = /^[\x21-\x7e]{1,128}$/;
+export const AGENT_LABEL_SHAPE = /^[\x20-\x7e]{1,128}$/;
+export const resolveWriteIdentityDetail = (store, atTerminal) => {
+    const rawLabel = store.env.LATTRIS_AGENT;
+    if (rawLabel !== undefined && rawLabel.length > 0 && !AGENT_LABEL_SHAPE.test(rawLabel)) {
+        return {
+            kind: 'invalid',
+            words: `LATTRIS_AGENT must be 1 to ${SESSION_ID_MAX} printable ASCII characters, the only ones a request header carries; ` +
+                `this one is ${rawLabel.length} characters. Nothing was written.`
+        };
+    }
+    const agentLabel = rawLabel && rawLabel.length > 0 ? rawLabel : undefined;
+    const fromEnv = store.env.LATTRIS_SESSION_ID;
+    if (fromEnv !== undefined && fromEnv.length > 0) {
+        if (!SESSION_ID_SHAPE.test(fromEnv)) {
+            return {
+                kind: 'invalid',
+                words: `LATTRIS_SESSION_ID must be 1 to ${SESSION_ID_MAX} printable characters with no spaces; ` +
+                    `this one is ${fromEnv.length} characters. Nothing was written.`
+            };
+        }
+        return { kind: 'ok', identity: { sessionId: fromEnv, agentLabel } };
+    }
+    const key = terminalKey(store, atTerminal);
+    if (key === undefined)
+        return { kind: 'none' };
+    const sessionId = mintTerminalIdentity(store, join(sessionDir(store), 'sessions'), key);
+    return { kind: 'ok', identity: { sessionId, agentLabel } };
+};
+export const requireWriteIdentity = (store, atTerminal) => {
+    const r = resolveWriteIdentityDetail(store, atTerminal);
+    if (r.kind === 'ok')
+        return r.identity;
+    return refusal(`${r.kind === 'invalid' ? r.words : SESSION_ID_DOOR}\n`, EXIT.USAGE);
+};
+export const SESSION_ID_DOOR = 'This write changes a note’s history and has to name the session doing it. ' +
+    'Off a terminal there is no session to infer: set LATTRIS_SESSION_ID to a stable ' +
+    'name for this worker or run (1 to 128 characters), and LATTRIS_AGENT to a readable ' +
+    'label if you want one. Nothing was written.';
+export const noteWriteHeaders = (identity, idempotencyKey) => ({
+    'X-Lattris-Session-Id': identity.sessionId,
+    ...(identity.agentLabel ? { 'X-Lattris-Agent': identity.agentLabel } : {}),
+    ...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {})
+});
+const UUID_KEY_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const isUuidKey = (key) => UUID_KEY_SHAPE.test(key);
+//# sourceMappingURL=write-identity.js.map

package/dist/version.js

@@ -0,0 +1,16 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readJsonObject } from "./store/json-file.js";
+export const currentPackageVersion = (files) => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = readJsonObject(files, join(here, '..', 'package.json'));
+    return typeof pkg?.version === 'string' ? pkg.version : 'unknown';
+};
+export const printVersion = (term, files) => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const build = readJsonObject(files, join(here, 'build.json'));
+    const version = currentPackageVersion(files);
+    const commit = typeof build?.commit === 'string' ? build.commit.slice(0, 12) : undefined;
+    term.stdout.write(commit ? `lattris ${version} (${commit})\n` : `lattris ${version}\n`);
+};
+//# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lattris",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "type": "module",
   "description": "First-party CLI for Lattris — sign in, capture notes and sessions, and read your own tree from the terminal.",
   "keywords": [
@@ -23,9 +23,8 @@
     "node": ">=22"
   },
   "files": [
-    "dist/main.js",
-    "dist/extract-claude-jsonl.js",
-    "dist/save-session-chain.js",
+    "dist/**/*.js",
+    "!dist/installed-check.js",
     "dist/build.json"
   ],
   "publishConfig": {

package/dist/save-session-chain.js

@@ -1,136 +0,0 @@
-// The whole-chain materialiser (session-block spec: "the extractor
-// materialises the WHOLE chain oldest-epoch-first on every save — extend an
-// epoch's block where it exists, create-and-link where it doesn't —
-// complete, idempotent, regardless of when the person last saved"; block-
-// graph spec: "The whole loop — epoch detection, chain materialisation,
-// fork handling, edge writing, reasons — is a deterministic script reading
-// the jsonl on one side and the CLI/API's own responses on the other").
-//
-// An internal module behind `lattris capture session <transcript.jsonl>`
-// (main.ts), which owns the IO: the token, the POST, the receipts dir, the
-// door rendering. What lives here is the deterministic drive loop and the
-// receipts store — machine-read receipts and refusal CODES, never parsed
-// prose. Per epoch, oldest first:
-//   - a RECEIPT HINT exists for this epoch (a prior run's own receipt,
-//     cached under the state dir): save with `extends` — the server's
-//     fingerprints decide; a divergence 409 is the scripted fork signal →
-//     re-submit `asNewBlock` + `forkedFrom` that block (the server verifies
-//     THAT claim too — the hint only ever nominates, per the law: "receipts
-//     and external ids are hints; the server's fingerprint comparison is
-//     the truth").
-//   - no hint: a plain save (`externalConversationId` nomination resolves a
-//     known epoch; otherwise create), with `continuesFrom` naming the
-//     PREVIOUS epoch's block from THIS run's receipts — the chain edge.
-//     A forked block carries its `forked_into` edge INSTEAD of a chain edge
-//     (the door's one-born-with-edge rule); continuity stays derivable
-//     through the origin's own chain — edge-economy, nothing duplicated.
-//   - the receipt (outcome + block id + turn count) is recorded back into
-//     the hint file, so the next run resumes exactly where the truth is.
-//
-// The AI-judgment inputs are --title, --ai-summary (applied to the LIVE —
-// last — epoch's save only), and --contributor (applied to EVERY epoch's
-// save — attribution is a whole-chain fact, not an epoch-specific one, and
-// an extend's own save carries it so re-running with the flag heals older
-// epochs of the same chain); everything else is mechanical.
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-// A save the drive loop could not scriptedly react to (anything beyond the
-// divergence-fork and stale-hint outcomes above). Typed, carrying the wire's
-// own status and body, so the command can render it through the CLI's one
-// door rule (classifyApiError → renderDoor) with the house exit codes — a
-// 401 mid-chain must read as NOAUTH, not a generic failure.
-export class ChainSaveError extends Error {
-    // Explicit fields, not constructor parameter properties — those are
-    // TS-only syntax the no-build `node --experimental-strip-types` run
-    // cannot erase (strip-only mode refuses them outright).
-    epoch;
-    status;
-    body;
-    constructor(epoch, status, body) {
-        super(`epoch ${epoch} save failed (${status} ${body.code ?? ''}): ${body.message ?? 'no message'}`);
-        this.epoch = epoch;
-        this.status = status;
-        this.body = body;
-    }
-}
-export const driveChain = async (chain, receipts, judgment, save) => {
-    const results = [];
-    let previousBlockId;
-    for (let k = 0; k < chain.epochs.length; k++) {
-        const turns = chain.epochs[k];
-        const isLive = k === chain.epochs.length - 1;
-        const base = { turns, source: chain.source };
-        if (chain.conversationId !== null)
-            base.externalConversationId = chain.conversationId;
-        if (isLive && judgment.title !== undefined)
-            base.title = judgment.title;
-        if (isLive && judgment.aiSummary !== undefined)
-            base.aiSummary = judgment.aiSummary;
-        // contributor rides EVERY epoch, not just the live one — attribution is a
-        // whole-chain fact, and an extend re-running with the flag heals older
-        // epochs whose original save predated the contact.
-        if (judgment.contributor !== undefined)
-            base.contributor = judgment.contributor;
-        const hinted = receipts.epochs[String(k)];
-        let outcome;
-        let forked = false;
-        if (hinted !== undefined) {
-            outcome = await save({ ...base, extends: hinted });
-            if (outcome.status === 409 && outcome.body.code === 'memory:session-diverged') {
-                // The scripted fork reaction: the walked path rewound-and-diverged
-                // from what that block holds — a NEW record, its origin claimed and
-                // server-verified. No continuesFrom here (the door's one-edge rule);
-                // the chain stays derivable through the origin.
-                outcome = await save({ ...base, asNewBlock: true, forkedFrom: hinted });
-                forked = true;
-            }
-            else if (outcome.status === 400 && outcome.body.code === 'memory:unknown-extends') {
-                // The hint went stale (the block was deleted) — hints never decide:
-                // fall back to the no-hint path.
-                outcome = await save(previousBlockId !== undefined ? { ...base, continuesFrom: previousBlockId } : base);
-            }
-        }
-        else {
-            outcome = await save(previousBlockId !== undefined && k > 0 ? { ...base, continuesFrom: previousBlockId } : base);
-        }
-        if (outcome.status !== 200 || !outcome.body.block?.id) {
-            throw new ChainSaveError(k, outcome.status, outcome.body);
-        }
-        const blockId = outcome.body.block.id;
-        receipts.epochs[String(k)] = blockId;
-        results.push({
-            epoch: k,
-            blockId,
-            outcome: outcome.body.outcome ?? 'unknown',
-            turnCount: outcome.body.turnCount ?? turns.length,
-            forked
-        });
-        previousBlockId = blockId;
-    }
-    return results;
-};
-// ─── the receipts store (hints, never decisions) ────────────────────────────
-// Lives under the CLI's own state dir — the command passes sessionDir() in, so
-// this module never re-derives the LATTRIS_HOME/XDG resolution main.ts owns.
-// Same 0700/0600 hygiene as the session file: a receipt names block ids in the
-// person's own record.
-const receiptsPath = (dir, conversationId) => join(dir, 'chains', `${conversationId}.json`);
-export const loadReceipts = (dir, conversationId) => {
-    if (conversationId === null)
-        return { epochs: {} };
-    try {
-        return JSON.parse(readFileSync(receiptsPath(dir, conversationId), 'utf8'));
-    }
-    catch {
-        return { epochs: {} };
-    }
-};
-export const saveReceipts = (dir, conversationId, receipts) => {
-    if (conversationId === null)
-        return;
-    mkdirSync(join(dir, 'chains'), { recursive: true, mode: 0o700 });
-    writeFileSync(receiptsPath(dir, conversationId), JSON.stringify(receipts, null, 2), {
-        mode: 0o600
-    });
-};
-//# sourceMappingURL=save-session-chain.js.map