lattris 0.1.3 → 0.2.0

package/dist/nouns/share.js

@@ -0,0 +1,105 @@
+import { formatAudiences } from "../render/rows.js";
+import { consent } from "./consent.js";
+const NOT_LINKED = 'This contact is not linked to an account yet. Invite them from this contact; accepting links it.\n';
+export const SHARE_HELP = [
+    'share — grant public or a person contact access to a memory.',
+    '',
+    'Usage:',
+    '  lattris share memory <id-or-prefix> --with <public-or-contact> [--yes]',
+    '',
+    '  --with   public, or an exact contact name or id from `lattris contact list`.',
+    '  --yes                required when not at a terminal; at a terminal you',
+    '                       are always asked, --yes or not.',
+    '',
+    'Idempotent: sharing with an audience that already has access succeeds and',
+    'changes nothing.',
+    '',
+    'Alias: publish → share'
+].join('\n');
+const shareVerb = {
+    verb: 'share',
+    nouns: ['memory', 'memories'],
+    form: {
+        usage: 'Usage: lattris share memory <id> --with <audience> [--yes]',
+        flags: { '--with': 'with' },
+        switches: ['--yes'],
+        positionals: 1,
+        idPositionals: [0],
+        steps: {
+            requireFlag: {
+                key: 'with',
+                message: '--with is required. Use public or one of your contact names or ids.\n'
+            },
+            pipedNeedsYes: {
+                message: 'Refusing to share without confirmation on a non-interactive session. Pass --yes to skip the prompt.\n'
+            },
+            contact: { from: ['flag:with'], publicWord: 'public', mustBeLinked: NOT_LINKED },
+            memory: 'at-tty',
+            confirm: {
+                question: 'Share "{title}" ({memory.id}) with {audience}? [y/N] ',
+                onNo: { text: 'Cancelled.\n', to: 'stderr' },
+                onInterrupted: { text: 'Cancelled.\n', exit: 1 }
+            }
+        },
+        request: {
+            method: 'POST',
+            path: '/memories/{memory.id}/grants',
+            body: {
+                kind: { value: 'person' },
+                contactId: { context: 'contact.id' }
+            },
+            bodyWithPublic: { audience: 'public' }
+        },
+        ambiguousRefusal: true,
+        render: (grant, context) => `Shared memory ${context.memory?.id ?? context.positionals[0]} with ${context.contact?.displayName ?? grant.kind}`
+    }
+};
+export const UNSHARE_HELP = [
+    'unshare — withdraw an audience from a memory. No confirmation — withdrawal',
+    'is the safe direction.',
+    '',
+    'Usage:',
+    '  lattris unshare memory <id-or-prefix> --with <public-or-contact>',
+    '',
+    '  --with   public, or an exact contact name or id from `lattris contact list`.',
+    '',
+    'Bare (no --with): refuses and shows what the memory is currently shared',
+    'with, so you can see the state and the fix in one line.',
+    '',
+    'Alias: unpublish → unshare'
+].join('\n');
+const unshareVerb = {
+    verb: 'unshare',
+    nouns: ['memory', 'memories'],
+    form: {
+        usage: 'Usage: lattris unshare memory <id> [--with <audience>]',
+        flags: { '--with': 'with' },
+        positionals: 1,
+        idPositionals: [0],
+        steps: {
+            contact: { from: ['flag:with'], publicWord: 'public', mustBeLinked: NOT_LINKED },
+            memory: 'always',
+            noAudienceReport: {
+                key: 'with',
+                first: '--with is required. Use public or one of your contact names or ids.\n',
+                second: '"{title}" ({memory.id}) is currently shared with: {audiences}\n'
+            }
+        },
+        request: {
+            method: 'DELETE',
+            path: '/memories/{memory.id}/grants/person/{contact.claimedPersonId}',
+            pathWithPublic: '/memories/{memory.id}/grants/public'
+        },
+        ambiguousRefusal: true,
+        renderTo: 'stderr',
+        render: (_data, context) => `Unshared memory ${context.memory?.id ?? ''} from ${context.contact?.displayName ?? 'public'}`
+    }
+};
+export const audiencesOf = (memory) => formatAudiences(memory.audiences);
+export const grants = {
+    name: 'grants',
+    words: { singular: 'grant', plural: 'grants' },
+    help: SHARE_HELP,
+    verbs: [shareVerb, unshareVerb, consent]
+};
+//# sourceMappingURL=share.js.map

