gekto 0.0.13 → 0.0.14

package/dist/agents/agentWebSocket.js

@@ -6,6 +6,7 @@ import { getState, mutate, mutateBatch, addClient, removeClient, sendSnapshot, g
 import { persistEntity } from '../entityStore.js';
 import fs from 'fs';
 import nodePath from 'path';
+import { getPostHog, getDistinctId } from '../posthog.js';
 let gektoInitialized = false;
 function broadcastGektoState(state) {
     const message = JSON.stringify({ type: 'gekto_state', state });
@@ -160,6 +161,11 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             type: 'kill_all_result',
                             killed: killedCount,
                         }));
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'all agents killed',
+                            properties: { killed_count: killedCount },
+                        });
                         // Notify about state changes
                         for (const session of getActiveSessions()) {
                             ws.send(JSON.stringify({ type: 'state', lizardId: session.lizardId, state: 'ready' }));
@@ -193,6 +199,11 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         mutate('activePlanId', null);
                         broadcastActivePlans();
                         broadcastActivePlanId();
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'all agents cleared',
+                            properties: { agent_count: agentIds.length },
+                        });
                         return;
                     }
                     case 'set_active_plan': {
@@ -299,6 +310,14 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                 planId: msg.planId,
                                 prompt: msg.prompt,
                             }));
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'gekto message sent',
+                                properties: {
+                                    plan_id: msg.planId,
+                                    has_images: Boolean(planImagePaths?.length),
+                                },
+                            });
                             const planResult = await processWithTools(msg.prompt, msg.planId, getWorkingDir(), getActiveSessions(), planCallbacks, msg.existingPlan, planImagePaths);
                             // Replace streamed JSON with clean message (always send to overwrite raw JSON)
                             // For delegate, the system message handles display — clear the streaming text
@@ -348,6 +367,15 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                     planId: msg.planId,
                                     plan: planResult.plan,
                                 }));
+                                getPostHog().capture({
+                                    distinctId: getDistinctId(),
+                                    event: 'plan created',
+                                    properties: {
+                                        plan_id: planResult.plan.id,
+                                        plan_title: planResult.plan.title,
+                                        action: planExistedBefore ? 'update_plan' : 'create_plan',
+                                    },
+                                });
                             }
                             else if (planResult.type === 'remove' && planResult.removedAgents) {
                                 // Remove agents from server state
@@ -441,6 +469,7 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         }
                         catch (err) {
                             console.error('[Agent] Gekto processing failed:', err);
+                            getPostHog().captureException(err, getDistinctId(), { plan_id: msg.planId });
                             ws.send(JSON.stringify({
                                 type: 'gekto_chat',
                                 planId: msg.planId,
@@ -531,6 +560,14 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                         planId: msg.planId,
                                         taskCount: tasks.length,
                                     }));
+                                    getPostHog().capture({
+                                        distinctId: getDistinctId(),
+                                        event: 'plan tasks generated',
+                                        properties: {
+                                            plan_id: msg.planId,
+                                            task_count: tasks.length,
+                                        },
+                                    });
                                 },
                                 onError: (error) => {
                                     ws.send(JSON.stringify({
@@ -547,6 +584,7 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         }
                         catch (err) {
                             console.error('[Agent] Task generation failed:', err);
+                            getPostHog().captureException(err, getDistinctId(), { plan_id: msg.planId });
                             ws.send(JSON.stringify({
                                 type: 'gekto_chat',
                                 planId: msg.planId,
@@ -570,9 +608,22 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             mutate(`activePlans.${msg.planId}.status`, 'executing');
                             broadcastSinglePlan(msg.planId);
                         }
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'plan executed',
+                            properties: {
+                                plan_id: msg.planId,
+                                task_count: currentState.activePlans[msg.planId]?.taskIds?.length ?? 0,
+                            },
+                        });
                         return;
                     }
                     case 'cancel_plan': {
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'plan canceled',
+                            properties: { plan_id: msg.planId },
+                        });
                         const currentState = getState();
                         const cancelPlan = currentState.activePlans[msg.planId];
                         if (cancelPlan) {
@@ -625,6 +676,15 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         ]);
                         broadcastTask(task.id);
                         broadcastAgent(agent.id);
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'worker agent spawned',
+                            properties: {
+                                agent_id: agent.id,
+                                task_id: task.id,
+                                plan_id: task.planId,
+                            },
+                        });
                         return;
                     }
                     // Client updates a chat message list — store on agent
@@ -695,6 +755,16 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             broadcastTask(msg.taskId);
                             if (agentId)
                                 broadcastAgent(agentId);
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'task completed',
+                                properties: {
+                                    task_id: msg.taskId,
+                                    task_name: taskState?.name,
+                                    plan_id: taskState?.planId,
+                                    agent_id: agentId,
+                                },
+                            });
                         }
                         return;
                     }
