@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/web-ui/_expo/static/js/web/indexeddb-attachment-store-5444610146b0794f1e7d9edad4522d41.js

@@ -0,0 +1 @@
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createIndexedDbAttachmentStore=function(){return{storageType:"web-indexeddb",async save(n){const o=n.id??(0,t.generateAttachmentId)(),s=Date.now(),{blob:c,mimeType:u}=await b(n),w=n.fileName??null,p=await l();try{await y(p,"readwrite",t=>t.put({id:o,blob:c,createdAt:s,fileName:w}))}finally{p.close()}return{id:o,mimeType:u,storageType:"web-indexeddb",storageKey:o,fileName:w,byteSize:c.size,createdAt:s}},async encodeBase64({attachment:n}){const o=await l();try{const s=await u(o,n.storageKey);return await(0,t.blobToBase64)(s)}finally{o.close()}},async resolvePreviewUrl({attachment:t}){const n=await l();try{const o=await u(n,t.storageKey);return URL.createObjectURL(o)}finally{n.close()}},async releasePreviewUrl({url:t}){URL.revokeObjectURL(t)},async delete({attachment:t}){const n=await l();try{await y(n,"readwrite",n=>n.delete(t.storageKey))}finally{n.close()}},async garbageCollect({referencedIds:t}){const n=await l();try{await new Promise((s,c)=>{const l=n.transaction(o,"readwrite"),y=l.objectStore(o).openCursor();y.addEventListener("error",()=>{c(y.error??new Error("Failed to iterate IndexedDB attachment store."))}),y.addEventListener("success",()=>{const n=y.result;if(!n)return void s();const o=String(n.key);t.has(o)||n.delete(),n.continue()}),l.addEventListener("error",()=>{c(l.error??new Error("Failed to garbage collect IndexedDB attachments."))})})}finally{n.close()}}}};var t=r(d[0]);const n="paseo-attachment-bytes",o="attachments",s=1;function c(){const t=globalThis.indexedDB;if(!t)throw new Error("IndexedDB is unavailable in this runtime.");return t}function l(){return new Promise((t,l)=>{const y=c().open(n,s);y.onupgradeneeded=()=>{const t=y.result;t.objectStoreNames.contains(o)||t.createObjectStore(o,{keyPath:"id"})},y.addEventListener("success",()=>{t(y.result)}),y.addEventListener("error",()=>{l(y.error??new Error("Failed to open attachment IndexedDB."))})})}function y(t,n,s){return new Promise((c,l)=>{const y=t.transaction(o,n),b=y.objectStore(o),u=s(b);u.addEventListener("success",()=>{c(u.result)}),u.addEventListener("error",()=>{l(u.error??new Error("IndexedDB transaction request failed."))}),y.addEventListener("error",()=>{l(y.error??new Error("IndexedDB transaction failed."))})})}async function b(n){const o=n.source;if("bytes"===o.kind){const s=(0,t.normalizeMimeType)(n.mimeType),c=new ArrayBuffer(o.bytes.byteLength);return new Uint8Array(c).set(o.bytes),{blob:new Blob([c],{type:s}),mimeType:s}}if("blob"===o.kind){const s=(0,t.normalizeMimeType)(n.mimeType??o.blob.type);return{blob:o.blob.type===s?o.blob:o.blob.slice(0,o.blob.size,s),mimeType:s}}if("data_url"===o.kind){const s=(0,t.parseDataUrl)(o.dataUrl),c=await fetch(o.dataUrl),l=await c.blob(),y=(0,t.normalizeMimeType)(n.mimeType??s.mimeType??l.type);return{blob:l.type===y?l:l.slice(0,l.size,y),mimeType:y}}const s=await fetch(o.uri),c=await s.blob(),l=(0,t.normalizeMimeType)(n.mimeType??c.type);return{blob:c.type===l?c:c.slice(0,c.size,l),mimeType:l}}async function u(t,n){const o=await y(t,"readonly",t=>t.get(n));if(!o?.blob)throw new Error(`Attachment ${n} was not found in IndexedDB.`);return o.blob}},5060,[4397]);

