lattris 0.1.4 → 0.2.0

package/dist/store/environment.js

@@ -0,0 +1,57 @@
+import { basename, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { EXIT, refusal } from "./exit.js";
+export const stripTrailingSlash = (s) => s.replace(/\/+$/, '');
+export const defaultEnvironmentForEntry = (files, entryUrl) => {
+    const entryPath = fileURLToPath(entryUrl);
+    const entryDir = dirname(entryPath);
+    const isBuiltMain = basename(entryPath) === 'main.js' && basename(entryDir) === 'dist';
+    return isBuiltMain && !files.existsSync(join(entryDir, 'installed-check.js')) ? 'prod' : 'local';
+};
+const environmentsPath = (machine) => join(machine.env.XDG_CONFIG_HOME || join(machine.home, '.config'), 'lattris', 'environments.json');
+const BUILTIN_LOCAL = {
+    issuer: 'http://localhost:4444',
+    api: 'http://localhost:54301',
+    web: 'http://localhost:4500',
+    clientId: 'lattris-cli'
+};
+export const BUILTIN_PROD = {
+    issuer: 'https://api.felix-synthetix.com',
+    api: 'https://lattris.com/api/lattris',
+    web: 'https://lattris.com',
+    clientId: 'lattris-cli'
+};
+const BUILTINS = { local: BUILTIN_LOCAL, prod: BUILTIN_PROD };
+const environmentEntry = (machine, envName) => {
+    try {
+        const registry = JSON.parse(machine.files.readFileSync(environmentsPath(machine), 'utf8'));
+        if (typeof registry === 'object' && registry !== null && Object.hasOwn(registry, envName)) {
+            const entry = registry[envName];
+            if (entry)
+                return entry;
+        }
+    }
+    catch { }
+    return Object.hasOwn(BUILTINS, envName) ? BUILTINS[envName] : undefined;
+};
+export const knownEnvironment = (machine, envName) => environmentEntry(machine, envName) !== undefined;
+const loadEnvironmentEntry = (machine, envName) => environmentEntry(machine, envName) ??
+    refusal(`Unknown environment: ${envName}. Known: local, prod (or add it to ${environmentsPath(machine)}).\n`, EXIT.USAGE);
+export const loadConfig = (store) => {
+    const entry = loadEnvironmentEntry(store, store.envName);
+    if ('exit' in entry)
+        return entry;
+    const env = store.env;
+    return {
+        env: store.envName,
+        issuer: stripTrailingSlash(env.LATTRIS_ISSUER ?? entry.issuer),
+        apiUrl: stripTrailingSlash(env.LATTRIS_API ?? entry.api),
+        clientId: env.LATTRIS_CLIENT_ID ?? entry.clientId,
+        redirectPort: Number(env.LATTRIS_REDIRECT_PORT ?? '4577'),
+        audience: env.LATTRIS_AUDIENCE ?? 'foundations lattris',
+        scopes: env.LATTRIS_SCOPES ?? 'openid offline_access lattris:all:all',
+        webUrl: stripTrailingSlash(env.LATTRIS_WEB_URL ?? entry.web),
+        ...(entry.remember_for !== undefined ? { rememberFor: entry.remember_for } : {})
+    };
+};
+//# sourceMappingURL=environment.js.map

package/dist/store/exit.js

@@ -0,0 +1,13 @@
+export const EXIT = {
+    OK: 0,
+    GENERIC: 1,
+    USAGE: 2,
+    NOAUTH: 3,
+    DOOR: 4
+};
+export const refusal = (message, exit = EXIT.USAGE) => ({
+    message,
+    exit
+});
+export const isRefusal = (value) => typeof value === 'object' && value !== null && 'exit' in value && 'message' in value;
+//# sourceMappingURL=exit.js.map

package/dist/store/io.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=io.js.map

package/dist/store/json-file.js

@@ -0,0 +1,9 @@
+export const readJsonObject = (files, path) => {
+    try {
+        return JSON.parse(files.readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+};
+//# sourceMappingURL=json-file.js.map

package/dist/store/session-home.js

@@ -0,0 +1,189 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { basename, dirname, join, resolve, sep } from 'node:path';
+import { knownEnvironment } from "./environment.js";
+export const stateHome = (machine) => machine.env.XDG_STATE_HOME || join(machine.home, '.local', 'state');
+const stateDir = (machine) => join(stateHome(machine), 'lattris');
+export const machinesRoot = (machine) => {
+    const named = machine.env.LATTRIS_MACHINES_ROOT;
+    return named
+        ? resolve(machine.home, named.replace(/^~(?=\/|$)/, machine.home))
+        : join(machine.home, 'lattris-machines');
+};
+export const BINDING_FILE = '.lattris';
+const madeHerePath = (machine) => join(stateDir(machine), 'bindings.json');
+const present = (files, path) => {
+    try {
+        files.lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const realPathOf = (files, path) => {
+    try {
+        return files.realpathSync(path);
+    }
+    catch {
+        const parent = dirname(path);
+        return parent === path ? path : join(realPathOf(files, parent), basename(path));
+    }
+};
+const bindingKey = (files, bindingFile) => join(realPathOf(files, dirname(bindingFile)), basename(bindingFile));
+const underMachinesRoot = (machine, bindingFile, dir) => {
+    const root = realPathOf(machine.files, machinesRoot(machine));
+    const under = (path) => path.startsWith(root + sep);
+    const from = realPathOf(machine.files, dirname(bindingFile));
+    return under(realPathOf(machine.files, dir)) && from !== root && !under(from);
+};
+const digest = (content) => createHash('sha256').update(content).digest('hex');
+const readMadeHere = (machine) => {
+    try {
+        const made = JSON.parse(machine.files.readFileSync(madeHerePath(machine), 'utf8'));
+        return typeof made === 'object' && made !== null ? made : {};
+    }
+    catch {
+        return {};
+    }
+};
+const wasMadeHere = (machine, bindingFile, content) => {
+    const made = readMadeHere(machine);
+    const key = bindingKey(machine.files, bindingFile);
+    return Object.hasOwn(made, key) && made[key] === digest(content);
+};
+const writeWhole = (machine, file, content, mode) => {
+    const draft = `${file}.${randomUUID()}.new`;
+    try {
+        machine.files.writeFileSync(draft, content, { mode, flag: 'wx' });
+        machine.files.renameSync(draft, file);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST') {
+            try {
+                machine.files.unlinkSync(draft);
+            }
+            catch { }
+        }
+        throw e;
+    }
+};
+const saveMadeHere = (machine, made) => {
+    machine.files.mkdirSync(stateDir(machine), { recursive: true, mode: 0o700 });
+    writeWhole(machine, madeHerePath(machine), `${JSON.stringify(made, null, 2)}\n`, 0o600);
+};
+const readBinding = (machine, bindingFile) => {
+    const refused = { trusted: false, bindingFile };
+    let content;
+    try {
+        if (!machine.files.lstatSync(bindingFile).isFile())
+            return refused;
+        content = machine.files.readFileSync(bindingFile, 'utf8');
+    }
+    catch {
+        return refused;
+    }
+    const lines = content
+        .trim()
+        .split('\n')
+        .map((l) => l.trim());
+    const pathLine = lines[0];
+    const env = lines
+        .slice(1)
+        .find((l) => l.startsWith('env='))
+        ?.slice(4)
+        .trim();
+    if (!pathLine)
+        return refused;
+    if (env && !knownEnvironment(machine, env))
+        return refused;
+    const machineDir = resolve(dirname(bindingFile), pathLine);
+    if (!underMachinesRoot(machine, bindingFile, machineDir) &&
+        !wasMadeHere(machine, bindingFile, content))
+        return refused;
+    return { trusted: true, bindingFile, machineDir, ...(env ? { env } : {}) };
+};
+export const findBinding = (machine, from = machine.cwd) => {
+    let dir = from;
+    while (dir.startsWith(machine.home + sep)) {
+        const bindingFile = join(dir, BINDING_FILE);
+        if (present(machine.files, bindingFile))
+            return readBinding(machine, bindingFile);
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+};
+export const writeBinding = (machine, dir, target, env) => {
+    const bindingFile = join(dir, BINDING_FILE);
+    const content = env ? `${target}\nenv=${env}\n` : `${target}\n`;
+    writeWhole(machine, bindingFile, content, 0o644);
+    if (underMachinesRoot(machine, bindingFile, target))
+        return;
+    saveMadeHere(machine, {
+        ...readMadeHere(machine),
+        [bindingKey(machine.files, bindingFile)]: digest(content)
+    });
+};
+export const clearBinding = (machine, dir) => {
+    const bindingFile = join(dir, BINDING_FILE);
+    if (!present(machine.files, bindingFile))
+        return false;
+    const key = bindingKey(machine.files, bindingFile);
+    machine.files.rmSync(bindingFile);
+    const made = readMadeHere(machine);
+    if (Object.hasOwn(made, key)) {
+        delete made[key];
+        saveMadeHere(machine, made);
+    }
+    return true;
+};
+export const resolveActorDir = (files, actor, root) => {
+    const exact = join(root, actor);
+    if (actor.includes('@') || files.existsSync(exact))
+        return { dir: exact };
+    let entries = [];
+    try {
+        entries = files.readdirSync(root);
+    }
+    catch {
+        return { dir: exact };
+    }
+    const matches = entries.filter((e) => e.startsWith(`${actor}@`)).sort();
+    if (matches.length === 1)
+        return { dir: join(root, matches[0]) };
+    if (matches.length > 1)
+        return { ambiguous: matches };
+    return { dir: exact };
+};
+export const resolveSessionHome = (machine) => {
+    if (machine.env.LATTRIS_HOME)
+        return { dir: machine.env.LATTRIS_HOME };
+    const bound = findBinding(machine);
+    if (bound?.trusted)
+        return { dir: bound.machineDir, bindingFile: bound.bindingFile, bindingEnv: bound.env };
+    return { dir: stateDir(machine), ...(bound ? { untrusted: bound.bindingFile } : {}) };
+};
+export const sessionDir = (store) => {
+    const home = resolveSessionHome(store);
+    const isDefault = !home.bindingFile && !store.env.LATTRIS_HOME;
+    if (isDefault && !store.envExplicit)
+        return home.dir;
+    const envDir = join(home.dir, store.envName);
+    const files = store.files;
+    if (store.envName === 'local' &&
+        !files.existsSync(join(envDir, 'session.json')) &&
+        files.existsSync(join(home.dir, 'session.json'))) {
+        files.mkdirSync(envDir, { recursive: true, mode: 0o700 });
+        files.renameSync(join(home.dir, 'session.json'), join(envDir, 'session.json'));
+        files.chmodSync(join(envDir, 'session.json'), 0o600);
+    }
+    return envDir;
+};
+export const sessionPath = (store) => join(sessionDir(store), 'session.json');
+export const safeFileName = (name) => {
+    const safe = name.replace(/[^A-Za-z0-9._-]/g, '_');
+    return safe === '' || safe === '.' || safe === '..' ? undefined : safe;
+};
+//# sourceMappingURL=session-home.js.map

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