@turns/dev 0.0.13 → 0.0.15

package/dist/daemon.js

@@ -4,6 +4,8 @@ import path from 'node:path';
 import process from 'node:process';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { AGENT_SLICE_NAME } from "./agent-isolation.js";
+import { executablePath } from "./executable-path.js";
 import { applicationPaths } from "./auth.js";
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 /** Resolve linked-worktree installs back to the primary checkout. A service
@@ -41,7 +43,7 @@ export const MAC_LAUNCH_AGENT_LABEL = 'dev.turns.cli';
 function systemdQuote(value) {
     return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%')}"`;
 }
-export function linuxServiceUnit({ cliEntry = canonicalDaemonCliEntry(), execPath = process.execPath } = {}) {
+export function linuxServiceUnit({ cliEntry = canonicalDaemonCliEntry(), execPath = process.execPath, pathEnvironment = executablePath(), } = {}) {
     return `[Unit]
 Description=Continuously upload local AI sessions to turns.dev
 Wants=network-online.target
@@ -56,11 +58,23 @@ ExecStart=${systemdQuote(execPath)} --max-old-space-size=256 --max-semi-space-si
 Restart=on-failure
 RestartSec=5
 Environment=NODE_NO_WARNINGS=1
+Environment=${systemdQuote(`PATH=${pathEnvironment}`)}
 
 [Install]
 WantedBy=default.target
 `;
 }
+/** Monitor agents separately, before pressure reaches the user-manager limit. */
+export function linuxAgentSliceUnit() {
+    return `[Unit]
+Description=Turns agent workloads
+
+[Slice]
+MemoryAccounting=yes
+ManagedOOMMemoryPressure=kill
+ManagedOOMMemoryPressureLimit=40%
+`;
+}
 function xmlEscape(value) {
     return String(value)
         .replaceAll('&', '&')
@@ -140,6 +154,10 @@ export function installLinuxDaemon({ paths = applicationPaths(), spawnSyncImpl =
     const temporary = `${paths.linuxService}.${process.pid}.tmp`;
     fs.writeFileSync(temporary, unit, { mode: 0o644 });
     fs.renameSync(temporary, paths.linuxService);
+    const slicePath = path.join(path.dirname(paths.linuxService), AGENT_SLICE_NAME);
+    const sliceTemporary = `${slicePath}.${process.pid}.tmp`;
+    fs.writeFileSync(sliceTemporary, linuxAgentSliceUnit(), { mode: 0o644 });
+    fs.renameSync(sliceTemporary, slicePath);
     systemctl(['disable', '--now', LEGACY_SYSTEMD_SERVICE_NAME], { spawnSyncImpl, allowFailure: true });
     const unitDirectory = path.dirname(paths.linuxService);
     for (const legacyLink of [
@@ -174,6 +192,7 @@ export function uninstallLinuxDaemon({ paths = applicationPaths(), spawnSyncImpl
         if (error?.code !== 'ENOENT')
             throw error;
     }
+    fs.rmSync(path.join(path.dirname(paths.linuxService), AGENT_SLICE_NAME), { force: true });
     systemctl(['daemon-reload'], { spawnSyncImpl, allowFailure: true });
 }
 export function linuxDaemonStatus({ spawnSyncImpl = spawnSync } = {}) {

package/dist/executable-path.js

@@ -0,0 +1,19 @@
+import os from 'node:os';
+import path from 'node:path';
+/** Preserve explicit PATH precedence and add installations absent from service environments. */
+export function executablePath(env = process.env, home = os.homedir(), execPath = process.execPath) {
+    return [
+        ...new Set([
+            ...String(env.PATH || '').split(path.delimiter),
+            path.dirname(execPath),
+            path.join(home, '.local', 'bin'),
+            path.join(home, 'bin'),
+            path.join(home, '.npm-global', 'bin'),
+            ...(env.NPM_CONFIG_PREFIX ? [path.join(env.NPM_CONFIG_PREFIX, 'bin')] : []),
+            '/opt/homebrew/bin',
+            '/usr/local/bin',
+            '/usr/bin',
+            '/bin',
+        ].filter((directory) => path.isAbsolute(directory))),
+    ].join(path.delimiter);
+}

package/dist/file-browsing.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { workingDirectoryIsAllowed } from "./directory-policy.js";
-import { uploadFileStream } from "./path-resolution.js";
+import { storedFileMetadata, uploadFileStream } from "./path-resolution.js";
 /**
  * Answering "what is in that directory?" from the machine that knows.
  *
@@ -248,6 +248,22 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
     if (resolved.stat.size > MAX_BROWSE_FILE_BYTES) {
         throw new Error(`File is larger than the ${BROWSE_FILE_LIMIT_LABEL} browse limit.`);
     }
+    // Compare metadata attached to the R2 object, not the directory index:
+    // directory observations can already describe newer, unuploaded bytes.
+    // Post-edit hashes always force an upload, even when mtime was preserved.
+    if (resolved.stat.size > 0 && !contentEtag) {
+        const cached = await storedFileMetadata({ baseUrl, options, machine, absolutePath: resolved.path, fetchImpl });
+        // The file can change while its stored metadata is being fetched.
+        resolved.stat = fs.statSync(resolved.path);
+        if (!resolved.stat.isFile())
+            throw new Error('The file changed while its stored metadata was being checked.');
+        if (resolved.stat.size > MAX_BROWSE_FILE_BYTES)
+            throw new Error(`File is larger than the ${BROWSE_FILE_LIMIT_LABEL} browse limit.`);
+        const modifiedAt = isoTime(resolved.stat.mtimeMs);
+        if (cached && cached.bytes === resolved.stat.size && cached.modifiedAt === modifiedAt) {
+            return { path: resolved.path, kind: 'file', bytes: cached.bytes, contentType: cached.contentType, modifiedAt };
+        }
+    }
     const sample = readFileTypeSample(resolved.path, resolved.stat.size);
     const contentType = browseContentType(resolved.path, sample, sample.byteLength === resolved.stat.size);
     const modifiedAt = isoTime(resolved.stat.mtimeMs);

package/dist/harness-account.js

@@ -0,0 +1,299 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/** Fixed, read-only CLI commands. Never invoke a prompt, login, or config dump. */
+export const NATIVE_ACCOUNT_COMMANDS = {
+    cursor: ['status', '--format', 'json'],
+    devin: ['auth', 'status'],
+    kilo: ['profile', '--json'],
+};
+function text(value, limit = 160) {
+    if (typeof value !== 'string')
+        return '';
+    const result = value.trim();
+    if (result.length > limit || /[\x00-\x1f]|(?:sk-|gh[pousr]_|github_pat_|eyJ)[A-Za-z0-9_-]{12}/u.test(result))
+        return '';
+    return result;
+}
+/** Allowlisted display metadata, never serialized credentials or arbitrary messages. */
+export function accountSummary(value) {
+    if (!value || typeof value !== 'object')
+        return '';
+    const identity = text(value.email) || text(value.login) || text(value.username) || text(value.name);
+    const plan = text(value.planType ?? value.subscriptionType ?? value.plan_name ?? value.plan, 80);
+    return [identity, plan ? `(${plan})` : ''].filter(Boolean).join(' ');
+}
+function jsonDocument(output) {
+    try {
+        // Some CLIs put warnings before their JSON response.
+        return JSON.parse(output.slice(output.indexOf('{'), output.lastIndexOf('}') + 1));
+    }
+    catch {
+        return null;
+    }
+}
+export function parseNativeHarnessAccount(harness, output) {
+    const clean = output.replace(/\u001b\[[0-9;?]*[A-Za-z]/g, '');
+    if (harness === 'devin') {
+        if (/not logged in|not authenticated/iu.test(clean))
+            return { authenticated: false };
+        if (!/^Logged in/mu.test(clean))
+            return null;
+        const email = clean.match(/^\s*Email:\s*(.+)$/mu)?.[1];
+        const plan = clean.match(/^\s*Plan:\s*(.+)$/mu)?.[1] || clean.match(/^\s*Tier:\s*(.+)$/mu)?.[1];
+        const account = accountSummary({ email, plan });
+        return { authenticated: true, ...(account ? { account } : {}) };
+    }
+    const data = jsonDocument(clean);
+    if (!data)
+        return null;
+    if (harness === 'cursor') {
+        if (typeof data.isAuthenticated !== 'boolean')
+            return null;
+        const email = data.email ||
+            data.user?.email ||
+            clean.match(/[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/u)?.[0];
+        const account = accountSummary({ email, plan: data.membershipType || data.plan });
+        return { authenticated: data.isAuthenticated, ...(data.isAuthenticated && account ? { account } : {}) };
+    }
+    if (harness === 'kilo') {
+        const account = accountSummary(data.user ?? data.profile ?? data);
+        return account ? { authenticated: true, account } : null;
+    }
+    return null;
+}
+/** JSONC support for Copilot, preserving quoted URLs and trailing-comma strings. */
+function readJson(file) {
+    try {
+        if (fs.statSync(file).size > 1024 * 1024)
+            return null;
+        const content = fs
+            .readFileSync(file, 'utf8')
+            .replace(/("(?:\\.|[^"\\])*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//gu, (_match, quoted) => quoted || '')
+            .replace(/("(?:\\.|[^"\\])*")|,\s*(?=[}\]])/gu, (_match, quoted) => quoted || '');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/** Decode only display claims locally. They are NOT proof that a grant is valid. */
+function tokenAccount(value) {
+    if (typeof value !== 'string' || value.length > 32_768)
+        return '';
+    try {
+        const claims = JSON.parse(Buffer.from(value.split('.')[1], 'base64url').toString('utf8'));
+        return accountSummary({
+            email: claims.email || claims['https://api.openai.com/profile']?.email,
+            username: claims.preferred_username,
+            plan: claims['https://api.openai.com/auth']?.chatgpt_plan_type,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+function credentialSummary(value) {
+    if (!value || typeof value !== 'object')
+        return '';
+    const tokens = value.tokens ?? value;
+    return (accountSummary(value.user) ||
+        accountSummary(value.account) ||
+        accountSummary(value) ||
+        tokenAccount(tokens.id_token ?? tokens.idToken) ||
+        tokenAccount(tokens.access_token ?? tokens.accessToken ?? tokens.access ?? tokens.token));
+}
+function stored(account) {
+    return account ? { authenticated: null, account: account.slice(0, 512) } : null;
+}
+const PROVIDER_LABELS = {
+    'openai-codex': 'ChatGPT',
+    anthropic: 'Claude',
+    'github-copilot': 'Copilot',
+    'google-gemini-cli': 'Gemini',
+    'google-antigravity': 'Antigravity',
+    opencode: 'OpenCode Zen',
+    'opencode-go': 'OpenCode Go',
+    kilo: 'Kilo',
+};
+/** Multiple configured providers stay explicitly labelled; never pick an arbitrary
+ * saved account and present it as the selected model's subscription. */
+function providerAccounts(providers) {
+    if (!providers || typeof providers !== 'object' || Array.isArray(providers))
+        return null;
+    const entries = Object.entries(providers)
+        .slice(0, 8)
+        .flatMap(([id, credential]) => {
+        if (!credential || typeof credential !== 'object')
+            return [];
+        const label = PROVIDER_LABELS[id] || text(id, 60);
+        if (!label)
+            return [];
+        const identity = credentialSummary(credential);
+        const method = credential.type === 'oauth' || credential.tokens
+            ? 'OAuth configured'
+            : credential.type === 'api' || credential.type === 'api_key'
+                ? 'API key configured'
+                : '';
+        return identity || method ? [`${label}: ${identity || method}`] : [];
+    });
+    return stored(entries.join('; '));
+}
+/** Local metadata is a saved account hint, not a live auth/entitlement check.
+ * Read only each harness's own store, honour home overrides, and never send keys,
+ * access/refresh tokens, or a whole configuration over the socket. Missing,
+ * opaque, encrypted, or unfamiliar stores report unknown rather than signed out. */
+export function readLocalHarnessAccount(harness, { home = os.homedir(), env = process.env } = {}) {
+    const dataHome = env.XDG_DATA_HOME || path.join(home, '.local/share');
+    const configHome = env.XDG_CONFIG_HOME || path.join(home, '.config');
+    const read = (...parts) => readJson(path.join(...parts));
+    if (harness === 'copilot') {
+        if (env.COPILOT_GITHUB_TOKEN || env.GH_TOKEN || env.GITHUB_TOKEN)
+            return stored('GitHub token configured');
+        const config = read(env.COPILOT_HOME || path.join(home, '.copilot'), 'config.json');
+        const user = config?.lastLoggedInUser;
+        const login = text(user?.login);
+        return stored(login ? `@${login}` : '');
+    }
+    if (harness === 'gemini' || harness === 'qwen') {
+        const root = path.join(harness === 'gemini' ? env.GEMINI_CLI_HOME || home : home, `.${harness}`);
+        const config = read(root, 'settings.json');
+        const authType = config?.security?.auth?.selectedType;
+        if (authType && !['oauth-personal', 'qwen-oauth'].includes(authType)) {
+            return stored(authType === 'vertex-ai' ? 'Vertex AI configured' : 'API key configured');
+        }
+        if (harness === 'gemini') {
+            const email = text(read(root, 'google_accounts.json')?.active);
+            if (email)
+                return stored(email);
+        }
+        return stored(credentialSummary(read(root, 'oauth_creds.json')));
+    }
+    if (harness === 'grok') {
+        if (env.XAI_API_KEY || env.GROK_API_KEY)
+            return stored('API key configured');
+        const auth = read(env.GROK_HOME || path.join(home, '.grok'), 'auth.json');
+        const accounts = Object.values(auth ?? {})
+            .map(credentialSummary)
+            .filter(Boolean);
+        return stored([...new Set(accounts)].join('; '));
+    }
+    if (harness === 'kimi') {
+        const root = env.KIMI_SHARE_DIR || path.join(home, '.kimi');
+        // The Python and newer standalone CLIs use separate credential roots.
+        for (const directory of [path.join(root, 'credentials'), path.join(home, '.kimi-code/credentials')]) {
+            try {
+                const accounts = fs
+                    .readdirSync(directory)
+                    .filter((name) => name.endsWith('.json'))
+                    .slice(0, 8)
+                    .map((name) => credentialSummary(read(directory, name)))
+                    .filter(Boolean);
+                if (accounts.length)
+                    return stored([...new Set(accounts)].join('; '));
+            }
+            catch { }
+        }
+        return null;
+    }
+    if (harness === 'opencode' || harness === 'kilo')
+        return providerAccounts(read(dataHome, harness, 'auth.json'));
+    if (harness === 'pi' || harness === 'prime') {
+        return providerAccounts(read(harness === 'pi'
+            ? env.PI_CODING_AGENT_DIR || path.join(home, '.pi/agent')
+            : env.PRIME_AGENT_CODING_AGENT_DIR || path.join(home, '.prime/agent'), 'auth.json'));
+    }
+    if (harness === 'hermes') {
+        const config = read(env.HERMES_HOME || path.join(home, '.hermes'), 'auth.json');
+        const active = config?.active_provider;
+        return providerAccounts(active && config?.providers?.[active] ? { [active]: config.providers[active] } : config?.providers);
+    }
+    if (harness === 'openclaw') {
+        const config = read(env.OPENCLAW_STATE_DIR || path.join(home, '.openclaw'), 'agents/main/agent/auth-profiles.json');
+        return providerAccounts(config?.profiles);
+    }
+    if (harness === 'letta') {
+        if (env.LETTA_API_KEY)
+            return stored('Letta API key configured');
+        const settings = read(path.join(home, '.letta'), 'settings.json');
+        const identity = credentialSummary(settings);
+        return stored(identity || tokenAccount(settings?.env?.LETTA_API_KEY));
+    }
+    if (harness === 'codebuddy') {
+        if (env.CODEBUDDY_API_KEY)
+            return stored('CodeBuddy API key configured');
+        // CodeBuddy encrypts credential fields but leaves its account metadata in
+        // the shared auth session. Do not inspect the historical `accounts` array.
+        const roots = [
+            path.join(dataHome, 'CodeBuddyExtension'),
+            path.join(home, 'Library/Application Support/CodeBuddyExtension'),
+        ];
+        for (const root of roots) {
+            const directory = path.join(root, 'Data/Public/auth');
+            try {
+                const accounts = fs
+                    .readdirSync(directory)
+                    .filter((name) => name.endsWith('.info'))
+                    .slice(0, 8)
+                    .map((name) => read(directory, name)?.account)
+                    .map((account) => accountSummary({ name: account?.nickname, email: account?.email, plan: account?.enterpriseName }))
+                    .filter(Boolean);
+                if (accounts.length)
+                    return stored([...new Set(accounts)].join('; '));
+            }
+            catch { }
+        }
+        return null;
+    }
+    if (harness === 'poolside') {
+        const credentials = read(configHome, 'poolside/credentials.json');
+        if (!Array.isArray(credentials))
+            return null;
+        return stored(credentials.map(credentialSummary).filter(Boolean).join('; '));
+    }
+    return null;
+}
+/** Vibe's own account endpoint supplies its subscription plan without a model
+ * request. Mirror the installed CLI's /api/vibe/whoami contract; restrict this
+ * fallback to the standard Mistral host rather than sending a tenant key there.
+ * https://github.com/mistralai/mistral-vibe */
+export async function readVibeAccount({ home = os.homedir(), env = process.env, fetchImpl = fetch, } = {}) {
+    const root = env.VIBE_HOME || path.join(home, '.vibe');
+    let config = '';
+    let dotenv = '';
+    try {
+        config = fs.readFileSync(path.join(root, 'config.toml'), 'utf8');
+    }
+    catch { }
+    try {
+        dotenv = fs.readFileSync(path.join(root, '.env'), 'utf8');
+    }
+    catch { }
+    const consoleOverride = env.VIBE_CONSOLE_BASE_URL || config.match(/^\s*console_base_url\s*=\s*["']([^"']+)["']/mu)?.[1];
+    if (consoleOverride && consoleOverride.replace(/\/$/u, '') !== 'https://console.mistral.ai')
+        return null;
+    const raw = dotenv.match(/^\s*(?:export\s+)?MISTRAL_API_KEY\s*=\s*(.+)\s*$/mu)?.[1]?.trim() || '';
+    const key = env.MISTRAL_API_KEY || raw.replace(/^(["'])(.*)\1$/u, '$2');
+    if (!key)
+        return null;
+    try {
+        const response = await fetchImpl('https://console.mistral.ai/api/vibe/whoami', {
+            headers: { Authorization: `Bearer ${key}` },
+            redirect: 'error',
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (response.status === 401)
+            return { authenticated: false };
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const plan = data.plan_type === 'chat'
+            ? { INDIVIDUAL: 'Pro', TEAM: 'Team', EDU: 'Student', FREE: 'Free' }[data.plan_name || ''] || data.plan_name
+            : data.plan_name;
+        const account = accountSummary({ email: data.email || 'Mistral', plan });
+        return data.plan_name ? { authenticated: true, account } : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/harness-auth.js

@@ -14,8 +14,8 @@
  * scraping is deliberately loose — the first https URL is the approval
  * link, a short hyphenated all-caps token is the device code — so cosmetic
  * output changes in either CLI degrade to "no URL yet" rather than to a
- * crash. Auth *status*, by contrast, is read from the commands both CLIs
- * commit to: `claude auth status --json` and `codex login status`.
+ * crash. Auth status comes from `claude auth status --json` or Codex's
+ * structured `account/read`, with `codex login status` as a fallback.
  *
  * One flow per harness runs at a time. Flow state lives in this process and
  * dies with it; the credentials themselves live where the harness put them,
@@ -23,10 +23,12 @@
  */
 import { spawn } from 'node:child_process';
 import os from 'node:os';
-import { resolveHarnessCommand } from "./harness-registry.js";
-/** Harnesses whose sign-in this module can run. Mirrors the shared
+import { readCodexAccountStatus } from "./codex-account.js";
+import { readVibeAccount, readLocalHarnessAccount, parseNativeHarnessAccount, NATIVE_ACCOUNT_COMMANDS, } from "./harness-account.js";
+import { ACP_PROFILES, HARNESS_IDS, resolveHarnessCommand } from "./harness-registry.js";
+/** Harnesses whose account status this module can inspect. Mirrors the shared
  * HARNESS_AUTH_HARNESSES list; cli/ cannot import cloudflare/shared. */
-export const HARNESS_AUTH_HARNESSES = ['claude', 'codex'];
+export const HARNESS_AUTH_HARNESSES = HARNESS_IDS;
 const STATUS_TIMEOUT_MS = 30_000;
 const STATUS_CACHE_MS = 10_000;
 const FLOW_TIMEOUT_MS = 15 * 60_000;
@@ -140,7 +142,32 @@ export function createHarnessAuthManager() {
             return cached.answer;
         let answer = { authenticated: null };
         try {
+            if (harness !== 'claude' && harness !== 'codex') {
+                const local = readLocalHarnessAccount(harness);
+                const args = NATIVE_ACCOUNT_COMMANDS[harness];
+                let native = harness === 'vibe' ? await readVibeAccount() : null;
+                if (args) {
+                    try {
+                        const run = await runCommand(resolveHarnessCommand(harness, ACP_PROFILES[harness]), args, STATUS_TIMEOUT_MS);
+                        if (!run.failed && !run.timedOut)
+                            native = parseNativeHarnessAccount(harness, run.output);
+                    }
+                    catch {
+                        // Keep saved metadata when this CLI version cannot answer status.
+                    }
+                }
+                const result = native?.authenticated === false ? native : native?.account ? native : (local ?? native ?? answer);
+                statusCache.set(harness, { at: Date.now(), answer: result });
+                return result;
+            }
             const command = resolveHarnessCommand(harness);
+            // The structured account report includes the email, unlike login status.
+            // Older CLIs can still answer the existing human-readable status command.
+            const account = harness === 'codex' ? await readCodexAccountStatus(command) : null;
+            if (account) {
+                statusCache.set(harness, { at: Date.now(), answer: account });
+                return account;
+            }
             const args = harness === 'claude' ? ['auth', 'status', '--json'] : ['login', 'status'];
             const run = await runCommand(command, args, STATUS_TIMEOUT_MS);
             if (!run.failed && !run.timedOut) {
@@ -228,7 +255,10 @@ export function createHarnessAuthManager() {
             else {
                 // The last output line is usually the CLI's own explanation. It has
                 // secrets stripped by the caller like every other error string.
-                const lines = stripAnsi(flow.tail).split('\n').map((line) => line.trim()).filter(Boolean);
+                const lines = stripAnsi(flow.tail)
+                    .split('\n')
+                    .map((line) => line.trim())
+                    .filter(Boolean);
                 finishFlow(harness, flow, 'failed', lines.at(-1) || 'The sign-in flow ended without succeeding.');
             }
         });
@@ -265,6 +295,9 @@ export function createHarnessAuthManager() {
         if (!HARNESS_AUTH_HARNESSES.includes(harness)) {
             throw new Error(`Sign-in is not supported for harness "${harness}".`);
         }
+        if (action !== 'status' && harness !== 'claude' && harness !== 'codex') {
+            throw new Error('Use this harness’s terminal sign-in; account status is read-only here.');
+        }
         if (action === 'login')
             startFlow(harness);
         else if (action === 'code')

package/dist/harness-registry.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { executablePath } from "./executable-path.js";
 const HOME = os.homedir();
 // Turns owns this catalog.  It mirrors the transports verified by
 // turns/scaffolding; queue execution must never depend on another product's
@@ -269,30 +270,55 @@ function executable(candidate) {
         return '';
     }
 }
-export function resolveHarnessCommand(harness, profile = {}) {
+export const MACOS_BUNDLED_CODEX_PATH = '/Applications/Codex.app/Contents/Resources/codex';
+/** The app owns this executable and updates it as part of the app bundle. */
+export function codexCommandIsAppManaged(command) {
+    let candidate = path.resolve(command);
+    try {
+        candidate = fs.realpathSync(candidate);
+    }
+    catch { }
+    return /\/Codex\.app\/Contents\/Resources\/codex$/u.test(candidate.replaceAll('\\', '/'));
+}
+export function resolveHarnessCommand(harness, profile = {}, dependencies = {}) {
+    const env = dependencies.env || process.env;
+    const home = dependencies.home || HOME;
     const envName = `TURNS_${String(harness).toUpperCase().replaceAll('-', '_')}_BIN`;
-    const configured = String(process.env[envName] || '').trim();
+    const configured = String(env[envName] || '').trim();
     if (configured) {
         const found = executable(path.resolve(configured));
         if (found)
             return found;
         throw new Error(`${envName} is not executable: ${configured}`);
     }
+    // The desktop app and its bundled CLI are released together. On macOS,
+    // prefer that known-compatible binary over independently installed npm or
+    // Homebrew copies while preserving TURNS_CODEX_BIN as the explicit escape
+    // hatch above.
+    if (harness === 'codex' && (dependencies.platform || process.platform) === 'darwin') {
+        const candidates = dependencies.bundledCodexPaths ||
+            [MACOS_BUNDLED_CODEX_PATH, path.join(home, 'Applications', 'Codex.app', 'Contents', 'Resources', 'codex')];
+        for (const candidate of candidates) {
+            const found = executable(candidate);
+            if (found)
+                return found;
+        }
+    }
     const command = profile.command || ({ cursor: 'cursor-agent', antigravity: 'agy' }[harness] ?? harness);
-    for (const directory of String(process.env.PATH || '').split(path.delimiter)) {
+    for (const directory of executablePath(env, home).split(path.delimiter)) {
         const found = executable(path.join(directory, command));
         if (found)
             return found;
     }
     for (const segments of profile.homePaths || []) {
-        const found = executable(path.join(HOME, ...segments));
+        const found = executable(path.join(home, ...segments));
         if (found)
             return found;
     }
     if (harness === 'cursor') {
         for (const candidate of [
-            path.join(HOME, '.local', 'bin', 'cursor-agent'),
-            path.join(HOME, '.local', 'bin', 'agent'),
+            path.join(home, '.local', 'bin', 'cursor-agent'),
+            path.join(home, '.local', 'bin', 'agent'),
         ]) {
             const found = executable(candidate);
             if (found)

package/dist/path-resolution.js

@@ -181,6 +181,34 @@ function fileUploadUrl(baseUrl, machine, absolutePath) {
             : encoded;
     return new URL(`/api/file/${encodeURIComponent(machine)}/${encodedPath}`, String(baseUrl));
 }
+/** Read only the R2 object's upload metadata. Older servers, cache misses,
+ * and unavailable metadata conservatively retain the normal upload path. */
+export async function storedFileMetadata({ baseUrl, options, machine, absolutePath, fetchImpl = fetch, }) {
+    const url = fileUploadUrl(baseUrl, machine, absolutePath);
+    url.pathname = url.pathname.replace('/api/file/', '/api/file-metadata/');
+    try {
+        const response = await fetchImpl(url, {
+            method: 'HEAD', headers: uploadHeaders(options), signal: AbortSignal.timeout(5000),
+        });
+        try {
+            if (!response.ok)
+                return null;
+            const size = response.headers.get('x-turns-file-size');
+            const bytes = Number(size);
+            const modifiedAt = response.headers.get('x-turns-file-modified-at') || '';
+            const contentType = response.headers.get('content-type') || '';
+            if (size === null || !Number.isSafeInteger(bytes) || bytes < 0 || !Number.isFinite(Date.parse(modifiedAt)) || !contentType)
+                return null;
+            return { bytes, modifiedAt: new Date(modifiedAt).toISOString(), contentType };
+        }
+        finally {
+            await response.body?.cancel();
+        }
+    }
+    catch {
+        return null;
+    }
+}
 /** Kept in step with the explicit-browse transport constants in shared/files.ts. */
 export const MAX_SINGLE_BROWSE_UPLOAD_BYTES = 100 * 1024 * 1024;
 export const BROWSE_MULTIPART_PART_BYTES = 32 * 1024 * 1024;