pi-x-ide 1.4.0 → 1.4.2

package/src/nvim/sidecar.ts

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline";
+import { LOCK_DIR_ENV, type EditorSelectionSnapshot, type IdeLockFile } from "../shared/protocol";
+import { formatRangeMention } from "../shared/format";
+import { IdeWebSocketServer } from "../shared/ide-server";
+import {
+  createAuthToken,
+  createIdeLockFile,
+  createIdeLockFilePath,
+  refreshIdeLockFile,
+  removeIdeLockFile,
+  writeIdeLockFile,
+} from "../shared/lock-file";
+import { parseJsonLine, parseNvimSidecarMessage, parseSidecarConfig, type NvimSidecarMessage } from "./sidecar-schema";
+
+export interface NvimSidecarOptions {
+  workspaceFolders?: string[];
+  name?: string;
+  lockDir?: string;
+  stdin?: NodeJS.ReadableStream;
+  stdout?: NodeJS.WritableStream;
+  stderr?: NodeJS.WritableStream;
+}
+
+export interface NvimSidecarHandle {
+  server: IdeWebSocketServer;
+  lockFilePath: string;
+  stop: () => Promise<void>;
+}
+
+interface RuntimeState {
+  latestSelection?: EditorSelectionSnapshot;
+  workspaceFolders: string[];
+  lockFile?: IdeLockFile;
+  lockFilePath?: string;
+  stopped: boolean;
+}
+
+export async function startNvimSidecar(options: NvimSidecarOptions = {}): Promise<NvimSidecarHandle> {
+  const previousLockDir = process.env[LOCK_DIR_ENV];
+  if (options.lockDir) process.env[LOCK_DIR_ENV] = options.lockDir;
+
+  const state: RuntimeState = {
+    workspaceFolders: normalizeWorkspaceFolders(options.workspaceFolders),
+    stopped: false,
+  };
+
+  const authToken = createAuthToken();
+  const server = new IdeWebSocketServer(
+    authToken,
+    { name: options.name ?? "Neovim", ide: "nvim" },
+    () => state.latestSelection,
+  );
+
+  const port = await server.start();
+  state.lockFilePath = createIdeLockFilePath("nvim", port);
+  state.lockFile = createIdeLockFile({
+    ide: "nvim",
+    name: options.name ?? "Neovim",
+    port,
+    authToken,
+    workspaceFolders: state.workspaceFolders,
+  });
+  await writeIdeLockFile(state.lockFilePath, state.lockFile);
+
+  const stdout = options.stdout ?? process.stdout;
+  stdout.write(JSON.stringify({ type: "ready", port, lockFilePath: state.lockFilePath }) + "\n");
+
+  const stop = async () => {
+    if (state.stopped) return;
+    state.stopped = true;
+    await removeIdeLockFile(state.lockFilePath);
+    await server.stop();
+    if (options.lockDir) {
+      if (previousLockDir === undefined) delete process.env[LOCK_DIR_ENV];
+      else process.env[LOCK_DIR_ENV] = previousLockDir;
+    }
+  };
+
+  const stdin = options.stdin ?? process.stdin;
+  const stderr = options.stderr ?? process.stderr;
+  const rl = createInterface({ input: stdin });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    const parsed = parseJsonLine(trimmed);
+    const config = parseSidecarConfig(parsed);
+    if (config && !("type" in (parsed as Record<string, unknown>))) {
+      void applyConfig(state, config, stderr);
+      return;
+    }
+
+    const message = parseNvimSidecarMessage(parsed);
+    if (!message) {
+      stderr.write(`pi-x-ide nvim sidecar: ignored malformed message: ${trimmed}\n`);
+      return;
+    }
+    void handleMessage(state, server, message, stderr, stop);
+  });
+  rl.on("close", () => void stop());
+
+  const cleanup = () => void stop();
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+  process.once("beforeExit", cleanup);
+
+  return { server, lockFilePath: state.lockFilePath, stop };
+}
+
+async function applyConfig(
+  state: RuntimeState,
+  config: { workspaceFolders?: string[] },
+  stderr: NodeJS.WritableStream,
+) {
+  if (config.workspaceFolders) state.workspaceFolders = normalizeWorkspaceFolders(config.workspaceFolders);
+  if (!state.lockFilePath || !state.lockFile) return;
+  state.lockFile = refreshIdeLockFile(state.lockFile, state.workspaceFolders);
+  try {
+    await writeIdeLockFile(state.lockFilePath, state.lockFile);
+  } catch (error) {
+    stderr.write(`pi-x-ide nvim sidecar: failed to refresh lock file: ${errorMessage(error)}\n`);
+  }
+}
+
+async function handleMessage(
+  state: RuntimeState,
+  server: IdeWebSocketServer,
+  message: NvimSidecarMessage,
+  stderr: NodeJS.WritableStream,
+  stop: () => Promise<void>,
+): Promise<void> {
+  switch (message.type) {
+    case "selection_changed": {
+      const snapshot = withNvimSource(message.snapshot);
+      state.latestSelection = snapshot;
+      server.broadcast({
+        jsonrpc: "2.0",
+        method: "selection_changed",
+        params: { ...snapshot, receivedAt: snapshot.receivedAt ?? Date.now() },
+      });
+      return;
+    }
+    case "selection_cleared":
+      state.latestSelection = undefined;
+      server.broadcast({
+        jsonrpc: "2.0",
+        method: "selection_cleared",
+        params: { source: "nvim", reason: message.reason ?? "no-active-editor", receivedAt: Date.now() },
+      });
+      return;
+    case "at_mentioned": {
+      const snapshot = withNvimSource(message.snapshot);
+      state.latestSelection = snapshot;
+      const rangeText = message.rangeText || formatRangeMention(snapshot);
+      server.broadcast({
+        jsonrpc: "2.0",
+        method: "at_mentioned",
+        params: { ...snapshot, rangeText, receivedAt: snapshot.receivedAt ?? Date.now() },
+      });
+      return;
+    }
+    case "workspace_changed":
+      await applyConfig(state, { workspaceFolders: message.workspaceFolders }, stderr);
+      return;
+    case "shutdown":
+      await stop();
+      return;
+  }
+}
+
+function withNvimSource<T extends EditorSelectionSnapshot>(snapshot: T): T {
+  return { ...snapshot, source: "nvim" };
+}
+
+function normalizeWorkspaceFolders(workspaceFolders: string[] | undefined): string[] {
+  const folders = workspaceFolders?.filter((folder) => folder.length > 0) ?? [];
+  return folders.length > 0 ? folders : [process.cwd()];
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function parseCliArgs(argv: string[]): NvimSidecarOptions | "help" {
+  const options: NvimSidecarOptions = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") return "help";
+    if (arg === "--name") options.name = argv[++index];
+    else if (arg === "--lock-dir") options.lockDir = argv[++index];
+    else if (arg === "--workspace-folder") {
+      options.workspaceFolders = [...(options.workspaceFolders ?? []), argv[++index]].filter(Boolean);
+    } else if (arg === "--workspace-folders") {
+      const value = argv[++index];
+      const parsed = parseJsonLine(value ?? "");
+      const config = parseSidecarConfig({ workspaceFolders: parsed });
+      if (config?.workspaceFolders) options.workspaceFolders = config.workspaceFolders;
+    }
+  }
+  return options;
+}
+
+function printHelp(): void {
+  process.stdout.write(
+    `Usage: pi-x-ide-nvim-sidecar [options]\n\nOptions:\n  --workspace-folder <path>   Add a workspace folder. May be repeated.\n  --workspace-folders <json>  JSON array of workspace folders.\n  --lock-dir <path>           Override PI_X_IDE_LOCK_DIR for tests.\n  --name <name>               Display name reported to Pi.\n  --help                      Show this help.\n`,
+  );
+}
+
+if (require.main === module) {
+  const parsed = parseCliArgs(process.argv.slice(2));
+  if (parsed === "help") {
+    printHelp();
+  } else {
+    startNvimSidecar(parsed).catch((error: unknown) => {
+      process.stderr.write(`pi-x-ide nvim sidecar: ${errorMessage(error)}\n`);
+      process.exitCode = 1;
+    });
+  }
+}