package/dist/nouns/words.js

@@ -0,0 +1,76 @@
+export const VERB_ALIASES = {
+    read: 'get',
+    show: 'get',
+    view: 'get',
+    fetch: 'get',
+    remove: 'delete',
+    publish: 'share',
+    unpublish: 'unshare'
+};
+export const USAGE_LINES = [
+    '  lattris login                Sign in via the browser (PKCE) and store the session',
+    '  lattris setup                Transition this repo’s Claude to Lattris as its memory system',
+    '  lattris use <name|path>      Bind this directory to an actor (.lattris; bare `use` shows, --clear removes)',
+    '  lattris whoami               Print "<name> · #<lattris_no>" for the signed-in person',
+    '  lattris set name "<value>"   Set the name shown on your public page',
+    '  lattris set root <id>        Set the block a walker starts from on your tree (whoami shows it)',
+    '  lattris set banned-words     The words your own notes refuse (bare shows; words given replace; --clear)',
+    '  lattris capture memory       Capture a memory — `echo "…" | lattris capture memory`',
+    '  lattris capture session <transcript>  Save an AI conversation — the whole chain from its file',
+    '  lattris capture recording    Keep a recording \u2014 held audio, a source, or a transcript file',
+    '  lattris get memories         List your memories, newest first, with filters',
+    '  lattris contact create "<name>"  Record a person or an AI you work with (--ai); add, list, get, update',
+    '  lattris invite <contact>     Mint an invitation for one of your person contacts',
+    '  lattris get invites          List the invitations you have minted',
+    '  lattris get memory <id>      Read one memory back \u2014 words and edges (--links/--depth/--content)',
+    '  lattris ask <handle>         Leave a question on someone\u2019s tree \u2014 `echo "\u2026" | lattris ask <handle>`',
+    '  lattris get questions        The questions on your tree, open first (--mine: ones you asked)',
+    '  lattris close question <id>  Close a question (--close-as updated|declined|already-answered)',
+    '  lattris share memory <id>    Grant an audience access (--with public)',
+    '  lattris unshare memory <id>  Withdraw an audience (--with public)',
+    '  lattris consent <id>         Put a memory shared with you on your graph (--withdraw reverses)',
+    '  lattris link <from> <to>     State that one memory leads to another (--verb, --reason)',
+    '  lattris unlink <from> <to>   Remove that claim (--verb; the blocks stay)',
+    '  lattris update edge <from>   Rewrite an edge\u2019s reason (--verb, --to, --reason)',
+    '  lattris update memory <id>   Correct a memory — `echo "…" | lattris update memory <id> --base-fingerprint <fp>`',
+    '  lattris update recording     Replace a recording\u2019s transcript, or name its speakers',
+    '  lattris get history <id>     A note\u2019s history: every change, newest first, and the head fingerprint',
+    '  lattris delete memory <id>   Move a note to deleted items (its history stays); other types delete',
+    '  lattris get deleted          Your deleted items, with the fingerprint restore and erase need',
+    '  lattris restore memory <id>  Bring a note back, or an earlier revision (--revision, --base-fingerprint)',
+    '  lattris erase memory <id>    Permanently erase a note in deleted items. No undo.',
+    '  lattris resend <request.json>  Send a kept request again, exactly (a lost capture or overwrite)',
+    '  lattris get datasets         The datasets the API keeps, whether you hold rows, and their time range',
+    '  lattris get dataset <name>   One dataset: its identity, filters, fields and an example line',
+    '  lattris get rows <name>      One page of a dataset\u2019s rows (field=value filters, --from, --to, --limit)',
+    '  lattris get row <name> <id>  One row of a dataset',
+    '  lattris capture rows <name>  Save rows \u2014 newline-delimited JSON on stdin, sent in pieces of 5,000 lines',
+    '  lattris delete row <name> <id>  Remove one row of a dataset, permanently',
+    '  lattris logout               Forget the stored session'
+];
+export const COMMAND_WORDS = new Set([
+    'login',
+    'setup',
+    'use',
+    'whoami',
+    'set',
+    'capture',
+    'get',
+    'ask',
+    'close',
+    'delete',
+    'update',
+    'link',
+    'unlink',
+    'invite',
+    'share',
+    'unshare',
+    'consent',
+    'restore',
+    'erase',
+    'resend',
+    'contact',
+    'logout',
+    '--as'
+]);
+//# sourceMappingURL=words.js.map

