@electric-agent/studio 1.3.0 → 1.5.0

package/dist/server.js

@@ -164,6 +164,7 @@ function mapHookToEngineEvent(body) {
                     tool_use_id: toolUseId,
                     question: firstQuestion?.question || toolInput.question || "",
                     options: firstQuestion?.options,
+                    questions: questions ?? undefined,
                     ts: now,
                 };
             }
@@ -432,7 +433,7 @@ export function createApp(config) {
             console.log(`[hook-event] Blocking for ask_user_question gate: ${toolUseId}`);
             try {
                 const gateTimeout = 5 * 60 * 1000; // 5 minutes
-                const answer = await Promise.race([
+                const result = await Promise.race([
                     createGate(sessionId, `ask_user_question:${toolUseId}`),
                     new Promise((_, reject) => setTimeout(() => reject(new Error("AskUserQuestion gate timed out")), gateTimeout)),
                 ]);
@@ -443,7 +444,7 @@ export function createApp(config) {
                         permissionDecision: "allow",
                         updatedInput: {
                             questions: body.tool_input?.questions,
-                            answers: { [hookEvent.question]: answer.answer },
+                            answers: result.answers,
                         },
                     },
                 });
@@ -562,7 +563,7 @@ export function createApp(config) {
             console.log(`[hook] Blocking for ask_user_question gate: ${toolUseId}`);
             try {
                 const gateTimeout = 5 * 60 * 1000;
-                const answer = await Promise.race([
+                const result = await Promise.race([
                     createGate(sessionId, `ask_user_question:${toolUseId}`),
                     new Promise((_, reject) => setTimeout(() => reject(new Error("AskUserQuestion gate timed out")), gateTimeout)),
                 ]);
@@ -574,7 +575,7 @@ export function createApp(config) {
                         permissionDecision: "allow",
                         updatedInput: {
                             questions: body.tool_input?.questions,
-                            answers: { [hookEvent.question]: answer.answer },
+                            answers: result.answers,
                         },
                     },
                 });
@@ -717,8 +718,9 @@ echo "Start claude in this project — the session will appear in the studio UI.
         // Write user prompt to the stream so it shows in the UI
         await bridge.emit({ type: "user_prompt", message: body.description, ts: ts() });
         // Gather GitHub accounts for the merged setup gate
+        // Only check if the client provided a token — never fall back to server-side GH_TOKEN
         let ghAccounts = [];
-        if (isGhAuthenticated(body.ghToken)) {
+        if (body.ghToken && isGhAuthenticated(body.ghToken)) {
             try {
                 ghAccounts = ghListAccounts(body.ghToken);
             }
@@ -932,14 +934,16 @@ echo "Start claude in this project — the session will appear in the studio UI.
                 }
                 config.sessions.update(sessionId, updates);
                 // Check if the app is running after completion
-                // and emit app_ready so the UI shows the preview link
+                // and emit app_status so the UI shows the preview link
                 if (success) {
                     try {
                         const appRunning = await config.sandbox.isAppRunning(handle);
                         if (appRunning) {
                             await bridge.emit({
-                                type: "app_ready",
+                                type: "app_status",
+                                status: "running",
                                 port: handle.port ?? session.appPort,
+                                previewUrl: handle.previewUrl ?? session.previewUrl,
                                 ts: ts(),
                             });
                         }
@@ -949,6 +953,13 @@ echo "Start claude in this project — the session will appear in the studio UI.
                     }
                 }
             });
+            // Show the command being sent to Claude Code
+            await bridge.emit({
+                type: "log",
+                level: "build",
+                message: `Running: claude "/create-app ${body.description}"`,
+                ts: ts(),
+            });
             console.log(`[session:${sessionId}] Starting bridge listener...`);
             await bridge.start();
             console.log(`[session:${sessionId}] Bridge started, sending 'new' command...`);
@@ -1015,7 +1026,13 @@ echo "Start claude in this project — the session will appear in the studio UI.
                         message: "App started",
                         ts: ts(),
                     });
-                    await bridge.emit({ type: "app_ready", port: session.appPort, ts: ts() });
+                    await bridge.emit({
+                        type: "app_status",
+                        status: "running",
+                        port: session.appPort,
+                        previewUrl: session.previewUrl,
+                        ts: ts(),
+                    });
                 }
             }
             catch (err) {
@@ -1082,8 +1099,10 @@ echo "Start claude in this project — the session will appear in the studio UI.
             if (!toolUseId) {
                 return c.json({ error: "toolUseId is required for ask_user_question" }, 400);
             }
-            const answer = body.answer || "";
-            const resolved = resolveGate(sessionId, `ask_user_question:${toolUseId}`, { answer });
+            // Accept either answers (Record<string, string>) or legacy answer (string)
+            const answers = body.answers ??
+                (body.answer ? { [body.question || "answer"]: body.answer } : {});
+            const resolved = resolveGate(sessionId, `ask_user_question:${toolUseId}`, { answers });
             if (resolved) {
                 // Hook session — gate was blocking, now resolved
                 try {
@@ -1234,6 +1253,24 @@ echo "Start claude in this project — the session will appear in the studio UI.
         }
         return c.json({ success: true });
     });
