glad-web 1.0.46 → 2.0.2

package/lib/schedule/job-runner.js

@@ -1,162 +0,0 @@
-const { sequenceForKey } = require('./key-sequences');
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-class SessionEndedError extends Error {
-  constructor() {
-    super('Session ended');
-    this.code = 'SESSION_ENDED';
-  }
-}
-
-class JobRunner {
-  constructor({ createSession, getJob, updateJob, logger }) {
-    this.createSession = createSession;
-    this.getJob = getJob;
-    this.updateJob = updateJob;
-    this.logger = logger;
-    this.running = new Set();
-  }
-
-  async run(jobId, options = {}) {
-    const job = this.getJob(jobId);
-    if (!job) throw new Error('Scheduled task not found');
-    if (this.running.has(job.id)) {
-      this.updateJob(job.id, {
-        lastRunAt: Date.now(),
-        lastRunStatus: 'skipped',
-        lastRunMessage: 'Previous run is still active'
-      });
-      return { skipped: true, reason: 'Previous run is still active' };
-    }
-
-    this.running.add(job.id);
-    this.updateJob(job.id, {
-      running: true,
-      lastRunAt: Date.now(),
-      lastRunStatus: options.manual ? 'manual-running' : 'running',
-      lastRunMessage: ''
-    });
-
-    let session = null;
-    try {
-      session = this.createSession({
-        toolKey: job.target.toolKey,
-        workingDirectory: job.target.workingDirectory,
-        name: `${job.name}${options.manual ? ' (Test)' : ''}`
-      });
-
-      this.updateJob(job.id, {
-        lastSessionId: session.id,
-        lastRunMessage: `Started session ${session.id}`
-      });
-
-      const execute = async () => {
-        try {
-          await sleep(1000);
-          await this.executeSteps(job, session);
-          this.updateJob(job.id, {
-            running: false,
-            lastRunStatus: options.manual ? 'manual-success' : 'success',
-            lastRunMessage: `Started session ${session.id}`,
-            lastSessionId: session.id
-          });
-        } catch (error) {
-          const ended = error && error.code === 'SESSION_ENDED';
-          if (!ended) this.logger?.error?.(`Scheduled task failed: ${error.message}`);
-          this.updateJob(job.id, {
-            running: false,
-            lastRunStatus: ended ? 'cancelled' : 'failed',
-            lastRunMessage: ended ? 'Session ended' : error.message,
-            lastSessionId: session?.id || null
-          });
-          if (!options.background) throw error;
-        } finally {
-          this.running.delete(job.id);
-          this.updateJob(job.id, { running: false });
-        }
-      };
-
-      if (options.background) {
-        execute();
-        return { success: true, sessionId: session.id };
-      }
-
-      await execute();
-      return { success: true, sessionId: session.id };
-    } catch (error) {
-      if (!session) {
-        this.running.delete(job.id);
-        this.updateJob(job.id, { running: false });
-      }
-      this.logger?.error?.(`Scheduled task failed: ${error.message}`);
-      this.updateJob(job.id, {
-        running: false,
-        lastRunStatus: 'failed',
-        lastRunMessage: error.message,
-        lastSessionId: session?.id || null
-      });
-      throw error;
-    }
-  }
-
-  async executeSteps(job, session) {
-    const modifiers = { ctrl: false, alt: false };
-
-    for (const step of job.steps || []) {
-      this.assertSessionRunning(session);
-      if (step.type === 'sleep') {
-        await this.sleepWhileRunning(session, Math.max(0, Number(step.seconds) || 0) * 1000);
-        continue;
-      }
-
-      if (step.type === 'sendText') {
-        if (!session.write(String(step.text || ''))) throw new SessionEndedError();
-        continue;
-      }
-
-      if (step.type === 'sendKey') {
-        if (!session.write(sequenceForKey(step.key, modifiers))) throw new SessionEndedError();
-        continue;
-      }
-
-      if (step.type === 'keyDown') {
-        const key = String(step.key || '').toLowerCase();
-        if (key === 'ctrl' || key === 'alt') modifiers[key] = true;
-        continue;
-      }
-
-      if (step.type === 'keyUp') {
-        const key = String(step.key || '').toLowerCase();
-        if (key === 'ctrl' || key === 'alt') modifiers[key] = false;
-        continue;
-      }
-
-      if (step.type === 'stop') break;
-
-      if (step.type === 'closeSession') {
-        session.kill?.();
-        break;
-      }
-    }
-  }
-
-  assertSessionRunning(session) {
-    if (session && typeof session.isRunning === 'function' && !session.isRunning()) {
-      throw new SessionEndedError();
-    }
-  }
-
-  async sleepWhileRunning(session, ms) {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
-      this.assertSessionRunning(session);
-      await sleep(Math.min(500, end - Date.now()));
-    }
-    this.assertSessionRunning(session);
-  }
-}
-
-module.exports = JobRunner;

