@hyperdrive.bot/paseo-server 0.2.6

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

@@ -0,0 +1,183 @@
+import { isAbsolute } from "node:path";
+// Single import+export block: imports schemas/types for local use AND re-exports
+// them for downstream consumers (claude/agent.ts, config.ts, session.ts,
+// persisted-config.ts, provider-registry.ts, opencode-agent.ts, bootstrap.ts,
+// exports.ts, and all per-provider files in agent/providers/). Combining the
+// two avoids the TS2459 "declares X locally but is not exported" trap that
+// hits when a separate `import { type X }` shadows an `export type { X } from`.
+import { executableExists, findExecutable, } from "../../executable-resolution/executable-resolution.js";
+import { createExternalProcessEnv } from "../paseo-env.js";
+import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, AgentProviderRuntimeSettingsMapSchema, ProviderProfileModelSchema, } from "@hyperdrive.bot/paseo-protocol/provider-config";
+export { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, AgentProviderRuntimeSettingsMapSchema, ProviderProfileModelSchema, };
+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",
+    // A claude child that inherits these treats itself as a NESTED child session and
+    // does NOT persist its own transcript under ~/.claude/projects — which breaks the
+    // PTY transport's transcript reconstruction (it reads that JSONL). Scrub them so
+    // every spawned claude is a clean top-level `entrypoint:cli` session. Safe for the
+    // SDK path too: it binds sessions via query options (resume/sessionId), not env.
+    "CLAUDE_CODE_CHILD_SESSION",
+    "CLAUDE_CODE_SESSION_ID",
+];
+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;
+    }
+    for (const key of options.extraScrubKeys ?? []) {
+        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

package/dist/server/server/agent/provider-notices.d.ts

@@ -0,0 +1,3 @@
+import type { AgentProviderNotice } from "./agent-sdk-types.js";
+export declare const SETTING_APPLIES_NEXT_TURN_NOTICE: AgentProviderNotice;
+//# sourceMappingURL=provider-notices.d.ts.map

package/dist/server/server/agent/provider-notices.js

@@ -0,0 +1,5 @@
+export const SETTING_APPLIES_NEXT_TURN_NOTICE = {
+    type: "info",
+    message: "This change applies next turn.",
+};
+//# sourceMappingURL=provider-notices.js.map

package/dist/server/server/agent/provider-registry.d.ts

@@ -0,0 +1,49 @@
+import type { Logger } from "pino";
+import type { AgentClient, AgentCreateConfigUnattendedInput, AgentProvider, AgentSession, FetchCatalogOptions, ProviderCatalog, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
+import type { WorkspaceGitService } from "../workspace-git-service.js";
+import type { ManagedProcessRegistry } from "../managed-processes/managed-processes.js";
+import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
+import { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition, type AgentProviderDefinition } from "@hyperdrive.bot/paseo-protocol/provider-manifest";
+export declare function resolveClaudeTransport(setting: "sdk" | "pty" | "auto" | undefined, deps?: {
+    requireNodePty?: () => unknown;
+    probeClaudeBinary?: () => void;
+}): "sdk" | "pty";
+export declare const NODE_PTY_UNAVAILABLE_REASON = "node-pty native module not built. Run 'npm rebuild node-pty' in packages/server.";
+export declare function isNodePtyAvailable(deps?: {
+    requireNodePty?: () => unknown;
+}): boolean;
+export type { AgentProviderDefinition };
+export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
+export interface ProviderDefinition extends AgentProviderDefinition {
+    enabled: boolean;
+    /**
+     * The id of another *registered* provider this one extends (e.g. a Z.AI
+     * profile that extends "claude"). null for built-in providers and for
+     * generic ACP providers (which only extend the literal "acp" sentinel).
+     */
+    derivedFromProviderId: string | null;
+    createClient: (logger: Logger) => AgentClient;
+    resolveCreateConfig: (input: ResolveAgentCreateConfigInput) => ResolveAgentCreateConfigResult;
+    isCreateConfigUnattended: (input: AgentCreateConfigUnattendedInput) => boolean;
+    /**
+     * Single catalog discovery call used by ProviderSnapshotManager. Should spawn
+     * at most one provider runtime process and return both models and modes.
+     */
+    fetchCatalog: (options: FetchCatalogOptions, client?: AgentClient) => Promise<ProviderCatalog>;
+}
+export interface BuildProviderRegistryOptions {
+    runtimeSettings?: AgentProviderRuntimeSettingsMap;
+    providerOverrides?: Record<string, ProviderOverride>;
+    workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
+    managedProcesses?: ManagedProcessRegistry;
+    isDev?: boolean;
+}
+export declare function wrapSessionProvider(provider: AgentProvider, inner: AgentSession): AgentSession;
+export declare function buildProviderRegistry(logger: Logger, options?: BuildProviderRegistryOptions): Record<AgentProvider, ProviderDefinition>;
+export declare function getProviderIds(registry: Record<AgentProvider, ProviderDefinition>): AgentProvider[];
+export declare const PROVIDER_REGISTRY: Record<AgentProvider, ProviderDefinition>;
+export declare function createAllClients(logger: Logger, options?: BuildProviderRegistryOptions): Record<AgentProvider, AgentClient>;
+export declare function createClientsFromRegistry(registry: Record<AgentProvider, ProviderDefinition>, logger: Logger): Record<AgentProvider, AgentClient>;
+export declare function shutdownProviders(logger: Logger, options?: BuildProviderRegistryOptions): Promise<void>;
+export declare function shutdownAgentClients(clients: Iterable<AgentClient>, logger: Logger): Promise<void>;
+//# sourceMappingURL=provider-registry.d.ts.map