+    // Interrupt the running Claude Code process without destroying the session.
+    // The sandbox stays alive and the bridge remains open for follow-up messages.
+    app.post("/api/sessions/:id/interrupt", async (c) => {
+        const sessionId = c.req.param("id");
+        const bridge = bridges.get(sessionId);
+        if (bridge) {
+            bridge.interrupt();
+            // Emit session_end so the UI knows the process stopped
+            await bridge.emit({
+                type: "session_end",
+                success: false,
+                ts: ts(),
+            });
+        }
+        rejectAllGates(sessionId);
+        config.sessions.update(sessionId, { status: "complete" });
+        return c.json({ ok: true });
+    });
     // Cancel a running session
     app.post("/api/sessions/:id/cancel", async (c) => {
         const sessionId = c.req.param("id");
@@ -1694,9 +1731,11 @@ echo "Start claude in this project — the session will appear in the studio UI.
         }
         return c.json({ content });
     });
-    // List GitHub accounts (personal + orgs)
+    // List GitHub accounts (personal + orgs) — requires client-provided token
     app.get("/api/github/accounts", (c) => {
-        const token = c.req.header("X-GH-Token") || undefined;
+        const token = c.req.header("X-GH-Token");
+        if (!token)
+            return c.json({ accounts: [] });
         try {
             const accounts = ghListAccounts(token);
             return c.json({ accounts });
@@ -1705,9 +1744,11 @@ echo "Start claude in this project — the session will appear in the studio UI.
             return c.json({ error: e instanceof Error ? e.message : "Failed to list accounts" }, 500);
         }
     });
