@assethub/cli 0.1.29 → 0.1.31

package/dist/hooks/save.js

@@ -0,0 +1,330 @@
+// The hook body: copy + redact the transcript, collect images, prune old
+// sessions, and on SessionEnd start the upload in a detached process. Never throws.
+import { spawn } from 'node:child_process';
+import { chmod, copyFile, readFile, readdir, realpath, rm, stat } from 'node:fs/promises';
+import { basename, dirname, extname, join, resolve, sep } from 'node:path';
+import { PRIVATE_FILE_MODE, ensurePrivateDir, listSessionDirs, logError, readMeta, sessionsRoot, updateMeta, writePrivateFileAtomic, } from './paths.js';
+import { redactJsonl } from './redact.js';
+import { TRANSCRIPT_FORMAT, trimTranscript } from './trim.js';
+import { extractImagePaths } from './transcript.js';
+export const MAX_IMAGES = 50;
+export const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+export const DEFAULT_RETENTION_DAYS = 30;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+};
+const spawnCli = (args, profile) => {
+    const script = process.argv[1];
+    if (!script)
+        return;
+    const argv = [script, ...args];
+    if (profile)
+        argv.push('--profile', profile);
+    const child = spawn(process.execPath, argv, { detached: true, stdio: 'ignore' });
+    child.on('error', () => { });
+    child.unref();
+};
+/** SessionEnd: upload this session, then retry up to SWEEP_LIMIT older pending ones. */
+export const spawnDetachedUpload = (sessionDir, profile) => spawnCli(['hooks', 'upload', '--session', sessionDir, '--auto', '--sweep', String(SWEEP_LIMIT)], profile);
+/** SessionStart: retry up to SWEEP_LIMIT pending sessions. */
+export const spawnDetachedSweep = (profile) => spawnCli(['hooks', 'upload', '--pending', '--limit', String(SWEEP_LIMIT)], profile);
+export const retentionDays = (env) => {
+    const raw = env.ASSETHUB_SESSION_RETENTION_DAYS?.trim();
+    if (!raw)
+        return DEFAULT_RETENTION_DAYS;
+    if (raw === 'off' || raw === '0')
+        return null;
+    const days = Number(raw);
+    return Number.isFinite(days) && days > 0 ? days : DEFAULT_RETENTION_DAYS;
+};
+/** Delete saved sessions last written more than `days` ago, whatever their upload state. */
+export const pruneSessions = async (root, now, days, keep) => {
+    let removed = 0;
+    let names;
+    try {
+        names = await readdir(root);
+    }
+    catch {
+        return 0;
+    }
+    for (const name of names) {
+        const dir = join(root, name);
+        if (dir === keep)
+            continue;
+        try {
+            const info = await stat(dir);
+            if (!info.isDirectory())
+                continue;
+            const meta = await readMeta(dir);
+            const savedAt = meta?.savedAt ? new Date(meta.savedAt).getTime() : info.mtimeMs;
+            if (now.getTime() - savedAt <= days * DAY_MS)
+                continue;
+            await rm(dir, { recursive: true, force: true });
+            removed += 1;
+        }
+        catch {
+            // leave anything we cannot read
+        }
+    }
+    return removed;
+};
+const optedOut = async (cwd, env) => {
+    if (env.ASSETHUB_SESSION_SAVE === 'off')
+        return true;
+    let dir = resolve(cwd);
+    for (;;) {
+        try {
+            await stat(join(dir, '.assethub', 'no-session-save'));
+            return true;
+        }
+        catch {
+            // keep walking
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+};
+const readCanvasId = async (cwd, env) => {
+    if (env.ASSETHUB_CANVAS?.trim())
+        return env.ASSETHUB_CANVAS.trim();
+    try {
+        return (await readFile(join(cwd, '.assethub', 'canvas'), 'utf8')).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const safeId = (value) => value.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 100);
+// `<yyyy-mm-dd>_<id>`: match the id exactly, so session `b` never adopts the
+// directory of session `a_b`.
+const SESSION_DIR_DATE = /^\d{4}-\d{2}-\d{2}_/;
+const findSessionDir = async (root, id, date) => {
+    try {
+        const existing = (await readdir(root)).find(name => SESSION_DIR_DATE.test(name) && name.slice(11) === id);
+        if (existing)
+            return join(root, existing);
+    }
+    catch {
+        // root does not exist yet
+    }
+    return join(root, `${date}_${id}`);
+};
+const collectImages = async (sessionDir, transcript, cwd) => {
+    const images = [];
+    let realCwd;
+    try {
+        realCwd = await realpath(cwd);
+    }
+    catch {
+        return images;
+    }
+    for (const original of extractImagePaths(transcript)) {
+        if (images.length >= MAX_IMAGES)
+            break;
+        try {
+            const real = await realpath(original);
+            if (real !== realCwd && !real.startsWith(realCwd + sep))
+                continue;
+            const info = await stat(real);
+            if (!info.isFile() || info.size > MAX_IMAGE_BYTES)
+                continue;
+            const file = `${String(images.length).padStart(3, '0')}-${safeId(basename(real))}`;
+            await ensurePrivateDir(join(sessionDir, 'images'));
+            await copyFile(real, join(sessionDir, 'images', file));
+            await chmod(join(sessionDir, 'images', file), PRIVATE_FILE_MODE);
+            images.push({
+                original,
+                file,
+                size: info.size,
+                mime: MIME_BY_EXT[extname(real).toLowerCase()] ?? 'application/octet-stream',
+            });
+        }
+        catch {
+            // missing or unreadable: skip
+        }
+    }
+    return images;
+};
+/** A session with no hook for this long, and never ended, was abandoned (crash, killed terminal). */
+export const ABANDONED_AFTER_MS = 2 * 60 * 60 * 1000;
+/** Sessions retried in the background per SessionStart / SessionEnd. */
+export const SWEEP_LIMIT = 3;
+/** Events that copy and redact the transcript now; the rest only mark it changed. */
+const FULL_SAVE_EVENTS = new Set(['SessionEnd', 'Manual']);
+/**
+ * Copy + redact the transcript Claude Code keeps at `meta.transcriptPath`, and
+ * collect its images. Runs once per SessionEnd and before an upload, never per
+ * turn. A copy shorter than the saved one is an older read (a transcript only
+ * grows) and never replaces it.
+ */
+export const materializeSession = async (sessionDir, options = {}) => {
+    const meta = await readMeta(sessionDir);
+    if (!meta)
+        return null;
+    const source = options.transcriptPath ?? meta.transcriptPath;
+    const target = join(sessionDir, 'transcript.jsonl');
+    // A copy an older CLI saved holds the whole transcript: it is trimmed once,
+    // even though that makes it shorter.
+    const legacy = meta.transcriptFormat !== TRANSCRIPT_FORMAT;
+    let raw;
+    let fromLive = source != null;
+    try {
+        raw = await readFile(source ?? target, 'utf8');
+    }
+    catch {
+        // Claude Code already cleaned it up: keep our copy, trimmed if it is old.
+        if (!legacy || source == null)
+            return meta;
+        try {
+            raw = await readFile(target, 'utf8');
+        }
+        catch {
+            return meta;
+        }
+        fromLive = false;
+    }
+    // Only the conversation is kept, then recognised secrets in it are masked.
+    // Our own copy is already masked; trimming it again changes nothing.
+    const redacted = fromLive ? redactJsonl(trimTranscript(raw)) : trimTranscript(raw);
+    // Compare the live transcript before masking: masking rules can change
+    // between CLI versions, so a newer masked copy may be shorter.
+    const sourceBytes = Buffer.byteLength(raw, 'utf8');
+    if (!legacy) {
+        if (fromLive && meta.sourceBytes != null) {
+            if (sourceBytes < meta.sourceBytes)
+                return meta;
+        }
+        else {
+            const savedLength = await stat(target).then(info => info.size, () => -1);
+            if (Buffer.byteLength(redacted, 'utf8') < savedLength)
+                return meta;
+        }
+    }
+    await writePrivateFileAtomic(target, redacted);
+    const images = fromLive ? await collectImages(sessionDir, raw, meta.cwd) : undefined;
+    return updateMeta(sessionDir, meta, latest => ({
+        ...latest,
+        ...(images ? { images } : {}),
+        dirty: false,
+        ...(fromLive ? { sourceBytes } : {}),
+        transcriptFormat: TRANSCRIPT_FORMAT,
+    }));
+};
+/**
+ * On SessionStart: a session that never reached SessionEnd and has been quiet
+ * for ABANDONED_AFTER_MS is marked for upload, so a crash or a killed terminal
+ * does not lose it.
+ */
+export const markAbandonedSessions = async (root, now, currentSessionId) => {
+    let marked = 0;
+    let names;
+    try {
+        names = await readdir(root);
+    }
+    catch {
+        return 0;
+    }
+    for (const name of names) {
+        const dir = join(root, name);
+        const meta = await readMeta(dir);
+        if (!meta || meta.status !== 'saved' || meta.sessionId === currentSessionId)
+            continue;
+        if (now.getTime() - new Date(meta.savedAt).getTime() < ABANDONED_AFTER_MS)
+            continue;
+        await updateMeta(dir, meta, latest => latest.status === 'saved' ? { ...latest, status: 'pending-upload', abandoned: true } : latest);
+        marked += 1;
+    }
+    return marked;
+};
+export const saveSession = async (options = {}) => {
+    const env = options.env ?? process.env;
+    try {
+        let input = options.input;
+        if (!input && options.stdin?.trim())
+            input = JSON.parse(options.stdin);
+        const event = input?.hook_event_name ?? 'unknown';
+        const now = (options.now ?? (() => new Date()))();
+        const root = sessionsRoot(options.home);
+        const uploadOn = env.ASSETHUB_SESSION_UPLOAD !== 'off';
+        // SessionStart: pick up what earlier sessions left behind, record nothing.
+        if (event === 'SessionStart') {
+            const cwd = input?.cwd ?? process.cwd();
+            if (await optedOut(cwd, env))
+                return { sessionDir: '', skipped: 'opt-out', event };
+            const result = { sessionDir: '', event };
+            result.abandoned = await markAbandonedSessions(root, now, input?.session_id);
+            const days = retentionDays(env);
+            if (days != null)
+                result.pruned = await pruneSessions(root, now, days, '');
+            if (uploadOn && (await listSessionDirs(options.home)).length > 0) {
+                ;
+                (options.startSweep ?? spawnDetachedSweep)(options.upload?.profile);
+                result.uploadStarted = true;
+            }
+            return result;
+        }
+        if (!input?.session_id || !input.transcript_path)
+            return { sessionDir: '', skipped: 'no-input', event };
+        const cwd = input.cwd ?? process.cwd();
+        if (await optedOut(cwd, env))
+            return { sessionDir: '', skipped: 'opt-out', event };
+        const id = safeId(input.session_id);
+        const sessionDir = await findSessionDir(root, id, now.toISOString().slice(0, 10));
+        await ensurePrivateDir(root);
+        await ensurePrivateDir(sessionDir);
+        const canvasId = await readCanvasId(cwd, env);
+        const sessionId = input.session_id;
+        const transcriptPath = input.transcript_path;
+        const full = FULL_SAVE_EVENTS.has(event);
+        const fresh = {
+            sessionId,
+            cwd,
+            client: 'claude',
+            lastEvent: event,
+            savedAt: now.toISOString(),
+            status: 'saved',
+            images: [],
+        };
+        // Stop and PreCompact only record that the session moved on: cheap, and
+        // nothing to race. Decide from the meta as it is now.
+        await updateMeta(sessionDir, fresh, latest => ({
+            ...latest,
+            sessionId,
+            cwd,
+            client: 'claude',
+            transcriptPath,
+            lastEvent: event,
+            savedAt: now.toISOString(),
+            canvasId: canvasId ?? latest.canvasId,
+            dirty: true,
+            // An already-uploaded session that grew needs a new revision.
+            status: event === 'SessionEnd' || latest.status === 'uploaded'
+                ? 'pending-upload'
+                : (latest.status ?? 'saved'),
+        }));
+        if (full)
+            await materializeSession(sessionDir, { env, transcriptPath });
+        const result = { sessionDir, event };
+        if (event === 'SessionEnd') {
+            const days = retentionDays(env);
+            if (days != null)
+                result.pruned = await pruneSessions(root, now, days, sessionDir);
+            if (uploadOn) {
+                ;
+                (options.startUpload ?? spawnDetachedUpload)(sessionDir, options.upload?.profile);
+                result.uploadStarted = true;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        await logError(options.home, error);
+        return { sessionDir: '' };
+    }
+};

package/dist/hooks/transcript.d.ts

@@ -0,0 +1,23 @@
+export type TranscriptItem = {
+    kind: 'prompt';
+    text: string;
+    timestamp?: string;
+} | {
+    kind: 'assistant';
+    text: string;
+    timestamp?: string;
+} | {
+    kind: 'tool';
+    toolUseId: string;
+    toolName: string;
+    input: unknown;
+    timestamp?: string;
+};
+export type ParsedTranscript = {
+    items: TranscriptItem[];
+    /** tool_use id -> absolute image paths seen in its tool_result. */
+    resultImages: Map<string, string[]>;
+};
+export declare const extractImagePaths: (text: string) => string[];
+export declare const parseTranscript: (raw: string) => ParsedTranscript;
+//# sourceMappingURL=transcript.d.ts.map

package/dist/hooks/transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../src/hooks/transcript.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,cAAc,GACtB;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,GAClD;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,GACrD;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,CAAA;AAE3F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB,mEAAmE;IACnE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CACpC,CAAA;AAID,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,MAAM,EAGtD,CAAA;AAgBD,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,KAAG,gBAiD7C,CAAA"}

package/dist/hooks/transcript.js

@@ -0,0 +1,74 @@
+// Parse a Claude Code transcript (JSONL) into the flat sequence the session
+// graph is built from.
+const IMAGE_PATH_RE = /(?<![\w.~-])(?:\/[^\s"'\\<>|:*?`()[\]{}]+)+\.(?:png|jpe?g|webp)\b/gi;
+export const extractImagePaths = (text) => {
+    const found = text.match(IMAGE_PATH_RE) ?? [];
+    return [...new Set(found)];
+};
+const isObject = (value) => value != null && typeof value === 'object' && !Array.isArray(value);
+const textOf = (content) => {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map(block => isObject(block) && block.type === 'text' && typeof block.text === 'string' ? block.text : '')
+        .filter(Boolean)
+        .join('\n');
+};
+export const parseTranscript = (raw) => {
+    const items = [];
+    const resultImages = new Map();
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isObject(entry) || !isObject(entry.message))
+            continue;
+        const timestamp = typeof entry.timestamp === 'string' ? entry.timestamp : undefined;
+        const content = entry.message.content;
+        if (entry.type === 'user') {
+            if (entry.isMeta === true)
+                continue;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (isObject(block) &&
+                        block.type === 'tool_result' &&
+                        typeof block.tool_use_id === 'string') {
+                        const paths = extractImagePaths(JSON.stringify(block.content ?? ''));
+                        if (paths.length)
+                            resultImages.set(block.tool_use_id, paths);
+                    }
+                }
+            }
+            const text = textOf(content).trim();
+            if (text)
+                items.push({ kind: 'prompt', text, timestamp });
+        }
+        else if (entry.type === 'assistant') {
+            const text = textOf(content).trim();
+            if (text)
+                items.push({ kind: 'assistant', text, timestamp });
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (isObject(block) && block.type === 'tool_use' && typeof block.id === 'string') {
+                        items.push({
+                            kind: 'tool',
+                            toolUseId: block.id,
+                            toolName: typeof block.name === 'string' ? block.name : 'unknown',
+                            input: block.input ?? {},
+                            timestamp,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { items, resultImages };
+};

package/dist/hooks/trim.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Recorded in a session's meta once its copy holds only the conversation. A
+ * copy without it was saved by an older CLI and is trimmed before upload.
+ */
+export declare const TRANSCRIPT_FORMAT = "conversation-v1";
+type Json = Record<string, unknown>;
+/** One transcript entry reduced to what the conversation needs, or undefined to drop it. */
+export declare const trimTranscriptEntry: (entry: unknown) => Json | undefined;
+/**
+ * Trim a JSONL transcript. A file that is not a Claude Code transcript (for
+ * example a Codex rollout saved by hand) is returned unchanged.
+ */
+export declare const trimTranscript: (raw: string) => string;
+export {};
+//# sourceMappingURL=trim.d.ts.map

package/dist/hooks/trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim.d.ts","sourceRoot":"","sources":["../../src/hooks/trim.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,oBAAoB,CAAA;AAElD,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAuDnC,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,IAAI,GAAG,SAqB3D,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,KAAG,MAc5C,CAAA"}

package/dist/hooks/trim.js

@@ -0,0 +1,108 @@
+// Keep only the conversation from a Claude Code transcript before it is saved
+// or uploaded: the artist's prompts, the agent's replies, its tool calls and
+// their results, and compaction summaries. Everything else Claude Code writes
+// to the file (skill, tool and agent listings, the system prompt, hook
+// context, the environment, the signed-in email, file-history snapshots) is
+// dropped. So is per-line bookkeeping such as the working directory, git
+// branch, token usage and thinking blocks. Image pixels are saved separately,
+// so an inline image keeps only its media type.
+/**
+ * Recorded in a session's meta once its copy holds only the conversation. A
+ * copy without it was saved by an older CLI and is trimmed before upload.
+ */
+export const TRANSCRIPT_FORMAT = 'conversation-v1';
+const isObject = (value) => value != null && typeof value === 'object' && !Array.isArray(value);
+/** Line types a Claude Code transcript uses; any of them marks the file as one. */
+const CLAUDE_LINE_TYPES = new Set([
+    'user',
+    'assistant',
+    'summary',
+    'system',
+    'attachment',
+    'queue-operation',
+    'file-history-snapshot',
+    'last-prompt',
+]);
+// Claude Code can append context (for example CLAUDE.md) inside a message.
+const SYSTEM_REMINDER = /<system-reminder>[\s\S]*?<\/system-reminder>\s*/g;
+const cleanText = (text) => text.replace(SYSTEM_REMINDER, '');
+const cleanBlock = (block) => {
+    if (!isObject(block))
+        return undefined;
+    switch (block.type) {
+        case 'text': {
+            const text = cleanText(typeof block.text === 'string' ? block.text : '');
+            return text.trim() ? { type: 'text', text } : undefined;
+        }
+        case 'tool_use':
+            return { type: 'tool_use', id: block.id, name: block.name, input: block.input ?? {} };
+        case 'tool_result':
+            return {
+                type: 'tool_result',
+                tool_use_id: block.tool_use_id,
+                ...(block.is_error === true ? { is_error: true } : {}),
+                content: cleanContent(block.content) ?? '',
+            };
+        case 'image': {
+            const source = isObject(block.source) ? block.source : {};
+            return { type: 'image', ...(typeof source.media_type === 'string' ? { media_type: source.media_type } : {}) };
+        }
+        default:
+            // thinking, redacted_thinking and anything else that is not conversation
+            return undefined;
+    }
+};
+const cleanContent = (content) => {
+    if (typeof content === 'string')
+        return cleanText(content);
+    if (!Array.isArray(content))
+        return undefined;
+    return content.map(cleanBlock).filter((block) => block !== undefined);
+};
+const isEmpty = (content) => content === undefined || (typeof content === 'string' ? !content.trim() : content.length === 0);
+/** One transcript entry reduced to what the conversation needs, or undefined to drop it. */
+export const trimTranscriptEntry = (entry) => {
+    if (!isObject(entry))
+        return undefined;
+    if (entry.type === 'summary' && typeof entry.summary === 'string')
+        return { type: 'summary', summary: entry.summary, ...(typeof entry.leafUuid === 'string' ? { leafUuid: entry.leafUuid } : {}) };
+    if ((entry.type !== 'user' && entry.type !== 'assistant') || entry.isMeta === true || !isObject(entry.message))
+        return undefined;
+    const content = cleanContent(entry.message.content);
+    if (isEmpty(content))
+        return undefined;
+    const message = entry.message;
+    return {
+        type: entry.type,
+        ...(typeof entry.uuid === 'string' ? { uuid: entry.uuid } : {}),
+        ...('parentUuid' in entry ? { parentUuid: entry.parentUuid ?? null } : {}),
+        ...(typeof entry.isSidechain === 'boolean' ? { isSidechain: entry.isSidechain } : {}),
+        ...(typeof entry.timestamp === 'string' ? { timestamp: entry.timestamp } : {}),
+        message: {
+            role: typeof message.role === 'string' ? message.role : entry.type,
+            ...(typeof message.model === 'string' ? { model: message.model } : {}),
+            content,
+        },
+    };
+};
+/**
+ * Trim a JSONL transcript. A file that is not a Claude Code transcript (for
+ * example a Codex rollout saved by hand) is returned unchanged.
+ */
+export const trimTranscript = (raw) => {
+    const entries = raw
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    });
+    if (!entries.some(entry => isObject(entry) && CLAUDE_LINE_TYPES.has(String(entry.type))))
+        return raw;
+    const kept = entries.map(trimTranscriptEntry).filter((entry) => entry !== undefined);
+    return kept.map(entry => `${JSON.stringify(entry)}\n`).join('');
+};

package/dist/hooks/types.d.ts

@@ -0,0 +1,56 @@
+export type HookClient = 'claude' | 'codex';
+export type HookInput = {
+    session_id?: string;
+    transcript_path?: string;
+    cwd?: string;
+    hook_event_name?: string;
+};
+export type SessionStatus = 'saved' | 'pending-upload' | 'uploaded';
+export type SessionImage = {
+    original: string;
+    file: string;
+    size: number;
+    mime: string;
+};
+export type SessionMeta = {
+    sessionId: string;
+    cwd: string;
+    client: 'claude';
+    lastEvent: string;
+    savedAt: string;
+    canvasId?: string;
+    status: SessionStatus;
+    images: SessionImage[];
+    /** Highest rev successfully uploaded; the next upload uses uploadedRev + 1. */
+    uploadedRev?: number;
+    /**
+     * Highest rev ever sent, success or not. A snapshot whose response was lost
+     * may have been published, so the next upload goes past this one too.
+     */
+    attemptedRev?: number;
+    graphId?: string;
+    reason?: string;
+    lastUploadAttemptAt?: string;
+    /** Where Claude Code keeps the live transcript; copied and redacted on SessionEnd or upload. */
+    transcriptPath?: string;
+    /** The live transcript moved on since the local copy was made. */
+    dirty?: boolean;
+    /** Never reached SessionEnd; picked up by a later SessionStart. */
+    abandoned?: boolean;
+    /** How far the graph is compacted after uploads failed for size or time (0 = none). */
+    compactLevel?: number;
+    /** Failed uploads in a row; spaces out the automatic retries. */
+    failedAttempts?: number;
+    /** Size of the live transcript the local copy was made from (before masking). */
+    sourceBytes?: number;
+    /** `conversation-v1` once the local copy is trimmed; absent for copies an older CLI saved. */
+    transcriptFormat?: string;
+};
+export type UploadOutcome = {
+    ok: boolean;
+    graphId?: string;
+    reason?: string;
+    /** Skipped without a request because an earlier failure is still being waited out. */
+    throttled?: true;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/hooks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hooks/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAA;AAE3C,MAAM,MAAM,SAAS,GAAG;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,gBAAgB,GAAG,UAAU,CAAA;AAEnE,MAAM,MAAM,YAAY,GAAG;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAA;AAEvF,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,QAAQ,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,aAAa,CAAA;IACrB,MAAM,EAAE,YAAY,EAAE,CAAA;IACtB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,gGAAgG;IAChG,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,kEAAkE;IAClE,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,mEAAmE;IACnE,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,uFAAuF;IACvF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,iEAAiE;IACjE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iFAAiF;IACjF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8FAA8F;IAC9F,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,OAAO,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,sFAAsF;IACtF,SAAS,CAAC,EAAE,IAAI,CAAA;CACjB,CAAA"}

package/dist/hooks/upload.d.ts

@@ -0,0 +1,52 @@
+import type { UploadOutcome } from './types.js';
+export declare const CODING_AGENT_SESSION_API_PREFIX = "/api/v2/coding-agent-sessions";
+export declare const UPLOAD_TIMEOUT_MS = 20000;
+export type UploadAuth = {
+    apiKey: string;
+    baseUrl: string;
+    workspaceId?: string;
+};
+export type UploadOptions = {
+    profile?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: typeof fetch;
+    auth?: UploadAuth;
+    now?: () => Date;
+    /** Ignore the once-a-day throttle after a `no-upload-access` answer. */
+    force?: boolean;
+    timeoutMs?: number;
+};
+/**
+ * Resolve the CLI profile's key + base URL from ~/.assethub/config.json.
+ * src/index.ts's resolveAuth is module-private, so this mirrors its precedence
+ * for the non-interactive case (stored profile, then ASSETHUB_API_KEY).
+ */
+export declare const resolveUploadAuth: (options: Pick<UploadOptions, "profile" | "home" | "env">) => Promise<UploadAuth | null>;
+/** Automatic retries after an ordinary failure wait 1h, 2h, 4h … up to a day. */
+export declare const retryDelayMs: (failedAttempts: number) => number;
+/**
+ * Whether this login may upload coding-agent sessions (internal accounts for
+ * now). The register route answers 404 to anyone it does not let in before it
+ * reads the body; for everyone else this empty body fails validation, so
+ * nothing is written. Any other answer, or no answer, counts as "no".
+ */
+export declare const canUploadSessions: (auth: UploadAuth, fetchImpl?: typeof fetch) => Promise<boolean>;
+/**
+ * One upload per session at a time: the SessionEnd upload and a background
+ * retry would otherwise rebuild the same graph folder under each other.
+ */
+export declare const uploadSession: (sessionDir: string, options?: UploadOptions) => Promise<UploadOutcome>;
+/**
+ * Upload pending sessions, newest first. `limit` caps how many are attempted
+ * (sessions waiting out a retry delay do not count); `exclude` skips one that
+ * the caller already handled.
+ */
+export declare const uploadPending: (options?: UploadOptions & {
+    limit?: number;
+    exclude?: string;
+}) => Promise<{
+    session: string;
+    outcome: UploadOutcome;
+}[]>;
+//# sourceMappingURL=upload.d.ts.map