lattris 0.1.4 → 0.2.0

package/dist/memory/history.js

@@ -0,0 +1,134 @@
+import { parseArgs } from "../request/flags.js";
+import { formatDeletedPage } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const formatHistoryItem = (i) => {
+    const who = i.actor.agentLabel
+        ? `${sanitizeForTerminal(i.actor.sessionId)} (${sanitizeForTerminal(i.actor.agentLabel)})`
+        : sanitizeForTerminal(i.actor.sessionId);
+    const rev = i.revisionNo === null ? '-' : `rev ${i.revisionNo}`;
+    const extra = [
+        i.restoredFromRevisionNo !== null ? `from rev ${i.restoredFromRevisionNo}` : undefined,
+        i.overwriteReason !== null ? `reason: ${sanitizeForTerminal(i.overwriteReason)}` : undefined,
+        i.baseline ? 'baseline' : undefined
+    ]
+        .filter((x) => x !== undefined)
+        .join('; ');
+    return `${i.recordedAt}  ${i.action.padEnd(12)}  ${rev.padEnd(9)}  ${who}${extra ? `  (${extra})` : ''}  ${i.operationId}`;
+};
+export const formatHistoryPage = (page, headFingerprint) => {
+    const lines = [];
+    if (headFingerprint)
+        lines.push(`head fingerprint  ${headFingerprint}`, '');
+    else
+        lines.push('head fingerprint  (not on this page)', '');
+    lines.push(...page.items.map((i) => formatHistoryItem(i)));
+    if (page.items.length === 0)
+        lines.push('(no history)');
+    lines.push('', `history starts at revision ${page.coverage.startsAtRevisionNo}` +
+        (page.coverage.baselineRecordedAt ? ` (baseline ${page.coverage.baselineRecordedAt})` : '') +
+        ` \u2014 ${sanitizeForTerminal(page.coverage.note, Infinity)}`);
+    if (page.nextBeforeOperation) {
+        lines.push(`More: --before ${page.nextBeforeOperation}`);
+    }
+    return lines.join('\n');
+};
+export const formatRevision = (r) => {
+    const lines = [
+        `revisionNo   ${r.revisionNo ?? '-'}`,
+        `fingerprint  ${r.fingerprint}`,
+        `recordedAt   ${r.recordedAt}`,
+        `action       ${r.action}`,
+        `session      ${sanitizeForTerminal(r.actor.sessionId)}${r.actor.agentLabel ? ` (${sanitizeForTerminal(r.actor.agentLabel)})` : ''}`
+    ];
+    if (r.restoredFromRevisionNo !== null)
+        lines.push(`restoredFrom rev ${r.restoredFromRevisionNo}`);
+    if (r.overwriteReason !== null)
+        lines.push(`reason       ${sanitizeForTerminal(r.overwriteReason)}`);
+    if (r.snapshot.intent)
+        lines.push(`intent       ${sanitizeForTerminal(r.snapshot.intent)}`);
+    if (r.snapshot.capturedAt)
+        lines.push(`capturedAt   ${r.snapshot.capturedAt}`);
+    if (r.snapshot.title)
+        lines.push(`title        ${sanitizeForTerminal(r.snapshot.title)}`);
+    if (r.snapshot.aiSummary)
+        lines.push(`aiSummary    ${sanitizeForTerminal(r.snapshot.aiSummary, Infinity)}`);
+    lines.push('', sanitizeForTerminal(r.snapshot.content, Infinity));
+    return lines.join('\n');
+};
+const HISTORY_FLAG_NAMES = {
+    '--limit': 'limit',
+    '--before': 'before'
+};
+export const getHistory = async (cfg, io, rest) => {
+    const { flags, positionals, unknown, notAnId } = parseArgs(HISTORY_FLAG_NAMES, rest, [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1) {
+        return refusal(`Usage: lattris get history <id> [--limit <n>] [--before <operation-id>]\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = new URL(`${cfg.apiUrl}/memories/${encodeURIComponent(positionals[0])}/revisions`);
+    if (flags.limit !== undefined)
+        url.searchParams.set('limit', flags.limit);
+    if (flags.before !== undefined)
+        url.searchParams.set('beforeOperation', flags.before);
+    const result = await io.api(accessToken, url);
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, (page) => formatHistoryPage(page, page.head?.fingerprint));
+};
+export const REVISION_NO_SHAPE = /^[1-9][0-9]{0,17}$/;
+export const getRevision = async (cfg, io, idOrPrefix, revisionNo) => {
+    if (!REVISION_NO_SHAPE.test(revisionNo)) {
+        return refusal(`--revision must be a positive number from the history: ${revisionNo}\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(idOrPrefix)}/revisions/${revisionNo}`);
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, formatRevision);
+};
+const DELETED_FLAG_NAMES = {
+    '--limit': 'limit',
+    '--cursor': 'cursor'
+};
+export const getDeleted = async (cfg, io, rest) => {
+    const { flags, positionals, unknown } = parseArgs(DELETED_FLAG_NAMES, rest);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (positionals.length > 0) {
+        return refusal(`Unexpected argument: ${positionals[0]}\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = new URL(`${cfg.apiUrl}/memories`);
+    url.searchParams.set('state', 'deleted');
+    if (flags.limit !== undefined)
+        url.searchParams.set('limit', flags.limit);
+    if (flags.cursor !== undefined)
+        url.searchParams.set('cursor', flags.cursor);
+    const result = await io.api(accessToken, url);
+    if (!result.ok)
+        return refusalOf(result);
+    emit(io, result.data, result.rawText, (page) => {
+        const lines = [formatDeletedPage(page)].filter((l) => l.length > 0);
+        if (page.nextCursor)
+            lines.push(`More: ${renderRunHint(['get', 'deleted', '--cursor', page.nextCursor])}`);
+        return lines.join('\n');
+    });
+};
+//# sourceMappingURL=history.js.map

package/dist/memory/recording-update.js

@@ -0,0 +1,128 @@
+import { parseArgs } from "../request/flags.js";
+import { RECORDING_FORMATS, TRANSCRIPT_CONVERTERS, formatRecording } from "../memory/transcript.js";
+import { emit } from "../render/output.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+const RECORDING_UPDATE_HELP = [
+    'update recording — correct a recording’s transcript or its speaker map.',
+    '',
+    'The transcript is replace-whole (turns AND the speaker map are one record);',
+    'the speaker map is the recording’s one correctable finding aid — who each',
+    'voice is.',
+    '',
+    'Usage:',
+    '  lattris update recording transcript <id> <file> [--format json|a] [--force]',
+    '  lattris update recording speakers <id> <key>=<value> [<key>=<value> …]',
+    '',
+    '  transcript   replaces the whole transcript from <file> (same converters as',
+    '               capture recording). --force is REQUIRED when the transcript is',
+    '               the recording’s ONLY substance — those words ARE the record,',
+    '               and the server refuses to replace them without it and says so.',
+    '',
+    '  speakers     corrects the map, one key=value per declared speaker key:',
+    '                 <key>=me            claim that voice as your own',
+    '                 <key>=<contact-id>  map it to one of your contacts',
+    '                 <key>=clear         remove both (back to label-only)',
+    '               A key the recording does not declare is a 404 — the map is',
+    '               corrected, never widened. Labels are the record and unreachable',
+    '               here (re-send the transcript to change a label).'
+].join('\n');
+const updateRecordingTranscript = async (cfg, io, args) => {
+    const force = args.includes('--force');
+    const { flags, positionals, unknown, notAnId } = parseArgs({ '--format': 'format' }, args.filter((a) => a !== '--force'), [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 2) {
+        return refusal('Usage: lattris update recording transcript <id> <file> [--force]\n');
+    }
+    const [id, file] = positionals;
+    const format = flags.format ?? (file.toLowerCase().endsWith('.json') ? 'json' : 'a');
+    const convert = TRANSCRIPT_CONVERTERS[format];
+    if (convert === undefined) {
+        return refusal(`Unknown --format: ${format}. Accepted: ${RECORDING_FORMATS.join(', ')}.\n`);
+    }
+    let transcript;
+    try {
+        transcript = convert(io.store.files.readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        return refusal(`Could not read or parse ${file} as --format ${format}: ${e instanceof Error ? e.message : 'invalid'}\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(id)}/transcript`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(force ? { transcript, force: true } : { transcript })
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, (r) => `Updated transcript.\n\n${formatRecording(r)}`);
+};
+export const buildSpeakerCorrection = (value) => {
+    if (value === 'me')
+        return { me: true };
+    if (value === 'clear' || value === 'none')
+        return { contactId: null };
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value))
+        return { contactId: value };
+    return null;
+};
+const updateRecordingSpeakers = async (cfg, io, args) => {
+    const { positionals, unknown, notAnId } = parseArgs({}, args, [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length < 2) {
+        return refusal('Usage: lattris update recording speakers <id> <key>=me|<contact-id>|clear [<key>=… …]\n');
+    }
+    const [id, ...pairs] = positionals;
+    const speakers = {};
+    for (const pair of pairs) {
+        const eq = pair.indexOf('=');
+        if (eq <= 0) {
+            return refusal(`Each correction is <key>=<value>: ${pair}\n`);
+        }
+        const key = pair.slice(0, eq);
+        if (Object.prototype.hasOwnProperty.call(speakers, key)) {
+            return refusal(`speaker "${key}" given twice — one correction per speaker per call.\n`);
+        }
+        const correction = buildSpeakerCorrection(pair.slice(eq + 1));
+        if (correction === null) {
+            return refusal(`${key}: a correction is me, a contact id (full UUID), or clear — not "${pair.slice(eq + 1)}".\n`);
+        }
+        speakers[key] = correction;
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(id)}/speakers`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ speakers })
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, (r) => `Updated speakers.\n\n${formatRecording(r)}`);
+};
+export const updateRecording = async (cfg, io, rest) => {
+    const sub = rest[0];
+    if (sub === 'transcript') {
+        return updateRecordingTranscript(cfg, io, rest.slice(1));
+    }
+    if (sub === 'speakers') {
+        return updateRecordingSpeakers(cfg, io, rest.slice(1));
+    }
+    io.stdout.write(`${RECORDING_UPDATE_HELP}\n`);
+    if (sub !== undefined)
+        return refusal('', EXIT.USAGE);
+};
+//# sourceMappingURL=recording-update.js.map

package/dist/memory/recording.js

@@ -0,0 +1,249 @@
+import { createHash } from 'node:crypto';
+import { parseArgs } from "../request/flags.js";
+import { HELP_TOKENS } from "../request/flags.js";
+import { RECORDING_FORMATS, TRANSCRIPT_CONVERTERS, buildRecordingBody, formatRecording, mimeForAudio } from "../memory/transcript.js";
+import { SHARE_AUDIENCES } from "../memory/capture-common.js";
+import { emit } from "../render/output.js";
+import { confirmAction } from "../render/prompt.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { classifyApiError, parseErrorBody } from "../request/door.js";
+import { putToSignedUploadUrl } from "../request/upload.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+export const CAPTURE_RECORDING_HELP = `capture recording — keep an audio recording, its source, and its transcript.
+
+A recording stands on any of THREE substances, at least one:
+  • held audio    the file itself (--audio) — uploaded, then confirmed
+  • a source      where it lives elsewhere (--source-url)
+  • a transcript  the words (a file, in a format the CLI converts)
+
+The API meets ONE transcript shape; vendor formats convert HERE. Formats:
+  json   the file is already {speakers, turns, …} — passed through
+  a      a plain transcript, one turn per line as \`Label: text\`; a line with
+         no colon continues the turn above it
+
+Usage:
+  lattris capture recording <transcript-file> --format a --title "…"
+  lattris capture recording <transcript.json> --format json
+  lattris capture recording --audio talk.m4a --title "…"
+  lattris capture recording --source-url https://… --source-name "…"
+
+  <transcript-file>   optional; the transcript to convert (--format picks how)
+  --format <name>     json | a  (default json when the file ends .json)
+  --audio <path>      the audio file to hold — its size and sha256 are computed
+                      locally, the type comes from the extension (or --mime-type)
+  --mime-type <type>  override the audio content type (an unknown extension)
+  --source-url <url>  where the recording lives, if referenced not held
+  --source-name <s>   the source's name        --title <s>          one line, what it is
+  --title-at-source   its title at the source  --creator <s>        who made it (text)
+  --published-at <t>  when the source published it (ISO 8601)
+  --captured-at <t>   when it was recorded (ISO 8601; the future is refused)
+  --duration <n>      length in seconds
+  --span <uuid>       group it into one of your spans
+  --share-with public make it public immediately
+  --contributor <id>  whose expression it is — a contact id
+  --allow-banned-words  keep a flagged word in the title deliberately
+
+saved → prints the id, what it stands on, and the address. Held audio uploads
+the bytes and confirms before the receipt.`;
+const RECORDING_FLAG_NAMES = {
+    '--format': 'format',
+    '--audio': 'audio',
+    '--mime-type': 'mimeType',
+    '--source-url': 'sourceUrl',
+    '--source-name': 'sourceName',
+    '--title': 'title',
+    '--title-at-source': 'titleAtSource',
+    '--creator': 'creator',
+    '--published-at': 'publishedAt',
+    '--captured-at': 'capturedAt',
+    '--duration': 'duration',
+    '--span': 'span',
+    '--share-with': 'shareWith',
+    '--contributor': 'contributor'
+};
+export const captureRecording = async (cfg, io, args) => {
+    if (args.length === 0 || args.some((t) => HELP_TOKENS.has(t))) {
+        io.stdout.write(`${CAPTURE_RECORDING_HELP}\n`);
+        return;
+    }
+    const allowBanned = args.includes('--allow-banned-words');
+    const yes = args.includes('--yes');
+    const { flags, positionals, unknown } = parseArgs(RECORDING_FLAG_NAMES, args.filter((a) => a !== '--allow-banned-words' && a !== '--yes'));
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (positionals.length > 1) {
+        return refusal(`Unexpected argument: ${positionals[1]}\n`);
+    }
+    const transcriptFile = positionals[0];
+    if (flags.shareWith !== undefined &&
+        !SHARE_AUDIENCES.includes(flags.shareWith)) {
+        return refusal(`Unknown audience: ${flags.shareWith}. Accepted: ${SHARE_AUDIENCES.join(', ')}\n`);
+    }
+    if (flags.shareWith !== undefined && !io.stdin.isTTY && !yes) {
+        return refusal('This will save the recording AND make it public — anyone, including people ' +
+            'without accounts. There is no prompt here (the content already arrived on ' +
+            'a pipe) — pass --yes once the person has confirmed both facts.\n');
+    }
+    if (transcriptFile === undefined && flags.audio === undefined && flags.sourceUrl === undefined) {
+        return refusal('A recording needs at least one of: a transcript file, --audio, or --source-url.\n');
+    }
+    let transcript;
+    if (transcriptFile !== undefined) {
+        const format = flags.format ?? (transcriptFile.toLowerCase().endsWith('.json') ? 'json' : 'a');
+        const convert = TRANSCRIPT_CONVERTERS[format];
+        if (convert === undefined) {
+            return refusal(`Unknown --format: ${format}. Accepted: ${RECORDING_FORMATS.join(', ')}.\n`);
+        }
+        let raw;
+        try {
+            raw = io.store.files.readFileSync(transcriptFile, 'utf8');
+        }
+        catch {
+            return refusal(`Cannot read transcript file: ${transcriptFile}\n`);
+        }
+        try {
+            transcript = convert(raw);
+        }
+        catch (e) {
+            return refusal(`Could not parse ${transcriptFile} as --format ${format}: ${e instanceof Error ? e.message : 'invalid'}\n`);
+        }
+    }
+    let upload;
+    let audioBytes;
+    if (flags.audio !== undefined) {
+        const mimeType = mimeForAudio(flags.audio, flags.mimeType);
+        if (mimeType === null) {
+            return refusal(`Can't tell the audio type of ${flags.audio} from its extension — pass --mime-type <type>.\n`);
+        }
+        try {
+            audioBytes = io.store.files.readFileSync(flags.audio);
+        }
+        catch {
+            return refusal(`Cannot read audio file: ${flags.audio}\n`);
+        }
+        upload = {
+            filename: flags.audio.slice(flags.audio.lastIndexOf('/') + 1),
+            mimeType,
+            size: audioBytes.length,
+            sha256: createHash('sha256').update(audioBytes).digest('hex')
+        };
+    }
+    if (flags.duration !== undefined && !/^\d+$/.test(flags.duration)) {
+        return refusal(`--duration must be a whole number of seconds: ${flags.duration}\n`);
+    }
+    const body = buildRecordingBody({
+        transcript,
+        upload,
+        sourceUrl: flags.sourceUrl,
+        title: flags.title,
+        capturedAt: flags.capturedAt,
+        spanId: flags.span,
+        audience: flags.shareWith,
+        contributor: flags.contributor,
+        sourceName: flags.sourceName,
+        titleAtSource: flags.titleAtSource,
+        creator: flags.creator,
+        publishedAt: flags.publishedAt,
+        durationSeconds: flags.duration === undefined ? undefined : Number(flags.duration),
+        allowBannedWords: allowBanned
+    });
+    if (flags.shareWith !== undefined && io.stdin.isTTY) {
+        const answer = await confirmAction(io, `Share "${sanitizeForTerminal(flags.title ?? '(untitled)')}" with public — anyone, including people without accounts? [y/N] `);
+        if (answer === 'interrupted')
+            return refusal('Cancelled.\n', EXIT.GENERIC);
+        if (answer === 'no') {
+            io.stderr.write('Cancelled.\n');
+            return;
+        }
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const created = await io.api(accessToken, `${cfg.apiUrl}/memories/recordings`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+    });
+    if (!created.ok)
+        return refusalOf(created);
+    if ('signedUploadUrl' in created.data) {
+        const pending = created.data;
+        const putOnce = async () => {
+            try {
+                const res = await putToSignedUploadUrl(io.network, pending.signedUploadUrl, upload.mimeType, new Uint8Array(audioBytes));
+                if (res.ok)
+                    return { ok: true };
+                return {
+                    ok: false,
+                    why: res.status === 403
+                        ? 'the signed upload URL was rejected (it may have expired)'
+                        : `HTTP ${res.status}`
+                };
+            }
+            catch (e) {
+                return { ok: false, why: e instanceof Error ? e.message : 'a network error' };
+            }
+        };
+        let put = await putOnce();
+        if (!put.ok)
+            put = await putOnce();
+        if (!put.ok) {
+            return refusal(`The recording was reserved (${pending.block.id}) but the audio upload failed — ${put.why}.\n` +
+                `That reservation has no confirmed audio and is cleared server-side; running the capture ` +
+                `again creates a NEW recording — it does not adopt this one.\n`, EXIT.GENERIC);
+        }
+        const confirmUrl = `${cfg.apiUrl}/memories/${encodeURIComponent(pending.block.id)}/confirm`;
+        const confirmOnce = async () => {
+            try {
+                const res = await io.api(accessToken, confirmUrl, { method: 'POST' });
+                const rawText = res.rawText;
+                if (res.ok || res.answer.kind === 'page')
+                    return { kind: 'ok', data: JSON.parse(rawText), rawText };
+                return { kind: 'http', status: res.status, rawText };
+            }
+            catch (e) {
+                return { kind: 'transport', message: e instanceof Error ? e.message : 'a network error' };
+            }
+        };
+        let confirmed = await confirmOnce();
+        const firstLost = confirmed.kind === 'transport';
+        if (firstLost)
+            confirmed = await confirmOnce();
+        if (confirmed.kind === 'ok') {
+            emit(io, confirmed.data, confirmed.rawText, formatRecording);
+            return;
+        }
+        if (firstLost) {
+            try {
+                const probe = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(pending.block.id)}`);
+                if (probe.ok) {
+                    const rawText = probe.rawText;
+                    const rec = JSON.parse(rawText);
+                    if (rec.media != null) {
+                        emit(io, rec, rawText, formatRecording);
+                        return;
+                    }
+                }
+            }
+            catch { }
+        }
+        if (confirmed.kind === 'http') {
+            const { message, next, exit } = classifyApiError(confirmed.status, parseErrorBody(confirmed.rawText));
+            return {
+                message: `The recording was reserved (${pending.block.id}); the audio uploaded but the confirm did ` +
+                    `not land. That reservation is incomplete and cleared server-side; running the capture ` +
+                    `again creates a NEW recording — it does not finish this one.\n`,
+                exit,
+                answer: { kind: 'door', message, next }
+            };
+        }
+        return refusal(`The audio uploaded but confirming the recording (${pending.block.id}) failed — ${confirmed.message}.\n` +
+            `That reservation is incomplete and cleared server-side; running the capture again creates ` +
+            `a NEW recording — it does not finish this one.\n`, EXIT.GENERIC);
+    }
+    emit(io, created.data, created.rawText, formatRecording);
+};
+//# sourceMappingURL=recording.js.map

package/dist/memory/resend.js

@@ -0,0 +1,82 @@
+import { HELP_TOKENS } from "../request/flags.js";
+import { formatSaved } from "../memory/capture-common.js";
+import { formatBlockLine, formatMemoryDetail } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { AGENT_LABEL_SHAPE, SESSION_ID_SHAPE, isUuidKey, noteWriteHeaders } from "../store/write-identity.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const RESEND_HELP = [
+    'resend — send a kept request again, exactly: the same door, the same session, the same',
+    'key, the same body. What a lost response on `capture memory` or `update memory --overwrite`',
+    'leaves under drafts/ in the machine dir.',
+    '',
+    'Usage:',
+    '  lattris resend <path-to-request.json>',
+    '',
+    'If the first attempt landed, the door answers the same receipt and writes nothing; if it',
+    'did not, the write happens now, once. The file’s own session is used, whatever',
+    'LATTRIS_SESSION_ID says here.'
+].join('\n');
+const RESEND_DOORS = /^(POST \/memories\/notes|PATCH \/memories\/[^/\s]+)$/;
+export const resend = async (cfg, io, args) => {
+    if (args.length === 0 || args.some((t) => HELP_TOKENS.has(t))) {
+        io.stdout.write(`${RESEND_HELP}\n`);
+        if (args.length > 0 && !args.some((t) => HELP_TOKENS.has(t)))
+            return refusal('', EXIT.USAGE);
+        return;
+    }
+    if (args.length !== 1) {
+        return refusal('Usage: lattris resend <path-to-request.json>\n');
+    }
+    let draft;
+    try {
+        draft = JSON.parse(io.store.files.readFileSync(args[0], 'utf8'));
+    }
+    catch (e) {
+        return refusal(`Could not read a kept request at ${args[0]}: ${sanitizeForTerminal(e instanceof Error ? e.message : String(e))}\n`);
+    }
+    if (typeof draft !== 'object' ||
+        draft === null ||
+        typeof draft.door !== 'string' ||
+        !RESEND_DOORS.test(draft.door) ||
+        typeof draft.idempotencyKey !== 'string' ||
+        !isUuidKey(draft.idempotencyKey) ||
+        typeof draft.sessionId !== 'string' ||
+        !SESSION_ID_SHAPE.test(draft.sessionId) ||
+        typeof draft.body !== 'object' ||
+        draft.body === null) {
+        return refusal(`${args[0]} is not a kept request (door, idempotencyKey, sessionId and body are what one carries).\n`);
+    }
+    if (draft.agentLabel !== undefined &&
+        (typeof draft.agentLabel !== 'string' || !AGENT_LABEL_SHAPE.test(draft.agentLabel))) {
+        return refusal(`The kept request at ${args[0]} names the agent label "${sanitizeForTerminal(String(draft.agentLabel))}", ` +
+            'which a request header cannot carry: an agent label is 1 to 128 printable ASCII characters. ' +
+            'Nothing was sent.\n');
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const [method, path] = draft.door.split(' ');
+    const identity = { sessionId: draft.sessionId, agentLabel: draft.agentLabel };
+    const result = await io.api(accessToken, `${cfg.apiUrl}${path}`, {
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+            ...noteWriteHeaders(identity, draft.idempotencyKey)
+        },
+        body: JSON.stringify(draft.body)
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    if (method === 'POST') {
+        io.stdout.write(`${formatSaved(result.data)}\n`);
+        return;
+    }
+    emit(io, result.data, result.rawText, (m) => 'visibility' in m
+        ? `Resent.\n\n${formatBlockLine(m)}`
+        : `Resent.\n\n${formatMemoryDetail(m)}`);
+};
+//# sourceMappingURL=resend.js.map

package/dist/memory/restore.js

@@ -0,0 +1,73 @@
+import { parseArgs } from "../request/flags.js";
+import { REVISION_NO_SHAPE } from "../memory/history.js";
+import { FINGERPRINT_SHAPE } from "../memory/update-help.js";
+import { composeAddressFor, formatMemoryDetail } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { noteWriteHeaders, requireWriteIdentity } from "../store/write-identity.js";
+import { isRefusal, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const RESTORE_HELP = [
+    'restore — bring a note back from deleted items, or bring an earlier revision back as the head.',
+    '',
+    'Usage:',
+    '  lattris restore memory <id-or-prefix> --revision <n> --base-fingerprint <head> [--clear-missing]',
+    '',
+    '  --revision          required; the revision to bring back, from `lattris get history <id>`.',
+    '                      The note\u2019s own current number un-archives it with its last words.',
+    '  --base-fingerprint  required; the head fingerprint history printed. A head that moved',
+    '                      since is refused and nothing changes.',
+    '  --clear-missing     restore even when the revision names a span or contact that no',
+    '                      longer exists, clearing those references; without it the door',
+    '                      refuses and names them.',
+    '',
+    'History is never rewritten: restoring earlier words appends them as a new revision',
+    'that says where it came from. A note back from deleted items returns private.'
+].join('\n');
+const RESTORE_FLAG_NAMES = {
+    '--revision': 'revision',
+    '--base-fingerprint': 'baseFingerprint'
+};
+export const restoreMemory = async (cfg, io, rest) => {
+    const clearMissing = rest.includes('--clear-missing');
+    const { flags, positionals, unknown, notAnId } = parseArgs(RESTORE_FLAG_NAMES, rest.filter((a) => a !== '--clear-missing'), [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1 ||
+        flags.revision === undefined ||
+        flags.baseFingerprint === undefined) {
+        return refusal(`Usage: lattris restore memory <id> --revision <n> --base-fingerprint <head>\n`);
+    }
+    if (!REVISION_NO_SHAPE.test(flags.revision)) {
+        return refusal(`--revision must be a positive number from the history: ${flags.revision}\n`);
+    }
+    if (!FINGERPRINT_SHAPE.test(flags.baseFingerprint)) {
+        return refusal(`--base-fingerprint must be the 64 lowercase hex characters history printed: ${flags.baseFingerprint}\n`);
+    }
+    const identity = requireWriteIdentity(io.store, io.stdin.isTTY);
+    if (isRefusal(identity))
+        return identity;
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(positionals[0])}/restore`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...noteWriteHeaders(identity) },
+        body: JSON.stringify({
+            revisionNo: flags.revision,
+            baseFingerprint: flags.baseFingerprint,
+            ...(clearMissing ? { missingReferences: 'clear' } : {})
+        })
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    let address;
+    if (io.stdout.isTTY)
+        address = await composeAddressFor(cfg, io, accessToken, result.data);
+    emit(io, result.data, result.rawText, (m) => `Restored.\n\n${formatMemoryDetail(m, address)}`);
+};
+//# sourceMappingURL=restore.js.map