package/dist/server/web-ui/_expo/static/js/web/native-file-attachment-store-88b083190031a44788be59103814f511.js

@@ -0,0 +1,3 @@
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createNativeFileAttachmentStore=function(){return(0,s.createLocalFileAttachmentStore)({storageType:"native-file",baseDirectoryName:"paseo-native-attachments",fileSystem:(0,t.createExpoAttachmentFileSystem)(),resolvePreviewUrl:async t=>t.storageKey.startsWith("file://")?t.storageKey:(0,o.isAbsolutePath)(t.storageKey)?t.storageKey.startsWith("/")?`file://${t.storageKey}`:t.storageKey.startsWith("\\\\")?`file:${t.storageKey.replace(/\\/g,"/")}`:`file:///${t.storageKey.replace(/\\/g,"/")}`:t.storageKey})};var t=r(d[0]),s=r(d[1]),o=r(d[2])},5061,[5062,5063,3551]);
+__d(function(g,r,i,a,m,_e,_d){"use strict";Object.defineProperty(_e,'__esModule',{value:!0}),_e.createExpoAttachmentFileSystem=function(){return{cacheDirectory:t.cacheDirectory,async getInfo(e){const n=await t.getInfoAsync(e);if(!n.exists)return{exists:!1};const c="number"==typeof n.size?n.size:null;return{exists:!0,isDirectory:n.isDirectory??!1,size:c}},async makeDirectory(e,n){await t.makeDirectoryAsync(e,n)},async writeBytes(t,n){new e.File(t).write(n)},async copy(e){await t.copyAsync(e)},readAsBase64:async e=>await t.readAsStringAsync(e,{encoding:t.EncodingType.Base64}),async delete(e,n){await t.deleteAsync(e,n)},listDirectory:async e=>await t.readDirectoryAsync(e)}};var e=r(_d[0]),t=(function(e){if(e&&e.__esModule)return e;var t={};return e&&Object.keys(e).forEach(function(n){var c=Object.getOwnPropertyDescriptor(e,n);Object.defineProperty(t,n,c.get?c:{enumerable:!0,get:function(){return e[n]}})}),t.default=e,t})(r(_d[1]))},5062,[3931,3939]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createLocalFileAttachmentStore=function(n){const{fileSystem:o}=n,l=o.cacheDirectory?`${o.cacheDirectory}${n.baseDirectoryName}/`:null;async function u(n){if(!l)throw new Error("Attachment file-system cacheDirectory is unavailable.");await c(o,l);const y=n.id??(0,t.generateAttachmentId)();let f;f="data_url"===n.source.kind?(0,t.parseDataUrl)(n.source.dataUrl).mimeType:"blob"===n.source.kind?n.source.blob.type:void 0;const u=(0,t.normalizeMimeType)(n.mimeType??f),p=n.fileName??null,w=s({fileName:p,mimeType:u}),U=Date.now(),b=`${l}${y}${w}`;return{id:y,mimeType:u,fileName:p,createdAt:U,targetUri:b,storageKey:(0,t.fileUriToPath)(b)}}return Object.assign({storageType:n.storageType,async save(t){const s=await u(t);await y({fileSystem:o,source:t.source,targetUri:s.targetUri,mimeType:s.mimeType});const c=await o.getInfo(s.targetUri),l=c.exists?c.size:null;return{id:s.id,mimeType:s.mimeType,storageType:n.storageType,storageKey:s.storageKey,fileName:s.fileName,byteSize:l,createdAt:s.createdAt}},encodeBase64:async({attachment:t})=>await o.readAsBase64(f(t)),resolvePreviewUrl:async({attachment:t})=>await n.resolvePreviewUrl(t)},n.releasePreviewUrl?{async releasePreviewUrl(t){await(n.releasePreviewUrl?.(t))}}:{},{async delete({attachment:t}){await o.delete(f(t),{idempotent:!0})},async garbageCollect({referencedIds:t}){if(!l)return;await c(o,l);const n=await o.listDirectory(l);await Promise.all(n.map(async n=>{const s=n.split(".",1)[0]??"";s&&!t.has(s)&&await o.delete(`${l}${n}`,{idempotent:!0})}))}})};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(s){const c=(0,t.getFileExtensionFromName)(s.fileName);return c||(n[s.mimeType]??".img")}async function c(t,n){const s=await t.getInfo(n);s.exists&&s.isDirectory||await t.makeDirectory(n,{intermediates:!0})}async function o(t){const n=await fetch(t);return new Uint8Array(await n.arrayBuffer())}async function l(t){return new Uint8Array(await t.arrayBuffer())}async function y(n){if("file_uri"===n.source.kind){const s=(0,t.pathToFileUri)(n.source.uri);if(s===n.targetUri)return;return void await n.fileSystem.copy({from:s,to:n.targetUri})}let s;s="data_url"===n.source.kind?await o(n.source.dataUrl):"blob"===n.source.kind?await l(n.source.blob):n.source.bytes,await n.fileSystem.writeBytes(n.targetUri,s)}function f(n){return(0,t.pathToFileUri)(n.storageKey)}},5063,[4397]);