-    // List GitHub repos for the authenticated user
+    // List GitHub repos for the authenticated user — requires client-provided token
     app.get("/api/github/repos", (c) => {
-        const token = c.req.header("X-GH-Token") || undefined;
+        const token = c.req.header("X-GH-Token");
+        if (!token)
+            return c.json({ repos: [] });
         try {
             const repos = ghListRepos(50, token);
             return c.json({ repos });
@@ -1719,7 +1760,9 @@ echo "Start claude in this project — the session will appear in the studio UI.
     app.get("/api/github/repos/:owner/:repo/branches", (c) => {
         const owner = c.req.param("owner");
         const repo = c.req.param("repo");
-        const token = c.req.header("X-GH-Token") || undefined;
+        const token = c.req.header("X-GH-Token");
+        if (!token)
+            return c.json({ branches: [] });
         try {
             const branches = ghListBranches(`${owner}/${repo}`, token);
             return c.json({ branches });
@@ -1772,24 +1815,47 @@ echo "Start claude in this project — the session will appear in the studio UI.
         catch {
             return c.json({ error: "Failed to create event stream" }, 500);
         }
-        try {
+        // Create the initial session bridge for emitting progress events
+        const bridge = getOrCreateBridge(config, sessionId);
+        // Record session as running (like normal session creation)
+        const sandboxProjectDir = `/home/agent/workspace/${repoName}`;
+        const session = {
+            id: sessionId,
+            projectName: body.branch ? `${repoName}/${body.branch}` : repoName,
+            sandboxProjectDir,
+            description: `Resumed from ${body.repoUrl}`,
+            createdAt: new Date().toISOString(),
+            lastActiveAt: new Date().toISOString(),
+            status: "running",
+        };
+        config.sessions.add(session);
+        // Write user prompt to the stream so it shows in the UI
+        await bridge.emit({
+            type: "user_prompt",
+            message: `Resume from ${body.repoUrl}`,
+            ts: ts(),
+        });
+        // Launch async flow: clone repo → set up Claude Code → start exploring
+        const asyncFlow = async () => {
+            // 1. Clone the repo into a sandbox
+            await bridge.emit({
+                type: "log",
+                level: "build",
+                message: "Cloning repository...",
+                ts: ts(),
+            });
             const handle = await config.sandbox.createFromRepo(sessionId, body.repoUrl, {
                 branch: body.branch,
                 apiKey: body.apiKey,
                 oauthToken: body.oauthToken,
                 ghToken: body.ghToken,
             });
-            // Get git state from cloned repo inside the container
+            // Get git state from cloned repo
             const gs = await config.sandbox.gitStatus(handle, handle.projectDir);
-            const session = {
-                id: sessionId,
-                projectName: repoName,
-                sandboxProjectDir: handle.projectDir,
-                description: `Resumed from ${body.repoUrl}`,
-                createdAt: new Date().toISOString(),
-                lastActiveAt: new Date().toISOString(),
-                status: "complete",
+            config.sessions.update(sessionId, {
                 appPort: handle.port,
+                sandboxProjectDir: handle.projectDir,
+                previewUrl: handle.previewUrl,
                 git: {
                     branch: gs.branch ?? body.branch ?? "main",
                     remoteUrl: body.repoUrl,
@@ -1798,23 +1864,128 @@ echo "Start claude in this project — the session will appear in the studio UI.
                     lastCommitMessage: gs.lastCommitMessage ?? null,
                     lastCheckpointAt: null,
                 },
-            };
-            config.sessions.add(session);
-            // Write initial message to stream
-            const bridge = getOrCreateBridge(config, sessionId);
+            });
             await bridge.emit({
                 type: "log",
                 level: "done",
-                message: `Resumed from ${body.repoUrl}`,
+                message: "Repository cloned",
                 ts: ts(),
             });
-            const sessionToken = deriveSessionToken(config.streamConfig.secret, sessionId);
-            return c.json({ sessionId, session, sessionToken, appPort: handle.port }, 201);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : "Failed to resume from repo";
-            return c.json({ error: msg }, 500);
-        }
+            // 2. Write CLAUDE.md to the sandbox workspace
+            const claudeMd = generateClaudeMd({
+                description: `Resumed from ${body.repoUrl}`,
+                projectName: repoName,
+                projectDir: handle.projectDir,
+                runtime: config.sandbox.runtime,
+            });
+            try {
+                await config.sandbox.exec(handle, `cat > '${handle.projectDir}/CLAUDE.md' << 'CLAUDEMD_EOF'\n${claudeMd}\nCLAUDEMD_EOF`);
+            }
+            catch (err) {
+                console.error(`[session:${sessionId}] Failed to write CLAUDE.md:`, err);
+            }
+            // Ensure the create-app skill is present in the project
+            if (createAppSkillContent) {
+                try {
+                    const skillDir = `${handle.projectDir}/.claude/skills/create-app`;
+                    const skillB64 = Buffer.from(createAppSkillContent).toString("base64");
+                    await config.sandbox.exec(handle, `mkdir -p '${skillDir}' && echo '${skillB64}' | base64 -d > '${skillDir}/SKILL.md'`);
+                }
+                catch (err) {
+                    console.error(`[session:${sessionId}] Failed to write create-app skill:`, err);
+                }
+            }
+            // 3. Create Claude Code bridge with a resume prompt
+            const resumePrompt = "You are resuming work on an existing project. Explore the codebase to understand its structure, then wait for instructions from the user.";
+            const claudeConfig = config.sandbox.runtime === "sprites"
+                ? {
+                    prompt: resumePrompt,
+                    cwd: handle.projectDir,
+                    studioUrl: resolveStudioUrl(config.port),
+                }
+                : {
+                    prompt: resumePrompt,
+                    cwd: handle.projectDir,
+                    studioPort: config.port,
+                };
+            const ccBridge = createClaudeCodeBridge(config, sessionId, claudeConfig);
+            // 4. Register event listeners (reuse pattern from normal flow)
+            ccBridge.onAgentEvent((event) => {
+                if (event.type === "session_start") {
+                    const ccSessionId = event.session_id;
+                    console.log(`[session:${sessionId}] Captured Claude Code session ID: ${ccSessionId}`);
+                    if (ccSessionId) {
+                        config.sessions.update(sessionId, { lastCoderSessionId: ccSessionId });
+                    }
+                }
+            });
+            ccBridge.onComplete(async (success) => {
+                const updates = {
+                    status: success ? "complete" : "error",
+                };
+                try {
+                    const latestGs = await config.sandbox.gitStatus(handle, handle.projectDir);
+                    if (latestGs.initialized) {
+                        const existing = config.sessions.get(sessionId);
+                        updates.git = {
+                            branch: latestGs.branch ?? "main",
+                            remoteUrl: existing?.git?.remoteUrl ?? null,
+                            repoName: existing?.git?.repoName ?? null,
+                            repoVisibility: existing?.git?.repoVisibility,
+                            lastCommitHash: latestGs.lastCommitHash ?? null,
+                            lastCommitMessage: latestGs.lastCommitMessage ?? null,
+                            lastCheckpointAt: existing?.git?.lastCheckpointAt ?? null,
+                        };
+                    }
+                }
+                catch {
+                    // Container may already be stopped
+                }
+                config.sessions.update(sessionId, updates);
+                // Check if the app is running after completion
+                if (success) {
+                    try {
+                        const appRunning = await config.sandbox.isAppRunning(handle);
+                        if (appRunning) {
+                            await ccBridge.emit({
+                                type: "app_status",
+                                status: "running",
+                                port: handle.port ?? session.appPort,
+                                previewUrl: handle.previewUrl ?? session.previewUrl,
+                                ts: ts(),
+                            });
+                        }
+                    }
+                    catch {
+                        // Container may already be stopped
+                    }
+                }
+            });
+            // 5. Start the bridge and send command
+            await ccBridge.emit({
+                type: "log",
+                level: "build",
+                message: "Starting Claude Code...",
+                ts: ts(),
+            });
+            console.log(`[session:${sessionId}] Starting bridge listener...`);
+            await ccBridge.start();
+            console.log(`[session:${sessionId}] Bridge started, sending 'new' command...`);
+            const newCmd = {
+                command: "new",
+                description: resumePrompt,
+                projectName: repoName,
+                baseDir: "/home/agent/workspace",
+            };
+            await ccBridge.sendCommand(newCmd);
+            console.log(`[session:${sessionId}] Command sent, waiting for agent...`);
+        };
+        asyncFlow().catch(async (err) => {
+            console.error(`[session:${sessionId}] Resume flow failed:`, err);
+            config.sessions.update(sessionId, { status: "error" });
+        });
+        const sessionToken = deriveSessionToken(config.streamConfig.secret, sessionId);
+        return c.json({ sessionId, session, sessionToken }, 201);
     });
     // Serve static SPA files (if built)
     const clientDir = path.resolve(path.dirname(new URL(import.meta.url).pathname), "./client");