@kite-copilot/cli 1.0.0 → 1.0.1

package/dist/index.js

@@ -52,6 +52,7 @@ const readline = __importStar(require("node:readline"));
 const config_js_1 = require("./config.js");
 const login_js_1 = require("./login.js");
 const analyzer_js_1 = require("./analyzer.js");
+const remote_analyzer_js_1 = require("./remote-analyzer.js");
 const program = new commander_1.Command();
 /**
  * Prompt user for yes/no confirmation
@@ -69,6 +70,111 @@ async function promptYesNo(question) {
         });
     });
 }
+/**
+ * Handle analysis result - display, prompt, and save/upload
+ * Shared between local and remote analysis
+ */
+async function handleAnalysisResult(result, options, quiet, verbose, spinner, skipPrompt) {
+    if (verbose) {
+        console.log(chalk_1.default.gray(`[DEBUG] Found ${result.routes.length} routes`));
+        console.log(chalk_1.default.gray(`[DEBUG] Found ${result.api_calls.length} API calls`));
+        console.log(chalk_1.default.gray(`[DEBUG] Generated ${result.mappings.length} mappings`));
+    }
+    // Display results
+    if (!quiet) {
+        console.log();
+        console.log(chalk_1.default.bold("Analysis Results"));
+        console.log(chalk_1.default.gray("-".repeat(40)));
+        // Routes
+        console.log(chalk_1.default.cyan(`\nRoutes (${result.routes.length}):`));
+        for (const route of result.routes) {
+            console.log(`  - ${route.route_name} -> ${route.component_name}`);
+            console.log(chalk_1.default.gray(`    ${route.file_path}`));
+        }
+        // API Calls
+        console.log(chalk_1.default.cyan(`\nAPI Calls (${result.api_calls.length}):`));
+        for (const call of result.api_calls) {
+            console.log(`  - ${call.method} ${call.endpoint}`);
+            console.log(chalk_1.default.gray(`    ${call.component_file}`));
+        }
+        // Mappings
+        console.log(chalk_1.default.cyan(`\nMappings (${result.mappings.length}):`));
+        for (const mapping of result.mappings) {
+            console.log(`  - ${mapping.tool_name} -> ${mapping.api_endpoint}`);
+            if (mapping.navigation_page) {
+                console.log(chalk_1.default.gray(`    Page: ${mapping.navigation_page}`));
+            }
+        }
+        console.log();
+    }
+    // Summary
+    if (!quiet) {
+        console.log();
+        console.log(chalk_1.default.bold("Summary"));
+        console.log(chalk_1.default.gray("-".repeat(40)));
+        console.log(`  Routes:    ${result.routes.length}`);
+        console.log(`  API Calls: ${result.api_calls.length}`);
+        console.log(`  Mappings:  ${result.mappings.length}`);
+        console.log();
+    }
+    // Handle save decision
+    if (skipPrompt) {
+        // --no-prompt: save locally
+        const outputPath = options.output || "kite-mappings.json";
+        (0, analyzer_js_1.saveResultToFile)(result, outputPath);
+        if (!quiet) {
+            console.log(chalk_1.default.green(`Saved mappings to: ${outputPath}`));
+        }
+    }
+    else {
+        // Prompt user for confirmation
+        console.log();
+        const shouldUpload = await promptYesNo(chalk_1.default.cyan("Save mappings to Kite? (y/n): "));
+        if (shouldUpload) {
+            // Check if logged in
+            if (!(0, config_js_1.isLoggedIn)()) {
+                console.log(chalk_1.default.yellow("\nNot logged in. Run 'kite login' first to upload mappings."));
+                // Save to rejected as fallback
+                const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
+                console.log(chalk_1.default.gray(`  Saved locally to: ${rejectedPath}\n`));
+                process.exit(1);
+            }
+            const config = (0, config_js_1.loadConfig)();
+            if (!quiet) {
+                spinner.start("Uploading mappings to Kite...");
+            }
+            try {
+                const uploadResult = await (0, analyzer_js_1.uploadMappings)(result, {
+                    backendUrl: config.backend_url,
+                    token: config.token,
+                    orgId: config.org_id,
+                    apiConfigId: config.api_config_id,
+                });
+                if (!quiet) {
+                    spinner.succeed(`Uploaded ${uploadResult.mappings_uploaded} mappings ` +
+                        `(merged: ${uploadResult.mappings_merged}, skipped: ${uploadResult.mappings_skipped})`);
+                }
+            }
+            catch (uploadError) {
+                if (!quiet)
+                    spinner.fail("Upload failed");
+                console.log(chalk_1.default.red(`\n${uploadError.message}`));
+                // Save to rejected on upload failure
+                const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
+                console.log(chalk_1.default.gray(`  Saved locally to: ${rejectedPath}\n`));
+                process.exit(1);
+            }
+        }
+        else {
+            // User declined - save to rejected folder
+            const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
+            if (!quiet) {
+                console.log(chalk_1.default.yellow(`\nMappings saved locally to: ${rejectedPath}`));
+            }
+        }
+    }
+    console.log();
+}
 program
     .name("kite")
     .description("Kite CLI - Analyze frontend codebases and map API calls")
