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

package/dist/src/pi/install.js

@@ -0,0 +1,308 @@
+import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
+import { delimiter, isAbsolute, join } from "node:path";
+import { promisify } from "node:util";
+import * as Effect from "effect/Effect";
+import { resolvePiConfigEnv } from "../shared/config.js";
+import { InstallCommandError } from "../shared/effect-errors.js";
+import { PI_X_IDE_VERSION } from "../shared/version.js";
+const execFileAsync = promisify(execFile);
+export const PI_X_IDE_EXTENSION_ID = "balaenis.pi-x-ide";
+export const PI_X_IDE_AUTO_INSTALL_ENV = "PI_X_IDE_AUTO_INSTALL";
+export const PI_X_IDE_TARGET_VERSION = PI_X_IDE_VERSION;
+const DEFAULT_LIST_EXTENSIONS_TIMEOUT_MS = 15_000;
+const DEFAULT_INSTALL_EXTENSION_TIMEOUT_MS = 60_000;
+export const SUPPORTED_IDE_CLI_PROFILES = [
+    { id: "vscode", label: "VS Code", command: "code" },
+    { id: "cursor", label: "Cursor", command: "cursor" },
+    { id: "windsurf", label: "Windsurf", command: "windsurf" },
+];
+export function isAutoInstallEnabled(env = process.env, options = {}) {
+    const configuredEnv = resolvePiConfigEnv(env, options);
+    const value = configuredEnv[PI_X_IDE_AUTO_INSTALL_ENV];
+    if (value === undefined)
+        return true;
+    return !["0", "false", "off"].includes(value.trim().toLowerCase());
+}
+export function parseInstalledExtensionVersion(output, extensionId = PI_X_IDE_EXTENSION_ID) {
+    const target = extensionId.toLowerCase();
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const separatorIndex = line.lastIndexOf("@");
+        if (separatorIndex <= 0)
+            continue;
+        const id = line.slice(0, separatorIndex).toLowerCase();
+        if (id === target)
+            return line.slice(separatorIndex + 1).trim() || undefined;
+    }
+    return undefined;
+}
+export function compareExtensionVersions(installed, target) {
+    if (!installed)
+        return "unknown";
+    const installedParts = parseStableVersion(installed);
+    const targetParts = parseStableVersion(target);
+    if (!installedParts || !targetParts)
+        return "unknown";
+    for (let index = 0; index < 3; index += 1) {
+        if (installedParts[index] < targetParts[index])
+            return "older";
+        if (installedParts[index] > targetParts[index])
+            return "newer";
+    }
+    return "equal";
+}
+export function inferCurrentIdeFromEnv(env = process.env) {
+    const configuredEnv = resolvePiConfigEnv(env);
+    const matches = new Set();
+    const hasWindsurfMarker = hasWindsurfEnvMarker(configuredEnv);
+    const hasCursorMarker = hasCursorEnvMarker(configuredEnv);
+    const hasVscodeMarker = hasVscodeEnvMarker(configuredEnv);
+    if (hasWindsurfMarker)
+        matches.add("windsurf");
+    if (hasCursorMarker)
+        matches.add("cursor");
+    if (hasVscodeMarker && !hasWindsurfMarker && !hasCursorMarker)
+        matches.add("vscode");
+    return matches.size === 1 ? [...matches][0] : undefined;
+}
+function hasWindsurfEnvMarker(env) {
+    if (env.TERM_PROGRAM?.toLowerCase() === "windsurf")
+        return true;
+    if (hasEnvKey(env, [/^WINDSURF/, /^CODEIUM/]))
+        return true;
+    return idePathHints(env).some((value) => envValueMatches(value, [/WINDSURF/, /CODEIUM/]));
+}
+function hasCursorEnvMarker(env) {
+    if (env.TERM_PROGRAM?.toLowerCase() === "cursor")
+        return true;
+    if (hasEnvKey(env, [/^CURSOR/]))
+        return true;
+    return idePathHints(env).some((value) => envValueMatches(value, [/CURSOR/]));
+}
+function hasVscodeEnvMarker(env) {
+    if (env.TERM_PROGRAM?.toLowerCase() === "vscode")
+        return true;
+    return Boolean(env.VSCODE_CWD || env.VSCODE_PID || env.VSCODE_IPC_HOOK_CLI || env.VSCODE_GIT_IPC_HANDLE);
+}
+function hasEnvKey(env, patterns) {
+    return Object.keys(env).some((key) => patterns.some((pattern) => pattern.test(key.toUpperCase())));
+}
+function idePathHints(env) {
+    return [env.VSCODE_CWD, env.VSCODE_IPC_HOOK_CLI, env.VSCODE_GIT_IPC_HANDLE];
+}
+function envValueMatches(value, patterns) {
+    const upperValue = value?.toUpperCase();
+    return upperValue ? patterns.some((pattern) => pattern.test(upperValue)) : false;
+}
+export function buildInstallArgs() {
+    return ["--force", "--install-extension", PI_X_IDE_EXTENSION_ID];
+}
+export async function findExecutable(command, env = process.env) {
+    const configuredEnv = resolvePiConfigEnv(env);
+    const pathEnv = configuredEnv.PATH ?? configuredEnv.Path ?? configuredEnv.path;
+    if (!pathEnv)
+        return undefined;
+    const extensions = process.platform === "win32" ? parsePathExt(configuredEnv) : [""];
+    const candidates = isAbsolute(command)
+        ? [command]
+        : pathEnv
+            .split(delimiter)
+            .filter(Boolean)
+            .flatMap((directory) => extensions.map((extension) => join(directory, withExtension(command, extension))));
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+        }
+    }
+    return undefined;
+}
+export async function runCli(cliPath, args, timeoutMs = DEFAULT_LIST_EXTENSIONS_TIMEOUT_MS) {
+    if (process.platform === "win32" && isCmdOrBatFile(cliPath)) {
+        const { stdout, stderr } = await execFileAsync(resolveCmdExe(), ["/d", "/c", cliPath, ...args], {
+            timeout: timeoutMs,
+            windowsHide: true,
+            maxBuffer: 1024 * 1024,
+        });
+        return { stdout: String(stdout), stderr: String(stderr) };
+    }
+    const { stdout, stderr } = await execFileAsync(cliPath, args, {
+        timeout: timeoutMs,
+        windowsHide: true,
+        maxBuffer: 1024 * 1024,
+    });
+    return { stdout: String(stdout), stderr: String(stderr) };
+}
+function listExtensionVersion(cliPath, timeoutMs) {
+    return Effect.promise(async () => {
+        try {
+            const { stdout } = await runCli(cliPath, ["--list-extensions", "--show-versions"], timeoutMs);
+            return { installedVersion: parseInstalledExtensionVersion(stdout) };
+        }
+        catch (error) {
+            return { listError: error instanceof Error ? error.message : String(error) };
+        }
+    });
+}
+export function discoverInstallCandidatesEffect(options = {}) {
+    return Effect.gen(function* () {
+        const env = resolvePiConfigEnv(options.env ?? process.env);
+        const currentIde = inferCurrentIdeFromEnv(env);
+        const includeLowConfidence = options.includeLowConfidence ?? false;
+        const timeoutMs = options.timeoutMs ?? DEFAULT_LIST_EXTENSIONS_TIMEOUT_MS;
+        const candidates = [];
+        for (const profile of SUPPORTED_IDE_CLI_PROFILES) {
+            const cliPath = yield* Effect.promise(() => findExecutable(profile.command, env));
+            if (!cliPath)
+                continue;
+            const confidence = currentIde === profile.id ? "current-terminal" : "available-cli";
+            if (confidence !== "current-terminal" && !includeLowConfidence)
+                continue;
+            const { installedVersion, listError } = yield* listExtensionVersion(cliPath, timeoutMs);
+            const reason = resolveInstallReason(installedVersion, PI_X_IDE_TARGET_VERSION, listError);
+            candidates.push({
+                id: profile.id,
+                label: profile.label,
+                cli: profile.command,
+                cliPath,
+                confidence,
+                installedVersion,
+                targetVersion: PI_X_IDE_TARGET_VERSION,
+                needsInstall: reason === "missing" || reason === "outdated" || reason === "unknown",
+                reason,
+                listError,
+            });
+        }
+        return candidates;
+    });
+}
+export async function discoverInstallCandidates(options = {}) {
+    return Effect.runPromise(discoverInstallCandidatesEffect(options));
+}
+export function selectAutoInstallCandidate(candidates, env = process.env) {
+    const configuredEnv = resolvePiConfigEnv(env);
+    const currentIde = inferCurrentIdeFromEnv(configuredEnv);
+    const highConfidence = candidates.filter((candidate) => candidate.confidence === "current-terminal" &&
+        candidate.reason !== "unknown" &&
+        (!currentIde || candidate.id === currentIde));
+    return highConfidence.length === 1 ? highConfidence[0] : undefined;
+}
+export function installIdeExtensionEffect(candidate, runtime, options = {}) {
+    return Effect.gen(function* () {
+        if (!candidate.needsInstall) {
+            return { candidate, skipped: true, success: true, stdout: "", stderr: "" };
+        }
+        const installKey = candidate.id;
+        if (runtime.installingIdeIds.has(installKey)) {
+            return {
+                candidate,
+                skipped: true,
+                success: false,
+                stdout: "",
+                stderr: "",
+                error: `${candidate.label} extension install is already in progress.`,
+            };
+        }
+        runtime.installingIdeIds.add(installKey);
+        return yield* Effect.promise(async () => {
+            try {
+                const { stdout, stderr } = await runCli(candidate.cliPath, buildInstallArgs(), options.timeoutMs ?? DEFAULT_INSTALL_EXTENSION_TIMEOUT_MS);
+                return { candidate, skipped: false, success: true, stdout, stderr };
+            }
+            catch (error) {
+                const stdout = getExecOutput(error, "stdout");
+                const stderr = getExecOutput(error, "stderr");
+                const tagged = new InstallCommandError({
+                    cli: candidate.cli,
+                    code: getExecExitCode(error),
+                    stderr,
+                    stdout,
+                });
+                return {
+                    candidate,
+                    skipped: false,
+                    success: false,
+                    stdout: tagged.stdout ?? "",
+                    stderr: tagged.stderr,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            finally {
+                runtime.installingIdeIds.delete(installKey);
+            }
+        });
+    });
+}
+export async function installIdeExtension(candidate, runtime, options = {}) {
+    return Effect.runPromise(installIdeExtensionEffect(candidate, runtime, options));
+}
+function resolveInstallReason(installedVersion, targetVersion, listError) {
+    if (listError)
+        return "unknown";
+    if (!installedVersion)
+        return "missing";
+    const comparison = compareExtensionVersions(installedVersion, targetVersion);
+    if (comparison === "older")
+        return "outdated";
+    if (comparison === "equal" || comparison === "newer")
+        return "current";
+    return "unknown";
+}
+function parseStableVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:$|[-+])/.exec(version.trim());
+    if (!match)
+        return undefined;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function parsePathExt(env) {
+    const pathExt = env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+    const values = pathExt
+        .split(";")
+        .map((extension) => extension.trim())
+        .filter(Boolean);
+    if (process.platform !== "win32") {
+        return values.length > 0 ? ["", ...values] : [""];
+    }
+    return values;
+}
+function withExtension(command, extension) {
+    if (!extension)
+        return command;
+    return command.toLowerCase().endsWith(extension.toLowerCase()) ? command : `${command}${extension}`;
+}
+function isCmdOrBatFile(cliPath) {
+    const lowerPath = cliPath.toLowerCase();
+    return lowerPath.endsWith(".cmd") || lowerPath.endsWith(".bat");
+}
+function resolveCmdExe() {
+    return process.env.ComSpec ?? "cmd.exe";
+}
+function getExecOutput(error, key) {
+    if (typeof error !== "object" || error === null || !(key in error))
+        return "";
+    const value = error[key];
+    if (typeof value === "string")
+        return value;
+    if (Buffer.isBuffer(value))
+        return value.toString("utf8");
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+        return value.toString();
+    return "";
+}
+function getExecExitCode(error) {
+    if (typeof error !== "object" || error === null || !("code" in error))
+        return undefined;
+    const value = error.code;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (value === null)
+        return null;
+    return undefined;
+}

package/dist/src/pi/reconnect.js

@@ -0,0 +1,57 @@
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import { updateIdeUi } from "./ui.js";
+export const MAX_RECONNECT_ATTEMPTS = 3;
+export const RECONNECT_DELAY_MS = 2_000;
+export function resetReconnectState(runtime) {
+    runtime.reconnectAttempts = 0;
+    runtime.reconnectCandidateKey = undefined;
+}
+export function recordReconnectAttempt(runtime, candidate) {
+    const key = candidate ? reconnectCandidateKey(candidate) : undefined;
+    if (runtime.reconnectCandidateKey !== key) {
+        runtime.reconnectCandidateKey = key;
+        runtime.reconnectAttempts = 0;
+    }
+    if (runtime.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS)
+        return undefined;
+    runtime.reconnectAttempts += 1;
+    return runtime.reconnectAttempts;
+}
+export function formatReconnectLimitMessage(candidate) {
+    const target = candidate ? `${candidate.lock.name} at ${candidate.lock.host}:${candidate.lock.port}` : "IDE";
+    return `Stopped reconnecting to ${target} after ${MAX_RECONNECT_ATTEMPTS} attempts.`;
+}
+export function stopReconnectScheduling(runtime) {
+    const fiber = runtime.reconnectFiber;
+    runtime.reconnectFiber = undefined;
+    if (fiber)
+        Effect.runFork(Fiber.interrupt(fiber));
+}
+export function scheduleReconnect(runtime, reconnect) {
+    if (runtime.reconnectFiber || !runtime.enabled)
+        return;
+    const generation = runtime.sessionGeneration;
+    const attempt = recordReconnectAttempt(runtime, runtime.currentCandidate);
+    if (attempt === undefined) {
+        runtime.connectionStatus = "error";
+        runtime.connectionMessage = formatReconnectLimitMessage(runtime.currentCandidate);
+        updateIdeUi(runtime);
+        return;
+    }
+    const fiber = Effect.runFork(Effect.gen(function* () {
+        yield* Effect.sleep(`${RECONNECT_DELAY_MS} millis`);
+        if (runtime.reconnectFiber === fiber)
+            runtime.reconnectFiber = undefined;
+        if (!runtime.enabled || runtime.sessionGeneration !== generation)
+            return;
+        yield* Effect.promise(() => reconnect(generation));
+    }).pipe(Effect.ensuring(Effect.sync(() => {
+        if (runtime.reconnectFiber === fiber)
+            runtime.reconnectFiber = undefined;
+    }))));
+    runtime.reconnectFiber = fiber;
+}
+function reconnectCandidateKey(candidate) {
+    return `${candidate.path}:${candidate.lock.host}:${candidate.lock.port}:${candidate.mtimeMs}`;
+}

package/dist/src/pi/runtime-loader.js

@@ -0,0 +1,38 @@
+const defaultImporter = () => import("./runtime-services.js");
+let importer = defaultImporter;
+let cachedPromise;
+export function preloadRuntimeServices() {
+    return loadRuntimeServices();
+}
+export function loadRuntimeServices() {
+    if (!cachedPromise) {
+        cachedPromise = importer().then((module) => module, (error) => {
+            cachedPromise = undefined;
+            throw error;
+        });
+    }
+    return cachedPromise;
+}
+export function createRuntimeServicesLoaderForTests(nextImporter = defaultImporter) {
+    let testCached;
+    const load = () => {
+        if (!testCached) {
+            testCached = nextImporter().then((module) => module, (error) => {
+                testCached = undefined;
+                throw error;
+            });
+        }
+        return testCached;
+    };
+    return {
+        preloadRuntimeServices: load,
+        loadRuntimeServices: load,
+        reset: () => {
+            testCached = undefined;
+        },
+    };
+}
+export function setRuntimeServicesImporterForTests(nextImporter) {
+    importer = nextImporter ?? defaultImporter;
+    cachedPromise = undefined;
+}