package/dist/registry/datasets.js

@@ -0,0 +1,15 @@
+import { captureRows } from "../datasets/capture.js";
+import { getRows } from "../datasets/page.js";
+import { GET_DATASETS_HELP } from "../nouns/datasets.js";
+export const datasetNouns = [
+    {
+        name: 'rows',
+        words: { singular: 'row', plural: 'rows' },
+        help: GET_DATASETS_HELP,
+        verbs: [
+            { verb: 'get', nouns: ['rows'], handler: getRows },
+            { verb: 'capture', nouns: ['rows'], handler: captureRows }
+        ]
+    }
+];
+//# sourceMappingURL=datasets.js.map

package/dist/registry/entry.js

@@ -0,0 +1,51 @@
+import { LOGIN_HELP, WHOAMI_HELP, login, logout, whoami } from "../entry/session.js";
+import { SET_HELP, setBannedWords, setName, setRoot } from "../entry/set.js";
+import { setup } from "../entry/setup.js";
+import { use } from "../entry/use.js";
+export const entryNouns = [
+    {
+        name: 'session',
+        words: { singular: 'session', plural: 'sessions' },
+        help: LOGIN_HELP,
+        verbs: [
+            { verb: 'login', handler: login },
+            { verb: 'logout', handler: async (_cfg, io) => logout(io) },
+            { verb: 'whoami', handler: whoami },
+            { verb: 'setup', handler: setup },
+            { verb: 'use', handler: use }
+        ]
+    },
+    {
+        name: 'person',
+        words: { singular: 'person', plural: 'persons' },
+        help: SET_HELP,
+        verbs: [
+            { verb: 'set', nouns: ['name'], handler: setName },
+            { verb: 'set', nouns: ['root'], handler: setRoot },
+            { verb: 'set', nouns: ['banned-words'], handler: setBannedWords }
+        ]
+    }
+];
+export const entryVerbs = {
+    login: { help: LOGIN_HELP, helpBeforeAuth: true },
+    logout: {
+        help: [
+            'Usage: lattris logout',
+            '',
+            'Signs this machine dir out: removes its session file, so the next',
+            'command that needs a session asks for lattris login. Nothing is sent',
+            'to the server; with no session there it still prints "Logged out."',
+            'Exit 1 when the session file cannot be removed.'
+        ].join('\n'),
+        helpBeforeAuth: true
+    },
+    whoami: { help: WHOAMI_HELP, helpBeforeAuth: true },
+    setup: {},
+    use: {},
+    set: {
+        help: SET_HELP,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Unknown field: {noun}\n\n', stdout: `${SET_HELP}\n` }
+    }
+};
+//# sourceMappingURL=entry.js.map

package/dist/registry/index.js

@@ -0,0 +1,17 @@
+import { datasetNouns } from "./datasets.js";
+import { entryNouns, entryVerbs } from "./entry.js";
+import { memoryNouns, memoryVerbs } from "./memory.js";
+import { listNouns, listVerbs } from "../nouns/index.js";
+export const registry = {
+    nouns: [...listNouns, ...memoryNouns, ...entryNouns, ...datasetNouns],
+    verbs: { ...listVerbs, ...memoryVerbs, ...entryVerbs }
+};
+export const commandWordsOf = (r) => [
+    ...new Set([
+        ...r.nouns
+            .filter((n) => n.grammar === 'noun-first')
+            .flatMap((n) => [n.words.singular, ...(n.words.aliases ?? [])]),
+        ...r.nouns.filter((n) => n.grammar !== 'noun-first').flatMap((n) => n.verbs.map((v) => v.verb))
+    ])
+];
+//# sourceMappingURL=index.js.map

