neon 2.45.0 → 2.46.0

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";
+}

package/dist/init/inspect.js

@@ -0,0 +1,287 @@
+/**
+ * Filesystem-based project inspection for interactive (agentless) mode.
+ * Replaces the "agent_check" pattern — instead of asking an agent to look,
+ * we examine the filesystem directly.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+/**
+ * Runs filesystem checks based on the agent_check descriptors.
+ * Maps check IDs to concrete inspection functions.
+ */
+export async function inspectProject(checks) {
+    const results = {};
+    const cwd = process.cwd();
+    for (const check of checks) {
+        switch (check.id) {
+            case "mcp_server": {
+                const mcpScope = checkMcpServer(cwd);
+                results.mcpConfigured = mcpScope !== false;
+                results.mcpScope = mcpScope;
+                break;
+            }
+            case "connection_string":
+                results.connectionString = checkConnectionString(cwd);
+                break;
+            case "database_url":
+                results.databaseUrl = checkDatabaseUrl(cwd);
+                break;
+            case "project_stack": {
+                const stack = detectProjectStack(cwd);
+                results.framework = stack.framework;
+                results.orm = stack.orm;
+                break;
+            }
+            case "migrations": {
+                const migrations = detectMigrations(cwd);
+                results.migrationTool = migrations.tool;
+                results.migrationDir = migrations.dir;
+                break;
+            }
+            case "skills": {
+                const skillsScope = checkSkillsInstalled(cwd);
+                results.skillsInstalled = skillsScope !== false;
+                results.skillsScope = skillsScope;
+                break;
+            }
+            case "ide_type":
+                results.isVscodeIde = checkVscodeIde();
+                break;
+            case "has_app":
+                results.hasApp = checkHasApp(cwd);
+                break;
+            case "agent_type":
+                // Handled by the interactive runner (prompt or env detection)
+                break;
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Individual check implementations
+// ---------------------------------------------------------------------------
+function checkMcpServer(cwd) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    // Check project-level configs first
+    const projectConfigs = [
+        resolve(cwd, ".cursor", "mcp.json"),
+        resolve(cwd, ".vscode", "settings.json"),
+    ];
+    for (const configPath of projectConfigs) {
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, "utf-8");
+                if (content.includes("neon") ||
+                    content.includes("mcp.neon.tech")) {
+                    return "project";
+                }
+            }
+            catch { }
+        }
+    }
+    // Check global configs
+    const globalConfigs = [
+        resolve(home, ".cursor", "mcp.json"),
+        // Claude Code config (add-mcp writes to settings.local.json)
+        resolve(home, ".claude", "settings.local.json"),
+        resolve(home, ".claude", "settings.json"),
+    ];
+    for (const configPath of globalConfigs) {
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, "utf-8");
+                if (content.includes("neon") ||
+                    content.includes("mcp.neon.tech")) {
+                    return "global";
+                }
+            }
+            catch { }
+        }
+    }
+    return false;
+}
+function checkConnectionString(cwd) {
+    for (const envFile of [".env", ".env.local"]) {
+        const envPath = resolve(cwd, envFile);
+        if (existsSync(envPath)) {
+            try {
+                const content = readFileSync(envPath, "utf-8");
+                if (/^DATABASE_URL=.*neon/m.test(content) ||
+                    /^PGHOST=.*neon/m.test(content)) {
+                    return true;
+                }
+            }
+            catch { }
+        }
+    }
+    return false;
+}
+function detectProjectStack(cwd) {
+    const result = { framework: "none", orm: "none" };
+    const pkgPath = resolve(cwd, "package.json");
+    if (!existsSync(pkgPath))
+        return result;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        // Framework detection
+        if (allDeps.next)
+            result.framework = "next";
+        else if (allDeps.remix || allDeps["@remix-run/node"])
+            result.framework = "remix";
+        else if (allDeps.express)
+            result.framework = "express";
+        else if (allDeps.hono)
+            result.framework = "hono";
+        else if (allDeps.fastify)
+            result.framework = "fastify";
+        else if (allDeps["@sveltejs/kit"])
+            result.framework = "sveltekit";
+        else if (allDeps.nuxt)
+            result.framework = "nuxt";
+        else if (allDeps.astro)
+            result.framework = "astro";
+        // ORM detection
+        if (allDeps.prisma || allDeps["@prisma/client"])
+            result.orm = "prisma";
+        else if (allDeps["drizzle-orm"])
+            result.orm = "drizzle";
+        else if (allDeps.knex)
+            result.orm = "knex";
+        else if (allDeps.typeorm)
+            result.orm = "typeorm";
+        else if (allDeps.sequelize)
+            result.orm = "sequelize";
+        else if (allDeps["@neondatabase/serverless"])
+            result.orm = "neon-serverless";
+    }
+    catch { }
+    return result;
+}
+function detectMigrations(cwd) {
+    // Prisma
+    if (existsSync(resolve(cwd, "prisma", "schema.prisma"))) {
+        const migrationsDir = resolve(cwd, "prisma", "migrations");
+        return {
+            tool: "prisma",
+            dir: existsSync(migrationsDir) ? "prisma/migrations" : "none",
+        };
+    }
+    // Drizzle
+    if (existsSync(resolve(cwd, "drizzle.config.ts")) ||
+        existsSync(resolve(cwd, "drizzle.config.js"))) {
+        const drizzleDir = resolve(cwd, "drizzle");
+        return {
+            tool: "drizzle",
+            dir: existsSync(drizzleDir) ? "drizzle" : "none",
+        };
+    }
+    // Knex
+    if (existsSync(resolve(cwd, "knexfile.js")) ||
+        existsSync(resolve(cwd, "knexfile.ts"))) {
+        const migrationsDir = resolve(cwd, "migrations");
+        return {
+            tool: "knex",
+            dir: existsSync(migrationsDir) ? "migrations" : "none",
+        };
+    }
+    return { tool: "none", dir: "none" };
+}
+function checkDatabaseUrl(cwd) {
+    const envPath = resolve(cwd, ".env");
+    if (existsSync(envPath)) {
+        try {
+            const content = readFileSync(envPath, "utf-8");
+            if (/^DATABASE_URL=/m.test(content))
+                return true;
+        }
+        catch { }
+    }
+    return false;
+}
+function checkSkillsInstalled(cwd) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const skillNames = ["neon", "neon-postgres"];
+    // Check project-level skill directories — ALL base skills must exist
+    const projectDirs = [
+        resolve(cwd, ".cursor", "skills"),
+        resolve(cwd, ".claude", "skills"),
+        resolve(cwd, ".agents", "skills"),
+    ];
+    const allProjectSkills = skillNames.every((skill) => projectDirs.some((dir) => existsSync(resolve(dir, skill, "SKILL.md"))));
+    if (allProjectSkills)
+        return "project";
+    // Check CLAUDE.md for neon skill references (injected by skills CLI)
+    // Only counts as installed if both skill names are referenced
+    const claudeMd = resolve(cwd, "CLAUDE.md");
+    if (existsSync(claudeMd)) {
+        try {
+            const content = readFileSync(claudeMd, "utf-8");
+            if (content.includes("neon-postgres") &&
+                content.includes("neon/SKILL.md"))
+                return "project";
+        }
+        catch { }
+    }
+    // Check global skill directories — ALL base skills must exist
+    const globalDirs = [
+        resolve(home, ".cursor", "skills"),
+        resolve(home, ".claude", "skills"),
+        resolve(home, ".agents", "skills"),
+    ];
+    const allGlobalSkills = skillNames.every((skill) => globalDirs.some((dir) => existsSync(resolve(dir, skill, "SKILL.md"))));
+    if (allGlobalSkills)
+        return "global";
+    // Check for partial installations — ANY skill exists
+    const anyProjectSkill = skillNames.some((skill) => projectDirs.some((dir) => existsSync(resolve(dir, skill, "SKILL.md"))));
+    if (anyProjectSkill)
+        return "project-partial";
+    const anyGlobalSkill = skillNames.some((skill) => globalDirs.some((dir) => existsSync(resolve(dir, skill, "SKILL.md"))));
+    if (anyGlobalSkill)
+        return "global-partial";
+    return false;
+}
+function checkVscodeIde() {
+    const env = process.env;
+    return !!(env.TERM_PROGRAM === "vscode" ||
+        env.TERM_PROGRAM === "cursor" ||
+        env.TERM_PROGRAM === "windsurf" ||
+        env.VSCODE_PID ||
+        env.VSCODE_CWD);
+}
+/**
+ * Detects whether the current directory contains an application.
+ * Returns true if package.json has dependencies or common source directories exist.
+ */
+function checkHasApp(cwd) {
+    const pkgPath = resolve(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const deps = Object.keys(pkg.dependencies ?? {});
+            const devDeps = Object.keys(pkg.devDependencies ?? {});
+            if (deps.length > 0 || devDeps.length > 0)
+                return true;
+        }
+        catch { }
+    }
+    // Check for common source directories / entry files
+    const indicators = [
+        "src",
+        "app",
+        "pages",
+        "lib",
+        "index.ts",
+        "index.js",
+        "main.ts",
+        "main.js",
+    ];
+    for (const indicator of indicators) {
+        if (existsSync(resolve(cwd, indicator)))
+            return true;
+    }
+    return false;
+}