@saifymatteo/pi-x-ide 0.0.0-stage → 1.20.1

package/dist/src/pi/diagnostic-renderer.js

@@ -0,0 +1,326 @@
+import { visibleWidth } from "../shared/display-width.js";
+import { toRelativeDisplayPath } from "../shared/paths.js";
+import { formatDiagnosticCode, formatRange } from "./diagnostics.js";
+import { DIAGNOSTIC_FIX_CUSTOM_TYPE } from "./diagnostic-types.js";
+export { DIAGNOSTIC_FIX_CUSTOM_TYPE } from "./diagnostic-types.js";
+const DIAGNOSTIC_BOX_PADDING_X = 1;
+const DIAGNOSTIC_BOX_PADDING_Y = 1;
+const MIN_CONTENT_WIDTH = 1;
+const TAB_REPLACEMENT = "   ";
+const ESCAPE_CHARACTER = String.fromCharCode(27);
+const ANSI_SEQUENCE_AT_START = new RegExp(`^${ESCAPE_CHARACTER}\\[[0-?]*[ -/]*[@-~]`);
+const GRAPHEME_SEGMENTER = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(undefined, { granularity: "grapheme" }) : undefined;
+const SGR_CODES = {
+    reset: 0,
+    bold: 1,
+    dim: 2,
+    italic: 3,
+    underline: 4,
+    slowBlink: 5,
+    rapidBlink: 6,
+    inverse: 7,
+    conceal: 8,
+    strikethrough: 9,
+    doubleUnderline: 21,
+    intensityReset: 22,
+    italicReset: 23,
+    underlineReset: 24,
+    blinkReset: 25,
+    inverseReset: 27,
+    concealReset: 28,
+    strikethroughReset: 29,
+    foregroundStart: 30,
+    foregroundEnd: 37,
+    extendedForeground: 38,
+    foregroundReset: 39,
+    backgroundStart: 40,
+    backgroundEnd: 47,
+    extendedBackground: 48,
+    backgroundReset: 49,
+    overline: 53,
+    overlineReset: 55,
+    extendedUnderlineColor: 58,
+    underlineColorReset: 59,
+    brightForegroundStart: 90,
+    brightForegroundEnd: 97,
+    brightBackgroundStart: 100,
+    brightBackgroundEnd: 107,
+};
+const SGR_INDEXED_COLOR_MODE = 5;
+const SGR_TRUE_COLOR_MODE = 2;
+const SGR_INDEXED_COLOR_PARAMETER_COUNT = 2;
+const SGR_TRUE_COLOR_PARAMETER_COUNT = 4;
+const SGR_STYLE_GROUPS = new Map([
+    [SGR_CODES.bold, "bold"],
+    [SGR_CODES.dim, "dim"],
+    [SGR_CODES.italic, "italic"],
+    [SGR_CODES.underline, "underline"],
+    [SGR_CODES.slowBlink, "blink"],
+    [SGR_CODES.rapidBlink, "blink"],
+    [SGR_CODES.inverse, "inverse"],
+    [SGR_CODES.conceal, "conceal"],
+    [SGR_CODES.strikethrough, "strikethrough"],
+    [SGR_CODES.doubleUnderline, "underline"],
+    [SGR_CODES.overline, "overline"],
+]);
+const SGR_STYLE_RESETS = new Map([
+    [SGR_CODES.intensityReset, ["bold", "dim"]],
+    [SGR_CODES.italicReset, ["italic"]],
+    [SGR_CODES.underlineReset, ["underline"]],
+    [SGR_CODES.blinkReset, ["blink"]],
+    [SGR_CODES.inverseReset, ["inverse"]],
+    [SGR_CODES.concealReset, ["conceal"]],
+    [SGR_CODES.strikethroughReset, ["strikethrough"]],
+    [SGR_CODES.overlineReset, ["overline"]],
+]);
+export function registerDiagnosticRenderer(pi) {
+    pi.registerMessageRenderer(DIAGNOSTIC_FIX_CUSTOM_TYPE, (message, { expanded }, theme) => {
+        const details = message.details;
+        if (!details)
+            return undefined;
+        return createDiagnosticFixComponent(details, theme, expanded);
+    });
+}
+export function createDiagnosticFixComponent(details, theme, expanded) {
+    return new DiagnosticMessageComponent(buildText(details, theme, expanded), (text) => theme.bg("customMessageBg", text));
+}
+class DiagnosticMessageComponent {
+    text;
+    bgFn;
+    cache;
+    constructor(text, bgFn) {
+        this.text = text;
+        this.bgFn = bgFn;
+    }
+    invalidate() {
+        this.cache = undefined;
+    }
+    render(width) {
+        if (this.cache?.width === width)
+            return this.cache.lines;
+        const contentWidth = Math.max(MIN_CONTENT_WIDTH, width - DIAGNOSTIC_BOX_PADDING_X * 2);
+        const leftPad = " ".repeat(DIAGNOSTIC_BOX_PADDING_X);
+        const lines = [];
+        for (let index = 0; index < DIAGNOSTIC_BOX_PADDING_Y; index += 1) {
+            lines.push(this.padAndApplyBackground("", width));
+        }
+        for (const wrappedLine of wrapAnsiText(this.text, contentWidth)) {
+            lines.push(this.padAndApplyBackground(leftPad + wrappedLine, width));
+        }
+        for (let index = 0; index < DIAGNOSTIC_BOX_PADDING_Y; index += 1) {
+            lines.push(this.padAndApplyBackground("", width));
+        }
+        this.cache = { width, lines };
+        return lines;
+    }
+    padAndApplyBackground(line, width) {
+        const padNeeded = Math.max(0, width - visibleWidth(line));
+        return this.bgFn(line + " ".repeat(padNeeded));
+    }
+}
+export function wrapAnsiText(text, width) {
+    const normalizedText = text.replaceAll("\t", TAB_REPLACEMENT);
+    const lines = [];
+    const sgrState = new SgrState();
+    for (const logicalLine of normalizedText.split("\n")) {
+        lines.push(...wrapAnsiLine(logicalLine, width, sgrState));
+    }
+    return lines.length > 0 ? lines : [""];
+}
+function wrapAnsiLine(line, width, sgrState) {
+    const lines = [];
+    let currentLine = sgrState.toAnsi();
+    let currentWidth = 0;
+    let index = 0;
+    while (index < line.length) {
+        const ansiSequence = readAnsiSequence(line, index);
+        if (ansiSequence) {
+            currentLine += ansiSequence;
+            sgrState.process(ansiSequence);
+            index += ansiSequence.length;
+            continue;
+        }
+        if (line[index] === ESCAPE_CHARACTER) {
+            currentLine += ESCAPE_CHARACTER;
+            index += 1;
+            continue;
+        }
+        const nextEscape = line.indexOf(ESCAPE_CHARACTER, index);
+        const textEnd = nextEscape === -1 ? line.length : nextEscape;
+        const textChunk = line.slice(index, textEnd);
+        for (const grapheme of segmentGraphemes(textChunk)) {
+            const graphemeWidth = visibleWidth(grapheme);
+            if (currentWidth > 0 && currentWidth + graphemeWidth > width) {
+                lines.push(currentLine + sgrState.lineEndReset());
+                currentLine = sgrState.toAnsi();
+                currentWidth = 0;
+            }
+            currentLine += grapheme;
+            currentWidth += graphemeWidth;
+        }
+        index = textEnd;
+    }
+    lines.push(currentLine + sgrState.lineEndReset());
+    return lines;
+}
+function readAnsiSequence(text, index) {
+    if (text[index] !== ESCAPE_CHARACTER)
+        return undefined;
+    return ANSI_SEQUENCE_AT_START.exec(text.slice(index))?.[0];
+}
+class SgrState {
+    activeCodes = new Map();
+    process(sequence) {
+        if (!sequence.endsWith("m"))
+            return;
+        const rawParameters = sequence.slice(2, -1);
+        const parameters = rawParameters === "" ? [SGR_CODES.reset] : rawParameters.split(";").map(Number);
+        for (let index = 0; index < parameters.length; index += 1) {
+            const code = parameters[index];
+            if (!Number.isInteger(code))
+                continue;
+            if (code === SGR_CODES.reset) {
+                this.activeCodes.clear();
+                continue;
+            }
+            const styleGroup = SGR_STYLE_GROUPS.get(code);
+            if (styleGroup) {
+                this.activeCodes.set(styleGroup, formatSgrSequence([code]));
+                continue;
+            }
+            const resetGroups = SGR_STYLE_RESETS.get(code);
+            if (resetGroups) {
+                for (const resetGroup of resetGroups)
+                    this.activeCodes.delete(resetGroup);
+                continue;
+            }
+            if (isStandardForegroundCode(code)) {
+                this.activeCodes.set("foreground", formatSgrSequence([code]));
+                continue;
+            }
+            if (code === SGR_CODES.foregroundReset) {
+                this.activeCodes.delete("foreground");
+                continue;
+            }
+            if (isStandardBackgroundCode(code)) {
+                this.activeCodes.set("background", formatSgrSequence([code]));
+                continue;
+            }
+            if (code === SGR_CODES.backgroundReset) {
+                this.activeCodes.delete("background");
+                continue;
+            }
+            if (code === SGR_CODES.underlineColorReset) {
+                this.activeCodes.delete("underline-color");
+                continue;
+            }
+            const extendedGroup = getExtendedColorGroup(code);
+            if (extendedGroup) {
+                const parameterCount = getExtendedColorParameterCount(parameters[index + 1]);
+                if (parameterCount === 0 || index + parameterCount >= parameters.length)
+                    continue;
+                const colorParameters = parameters.slice(index, index + parameterCount + 1);
+                this.activeCodes.set(extendedGroup, formatSgrSequence(colorParameters));
+                index += parameterCount;
+            }
+        }
+    }
+    toAnsi() {
+        return [...this.activeCodes.values()].join("");
+    }
+    lineEndReset() {
+        return this.activeCodes.has("underline") ? formatSgrSequence([SGR_CODES.underlineReset]) : "";
+    }
+}
+function isStandardForegroundCode(code) {
+    return ((code >= SGR_CODES.foregroundStart && code <= SGR_CODES.foregroundEnd) ||
+        (code >= SGR_CODES.brightForegroundStart && code <= SGR_CODES.brightForegroundEnd));
+}
+function isStandardBackgroundCode(code) {
+    return ((code >= SGR_CODES.backgroundStart && code <= SGR_CODES.backgroundEnd) ||
+        (code >= SGR_CODES.brightBackgroundStart && code <= SGR_CODES.brightBackgroundEnd));
+}
+function getExtendedColorGroup(code) {
+    if (code === SGR_CODES.extendedForeground)
+        return "foreground";
+    if (code === SGR_CODES.extendedBackground)
+        return "background";
+    if (code === SGR_CODES.extendedUnderlineColor)
+        return "underline-color";
+    return undefined;
+}
+function getExtendedColorParameterCount(mode) {
+    if (mode === SGR_INDEXED_COLOR_MODE)
+        return SGR_INDEXED_COLOR_PARAMETER_COUNT;
+    if (mode === SGR_TRUE_COLOR_MODE)
+        return SGR_TRUE_COLOR_PARAMETER_COUNT;
+    return 0;
+}
+function formatSgrSequence(parameters) {
+    return `${ESCAPE_CHARACTER}[${parameters.join(";")}m`;
+}
+function* segmentGraphemes(text) {
+    if (GRAPHEME_SEGMENTER) {
+        for (const segment of GRAPHEME_SEGMENTER.segment(text))
+            yield segment.segment;
+        return;
+    }
+    yield* text;
+}
+export function buildDiagnosticFixText(details, theme, expanded) {
+    return buildText(details, theme, expanded);
+}
+function buildText(details, theme, expanded) {
+    const severityColor = pickSeverityColor(details.diagnostics);
+    const label = theme.fg(severityColor, theme.bold("[DIAGNOSTIC]"));
+    const sourceLabel = describeSource(details.source);
+    const relPath = toRelativeDisplayPath(details.filePath, details.workspaceFolder, details.cwd);
+    const location = theme.fg("dim", `${relPath}:${formatRange(details.triggerRange)}`);
+    const count = details.diagnostics.length;
+    const noun = count === 1 ? "diagnostic" : "diagnostics";
+    const header = `${label} Fix ${count} ${noun} from ${sourceLabel} — ${location}`;
+    if (!expanded) {
+        return `${header}\n${theme.fg("dim", "ctrl+o to expand")}`;
+    }
+    const lines = [header];
+    for (const [index, diagnostic] of details.diagnostics.entries()) {
+        lines.push("");
+        lines.push(formatDiagnostic(diagnostic, index, details, theme));
+    }
+    return lines.join("\n");
+}
+function formatDiagnostic(diagnostic, index, details, theme) {
+    const color = diagnostic.severity === "error" ? "error" : "warning";
+    const headerText = `${diagnostic.severity.toUpperCase()} #${index + 1}`;
+    const lines = [`${theme.fg(color, headerText)} ${theme.fg("dim", formatRange(diagnostic.range))}`];
+    if (diagnostic.code !== undefined) {
+        lines.push(theme.fg("dim", `  code: ${formatDiagnosticCode(diagnostic.code)}`));
+    }
+    if (diagnostic.source) {
+        lines.push(theme.fg("dim", `  source: ${diagnostic.source}`));
+    }
+    lines.push(`  ${diagnostic.message}`);
+    if (diagnostic.contextLines.length > 0) {
+        for (const contextLine of diagnostic.contextLines) {
+            const marker = contextLine.isPrimary ? theme.fg(color, ">") : " ";
+            const lineNumber = theme.fg("dim", `${contextLine.line + 1}:`.padStart(4, " "));
+            lines.push(`  ${marker} ${lineNumber} ${contextLine.text}`);
+        }
+    }
+    if (diagnostic.relatedInformation && diagnostic.relatedInformation.length > 0) {
+        lines.push(theme.fg("dim", "  related:"));
+        for (const related of diagnostic.relatedInformation) {
+            const relatedPath = toRelativeDisplayPath(related.filePath, details.workspaceFolder, details.cwd);
+            lines.push(theme.fg("dim", `    ${relatedPath} ${formatRange(related.range)}: ${related.message}`));
+        }
+    }
+    return lines.join("\n");
+}
+function pickSeverityColor(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "error" : "warning";
+}
+function describeSource(source) {
+    if (source === "vscode")
+        return "VS Code";
+    return source;
+}