package/dist/registry/memory.js

@@ -0,0 +1,110 @@
+import { CAPTURE_ROWS_HELP } from "../datasets/capture.js";
+import { DELETE_ROW_HELP, GET_DATASETS_HELP } from "../nouns/datasets.js";
+import { CAPTURE_INDEX, CAPTURE_NOTE_HELP, CAPTURE_SESSION_HELP } from "../memory/capture-help.js";
+import { asksForSessionForm, captureMemory } from "../memory/capture-note.js";
+import { DELETE_HELP, deleteMemory } from "../memory/delete.js";
+import { ERASE_HELP, eraseMemory } from "../memory/erase.js";
+import { GET_HELP } from "../memory/get-help.js";
+import { getMemories } from "../memory/get.js";
+import { getDeleted, getHistory } from "../memory/history.js";
+import { CAPTURE_RECORDING_HELP, captureRecording } from "../memory/recording.js";
+import { updateRecording } from "../memory/recording-update.js";
+import { RESEND_HELP, resend } from "../memory/resend.js";
+import { RESTORE_HELP, restoreMemory } from "../memory/restore.js";
+import { UPDATE_HELP } from "../memory/update-help.js";
+import { updateMemory } from "../memory/update.js";
+export const memoryNouns = [
+    {
+        name: 'memories',
+        words: { singular: 'memory', plural: 'memories', aliases: ['note'] },
+        help: GET_HELP,
+        verbs: [
+            { verb: 'capture', nouns: ['note', 'memory'], handler: captureMemory },
+            {
+                verb: 'capture',
+                nouns: ['session'],
+                handler: (cfg, io, rest) => captureMemory(cfg, io, ['--type', 'session', ...rest])
+            },
+            {
+                verb: 'get',
+                nouns: ['memory'],
+                handler: (cfg, io, rest) => getMemories(cfg, io, rest, 'memory')
+            },
+            {
+                verb: 'get',
+                nouns: ['memories'],
+                handler: (cfg, io, rest) => getMemories(cfg, io, rest, 'memories')
+            },
+            { verb: 'get', nouns: ['history'], handler: getHistory },
+            { verb: 'get', nouns: ['deleted'], handler: getDeleted },
+            { verb: 'update', nouns: ['memory', 'memories'], handler: updateMemory },
+            { verb: 'delete', nouns: ['memory', 'memories'], handler: deleteMemory },
+            { verb: 'restore', nouns: ['memory', 'memories', 'note'], handler: restoreMemory },
+            { verb: 'erase', nouns: ['memory', 'memories', 'note'], handler: eraseMemory },
+            { verb: 'resend', handler: resend }
+        ]
+    },
+    {
+        name: 'recordings',
+        words: { singular: 'recording', plural: 'recordings' },
+        help: CAPTURE_RECORDING_HELP,
+        verbs: [
+            { verb: 'capture', nouns: ['recording'], handler: captureRecording },
+            { verb: 'update', nouns: ['recording', 'recordings'], handler: updateRecording }
+        ]
+    }
+];
+const captureHelp = (args) => {
+    if (args[0] === 'rows')
+        return CAPTURE_ROWS_HELP;
+    if (args[0] === 'session' || asksForSessionForm(args))
+        return CAPTURE_SESSION_HELP;
+    if (args[0] === 'note' || args[0] === 'memory')
+        return CAPTURE_NOTE_HELP;
+    if (args[0] === 'recording')
+        return CAPTURE_RECORDING_HELP;
+    return CAPTURE_INDEX;
+};
+export const memoryVerbs = {
+    capture: {
+        help: captureHelp,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Unknown capture form: {noun}\n\n', stdout: `${CAPTURE_INDEX}\n` }
+    },
+    get: {
+        help: (args) => ['datasets', 'dataset', 'rows', 'row'].includes(args[0]) ? GET_DATASETS_HELP : GET_HELP,
+        bareIsHelp: true,
+        badNoun: {
+            stderr: 'Usage: lattris get memories | lattris get memory <id> | lattris get history <id> | lattris get deleted | lattris get invites | lattris get questions | lattris get datasets | lattris get dataset <name> | lattris get rows <name> | lattris get row <name> <id>\n'
+        }
+    },
+    update: {
+        help: UPDATE_HELP,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Usage: lattris update memory <id>\n' }
+    },
+    delete: {
+        help: (args) => (args[0] === 'row' ? DELETE_ROW_HELP : DELETE_HELP),
+        bareIsHelp: true,
+        badNoun: {
+            stderr: 'Usage: lattris delete memory <id> [--yes] | lattris delete row <name> <id> [--yes]\n'
+        }
+    },
+    restore: {
+        help: RESTORE_HELP,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: {
+            stderr: 'Usage: lattris restore memory <id> --revision <n> --base-fingerprint <head>\n'
+        }
+    },
+    erase: {
+        help: ERASE_HELP,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Usage: lattris erase memory <id> --base-fingerprint <head> [--yes]\n' }
+    },
+    resend: { help: RESEND_HELP, helpBeforeAuth: true }
+};
+//# sourceMappingURL=memory.js.map

