@loucompanion/forge-bridge 0.1.3-dev.b6be5e7f9668 → 0.1.3-dev.ba7d36726eda

package/dist/session/provider-cli/provider-cli.process.d.ts

@@ -0,0 +1,34 @@
+import { type LaunchCommand } from "../../shared/process/windows-launch.js";
+export type ProviderCliCommand = LaunchCommand;
+export interface ProviderProcessRunRequest {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly stdin?: string;
+    readonly captureOutput?: boolean;
+}
+export interface ProviderProcessRunResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ProviderProcessRunner {
+    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
+}
+export interface ProviderProcessHandlers {
+    onStdoutLine?(line: string): Promise<void> | void;
+    onStderrLine?(line: string): Promise<void> | void;
+}
+interface ProviderChildEnvironmentOptions {
+    readonly parentEnv?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly homeDir?: string;
+}
+export declare function buildProviderChildEnvironment(requestEnv?: Readonly<Record<string, string>>, options?: ProviderChildEnvironmentOptions): NodeJS.ProcessEnv;
+export declare class StreamingProviderProcessRunner implements ProviderProcessRunner {
+    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
+}
+export declare function resolveCodexNpmDirectLaunch(commandPath: string, args: readonly string[]): LaunchCommand | null;
+export declare function chooseWindowsCommandCandidate(candidates: readonly string[]): string | null;
+export {};

package/dist/session/provider-cli/provider-cli.process.js

