@assethub/cli 0.1.30 → 0.1.32

package/dist/hooks/trim.js

@@ -0,0 +1,220 @@
+// Keep only the conversation from a Claude Code transcript (or a Codex rollout,
+// converted to the same shape) 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,
+        },
+    };
+};
+/** Top-level record types of a Codex rollout (`~/.codex/sessions/.../rollout-*.jsonl`). */
+const CODEX_LINE_TYPES = new Set(['session_meta', 'response_item', 'event_msg', 'turn_context', 'compacted']);
+// Codex sends its context as user messages: AGENTS.md, and tagged blocks such
+// as <environment_context> or <user_instructions>. They are not the artist's words.
+const CODEX_CONTEXT_BLOCK = /<([A-Za-z][\w-]*(?:context|instructions|plugins))(?:\s[^>]*)?>[\s\S]*?<\/\1>\s*/g;
+const codexUserText = (text) => /^\s*# AGENTS\.md instructions/.test(text) ? '' : cleanText(text.replace(CODEX_CONTEXT_BLOCK, ''));
+const codexText = (content, blockType, clean) => (Array.isArray(content) ? content : [])
+    .map(block => (isObject(block) && block.type === blockType && typeof block.text === 'string' ? clean(block.text) : ''))
+    .filter(text => text.trim())
+    .join('\n');
+// An exec result is JSON text with timing and token bookkeeping around the
+// command's output; only the output is conversation.
+const codexOutputText = (text) => {
+    if (text.trimStart().startsWith('{')) {
+        try {
+            const parsed = JSON.parse(text);
+            if (isObject(parsed) && typeof parsed.output === 'string')
+                return parsed.output;
+        }
+        catch {
+            // plain text that happens to start with a brace
+        }
+    }
+    return text;
+};
+/** Tool output: a string, `{output}`, or a list of `{type, text}` items (images are dropped). */
+const codexToolOutput = (output) => {
+    if (typeof output === 'string')
+        return cleanText(codexOutputText(output));
+    if (Array.isArray(output))
+        return cleanText(output
+            .map(item => (isObject(item) && typeof item.text === 'string' ? codexOutputText(item.text) : ''))
+            .filter(Boolean)
+            .join('\n'));
+    if (isObject(output)) {
+        for (const key of ['output', 'content'])
+            if (typeof output[key] === 'string')
+                return cleanText(output[key]);
+    }
+    return output === undefined ? '' : JSON.stringify(output);
+};
+const codexArguments = (value) => {
+    if (typeof value !== 'string')
+        return value ?? {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return { arguments: value };
+    }
+};
+const codexMessage = (type, timestamp, content) => ({
+    type,
+    ...(typeof timestamp === 'string' ? { timestamp } : {}),
+    message: { role: type, content },
+});
+/**
+ * One Codex rollout record as a conversation entry in the same shape as a
+ * trimmed Claude Code transcript, or undefined to drop it. Kept: the artist's
+ * prompts, the agent's replies, its tool calls and their output, and compaction
+ * summaries. Dropped: session metadata (base instructions, git, cwd), developer
+ * and context messages, reasoning, turn settings and the event stream, which
+ * repeats the messages.
+ */
+export const codexEntry = (entry) => {
+    if (!isObject(entry) || !isObject(entry.payload))
+        return undefined;
+    const { payload, timestamp } = entry;
+    if (entry.type === 'compacted')
+        return typeof payload.message === 'string' && payload.message.trim() ? { type: 'summary', summary: payload.message } : undefined;
+    if (entry.type !== 'response_item')
+        return undefined;
+    switch (payload.type) {
+        case 'message': {
+            if (payload.role === 'user') {
+                const text = codexText(payload.content, 'input_text', codexUserText).trim();
+                return text ? codexMessage('user', timestamp, text) : undefined;
+            }
+            if (payload.role !== 'assistant')
+                return undefined;
+            const text = codexText(payload.content, 'output_text', cleanText);
+            return text.trim() ? codexMessage('assistant', timestamp, [{ type: 'text', text }]) : undefined;
+        }
+        case 'function_call':
+        case 'custom_tool_call':
+        case 'local_shell_call': {
+            const id = typeof payload.call_id === 'string' ? payload.call_id : payload.id;
+            if (typeof id !== 'string')
+                return undefined;
+            const name = typeof payload.name === 'string' ? payload.name : payload.type === 'local_shell_call' ? 'shell' : 'unknown';
+            const input = payload.type === 'function_call'
+                ? codexArguments(payload.arguments)
+                : payload.type === 'custom_tool_call'
+                    ? { input: payload.input }
+                    : (payload.action ?? {});
+            return codexMessage('assistant', timestamp, [{ type: 'tool_use', id, name, input }]);
+        }
+        case 'function_call_output':
+        case 'custom_tool_call_output': {
+            if (typeof payload.call_id !== 'string')
+                return undefined;
+            return codexMessage('user', timestamp, [{ type: 'tool_result', tool_use_id: payload.call_id, content: codexToolOutput(payload.output) }]);
+        }
+        default:
+            // reasoning, web search and anything else that is not conversation
+            return undefined;
+    }
+};
+/**
+ * Trim a JSONL transcript: a Claude Code transcript, or a Codex rollout turned
+ * into the same conversation shape. A file in any other format 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;
+        }
+    });
+    const isClaude = entries.some(entry => isObject(entry) && CLAUDE_LINE_TYPES.has(String(entry.type)));
+    const isCodex = !isClaude && entries.some(entry => isObject(entry) && CODEX_LINE_TYPES.has(String(entry.type)) && isObject(entry.payload));
+    if (!isClaude && !isCodex)
+        return raw;
+    const kept = entries.map(isCodex ? codexEntry : 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: HookClient;
+    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,UAAU,CAAA;IAClB,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/hooks/upload.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAc,aAAa,EAAC,MAAM,YAAY,CAAA;AAG1D,eAAO,MAAM,+BAA+B,kCAAkC,CAAA;AAQ9E,eAAO,MAAM,iBAAiB,QAAS,CAAA;AAEvC,MAAM,MAAM,UAAU,GAAG;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAC,CAAA;AAEhF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;IACvB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;IACxB,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAA;IAChB,wEAAwE;IACxE,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,MAAM,GAAG,KAAK,CAAC,KACvD,OAAO,CAAC,UAAU,GAAG,IAAI,CA2B3B,CAAA;AAED,iFAAiF;AACjF,eAAO,MAAM,YAAY,GAAI,gBAAgB,MAAM,KAAG,MACmB,CAAA;AAmBzE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,UAAU,EAChB,YAAW,OAAO,KAAyC,KAC1D,OAAO,CAAC,OAAO,CAgBjB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,GACxB,YAAY,MAAM,EAClB,UAAS,aAAkB,KAC1B,OAAO,CAAC,aAAa,CASvB,CAAA;AAoHD;;;;GAIG;AACH,eAAO,MAAM,aAAa,GACxB,UAAS,aAAa,GAAG;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAM,KAC/D,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAAC,EAAE,CAkBrD,CAAA"}

package/dist/hooks/upload.js

@@ -0,0 +1,252 @@
+// Upload saved sessions to AssetHub's coding-agent session store
+// (`/api/v2/coding-agent-sessions`). It speaks the same `ag.registry.v1`
+// contract as `runs upload`, so the plan and transport are shared; only the
+// URL prefix and the extra `session` registration fields differ. Sessions are
+// owned by, and readable only by, the key's user.
+import { readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { buildRunUploadPlan } from '../runsUpload/buildRunUpload.js';
+import { controlRunUploadUrls } from '../runsUpload/controlEndpoints.js';
+import { readGraphFolder } from '../runsUpload/graphFolder.js';
+import { uploadRun } from '../runsUpload/uploadRun.js';
+import { RunUploadError } from '../runsUpload/runUploadError.js';
+import { MAX_COMPACT_LEVEL, buildSessionGraphFolder, sessionGraphId } from './graph.js';
+import { acquireLock, listSessionDirs, readMeta, resolveHome, updateMeta } from './paths.js';
+import { redactText } from './redact.js';
+import { materializeSession } from './save.js';
+import { TRANSCRIPT_FORMAT } from './trim.js';
+const DEFAULT_BASE_URL = 'https://app.assethub.io';
+export const CODING_AGENT_SESSION_API_PREFIX = '/api/v2/coding-agent-sessions';
+/** `.assethub/canvas` holds a Workflow canvas id; only a positive integer is sent. */
+const canvasIdOf = (value) => {
+    const id = Number(value?.trim());
+    return Number.isSafeInteger(id) && id > 0 ? id : null;
+};
+const DAY_MS = 24 * 60 * 60 * 1000;
+export const UPLOAD_TIMEOUT_MS = 20_000;
+/**
+ * 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 const resolveUploadAuth = async (options) => {
+    const env = options.env ?? process.env;
+    const configPath = env.ASSETHUB_CLI_CONFIG ?? join(resolveHome(options.home), '.assethub', 'config.json');
+    let config = {};
+    try {
+        config = JSON.parse(await readFile(configPath, 'utf8'));
+    }
+    catch {
+        // no config: fall back to env only
+    }
+    const name = options.profile ?? config.defaultProfile ?? 'default';
+    const stored = config.profiles?.[name];
+    const envKey = env.ASSETHUB_API_KEY?.trim();
+    // Same precedence as the CLI's own auth: an explicit profile, a selected
+    // workspace or a personal profile wins over ASSETHUB_API_KEY.
+    const personal = stored?.authentication === 'personal' || Boolean(stored?.apiKey?.startsWith('ah_pat_'));
+    const useStored = Boolean(options.profile || stored?.workspaceId || personal);
+    const apiKey = useStored ? stored?.apiKey : envKey || stored?.apiKey;
+    if (!apiKey)
+        return null;
+    const baseUrl = (options.profile ? stored?.baseUrl : env.ASSETHUB_API_BASE_URL ?? stored?.baseUrl) ??
+        DEFAULT_BASE_URL;
+    // The selected workspace belongs to the saved key, not to an ASSETHUB_API_KEY override.
+    const workspaceId = apiKey === stored?.apiKey ? stored?.workspaceId : undefined;
+    return { apiKey, baseUrl, ...(workspaceId ? { workspaceId } : {}) };
+};
+/** Automatic retries after an ordinary failure wait 1h, 2h, 4h … up to a day. */
+export const retryDelayMs = (failedAttempts) => Math.min(DAY_MS, 60 * 60 * 1000 * 2 ** Math.max(0, failedAttempts - 1));
+const causeName = (error) => {
+    const cause = error?.cause;
+    return typeof cause?.name === 'string' ? cause.name : undefined;
+};
+/** The upload was too big, or too slow to finish: a smaller graph may get through. */
+const isSizeOrTimeFailure = (error) => {
+    if (!(error instanceof RunUploadError)) {
+        const name = error?.name;
+        return name === 'TimeoutError' || name === 'AbortError';
+    }
+    if (['push_too_large', 'PAYLOAD_TOO_LARGE'].includes(error.code))
+        return true;
+    if (error.status === 413 || error.status === 504)
+        return true;
+    const cause = causeName(error);
+    return error.code === 'network_unreachable' && (cause === 'TimeoutError' || cause === 'AbortError');
+};
+/**
+ * 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 const canUploadSessions = async (auth, fetchImpl = globalThis.fetch.bind(globalThis)) => {
+    try {
+        const response = await fetchImpl(controlRunUploadUrls(auth.baseUrl, CODING_AGENT_SESSION_API_PREFIX).graphs, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${auth.apiKey}`,
+                'content-type': 'application/json',
+                ...(auth.workspaceId ? { 'x-assethub-workspace': auth.workspaceId } : {}),
+            },
+            body: '{}',
+            signal: AbortSignal.timeout(10_000),
+        });
+        return response.status === 400 || response.status === 422;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * 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 const uploadSession = async (sessionDir, options = {}) => {
+    if (!(await readMeta(sessionDir)))
+        return { ok: false, reason: 'no-session' };
+    const release = await acquireLock(join(sessionDir, '.upload.lock'), { waitMs: 0, staleMs: 15 * 60_000 });
+    if (!release)
+        return { ok: false, reason: 'upload-in-progress', throttled: true };
+    try {
+        return await uploadSessionUnlocked(sessionDir, options);
+    }
+    finally {
+        await release();
+    }
+};
+const uploadSessionUnlocked = async (sessionDir, options) => {
+    const now = options.now ?? (() => new Date());
+    let meta = await readMeta(sessionDir);
+    if (!meta)
+        return { ok: false, reason: 'no-session' };
+    if (!options.force && meta.lastUploadAttemptAt) {
+        const since = now().getTime() - new Date(meta.lastUploadAttemptAt).getTime();
+        if (meta.reason === 'no-upload-access' && since < DAY_MS) {
+            return { ok: false, reason: 'no-upload-access', throttled: true };
+        }
+        if ((meta.failedAttempts ?? 0) > 0 && since < retryDelayMs(meta.failedAttempts ?? 0)) {
+            return { ok: false, reason: 'retry-later', throttled: true };
+        }
+    }
+    // Re-read on every write: a hook may have saved the session meanwhile.
+    const record = async (patch) => {
+        await updateMeta(sessionDir, meta, latest => ({
+            ...latest,
+            ...patch,
+            lastUploadAttemptAt: now().toISOString(),
+        }));
+    };
+    const fail = async (reason, patch = {}) => {
+        try {
+            const latest = (await readMeta(sessionDir)) ?? meta;
+            await record({ status: 'pending-upload', reason, failedAttempts: (latest?.failedAttempts ?? 0) + 1, ...patch });
+        }
+        catch {
+            // keep the original failure as the answer
+        }
+        return { ok: false, reason };
+    };
+    const auth = options.auth ?? (await resolveUploadAuth(options));
+    if (!auth) {
+        await record({ status: 'pending-upload', reason: 'no-credentials' });
+        return { ok: false, reason: 'no-credentials' };
+    }
+    // Copy and redact now if the live transcript moved on since the last copy.
+    // Also re-copy a session an older CLI saved whole, so it is trimmed before it leaves the machine.
+    if (meta.dirty || meta.transcriptFormat !== TRANSCRIPT_FORMAT)
+        meta = (await materializeSession(sessionDir, { env: options.env })) ?? meta;
+    let level = meta.compactLevel ?? 0;
+    try {
+        const baseFetch = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+        const timeoutMs = options.timeoutMs ?? UPLOAD_TIMEOUT_MS;
+        // Per request, not one deadline for the whole upload: many blobs of up to
+        // 4 MiB each cannot share 20 seconds.
+        const fetchImpl = ((input, init) => baseFetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+        for (;;) {
+            // Past every rev ever sent: a snapshot whose response was lost may have
+            // been published, and re-sending its rev with new content is a permanent
+            // conflict. The server accepts gaps, so skipping an unsent rev is harmless.
+            const latest = (await readMeta(sessionDir)) ?? meta;
+            const rev = Math.max(latest.uploadedRev ?? -1, latest.attemptedRev ?? -1) + 1;
+            let plan;
+            try {
+                const folder = await readGraphFolder(await buildSessionGraphFolder(sessionDir, { compactLevel: level }));
+                plan = await buildRunUploadPlan({
+                    folder,
+                    graphId: sessionGraphId(basename(sessionDir)),
+                    rev,
+                    description: `Agent session ${meta.sessionId}`,
+                    tags: ['session', `agent:${meta.client ?? 'claude'}`],
+                    now: now(),
+                });
+            }
+            catch (error) {
+                // Too big to send at all: compact and try again right away.
+                if (isSizeOrTimeFailure(error) && level < MAX_COMPACT_LEVEL) {
+                    level += 1;
+                    continue;
+                }
+                throw error;
+            }
+            await record({ attemptedRev: rev, compactLevel: level });
+            const result = await uploadRun({
+                plan,
+                baseUrl: auth.baseUrl,
+                apiKey: auth.apiKey,
+                workspaceId: auth.workspaceId,
+                fetchImpl,
+                urls: controlRunUploadUrls(auth.baseUrl, CODING_AGENT_SESSION_API_PREFIX),
+                registrationExtra: {
+                    session: { client: meta.client, sessionId: meta.sessionId, canvasId: canvasIdOf(meta.canvasId) },
+                },
+            });
+            await record({
+                status: 'uploaded',
+                graphId: result.graphId,
+                uploadedRev: rev,
+                reason: undefined,
+                failedAttempts: 0,
+            });
+            return { ok: true, graphId: result.graphId };
+        }
+    }
+    catch (error) {
+        if (error instanceof RunUploadError && error.status === 404) {
+            await record({ status: 'pending-upload', reason: 'no-upload-access' });
+            return { ok: false, reason: 'no-upload-access' };
+        }
+        const reason = redactText(error instanceof Error ? error.message : String(error)).slice(0, 500);
+        // Too big or too slow on the wire: the next try sends a smaller graph.
+        const compacted = isSizeOrTimeFailure(error) ? { compactLevel: Math.min(level + 1, MAX_COMPACT_LEVEL) } : {};
+        return fail(reason, compacted);
+    }
+};
+/**
+ * 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 const uploadPending = async (options = {}) => {
+    const pending = [];
+    for (const dir of await listSessionDirs(options.home)) {
+        if (dir === options.exclude)
+            continue;
+        const meta = await readMeta(dir);
+        if (meta?.status !== 'pending-upload')
+            continue;
+        pending.push({ dir, savedAt: new Date(meta.savedAt).getTime() || 0 });
+    }
+    pending.sort((a, b) => b.savedAt - a.savedAt);
+    const results = [];
+    let attempted = 0;
+    for (const { dir } of pending) {
+        if (options.limit !== undefined && attempted >= options.limit)
+            break;
+        const outcome = await uploadSession(dir, options);
+        results.push({ session: dir, outcome });
+        if (!outcome.throttled)
+            attempted += 1;
+    }
+    return results;
+};