package/dist/render/datasets.js

@@ -0,0 +1,77 @@
+import { sanitizeForTerminal } from "./text.js";
+const LABEL = 13;
+const valueText = (value, max = 200) => typeof value === 'string'
+    ? sanitizeForTerminal(value, max)
+    : sanitizeForTerminal(JSON.stringify(value) ?? 'null', max);
+const wordsText = (words) => words.length === 0 ? '(none)' : words.map((w) => sanitizeForTerminal(w)).join(', ');
+const widest = (cells) => Math.max(0, ...cells.map((c) => c.length));
+const table = (rows) => {
+    const widths = rows[0]?.map((_, i) => widest(rows.map((r) => r[i] ?? ''))) ?? [];
+    return rows
+        .map((r) => r
+        .map((cell, i) => (i === r.length - 1 ? cell : cell.padEnd(widths[i])))
+        .join('  ')
+        .trimEnd())
+        .join('\n');
+};
+export const formatCatalogue = (entries) => entries.length === 0
+    ? 'No datasets.'
+    : table(entries.map((e) => [
+        sanitizeForTerminal(e.name),
+        sanitizeForTerminal(e.storage),
+        e.holds ? 'holds rows' : 'no rows',
+        valueText(e.earliest ?? '-'),
+        valueText(e.latest ?? '-')
+    ]));
+const boundText = (value) => Array.isArray(value) ? value.map((v) => valueText(v)).join(', ') : valueText(value);
+const fieldCells = (f) => {
+    const { name, type, required, nullable, ...bounds } = f;
+    const rest = [
+        required ? 'required' : 'optional',
+        ...(nullable ? ['nullable'] : []),
+        ...Object.entries(bounds).map(([k, v]) => `${sanitizeForTerminal(k)} ${boundText(v)}`)
+    ];
+    return [`  ${sanitizeForTerminal(name)}`, sanitizeForTerminal(type), rest.join('  ')];
+};
+export const formatDescription = (d) => {
+    const lines = [
+        `${'dataset'.padEnd(LABEL)}${sanitizeForTerminal(d.name)}  (${sanitizeForTerminal(d.storage)})`,
+        `${'identity'.padEnd(LABEL)}${wordsText(d.identity)}`,
+        `${'filters'.padEnd(LABEL)}required ${wordsText(d.filters.required)}`,
+        `${''.padEnd(LABEL)}optional ${wordsText(d.filters.optional)}`
+    ];
+    if (d.page) {
+        const limits = d.limits ? `, ${d.limits.default} rows a page, at most ${d.limits.maximum}` : '';
+        lines.push(`${'page'.padEnd(LABEL)}by ${valueText(d.page.by)} on ${valueText(d.page.field)}${limits}`);
+    }
+    lines.push('', 'fields', table(d.fields.map(fieldCells)));
+    if (d.example) {
+        lines.push('', 'example line', `  ${valueText(JSON.stringify(d.example), Infinity)}`);
+    }
+    return lines.join('\n');
+};
+export const formatRow = (row) => {
+    const width = widest(Object.keys(row)) + 2;
+    return Object.entries(row)
+        .map(([k, v]) => `${sanitizeForTerminal(k).padEnd(width)}${valueText(v, Infinity)}`)
+        .join('\n');
+};
+const formatRowLine = (row) => [
+    valueText(row.id),
+    ...Object.entries(row)
+        .filter(([k, v]) => k !== 'id' && k !== 'ownerId' && v !== null)
+        .map(([k, v]) => `${sanitizeForTerminal(k)}=${valueText(v)}`)
+].join('  ');
+export const formatRowPage = (page) => page.items.length === 0 ? 'No rows.' : page.items.map(formatRowLine).join('\n');
+export const formatCaptured = (name, c) => {
+    const lines = [
+        `Sent ${c.sent} ${c.sent === 1 ? 'line' : 'lines'} to ${sanitizeForTerminal(name)}: ` +
+            `${c.added} added, ${c.replaced} replaced, ${c.refused} refused.`,
+        ...c.refusals.map((r) => `  ${valueText(r.message ?? '', Infinity)}`)
+    ];
+    if (c.refused > c.refusals.length) {
+        lines.push(`  ${c.refused - c.refusals.length} more refused, counted and not named.`);
+    }
+    return lines.join('\n');
+};
+//# sourceMappingURL=datasets.js.map

