neon 2.44.0 → 2.46.0

package/dist/init/detect_agent.js

@@ -0,0 +1,108 @@
+import { existsSync } from "node:fs";
+/**
+ * Detects the IDE/editor the terminal is running in, regardless of which
+ * agent is active. Used for extension installation — the extension goes
+ * into the IDE, not the agent.
+ *
+ * Returns an Editor-compatible string: "Cursor", "VS Code", "Windsurf", or null.
+ */
+export function detectIde() {
+    const env = process.env;
+    // Cursor: check explicit Cursor env vars (set in extension host context)
+    if (env.TERM_PROGRAM === "cursor" ||
+        env.CURSOR_TRACE_ID !== undefined ||
+        env.CURSOR_EXTENSION_HOST_ROLE !== undefined ||
+        env.CURSOR_LAYOUT !== undefined ||
+        env.CURSOR_SPAWNED_BY_EXTENSION_ID !== undefined) {
+        return "Cursor";
+    }
+    // Cursor: check app paths in env vars (reliable from terminal context)
+    if (env.GIT_ASKPASS?.includes("Cursor.app") ||
+        env.VSCODE_GIT_ASKPASS_NODE?.includes("Cursor.app") ||
+        env.GIT_ASKPASS?.includes("cursor") ||
+        env.VSCODE_GIT_ASKPASS_NODE?.includes("cursor")) {
+        return "Cursor";
+    }
+    // Windsurf
+    if (env.TERM_PROGRAM === "windsurf") {
+        return "Windsurf";
+    }
+    // At this point we know we're in a VS Code-like environment if any
+    // VSCODE_ env vars are set. But is it actually Cursor with generic env vars?
+    if (env.TERM_PROGRAM === "vscode" ||
+        env.VSCODE_PID !== undefined ||
+        env.VSCODE_CWD !== undefined) {
+        // Check any remaining env vars that might contain "cursor" (case-insensitive)
+        // This catches VSCODE_IPC_HOOK_CLI, PATH additions, etc.
+        const envValues = Object.values(env).join("\n").toLowerCase();
+        if (envValues.includes("cursor.app") ||
+            envValues.includes("/cursor/")) {
+            return "Cursor";
+        }
+        // If only Cursor is installed (not VS Code), it must be Cursor
+        if (isCursorInstalled() && !isVSCodeInstalled()) {
+            return "Cursor";
+        }
+        return "VS Code";
+    }
+    return null;
+}
+export function isCursorInstalled() {
+    if (process.platform === "darwin") {
+        return existsSync("/Applications/Cursor.app");
+    }
+    if (process.platform === "linux") {
+        return existsSync("/usr/share/cursor") || existsSync("/usr/bin/cursor");
+    }
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA || "";
+        return (existsSync(`${localAppData}\\Programs\\Cursor\\Cursor.exe`) ||
+            existsSync(`${localAppData}\\cursor\\Cursor.exe`));
+    }
+    return false;
+}
+export function isVSCodeInstalled() {
+    if (process.platform === "darwin") {
+        return existsSync("/Applications/Visual Studio Code.app");
+    }
+    if (process.platform === "linux") {
+        return existsSync("/usr/share/code") || existsSync("/usr/bin/code");
+    }
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA || "";
+        const programFiles = process.env.PROGRAMFILES || "C:\\Program Files";
+        return (existsSync(`${localAppData}\\Programs\\Microsoft VS Code\\Code.exe`) || existsSync(`${programFiles}\\Microsoft VS Code\\Code.exe`));
+    }
+    return false;
+}
+/**
+ * Detects which agent/IDE is running the CLI from environment variables.
+ * Returns the add-mcp compatible agent ID (e.g. "cursor", "claude-code").
+ *
+ * Delegates IDE detection to detectIde() to avoid duplicating Cursor/VS Code
+ * heuristics, then checks for agent-specific env vars.
+ */
+export function detectAgent() {
+    const env = process.env;
+    // Agent-specific env vars (checked first — these are unambiguous)
+    if (env.CLAUDECODE === "1" ||
+        env.CLAUDE_CODE === "1" ||
+        env.CLAUDE_CLI === "1") {
+        return "claude-code";
+    }
+    if (env.CODEX === "1")
+        return "codex";
+    if (env.CLINE === "1")
+        return "cline";
+    // Fall back to IDE detection (Cursor, VS Code, Windsurf)
+    const ide = detectIde();
+    if (ide) {
+        const IDE_TO_AGENT = {
+            Cursor: "cursor",
+            "VS Code": "vscode",
+            Windsurf: "windsurf",
+        };
+        return IDE_TO_AGENT[ide] ?? null;
+    }
+    return null;
+}

package/dist/init/editors.js

