glad-web 1.0.18 → 1.0.20

package/lib/commands/web.js

@@ -33,11 +33,16 @@ function sendCompressedJson(req, res, payload) {
   res.type('application/json').send(body);
 }
 
+function getSessionWorkingDirectory(session) {
+  return session.workingDir || (session.ptyManager && session.ptyManager.workingDir) || process.cwd();
+}
+
 const { detectInstalledTools } = require('../ai-tools/detector');
 const logger = require('../utils/logger');
 const { JobStore } = require('../schedule/job-store');
 const JobRunner = require('../schedule/job-runner');
 const SchedulerService = require('../schedule/scheduler-service');
+const { getClaudeRuntimeConfig } = require('../claude/config');
 
 async function webCommand(options) {
   const port = parseInt(options.port) || 3000;
@@ -85,6 +90,9 @@ async function webCommand(options) {
   sessionManager.on('output', ({ sessionId, data }) => {
     broadcastToSession(sessionId, { type: 'output', data });
   });
+  sessionManager.on('claude-event', ({ sessionId, event }) => {
+    broadcastToSession(sessionId, { type: 'claude-event', event });
+  });
   sessionManager.on('exit', ({ sessionId }) => {
     broadcastToSession(sessionId, { type: 'exit' });
   });
@@ -179,12 +187,16 @@ async function webCommand(options) {
     res.json(sessionManager.list());
   });
 
+  app.get('/api/claude-config', (req, res) => {
+    res.json({ success: true, config: getClaudeRuntimeConfig(process.env) });
+  });
+
   // API: Create a new PTY session
   app.post('/api/sessions', async (req, res) => {
     logger.debug(`API: POST /api/sessions - ${JSON.stringify(req.body)}`);
     try {
-      const { toolKey, workingDirectory } = req.body;
-      const session = sessionManager.create({ toolKey, workingDirectory });
+      const { toolKey, workingDirectory, claudeOptions } = req.body;
+      const session = sessionManager.create({ toolKey, workingDirectory, claudeOptions });
       res.json({ id: session.id });
     } catch (e) {
       logger.error(`API: POST /api/sessions failed: ${e.message}`);
@@ -217,6 +229,40 @@ async function webCommand(options) {
     res.json({ success: true });
   });
 
+  app.get('/api/sessions/:id/timed-inputs', (req, res) => {
+    const items = sessionManager.listTimedInputs(req.params.id);
+    if (!items) return res.status(404).json({ error: 'Session not found' });
+    res.json({ success: true, items });
+  });
+
+  app.post('/api/sessions/:id/timed-inputs', (req, res) => {
+    try {
+      const item = sessionManager.scheduleTimedInput(req.params.id, req.body || {});
+      if (!item) return res.status(404).json({ error: 'Session not found' });
+      res.json({ success: true, item });
+    } catch (e) {
+      res.status(e.statusCode || 500).json({ error: e.message });
+    }
+  });
+
+  app.patch('/api/sessions/:id/timed-inputs/:inputId', (req, res) => {
+    try {
+      const item = sessionManager.updateTimedInput(req.params.id, req.params.inputId, req.body || {});
+      if (item === null) return res.status(404).json({ error: 'Session not found' });
+      if (!item) return res.status(404).json({ error: 'Timed input not found' });
+      res.json({ success: true, item });
+    } catch (e) {
+      res.status(e.statusCode || 500).json({ error: e.message });
+    }
+  });
+
+  app.delete('/api/sessions/:id/timed-inputs/:inputId', (req, res) => {
+    const cancelled = sessionManager.cancelTimedInput(req.params.id, req.params.inputId);
+    if (cancelled === null) return res.status(404).json({ error: 'Session not found' });
+    if (!cancelled) return res.status(404).json({ error: 'Timed input not found' });
+    res.json({ success: true });
+  });
+
   // API: Delete/Kill session
   app.delete('/api/sessions/:id', (req, res) => {
     sessionManager.kill(req.params.id);
@@ -229,6 +275,32 @@ async function webCommand(options) {
     res.json({ success: true, diagnostics });
   });
 
+  app.get('/api/sessions/:id/claude-resume-sessions', (req, res) => {
+    const items = sessionManager.listClaudeResumeSessions(req.params.id);
+    if (!items) return res.status(404).json({ error: 'Claude session not found' });
+    res.json({ success: true, items });
+  });
+
+  app.patch('/api/sessions/:id/claude-settings', (req, res) => {
+    const state = sessionManager.updateClaudeSettings(req.params.id, req.body || {});
+    if (!state) return res.status(404).json({ error: 'Claude session not found' });
+    res.json({ success: true, state });
+  });
+
+  app.post('/api/sessions/:id/claude-abort', (req, res) => {
+    const success = sessionManager.abortClaude(req.params.id);
+    if (!success) return res.status(404).json({ error: 'Claude session not found or idle' });
+    res.json({ success: true });
+  });
+
+  app.post('/api/sessions/:id/claude-resume', (req, res) => {
+    const resumeSessionId = req.body && req.body.resumeSessionId;
+    if (!resumeSessionId) return res.status(400).json({ error: 'Missing resumeSessionId' });
+    const success = sessionManager.resumeClaude(req.params.id, resumeSessionId);
+    if (!success) return res.status(404).json({ error: 'Claude session not found' });
+    res.json({ success: true });
+  });
+
   app.post('/api/debug/client-log', (req, res) => {
     const { sessionId, event, payload } = req.body || {};
     sessionManager.logClientDebug(sessionId, event, payload);
@@ -240,7 +312,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const hash = req.params.hash;
-    const result = await gitService.show(session.ptyManager.workingDir, hash);
+    const result = await gitService.show(getSessionWorkingDirectory(session), hash);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -249,7 +321,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const hash = req.params.hash;
-    const result = await gitService.nameRev(session.ptyManager.workingDir, hash);
+    const result = await gitService.nameRev(getSessionWorkingDirectory(session), hash);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -257,7 +329,7 @@ async function webCommand(options) {
   app.get('/api/sessions/:id/git-log', async (req, res) => {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
-    const result = await gitService.log(session.ptyManager.workingDir, req.query.maxCount);
+    const result = await gitService.log(getSessionWorkingDirectory(session), req.query.maxCount);
     if (!result.success) {
       return res.status(500).json({ error: result.error, stderr: result.stderr });
     }
@@ -268,7 +340,7 @@ async function webCommand(options) {
   app.get('/api/sessions/:id/git-status', async (req, res) => {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
-    const result = await gitService.status(session.ptyManager.workingDir);
+    const result = await gitService.status(getSessionWorkingDirectory(session));
     if (!result.success) {
       return res.status(500).json({ error: result.error, stderr: result.stderr });
     }
@@ -280,7 +352,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const isStaged = req.query.staged === 'true';
-    const result = await gitService.diffNumstat(session.ptyManager.workingDir, isStaged);
+    const result = await gitService.diffNumstat(getSessionWorkingDirectory(session), isStaged);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -291,7 +363,7 @@ async function webCommand(options) {
     const isStaged = req.query.staged === 'true';
     const filePath = req.query.path;
     if (!filePath) return res.status(400).json({ error: 'Missing file path' });
-    const result = await gitService.diffFile(session.ptyManager.workingDir, filePath, isStaged);
+    const result = await gitService.diffFile(getSessionWorkingDirectory(session), filePath, isStaged);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -301,7 +373,7 @@ async function webCommand(options) {
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const filePath = req.query.path || '';
     if (!filePath) return res.status(400).json({ error: 'Missing file path' });
-    const cwd = session.ptyManager.workingDir || '';
+    const cwd = getSessionWorkingDirectory(session);
     try {
       const content = workspaceService.readFile(cwd, filePath);
       res.json({ success: true, content });
@@ -315,7 +387,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const dirPath = req.query.path || '';
-    const cwd = session.ptyManager.workingDir || '';
+    const cwd = getSessionWorkingDirectory(session);
     try {
       const files = await workspaceService.listDirectory(cwd, dirPath);
       res.json({ success: true, files });
@@ -359,15 +431,20 @@ async function webCommand(options) {
       session.resizeOwner = ws;
     }
     sessionManager.logWsConnected(sessionId, req);
+
+    if (session.kind === 'claude-structured') {
+      ws.send(JSON.stringify({ type: 'claude-snapshot', snapshot: sessionManager.getClaudeSnapshot(sessionId) }));
+    }
     
     // Send catchup output. TUI tools may skip the raw circular buffer, so fall
     // back to the rendered/text history snapshot instead of reconnecting blank.
     const catchup = sessionManager.getCatchupOutput(sessionId);
-    ws.needsTuiRedraw = ['antigravity', 'claude-code', 'codex', 'gemini'].includes(session.tool.key)
+    ws.needsTuiRedraw = session.kind !== 'claude-structured'
+      && ['antigravity', 'claude-code', 'codex'].includes(session.tool.key)
       && (isReconnect || (catchup && catchup.source === 'rendered-history'));
     if (ws.needsTuiRedraw) {
       ws.send(JSON.stringify({ type: 'reset' }));
-    } else if (catchup && catchup.data) {
+    } else if (session.kind !== 'claude-structured' && catchup && catchup.data) {
       sessionManager.logWsCatchupOutput(sessionId, catchup);
       ws.send(JSON.stringify({ type: 'output', data: catchup.data }));
     }
@@ -378,6 +455,21 @@ async function webCommand(options) {
         if (payload.type === 'input') {
           session.write(payload.data);
         }
+        if (payload.type === 'claude-input') {
+          sessionManager.sendClaudeInput(sessionId, payload.text || '');
+        }
+        if (payload.type === 'claude-permission') {
+          sessionManager.respondClaudePermission(sessionId, payload.id, Boolean(payload.approved));
+        }
+        if (payload.type === 'claude-settings') {
+          sessionManager.updateClaudeSettings(sessionId, payload.settings || {});
+        }
+        if (payload.type === 'claude-abort') {
+          sessionManager.abortClaude(sessionId);
+        }
+        if (payload.type === 'claude-resume') {
+          sessionManager.resumeClaude(sessionId, payload.resumeSessionId || '');
+        }
         if (payload.type === 'resize' && session.resizeOwner === ws) {
           sessionManager.logWsResize(sessionId, payload.cols, payload.rows);
           if (ws.needsTuiRedraw) {