package/dist/render/door.js

@@ -0,0 +1,39 @@
+import { renderRunHint, sanitizeForTerminal } from "./text.js";
+const EDGE_REFUSAL_EXCERPT_BYTES = 200;
+export const truncateToUtf8Bytes = (s, max) => {
+    let bytes = 0;
+    let out = '';
+    for (const ch of s) {
+        const n = Buffer.byteLength(ch, 'utf8');
+        if (bytes + n > max)
+            break;
+        bytes += n;
+        out += ch;
+    }
+    return out;
+};
+export const doorText = (commands, message, next, messageLimit = 200) => {
+    let text = `${sanitizeForTerminal(message, messageLimit)}\n`;
+    if (next?.action) {
+        const argv = next.action.trim().split(/\s+/);
+        text += commands.has(argv[0])
+            ? `Run: ${renderRunHint(argv)}\n`
+            : `The door suggests: ${sanitizeForTerminal(next.action)}\n`;
+    }
+    return text;
+};
+export const edgeText = (excerpt) => {
+    const shown = truncateToUtf8Bytes(sanitizeForTerminal(excerpt.replace(/\r/g, ''), Infinity), EDGE_REFUSAL_EXCERPT_BYTES);
+    return ('Refused at the edge before reaching Lattris (403). The words or the request shape ' +
+        "tripped the gateway's screen; nothing was written." +
+        (shown.length > 0 ? `\n${shown}` : ''));
+};
+export const answerText = (commands, answer) => {
+    if (answer.kind === 'door') {
+        return doorText(commands, answer.message, answer.next, answer.whole ? Infinity : 200);
+    }
+    if (answer.kind === 'edge')
+        return `${edgeText(answer.excerpt)}\n`;
+    return `The server answered with a web page, not the API — check the environment’s \`${answer.address}\` URL.\n`;
+};
+//# sourceMappingURL=door.js.map

package/dist/render/output.js

@@ -0,0 +1,19 @@
+import { answerText } from "./door.js";
+export const emit = (term, data, rawText, renderHuman) => {
+    if (term.stdout.isTTY) {
+        const human = renderHuman(data);
+        if (human.length > 0)
+            term.stdout.write(`${human}\n`);
+    }
+    else {
+        term.stdout.write(rawText.endsWith('\n') ? rawText : `${rawText}\n`);
+    }
+};
+export const renderRefusal = (term, refused) => {
+    if (refused.answer)
+        term.stderr.write(answerText(term.commands, refused.answer));
+    if (refused.message.length > 0)
+        term.stderr.write(refused.message);
+    term.exit(refused.exit);
+};
+//# sourceMappingURL=output.js.map

package/dist/render/prompt.js