package/dist/src/pi/diagnostic-types.js

@@ -0,0 +1 @@
+export const DIAGNOSTIC_FIX_CUSTOM_TYPE = "pi-x-ide/diagnostic-fix";

package/dist/src/pi/diagnostics.js

@@ -0,0 +1,104 @@
+import { readPiConfigFixPrompt } from "../shared/config.js";
+import { DIAGNOSTIC_FIX_CUSTOM_TYPE } from "./diagnostic-types.js";
+export const DIAGNOSTIC_CONTEXT_MARKER = "pi-x-ide/diagnostic-context";
+export function buildDiagnosticFixPrompt(params, options = {}) {
+    const context = buildDiagnosticContextMessage(params);
+    const template = options.fixPrompt;
+    if (!template) {
+        return `Analyze the errors and warnings at the following location, and try to fix them:
+${context}`;
+    }
+    if (template.includes("{DIAGNOSTIC}")) {
+        return template.replaceAll("{DIAGNOSTIC}", context);
+    }
+    return `${template}
+${context}`;
+}
+export function buildDiagnosticContextMessage(params) {
+    return `<!-- ${DIAGNOSTIC_CONTEXT_MARKER} -->
+${formatDiagnosticContext(params)}
+<!-- ${DIAGNOSTIC_CONTEXT_MARKER} -->
+`;
+}
+export function formatDiagnosticContext(params) {
+    const filePath = params.filePath;
+    const lines = [`File: ${filePath}`, `Source: ${params.source}`];
+    if (params.documentVersion !== undefined)
+        lines.push(`Document version: ${params.documentVersion}`);
+    lines.push(`Trigger range: ${formatRange(params.triggerRange)}`);
+    for (const [index, diagnostic] of params.diagnostics.entries()) {
+        lines.push("", `Diagnostic ${index + 1}:`);
+        lines.push(`- Severity: ${diagnostic.severity}`);
+        if (diagnostic.source)
+            lines.push(`- Source: ${diagnostic.source}`);
+        if (diagnostic.code !== undefined)
+            lines.push(`- Code: ${formatDiagnosticCode(diagnostic.code)}`);
+        lines.push(`- Range: ${formatRange(diagnostic.range)}`);
+        lines.push(`- Message: ${diagnostic.message}`);
+        if (diagnostic.selectedText.length > 0) {
+            lines.push("- Selected text:", fence(diagnostic.selectedText));
+        }
+        if (diagnostic.contextLines.length > 0) {
+            lines.push("- Context lines:");
+            for (const contextLine of diagnostic.contextLines) {
+                const marker = contextLine.isPrimary ? "\\>" : " ";
+                lines.push(`  ${marker} ${contextLine.line + 1}: ${contextLine.text}`);
+            }
+        }
+        if (diagnostic.relatedInformation && diagnostic.relatedInformation.length > 0) {
+            lines.push("- Related information:");
+            for (const related of diagnostic.relatedInformation) {
+                const relatedPath = related.filePath;
+                lines.push(`  - ${relatedPath} ${formatRange(related.range)}: ${related.message}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+export function handleDiagnosticFixRequested(pi, runtime, params) {
+    const ctx = runtime.ctx;
+    if (!ctx)
+        return;
+    if (params.action === "send-diagnostic") {
+        if (!ctx.hasUI)
+            return;
+        ctx.ui.pasteToEditor(buildDiagnosticContextMessage(params));
+        ctx.ui.notify("VS Code diagnostic context added to input.", "info");
+        return;
+    }
+    const fixPrompt = readPiConfigFixPrompt();
+    const prompt = buildDiagnosticFixPrompt(params, { fixPrompt });
+    const details = {
+        source: params.source,
+        filePath: params.filePath,
+        workspaceFolder: params.workspaceFolder,
+        triggerRange: params.triggerRange,
+        diagnostics: params.diagnostics,
+        cwd: ctx.cwd,
+    };
+    pi.sendMessage({
+        customType: DIAGNOSTIC_FIX_CUSTOM_TYPE,
+        content: prompt,
+        display: true,
+        details,
+    }, { triggerTurn: true, deliverAs: "followUp" });
+    if (!ctx.isIdle() && ctx.hasUI)
+        ctx.ui.notify("VS Code diagnostic fix request queued.", "info");
+}
+export function formatRange(range) {
+    const start = formatPosition(range.start);
+    const end = formatPosition(range.end);
+    return start === end ? start : `${start}-${end}`;
+}
+export function formatPosition(position) {
+    return `L${position.line + 1}:C${position.character + 1}`;
+}
+export function formatDiagnosticCode(code) {
+    if (typeof code === "string" || typeof code === "number")
+        return String(code);
+    return code.target ? `${code.value} (${code.target})` : String(code.value);
+}
+function fence(text) {
+    const fenceMarker = text.includes("```") ? "````" : "```";
+    return `${fenceMarker}\n${text}\n${fenceMarker}`;
+}

package/dist/src/pi/discovery.js

@@ -0,0 +1,135 @@
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import * as Effect from "effect/Effect";
+import { LOCK_FILE_EXTENSION } from "../shared/protocol.js";
+import { relationshipMatchLength, resolveLockDirs } from "../shared/paths.js";
+import { parseLockFileContent } from "../shared/schema.js";
+import { isWsl, normalizePathForHost } from "../shared/platform.js";
+import { IDE_HOST_TCP_PROBE_TIMEOUT_MS, resolveIdeHost, tcpReachable } from "./ide-host.js";
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isUsableLocalPid(pid) {
+    return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0;
+}
+function bestWorkspaceMatch(lock, cwd, env) {
+    let best;
+    for (const workspaceFolder of lock.workspaceFolders) {
+        const matchLength = relationshipMatchLength(workspaceFolder, cwd, env);
+        if (matchLength <= 0)
+            continue;
+        if (!best || matchLength > best.matchLength) {
+            best = { matchLength, workspaceFolder: normalizePathForHost(workspaceFolder, env) };
+        }
+    }
+    return best;
+}
+export function sortCandidates(candidates) {
+    return [...candidates].sort((a, b) => b.matchLength - a.matchLength || b.mtimeMs - a.mtimeMs || a.path.localeCompare(b.path));
+}
+function removeLockFile(path) {
+    return Effect.promise(() => rm(path, { force: true }).then(() => undefined, () => undefined));
+}
+function isWindowsLockReachable(lock, options, env) {
+    return Effect.promise(async () => {
+        try {
+            const host = await (options.resolveHost ?? ((ideLock) => resolveIdeHost(ideLock, { env, tcpProbe: options.tcpProbe })))(lock);
+            return await (options.tcpProbe ?? tcpReachable)(host, lock.port, IDE_HOST_TCP_PROBE_TIMEOUT_MS);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function discoverIdeCandidatesInDirEffect(lockDir, options, env) {
+    return Effect.gen(function* () {
+        const now = options.now ?? Date.now();
+        const maxAgeMs = options.maxAgeMs ?? 24 * 60 * 60 * 1000;
+        const checkPid = options.checkPid ?? true;
+        const entries = yield* Effect.promise(async () => {
+            try {
+                return await readdir(lockDir);
+            }
+            catch {
+                return [];
+            }
+        });
+        const candidates = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(LOCK_FILE_EXTENSION))
+                continue;
+            const path = join(lockDir, entry);
+            const file = yield* Effect.promise(async () => {
+                try {
+                    const [content, fileStat] = await Promise.all([readFile(path, "utf8"), stat(path)]);
+                    return { content, mtimeMs: fileStat.mtimeMs };
+                }
+                catch {
+                    return undefined;
+                }
+            });
+            if (!file)
+                continue;
+            const lock = parseLockFileContent(file.content);
+            if (!lock) {
+                yield* removeLockFile(path);
+                continue;
+            }
+            const isWindowsSideWsl = lock.runningInWindows === true && isWsl(env);
+            const pid = lock.pid;
+            if (checkPid && isWindowsSideWsl) {
+                const reachable = yield* isWindowsLockReachable(lock, options, env);
+                if (!reachable) {
+                    yield* removeLockFile(path);
+                    continue;
+                }
+            }
+            else if (checkPid && isUsableLocalPid(pid)) {
+                if (!isProcessAlive(pid)) {
+                    yield* removeLockFile(path);
+                    continue;
+                }
+            }
+            else if (now - file.mtimeMs > maxAgeMs) {
+                yield* removeLockFile(path);
+                continue;
+            }
+            const match = bestWorkspaceMatch(lock, options.cwd, env);
+            const { matchLength, workspaceFolder } = match ?? {
+                matchLength: 0,
+                workspaceFolder: lock.workspaceFolders[0] ? normalizePathForHost(lock.workspaceFolders[0], env) : "",
+            };
+            candidates.push({ path, lock, mtimeMs: file.mtimeMs, matchLength, workspaceFolder });
+        }
+        return candidates;
+    });
+}
+export function discoverIdeCandidatesEffect(options) {
+    return Effect.gen(function* () {
+        const env = options.env ?? process.env;
+        const lockDirs = resolveLockDirs({
+            lockDir: options.lockDir,
+            homeLockDir: options.homeLockDir,
+            env,
+            windowsUsersRoot: options.windowsUsersRoot,
+        });
+        const candidates = [];
+        for (const lockDir of lockDirs) {
+            const dirCandidates = yield* discoverIdeCandidatesInDirEffect(lockDir, options, env);
+            candidates.push(...dirCandidates);
+        }
+        return sortCandidates(candidates);
+    });
+}
+export async function discoverIdeCandidates(options) {
+    return Effect.runPromise(discoverIdeCandidatesEffect(options));
+}
+export async function resolveBestIdeCandidate(options) {
+    return (await discoverIdeCandidates(options))[0];
+}

package/dist/src/pi/effect-boundary.js

@@ -0,0 +1,5 @@
+import { runEffect } from "../shared/effect-runtime.js";
+import { containPiError } from "./safety.js";
+export function runPiEffect(scope, runtime, effect, ctx) {
+    return runEffect(scope, effect, (error) => containPiError(runtime, scope, error, ctx));
+}

package/dist/src/pi/ide-host.js

@@ -0,0 +1,68 @@
+import { execFile } from "node:child_process";
+import { createConnection } from "node:net";
+import { promisify } from "node:util";
+import * as Effect from "effect/Effect";
+import { resolvePiConfigEnv } from "../shared/config.js";
+import { isWsl } from "../shared/platform.js";
+export const PI_X_IDE_HOST_OVERRIDE_ENV = "PI_X_IDE_HOST_OVERRIDE";
+export const IDE_HOST_TCP_PROBE_TIMEOUT_MS = 500;
+const execFileAsync = promisify(execFile);
+export function resolveIdeHostEffect(lock, options = {}) {
+    return Effect.gen(function* () {
+        const env = resolvePiConfigEnv(options.env ?? process.env);
+        const override = env[PI_X_IDE_HOST_OVERRIDE_ENV]?.trim();
+        if (override)
+            return override;
+        if (lock.runningInWindows === true && isWsl(env)) {
+            const gateway = yield* Effect.promise(() => resolveWslDefaultGateway(options.runCommand ?? defaultRunCommand));
+            if (gateway) {
+                const reachable = yield* Effect.promise(() => (options.tcpProbe ?? tcpReachable)(gateway, lock.port, options.timeoutMs ?? IDE_HOST_TCP_PROBE_TIMEOUT_MS));
+                if (reachable)
+                    return gateway;
+            }
+        }
+        return lock.host || "127.0.0.1";
+    });
+}
+export async function resolveIdeHost(lock, options = {}) {
+    return Effect.runPromise(resolveIdeHostEffect(lock, options));
+}
+export async function resolveWslDefaultGateway(runCommand = defaultRunCommand) {
+    try {
+        const { stdout } = await runCommand("ip", ["route", "show"]);
+        return parseDefaultGateway(stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseDefaultGateway(output) {
+    for (const line of output.split(/\r?\n/)) {
+        const match = line.match(/^default\s+via\s+(\d{1,3}(?:\.\d{1,3}){3})(?:\s|$)/);
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+async function defaultRunCommand(command, args) {
+    const { stdout } = await execFileAsync(command, args, { encoding: "utf8" });
+    return { stdout };
+}
+export function tcpReachable(host, port, timeoutMs = IDE_HOST_TCP_PROBE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const socket = createConnection({ host, port });
+        let settled = false;
+        const finish = (reachable) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(reachable);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => finish(true));
+        socket.once("timeout", () => finish(false));
+        socket.once("error", () => finish(false));
+    });
+}