glad-web 1.0.7

package/lib/commands/web.js

@@ -0,0 +1,454 @@
+const express = require('express');
+const http = require('http');
+const { WebSocketServer } = require('ws');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const zlib = require('zlib');
+const chalk = require('chalk');
+const { getAllTools } = require('../ai-tools/registry');
+const { GitService } = require('../git/service');
+const WorkspaceService = require('../workspace/service');
+const SessionManager = require('../session/session-manager');
+
+function sendCompressedJson(req, res, payload) {
+  const body = Buffer.from(JSON.stringify(payload), 'utf8');
+  const acceptEncoding = req.headers['accept-encoding'] || '';
+
+  if (/\bgzip\b/.test(acceptEncoding)) {
+    zlib.gzip(body, { level: 6 }, (error, compressed) => {
+      if (error) {
+        res.type('application/json').send(body);
+        return;
+      }
+      res.setHeader('Content-Type', 'application/json; charset=utf-8');
+      res.setHeader('Content-Encoding', 'gzip');
+      res.setHeader('Vary', 'Accept-Encoding');
+      res.setHeader('Content-Length', compressed.length);
+      res.send(compressed);
+    });
+    return;
+  }
+
+  res.type('application/json').send(body);
+}
+
+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');
+
+async function webCommand(options) {
+  const port = parseInt(options.port) || 3000;
+  const debugHistoryEnabled = process.env.DEBUG_SESSION_HISTORY === '1';
+  const defaultRenderedTools = getAllTools().map(tool => tool.key).join(',');
+  const renderHistoryTools = new Set(
+    String(process.env.HISTORY_RENDER_TOOLS || defaultRenderedTools)
+      .split(',')
+      .map(value => value.trim().toLowerCase())
+      .filter(Boolean)
+  );
+  const app = express();
+  app.use((req, res, next) => {
+    res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
+    res.setHeader('Pragma', 'no-cache');
+    res.setHeader('Expires', '0');
+    next();
+  });
+  app.use(express.json());
+  const server = http.createServer(app);
+  const wss = new WebSocketServer({
+    server,
+    perMessageDeflate: {
+      threshold: 1024,
+      zlibDeflateOptions: { level: 3 },
+      zlibInflateOptions: {},
+      clientNoContextTakeover: true,
+      serverNoContextTakeover: true
+    }
+  });
+  
+  // Use directory from options if provided, otherwise default to current working directory
+  const baseDir = options.directory ? path.resolve(process.cwd(), options.directory) : process.cwd();
+  
+  const jobStore = new JobStore();
+  const gitService = new GitService();
+  const workspaceService = new WorkspaceService({ gitService });
+  const sessionManager = new SessionManager({
+    baseDir,
+    renderHistoryTools,
+    debugHistoryEnabled,
+    logger,
+    hasConnectedSessionClient
+  });
+  sessionManager.on('output', ({ sessionId, data }) => {
+    broadcastToSession(sessionId, { type: 'output', data });
+  });
+  sessionManager.on('exit', ({ sessionId }) => {
+    broadcastToSession(sessionId, { type: 'exit' });
+  });
+
+  const jobRunner = new JobRunner({
+    createSession: input => sessionManager.create(input),
+    getJob: id => jobStore.get(id),
+    updateJob: (id, patch) => jobStore.patchRuntime(id, patch),
+    logger
+  });
+  const schedulerService = new SchedulerService({ jobStore, jobRunner, logger });
+  schedulerService.start();
+
+  // API: Get all supported and installed tools
+  app.get('/api/tools', async (req, res) => {
+    try {
+      const tools = await detectInstalledTools();
+      res.json(tools);
+    } catch (e) {
+      res.status(500).json({ error: 'Failed to detect tools' });
+    }
+  });
+
+  // API: Get web UI runtime configuration
+  app.get('/api/config', (req, res) => {
+    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 });
+    }
+  });
+
+  // API: List all active sessions
+  app.get('/api/sessions', (req, res) => {
+    logger.debug('API: GET /api/sessions');
+    res.json(sessionManager.list());
+  });
+
+  // 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 });
+      res.json({ id: session.id });
+    } catch (e) {
+      logger.error(`API: POST /api/sessions failed: ${e.message}`);
+      res.status(e.statusCode || 500).json({ error: e.message });
+    }
+  });
+
+  // API: Plain text terminal history for mobile-friendly reading
+  app.get('/api/sessions/:id/history', (req, res) => {
+    const history = sessionManager.getHistory(req.params.id);
+    if (!history) return res.status(404).json({ error: 'Session not found' });
+    sessionManager.logHistoryRequest(req.params.id, req);
+    sendCompressedJson(req, res, history);
+  });
+
+  // API: Rename session
+  app.patch('/api/sessions/:id', (req, res) => {
+    const session = sessionManager.rename(req.params.id, req.body.name);
+    if (session) {
+      res.json({ success: true, name: session.name });
+    } else {
+      res.status(404).json({ error: 'Session not found' });
+    }
+  });
+
+  // API: Mark a session completion indicator as read
+  app.post('/api/sessions/:id/completion/read', (req, res) => {
+    const session = sessionManager.markCompletionRead(req.params.id);
+    if (!session) return res.status(404).json({ error: 'Session not found' });
+    res.json({ success: true });
+  });
+
+  // API: Delete/Kill session
+  app.delete('/api/sessions/:id', (req, res) => {
+    sessionManager.kill(req.params.id);
+    res.json({ success: true });
+  });
+
+  app.get('/api/sessions/:id/debug', (req, res) => {
+    const diagnostics = sessionManager.getDiagnostics(req.params.id);
+    if (!diagnostics) return res.status(404).json({ error: 'Session not found' });
+    res.json({ success: true, diagnostics });
+  });
+
+  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(session.ptyManager.workingDir, 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(session.ptyManager.workingDir, 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(session.ptyManager.workingDir);
+    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(session.ptyManager.workingDir, 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(session.ptyManager.workingDir, 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 = session.ptyManager.workingDir || '';
+    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 });
+    }
+  });
+
+  // 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 = session.ptyManager.workingDir || '';
+    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 });
+    }
+  });
+
+
+  function broadcastToSession(sessionId, message) {
+    const msgStr = JSON.stringify(message);
+    wss.clients.forEach(client => {
+      if (client.readyState === 1 && client.sessionId === sessionId) {
+        client.send(msgStr);
+      }
+    });
+  }
+
+  function hasConnectedSessionClient(sessionId) {
+    for (const client of wss.clients) {
+      if (client.readyState === 1 && client.sessionId === sessionId) return true;
+    }
+    return false;
+  }
+
+  // WebSocket: Terminal I/O
+  wss.on('connection', (ws, req) => {
+    const url = new URL(req.url, 'http://' + req.headers.host);
+    const sessionId = url.searchParams.get('sessionId');
+    
+    if (!sessionId || !sessionManager.has(sessionId)) {
+      ws.close(4001, 'Invalid Session ID');
+      return;
+    }
+
+    ws.sessionId = sessionId;
+    const session = sessionManager.get(sessionId);
+    if (!session.resizeOwner) {
+      session.resizeOwner = ws;
+    }
+    sessionManager.logWsConnected(sessionId, req);
+    
+    // Send catchup buffer
+    const history = session.buffer.getAfter(0);
+    if (history.length > 0) {
+      sessionManager.logWsCatchup(sessionId, history);
+      ws.send(JSON.stringify({ type: 'output', data: history.map(m => m.data).join('') }));
+    }
+
+    ws.on('message', (message) => {
+      try {
+        const payload = JSON.parse(message);
+        if (payload.type === 'input') {
+          session.write(payload.data);
+        }
+        if (payload.type === 'resize' && session.resizeOwner === ws) {
+          sessionManager.logWsResize(sessionId, payload.cols, payload.rows);
+          sessionManager.resize(sessionId, payload.cols, payload.rows);
+        }
+      } catch (e) {
+        logger.error('WS Message Error: ' + e.message);
+      }
+    });
+
+    ws.on('close', () => {
+      sessionManager.logWsClosed(sessionId);
+      if (session.resizeOwner !== ws) return;
+      session.resizeOwner = null;
+      for (const client of wss.clients) {
+        if (client.readyState === 1 && client.sessionId === sessionId) {
+          session.resizeOwner = client;
+          break;
+        }
+      }
+    });
+  });
+
+  // Frontend routes
+  app.get('/', (req, res) => {
+    try {
+      const htmlPath = path.join(__dirname, '../web/index.html');
+      const html = fs.readFileSync(htmlPath, 'utf8');
+      res.send(html);
+    } catch (e) {
+      res.status(500).send('UI not found');
+    }
+  });
+
+  app.get('/gitgraph.js', (req, res) => {
+    try {
+      res.sendFile(path.join(__dirname, '../web/gitgraph.js'));
+    } catch (e) {
+      res.status(404).send('Not found');
+    }
+  });
+
+  app.get('/logo.svg', (req, res) => {
+    try {
+      res.sendFile(path.resolve(__dirname, '../../assets/logo.svg'));
+    } catch (e) {
+      res.status(404).send('Not found');
+    }
+  });
+
+  app.get('/manifest.json', (req, res) => res.json({ 
+    name: "Glad Web", 
+    short_name: "Glad", 
+    start_url: "/", 
+    display: "standalone",
+    background_color: "#000000",
+    theme_color: "#007aff",
+    icons: [
+      {
+        src: "/logo.svg",
+        sizes: "any",
+        type: "image/svg+xml"
+      }
+    ]
+  }));
+
+  server.listen(port, '0.0.0.0', () => {
+    const interfaces = os.networkInterfaces();
+    let networkInfo = '';
+    for (const name of Object.keys(interfaces)) {
+      for (const iface of interfaces[name]) {
+        if (iface.family === 'IPv4' && !iface.internal) {
+          networkInfo += `\n   ➜  Network: http://${iface.address}:${port}`;
+        }
+      }
+    }
+    console.log(chalk.green(`\n🚀 Glad Web Server is running!`));
+    console.log(chalk.cyan(`   ➜  Local:   http://localhost:${port}${networkInfo}\n`));
+    console.log(chalk.gray(`   ➜  Project: ${baseDir}\n`));
+    console.log(chalk.gray(`   ➜  History Render Tools: ${Array.from(renderHistoryTools).join(', ') || '(none)'}\n`));
+    console.log(chalk.gray(`Tips: Access from your phone via the Network URL above.\n`));
+  });
+
+  process.on('SIGINT', () => { 
+    schedulerService.stop();
+    sessionManager.killAll();
+    process.exit(0); 
+  });
+}
+
+module.exports = webCommand;