@@ -0,0 +1,4 @@
+export const readYesNo = (answer) => answer === null ? 'interrupted' : /^y(es)?$/i.test(answer.trim()) ? 'yes' : 'no';
+export const confirmAction = async (term, prompt) => readYesNo(await term.stdin.ask(prompt));
+export const promptLine = async (term, question) => (await term.stdin.ask(question))?.trim() ?? null;
+//# sourceMappingURL=prompt.js.map

package/dist/render/rows.js

@@ -0,0 +1,49 @@
+import { sanitizeForTerminal } from "./text.js";
+export const formatContact = (c) => `${sanitizeForTerminal(c.displayName)} · ${c.type} · ${c.id}` +
+    `${c.claimedPersonId ? ' · linked' : ''}` +
+    `${c.email ? ` · email ${sanitizeForTerminal(c.email)}` : ''}` +
+    `${c.rootBlockId ? ` · root ${c.rootBlockId}` : ''}`;
+export const formatQuestion = (q) => {
+    const lines = [`id           ${q.id}`, `createdAt    ${q.createdAt}`];
+    if (q.kind === 'share') {
+        lines.push(`shared by    @${sanitizeForTerminal(q.sharerHandle ?? '(unknown)')}`, `memory       ${q.aboutBlockId ?? '(missing)'}`, `seen         ${q.seenAt ?? '(unseen)'}`);
+        return lines.join('\n');
+    }
+    if (q.aboutBlockId)
+        lines.push(`about        ${q.aboutBlockId}`);
+    lines.push(q.closedAs === null
+        ? 'closed as    (open)'
+        : `closed as    ${sanitizeForTerminal(q.closedAs)}${q.closeBlockId ? ` → ${q.closeBlockId}` : ''}${q.closedAt ? `  ${q.closedAt}` : ''}`);
+    if (q.closeNote)
+        lines.push(`note         ${sanitizeForTerminal(q.closeNote, Infinity)}`);
+    lines.push('', sanitizeForTerminal(q.body ?? '', Infinity));
+    return lines.join('\n');
+};
+export const formatQuestionList = (qs) => qs.map((q) => formatQuestion(q)).join('\n\n');
+export const formatAsked = (q) => {
+    const lines = [`Sent question ${q.id}`];
+    if (q.aboutBlockId)
+        lines.push(`  about        ${q.aboutBlockId}`);
+    lines.push(`  createdAt    ${q.createdAt}`);
+    return lines.join('\n');
+};
+export const formatClosed = (q) => `Closed question ${q.id}  (${sanitizeForTerminal(q.closedAs ?? '')})${q.closeBlockId ? ` → ${q.closeBlockId}` : ''}`;
+export const formatEdgeReceipt = (heading, e) => [
+    `${heading}  (verb: ${sanitizeForTerminal(e.verb)})`,
+    `  from    ${e.fromBlockId}  (${e.fromType})`,
+    `  to      ${e.toBlockId}  (${e.toType})`,
+    `  reason  ${sanitizeForTerminal(e.reason, Infinity)}`
+].join('\n');
+export const formatAmendedEdge = (e) => formatEdgeReceipt('Updated edge reason.', e);
+export const formatAudiences = (audiences) => audiences.length === 0 ? '(private)' : audiences.map((a) => a.kind).join(', ');
+export const ambiguousText = (body) => {
+    if (body.code !== 'memory:ambiguous-id')
+        return '';
+    const matches = body.detail?.matches;
+    if (!Array.isArray(matches))
+        return '';
+    return matches
+        .map((m) => `  ${m.id}  ${sanitizeForTerminal(m.title ?? '(untitled)')}\n`)
+        .join('');
+};
+//# sourceMappingURL=rows.js.map

package/dist/render/text.js