@@ -0,0 +1,316 @@
+import { execFile, spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { promisify } from "node:util";
+import { resolveCursorAgentDirectLaunch } from "../../shared/cursor-agent/cursor-agent.launch.js";
+import { persistHostProcessSupervisorMetadata, resolveHostProcessSupervisedLaunch, terminateHostProcessTree, } from "../../shared/process/host-process-supervisor.js";
+import { buildWindowsLaunchCommand } from "../../shared/process/windows-launch.js";
+const execFileAsync = promisify(execFile);
+const allowedProviderParentEnvNames = [
+    "PATH",
+    "HOME",
+    "USERPROFILE",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "LANG"
+];
+const windowsAllowedProviderParentEnvNames = [
+    "SystemRoot",
+    "SystemDrive",
+    "ComSpec",
+    "PATHEXT",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "USERNAME",
+    "USERDOMAIN",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "ProgramData",
+    "ProgramFiles",
+    "ProgramFiles(x86)",
+    "ProgramW6432",
+    "DOTNET_ROOT",
+    "DOTNET_ROOT(x86)",
+    "DOTNET_CLI_HOME",
+    "NUGET_PACKAGES",
+    "NUGET_HTTP_CACHE_PATH"
+];
+export function buildProviderChildEnvironment(requestEnv, options = {}) {
+    const parentEnv = options.parentEnv ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const env = {};
+    for (const [key, value] of Object.entries(parentEnv)) {
+        if (typeof value === "string" && isAllowedProviderParentEnv(key, platform)) {
+            env[key] = value;
+        }
+    }
+    if (requestEnv) {
+        for (const [key, value] of Object.entries(requestEnv)) {
+            const trimmedKey = key.trim();
+            if (trimmedKey.length > 0) {
+                env[trimmedKey] = value;
+            }
+        }
+    }
+    if (platform === "win32") {
+        normalizeWindowsDotNetEnvironment(env, parentEnv, options.homeDir ?? os.homedir());
+    }
+    return env;
+}
+function isAllowedProviderParentEnv(key, platform = process.platform) {
+    return isAllowedProviderParentEnvName(key, allowedProviderParentEnvNames)
+        || key.toUpperCase().startsWith("LC_")
+        || (platform === "win32" && isAllowedProviderParentEnvName(key, windowsAllowedProviderParentEnvNames));
+}
+function isAllowedProviderParentEnvName(key, allowedNames) {
+    return allowedNames.some((allowed) => allowed.toLowerCase() === key.toLowerCase());
+}
+function normalizeWindowsDotNetEnvironment(env, parentEnv, homeDir) {
+    const systemRoot = readEnvironmentValue(env, "SystemRoot") ?? readEnvironmentValue(parentEnv, "SystemRoot") ?? "C:\\Windows";
+    const systemDrive = path.win32.parse(systemRoot).root.replace(/\\$/, "") || "C:";
+    setEnvironmentValueIfMissing(env, "SystemRoot", systemRoot);
+    setEnvironmentValueIfMissing(env, "SystemDrive", readEnvironmentValue(parentEnv, "SystemDrive") ?? systemDrive);
+    setEnvironmentValueIfMissing(env, "ComSpec", readEnvironmentValue(parentEnv, "ComSpec") ?? path.win32.join(systemRoot, "System32", "cmd.exe"));
+    setEnvironmentValueIfMissing(env, "PATHEXT", readEnvironmentValue(parentEnv, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL");
+    const userProfile = resolveWindowsUserProfile(env, parentEnv, homeDir);
+    if (userProfile) {
+        setEnvironmentValueIfMissing(env, "USERPROFILE", userProfile);
+        setEnvironmentValueIfMissing(env, "HOME", userProfile);
+        setEnvironmentValueIfMissing(env, "DOTNET_CLI_HOME", userProfile);
+        setEnvironmentValueIfMissing(env, "NUGET_PACKAGES", path.win32.join(userProfile, ".nuget", "packages"));
+        const parsed = path.win32.parse(userProfile);
+        if (parsed.root) {
+            setEnvironmentValueIfMissing(env, "HOMEDRIVE", parsed.root.replace(/\\$/, ""));
+            setEnvironmentValueIfMissing(env, "HOMEPATH", userProfile.slice(parsed.root.length - (parsed.root.endsWith("\\") ? 1 : 0)) || "\\");
+        }
+    }
+    const appData = readEnvironmentValue(env, "APPDATA")
+        ?? readEnvironmentValue(parentEnv, "APPDATA")
+        ?? (userProfile ? path.win32.join(userProfile, "AppData", "Roaming") : undefined);
+    const localAppData = readEnvironmentValue(env, "LOCALAPPDATA")
+        ?? readEnvironmentValue(parentEnv, "LOCALAPPDATA")
+        ?? (userProfile ? path.win32.join(userProfile, "AppData", "Local") : undefined);
+    if (appData) {
+        setEnvironmentValueIfMissing(env, "APPDATA", appData);
+    }
+    if (localAppData) {
+        setEnvironmentValueIfMissing(env, "LOCALAPPDATA", localAppData);
+        setEnvironmentValueIfMissing(env, "NUGET_HTTP_CACHE_PATH", path.win32.join(localAppData, "NuGet", "v3-cache"));
+    }
+    setEnvironmentValueIfMissing(env, "DOTNET_NOLOGO", "1");
+    setEnvironmentValueIfMissing(env, "DOTNET_CLI_TELEMETRY_OPTOUT", "1");
+    setEnvironmentValueIfMissing(env, "DOTNET_SKIP_FIRST_TIME_EXPERIENCE", "1");
+    setEnvironmentValueIfMissing(env, "NUGET_XMLDOC_MODE", "skip");
+}
+function resolveWindowsUserProfile(env, parentEnv, homeDir) {
+    const existing = readEnvironmentValue(env, "USERPROFILE") ?? readEnvironmentValue(parentEnv, "USERPROFILE");
+    if (existing) {
+        return existing;
+    }
+    const home = readEnvironmentValue(env, "HOME") ?? readEnvironmentValue(parentEnv, "HOME");
+    if (home && path.win32.isAbsolute(home)) {
+        return home;
+    }
+    const homeDrive = readEnvironmentValue(env, "HOMEDRIVE") ?? readEnvironmentValue(parentEnv, "HOMEDRIVE");
+    const homePath = readEnvironmentValue(env, "HOMEPATH") ?? readEnvironmentValue(parentEnv, "HOMEPATH");
+    if (homeDrive && homePath) {
+        return `${homeDrive}${homePath}`;
+    }
+    if (homeDir && path.win32.isAbsolute(homeDir)) {
+        return homeDir;
+    }
+    const systemDrive = readEnvironmentValue(env, "SystemDrive") ?? readEnvironmentValue(parentEnv, "SystemDrive") ?? "C:";
+    const username = readEnvironmentValue(env, "USERNAME") ?? readEnvironmentValue(parentEnv, "USERNAME");
+    return username ? path.win32.join(systemDrive, "Users", username) : undefined;
+}
+function readEnvironmentValue(env, name) {
+    const entry = Object.entries(env).find(([key]) => key.toLowerCase() === name.toLowerCase());
+    const value = entry?.[1];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function setEnvironmentValueIfMissing(env, name, value) {
+    if (readEnvironmentValue(env, name)) {
+        return;
+    }
+    env[name] = value;
+}
+export class StreamingProviderProcessRunner {
+    async run(request, handlers = {}, signal) {
+        const providerLaunch = await resolveProviderProcessLaunch(request.command, request.args);
+        const supervisedLaunch = resolveHostProcessSupervisedLaunch(request, providerLaunch.command, providerLaunch.args);
+        const launch = supervisedLaunch ?? { ...providerLaunch, detached: false };
+        return await new Promise((resolve, reject) => {
+            const rootCreatedAt = new Date().toISOString();
+            const child = spawn(launch.command, launch.args, {
+                cwd: request.cwd,
+                env: buildProviderChildEnvironment(request.env),
+                stdio: [request.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+                windowsHide: true,
+                detached: launch.detached,
+            });
+            let termination = null;
+            const terminate = () => {
+                termination ??= terminateHostProcessTree(child, supervisedLaunch);
+                return termination;
+            };
+            const childStdout = child.stdout;
+            const childStderr = child.stderr;
+            if (!childStdout || !childStderr) {
+                void terminate();
+                reject(new Error("Provider process stdout/stderr streams were not piped."));
+                return;
+            }
+            try {
+                if (supervisedLaunch) {
+                    persistHostProcessSupervisorMetadata(supervisedLaunch, request, child.pid ?? 0, rootCreatedAt);
+                }
+            }
+            catch (error) {
+                void terminate();
+                reject(error);
+                return;
+            }
+            let stdout = "";
+            let stderr = "";
+            let settled = false;
+            const cleanup = () => {
+                signal?.removeEventListener("abort", abort);
+            };
+            const fail = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                void terminate();
+                reject(error);
+            };
+            const abort = () => {
+                void terminate();
+            };
+            if (signal?.aborted) {
+                abort();
+            }
+            else {
+                signal?.addEventListener("abort", abort, { once: true });
+            }
+            child.on("error", fail);
+            if (request.stdin !== undefined) {
+                if (!child.stdin) {
+                    void terminate();
+                    fail(new Error("Provider process stdin stream was not piped."));
+                    return;
+                }
+                child.stdin.on("error", (error) => {
+                    void terminate();
+                    fail(error);
+                });
+                child.stdin.end(request.stdin, "utf8");
+            }
+            const readers = [
+                readProcessLines(childStdout, (line) => {
+                    if (request.captureOutput !== false)
+                        stdout += `${line}\n`;
+                    return handlers.onStdoutLine?.(line);
+                }),
+                readProcessLines(childStderr, (line) => {
+                    if (request.captureOutput !== false)
+                        stderr += `${line}\n`;
+                    return handlers.onStderrLine?.(line);
+                })
+            ];
+            child.on("close", (code) => {
+                Promise.allSettled(readers).then(async (readerResults) => {
+                    const rejected = readerResults.find((result) => result.status === "rejected");
+                    if (rejected?.status === "rejected") {
+                        fail(rejected.reason);
+                        return;
+                    }
+                    if (settled) {
+                        return;
+                    }
+                    if (supervisedLaunch?.strategy === "unix_process_group") {
+                        await terminate();
+                    }
+                    else if (termination) {
+                        await termination;
+                    }
+                    settled = true;
+                    cleanup();
+                    resolve({
+                        exitCode: code ?? 1,
+                        stdout,
+                        stderr
+                    });
+                }).catch(fail);
+            });
+        });
+    }
+}
+async function resolveProviderProcessLaunch(command, args) {
+    if (process.platform !== "win32") {
+        return { command, args };
+    }
+    const cursorDirect = await resolveCursorAgentDirectLaunch(command, args);
+    if (cursorDirect) {
+        return cursorDirect;
+    }
+    const resolved = await resolveWindowsCommand(command);
+    if (!resolved) {
+        return { command, args };
+    }
+    return resolveCodexNpmDirectLaunch(resolved, args) ?? buildWindowsLaunchCommand(resolved, args);
+}
+export function resolveCodexNpmDirectLaunch(commandPath, args) {
+    const extension = path.extname(commandPath).toLowerCase();
+    if ((extension !== ".cmd" && extension !== ".ps1")
+        || path.basename(commandPath, extension).toLowerCase() !== "codex") {
+        return null;
+    }
+    const entryPoint = path.join(path.dirname(commandPath), "node_modules", "@openai", "codex", "bin", "codex.js");
+    return fs.existsSync(entryPoint)
+        ? { command: process.execPath, args: [entryPoint, ...args] }
+        : null;
+}
+async function resolveWindowsCommand(command) {
+    if (path.isAbsolute(command)) {
+        return command;
+    }
+    try {
+        const result = await execFileAsync("where.exe", [command], { timeout: 2000 });
+        return chooseWindowsCommandCandidate(result.stdout.split(/\r?\n/));
+    }
+    catch {
+        return null;
+    }
+}
+export function chooseWindowsCommandCandidate(candidates) {
+    const normalized = candidates
+        .map((candidate) => candidate.trim())
+        .filter((candidate) => candidate.length > 0);
+    if (normalized.length === 0) {
+        return null;
+    }
+    const preferredExtensions = [".exe", ".ps1", ".cmd", ".bat", ""];
+    for (const extension of preferredExtensions) {
+        const candidate = normalized.find((entry) => path.extname(entry).toLowerCase() === extension);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return normalized[0];
+}
+async function readProcessLines(stream, onLine) {
+    const reader = readline.createInterface({ input: stream });
+    try {
+        for await (const line of reader) {
+            await onLine(line);
+        }
+    }
+    finally {
+        reader.close();
+    }
+}

package/dist/session/provider-cli/provider-cli.prompts.d.ts

@@ -0,0 +1,47 @@
+import { completionPhaseFromDispatch, type CompletionToolRuntime } from "../phase-completion.js";
+import type { RunOnceDispatchPacket } from "../session.types.js";
+import type { ProviderCliCommand } from "./provider-cli.process.js";
+export declare function buildDraftSpec(dispatch: RunOnceDispatchPacket): string;
+export interface DraftAttachmentPromptReference {
+    readonly index: number;
+    readonly path: string;
+}
+export declare function buildDraftPrompt(dispatch: RunOnceDispatchPacket, options?: {
+    readonly attachmentReferences?: readonly DraftAttachmentPromptReference[];
+}): string;
+export declare function durableDraftInput(dispatch: RunOnceDispatchPacket): RunOnceDispatchPacket["draft"];
+export declare function isDecomposeDraftKind(kind: string | null | undefined): boolean;
+export declare function isDecomposeDraftDispatch(dispatch: RunOnceDispatchPacket): boolean;
+export declare function formatProviderCliCommand(command: ProviderCliCommand): string;
+export declare function formatProviderCliCommandForCheckpoint(command: ProviderCliCommand): string;
+export declare function singleLine(value: string): string;
+export declare function buildProviderCliCommand(dispatch: RunOnceDispatchPacket, run?: {
+    readonly prompt?: string;
+    readonly promptFromStdin?: boolean;
+    readonly worktreePath?: string;
+    readonly completionTools?: CompletionToolRuntime;
+    readonly skipGitRepoCheck?: boolean;
+    readonly imagePaths?: readonly string[];
+    readonly runtimeEnvironment?: Readonly<Record<string, string>>;
+}): ProviderCliCommand;
+export declare function buildProviderCliPrompt(dispatch: RunOnceDispatchPacket, prompt: string, runtimeEnvironment?: Readonly<Record<string, string>>): string;
+export declare function codexSandboxModeForPlatform(platform?: NodeJS.Platform, executionMode?: string): "workspace-write" | "danger-full-access";
+export declare function buildArchitectPrompt(dispatch: RunOnceDispatchPacket): string;
+export declare function architectDependencyInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function designerRefInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function architectRevisionInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function buildImplementationPrompt(dispatch: RunOnceDispatchPacket, phase?: import("../phase-completion.js").CompletionPhase): string;
+export declare function buildDevelopCyclePrompt(dispatch: RunOnceDispatchPacket, phase?: import("../phase-completion.js").CompletionPhase): string;
+export declare function buildDebugCyclePrompt(dispatch: RunOnceDispatchPacket, phase?: import("../phase-completion.js").CompletionPhase): string;
+export declare function qaReworkImplementationInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function debugQaReworkInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function qaReworkRetestInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function phaseWorkInstruction(phase: ReturnType<typeof completionPhaseFromDispatch>): string;
+export declare function qaBrowserInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function storyQaInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function buildQaPrompt(dispatch: RunOnceDispatchPacket, laneSpec: string): string;
+export declare function buildConflictResolvePrompt(dispatch: RunOnceDispatchPacket, branchName: string): string;
+export declare function buildPullRequestCheckRepairPrompt(dispatch: RunOnceDispatchPacket, branchName: string): string;
+export declare function buildPullRequestCommentsPrompt(dispatch: RunOnceDispatchPacket, branchName: string): string;
+export declare function isPullRequestCheckRepairDispatch(dispatch: RunOnceDispatchPacket): boolean;
+export declare function isPullRequestCommentsDispatch(dispatch: RunOnceDispatchPacket): boolean;