glad-web 1.0.28 → 1.0.30

package/lib/commands/web.js

@@ -43,6 +43,9 @@ const { JobStore } = require('../schedule/job-store');
 const JobRunner = require('../schedule/job-runner');
 const SchedulerService = require('../schedule/scheduler-service');
 const { getClaudeRuntimeConfig } = require('../claude/config');
+const registerScheduleRoutes = require('../server/routes/schedules');
+const registerWorkspaceRoutes = require('../server/routes/workspace');
+const registerProviderRoutes = require('../server/routes/providers');
 
 async function webCommand(options) {
   const port = parseInt(options.port) || 3000;
@@ -124,65 +127,7 @@ async function webCommand(options) {
     res.json({ defaultWorkingDirectory: baseDir });
   });
 
-  // API: Scheduled tasks
-  app.get('/api/schedules', (req, res) => {
-    res.json(jobStore.list());
-  });
-
-  app.post('/api/schedules', (req, res) => {
-    try {
-      const job = jobStore.create(req.body || {});
-      res.json(job);
-    } catch (e) {
-      res.status(400).json({ error: e.message });
-    }
-  });
-
-  app.get('/api/schedules/:id', (req, res) => {
-    const job = jobStore.get(req.params.id);
-    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
-    res.json(job);
-  });
-
-  app.patch('/api/schedules/:id', (req, res) => {
-    const job = jobStore.update(req.params.id, req.body || {});
-    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
-    res.json(job);
-  });
-
-  app.patch('/api/schedules/:id/enabled', (req, res) => {
-    const job = jobStore.patchRuntime(req.params.id, { enabled: Boolean(req.body && req.body.enabled) });
-    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
-    res.json(job);
-  });
-
-  app.delete('/api/schedules/:id', (req, res) => {
-    res.json({ success: jobStore.delete(req.params.id) });
-  });
-
-  app.post('/api/schedules/:id/duplicate', (req, res) => {
-    const job = jobStore.duplicate(req.params.id);
-    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
-    res.json(job);
-  });
-
-  app.post('/api/schedules/:id/run', async (req, res) => {
-    try {
-      const result = await jobRunner.run(req.params.id, { manual: false });
-      res.json(result);
-    } catch (e) {
-      res.status(400).json({ error: e.message });
-    }
-  });
-
-  app.post('/api/schedules/:id/simulate', async (req, res) => {
-    try {
-      const result = await jobRunner.run(req.params.id, { manual: true, background: true });
-      res.json(result);
-    } catch (e) {
-      res.status(400).json({ error: e.message });
-    }
-  });
+  registerScheduleRoutes(app, { jobStore, jobRunner });
 
   // API: List all active sessions
   app.get('/api/sessions', (req, res) => {
@@ -267,10 +212,10 @@ async function webCommand(options) {
   });
 
   // Browser images are stored only in a private, per-session temporary directory.
-  // Codex receives the resulting local path through its app-server protocol.
+  // Structured providers receive either a local path or validated base64 content.
   app.post('/api/sessions/:id/attachments/images', express.raw({ type: () => true, limit: '50mb' }), async (req, res) => {
     try {
-      const attachment = await sessionManager.storeCodexImageAttachment(req.params.id, req.body);
+      const attachment = await sessionManager.storeImageAttachment(req.params.id, req.body);
       res.status(201).json({ success: true, attachment });
     } catch (e) {
       res.status(e.statusCode || 500).json({ error: e.message });
@@ -281,7 +226,7 @@ async function webCommand(options) {
   // Small sequential chunks let the browser report progress from server receipts.
   app.post('/api/sessions/:id/attachments/images/chunks', express.raw({ type: () => true, limit: '1mb' }), async (req, res) => {
     try {
-      const result = await sessionManager.appendCodexImageChunk(req.params.id, {
+      const result = await sessionManager.appendImageChunk(req.params.id, {
         uploadId: req.get('X-Glad-Upload-Id'),
         chunkIndex: req.get('X-Glad-Chunk-Index'),
         chunkTotal: req.get('X-Glad-Chunk-Total')
@@ -294,7 +239,7 @@ async function webCommand(options) {
 
   app.delete('/api/sessions/:id/attachments/images/uploads/:uploadId', async (req, res) => {
     try {
-      const removed = await sessionManager.discardCodexImageUpload(req.params.id, req.params.uploadId);
+      const removed = await sessionManager.discardImageUpload(req.params.id, req.params.uploadId);
       res.json({ success: true, removed });
     } catch (e) {
       res.status(e.statusCode || 500).json({ error: e.message });
@@ -303,7 +248,7 @@ async function webCommand(options) {
 
   app.delete('/api/sessions/:id/attachments/images/:attachmentId', async (req, res) => {
     try {
-      const removed = await sessionManager.discardCodexImageAttachment(req.params.id, req.params.attachmentId);
+      const removed = await sessionManager.discardImageAttachment(req.params.id, req.params.attachmentId);
       if (!removed) return res.status(404).json({ error: 'Image attachment not found' });
       res.json({ success: true });
     } catch (e) {
@@ -323,173 +268,13 @@ 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.patch('/api/sessions/:id/codex-settings', async (req, res) => {
-    try {
-      const state = await sessionManager.updateCodexSettings(req.params.id, req.body || {});
-      if (!state) return res.status(404).json({ error: 'Codex session not found' });
-      res.json({ success: true, state });
-    } catch (e) { res.status(400).json({ error: e.message }); }
-  });
-
-  app.get('/api/sessions/:id/codex-resume-threads', async (req, res) => {
-    try {
-      const items = await sessionManager.listCodexResumeThreads(req.params.id);
-      if (!items) return res.status(404).json({ error: 'Codex session not found' });
-      res.json({ success: true, items });
-    } catch (e) { res.status(400).json({ error: e.message }); }
-  });
-
-  app.post('/api/sessions/:id/codex-abort', (req, res) => {
-    const success = sessionManager.abortCodex(req.params.id);
-    if (!success) return res.status(409).json({ error: 'Codex session is idle or unavailable' });
-    res.json({ success: true });
-  });
-
-  app.post('/api/sessions/:id/codex-resume', async (req, res) => {
-    try {
-      const success = await sessionManager.resumeCodex(req.params.id, req.body && req.body.threadId);
-      if (!success) return res.status(409).json({ error: 'Codex session is busy or no thread is available' });
-      res.json({ success: true });
-    } catch (e) { res.status(400).json({ error: e.message }); }
-  });
-
-  app.post('/api/sessions/:id/codex-fork', async (req, res) => {
-    try {
-      const session = await sessionManager.forkCodex(req.params.id, req.body && req.body.threadId);
-      if (!session) return res.status(404).json({ error: 'Codex session not found' });
-      res.json({ success: true, id: session.id, name: session.name, threadId: session.threadId });
-    } catch (e) { res.status(e.statusCode || 400).json({ error: e.message }); }
-  });
-
-  app.post('/api/sessions/:id/codex-presentation', async (req, res) => {
-    const presentation = req.body && req.body.presentation;
-    if (!['terminal', 'structured'].includes(presentation)) return res.status(400).json({ error: 'Invalid presentation' });
-    try {
-      const success = await sessionManager.switchCodexPresentation(req.params.id, presentation);
-      if (!success) return res.status(409).json({ error: 'Codex session cannot switch presentation now' });
-      res.json({ success: true });
-    } catch (e) { res.status(409).json({ error: e.message }); }
-  });
-
-  app.post('/api/debug/client-log', (req, res) => {
-    const { sessionId, event, payload } = req.body || {};
-    sessionManager.logClientDebug(sessionId, event, payload);
-    res.json({ success: true });
-  });
-
-  // API: Git Show
-  app.get('/api/sessions/:id/git-show/:hash', async (req, res) => {
-    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(getSessionWorkingDirectory(session), hash);
-    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
-  });
-
-  // API: Git Branch Name for Commit
-  app.get('/api/sessions/:id/git-branch/:hash', async (req, res) => {
-    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(getSessionWorkingDirectory(session), hash);
-    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
-  });
-
-  // API: Git Log
-  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(getSessionWorkingDirectory(session), req.query.maxCount);
-    if (!result.success) {
-      return res.status(500).json({ error: result.error, stderr: result.stderr });
-    }
-    res.json({ success: true, commits: result.commits });
-  });
-
-  // API: Git Status
-  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(getSessionWorkingDirectory(session));
-    if (!result.success) {
-      return res.status(500).json({ error: result.error, stderr: result.stderr });
-    }
-    res.json({ success: true, files: result.files });
-  });
-
-  // API: Git Diff Numstat (unstaged and staged)
-  app.get('/api/sessions/:id/git-diff-numstat', async (req, res) => {
-    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(getSessionWorkingDirectory(session), isStaged);
-    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
-  });
-
-  // API: Git Diff File
-  app.get('/api/sessions/:id/git-diff-file', async (req, res) => {
-    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 filePath = req.query.path;
-    if (!filePath) return res.status(400).json({ error: 'Missing file path' });
-    const result = await gitService.diffFile(getSessionWorkingDirectory(session), filePath, isStaged);
-    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
-  });
-
-  // API: Get File Content
-  app.get('/api/sessions/:id/file', async (req, res) => {
-    const session = sessionManager.get(req.params.id);
-    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 = getSessionWorkingDirectory(session);
-    try {
-      const content = workspaceService.readFile(cwd, filePath);
-      res.json({ success: true, content });
-    } catch (e) {
-      res.status(e.statusCode || 200).json({ success: false, error: e.message });
-    }
-  });
+  registerProviderRoutes(app, { sessionManager });
 
-  // API: Get Directory Contents
-  app.get('/api/sessions/:id/fs/dir', async (req, res) => {
-    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 = getSessionWorkingDirectory(session);
-    try {
-      const files = await workspaceService.listDirectory(cwd, dirPath);
-      res.json({ success: true, files });
-    } catch (e) {
-      res.status(e.statusCode || 200).json({ success: false, error: e.message });
-    }
+  registerWorkspaceRoutes(app, {
+    sessionManager,
+    gitService,
+    workspaceService,
+    getWorkingDirectory: getSessionWorkingDirectory
   });
 
 
@@ -555,7 +340,8 @@ async function webCommand(options) {
           session.write(payload.data);
         }
         if (payload.type === 'claude-input') {
-          sessionManager.sendClaudeInput(sessionId, payload.text || '');
+          sessionManager.sendClaudeInput(sessionId, payload.text || '', payload.attachmentIds || [])
+            .catch(error => logger.error(`Claude input error: ${error.message}`));
         }
         if (payload.type === 'claude-permission') {
           sessionManager.respondClaudePermission(sessionId, payload.id, Boolean(payload.approved), payload.action || null);
@@ -563,6 +349,12 @@ async function webCommand(options) {
         if (payload.type === 'claude-settings') {
           sessionManager.updateClaudeSettings(sessionId, payload.settings || {});
         }
+        if (payload.type === 'claude-usage') {
+          sessionManager.showClaudeUsage(sessionId).catch(error => logger.error(`Claude usage error: ${error.message}`));
+        }
+        if (payload.type === 'claude-context') {
+          sessionManager.showClaudeContext(sessionId).catch(error => logger.error(`Claude context error: ${error.message}`));
+        }
         if (payload.type === 'claude-abort') {
           sessionManager.abortClaude(sessionId);
         }
@@ -618,6 +410,9 @@ async function webCommand(options) {
   // Frontend routes
   const assetsDir = path.resolve(__dirname, '../../assets');
   const webDir = path.join(__dirname, '../web');
+  const xtermScript = require.resolve('@xterm/xterm');
+  const xtermStyles = path.resolve(path.dirname(xtermScript), '../css/xterm.css');
+  const fitAddonScript = require.resolve('@xterm/addon-fit');
 
   const sendLogo = (req, res) => {
     res.sendFile('logo.svg', { root: assetsDir }, error => {
@@ -635,11 +430,34 @@ async function webCommand(options) {
     }
   });
 
-  app.get(['/gitgraph.js', /.*\/gitgraph\.js$/], (req, res) => {
-    res.sendFile('gitgraph.js', { root: webDir }, error => {
+  const sendWebAsset = assetName => (req, res) => {
+    res.sendFile(assetName, { root: webDir }, error => {
       if (error && !res.headersSent) res.status(404).send('Not found');
     });
-  });
+  };
+
+  const webAssets = [
+    'gitgraph.js',
+    'styles.css',
+    'core.js',
+    'claude.js',
+    'schedules.js',
+    'shell.js',
+    'codex.js',
+    'session.js',
+    'composer.js',
+    'timed-inputs.js',
+    'terminal-scroll.js',
+    'git.js'
+  ];
+  for (const assetName of webAssets) {
+    const escapedName = assetName.replace('.', '\\.');
+    app.get([`/${assetName}`, new RegExp(`.*\\/${escapedName}$`)], sendWebAsset(assetName));
+  }
+
+  app.get('/vendor/xterm.js', (req, res) => res.sendFile(xtermScript));
+  app.get('/vendor/xterm.css', (req, res) => res.sendFile(xtermStyles));
+  app.get('/vendor/xterm-addon-fit.js', (req, res) => res.sendFile(fitAddonScript));
 
   app.get(['/logo.svg', /.*\/logo\.svg$/], sendLogo);
 

package/lib/server/routes/providers.js

@@ -0,0 +1,103 @@
+function registerProviderRoutes(app, { sessionManager }) {
+  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?.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/sessions/:id/claude-fork', async (req, res) => {
+    try {
+      const result = await sessionManager.forkClaude(req.params.id, req.body?.claudeSessionId);
+      if (!result) return res.status(404).json({ error: 'Claude session not found' });
+      res.json({ success: true, ...result });
+    } catch (error) {
+      res.status(error.statusCode || 400).json({ error: error.message });
+    }
+  });
+
+  app.patch('/api/sessions/:id/codex-settings', async (req, res) => {
+    try {
+      const state = await sessionManager.updateCodexSettings(req.params.id, req.body || {});
+      if (!state) return res.status(404).json({ error: 'Codex session not found' });
+      res.json({ success: true, state });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  });
+
+  app.get('/api/sessions/:id/codex-resume-threads', async (req, res) => {
+    try {
+      const items = await sessionManager.listCodexResumeThreads(req.params.id);
+      if (!items) return res.status(404).json({ error: 'Codex session not found' });
+      res.json({ success: true, items });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  });
+
+  app.post('/api/sessions/:id/codex-abort', (req, res) => {
+    const success = sessionManager.abortCodex(req.params.id);
+    if (!success) return res.status(409).json({ error: 'Codex session is idle or unavailable' });
+    res.json({ success: true });
+  });
+
+  app.post('/api/sessions/:id/codex-resume', async (req, res) => {
+    try {
+      const success = await sessionManager.resumeCodex(req.params.id, req.body?.threadId);
+      if (!success) return res.status(409).json({ error: 'Codex session is busy or no thread is available' });
+      res.json({ success: true });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  });
+
+  app.post('/api/sessions/:id/codex-fork', async (req, res) => {
+    try {
+      const session = await sessionManager.forkCodex(req.params.id, req.body?.threadId);
+      if (!session) return res.status(404).json({ error: 'Codex session not found' });
+      res.json({ success: true, id: session.id, name: session.name, threadId: session.threadId });
+    } catch (error) {
+      res.status(error.statusCode || 400).json({ error: error.message });
+    }
+  });
+
+  app.post('/api/sessions/:id/codex-presentation', async (req, res) => {
+    const presentation = req.body?.presentation;
+    if (!['terminal', 'structured'].includes(presentation)) return res.status(400).json({ error: 'Invalid presentation' });
+    try {
+      const success = await sessionManager.switchCodexPresentation(req.params.id, presentation);
+      if (!success) return res.status(409).json({ error: 'Codex session cannot switch presentation now' });
+      res.json({ success: true });
+    } catch (error) {
+      res.status(409).json({ error: error.message });
+    }
+  });
+
+  app.post('/api/debug/client-log', (req, res) => {
+    const { sessionId, event, payload } = req.body || {};
+    sessionManager.logClientDebug(sessionId, event, payload);
+    res.json({ success: true });
+  });
+}
+
+module.exports = registerProviderRoutes;

package/lib/server/routes/schedules.js

@@ -0,0 +1,54 @@
+function registerScheduleRoutes(app, { jobStore, jobRunner }) {
+  app.get('/api/schedules', (req, res) => {
+    res.json(jobStore.list());
+  });
+
+  app.post('/api/schedules', (req, res) => {
+    try {
+      res.json(jobStore.create(req.body || {}));
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  });
+
+  app.get('/api/schedules/:id', (req, res) => {
+    const job = jobStore.get(req.params.id);
+    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
+    res.json(job);
+  });
+
+  app.patch('/api/schedules/:id', (req, res) => {
+    const job = jobStore.update(req.params.id, req.body || {});
+    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
+    res.json(job);
+  });
+
+  app.patch('/api/schedules/:id/enabled', (req, res) => {
+    const job = jobStore.patchRuntime(req.params.id, { enabled: Boolean(req.body?.enabled) });
+    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
+    res.json(job);
+  });
+
+  app.delete('/api/schedules/:id', (req, res) => {
+    res.json({ success: jobStore.delete(req.params.id) });
+  });
+
+  app.post('/api/schedules/:id/duplicate', (req, res) => {
+    const job = jobStore.duplicate(req.params.id);
+    if (!job) return res.status(404).json({ error: 'Scheduled task not found' });
+    res.json(job);
+  });
+
+  const runJob = options => async (req, res) => {
+    try {
+      res.json(await jobRunner.run(req.params.id, options));
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  };
+
+  app.post('/api/schedules/:id/run', runJob({ manual: false }));
+  app.post('/api/schedules/:id/simulate', runJob({ manual: true, background: true }));
+}
+
+module.exports = registerScheduleRoutes;

package/lib/server/routes/workspace.js

@@ -0,0 +1,77 @@
+function registerWorkspaceRoutes(app, { sessionManager, gitService, workspaceService, getWorkingDirectory }) {
+  function getSession(req, res) {
+    const session = sessionManager.get(req.params.id);
+    if (!session) res.status(404).json({ error: 'Session not found' });
+    return session;
+  }
+
+  app.get('/api/sessions/:id/git-show/:hash', async (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    const result = await gitService.show(getWorkingDirectory(session), req.params.hash);
+    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
+  });
+
+  app.get('/api/sessions/:id/git-branch/:hash', async (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    const result = await gitService.nameRev(getWorkingDirectory(session), req.params.hash);
+    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
+  });
+
+  app.get('/api/sessions/:id/git-log', async (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    const result = await gitService.log(getWorkingDirectory(session), req.query.maxCount);
+    if (!result.success) return res.status(500).json({ error: result.error, stderr: result.stderr });
+    res.json({ success: true, commits: result.commits });
+  });
+
+  app.get('/api/sessions/:id/git-status', async (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    const result = await gitService.status(getWorkingDirectory(session));
+    if (!result.success) return res.status(500).json({ error: result.error, stderr: result.stderr });
+    res.json({ success: true, files: result.files });
+  });
+
+  app.get('/api/sessions/:id/git-diff-numstat', async (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    const result = await gitService.diffNumstat(getWorkingDirectory(session), req.query.staged === 'true');
+    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
+  });
+
+  app.get('/api/sessions/:id/git-diff-file', async (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    if (!req.query.path) return res.status(400).json({ error: 'Missing file path' });
+    const result = await gitService.diffFile(getWorkingDirectory(session), req.query.path, req.query.staged === 'true');
+    res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
+  });
+
+  app.get('/api/sessions/:id/file', (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    if (!req.query.path) return res.status(400).json({ error: 'Missing file path' });
+    try {
+      const content = workspaceService.readFile(getWorkingDirectory(session), req.query.path);
+      res.json({ success: true, content });
+    } catch (error) {
+      res.status(error.statusCode || 200).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/sessions/:id/fs/dir', async (req, res) => {
+    const session = getSession(req, res);
+    if (!session) return;
+    try {
+      const files = await workspaceService.listDirectory(getWorkingDirectory(session), req.query.path || '');
+      res.json({ success: true, files });
+    } catch (error) {
+      res.status(error.statusCode || 200).json({ success: false, error: error.message });
+    }
+  });
+}
+
+module.exports = registerWorkspaceRoutes;