package/src/pi/index.ts

@@ -91,10 +91,20 @@ async function maybeAutoInstallAndReconnect(
 
     notifyInstall(ctx, `Pi x IDE extension installed for ${candidate.label}. Trying to connect...`, "info");
     const connected = await retryConnectAfterInstall(runtime, ctx, generation);
-    if (!connected && isInstallSessionActive(runtime, generation)) {
+    if (!isInstallSessionActive(runtime, generation)) return;
+
+    if (connected && runtime.connectionStatus === "connected") {
+      notifyInstall(ctx, `Pi x IDE extension installed for ${candidate.label}. Connected!`, "info");
+    } else if (!connected) {
+      notifyInstall(
+        ctx,
+        `Pi x IDE extension installed for ${candidate.label}. If Pi does not connect automatically, reload the IDE window and run /ide.`,
+        "warning",
+      );
+    } else {
       notifyInstall(
         ctx,
-        `Pi x IDE extension installed for ${candidate.label}. If Pi does not connect automatically, reload the IDE window and run /ide auto.`,
+        `Pi x IDE extension installed for ${candidate.label}. Connection attempt completed. Run /ide to retry if needed.`,
         "warning",
       );
     }

package/src/pi/install.ts

@@ -177,6 +177,14 @@ export async function runCli(
   args: string[],
   timeoutMs = 15_000,
 ): Promise<{ stdout: string; stderr: string }> {
+  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,
@@ -304,7 +312,13 @@ function parsePathExt(env: NodeJS.ProcessEnv): string[] {
     .split(";")
     .map((extension) => extension.trim())
     .filter(Boolean);
-  return values.length > 0 ? ["", ...values] : [""];
+  // On Windows, skip extensionless search to avoid matching
+  // non-executable shell scripts (e.g., VS Code ships both
+  // `code` (sh) and `code.cmd` — only `.cmd` is executable).
+  if (process.platform !== "win32") {
+    return values.length > 0 ? ["", ...values] : [""];
+  }
+  return values;
 }
 
 function withExtension(command: string, extension: string): string {
@@ -312,6 +326,15 @@ function withExtension(command: string, extension: string): string {
   return command.toLowerCase().endsWith(extension.toLowerCase()) ? command : `${command}${extension}`;
 }
 
+function isCmdOrBatFile(cliPath: string): boolean {
+  const lowerPath = cliPath.toLowerCase();
+  return lowerPath.endsWith(".cmd") || lowerPath.endsWith(".bat");
+}
+
+function resolveCmdExe(): string {
+  return process.env.ComSpec ?? "cmd.exe";
+}
+
 function getExecOutput(error: unknown, key: "stdout" | "stderr"): string {
   if (typeof error !== "object" || error === null || !(key in error)) return "";
   const value = (error as Record<typeof key, unknown>)[key];

package/src/shared/ide-server.ts

@@ -0,0 +1,120 @@
+import { createServer, type Server } from "node:http";
+import WebSocket, { WebSocketServer } from "ws";
+import {
+  AUTH_HEADER,
+  PROTOCOL_VERSION,
+  type EditorSelectionSnapshot,
+  type IdeSource,
+  type InitializeResult,
+} from "./protocol";
+import { isJsonRpcRequest } from "./schema";
+import { decodeRawData } from "./ws";
+
+export class IdeWebSocketServer {
+  private httpServer?: Server;
+  private wss?: WebSocketServer;
+  private readonly sockets = new Set<WebSocket>();
+
+  constructor(
+    private readonly authToken: string,
+    private readonly serverInfo: { name: string; version?: string; ide?: IdeSource },
+    private readonly getInitialSelection?: () => EditorSelectionSnapshot | undefined,
+  ) {}
+
+  get port(): number {
+    const address = this.httpServer?.address();
+    if (!address || typeof address === "string") return 0;
+    return address.port;
+  }
+
+  get clientCount(): number {
+    return this.sockets.size;
+  }
+
+  async start(): Promise<number> {
+    this.httpServer = createServer();
+    this.wss = new WebSocketServer({
+      server: this.httpServer,
+      verifyClient: ({ req }, done) => {
+        const header = req.headers[AUTH_HEADER];
+        const token = Array.isArray(header) ? header[0] : header;
+        done(token === this.authToken, token === this.authToken ? undefined : 401, "Unauthorized");
+      },
+    });
+
+    this.wss.on("connection", (socket) => {
+      this.sockets.add(socket);
+      socket.on("close", () => this.sockets.delete(socket));
+      socket.on("error", () => this.sockets.delete(socket));
+      socket.on("message", (raw) => this.handleMessage(socket, decodeRawData(raw)));
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      this.httpServer!.once("error", reject);
+      this.httpServer!.listen(0, "127.0.0.1", () => {
+        this.httpServer!.off("error", reject);
+        resolve();
+      });
+    });
+
+    return this.port;
+  }
+
+  broadcast(value: unknown): void {
+    const text = JSON.stringify(value);
+    for (const socket of this.sockets) {
+      if (socket.readyState === WebSocket.OPEN) socket.send(text);
+    }
+  }
+
+  async stop(): Promise<void> {
+    for (const socket of this.sockets) socket.close();
+    this.sockets.clear();
+    await Promise.all([
+      new Promise<void>((resolve) => this.wss?.close(() => resolve()) ?? resolve()),
+      new Promise<void>((resolve) => this.httpServer?.close(() => resolve()) ?? resolve()),
+    ]);
+  }
+
+  private handleMessage(socket: WebSocket, text: string): void {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(text) as unknown;
+    } catch {
+      return;
+    }
+
+    if (!isJsonRpcRequest(parsed)) return;
+    if (parsed.method !== "initialize") return;
+
+    const ide = this.serverInfo.ide ?? "vscode";
+    const result: InitializeResult = {
+      protocolVersion: PROTOCOL_VERSION,
+      server: {
+        name: this.serverInfo.name,
+        version: this.serverInfo.version,
+        ide,
+      },
+    };
+
+    socket.send(JSON.stringify({ jsonrpc: "2.0", id: parsed.id, result }));
+
+    const snapshot = this.getInitialSelection?.();
+    socket.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        method: snapshot ? "selection_changed" : "selection_cleared",
+        params: snapshot
+          ? {
+              ...snapshot,
+              receivedAt: Date.now(),
+            }
+          : {
+              source: ide,
+              reason: "no-active-editor",
+              receivedAt: Date.now(),
+            },
+      }),
+    );
+  }
+}

package/src/shared/lock-file.ts

@@ -0,0 +1,65 @@
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { LOCK_FILE_EXTENSION, type IdeLockFile, type IdeSource } from "./protocol";
+import { resolveLockDir } from "./paths";
+
+export function createAuthToken(): string {
+  return randomBytes(32).toString("hex");
+}
+
+export function createIdeLockFilePath(source: IdeSource, port: number, pid = process.pid): string {
+  return join(resolveLockDir(), `${source}-${pid}-${port}${LOCK_FILE_EXTENSION}`);
+}
+
+export interface CreateIdeLockFileOptions {
+  ide: IdeSource;
+  name: string;
+  port: number;
+  authToken: string;
+  workspaceFolders: string[];
+  pid?: number;
+  now?: Date;
+}
+
+export function createIdeLockFile(options: CreateIdeLockFileOptions): IdeLockFile {
+  const now = (options.now ?? new Date()).toISOString();
+  return {
+    version: 1,
+    ide: options.ide,
+    name: options.name,
+    transport: "ws",
+    host: "127.0.0.1",
+    port: options.port,
+    authToken: options.authToken,
+    workspaceFolders: options.workspaceFolders,
+    pid: options.pid ?? process.pid,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+export async function writeIdeLockFile(path: string, lock: IdeLockFile): Promise<void> {
+  const dir = resolveLockDir();
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  await chmod(dir, 0o700).catch(() => undefined);
+
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(lock, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  await chmod(tmp, 0o600).catch(() => undefined);
+  await rename(tmp, path);
+  await chmod(path, 0o600).catch(() => undefined);
+}
+
+export async function removeIdeLockFile(path: string | undefined): Promise<void> {
+  if (!path) return;
+  await rm(path, { force: true }).catch(() => undefined);
+}
+
+export function refreshIdeLockFile(lock: IdeLockFile, workspaceFolders: string[], now = new Date()): IdeLockFile {
+  return {
+    ...lock,
+    workspaceFolders,
+    updatedAt: now.toISOString(),
+  };
+}

package/src/shared/paths.ts

@@ -10,7 +10,14 @@ export function resolveLockDir(env: NodeJS.ProcessEnv = process.env): string {
 }
 
 export function normalizePath(input: string): string {
-  return resolve(input);
+  const resolved = resolve(input);
+  // Normalize drive letter to uppercase on Windows so that path comparison
+  // is case-insensitive (VS Code may write workspace paths with lowercase
+  // drive letters while process.cwd() uses uppercase).
+  if (process.platform === "win32" && resolved.length >= 2 && resolved[1] === ":") {
+    return resolved[0].toUpperCase() + resolved.slice(1);
+  }
+  return resolved;
 }
 
 export function isPathInsideOrEqual(parent: string, child: string): boolean {

package/src/shared/protocol.ts

@@ -3,7 +3,7 @@ export const LOCK_DIR_ENV = "PI_X_IDE_LOCK_DIR";
 export const AUTH_HEADER = "x-pi-x-ide-authorization";
 export const LOCK_FILE_EXTENSION = ".lock";
 
-export type IdeSource = "vscode" | "zed" | "unknown";
+export type IdeSource = "vscode" | "zed" | "nvim" | "unknown";
 export type Transport = "ws";
 
 export interface IdeLockFile {

package/src/shared/schema.ts

@@ -22,7 +22,7 @@ function isFiniteNumber(value: unknown): value is number {
 }
 
 function isIdeSource(value: unknown): value is IdeSource {
-  return value === "vscode" || value === "zed" || value === "unknown";
+  return value === "vscode" || value === "zed" || value === "nvim" || value === "unknown";
 }
 
 export function isIdeLockFile(value: unknown): value is IdeLockFile {