@@ -0,0 +1,21 @@
+import { createHash, randomBytes } from 'node:crypto';
+export const base64url = (b) => b.toString('base64url');
+export const makePkce = () => {
+    const verifier = base64url(randomBytes(32));
+    const challenge = base64url(createHash('sha256').update(verifier).digest());
+    return { verifier, challenge };
+};
+/* eslint-disable no-control-regex */
+const ESCAPE_SEQUENCES = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[PX^_][^\x1b]*\x1b\\|\x1b\[[0-9:;<=>?]*[ -/]*[@-~]|\x1b[@-Z\\^_]/g;
+const CONTROL_CHARS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f\u0080-\u009f]/g;
+/* eslint-enable no-control-regex */
+const BIDI_FORMAT_CHARS = /[\u202a-\u202e\u2066-\u2069]/g;
+export const sanitizeForTerminal = (s, maxLen = 200) => s
+    .replace(ESCAPE_SEQUENCES, '')
+    .replace(CONTROL_CHARS, '')
+    .replace(BIDI_FORMAT_CHARS, '')
+    .slice(0, maxLen);
+export const shellQuote = (token) => `'${sanitizeForTerminal(token, Infinity).replace(/'/g, `'\\''`)}'`;
+const SAFE_HINT_TOKEN = /^[A-Za-z0-9@._:/-]+$/;
+export const renderRunHint = (argv) => ['lattris', ...argv.map((t) => (SAFE_HINT_TOKEN.test(t) ? t : shellQuote(t)))].join(' ');
+//# sourceMappingURL=text.js.map

package/dist/request/access-token.js

@@ -0,0 +1,67 @@
+import { EXIT, refusal } from "../store/exit.js";
+import { RENEWAL_TIMEOUT_MS, SessionLockHeld, WAIT_AT_MOST_MS, withSessionLock } from "../store/session-lock.js";
+import { loadSession, notLoggedInWords, saveSession } from "../store/session.js";
+import { postToken, refreshBody, toSession } from "./token.js";
+const SKEW_SECONDS = 30;
+const stillValid = (session, now) => session.expiresAt > Math.floor(now / 1000) + SKEW_SECONDS;
+const renewFrom = async (io, cfg, session) => {
+    if (!session)
+        throw new Error('not-logged-in');
+    if (stillValid(session, io.store.now()))
+        return session.accessToken;
+    if (!session.refreshToken)
+        throw new Error('not-logged-in');
+    const token = await postToken(io.network, cfg, refreshBody(cfg, session.refreshToken), io.store.timeout(RENEWAL_TIMEOUT_MS));
+    const refreshed = toSession(token, io.store.now());
+    refreshed.refreshToken = refreshed.refreshToken ?? session.refreshToken;
+    refreshed.personId = session.personId;
+    refreshed.handle = session.handle;
+    saveSession(io.store, refreshed);
+    return refreshed.accessToken;
+};
+export const validAccessToken = async (io, cfg) => {
+    const session = loadSession(io.store);
+    if (!session)
+        throw new Error('not-logged-in');
+    if (stillValid(session, io.store.now()))
+        return session.accessToken;
+    if (!session.refreshToken)
+        throw new Error('not-logged-in');
+    try {
+        return await withSessionLock(io.store, () => renewFrom(io, cfg, loadSession(io.store)), () => io.stderr.write('Waiting for another lattris command to finish renewing the sign-in…\n'));
+    }
+    catch (e) {
+        if (e instanceof SessionLockHeld)
+            throw e;
+        throw new Error('not-logged-in');
+    }
+};
+export const optionalAccessToken = async (io, cfg) => {
+    try {
+        return await io.token(cfg);
+    }
+    catch {
+        return undefined;
+    }
+};
+const notLoggedIn = (io) => ({
+    message: '',
+    exit: EXIT.NOAUTH,
+    answer: {
+        kind: 'door',
+        message: notLoggedInWords(io.store),
+        next: { action: 'login' },
+        whole: true
+    }
+});
+const gaveUpWaiting = (lock) => refusal(`Gave up after ${WAIT_AT_MOST_MS / 1000} seconds waiting for another lattris command to renew the sign-in. ` +
+    `If none is running, remove ${lock} and run this again.\n`, EXIT.GENERIC);
+export const signedIn = async (io, cfg) => {
+    try {
+        return await io.token(cfg);
+    }
+    catch (e) {
+        return e instanceof SessionLockHeld ? gaveUpWaiting(e.path) : notLoggedIn(io);
+    }
+};
+//# sourceMappingURL=access-token.js.map