glad-web 1.0.7

package/lib/schedule/job-runner.js

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

@@ -0,0 +1,150 @@
+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 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)
+  };
+  job.nextRunAt = job.enabled ? computeNextRunAt(job.schedule) : null;
+  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;
+    jobs[index] = normalizeJob(input, jobs[index], { touch: true });
+    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

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

@@ -0,0 +1,39 @@
+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/session/buffer.js

@@ -0,0 +1,102 @@
+const logger = require('../utils/logger');
+
+class CircularBuffer {
+  constructor(maxSize = 100000) {
+    this.maxSize = maxSize; // 100KB default
+    this.buffer = [];
+    this.totalSize = 0;
+    this.currentSeq = 0;
+  }
+
+  previewText(text, maxChars = 240) {
+    if (!text) return '';
+    const normalized = String(text)
+      .replace(/\r/g, '\\r')
+      .replace(/\n/g, '\\n')
+      .replace(/\t/g, '\\t')
+      .replace(/\x1b/g, '\\x1b');
+    return normalized.length > maxChars ? normalized.slice(-maxChars) : normalized;
+  }
+
+  // Calculate byte size of data
+  getByteSize(data) {
+    return Buffer.byteLength(data, 'utf8');
+  }
+
+  // Append data to buffer
+  append(data) {
+    const timestamp = new Date().toISOString();
+    const seq = ++this.currentSeq;
+    const byteSize = this.getByteSize(data);
+
+    const item = {
+      seq,
+      data,
+      timestamp,
+      size: byteSize
+    };
+
+    this.buffer.push(item);
+    this.totalSize += byteSize;
+
+    // Remove old items if buffer exceeds max size
+    while (this.totalSize > this.maxSize && this.buffer.length > 0) {
+      const removed = this.buffer.shift();
+      this.totalSize -= removed.size;
+    }
+
+    return item;
+  }
+
+  // Get all items after a specific sequence number
+  getAfter(seq) {
+    return this.buffer.filter(item => item.seq > seq);
+  }
+
+  // Get all items
+  getAll() {
+    return [...this.buffer];
+  }
+
+  // Get current sequence number
+  getCurrentSeq() {
+    return this.currentSeq;
+  }
+
+  // Clear buffer
+  clear() {
+    logger.debug('Buffer: cleared');
+    this.buffer = [];
+    this.totalSize = 0;
+  }
+
+  // Get buffer stats
+  getStats() {
+    return {
+      items: this.buffer.length,
+      totalSize: this.totalSize,
+      maxSize: this.maxSize,
+      currentSeq: this.currentSeq,
+      oldestSeq: this.buffer.length > 0 ? this.buffer[0].seq : null,
+      newestSeq: this.buffer.length > 0 ? this.buffer[this.buffer.length - 1].seq : null
+    };
+  }
+
+  getDebugSnapshot(maxItems = 5, maxChars = 240) {
+    return {
+      ...this.getStats(),
+      tailItems: this.buffer.slice(-maxItems).map(item => ({
+        seq: item.seq,
+        size: item.size,
+        timestamp: item.timestamp,
+        preview: this.previewText(item.data, maxChars)
+      })),
+      combinedTailPreview: this.previewText(
+        this.buffer.slice(-maxItems).map(item => item.data).join(''),
+        maxChars
+      )
+    };
+  }
+}
+
+module.exports = CircularBuffer;