@@ -0,0 +1,62 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { execa } from "execa";
+/**
+ * Gets VS Code's global config directory based on the platform
+ */
+export function getVSCodeGlobalConfigDir(homeDir) {
+    const platform = process.platform;
+    if (platform === "darwin") {
+        // macOS: ~/Library/Application Support/Code/User
+        return resolve(homeDir, "Library", "Application Support", "Code", "User");
+    }
+    if (platform === "linux") {
+        // Linux: ~/.config/Code/User
+        return resolve(homeDir, ".config", "Code", "User");
+    }
+    if (platform === "win32") {
+        // Windows: %APPDATA%\Code\User
+        const appData = process.env.APPDATA;
+        if (appData) {
+            return resolve(appData, "Code", "User");
+        }
+    }
+    return null;
+}
+/**
+ * Checks if Claude CLI is installed
+ */
+async function isClaudeCLIInstalled() {
+    try {
+        await execa("claude", ["--version"], {
+            stdio: "ignore",
+            timeout: 5000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detects which editors are installed on the system
+ */
+export async function detectAvailableEditors(homeDir) {
+    const editors = [];
+    // Check for Cursor (global config directory)
+    const cursorDir = resolve(homeDir, ".cursor");
+    if (existsSync(cursorDir)) {
+        editors.push("Cursor");
+    }
+    // Check if VS Code's global config directory exists
+    const vscodeGlobalDir = getVSCodeGlobalConfigDir(homeDir);
+    if (vscodeGlobalDir && existsSync(vscodeGlobalDir)) {
+        editors.push("VS Code");
+    }
+    // Check for Claude CLI by running the command
+    const claudeInstalled = await isClaudeCLIInstalled();
+    if (claudeInstalled) {
+        editors.push("Claude CLI");
+    }
+    return editors;
+}

package/dist/init/enrich_output.js

@@ -0,0 +1,71 @@
+/**
+ * Converts a phase's `args` (e.g. ["neon-auth", "--json", "--setup"]) into the
+ * `neon init --agent --data` invocation that reaches the same handler.
+ */
+function argsToCommand(args) {
+    const data = {};
+    let i = 0;
+    // First non-flag arg is the subcommand → step
+    if (args.length > 0 && !args[0].startsWith("-")) {
+        data.step = args[0];
+        i = 1;
+    }
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg
+                .slice(2)
+                .replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            if (key === "json") {
+                i += 1;
+                continue;
+            }
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
+                data[key] = next;
+                i += 2;
+            }
+            else {
+                data[key] = true;
+                i += 1;
+            }
+        }
+        else {
+            i += 1;
+        }
+    }
+    return `neon init --agent --data '${JSON.stringify(data)}'`;
+}
+/**
+ * Walks a phase response object and:
+ * 1. Replaces `args` arrays with `command` strings (neon init --data format)
+ * 2. Renames `run_neon_init` → `run_shell_command`
+ * 3. Adds a description to finalize steps
+ */
+export function enrichResponse(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(enrichResponse);
+    const record = obj;
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        result[key] = enrichResponse(value);
+    }
+    // Replace args with command in run_neon_init actions and responseMapping entries
+    if (Array.isArray(result.args)) {
+        result.command = argsToCommand(result.args);
+        delete result.args;
+    }
+    // Rename run_neon_init → run_shell_command so agents don't infer subcommand patterns
+    if (result.type === "run_neon_init") {
+        result.type = "run_shell_command";
+        // Help agents understand finalize is the terminal step
+        if (typeof result.command === "string" &&
+            result.command.includes('"step":"finalize"')) {
+            result.description =
+                "Run this command to complete the setup. This is the final step — do not run any other neon init commands after this.";
+        }
+    }
+    return result;
+}

package/dist/init/extension.js

