gekto 0.0.13 → 0.0.15

package/dist/onboarding.js

@@ -0,0 +1,339 @@
+import * as p from '@clack/prompts';
+import { fileURLToPath } from 'node:url';
+import { detectClaude } from './detectClaude.js';
+import { inspectRepo, describeStack, DEV_TEST_APP_DIR } from './inspectRepo.js';
+import { isPortInUse, waitForPort, startDevServer } from './portUtils.js';
+import { getPostHog, getDistinctId, initDistinctId } from './posthog.js';
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    white: '\x1b[37m',
+};
+const FALLBACK_STACK = {
+    language: 'unknown',
+    hasWebUI: true,
+    port: 3000,
+};
+async function saveLeadToSheetDB(data) {
+    try {
+        await fetch('https://sheetdb.io/api/v1/hxn1hd5nzjxhd?sheet=Leads', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                data: {
+                    email: data.email,
+                    is_using_claude: data.isUsingClaude ? 'Yes' : 'No',
+                    source: 'tui_onboarding',
+                },
+            }),
+        });
+    }
+    catch {
+        // Silently fail - don't block onboarding
+    }
+}
+function printStack(stack) {
+    const row = (label, value) => p.log.info(`${c.dim}${label.padEnd(11)}${c.reset} ${value ?? '(none)'}`);
+    row('Language:', stack.language);
+    row('Framework:', stack.framework);
+    row('Bundler:', stack.bundler);
+    row('Runtime:', stack.runtime);
+    row('Package mgr:', stack.packageManager);
+    row('Web UI:', stack.hasWebUI ? 'yes' : 'no');
+    row('Port:', stack.hasWebUI ? stack.port : null);
+    row('Dev cmd:', stack.hasWebUI ? stack.devCommand : null);
+}
+function cap(s) {
+    if (!s)
+        return '';
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function describeProject(stack) {
+    if (stack.hasWebUI) {
+        const what = stack.framework ? `${cap(stack.framework)} app` : `${cap(stack.language)} app`;
+        const portPart = stack.port ? ` that runs on port ${stack.port}` : '';
+        return `Looks like it's a ${what}${portPart}. Gekto can run on top of your app.`;
+    }
+    const langPart = cap(stack.language);
+    const fwPart = stack.framework ? ` and ${cap(stack.framework)} framework` : '';
+    return `Hmm, I suggest this is a backend app that uses ${langPart}${fwPart}. There is no visual layer, only data — Gekto will run its widget standalone.`;
+}
+export async function runOnboarding(opts = {}) {
+    const dev = opts.dev ?? false;
+    const proxyPort = opts.defaultProxyPort ?? 3200;
+    let stack = { ...FALLBACK_STACK };
+    console.clear();
+    // Claude Code check — must come before anything else
+    const claudeSpinner = p.spinner();
+    claudeSpinner.start('Looking for installed Claude Code...');
+    const [claude] = await Promise.all([
+        opts.fakeNoClaude ? Promise.resolve({ available: false }) : detectClaude(),
+        new Promise(resolve => setTimeout(resolve, 1000)),
+    ]);
+    if (!claude.available) {
+        claudeSpinner.stop('Claude Code not found on PATH');
+        p.log.warn('Gekto requires the Claude Code CLI to run.');
+        p.log.info(`Install it:  ${c.white}npm install -g @anthropic-ai/claude-code${c.reset}`);
+        p.log.info(`Docs:        ${c.white}https://docs.claude.com/en/docs/claude-code${c.reset}`);
+        p.cancel('Install Claude Code, then run gekto again.');
+        process.exit(1);
+    }
+    claudeSpinner.stop(`Claude Code v${claude.version} detected`);
+    const fs = await import('fs');
+    const path = await import('path');
+    const STORE_PATH = path.join(process.cwd(), 'gekto-store.json');
+    const loadSettings = () => {
+        if (dev)
+            return undefined;
+        try {
+            if (fs.existsSync(STORE_PATH)) {
+                const store = JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+                const settings = store.data?.settings;
+                if (settings?.stack && typeof settings.stack.hasWebUI === 'boolean')
+                    return settings;
+            }
+        }
+        catch { }
+        return undefined;
+    };
+    const saveSettings = (settings) => {
+        if (dev)
+            return;
+        let store = { version: 1, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), data: {} };
+        try {
+            if (fs.existsSync(STORE_PATH)) {
+                store = JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+            }
+        }
+        catch { }
+        store.data.settings = settings;
+        store.updatedAt = new Date().toISOString();
+        fs.writeFileSync(STORE_PATH, JSON.stringify(store, null, 2));
+    };
+    const existingSettings = opts.force ? undefined : loadSettings();
+    if (existingSettings?.onboardingCompleted) {
+        initDistinctId(existingSettings.email);
+        console.log(`${c.dim}Loaded settings from gekto-store.json${c.reset}`);
+        return { stack: existingSettings.stack, proxyPort: existingSettings.proxyPort };
+    }
+    p.intro(`${c.green}${c.bold}create-gekto${c.reset}${dev ? `  ${c.dim}(dev mode — not persisting)${c.reset}` : ''}`);
+    // Optional: agent-based repo inspection (requires explicit consent)
+    let inspection = null;
+    const inspectAnswer = await p.confirm({
+        message: 'Inspect this repo with Claude to detect your tech stack? (read-only)',
+        initialValue: true,
+    });
+    if (p.isCancel(inspectAnswer)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+    if (inspectAnswer) {
+        const inspectSpinner = p.spinner();
+        inspectSpinner.start('Inspecting repository...');
+        inspection = await inspectRepo({
+            cwd: dev ? DEV_TEST_APP_DIR : process.cwd(),
+            onEvent: event => {
+                if (event.type === 'tool')
+                    inspectSpinner.message(event.summary);
+            },
+        });
+        if (inspection) {
+            inspectSpinner.stop(`Detected: ${describeStack(inspection)}`);
+        }
+        else {
+            inspectSpinner.stop('Inspection failed — continuing with manual setup');
+        }
+    }
+    // If inspection succeeded, show summary + narrative, then loop: agree / correct / manual.
+    let confirmedFromInspection = false;
+    let current = inspection;
+    while (current) {
+        printStack(current);
+        p.note(describeProject(current));
+        const choice = await p.select({
+            message: 'Agree?',
+            options: [
+                { label: 'Yes, continue', value: 'yes' },
+                { label: 'No, tell agent where he is wrong', value: 'tell' },
+                { label: 'No, setup manually', value: 'manual' },
+            ],
+        });
+        if (p.isCancel(choice)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        if (choice === 'yes') {
+            stack = current;
+            confirmedFromInspection = true;
+            inspection = current;
+            break;
+        }
+        if (choice === 'manual') {
+            inspection = current;
+            break;
+        }
+        // choice === 'tell' — re-inspect with user's correction
+        const correction = await p.text({
+            message: 'What did Claude get wrong?',
+            placeholder: "e.g. it's actually a Vue 3 app, not React",
+        });
+        if (p.isCancel(correction)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        if (!correction.trim())
+            continue;
+        const refineSpinner = p.spinner();
+        refineSpinner.start('Re-inspecting with your correction...');
+        const refined = await inspectRepo({
+            cwd: dev ? DEV_TEST_APP_DIR : process.cwd(),
+            correction,
+            onEvent: event => {
+                if (event.type === 'tool')
+                    refineSpinner.message(event.summary);
+            },
+        });
+        if (refined) {
+            current = refined;
+            refineSpinner.stop(`Updated: ${describeStack(refined)}`);
+        }
+        else {
+            refineSpinner.stop('Re-inspection failed — keeping previous detection');
+        }
+    }
+    if (!confirmedFromInspection) {
+        // Manual override — only ask what actually affects behavior: hasWebUI + port.
+        // Keep detected lang/framework/etc. as descriptive metadata.
+        const hasWebUIAnswer = await p.confirm({
+            message: 'Does this project have a web UI Gekto should proxy?',
+            initialValue: inspection?.hasWebUI ?? true,
+        });
+        if (p.isCancel(hasWebUIAnswer)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        let port;
+        if (hasWebUIAnswer) {
+            const detectedPort = inspection?.port ? String(inspection.port) : '3000';
+            const portAnswer = await p.text({
+                message: 'What port is your dev server running on?',
+                placeholder: detectedPort,
+                defaultValue: detectedPort,
+            });
+            if (p.isCancel(portAnswer)) {
+                p.cancel('Setup cancelled.');
+                process.exit(0);
+            }
+            port = parseInt(portAnswer, 10);
+        }
+        stack = {
+            language: inspection?.language ?? 'unknown',
+            framework: inspection?.framework,
+            bundler: inspection?.bundler,
+            runtime: inspection?.runtime,
+            packageManager: inspection?.packageManager,
+            hasWebUI: hasWebUIAnswer,
+            port,
+        };
+    }
+    const emailAnswer = await p.text({
+        message: 'Enter your email for updates',
+        placeholder: 'you@example.com',
+    });
+    if (p.isCancel(emailAnswer)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+    const email = emailAnswer || '';
+    // If the project has a web UI and a port, verify the dev server is up — or offer to start it.
+    if (stack.hasWebUI && stack.port) {
+        const cwd = dev ? DEV_TEST_APP_DIR : process.cwd();
+        const portUsed = await isPortInUse(stack.port);
+        if (!portUsed) {
+            const options = [];
+            if (stack.devCommand) {
+                options.push({ label: `Yes, start using "${stack.devCommand}"`, value: 'detected' });
+            }
+            options.push({ label: 'Yes, write command', value: 'custom' });
+            options.push({ label: 'Not now', value: 'skip' });
+            const startChoice = await p.select({
+                message: `Your app isn't running on port ${stack.port}. Start it?`,
+                options,
+            });
+            if (p.isCancel(startChoice)) {
+                p.cancel('Setup cancelled.');
+                process.exit(0);
+            }
+            let command = null;
+            if (startChoice === 'detected') {
+                command = stack.devCommand;
+            }
+            else if (startChoice === 'custom') {
+                const cmdDefault = stack.devCommand || 'npm run dev';
+                const cmdAnswer = await p.text({
+                    message: 'Command to start your dev server:',
+                    placeholder: cmdDefault,
+                    defaultValue: cmdDefault,
+                });
+                if (p.isCancel(cmdAnswer)) {
+                    p.cancel('Setup cancelled.');
+                    process.exit(0);
+                }
+                command = (cmdAnswer || cmdDefault).trim();
+            }
+            if (command) {
+                const launchSpinner = p.spinner();
+                launchSpinner.start(`Starting "${command}"...`);
+                startDevServer(command, cwd);
+                const opened = await waitForPort(stack.port, 60_000, elapsed => {
+                    launchSpinner.message(`Waiting for port ${stack.port}... (${Math.floor(elapsed / 1000)}s)`);
+                });
+                if (opened) {
+                    launchSpinner.stop(`Your app is up on port ${stack.port}`);
+                }
+                else {
+                    launchSpinner.stop(`Timed out waiting for port ${stack.port} — Gekto will start anyway`);
+                }
+            }
+        }
+    }
+    const spinner = p.spinner();
+    spinner.start(dev ? 'Finishing (dev mode — skipping persistence)...' : 'Preparing Gekto...');
+    if (!dev) {
+        await saveLeadToSheetDB({
+            email,
+            isUsingClaude: claude.available,
+        });
+    }
+    saveSettings({ stack, proxyPort, onboardingCompleted: true, email });
+    initDistinctId(email);
+    getPostHog().capture({
+        distinctId: getDistinctId(),
+        event: 'onboarding completed',
+        properties: {
+            language: stack.language,
+            framework: stack.framework,
+            bundler: stack.bundler,
+            runtime: stack.runtime,
+            has_web_ui: stack.hasWebUI,
+            port: stack.port,
+            has_email: Boolean(email),
+            dev_mode: dev,
+            $set: email ? { email } : undefined,
+            $set_once: { initial_language: stack.language, initial_framework: stack.framework },
+        },
+    });
+    spinner.stop('Ready!');
+    p.outro(`${c.green}Starting Gekto...${c.reset}`);
+    return { stack, proxyPort };
+}
+// CLI entry — run `bun run src/onboarding.ts [--dev] [--no-claude]`
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const dev = process.argv.includes('--dev');
+    const fakeNoClaude = process.argv.includes('--no-claude');
+    const result = await runOnboarding({ dev, fakeNoClaude });
+    console.log('\nResult:', result);
+    process.exit(0);
+}

package/dist/portUtils.js

@@ -0,0 +1,40 @@
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+export function isPortInUse(port, host = '127.0.0.1') {
+    return new Promise(resolve => {
+        const socket = new net.Socket();
+        let settled = false;
+        const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(500);
+        socket.once('connect', () => done(true));
+        socket.once('error', () => done(false));
+        socket.once('timeout', () => done(false));
+        socket.connect(port, host);
+    });
+}
+export async function waitForPort(port, timeoutMs, onTick) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await isPortInUse(port))
+            return true;
+        onTick?.(Date.now() - start);
+        await new Promise(r => setTimeout(r, 500));
+    }
+    return false;
+}
+export function startDevServer(command, cwd) {
+    const child = spawn(command, [], {
+        cwd,
+        shell: true,
+        stdio: 'ignore',
+        detached: false,
+    });
+    child.on('error', () => { });
+    return child;
+}

package/dist/posthog.js

@@ -0,0 +1,53 @@
+import { PostHog } from 'posthog-node';
+import { randomUUID } from 'crypto';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+// Public project API key — phc_ keys are safe to ship in client code.
+const DEFAULT_API_KEY = 'phc_s8GT8r8YG23NJqUhpyq2XcNegWyLomZjnsJmmtxOKMf';
+const DEFAULT_HOST = 'https://us.i.posthog.com';
+// Lazy singleton — created on first use
+let _client = null;
+// Distinct ID used for all events — set once per process
+let _distinctId = 'anonymous';
+export function getPostHog() {
+    if (!_client) {
+        _client = new PostHog(process.env.POSTHOG_API_KEY || DEFAULT_API_KEY, {
+            host: process.env.POSTHOG_HOST || DEFAULT_HOST,
+            enableExceptionAutocapture: true,
+        });
+    }
+    return _client;
+}
+/** Return the current distinct ID for event capture. */
+export function getDistinctId() {
+    return _distinctId;
+}
+/**
+ * Set the distinct ID from the user's stored email or a persisted install UUID.
+ * Should be called once during startup / after onboarding completes.
+ */
+export function initDistinctId(email) {
+    if (email && email.trim()) {
+        _distinctId = email.trim();
+        return;
+    }
+    // Fall back to a persisted install UUID stored alongside gekto-store.json
+    const installIdPath = join(process.cwd(), '.gekto-install-id');
+    if (existsSync(installIdPath)) {
+        try {
+            const id = readFileSync(installIdPath, 'utf8').trim();
+            if (id) {
+                _distinctId = id;
+                return;
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // First run — generate and persist an install UUID
+    const id = randomUUID();
+    try {
+        writeFileSync(installIdPath, id, 'utf8');
+    }
+    catch { /* ignore */ }
+    _distinctId = id;
+}