package/lib/config/constants.js

@@ -0,0 +1,17 @@
+/**
+ * Application constants
+ *
+ * All magic numbers and configuration values should be defined here.
+ */
+
+module.exports = {
+  // Network & WebSocket
+  HEARTBEAT_TIMEOUT: 13000,        // 13s - detect network loss (server pings every ~5s)
+  CLI_IDLE_THRESHOLD: 15000,       // 15s - no PTY output = CLI is idle
+
+  // Buffer
+  DEFAULT_BUFFER_SIZE: 100000,     // 100KB - circular buffer max size
+
+  // Reconnection
+  MAX_RECONNECT_ATTEMPTS: 10,      // Max WebSocket reconnection attempts
+};

package/lib/config/manager.js

@@ -0,0 +1,71 @@
+const Conf = require('conf');
+const path = require('path');
+const os = require('os');
+
+// Config schema - only user preferences, no environment config
+const schema = {
+  defaultAI: {
+    type: 'string',
+    default: ''
+  },
+  version: {
+    type: 'string',
+    default: '1.0.0'
+  },
+  lastUpdated: {
+    type: 'string',
+    default: ''
+  }
+};
+
+// Create config instance
+const config = new Conf({
+  projectName: 'glad',
+  cwd: path.join(os.homedir(), '.glad'),
+  configName: 'config',
+  schema
+});
+
+// Get config value
+function getConfig(key) {
+  if (key) {
+    return config.get(key);
+  }
+  return config.store;
+}
+
+// Set config value
+function setConfig(key, value) {
+  config.set(key, value);
+  config.set('lastUpdated', new Date().toISOString());
+}
+
+// Get default AI tool
+function getDefaultAI() {
+  const value = config.get('defaultAI');
+  return value || null;
+}
+
+// Set default AI tool
+function setDefaultAI(tool) {
+  setConfig('defaultAI', tool);
+}
+
+// Get config file path
+function getConfigPath() {
+  return config.path;
+}
+
+// Reset config to defaults
+function resetConfig() {
+  config.clear();
+}
+
+module.exports = {
+  getConfig,
+  setConfig,
+  getDefaultAI,
+  setDefaultAI,
+  getConfigPath,
+  resetConfig
+};