@@ -0,0 +1,191 @@
+import { existsSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { execa } from "execa";
+import { downloadVsix, NEON_EXTENSION_ID } from "./vsix.js";
+/**
+ * Uses macOS mdfind to locate an app by bundle identifier
+ */
+async function findAppWithMdfind(bundleId) {
+    try {
+        const result = await execa("mdfind", [`kMDItemCFBundleIdentifier == '${bundleId}'`], { timeout: 5000 });
+        const paths = result.stdout.trim().split("\n").filter(Boolean);
+        return paths[0] || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Known installation paths for VS Code CLI
+ */
+function getVSCodePaths() {
+    const platform = process.platform;
+    const home = process.env.HOME || "";
+    if (platform === "darwin") {
+        return [
+            "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+            "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders",
+            `${home}/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code`,
+            `${home}/Downloads/Visual Studio Code.app/Contents/Resources/app/bin/code`,
+        ];
+    }
+    if (platform === "linux") {
+        return [
+            "/usr/share/code/bin/code",
+            "/usr/bin/code",
+            "/snap/bin/code",
+            "/usr/share/code-insiders/bin/code-insiders",
+        ];
+    }
+    if (platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA || "";
+        const programFiles = process.env.PROGRAMFILES || "C:\\Program Files";
+        return [
+            `${localAppData}\\Programs\\Microsoft VS Code\\bin\\code.cmd`,
+            `${programFiles}\\Microsoft VS Code\\bin\\code.cmd`,
+            `${localAppData}\\Programs\\Microsoft VS Code Insiders\\bin\\code-insiders.cmd`,
+        ];
+    }
+    return [];
+}
+/**
+ * Known installation paths for Cursor CLI
+ */
+function getCursorPaths() {
+    const platform = process.platform;
+    const home = process.env.HOME || "";
+    if (platform === "darwin") {
+        return [
+            "/Applications/Cursor.app/Contents/Resources/app/bin/cursor",
+            `${home}/Applications/Cursor.app/Contents/Resources/app/bin/cursor`,
+            `${home}/Downloads/Cursor.app/Contents/Resources/app/bin/cursor`,
+        ];
+    }
+    if (platform === "linux") {
+        return [
+            "/usr/share/cursor/bin/cursor",
+            "/usr/bin/cursor",
+            `${home}/.local/bin/cursor`,
+            "/opt/cursor/bin/cursor",
+        ];
+    }
+    if (platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA || "";
+        const programFiles = process.env.PROGRAMFILES || "C:\\Program Files";
+        return [
+            `${localAppData}\\Programs\\Cursor\\resources\\app\\bin\\cursor.cmd`,
+            `${localAppData}\\cursor\\Cursor.exe`,
+            `${programFiles}\\Cursor\\resources\\app\\bin\\cursor.cmd`,
+        ];
+    }
+    return [];
+}
+/**
+ * Finds the CLI command for an editor by checking known installation paths
+ * On macOS, also uses mdfind to locate the app if standard paths fail
+ * Falls back to the simple command name if no full path is found (in case it's in PATH)
+ */
+export async function findEditorCommand(editor) {
+    let paths;
+    let fallbackCommand;
+    let bundleId = null;
+    if (editor === "VS Code") {
+        paths = getVSCodePaths();
+        fallbackCommand = "code";
+        bundleId = "com.microsoft.VSCode";
+    }
+    else if (editor === "Cursor") {
+        paths = getCursorPaths();
+        fallbackCommand = "cursor";
+        bundleId = "com.todesktop.230313mzl4w4u92";
+    }
+    else {
+        return null;
+    }
+    for (const path of paths) {
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    // On macOS, try mdfind to locate the app dynamically
+    if (process.platform === "darwin" && bundleId) {
+        const appPath = await findAppWithMdfind(bundleId);
+        if (appPath) {
+            const cliPath = `${appPath}/Contents/Resources/app/bin/${fallbackCommand}`;
+            if (existsSync(cliPath)) {
+                return cliPath;
+            }
+        }
+    }
+    return fallbackCommand;
+}
+/**
+ * Checks if the extension is installed by querying the editor's extension list
+ */
+export async function isExtensionInstalled(editor) {
+    const command = await findEditorCommand(editor);
+    if (!command) {
+        return false;
+    }
+    try {
+        const result = await execa(command, ["--list-extensions"], {
+            timeout: 5000,
+        });
+        return result.stdout.includes(NEON_EXTENSION_ID);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Installs the Neon Local Connect extension for VS Code or Cursor.
+ *
+ * Strategy:
+ * 1. Try `--install-extension <id>` directly (uses the editor's configured marketplace)
+ * 2. If that fails, download .vsix (from proxy or Open VSX) and install locally
+ * 3. Set NEON_VSX_GALLERY_URL to use a corporate proxy for the download
+ */
+export async function installExtension(editor) {
+    const command = await findEditorCommand(editor);
+    if (!command) {
+        return false;
+    }
+    // Try direct marketplace install first
+    try {
+        await execa(command, ["--install-extension", NEON_EXTENSION_ID], {
+            stdio: "pipe",
+            timeout: 60000,
+        });
+        return true;
+    }
+    catch {
+        // Fall through to VSIX download
+    }
+    // Download .vsix and install locally
+    const vsixPath = await downloadVsix();
+    if (!vsixPath) {
+        return false;
+    }
+    try {
+        await execa(command, ["--install-extension", vsixPath], {
+            stdio: "pipe",
+            timeout: 60000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            await unlink(vsixPath);
+        }
+        catch { }
+    }
+}
+/**
+ * Returns the editor types that should use extension installation (vs MCP)
+ */
+export function usesExtension(editor) {
+    return editor === "VS Code" || editor === "Cursor";
+}