package/lib/schedule/job-store.js

@@ -1,167 +0,0 @@
-const Conf = require('conf');
-const path = require('path');
-const os = require('os');
-const { v4: uuidv4 } = require('uuid');
-
-const config = new Conf({
-  projectName: 'glad',
-  cwd: path.join(os.homedir(), '.glad'),
-  configName: 'schedules'
-});
-
-function normalizeWeekdays(weekdays) {
-  const values = Array.isArray(weekdays) ? weekdays : [];
-  return Array.from(new Set(values.map(Number).filter(value => value >= 0 && value <= 6))).sort((a, b) => a - b);
-}
-
-function normalizeSteps(steps) {
-  const values = Array.isArray(steps) ? steps : [];
-  return values.map(step => {
-    const type = String(step.type || '').trim();
-    if (type === 'sleep') return { type, seconds: Math.max(0, Number(step.seconds) || 0) };
-    if (type === 'sendText') return { type, text: String(step.text || '') };
-    if (type === 'sendKey') return { type, key: String(step.key || 'enter') };
-    if (type === 'keyDown' || type === 'keyUp') return { type, key: String(step.key || '') };
-    if (type === 'stop' || type === 'closeSession') return { type };
-    return null;
-  }).filter(Boolean);
-}
-
-function computeNextRunAt(schedule, from = Date.now()) {
-  const weekdays = normalizeWeekdays(schedule && schedule.weekdays);
-  const time = String(schedule && schedule.time || '').trim();
-  const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(time);
-  if (!match || weekdays.length === 0) return null;
-
-  const hour = Number(match[1]);
-  const minute = Number(match[2]);
-  const start = new Date(from);
-
-  for (let offset = 0; offset <= 7; offset++) {
-    const candidate = new Date(start);
-    candidate.setDate(start.getDate() + offset);
-    candidate.setHours(hour, minute, 0, 0);
-    if (candidate.getTime() <= from) continue;
-    if (weekdays.includes(candidate.getDay())) return candidate.getTime();
-  }
-
-  return null;
-}
-
-function normalizeJob(input, existing = null, options = {}) {
-  const now = Date.now();
-  const schedule = input.schedule || {};
-  const target = input.target || {};
-  const hasStoredNextRunAt = existing && typeof existing.nextRunAt === 'number';
-  const job = {
-    id: existing?.id || input.id || uuidv4(),
-    name: String(input.name || existing?.name || 'Scheduled Task').trim() || 'Scheduled Task',
-    enabled: Boolean(input.enabled ?? existing?.enabled ?? true),
-    schedule: {
-      time: String(schedule.time || existing?.schedule?.time || '09:00'),
-      weekdays: normalizeWeekdays(schedule.weekdays ?? existing?.schedule?.weekdays ?? [1, 2, 3, 4, 5])
-    },
-    target: {
-      toolKey: String(target.toolKey || existing?.target?.toolKey || 'demo'),
-      workingDirectory: String(target.workingDirectory ?? existing?.target?.workingDirectory ?? '')
-    },
-    steps: normalizeSteps(input.steps ?? existing?.steps ?? []),
-    createdAt: existing?.createdAt || input.createdAt || now,
-    updatedAt: options.touch ? now : (existing?.updatedAt || input.updatedAt || now),
-    lastRunAt: existing?.lastRunAt || input.lastRunAt || null,
-    lastRunStatus: existing?.lastRunStatus || input.lastRunStatus || 'idle',
-    lastRunMessage: existing?.lastRunMessage || input.lastRunMessage || '',
-    lastSessionId: existing?.lastSessionId || input.lastSessionId || null,
-    running: Boolean(existing?.running || false)
-  };
-
-  if (options.recomputeNextRunAt || !hasStoredNextRunAt) {
-    job.nextRunAt = job.enabled ? computeNextRunAt(job.schedule, now) : null;
-  } else {
-    job.nextRunAt = existing.nextRunAt;
-  }
-
-  return job;
-}
-
-class JobStore {
-  list() {
-    return config.get('jobs', []).map(job => normalizeJob(job, job));
-  }
-
-  saveAll(jobs) {
-    config.set('jobs', jobs);
-  }
-
-  get(id) {
-    return this.list().find(job => job.id === id) || null;
-  }
-
-  create(input) {
-    const jobs = this.list();
-    const job = normalizeJob(input, null, { touch: true });
-    jobs.push(job);
-    this.saveAll(jobs);
-    return job;
-  }
-
-  update(id, input) {
-    const jobs = this.list();
-    const index = jobs.findIndex(job => job.id === id);
-    if (index === -1) return null;
-    const existing = jobs[index];
-    const nextSchedule = {
-      time: String(input.schedule?.time || existing.schedule?.time || '09:00'),
-      weekdays: normalizeWeekdays(input.schedule?.weekdays ?? existing.schedule?.weekdays ?? [1, 2, 3, 4, 5])
-    };
-    const scheduleChanged = JSON.stringify(nextSchedule) !== JSON.stringify(existing.schedule);
-    const enabledChanged = Boolean(input.enabled ?? existing.enabled ?? true) !== Boolean(existing.enabled);
-    jobs[index] = normalizeJob(input, existing, {
-      touch: true,
-      recomputeNextRunAt: scheduleChanged || enabledChanged
-    });
-    this.saveAll(jobs);
-    return jobs[index];
-  }
-
-  patchRuntime(id, patch) {
-    const jobs = this.list();
-    const index = jobs.findIndex(job => job.id === id);
-    if (index === -1) return null;
-    jobs[index] = { ...jobs[index], ...patch, updatedAt: Date.now() };
-    if ('enabled' in patch || 'lastRunAt' in patch || 'schedule' in patch) {
-      jobs[index].nextRunAt = jobs[index].enabled ? computeNextRunAt(jobs[index].schedule) : null;
-    }
-    this.saveAll(jobs);
-    return jobs[index];
-  }
-
-  delete(id) {
-    const jobs = this.list();
-    const next = jobs.filter(job => job.id !== id);
-    this.saveAll(next);
-    return next.length !== jobs.length;
-  }
-
-  duplicate(id) {
-    const source = this.get(id);
-    if (!source) return null;
-    return this.create({
-      ...source,
-      id: uuidv4(),
-      name: `${source.name} Copy`,
-      enabled: false,
-      lastRunAt: null,
-      lastRunStatus: 'idle',
-      lastRunMessage: '',
-      lastSessionId: null,
-      running: false
-    });
-  }
-}
-
-module.exports = {
-  JobStore,
-  computeNextRunAt,
-  normalizeJob
-};