package/lib/git/service.js

@@ -0,0 +1,79 @@
+const { execFile } = require('child_process');
+
+function execFilePromise(file, args, cwd) {
+  return new Promise((resolve) => {
+    execFile(file, args, { cwd, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      resolve({ success: !error, error: error?.message, stdout, stderr });
+    });
+  });
+}
+
+function parseGitStatusZ(stdout) {
+  if (!stdout) return [];
+
+  const entries = [];
+  const records = stdout.split('\0').filter(Boolean);
+
+  for (let i = 0; i < records.length; i++) {
+    const record = records[i];
+    if (record.length < 3) continue;
+
+    const status = record.substring(0, 2);
+    const path = record.substring(3);
+    const entry = { path, status };
+
+    if ((status.includes('R') || status.includes('C')) && i + 1 < records.length) {
+      entry.originalPath = records[++i];
+    }
+
+    entries.push(entry);
+  }
+
+  return entries;
+}
+
+class GitService {
+  async show(cwd, hash) {
+    return execFilePromise('git', ['show', '--format=fuller', '--stat', '-p', hash], cwd);
+  }
+
+  async log(cwd, maxCount = 100) {
+    const count = Number.parseInt(maxCount, 10) || 100;
+    const result = await execFilePromise(
+      'git',
+      ['log', '--all', '--date-order', `--max-count=${count}`, '--pretty=format:%h|%p|%d|%s|%an|%ar'],
+      cwd
+    );
+    if (!result.success) return result;
+
+    const commits = result.stdout.split('\n').filter(Boolean).map(line => {
+      const [hash, parents, refs, subject, author, time] = line.split('|');
+      return { hash, parents: parents ? parents.split(' ') : [], refs: refs ? refs.trim() : '', subject, author, time };
+    });
+    return { ...result, commits };
+  }
+
+  async status(cwd) {
+    const result = await execFilePromise('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all'], cwd);
+    if (!result.success) return result;
+    return { ...result, files: parseGitStatusZ(result.stdout) };
+  }
+
+  diffNumstat(cwd, isStaged = false) {
+    const args = isStaged ? ['diff', '--cached', '--numstat'] : ['diff', '--numstat'];
+    return execFilePromise('git', args, cwd);
+  }
+
+  diffFile(cwd, filePath, isStaged = false) {
+    const args = isStaged
+      ? ['diff', '--cached', '--no-ext-diff', '--', filePath]
+      : ['diff', '--no-ext-diff', '--', filePath];
+    return execFilePromise('git', args, cwd);
+  }
+}
+
+module.exports = {
+  GitService,
+  execFilePromise,
+  parseGitStatusZ
+};