@thegitai/cli 1.0.0-preview.4 → 1.0.0-preview.41

package/dist/src/browser/native-host.js

@@ -0,0 +1,209 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { EXTENSION_IDS, NATIVE_HOST_NAME } from './protocol.js';
+function browserConfigRoots(env, platform) {
+    const home = env.HOME ?? os.homedir();
+    if (platform === 'win32') {
+        const local = env.LOCALAPPDATA ?? path.join(home, 'AppData', 'Local');
+        return [
+            path.join(local, 'Google', 'Chrome', 'User Data'),
+            path.join(local, 'Google', 'Chrome Beta', 'User Data'),
+            path.join(local, 'Chromium', 'User Data'),
+            path.join(local, 'Microsoft', 'Edge', 'User Data'),
+            path.join(local, 'BraveSoftware', 'Brave-Browser', 'User Data'),
+            path.join(local, 'Vivaldi', 'User Data'),
+        ];
+    }
+    if (platform === 'darwin') {
+        const support = path.join(home, 'Library', 'Application Support');
+        return [
+            path.join(support, 'Google', 'Chrome'),
+            path.join(support, 'Google', 'Chrome Beta'),
+            path.join(support, 'Chromium'),
+            path.join(support, 'Microsoft Edge'),
+            path.join(support, 'BraveSoftware', 'Brave-Browser'),
+            path.join(support, 'Vivaldi'),
+            path.join(support, 'Arc', 'User Data'),
+        ];
+    }
+    const configHome = env.XDG_CONFIG_HOME ?? path.join(home, '.config');
+    return [
+        path.join(configHome, 'google-chrome'),
+        path.join(configHome, 'google-chrome-beta'),
+        path.join(configHome, 'chromium'),
+        path.join(configHome, 'microsoft-edge'),
+        path.join(configHome, 'BraveSoftware', 'Brave-Browser'),
+        path.join(configHome, 'vivaldi'),
+    ];
+}
+function thegitaiHome(env, platform = process.platform) {
+    if (platform === 'win32') {
+        const local = env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        return env.THEGITAI_HOME ?? path.join(local, 'thegitai');
+    }
+    return env.THEGITAI_HOME ?? path.join(env.HOME ?? os.homedir(), '.thegitai');
+}
+function writeLauncher(env, hostScript, platform = process.platform) {
+    const dir = thegitaiHome(env, platform);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (platform === 'win32') {
+        const launcherPath = path.join(dir, 'browser-bridge-host.bat');
+        const contents = [
+            '@echo off',
+            `"${process.execPath}" "${hostScript}" %*`,
+            '',
+        ].join('\r\n');
+        const existingBat = fs.existsSync(launcherPath)
+            ? fs.readFileSync(launcherPath, 'utf8')
+            : null;
+        if (existingBat === contents)
+            return { launcherPath, changed: false };
+        fs.writeFileSync(launcherPath, contents);
+        return { launcherPath, changed: true };
+    }
+    const launcherPath = path.join(dir, 'browser-bridge-host.sh');
+    const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+    const contents = `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(hostScript)} "$@"\n`;
+    const existing = fs.existsSync(launcherPath) ? fs.readFileSync(launcherPath, 'utf8') : null;
+    if (existing === contents) {
+        try {
+            fs.chmodSync(launcherPath, 0o700);
+        }
+        catch {
+        }
+        return { launcherPath, changed: false };
+    }
+    fs.writeFileSync(launcherPath, contents, { mode: 0o700 });
+    fs.chmodSync(launcherPath, 0o700);
+    return { launcherPath, changed: true };
+}
+function resolveHostScript() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(here, '..', '..', 'bin', 'browser-host.js');
+}
+export function registerNativeHost({ env = process.env, platform = process.platform, hostScript = resolveHostScript(), } = {}) {
+    const errors = [];
+    const manifests = [];
+    let changed = false;
+    const { launcherPath, changed: launcherChanged } = writeLauncher(env, hostScript, platform);
+    changed = launcherChanged;
+    const manifest = {
+        name: NATIVE_HOST_NAME,
+        description: 'TheGitAI browser bridge',
+        path: launcherPath,
+        type: 'stdio',
+        allowed_origins: EXTENSION_IDS.map((id) => `chrome-extension://${id}/`),
+    };
+    const serialized = `${JSON.stringify(manifest, null, 2)}\n`;
+    if (platform === 'win32') {
+        return registerWindowsNativeHost({ env, serialized, launcherPath, changed });
+    }
+    for (const root of browserConfigRoots(env, platform)) {
+        if (!fs.existsSync(root))
+            continue;
+        const dir = path.join(root, 'NativeMessagingHosts');
+        const file = path.join(dir, `${NATIVE_HOST_NAME}.json`);
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+            const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : null;
+            if (existing !== serialized) {
+                fs.writeFileSync(file, serialized, { mode: 0o600 });
+                changed = true;
+            }
+            manifests.push(file);
+        }
+        catch (error) {
+            errors.push(`${file}: ${error?.message ?? error}`);
+        }
+    }
+    return { manifests, launcherPath, changed, errors };
+}
+const WINDOWS_REGISTRY_ROOTS = [
+    { userData: 'Google\\Chrome', key: 'Software\\Google\\Chrome' },
+    { userData: 'Google\\Chrome Beta', key: 'Software\\Google\\Chrome Beta' },
+    { userData: 'Chromium', key: 'Software\\Chromium' },
+    { userData: 'Microsoft\\Edge', key: 'Software\\Microsoft\\Edge' },
+    { userData: 'BraveSoftware\\Brave-Browser', key: 'Software\\BraveSoftware\\Brave-Browser' },
+    { userData: 'Vivaldi', key: 'Software\\Vivaldi' },
+];
+function registerWindowsNativeHost({ env, serialized, launcherPath, changed, }) {
+    const errors = [];
+    const manifests = [];
+    let dirty = changed;
+    const manifestPath = path.join(thegitaiHome(env, 'win32'), `${NATIVE_HOST_NAME}.json`);
+    try {
+        fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+        const existing = fs.existsSync(manifestPath)
+            ? fs.readFileSync(manifestPath, 'utf8')
+            : null;
+        if (existing !== serialized) {
+            fs.writeFileSync(manifestPath, serialized);
+            dirty = true;
+        }
+        manifests.push(manifestPath);
+    }
+    catch (error) {
+        errors.push(`${manifestPath}: ${error?.message ?? error}`);
+        return { manifests, launcherPath, changed: dirty, errors };
+    }
+    const local = env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+    for (const browser of WINDOWS_REGISTRY_ROOTS) {
+        if (!fs.existsSync(path.join(local, browser.userData, 'User Data')))
+            continue;
+        const key = `HKCU\\${browser.key}\\NativeMessagingHosts\\${NATIVE_HOST_NAME}`;
+        try {
+            const current = readRegistryDefault(key);
+            if (current === manifestPath)
+                continue;
+            execFileSync('reg.exe', ['add', key, '/ve', '/t', 'REG_SZ', '/d', manifestPath, '/f'], { timeout: 5000, stdio: ['ignore', 'ignore', 'pipe'] });
+            dirty = true;
+        }
+        catch (error) {
+            errors.push(`${key}: ${error?.message ?? error}`);
+        }
+    }
+    return { manifests, launcherPath, changed: dirty, errors };
+}
+function readRegistryDefault(key) {
+    try {
+        const output = execFileSync('reg.exe', ['query', key, '/ve'], {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const match = /\(Default\)\s+REG_SZ\s+(.+?)\s*$/m.exec(output);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function chromiumProcessRunning(platform = process.platform) {
+    if (platform === 'win32') {
+        try {
+            const output = execFileSync('tasklist.exe', ['/fo', 'csv', '/nh'], {
+                encoding: 'utf8',
+                timeout: 4000,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return /"(chrome|chromium|msedge|brave|vivaldi)\.exe"/i.test(output);
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        const output = execFileSync('ps', ['-eo', 'comm='], {
+            encoding: 'utf8',
+            timeout: 2000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return /(google[- ]?chrome|chromium|brave|msedge|microsoft edge|vivaldi)/i.test(output);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/browser/protocol.js

@@ -0,0 +1,46 @@
+import os from 'node:os';
+import path from 'node:path';
+export const BROWSER_PROTOCOL_VERSION = 1;
+export const NATIVE_HOST_NAME = 'ai.thegit.browser_bridge';
+export const EXTENSION_IDS = [
+    'neleeiihdnddldafklledbkembkfagol',
+    'jipbjphlelfilkhdjkfdficafjhgjfmk',
+];
+export function browserRuntimeDir(env = process.env, platform = process.platform) {
+    if (platform === 'win32') {
+        const local = env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        return path.join(env.THEGITAI_HOME ?? path.join(local, 'thegitai'), 'browser');
+    }
+    const runtime = env.XDG_RUNTIME_DIR;
+    if (runtime && path.isAbsolute(runtime)) {
+        return path.join(runtime, 'thegitai', 'browser');
+    }
+    return path.join(env.THEGITAI_HOME ?? path.join(os.homedir(), '.thegitai'), 'browser');
+}
+const WINDOWS_PIPE_PREFIX = '\\\\.\\pipe\\';
+export function sessionSocketPath(dir, sessionKey, platform = process.platform) {
+    if (platform === 'win32') {
+        return `${WINDOWS_PIPE_PREFIX}thegitai-browser-${sessionKey}`;
+    }
+    return path.join(dir, `s-${sessionKey}.sock`);
+}
+export function socketIsFile(platform = process.platform) {
+    return platform !== 'win32';
+}
+export function sessionKeyFromRecordFile(fileName) {
+    const match = /^s-(.+)\.json$/.exec(fileName);
+    return match ? match[1] : null;
+}
+export function sessionRecordPath(dir, sessionKey) {
+    return path.join(dir, `s-${sessionKey}.json`);
+}
+export function protocolMismatchMessage(theirs) {
+    const version = Number(theirs);
+    if (!Number.isInteger(version)) {
+        return 'The TheGitAI extension did not report a protocol version. Update both TheGitAI and the extension.';
+    }
+    if (version < BROWSER_PROTOCOL_VERSION) {
+        return `The TheGitAI extension speaks browser protocol v${version}; this CLI speaks v${BROWSER_PROTOCOL_VERSION}. Update the extension from the Chrome Web Store.`;
+    }
+    return `The TheGitAI extension speaks browser protocol v${version}; this CLI speaks v${BROWSER_PROTOCOL_VERSION}. Update TheGitAI: npm i -g @thegitai/cli`;
+}

package/dist/src/browser/session-bridge.js

@@ -0,0 +1,104 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getClientStateDir } from '../client-state.js';
+import { pruneStaleSessions, startBrowserBridge, } from './bridge.js';
+import { chromiumProcessRunning } from './native-host.js';
+let bridge = null;
+let recentEvents = [];
+const processKey = `${process.pid.toString(36)}${crypto.randomBytes(3).toString('hex')}`;
+export function ensureBrowserBridge(options) {
+    if (bridge)
+        return bridge;
+    const env = options.env ?? process.env;
+    pruneStaleSessions(env);
+    bridge = startBrowserBridge({
+        sessionKey: processKey,
+        label: path.basename(options.cwd) || 'TheGitAI',
+        cwd: options.cwd,
+        env,
+    });
+    bridge.onEvent((event, data) => {
+        if (event === 'connected')
+            rememberBrowserExtensionSeen(env);
+        recentEvents.push({ event, data, at: Date.now() });
+        if (recentEvents.length > 50)
+            recentEvents.splice(0, recentEvents.length - 50);
+    });
+    return bridge;
+}
+function browserExtensionMarkerPath(env) {
+    return path.join(getClientStateDir(env), 'browser-extension-seen');
+}
+function rememberBrowserExtensionSeen(env) {
+    try {
+        const marker = browserExtensionMarkerPath(env);
+        if (fs.existsSync(marker))
+            return;
+        fs.mkdirSync(path.dirname(marker), { recursive: true });
+        fs.writeFileSync(marker, `${new Date().toISOString()}\n`);
+    }
+    catch {
+    }
+}
+export function browserExtensionSeen(env = process.env) {
+    try {
+        return fs.existsSync(browserExtensionMarkerPath(env));
+    }
+    catch {
+        return true;
+    }
+}
+export function startBrowserDiscoveryInBackground(options) {
+    setImmediate(() => {
+        try {
+            ensureBrowserBridge(options);
+        }
+        catch {
+        }
+    });
+}
+export function currentBrowserBridge() {
+    return bridge;
+}
+export function releaseBrowserAfterTurn() {
+    const active = bridge;
+    if (!active?.status().connected)
+        return;
+    void active
+        .request('release', {}, { timeoutMs: 5000 })
+        .catch(() => {
+    });
+}
+export function closeBrowserBridge() {
+    bridge?.close();
+    bridge = null;
+    recentEvents = [];
+}
+export function drainBrowserEvents() {
+    const events = recentEvents.map(({ event, data }) => ({ event, data }));
+    recentEvents = [];
+    return events;
+}
+export function browserAvailability(options) {
+    const active = ensureBrowserBridge(options);
+    const status = active.status();
+    if (status.connected) {
+        return {
+            connected: true,
+            browsers: status.browsers,
+            selected: status.selected,
+        };
+    }
+    const hint = status.registrationErrors.length
+        ? `TheGitAI could not register its browser bridge with Chrome: ${status.registrationErrors[0]}`
+        : chromiumProcessRunning()
+            ? 'Chrome is running but the TheGitAI extension has not connected. Install or enable the extension, then reload it from chrome://extensions.'
+            : 'Chrome does not appear to be running. Open Chrome with the TheGitAI extension installed.';
+    return {
+        connected: false,
+        browsers: [],
+        selected: null,
+        hint,
+    };
+}

package/dist/src/cli-args.js

@@ -1,9 +1,24 @@
 export const AUTH_COMMANDS = new Set(['login', 'whoami', 'logout']);
+function hasPromptWordsAfter(args) {
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--session' || arg === '--resume') {
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('-'))
+            continue;
+        return true;
+    }
+    return false;
+}
 export function parseArgs(argv) {
     const args = argv.slice(2);
     const firstArg = args[0];
-    const command = firstArg && AUTH_COMMANDS.has(firstArg) ? firstArg : null;
-    const commandArgs = command ? args.slice(1) : [];
+    const command = firstArg && AUTH_COMMANDS.has(firstArg) &&
+        (firstArg !== 'login' || !hasPromptWordsAfter(args))
+        ? firstArg
+        : null;
     let autoYes = false;
     let help = false;
     let version = false;
@@ -12,7 +27,7 @@ export function parseArgs(argv) {
     let listSessions = false;
     let unknownOption = null;
     const promptParts = [];
-    for (let i = 0; i < args.length; i++) {
+    for (let i = command ? 1 : 0; i < args.length; i++) {
         const arg = args[i];
         if (arg === '--yes' || arg === '-y') {
             autoYes = true;
@@ -39,7 +54,7 @@ export function parseArgs(argv) {
             usage = true;
             continue;
         }
-        if (command === null && unknownOption === null && /^-/.test(arg)) {
+        if (unknownOption === null && /^-/.test(arg)) {
             unknownOption = arg;
             continue;
         }
@@ -47,7 +62,6 @@ export function parseArgs(argv) {
     }
     return {
         command,
-        commandArgs,
         autoYes,
         help,
         version,

package/dist/src/client-environment.js

@@ -2,6 +2,7 @@ import { accessSync, constants, readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { ensureSessionScratchDir } from './scratch-dir.js';
+import { browserExtensionSeen } from './browser/session-bridge.js';
 const PACKAGE_MANAGER_CANDIDATES = [
     'apt',
     'apt-get',
@@ -125,5 +126,6 @@ export function collectClientEnvironment(options = {}) {
         ...linuxDistro,
         packageManagers: detectPackageManagers(env, platform, executableExists),
         scratchDir: options.scratchDir ?? ensureSessionScratchDir(),
+        browserExtensionSeen: options.browserExtensionSeen ?? browserExtensionSeen(env),
     };
 }

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}]`);