package/lib/schedule/key-sequences.js

@@ -1,49 +0,0 @@
-const KEY_SEQUENCES = {
-  enter: '\r',
-  return: '\r',
-  tab: '\t',
-  esc: '\x1b',
-  escape: '\x1b',
-  up: '\x1b[A',
-  down: '\x1b[B',
-  right: '\x1b[C',
-  left: '\x1b[D',
-  backspace: '\x7f',
-  delete: '\x1b[3~',
-  home: '\x1b[H',
-  end: '\x1b[F'
-};
-
-function ctrlSequence(key) {
-  const normalized = String(key || '').trim().toLowerCase();
-  if (normalized.length !== 1) return null;
-  const code = normalized.charCodeAt(0);
-  if (code >= 97 && code <= 122) return String.fromCharCode(code - 96);
-  if (normalized === '[') return '\x1b';
-  if (normalized === ']') return '\x1d';
-  if (normalized === '\\') return '\x1c';
-  if (normalized === '^') return '\x1e';
-  if (normalized === '_') return '\x1f';
-  return null;
-}
-
-function sequenceForKey(key, modifiers = {}) {
-  const normalized = String(key || '').trim().toLowerCase();
-  if (!normalized) return '';
-
-  if (normalized.startsWith('ctrl+')) {
-    return ctrlSequence(normalized.slice(5)) || '';
-  }
-
-  if (modifiers.ctrl) {
-    const sequence = ctrlSequence(normalized);
-    if (sequence) return sequence;
-  }
-
-  const sequence = KEY_SEQUENCES[normalized] || normalized;
-  return modifiers.alt ? '\x1b' + sequence : sequence;
-}
-
-module.exports = {
-  sequenceForKey
-};