@@ -713,16 +783,38 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             broadcastTask(msg.taskId);
                             if (agentId)
                                 broadcastAgent(agentId);
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'task failed',
+                                properties: {
+                                    task_id: msg.taskId,
+                                    task_name: taskState?.name,
+                                    plan_id: taskState?.planId,
+                                    agent_id: agentId,
+                                    error: msg.error,
+                                },
+                            });
                         }
                         return;
                     }
                     case 'task_started': {
                         if (msg.taskId) {
+                            const taskState = getState().tasks[msg.taskId];
                             mutateBatch([
                                 { path: `tasks.${msg.taskId}.status`, value: 'in_progress' },
                                 { path: `tasks.${msg.taskId}.assignedAgentId`, value: msg.lizardId },
                             ]);
                             broadcastTask(msg.taskId);
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'task started',
+                                properties: {
+                                    task_id: msg.taskId,
+                                    task_name: taskState?.name,
+                                    plan_id: taskState?.planId,
+                                    agent_id: msg.lizardId,
+                                },
+                            });
                         }
                         return;
                     }
@@ -930,6 +1022,14 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                 broadcastAgent(lizardId);
                             }
                             const images = msg.images;
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'agent message sent',
+                                properties: {
+                                    agent_id: lizardId,
+                                    has_images: Boolean(images?.length),
+                                },
+                            });
                             await sendMessage(lizardId, msg.content, ws, images);
                         }
                         catch (err) {
@@ -943,6 +1043,11 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         else {
                             resetSession(lizardId);
                         }
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'agent reset',
+                            properties: { agent_id: lizardId },
+                        });
                         ws.send(JSON.stringify({ type: 'state', lizardId, state: 'ready' }));
                         break;
                     case 'revert_files': {
@@ -953,6 +1058,15 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             reverted: revertResult.reverted,
                             failed: revertResult.failed,
                         }));
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'files reverted',
+                            properties: {
+                                agent_id: lizardId,
+                                reverted_count: revertResult.reverted.length,
+                                failed_count: revertResult.failed.length,
+                            },
+                        });
                         // Remove reverted file changes from agent state
                         const agentState = getState().agents[lizardId];
                         if (agentState?.fileChanges) {

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

package/dist/proxy.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import * as p from '@clack/prompts';
+import { getPostHog, getDistinctId, initDistinctId } from './posthog.js';
 // Colors for TUI
 const c = {
     reset: '\x1b[0m',
@@ -100,6 +101,7 @@ async function runOnboarding() {
         PROJECT_TYPE = existingSettings.projectType;
         TARGET_PORT = existingSettings.targetPort;
         PROXY_PORT = existingSettings.proxyPort;
+        initDistinctId(existingSettings.email);
         console.log(`${c.dim}Loaded settings from gekto-store.json${c.reset}`);
         return;
     }
@@ -162,6 +164,17 @@ async function runOnboarding() {
         onboardingCompleted: true,
         email,
     });
+    initDistinctId(email);
+    getPostHog().capture({
+        distinctId: getDistinctId(),
+        event: 'onboarding completed',
+        properties: {
+            project_type: PROJECT_TYPE,
+            has_email: Boolean(email),
+            $set: email ? { email } : undefined,
+            $set_once: { initial_project_type: PROJECT_TYPE },
+        },
+    });
     spinner.stop('Ready!');
     p.outro(`${c.green}Starting Gekto...${c.reset}`);
 }
@@ -182,9 +195,12 @@ async function main() {
     // Prevent EPIPE and other uncaught errors from crashing the server
     process.on('uncaughtException', (err) => {
         console.error('[proxy] Uncaught exception (server stays running):', err.message);
+        getPostHog().captureException(err, getDistinctId());
     });
     process.on('unhandledRejection', (err) => {
         console.error('[proxy] Unhandled rejection (server stays running):', err);
+        if (err instanceof Error)
+            getPostHog().captureException(err, getDistinctId());
     });
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
     // Parse CLI arguments (for overrides)
@@ -487,7 +503,24 @@ async function main() {
     // === STEP 4: Show logo and start listening ===
     console.clear();
     printLogo();
+    // Graceful shutdown — flush PostHog before exit
+    const shutdown = async () => {
+        await getPostHog().shutdown();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
     server.listen(PROXY_PORT, () => {
+        getPostHog().capture({
+            distinctId: getDistinctId(),
+            event: 'proxy started',
+            properties: {
+                project_type: PROJECT_TYPE,
+                proxy_port: PROXY_PORT,
+                target_port: TARGET_PORT,
+                dev_mode: DEV_MODE,
+            },
+        });
         if (PROJECT_TYPE === 'frontend') {
             printBox([
                 `${c.bold}Gekto is ready!${c.reset}`,

package/dist/terminal.js

@@ -1,5 +1,6 @@
 import { WebSocket, WebSocketServer } from 'ws';
 import * as pty from 'node-pty';
+import { getPostHog, getDistinctId } from './posthog.js';
 const sessions = new Map();
 export function setupTerminalWebSocket(server, path = '/__gekto/terminal') {
     const wss = new WebSocketServer({ noServer: true });
@@ -14,6 +15,10 @@ export function setupTerminalWebSocket(server, path = '/__gekto/terminal') {
         // Other upgrade requests (like Vite HMR) are handled elsewhere
     });
     wss.on('connection', (ws) => {
+        getPostHog().capture({
+            distinctId: getDistinctId(),
+            event: 'terminal session started',
+        });
         // Create session but don't spawn PTY yet - wait for resize
         const session = {
             pty: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gekto",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "AI coding assistant widget - inject into any web app",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
   "dependencies": {
     "@clack/prompts": "^1.0.0",
     "node-pty": "^1.1.0-beta30",
+    "posthog-node": "^5.21.2",
     "ws": "^8.18.3"
   },
   "devDependencies": {