package/dist/server/web-ui/index.html

@@ -0,0 +1,90 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="robots" content="noindex,nofollow" />
+    <meta name="theme-color" content="#181B1A" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-title" content="Paseo" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, shrink-to-fit=no, viewport-fit=cover"
+    />
+    <link rel="manifest" href="/manifest.json" />
+    <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+    <title>Paseo</title>
+    <!-- The `react-native-web` recommended style reset: https://necolas.github.io/react-native-web/docs/setup/#root-element -->
+    <style id="expo-reset">
+      /* Keep the app shell fixed to the viewport. */
+      html,
+      body {
+        width: 100%;
+        height: 100%;
+        margin: 0;
+        padding: 0;
+        overflow: hidden;
+        overscroll-behavior: none;
+      }
+      /* These styles smooth text rendering in the app shell. */
+      body {
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+      }
+      /* Prevent white flash before React mounts */
+      @media (prefers-color-scheme: dark) {
+        html,
+        body {
+          background-color: #181b1a;
+        }
+      }
+      /* These styles make the root element full-height */
+      #root {
+        display: flex;
+        width: 100%;
+        height: 100%;
+        flex: 1;
+        min-width: 0;
+        min-height: 0;
+        overflow: hidden;
+      }
+    </style>
+    <style>
+      button,
+      a,
+      input,
+      textarea,
+      select,
+      [role="button"],
+      [role="link"],
+      [role="textbox"],
+      [role="combobox"],
+      [role="tab"],
+      [role="switch"],
+      [role="checkbox"],
+      [role="slider"],
+      [role="menuitem"],
+      [tabindex],
+      [contenteditable="true"] {
+        -webkit-app-region: no-drag !important;
+      }
+
+      /* Suppress the browser's default focus outline — it appears on mouse
+         clicks and looks out of place against our themed surfaces. Keep a
+         themed ring for keyboard users via :focus-visible. */
+      *:focus {
+        outline: none;
+      }
+      *:focus-visible {
+        outline: 2px solid #20744a;
+        outline-offset: 2px;
+      }
+    </style>
+  <link rel="preload" href="/_expo/static/css/xterm-3bb1704bf6cb0876640973dc0244b4cb.css" as="style"><link rel="stylesheet" href="/_expo/static/css/xterm-3bb1704bf6cb0876640973dc0244b4cb.css"><link rel="icon" href="/favicon.ico" /></head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+  <script src="/_expo/static/js/web/index-03b99be4265ac4a2bc5a6d602fd59cc4.js" defer></script>
+</body>
+</html>

