@thegitai/cli 1.0.0-preview.20 → 1.0.0-preview.21

package/dist/src/api/chat.js

@@ -248,8 +248,12 @@ async function postUserInputResult({ config, turnId, requestId, result, fetchImp
         throw await readErrorResponse(response, trace.traceId);
     }
 }
-export async function postInterjection({ config, turnId, text, messageId, fetchImpl = globalThis.fetch, traceId, }) {
-    const payload = { text, messageId };
+export async function postInterjection({ config, turnId, text, messageId, imageAttachments = [], fetchImpl = globalThis.fetch, traceId, }) {
+    const payload = {
+        text,
+        messageId,
+        ...(imageAttachments.length > 0 ? { imageAttachments } : {}),
+    };
     const trace = createTraceContext(traceId);
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/interject`, {
         method: 'POST',

package/dist/src/core/clipboard.js

@@ -1,15 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-const MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024;
-const MIME_BY_EXT = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.webp': 'image/webp',
-};
-const SUPPORTED_MIME_TYPES = new Set(Object.values(MIME_BY_EXT));
+import { MAX_IMAGE_SIZE_BYTES, SUPPORTED_IMAGE_MIME_TYPES as SUPPORTED_MIME_TYPES, sniffImageMimeType, } from './image-limits.js';
 export class ClipboardError extends Error {
     code;
     constructor(message, code) {
@@ -273,11 +265,13 @@ export function loadImageFromFile(filePath) {
     if (stat.size > MAX_IMAGE_SIZE_BYTES) {
         throw new ClipboardError(`Image file exceeds 10MB limit (${(stat.size / 1024 / 1024).toFixed(1)}MB): ${resolved}`, 'READ_FAILED');
     }
-    const ext = path.extname(resolved).toLowerCase();
-    const mimeType = MIME_BY_EXT[ext];
+    const buf = readFileSync(resolved);
+    const mimeType = sniffImageMimeType(buf);
     if (!mimeType) {
-        throw new ClipboardError(`Unsupported image format "${ext}". Supported: PNG, JPEG, GIF, WebP.`, 'READ_FAILED');
+        const ext = path.extname(resolved).toLowerCase();
+        throw new ClipboardError(ext
+            ? `"${path.basename(resolved)}" is named ${ext} but its contents are not a supported image. Supported: PNG, JPEG, GIF, WebP.`
+            : `Not a supported image file: ${resolved}. Supported: PNG, JPEG, GIF, WebP.`, 'READ_FAILED');
     }
-    const buf = readFileSync(resolved);
     return { base64Data: buf.toString('base64'), mimeType };
 }

package/dist/src/core/image-limits.js

@@ -0,0 +1,56 @@
+export const MAX_IMAGES_PER_MESSAGE = 5;
+export const MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024;
+export const MAX_TOTAL_IMAGE_BYTES_PER_MESSAGE = 20 * 1024 * 1024;
+export function approximateBase64DecodedBytes(base64) {
+    const padding = base64.endsWith('==') ? 2 : base64.endsWith('=') ? 1 : 0;
+    return Math.max(0, Math.floor((base64.length * 3) / 4) - padding);
+}
+export function totalAttachmentBytes(attachments) {
+    return attachments.reduce((sum, attachment) => sum + approximateBase64DecodedBytes(attachment.base64Data), 0);
+}
+export const SUPPORTED_IMAGE_MIME_TYPES = new Set([
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp',
+]);
+export const IMAGE_MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+export const IMAGE_EXT_BY_MIME = {
+    'image/png': '.png',
+    'image/jpeg': '.jpg',
+    'image/gif': '.gif',
+    'image/webp': '.webp',
+};
+export function isSupportedImageMimeType(mime) {
+    return SUPPORTED_IMAGE_MIME_TYPES.has(mime);
+}
+export function sniffImageMimeType(bytes) {
+    if (bytes.length < 12)
+        return null;
+    if (bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47) {
+        return 'image/png';
+    }
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+        return 'image/jpeg';
+    }
+    if (bytes.subarray(0, 3).toString('latin1') === 'GIF') {
+        return 'image/gif';
+    }
+    if (bytes.subarray(0, 4).toString('latin1') === 'RIFF' &&
+        bytes.subarray(8, 12).toString('latin1') === 'WEBP') {
+        return 'image/webp';
+    }
+    return null;
+}
+export function imageExtensionForMime(mime) {
+    return IMAGE_EXT_BY_MIME[mime] ?? '.png';
+}

package/dist/src/core/image-path-extractor.js

@@ -1,7 +1,9 @@
-import { existsSync, statSync } from 'node:fs';
+import { closeSync, existsSync, openSync, readSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadImageFromFile } from './clipboard.js';
+import { MAX_IMAGES_PER_MESSAGE, MAX_IMAGE_SIZE_BYTES, MAX_TOTAL_IMAGE_BYTES_PER_MESSAGE, approximateBase64DecodedBytes, sniffImageMimeType, totalAttachmentBytes, } from './image-limits.js';
+import { tryCacheAttachmentBytes } from './session-image-store.js';
 const EXT = '(?:png|jpe?g|gif|webp)';
 const BARE_CHAR = "[^\\s\"'<>,:;!?()\\[\\]{}]";
 const BARE_PATH = `(?:[A-Za-z]:[\\\\/])?(?:\\\\ |${BARE_CHAR})+\\.${EXT}`;
@@ -110,13 +112,67 @@ function detectImagePaths(input, cwd) {
     }
     return rawsByPath;
 }
+const EXTENSIONLESS_CANDIDATE = new RegExp(`"([^"]*[\\\\/][^"]*)"` +
+    `|'([^']*[\\\\/][^']*)'` +
+    `|((?:[A-Za-z]:[\\\\/])?(?:\\\\ |${BARE_CHAR})*[\\\\/](?:\\\\ |${BARE_CHAR})+)`, 'g');
+function sniffFileHeader(resolvedPath) {
+    let fd = null;
+    try {
+        const stat = statSync(resolvedPath, { throwIfNoEntry: false });
+        if (!stat?.isFile() || stat.size > MAX_IMAGE_SIZE_BYTES)
+            return null;
+        fd = openSync(resolvedPath, 'r');
+        const header = Buffer.alloc(12);
+        const read = readSync(fd, header, 0, 12, 0);
+        return read === 12 ? header : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+            }
+        }
+    }
+}
+function detectExtensionlessImagePaths(input, cwd, alreadyDetected) {
+    const found = new Map();
+    const regex = new RegExp(EXTENSIONLESS_CANDIDATE.source, EXTENSIONLESS_CANDIDATE.flags);
+    let match;
+    while ((match = regex.exec(input)) !== null) {
+        const raw = match[0];
+        const inner = (match[1] ?? match[2] ?? match[3] ?? '').replace(/\\ /g, ' ');
+        if (!inner || inner.includes('://'))
+            continue;
+        if (/\.(?:png|jpe?g|gif|webp)$/i.test(inner))
+            continue;
+        const resolvedPath = path.isAbsolute(inner)
+            ? inner
+            : path.resolve(cwd, inner);
+        if (alreadyDetected.has(resolvedPath) || found.has(resolvedPath))
+            continue;
+        const header = sniffFileHeader(resolvedPath);
+        if (!header || !sniffImageMimeType(header))
+            continue;
+        found.set(resolvedPath, [raw]);
+    }
+    return found;
+}
 export function autoAttachImages(input, cwd, existing = []) {
-    const max = 2;
+    const max = MAX_IMAGES_PER_MESSAGE;
     const rawsByPath = detectImagePaths(input, cwd);
+    for (const [resolvedPath, rawForms] of detectExtensionlessImagePaths(input, cwd, new Set(rawsByPath.keys()))) {
+        rawsByPath.set(resolvedPath, rawForms);
+    }
     let sanitizedInput = input;
     const attachments = [];
     const errors = [];
     const maxExistingIndex = existing.reduce((highest, a) => Math.max(highest, a.index ?? 0), 0);
+    let budgetUsed = totalAttachmentBytes(existing);
     for (const [resolvedPath, rawForms] of rawsByPath) {
         if (existing.length + attachments.length >= max)
             break;
@@ -124,13 +180,24 @@ export function autoAttachImages(input, cwd, existing = []) {
             continue;
         try {
             const loaded = loadImageFromFile(resolvedPath);
-            const idx = maxExistingIndex + attachments.length + 1;
+            const bytes = approximateBase64DecodedBytes(loaded.base64Data);
+            if (budgetUsed + bytes > MAX_TOTAL_IMAGE_BYTES_PER_MESSAGE) {
+                errors.push(`${path.basename(resolvedPath)} was not attached: it would put this message over the ${Math.round(MAX_TOTAL_IMAGE_BYTES_PER_MESSAGE / 1024 / 1024)}MB combined image limit.`);
+                continue;
+            }
+            budgetUsed += bytes;
+            const cached = tryCacheAttachmentBytes({
+                base64Data: loaded.base64Data,
+                mimeType: loaded.mimeType,
+            });
+            const idx = cached?.index ?? maxExistingIndex + attachments.length + 1;
             attachments.push({
                 index: idx,
                 mimeType: loaded.mimeType,
                 base64Data: loaded.base64Data,
                 source: 'file',
                 filePath: resolvedPath,
+                ...(cached ? { cachePath: cached.cachePath } : {}),
             });
             for (const raw of rawForms) {
                 sanitizedInput = sanitizedInput.replace(raw, `[Image #${idx}]`);

package/dist/src/core/session-image-store.js

@@ -0,0 +1,199 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { getClientStateDir } from '../client-state.js';
+import { MAX_IMAGE_SIZE_BYTES, imageExtensionForMime, isSupportedImageMimeType, sniffImageMimeType, } from './image-limits.js';
+const IMAGE_FILE_MODE = 0o600;
+const IMAGE_DIR_MODE = 0o700;
+export const SESSION_IMAGE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+let activeSessionId = null;
+export function setImageStoreSession(sessionId) {
+    activeSessionId = String(sessionId ?? '').trim() || null;
+    contentIndex.clear();
+}
+const contentIndex = new Map();
+function imageContentKey(base64Data) {
+    return createHash('sha256').update(base64Data).digest('hex');
+}
+function rememberStoredImage(base64Data, cachePath) {
+    contentIndex.set(imageContentKey(base64Data), cachePath);
+}
+export function findStoredImageByContent(base64Data) {
+    const cachePath = contentIndex.get(imageContentKey(base64Data));
+    if (!cachePath)
+        return undefined;
+    if (!existsSync(cachePath)) {
+        contentIndex.delete(imageContentKey(base64Data));
+        return undefined;
+    }
+    return cachePath;
+}
+export function getImageStoreSession() {
+    return activeSessionId;
+}
+function safeSessionDirName(sessionId) {
+    const normalized = String(sessionId ?? '').trim();
+    if (!/^[a-zA-Z0-9_-]+$/.test(normalized)) {
+        throw new Error(`Invalid session id "${sessionId}".`);
+    }
+    return normalized;
+}
+export function getSessionImageBaseDir(env = process.env) {
+    return path.join(getClientStateDir(env), 'sessions', 'images');
+}
+export function getSessionImageDir(sessionId, env = process.env) {
+    return path.join(getSessionImageBaseDir(env), safeSessionDirName(sessionId));
+}
+function nextImageNumber(dir) {
+    if (!existsSync(dir))
+        return 1;
+    let highest = 0;
+    for (const name of readdirSync(dir)) {
+        const parsed = Number.parseInt(path.basename(name, path.extname(name)), 10);
+        if (Number.isInteger(parsed) && parsed > highest)
+            highest = parsed;
+    }
+    return highest + 1;
+}
+function ensureSessionImageDir(sessionId, env) {
+    const dir = getSessionImageDir(sessionId, env);
+    mkdirSync(dir, { recursive: true, mode: IMAGE_DIR_MODE });
+    return dir;
+}
+export function storeSessionImageBytes({ sessionId, base64Data, mimeType, env = process.env, }) {
+    const dir = ensureSessionImageDir(sessionId, env);
+    const index = nextImageNumber(dir);
+    const cachePath = path.join(dir, `${index}${imageExtensionForMime(mimeType)}`);
+    writeFileSync(cachePath, Buffer.from(base64Data, 'base64'), {
+        mode: IMAGE_FILE_MODE,
+    });
+    rememberStoredImage(base64Data, cachePath);
+    return { cachePath, mimeType, base64Data, index };
+}
+export function tryCacheAttachmentBytes({ base64Data, mimeType, env = process.env, }) {
+    if (!activeSessionId)
+        return undefined;
+    try {
+        const stored = storeSessionImageBytes({
+            sessionId: activeSessionId,
+            base64Data,
+            mimeType,
+            env,
+        });
+        return { cachePath: stored.cachePath, index: stored.index };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isSessionStorePath(candidate, env = process.env) {
+    if (!activeSessionId)
+        return false;
+    const dir = getSessionImageDir(activeSessionId, env);
+    const resolved = path.resolve(candidate);
+    return (resolved.startsWith(dir + path.sep) && path.dirname(resolved) === dir);
+}
+export function readSessionImageByIndex(index, env = process.env) {
+    if (!activeSessionId || !Number.isInteger(index) || index < 1)
+        return null;
+    const dir = getSessionImageDir(activeSessionId, env);
+    if (!existsSync(dir))
+        return null;
+    try {
+        for (const name of readdirSync(dir)) {
+            if (Number.parseInt(path.basename(name, path.extname(name)), 10) === index) {
+                return readSessionImage(path.join(dir, name));
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export class SessionImageError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'SessionImageError';
+    }
+}
+export function storeSessionImageFromPath({ sessionId, sourcePath, env = process.env, }) {
+    const resolved = path.resolve(sourcePath);
+    if (!existsSync(resolved) || !statSync(resolved).isFile()) {
+        throw new SessionImageError(`Image file not found: ${resolved}`, 'NOT_FOUND');
+    }
+    const size = statSync(resolved).size;
+    if (size > MAX_IMAGE_SIZE_BYTES) {
+        throw new SessionImageError(`Image file exceeds ${Math.round(MAX_IMAGE_SIZE_BYTES / 1024 / 1024)}MB limit (${(size / 1024 / 1024).toFixed(1)}MB): ${resolved}`, 'TOO_LARGE');
+    }
+    const bytes = readFileSync(resolved);
+    const sniffed = sniffImageMimeType(bytes);
+    if (!sniffed || !isSupportedImageMimeType(sniffed)) {
+        throw new SessionImageError(`Not a supported image file: ${resolved}. Supported: PNG, JPEG, GIF, WebP.`, 'UNSUPPORTED');
+    }
+    const dir = ensureSessionImageDir(sessionId, env);
+    const index = nextImageNumber(dir);
+    const cachePath = path.join(dir, `${index}${imageExtensionForMime(sniffed)}`);
+    writeFileSync(cachePath, bytes, { mode: IMAGE_FILE_MODE });
+    const base64Data = bytes.toString('base64');
+    rememberStoredImage(base64Data, cachePath);
+    return { cachePath, mimeType: sniffed, base64Data, index };
+}
+export function readSessionImage(cachePath) {
+    try {
+        if (!existsSync(cachePath))
+            return null;
+        const bytes = readFileSync(cachePath);
+        const sniffed = sniffImageMimeType(bytes);
+        if (!sniffed)
+            return null;
+        const parsed = Number.parseInt(path.basename(cachePath, path.extname(cachePath)), 10);
+        const base64Data = bytes.toString('base64');
+        rememberStoredImage(base64Data, cachePath);
+        return {
+            cachePath,
+            mimeType: sniffed,
+            base64Data,
+            index: Number.isInteger(parsed) ? parsed : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function pruneSessionImages(sessionId, env = process.env) {
+    try {
+        rmSync(getSessionImageDir(sessionId, env), { recursive: true, force: true });
+    }
+    catch {
+    }
+}
+export function sweepOrphanSessionImages({ activeSessionIds, maxAgeMs = SESSION_IMAGE_MAX_AGE_MS, env = process.env, now = Date.now(), }) {
+    const baseDir = getSessionImageBaseDir(env);
+    if (!existsSync(baseDir))
+        return 0;
+    let removed = 0;
+    let entries;
+    try {
+        entries = readdirSync(baseDir);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        if (activeSessionIds.has(entry))
+            continue;
+        const dir = path.join(baseDir, entry);
+        try {
+            if (now - statSync(dir).mtimeMs < maxAgeMs)
+                continue;
+            rmSync(dir, { recursive: true, force: true });
+            removed += 1;
+        }
+        catch {
+        }
+    }
+    return removed;
+}

package/dist/src/help-text.js

@@ -66,8 +66,8 @@ const HELP_MARKDOWN = [
     '  picks it up at its next step instead of waiting for the turn to finish, and',
     '  the Your messages panel tracks it from queued to delivered. **↑** brings it',
     '  back for editing and **Esc**/**Ctrl+C** discards it; both unlock the',
-    '  composer for the next message. Messages with images cannot be sent mid-turn',
-    '  and are sent with the next prompt instead.',
+    '  composer for the next message. **Ctrl+V** pastes a screenshot onto the',
+    '  queued message, and it is delivered into the running turn with the text.',
     `- **Paste** into the composer with your terminal's paste shortcut (\`${PASTE_SHORTCUT}\``,
     '  on this system) or by right-clicking the composer.',
     '- **Copy** from the transcript by dragging to select; double-click copies a',

package/dist/src/session-store.js

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from './client-state.js';
+import { findStoredImageByContent, pruneSessionImages, readSessionImage, sweepOrphanSessionImages, } from './core/session-image-store.js';
 import { normalizeAssistantEditJournal } from './edit-journal.js';
 import { createSessionGrants } from './permissions.js';
 import { cloneSessionSafetyState, createSessionSafetyState, mergeLocalSessionSafetyState, normalizeSessionSafetyState, } from './session-safety.js';
@@ -85,6 +86,39 @@ function normalizeBranch(value) {
         .trim();
     return text ? text.slice(0, 120) : null;
 }
+function dehydrateHistoryImages(history) {
+    return history.map((entry) => ({
+        ...entry,
+        parts: (entry.parts ?? []).map((part) => {
+            if (!part?.inlineData?.data)
+                return part;
+            const cachePath = part.imageCachePath ?? findStoredImageByContent(part.inlineData.data);
+            if (!cachePath)
+                return part;
+            return {
+                imageRef: { cachePath, mimeType: part.inlineData.mimeType },
+                text: '[image stored in this session]',
+            };
+        }),
+    }));
+}
+function rehydrateHistoryImages(history) {
+    return history.map((entry) => ({
+        ...entry,
+        parts: (entry.parts ?? []).map((part) => {
+            const ref = part?.imageRef;
+            if (!ref?.cachePath)
+                return part;
+            const stored = readSessionImage(String(ref.cachePath));
+            if (!stored)
+                return { text: part.text ?? '[image no longer available]' };
+            return {
+                inlineData: { mimeType: stored.mimeType, data: stored.base64Data },
+                imageCachePath: ref.cachePath,
+            };
+        }),
+    }));
+}
 function normalizeHistory(value) {
     if (!Array.isArray(value))
         return [];
@@ -154,14 +188,42 @@ function assertSessionNameAvailable(rootDir, name, sessionId, env = process.env)
         throw new Error(`Session name "${name}" is already used by ${duplicate.id}. Use --session "${name}" to resume it or choose a different name.`);
     }
 }
+function listAllSessionIds(env = process.env) {
+    const ids = new Set();
+    const projectsDir = path.join(getSessionBaseDir(env), 'sessions', 'projects');
+    if (!existsSync(projectsDir))
+        return ids;
+    try {
+        for (const project of readdirSync(projectsDir)) {
+            const dir = path.join(projectsDir, project);
+            try {
+                for (const file of readdirSync(dir)) {
+                    if (file.endsWith('.json'))
+                        ids.add(path.basename(file, '.json'));
+                }
+            }
+            catch {
+            }
+        }
+    }
+    catch {
+        return ids;
+    }
+    return ids;
+}
 export function pruneSavedSessions(rootDir, env = process.env) {
     const snapshots = loadAllSnapshots(rootDir, env);
     const keep = new Set(snapshots.slice(0, MAX_RECENT_SESSIONS).map((snapshot) => snapshot.id));
     for (const snapshot of snapshots.slice(MAX_RECENT_SESSIONS)) {
         if (!keep.has(snapshot.id)) {
             rmSync(getSessionPath(rootDir, snapshot.id, env), { force: true });
+            pruneSessionImages(snapshot.id, env);
         }
     }
+    sweepOrphanSessionImages({
+        activeSessionIds: listAllSessionIds(env),
+        env,
+    });
 }
 export function readGitBranch(rootDir) {
     try {

package/dist/src/tools/index.js

@@ -22,6 +22,7 @@ import { shellJobKill } from './shell-job-kill.js';
 import { strReplace } from './str-replace.js';
 import { undoEdit } from './undo-edit.js';
 import { updateTodos } from './update-todos.js';
+import { readImageFile } from './read-image-file.js';
 import { writeFile } from './write-file.js';
 export const TOOL_MAP = {
     search_code: (context, args) => searchCode(context.projectIndex, args),
@@ -50,6 +51,7 @@ export const TOOL_MAP = {
     shell_job_output: shellJobOutput,
     shell_job_kill: shellJobKill,
     update_todos: updateTodos,
+    analyze_image: (context, args) => readImageFile(context, args),
 };
 function invalidToolCall(error) {
     return {

package/dist/src/tools/read-image-file.js

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { normalizeProjectRelativePath } from '../artifact-policy.js';
+import { SessionImageError, getImageStoreSession, isSessionStorePath, readSessionImage, readSessionImageByIndex, storeSessionImageFromPath, } from '../core/session-image-store.js';
+export async function readImageFile(context, args) {
+    const rawPath = String(args.path ?? args.filePath ?? args.file_path ?? '').trim();
+    if (!rawPath) {
+        const requested = Number(args.imageIndex ?? args.image_index ?? args.index);
+        const stored = Number.isInteger(requested)
+            ? readSessionImageByIndex(requested)
+            : null;
+        if (!stored) {
+            return {
+                ok: false,
+                error: Number.isInteger(requested)
+                    ? `Image #${requested} is not in this session's image store.`
+                    : 'path is required and must name an image file on this machine.',
+                failureCategory: Number.isInteger(requested)
+                    ? 'not_found'
+                    : 'missing_required_argument',
+            };
+        }
+        return {
+            ok: true,
+            imageBytes: {
+                base64Data: stored.base64Data,
+                mimeType: stored.mimeType,
+                cachePath: stored.cachePath,
+                index: stored.index,
+            },
+        };
+    }
+    let resolved;
+    if (path.isAbsolute(rawPath)) {
+        resolved = rawPath;
+    }
+    else if (normalizeProjectRelativePath(context.rootDir, rawPath)) {
+        resolved = path.resolve(context.rootDir, rawPath);
+    }
+    else {
+        return {
+            ok: false,
+            error: `Refusing to access path outside the project root: ${rawPath}`,
+            failureCategory: 'permission_denied',
+        };
+    }
+    try {
+        const stored = isSessionStorePath(resolved)
+            ? readSessionImage(resolved)
+            : storeSessionImageFromPath({
+                sessionId: getImageStoreSession() ?? 'unbound',
+                sourcePath: resolved,
+            });
+        if (!stored) {
+            return {
+                ok: false,
+                error: `Not a readable image: ${resolved}`,
+                failureCategory: 'not_found',
+            };
+        }
+        return {
+            ok: true,
+            imageBytes: {
+                base64Data: stored.base64Data,
+                mimeType: stored.mimeType,
+                filePath: resolved,
+                cachePath: stored.cachePath,
+                index: stored.index,
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof SessionImageError) {
+            return {
+                ok: false,
+                error: err.message,
+                failureCategory: err.code === 'NOT_FOUND' ? 'not_found' : 'invalid_argument',
+            };
+        }
+        return {
+            ok: false,
+            error: `Could not read image: ${err?.message ?? err}`,
+            failureCategory: 'tool_exception',
+        };
+    }
+}

package/dist/src/ui/repl.js

@@ -10,6 +10,7 @@ import { isTurnCancelledError } from '../api/chat.js';
 import { getJobBufferedOutput, getJobOutputPreview, hasRunningBackgroundJobs, killAllBackgroundJobs, killBackgroundJob, listBackgroundJobs, setBackgroundJobSession, setBackgroundJobUpdateHook, } from '../background-jobs.js';
 import { clearTodos, listTodos, setTodoSession } from '../todo-list.js';
 import { setScratchSession } from '../scratch-dir.js';
+import { setImageStoreSession } from '../core/session-image-store.js';
 import { cancelActiveCommand } from '../executor.js';
 import { isTurnFailureMarker } from '../turn-failure-marker.js';
 import { clearCliAuthConfig } from '../api/auth.js';
@@ -1347,6 +1348,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
     await withTuiMode(async () => {
         setBackgroundJobSession(session.sessionId);
         setScratchSession(session.sessionId);
+        setImageStoreSession(session.sessionId);
         setTodoSession(session.sessionId);
         const store = createShellStore(createInitialShellState(session, serverModels, debugUi));
         store.replaceTranscript(createSessionTranscript(session));
@@ -2163,6 +2165,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 applySessionSnapshot(session, snapshot);
                 setBackgroundJobSession(session.sessionId);
                 setScratchSession(session.sessionId);
+                setImageStoreSession(session.sessionId);
                 syncBackgroundJobsState();
                 setTodoSession(session.sessionId);
                 syncTodosState();
@@ -2267,14 +2270,11 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             const text = (queued.pastedChunks.length
                 ? expandPastedChunks(queued.body, queued.pastedChunks)
                 : queued.body).trim();
-            if (!text)
+            const images = queued.imageAttachments.filter((attachment) => queued.body.includes(`[Image #${attachment.index}]`));
+            if (!text && images.length === 0)
                 return;
             const turnId = activeServerTurnId;
-            const blockedReason = queued.imageAttachments.length > 0
-                ? 'waiting — images go with the next prompt'
-                : !turnId
-                    ? 'waiting for the turn to end'
-                    : null;
+            const blockedReason = !turnId ? 'waiting for the turn to end' : null;
             const existingRow = blockedRows.get(queued);
             if (existingRow !== undefined) {
                 upsertTurnMessage(existingRow, {
@@ -2331,6 +2331,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     turnId,
                     text,
                     messageId,
+                    imageAttachments: images,
                 });
             }
             catch (error) {
@@ -2360,9 +2361,10 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     return;
                 }
                 const pending = store.getState();
+                const body = String(rawInput ?? '');
                 const snapshot = {
-                    body: String(rawInput ?? ''),
-                    imageAttachments: pending.imageAttachments,
+                    body,
+                    imageAttachments: pending.imageAttachments.filter((attachment) => body.includes(`[Image #${attachment.index}]`)),
                     pastedChunks: pending.pastedChunks,
                 };
                 scheduleLiveFrameRemount();
@@ -2377,11 +2379,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 }));
                 return;
             }
-            const imageAttachments = store.getState().imageAttachments;
+            const imageAttachments = store
+                .getState()
+                .imageAttachments.filter((attachment) => input.includes(`[Image #${attachment.index}]`));
             scheduleLiveFrameRemount();
             store.update((current) => ({
                 ...current,
                 cursor: 0,
+                imageAttachments: [],
                 input: '',
                 pastedChunks: [],
                 promptHistory: appendPromptToHistory(current.promptHistory, input),
@@ -2564,6 +2569,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 startNewConversation(session);
                 setBackgroundJobSession(session.sessionId);
                 setScratchSession(session.sessionId);
+                setImageStoreSession(session.sessionId);
                 setTodoSession(session.sessionId);
                 clearTodos();
                 syncBackgroundJobsState();
@@ -2975,6 +2981,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             killAllBackgroundJobs();
             setBackgroundJobSession(null);
             setScratchSession(null);
+            setImageStoreSession(null);
             setTodoSession(null);
             setBackgroundJobUpdateHook(null);
             await bridge.close();

package/dist/src/ui/tui/shell-input.js

@@ -1,4 +1,6 @@
 import { readClipboardImage, readClipboardText } from '../../core/clipboard.js';
+import { MAX_IMAGES_PER_MESSAGE, MAX_TOTAL_IMAGE_BYTES_PER_MESSAGE, approximateBase64DecodedBytes, totalAttachmentBytes, } from '../../core/image-limits.js';
+import { tryCacheAttachmentBytes } from '../../core/session-image-store.js';
 import { applySlashCommandSuggestion, buildModelPickerOptions, deleteAtCursor, deleteBeforeCursor, getInputCommandToken, getNextApprovalCursor, getNextModelPickerIndex, getSlashCommandSuggestions, insertAtCursor, isExactSlashCommandToken, navigatePromptHistory, shouldRemountLiveFrameForComposerInputChange, } from '../repl.js';
 import { buildPastePlaceholder, shouldCollapsePaste, } from '../paste-collapse.js';
 import { handleUserInputPromptEvent, } from './user-input.js';
@@ -446,7 +448,7 @@ export function handleShellKeyEvent(store, handlers, event) {
             void handlers.onFireQueuedMessage?.();
             return;
         }
-        if (!key.upArrow) {
+        if (!key.upArrow && !isClipboardImagePasteKey(key)) {
             return;
         }
     }
@@ -577,12 +579,16 @@ export function handleShellKeyEvent(store, handlers, event) {
     }
     if (isClipboardImagePasteKey(key)) {
         const current = store.getState();
-        if (current.busy)
-            return;
-        const liveAttachments = current.imageAttachments.filter((attachment) => current.input.includes(`[Image #${attachment.index}]`));
-        if (liveAttachments.length >= 2) {
+        const target = current.queuedMessage
+            ? {
+                body: current.queuedMessage.body,
+                attachments: current.queuedMessage.imageAttachments,
+            }
+            : { body: current.input, attachments: current.imageAttachments };
+        const liveAttachments = target.attachments.filter((attachment) => target.body.includes(`[Image #${attachment.index}]`));
+        if (liveAttachments.length >= MAX_IMAGES_PER_MESSAGE) {
             store.appendEntry({
-                body: 'Maximum of 2 images per message. Send the current message first.',
+                body: `Maximum of ${MAX_IMAGES_PER_MESSAGE} images per message. Send the current message first.`,
                 kind: 'error',
                 title: 'Image',
             });
@@ -590,22 +596,49 @@ export function handleShellKeyEvent(store, handlers, event) {
         }
         try {
             const clipResult = readClipboardImage();
+            if (totalAttachmentBytes(liveAttachments) +
+                approximateBase64DecodedBytes(clipResult.base64Data) >
+                MAX_TOTAL_IMAGE_BYTES_PER_MESSAGE) {
+                store.appendEntry({
+                    body: `This image would put the message over the ${Math.round(MAX_TOTAL_IMAGE_BYTES_PER_MESSAGE / 1024 / 1024)}MB combined image limit. Send the current message first.`,
+                    kind: 'error',
+                    title: 'Image',
+                });
+                return;
+            }
             const idx = liveAttachments.length === 0
                 ? 1
                 : Math.max(...liveAttachments.map((attachment) => attachment.index)) + 1;
-            store.update((shellState) => ({
-                ...shellState,
-                imageAttachments: [
-                    ...liveAttachments,
-                    {
-                        index: idx,
-                        mimeType: clipResult.mimeType,
-                        base64Data: clipResult.base64Data,
-                        source: 'clipboard',
-                    },
-                ],
-                ...insertAtCursor(shellState, `[Image #${idx}] `),
-            }));
+            const cached = tryCacheAttachmentBytes({
+                base64Data: clipResult.base64Data,
+                mimeType: clipResult.mimeType,
+            });
+            const attachment = {
+                index: cached?.index ?? idx,
+                mimeType: clipResult.mimeType,
+                base64Data: clipResult.base64Data,
+                source: 'clipboard',
+                ...(cached ? { cachePath: cached.cachePath } : {}),
+            };
+            const marker = attachment.index;
+            store.update((shellState) => {
+                const nextAttachments = [...liveAttachments, attachment];
+                if (shellState.queuedMessage) {
+                    return {
+                        ...shellState,
+                        queuedMessage: {
+                            ...shellState.queuedMessage,
+                            body: `${shellState.queuedMessage.body} [Image #${marker}]`.trim(),
+                            imageAttachments: nextAttachments,
+                        },
+                    };
+                }
+                return {
+                    ...shellState,
+                    imageAttachments: nextAttachments,
+                    ...insertAtCursor(shellState, `[Image #${marker}] `),
+                };
+            });
         }
         catch (error) {
             if (error?.code === 'NO_IMAGE') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.20",
+  "version": "1.0.0-preview.21",
   "description": "TheGitAI is an AI coding agent for your terminal. It indexes your repository, writes and edits files, runs commands, and builds features with you.",
   "keywords": [
     "ai",
@@ -37,10 +37,10 @@
     "@lydell/node-pty-linux-x64": "1.1.0",
     "@lydell/node-pty-win32-arm64": "1.1.0",
     "@lydell/node-pty-win32-x64": "1.1.0",
-    "@thegitai/tui-darwin-arm64": "1.0.0-preview.20",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.20",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.20",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.20",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.21",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.21",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.21",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.21",
     "@vscode/ripgrep": "1.18.0"
   },
   "publishConfig": {