package/lib/schedule/scheduler-service.js

@@ -1,39 +0,0 @@
-class SchedulerService {
-  constructor({ jobStore, jobRunner, logger, intervalMs = 30000 }) {
-    this.jobStore = jobStore;
-    this.jobRunner = jobRunner;
-    this.logger = logger || console;
-    this.intervalMs = intervalMs;
-    this.timer = null;
-  }
-
-  start() {
-    if (this.timer) return;
-    this.timer = setInterval(() => {
-      this.tick();
-    }, this.intervalMs);
-  }
-
-  stop() {
-    if (!this.timer) return;
-    clearInterval(this.timer);
-    this.timer = null;
-  }
-
-  tick(now = Date.now()) {
-    for (const job of this.jobStore.list()) {
-      if (!job.enabled || !job.nextRunAt || job.nextRunAt > now) continue;
-      this.jobStore.patchRuntime(job.id, {
-        nextRunAt: null,
-        lastRunAt: now,
-        lastRunStatus: 'queued',
-        lastRunMessage: ''
-      });
-      this.jobRunner.run(job.id, { manual: false }).catch(error => {
-        this.logger.error(`Scheduled task ${job.id} failed: ${error.message}`);
-      });
-    }
-  }
-}
-
-module.exports = SchedulerService;

package/lib/server/routes/notifications.js

@@ -1,52 +0,0 @@
-function statusCode(error) {
-  return Number(error?.statusCode) || 500;
-}
-
-function registerNotificationRoutes(app, {
-  settingsStore,
-  notificationService
-}) {
-  app.get('/api/notifications/serverchan', (_req, res) => {
-    res.json(settingsStore.getPublic());
-  });
-
-  app.put('/api/notifications/serverchan', (req, res) => {
-    try {
-      res.json({ success: true, settings: settingsStore.save(req.body || {}) });
-    } catch (error) {
-      res.status(statusCode(error)).json({ error: error.message });
-    }
-  });
-
-  app.delete('/api/notifications/serverchan', (_req, res) => {
-    const settings = settingsStore.clear();
-    notificationService.disableAllSessions();
-    res.json({ success: true, settings });
-  });
-
-  app.post('/api/notifications/serverchan/test', async (req, res) => {
-    try {
-      await notificationService.sendTest(req.body || {});
-      res.json({ success: true });
-    } catch (error) {
-      res.status(statusCode(error)).json({ error: error.message });
-    }
-  });
-
-  app.put('/api/sessions/:id/notifications/serverchan', async (req, res) => {
-    try {
-      const state = await notificationService.setSessionEnabled(
-        req.params.id,
-        Boolean(req.body?.enabled)
-      );
-      res.json({ success: true, state });
-    } catch (error) {
-      res.status(statusCode(error)).json({
-        error: error.message,
-        ...(error.code ? { code: error.code } : {})
-      });
-    }
-  });
-}
-
-module.exports = registerNotificationRoutes;

package/lib/server/routes/providers.js

@@ -1,114 +0,0 @@
-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.get('/api/sessions/:id/codex-prompts', async (req, res) => {
-    try {
-      const result = await sessionManager.listCodexPrompts(req.params.id, {
-        offset: req.query?.offset,
-        limit: req.query?.limit
-      });
-      if (!result) return res.status(404).json({ error: 'Codex session not found' });
-      res.json({ success: true, ...result });
-    } catch (error) {
-      res.status(400).json({ error: error.message });
-    }
-  });
-
-  app.get('/api/sessions/:id/codex-skills', async (req, res) => {
-    try {
-      const result = await sessionManager.listCodexSkills(req.params.id, req.query?.forceReload === 'true');
-      if (!result) return res.status(404).json({ error: 'Codex session not found' });
-      res.json({ success: true, ...result });
-    } 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/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

@@ -1,54 +0,0 @@
-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;