@@ -98,12 +204,85 @@ program
     .option("-v, --verbose", "Show verbose debug output")
     .option("--timeout <seconds>", "Analysis timeout in seconds", "300")
     .option("--no-prompt", "Skip confirmation prompt and save locally")
+    .option("--local", "Use local Claude CLI instead of remote server")
+    .option("--remote", "Force use of remote analysis server")
+    .option("--api-endpoint <url>", "Remote analysis API endpoint (or set KITE_API_ENDPOINT)")
+    .option("--ssh-key <path>", "SSH private key for remote server authentication")
     .action(async (codebasePath, options) => {
     const quiet = options.quiet || false;
     const verbose = options.verbose || false;
     const skipPrompt = options.prompt === false;
-    // Check Claude CLI is available
+    const forceLocal = options.local || false;
+    const forceRemote = options.remote || false;
+    const apiEndpoint = options.apiEndpoint || process.env.KITE_API_ENDPOINT;
     const spinner = (0, ora_1.default)();
+    // Determine whether to use remote or local analysis
+    const remoteAvailable = (0, remote_analyzer_js_1.isRemoteAnalysisAvailable)() || !!apiEndpoint;
+    let useRemote = remoteAvailable && !forceLocal;
+    if (forceRemote && !remoteAvailable && !apiEndpoint) {
+        console.log(chalk_1.default.red("\n✗ Remote analysis requested but not configured.\n"));
+        console.log(chalk_1.default.gray("  Set KITE_API_ENDPOINT or deploy the infrastructure first.\n"));
+        process.exit(1);
+    }
+    if (forceRemote) {
+        useRemote = true;
+    }
+    if (useRemote) {
+        // Remote analysis mode
+        if (!quiet) {
+            spinner.start("Preparing remote analysis...");
+        }
+        if (verbose) {
+            console.log(chalk_1.default.gray(`[DEBUG] Using remote analysis`));
+            console.log(chalk_1.default.gray(`[DEBUG] API endpoint: ${apiEndpoint || "(from env)"}`));
+            console.log(chalk_1.default.gray(`[DEBUG] Path: ${codebasePath}`));
+            console.log(chalk_1.default.gray(`[DEBUG] Timeout: ${options.timeout}s`));
+        }
+        try {
+            const result = await (0, remote_analyzer_js_1.analyzeWithRemoteClaude)(codebasePath, {
+                timeout: parseInt(options.timeout, 10),
+                verbose,
+                apiEndpoint,
+                sshKeyPath: options.sshKey,
+            }, (message) => {
+                if (!quiet) {
+                    spinner.text = message;
+                }
+            });
+            if (!quiet) {
+                spinner.succeed("Remote analysis complete");
+            }
+            // Continue with result handling (shared with local)
+            await handleAnalysisResult(result, options, quiet, verbose, spinner, skipPrompt);
+            return;
+        }
+        catch (error) {
+            if (!quiet)
+                spinner.fail("Remote analysis failed");
+            if (error instanceof remote_analyzer_js_1.EC2StartError) {
+                console.log(chalk_1.default.red(`\n✗ Failed to start remote server: ${error.message}\n`));
+            }
+            else if (error instanceof remote_analyzer_js_1.SSHTunnelError) {
+                console.log(chalk_1.default.red(`\n✗ SSH connection failed: ${error.message}\n`));
+            }
+            else if (error instanceof remote_analyzer_js_1.RemoteAnalyzerError) {
+                console.log(chalk_1.default.red(`\n✗ ${error.message}\n`));
+            }
+            else {
+                console.log(chalk_1.default.red(`\n✗ ${error.message}\n`));
+            }
+            // Offer to fall back to local if not forced remote
+            if (!forceRemote) {
+                console.log(chalk_1.default.yellow("Falling back to local analysis...\n"));
+                useRemote = false;
+                // Continue to local analysis below
+            }
+            else {
+                process.exit(1);
+            }
+        }
+    }
+    // Local analysis mode (or fallback)
     if (!quiet) {
         spinner.start("Checking Claude CLI...");
     }
@@ -111,8 +290,9 @@ program
     if (!claudeAvailable) {
         if (!quiet)
             spinner.fail("Claude CLI not found");
-        console.log(chalk_1.default.red("\n✗ Claude CLI is required for analysis.\n"));
+        console.log(chalk_1.default.red("\n✗ Claude CLI is required for local analysis.\n"));
         console.log(chalk_1.default.gray("  Install it with: npm install -g @anthropic-ai/claude-cli\n"));
+        console.log(chalk_1.default.gray("  Or configure remote analysis with KITE_API_ENDPOINT\n"));
         process.exit(1);
     }
     if (!quiet)
@@ -122,6 +302,7 @@ program
         spinner.start(`Analyzing codebase: ${codebasePath}`);
     }
     if (verbose) {
+        console.log(chalk_1.default.gray(`[DEBUG] Using local analysis`));
         console.log(chalk_1.default.gray(`[DEBUG] Path: ${codebasePath}`));
         console.log(chalk_1.default.gray(`[DEBUG] Timeout: ${options.timeout}s`));
     }
@@ -133,105 +314,7 @@ program
         if (!quiet) {
             spinner.succeed("Analysis complete");
         }
-        if (verbose) {
-            console.log(chalk_1.default.gray(`[DEBUG] Found ${result.routes.length} routes`));
-            console.log(chalk_1.default.gray(`[DEBUG] Found ${result.api_calls.length} API calls`));
-            console.log(chalk_1.default.gray(`[DEBUG] Generated ${result.mappings.length} mappings`));
-        }
-        // Display results
-        if (!quiet) {
-            console.log();
-            console.log(chalk_1.default.bold("📊 Analysis Results"));
-            console.log(chalk_1.default.gray("─".repeat(40)));
-            // Routes
-            console.log(chalk_1.default.cyan(`\nRoutes (${result.routes.length}):`));
-            for (const route of result.routes) {
-                console.log(`  • ${route.route_name} → ${route.component_name}`);
-                console.log(chalk_1.default.gray(`    ${route.file_path}`));
-            }
-            // API Calls
-            console.log(chalk_1.default.cyan(`\nAPI Calls (${result.api_calls.length}):`));
-            for (const call of result.api_calls) {
-                console.log(`  • ${call.method} ${call.endpoint}`);
-                console.log(chalk_1.default.gray(`    ${call.component_file}`));
-            }
-            // Mappings
-            console.log(chalk_1.default.cyan(`\nMappings (${result.mappings.length}):`));
-            for (const mapping of result.mappings) {
-                console.log(`  • ${mapping.tool_name} → ${mapping.api_endpoint}`);
-                if (mapping.navigation_page) {
-                    console.log(chalk_1.default.gray(`    Page: ${mapping.navigation_page}`));
-                }
-            }
-            console.log();
-        }
-        // Summary
-        if (!quiet) {
-            console.log();
-            console.log(chalk_1.default.bold("Summary"));
-            console.log(chalk_1.default.gray("─".repeat(40)));
-            console.log(`  Routes:    ${result.routes.length}`);
-            console.log(`  API Calls: ${result.api_calls.length}`);
-            console.log(`  Mappings:  ${result.mappings.length}`);
-            console.log();
-        }
-        // Handle save decision
-        if (skipPrompt) {
-            // --no-prompt: save locally
-            const outputPath = options.output || "kite-mappings.json";
-            (0, analyzer_js_1.saveResultToFile)(result, outputPath);
-            if (!quiet) {
-                console.log(chalk_1.default.green(`✓ Saved mappings to: ${outputPath}`));
-            }
-        }
-        else {
-            // Prompt user for confirmation
-            console.log();
-            const shouldUpload = await promptYesNo(chalk_1.default.cyan("Save mappings to Kite? (y/n): "));
-            if (shouldUpload) {
-                // Check if logged in
-                if (!(0, config_js_1.isLoggedIn)()) {
-                    console.log(chalk_1.default.yellow("\n⚠ Not logged in. Run 'kite login' first to upload mappings."));
-                    // Save to rejected as fallback
-                    const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
-                    console.log(chalk_1.default.gray(`  Saved locally to: ${rejectedPath}\n`));
-                    process.exit(1);
-                }
-                const config = (0, config_js_1.loadConfig)();
-                if (!quiet) {
-                    spinner.start("Uploading mappings to Kite...");
-                }
-                try {
-                    const uploadResult = await (0, analyzer_js_1.uploadMappings)(result, {
-                        backendUrl: config.backend_url,
-                        token: config.token,
-                        orgId: config.org_id,
-                        apiConfigId: config.api_config_id,
-                    });
-                    if (!quiet) {
-                        spinner.succeed(`Uploaded ${uploadResult.mappings_uploaded} mappings ` +
-                            `(merged: ${uploadResult.mappings_merged}, skipped: ${uploadResult.mappings_skipped})`);
-                    }
-                }
-                catch (uploadError) {
-                    if (!quiet)
-                        spinner.fail("Upload failed");
-                    console.log(chalk_1.default.red(`\n✗ ${uploadError.message}`));
-                    // Save to rejected on upload failure
-                    const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
-                    console.log(chalk_1.default.gray(`  Saved locally to: ${rejectedPath}\n`));
-                    process.exit(1);
-                }
-            }
-            else {
-                // User declined - save to rejected folder
-                const rejectedPath = (0, config_js_1.saveRejectedMapping)(result);
-                if (!quiet) {
-                    console.log(chalk_1.default.yellow(`\n✓ Mappings saved locally to: ${rejectedPath}`));
-                }
-            }
-        }
-        console.log();
+        await handleAnalysisResult(result, options, quiet, verbose, spinner, skipPrompt);
     }
     catch (error) {
         if (!quiet)

package/dist/remote-analyzer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Remote Claude Code Analyzer
+ *
+ * Runs Claude Code analysis on a remote EC2 instance via SSH tunnel.
+ * The codebase stays on the user's machine - only accessed via SSHFS.
+ */
+import type { FrontendAnalysisResult, AnalyzeOptions } from "./types.js";
+export declare class RemoteAnalyzerError extends Error {
+    constructor(message: string);
+}
+export declare class EC2StartError extends RemoteAnalyzerError {
+    constructor(message: string);
+}
+export declare class SSHTunnelError extends RemoteAnalyzerError {
+    constructor(message: string);
+}
+/**
+ * Main entry point: Analyze codebase using remote Claude Code
+ */
+export declare function analyzeWithRemoteClaude(codebasePath: string, options?: AnalyzeOptions & {
+    apiEndpoint?: string;
+}, onProgress?: (message: string) => void): Promise<FrontendAnalysisResult>;
+/**
+ * Check if remote analysis is available (API endpoint configured)
+ */
+export declare function isRemoteAnalysisAvailable(): boolean;
+/**
+ * Get the configured API endpoint
+ */
+export declare function getApiEndpoint(): string;

package/dist/remote-analyzer.js

@@ -0,0 +1,431 @@
+"use strict";
+/**
+ * Remote Claude Code Analyzer
+ *
+ * Runs Claude Code analysis on a remote EC2 instance via SSH tunnel.
+ * The codebase stays on the user's machine - only accessed via SSHFS.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSHTunnelError = exports.EC2StartError = exports.RemoteAnalyzerError = void 0;
+exports.analyzeWithRemoteClaude = analyzeWithRemoteClaude;
+exports.isRemoteAnalysisAvailable = isRemoteAnalysisAvailable;
+exports.getApiEndpoint = getApiEndpoint;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const net = __importStar(require("node:net"));
+const analyzer_js_1 = require("./analyzer.js");
+// Default API Gateway endpoint (should be configured via env or config)
+const DEFAULT_API_ENDPOINT = process.env.KITE_API_ENDPOINT || "";
+class RemoteAnalyzerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RemoteAnalyzerError";
+    }
+}
+exports.RemoteAnalyzerError = RemoteAnalyzerError;
+class EC2StartError extends RemoteAnalyzerError {
+    constructor(message) {
+        super(message);
+        this.name = "EC2StartError";
+    }
+}
+exports.EC2StartError = EC2StartError;
+class SSHTunnelError extends RemoteAnalyzerError {
+    constructor(message) {
+        super(message);
+        this.name = "SSHTunnelError";
+    }
+}
+exports.SSHTunnelError = SSHTunnelError;
+/**
+ * Find an available local port for SSH tunnel
+ */
+async function findAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (address && typeof address === "object") {
+                const port = address.port;
+                server.close(() => resolve(port));
+            }
+            else {
+                reject(new Error("Could not get port"));
+            }
+        });
+        server.on("error", reject);
+    });
+}
+/**
+ * Generate a temporary SSH keypair for this session
+ */
+async function generateTempSSHKey() {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "kite-ssh-"));
+    const privateKeyPath = path.join(tempDir, "id_ed25519");
+    return new Promise((resolve, reject) => {
+        const proc = (0, node_child_process_1.spawn)("ssh-keygen", [
+            "-t", "ed25519",
+            "-f", privateKeyPath,
+            "-N", "", // No passphrase
+            "-q", // Quiet
+        ]);
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                reject(new SSHTunnelError(`Failed to generate SSH key: exit code ${code}`));
+                return;
+            }
+            const publicKey = fs.readFileSync(`${privateKeyPath}.pub`, "utf-8").trim();
+            resolve({ privateKeyPath, publicKey });
+        });
+        proc.on("error", (err) => {
+            reject(new SSHTunnelError(`Failed to generate SSH key: ${err.message}`));
+        });
+    });
+}
+/**
+ * Start the EC2 instance via API Gateway
+ */
+async function startEC2Instance(apiEndpoint) {
+    const response = await fetch(`${apiEndpoint}/instance`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "start" }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new EC2StartError(`Failed to start EC2: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    if (!data.public_ip) {
+        throw new EC2StartError("EC2 started but no public IP available");
+    }
+    return data;
+}
+/**
+ * Get EC2 instance status
+ */
+async function getEC2Status(apiEndpoint) {
+    const response = await fetch(`${apiEndpoint}/instance?action=status`);
+    if (!response.ok) {
+        const text = await response.text();
+        throw new EC2StartError(`Failed to get EC2 status: ${response.status} ${text}`);
+    }
+    return response.json();
+}
+/**
+ * Wait for SSH to be available on the remote host
+ */
+async function waitForSSH(host, port, timeoutMs = 60000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        try {
+            await new Promise((resolve, reject) => {
+                const socket = net.createConnection({ host, port, timeout: 5000 });
+                socket.on("connect", () => {
+                    socket.destroy();
+                    resolve();
+                });
+                socket.on("error", reject);
+                socket.on("timeout", () => {
+                    socket.destroy();
+                    reject(new Error("Timeout"));
+                });
+            });
+            return; // SSH is available
+        }
+        catch {
+            // Wait and retry
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+    }
+    throw new SSHTunnelError(`SSH not available after ${timeoutMs / 1000} seconds`);
+}
+/**
+ * Establish reverse SSH tunnel for SSHFS
+ *
+ * This creates a tunnel where:
+ * - Local: User's machine listens on a port
+ * - Remote: EC2 can connect back through the tunnel
+ */
+async function establishReverseTunnel(connectionInfo, localPath, sshKeyPath, onProgress) {
+    const localPort = await findAvailablePort();
+    const remotePort = await findAvailablePort(); // Port on EC2 for the reverse tunnel
+    onProgress?.(`Establishing SSH tunnel to ${connectionInfo.public_ip}...`);
+    // Start a local SSH server that allows the remote to connect back
+    // We use SSH reverse port forwarding: -R remotePort:localhost:22
+    // But actually, for SSHFS we need the remote to access our files
+    //
+    // Better approach: Use SSH with -R to create a reverse tunnel
+    // Then remote does: sshfs -p <tunnelPort> user@localhost:<path> /mnt/user-code
+    const sshArgs = [
+        "-o", "StrictHostKeyChecking=no",
+        "-o", "UserKnownHostsFile=/dev/null",
+        "-o", "ServerAliveInterval=30",
+        "-o", "ServerAliveCountMax=3",
+        "-i", sshKeyPath,
+        // Reverse tunnel: remote port -> local SSH (for SSHFS)
+        "-R", `${remotePort}:localhost:22`,
+        "-p", String(connectionInfo.ssh_port),
+        `${connectionInfo.ssh_user}@${connectionInfo.public_ip}`,
+        // Keep connection alive, don't execute command
+        "-N",
+    ];
+    const tunnelProc = (0, node_child_process_1.spawn)("ssh", sshArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    let stderr = "";
+    tunnelProc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+    });
+    // Wait for tunnel to establish
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            tunnelProc.kill();
+            reject(new SSHTunnelError(`SSH tunnel timeout: ${stderr}`));
+        }, 30000);
+        tunnelProc.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(new SSHTunnelError(`SSH tunnel failed: ${err.message}`));
+        });
+        // Give it a moment to establish
+        setTimeout(() => {
+            if (tunnelProc.killed || tunnelProc.exitCode !== null) {
+                reject(new SSHTunnelError(`SSH tunnel exited early: ${stderr}`));
+            }
+            else {
+                clearTimeout(timeout);
+                resolve();
+            }
+        }, 3000);
+    });
+    onProgress?.("SSH tunnel established");
+    return {
+        process: tunnelProc,
+        localPort,
+        remoteHost: connectionInfo.public_ip,
+        remoteUser: connectionInfo.ssh_user,
+    };
+}
+/**
+ * Run analysis on the remote EC2 via SSH
+ *
+ * Instead of SSHFS (complex), we'll:
+ * 1. Tar the codebase locally
+ * 2. Stream it to the remote via SSH
+ * 3. Run Claude there
+ * 4. Get results back
+ */
+async function runRemoteAnalysis(connectionInfo, localPath, sshKeyPath, analysisPrompt, timeout, onProgress) {
+    const absolutePath = path.resolve(localPath);
+    onProgress?.("Preparing codebase for remote analysis...");
+    // Create a tar of the codebase (excluding node_modules, .git, etc.)
+    const excludes = [
+        "--exclude=node_modules",
+        "--exclude=.git",
+        "--exclude=dist",
+        "--exclude=build",
+        "--exclude=.next",
+        "--exclude=coverage",
+        "--exclude=*.log",
+    ];
+    // Remote command:
+    // 1. Create temp directory
+    // 2. Extract tar
+    // 3. Run claude --print -p <prompt>
+    // 4. Clean up
+    const remoteScript = `
+    set -e
+    WORK_DIR=$(mktemp -d)
+    cd "$WORK_DIR"
+    tar xzf -
+    source /etc/profile.d/anthropic.sh 2>/dev/null || true
+    claude --print -p '${analysisPrompt.replace(/'/g, "'\\''")}'
+    rm -rf "$WORK_DIR"
+  `;
+    return new Promise((resolve, reject) => {
+        // Pipe: tar -> ssh -> remote extraction + claude
+        const tarProc = (0, node_child_process_1.spawn)("tar", [
+            "czf", "-",
+            ...excludes,
+            "-C", path.dirname(absolutePath),
+            path.basename(absolutePath),
+        ], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const sshProc = (0, node_child_process_1.spawn)("ssh", [
+            "-o", "StrictHostKeyChecking=no",
+            "-o", "UserKnownHostsFile=/dev/null",
+            "-i", sshKeyPath,
+            "-p", String(connectionInfo.ssh_port),
+            `${connectionInfo.ssh_user}@${connectionInfo.public_ip}`,
+            "bash", "-c", remoteScript,
+        ], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Pipe tar output to ssh stdin
+        tarProc.stdout.pipe(sshProc.stdin);
+        let stdout = "";
+        let stderr = "";
+        sshProc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        sshProc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        tarProc.on("error", (err) => {
+            reject(new RemoteAnalyzerError(`Tar failed: ${err.message}`));
+        });
+        const timeoutId = setTimeout(() => {
+            tarProc.kill();
+            sshProc.kill();
+            reject(new RemoteAnalyzerError(`Remote analysis timed out after ${timeout} seconds`));
+        }, timeout * 1000);
+        sshProc.on("close", (code) => {
+            clearTimeout(timeoutId);
+            if (code !== 0) {
+                reject(new RemoteAnalyzerError(`Remote analysis failed (code ${code}): ${stderr}`));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+        sshProc.on("error", (err) => {
+            clearTimeout(timeoutId);
+            reject(new RemoteAnalyzerError(`SSH failed: ${err.message}`));
+        });
+        onProgress?.("Uploading codebase and running analysis...");
+    });
+}
+/**
+ * Clean up SSH key files
+ */
+function cleanupSSHKey(privateKeyPath) {
+    try {
+        fs.unlinkSync(privateKeyPath);
+        fs.unlinkSync(`${privateKeyPath}.pub`);
+        fs.rmdirSync(path.dirname(privateKeyPath));
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Main entry point: Analyze codebase using remote Claude Code
+ */
+async function analyzeWithRemoteClaude(codebasePath, options = {}, onProgress) {
+    const { timeout = 300, apiEndpoint = DEFAULT_API_ENDPOINT, } = options;
+    if (!apiEndpoint) {
+        throw new RemoteAnalyzerError("API endpoint not configured. Set KITE_API_ENDPOINT environment variable or deploy infrastructure first.");
+    }
+    // Validate local path
+    (0, analyzer_js_1.validateCodebasePath)(codebasePath);
+    const absolutePath = path.resolve(codebasePath);
+    let sshKeyPath = null;
+    try {
+        // 1. Start EC2 instance
+        onProgress?.("Starting remote analysis server...");
+        const connectionInfo = await startEC2Instance(apiEndpoint);
+        onProgress?.(`Server ready at ${connectionInfo.public_ip}`);
+        // 2. Wait for SSH
+        onProgress?.("Waiting for SSH to be available...");
+        await waitForSSH(connectionInfo.public_ip, connectionInfo.ssh_port);
+        // 3. Generate temp SSH key (for secure connection)
+        // Note: In production, you'd use a pre-shared key or other auth
+        // For now, we assume the EC2 has a known authorized key
+        // const { privateKeyPath, publicKey } = await generateTempSSHKey();
+        // sshKeyPath = privateKeyPath;
+        // For now, use the user's default SSH key or a configured one
+        sshKeyPath = options.sshKeyPath || path.join(os.homedir(), ".ssh", "id_rsa");
+        if (!fs.existsSync(sshKeyPath)) {
+            // Try ed25519
+            sshKeyPath = path.join(os.homedir(), ".ssh", "id_ed25519");
+            if (!fs.existsSync(sshKeyPath)) {
+                throw new SSHTunnelError("No SSH key found. Please create one with 'ssh-keygen' or specify --ssh-key");
+            }
+        }
+        // 4. Run remote analysis
+        const analysisPrompt = `Analyze this frontend codebase and extract:
+
+1. All page routes and their component files
+2. All API calls (fetch, axios, etc.) with endpoints and HTTP methods
+3. Form action types
+4. Map API endpoints to their likely tool names
+
+Return a JSON object with this EXACT structure (no markdown, no explanation, just JSON):
+{
+  "routes": [
+    {"route_name": "string", "file_path": "string", "component_name": "string"}
+  ],
+  "api_calls": [
+    {"endpoint": "string", "method": "string", "component_file": "string", "action_form_type": "string or null"}
+  ],
+  "mappings": [
+    {
+      "tool_name": "string",
+      "api_endpoint": "string",
+      "navigation_page": "string or null",
+      "action_form_type": "string or null",
+      "frontend_component": "string or null",
+      "frontend_file_path": "string or null"
+    }
+  ]
+}`;
+        onProgress?.("Running Claude Code analysis...");
+        const rawResult = await runRemoteAnalysis(connectionInfo, absolutePath, sshKeyPath, analysisPrompt, timeout, onProgress);
+        // 5. Parse results
+        onProgress?.("Parsing results...");
+        const data = (0, analyzer_js_1.parseClaudeResponse)(rawResult);
+        return (0, analyzer_js_1.buildAnalysisResult)(data, absolutePath);
+    }
+    finally {
+        // Cleanup would go here if we generated temp keys
+    }
+}
+/**
+ * Check if remote analysis is available (API endpoint configured)
+ */
+function isRemoteAnalysisAvailable() {
+    return !!DEFAULT_API_ENDPOINT;
+}
+/**
+ * Get the configured API endpoint
+ */
+function getApiEndpoint() {
+    return DEFAULT_API_ENDPOINT;
+}

package/dist/types.d.ts

@@ -33,6 +33,8 @@ export interface AnalyzeOptions {
     timeout?: number;
     verbose?: boolean;
     claudePath?: string;
+    sshKeyPath?: string;
+    apiEndpoint?: string;
 }
 export interface UploadResult {
     success: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kite-copilot/cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Kite CLI - Analyze frontend codebases and map API calls",
   "main": "dist/index.js",
   "bin": {