package/dist/server/web-ui/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "/",
+  "name": "Paseo",
+  "short_name": "Paseo",
+  "description": "Monitor and control local AI coding agents from anywhere.",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "orientation": "portrait",
+  "theme_color": "#181B1A",
+  "background_color": "#181B1A",
+  "categories": ["developer", "productivity", "utilities"],
+  "icons": [
+    {
+      "src": "/pwa-icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any maskable"
+    },
+    {
+      "src": "/pwa-icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ]
+}

package/dist/server/web-ui/metadata.json

@@ -0,0 +1 @@
+{"version":0,"bundler":"metro","fileMetadata":{}}

package/dist/server/web-ui/metadata.json.br

@@ -0,0 +1 @@
+�{"version":0,"bundler":"metro","fileMetadata":{}}

package/dist/server/web-ui/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

package/dist/src/executable-resolution/executable-resolution.js

@@ -0,0 +1,121 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { execCommand } from "../utils/spawn.js";
+import { isWindowsCommandScript } from "../utils/windows-command.js";
+import { windowsExecutableResolution } from "./windows.js";
+export { quoteWindowsArgument, quoteWindowsCommand } from "../utils/windows-command.js";
+const require = createRequire(import.meta.url);
+const which = require("which");
+const PROBE_TIMEOUT_MS = 2000;
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+async function enumerateCandidates(name) {
+    if (process.platform !== "win32" && existsSync("/usr/bin/which")) {
+        return enumerateCandidatesViaSystemWhich(name);
+    }
+    return enumerateCandidatesViaLibrary(name);
+}
+async function enumerateCandidatesViaSystemWhich(name) {
+    try {
+        const { stdout } = await execCommand("/usr/bin/which", ["-a", name], {
+            timeout: 3000,
+            killSignal: "SIGKILL",
+        });
+        return Array.from(new Set(stdout.trim().split("\n").filter(Boolean)));
+    }
+    catch (error) {
+        // which exits 1 for a missing command. A failed lookup is not evidence of absence.
+        if (error instanceof Error && "code" in error && error.code === 1)
+            return [];
+        throw error;
+    }
+}
+async function enumerateCandidatesViaLibrary(name) {
+    let candidates;
+    try {
+        candidates = await which(name, { all: true });
+    }
+    catch (error) {
+        // `which` throws ENOENT when the command is absent from PATH.
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        if (seen.has(candidate)) {
+            return false;
+        }
+        seen.add(candidate);
+        return true;
+    });
+}
+export async function probeExecutable(executablePath, timeoutMs = PROBE_TIMEOUT_MS) {
+    try {
+        await execCommand(executablePath, ["--version"], {
+            timeout: timeoutMs,
+            killSignal: "SIGKILL",
+            maxBuffer: 64 * 1024,
+            shell: isWindowsCommandScript(executablePath),
+        });
+        return true;
+    }
+    catch (error) {
+        return classifyProbeError(error);
+    }
+}
+function classifyProbeError(error) {
+    const err = error;
+    if (err.killed) {
+        return true;
+    }
+    if (typeof err.code === "number") {
+        return true;
+    }
+    if (err.code === "ENOENT" ||
+        err.code === "EACCES" ||
+        err.code === "ENOEXEC" ||
+        err.code === "UNKNOWN") {
+        return false;
+    }
+    return false;
+}
+/**
+ * Check a literal executable path. PATH search is handled by findExecutable().
+ */
+export function executableExists(executablePath, exists = existsSync) {
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.exists(executablePath, { exists });
+    }
+    return exists(executablePath) ? executablePath : null;
+}
+export async function findExecutable(name, probeTimeoutMs = PROBE_TIMEOUT_MS) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.find(trimmed, {
+            enumeratePathCandidates: enumerateCandidates,
+            probeExecutable,
+            exists: existsSync,
+            probeTimeoutMs,
+        });
+    }
+    if (hasPathSeparator(trimmed)) {
+        return (await probeExecutable(trimmed, probeTimeoutMs)) ? trimmed : null;
+    }
+    const candidates = await enumerateCandidates(trimmed);
+    for (const candidate of candidates) {
+        if (await probeExecutable(candidate, probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export async function isCommandAvailable(command) {
+    return (await findExecutable(command)) !== null;
+}
+//# sourceMappingURL=executable-resolution.js.map

package/dist/src/executable-resolution/windows.js

@@ -0,0 +1,65 @@
+import { readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+function enumerateLiteralPathCandidates(executablePath) {
+    if (extname(executablePath)) {
+        return [executablePath];
+    }
+    return [executablePath, `${executablePath}.exe`, `${executablePath}.cmd`];
+}
+function enumerateWingetPackageCandidates(name, localAppData) {
+    if (!localAppData) {
+        return [];
+    }
+    const wingetPackages = join(localAppData, "Microsoft", "WinGet", "Packages");
+    let packageDirs;
+    try {
+        packageDirs = readdirSync(wingetPackages, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+    const exeName = `${name}.exe`;
+    return packageDirs.map((packageDir) => join(wingetPackages, packageDir, exeName));
+}
+async function find(input, options) {
+    if (hasPathSeparator(input)) {
+        return findFirstProbeable(enumerateLiteralPathCandidates(input), options);
+    }
+    const pathCandidates = await options.enumeratePathCandidates(input);
+    const wingetCandidates = enumerateWingetPackageCandidates(input, options.localAppData ?? process.env.LOCALAPPDATA).filter(options.exists);
+    return findFirstProbeable([...pathCandidates, ...wingetCandidates], options);
+}
+async function findFirstProbeable(candidates, options) {
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate)) {
+            continue;
+        }
+        seen.add(candidate);
+        if (!options.exists(candidate)) {
+            continue;
+        }
+        if (await options.probeExecutable(candidate, options.probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function exists(executablePath, options) {
+    for (const candidate of enumerateLiteralPathCandidates(executablePath)) {
+        if (options.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export const windowsExecutableResolution = {
+    exists,
+    find,
+};
+//# sourceMappingURL=windows.js.map

package/dist/src/server/agent/provider-launch-config.js

@@ -0,0 +1,167 @@
+import { isAbsolute } from "node:path";
+import { executableExists, findExecutable, } from "../../executable-resolution/executable-resolution.js";
+import { createExternalProcessEnv } from "../paseo-env.js";
+export { AgentProviderRuntimeSettingsMapSchema, ProviderCommandSchema, ProviderOverrideSchema, ProviderOverridesSchema, ProviderProfileModelSchema, ProviderRuntimeSettingsSchema, } from "@camerontaylor/paseo-protocol/provider-config";
+import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, } from "@camerontaylor/paseo-protocol/provider-config";
+function normalizeLaunchDefault(defaultBinary) {
+    if (typeof defaultBinary === "string") {
+        return { command: defaultBinary };
+    }
+    return defaultBinary;
+}
+async function resolveLaunchPath(command) {
+    const found = await findExecutable(command);
+    if (found) {
+        return found;
+    }
+    if (isAbsolute(command)) {
+        return executableExists(command);
+    }
+    return null;
+}
+async function resolveDefaultLaunchPath(defaultBinary) {
+    return defaultBinary.resolvePath
+        ? await defaultBinary.resolvePath()
+        : await resolveLaunchPath(defaultBinary.command);
+}
+export async function resolveProviderLaunch({ commandConfig, defaultBinary, }) {
+    if (commandConfig?.mode === "replace") {
+        const command = commandConfig.argv[0];
+        return {
+            command,
+            args: commandConfig.argv.slice(1),
+            source: "override",
+        };
+    }
+    if (defaultBinary === undefined) {
+        throw new Error("defaultBinary is required when provider command is not replaced");
+    }
+    const normalizedDefault = normalizeLaunchDefault(defaultBinary);
+    const args = commandConfig?.mode === "append" ? [...(commandConfig.args ?? [])] : [];
+    return {
+        command: normalizedDefault.command,
+        args,
+        source: commandConfig?.mode === "append" ? "append" : "default",
+    };
+}
+export async function checkProviderLaunchAvailable(launch, defaultBinary) {
+    const resolvedPath = defaultBinary && launch.source !== "override"
+        ? await resolveDefaultLaunchPath(defaultBinary)
+        : await resolveLaunchPath(launch.command);
+    return {
+        available: resolvedPath !== null,
+        resolvedPath,
+    };
+}
+export async function resolveProviderCommandPrefix(commandConfig, resolveDefaultCommand) {
+    if (commandConfig?.mode === "replace") {
+        const launch = await resolveProviderLaunch({
+            commandConfig,
+        });
+        return {
+            command: launch.command,
+            args: launch.args,
+        };
+    }
+    const defaultCommand = await resolveDefaultCommand();
+    const launch = await resolveProviderLaunch({
+        commandConfig,
+        defaultBinary: {
+            command: defaultCommand,
+            resolvePath: async () => defaultCommand,
+        },
+    });
+    return {
+        command: launch.command,
+        args: launch.args,
+    };
+}
+let cachedShellEnv = null;
+export function resolveShellEnv() {
+    if (cachedShellEnv) {
+        return cachedShellEnv;
+    }
+    cachedShellEnv = { ...process.env };
+    return cachedShellEnv;
+}
+export function migrateProviderSettings(raw, builtinProviderIds) {
+    const migrated = {};
+    const builtinProviderIdSet = new Set(builtinProviderIds);
+    for (const [providerId, value] of Object.entries(raw)) {
+        const parsedNew = ProviderOverrideSchema.safeParse(value);
+        if (parsedNew.success) {
+            migrated[providerId] = parsedNew.data;
+            continue;
+        }
+        const parsedOld = ProviderRuntimeSettingsSchema.safeParse(value);
+        if (!parsedOld.success) {
+            continue;
+        }
+        const nextEntry = {};
+        const command = parsedOld.data.command;
+        if (command?.mode === "append") {
+            continue;
+        }
+        if (command?.mode === "replace") {
+            nextEntry.command = command.argv;
+        }
+        if (parsedOld.data.env) {
+            nextEntry.env = parsedOld.data.env;
+        }
+        if (!builtinProviderIdSet.has(providerId) && nextEntry.extends === undefined) {
+            delete nextEntry.extends;
+        }
+        migrated[providerId] = nextEntry;
+    }
+    return ProviderOverridesSchema.parse(migrated);
+}
+// Env vars that indicate a running Claude Code session. If the daemon itself is
+// launched from inside Claude Code (e.g. by a Paseo agent), these leak into
+// child processes and cause "cannot be launched inside another session" errors.
+const PARENT_SESSION_ENV_VARS = [
+    "CLAUDECODE",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_SSE_PORT",
+    "CLAUDE_AGENT_SDK_VERSION",
+];
+function collectProviderEnvOverlays(runtimeSettings, overlays) {
+    return [runtimeSettings?.env, ...overlays].filter((overlay) => !!overlay);
+}
+export function createProviderEnvSpec(options = {}) {
+    const overlays = collectProviderEnvOverlays(options.runtimeSettings, options.overlays ?? []);
+    const envOverlay = Object.assign({}, ...overlays);
+    for (const key of PARENT_SESSION_ENV_VARS) {
+        envOverlay[key] = undefined;
+    }
+    return {
+        ...(options.baseEnv ? { baseEnv: options.baseEnv } : {}),
+        envOverlay,
+    };
+}
+export function createProviderEnv(options = {}) {
+    const spec = createProviderEnvSpec(options);
+    return createExternalProcessEnv(spec.baseEnv ?? process.env, spec.envOverlay);
+}
+export async function isProviderCommandAvailable(commandConfig, resolveDefaultCommand) {
+    try {
+        if (commandConfig?.mode === "replace") {
+            const launch = await resolveProviderLaunch({
+                commandConfig,
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            return availability.available;
+        }
+        const defaultCommand = await resolveDefaultCommand();
+        const defaultBinary = {
+            command: defaultCommand,
+            resolvePath: async () => defaultCommand,
+        };
+        const launch = await resolveProviderLaunch({ commandConfig, defaultBinary });
+        const availability = await checkProviderLaunchAvailable(launch, defaultBinary);
+        return availability.available;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=provider-launch-config.js.map