@sooneocean/agw 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sooneocean/agw",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Agent Gateway — multi-agent task router for Claude, Codex, Gemini with combos, DAG, DSL",
   "type": "module",
   "bin": {

package/src/daemon/routes/export-import.ts

@@ -0,0 +1,54 @@
+import type { FastifyInstance } from 'fastify';
+import type { TemplateEngine } from '../services/template-engine.js';
+import type { WebhookManager } from '../services/webhook-manager.js';
+import type { Scheduler } from '../services/scheduler.js';
+import type { MemoryRepo } from '../../store/memory-repo.js';
+import { COMBO_PRESETS } from '../services/combo-executor.js';
+import { createExport, validateImport } from '../services/export-import.js';
+
+export function registerExportImportRoutes(
+  app: FastifyInstance,
+  templateEngine: TemplateEngine,
+  webhookManager: WebhookManager,
+  scheduler: Scheduler,
+  memoryRepo: MemoryRepo,
+): void {
+  app.get('/export', async () => {
+    return createExport({
+      templates: templateEngine.list(),
+      comboPresets: COMBO_PRESETS,
+      webhooks: webhookManager.getWebhooks(),
+      memory: memoryRepo.list(1000),
+      scheduledJobs: scheduler.listJobs(),
+      version: '1.6.0',
+    });
+  });
+
+  app.post('/import', async (request, reply) => {
+    const data = request.body;
+    if (!validateImport(data)) {
+      return reply.status(400).send({ error: 'Invalid import format' });
+    }
+
+    let imported = { templates: 0, memory: 0, jobs: 0 };
+
+    for (const t of data.templates) {
+      templateEngine.register(t);
+      imported.templates++;
+    }
+
+    for (const m of data.memory) {
+      memoryRepo.set(m.key, m.value, m.scope);
+      imported.memory++;
+    }
+
+    for (const j of data.scheduledJobs) {
+      try {
+        scheduler.addJob(j);
+        imported.jobs++;
+      } catch { /* skip invalid */ }
+    }
+
+    return { imported };
+  });
+}

package/src/daemon/routes/replay.ts

@@ -0,0 +1,22 @@
+import type { FastifyInstance } from 'fastify';
+import type { ReplayManager } from '../services/replay.js';
+
+export function registerReplayRoutes(app: FastifyInstance, replayManager: ReplayManager): void {
+  app.post<{ Params: { id: string } }>('/tasks/:id/replay', async (request, reply) => {
+    try {
+      const task = await replayManager.replayTask(request.params.id);
+      return reply.status(201).send(task);
+    } catch (err) {
+      return reply.status(404).send({ error: (err as Error).message });
+    }
+  });
+
+  app.post<{ Params: { id: string } }>('/combos/:id/replay', async (request, reply) => {
+    try {
+      const comboId = replayManager.replayCombo(request.params.id);
+      return reply.status(202).send({ comboId, status: 'replaying' });
+    } catch (err) {
+      return reply.status(404).send({ error: (err as Error).message });
+    }
+  });
+}

package/src/daemon/routes/scheduler.ts

@@ -0,0 +1,38 @@
+import type { FastifyInstance } from 'fastify';
+import type { Scheduler } from '../services/scheduler.js';
+
+export function registerSchedulerRoutes(app: FastifyInstance, scheduler: Scheduler): void {
+  app.get('/scheduler/jobs', async () => scheduler.listJobs());
+
+  app.get<{ Params: { id: string } }>('/scheduler/jobs/:id', async (request, reply) => {
+    const job = scheduler.getJob(request.params.id);
+    if (!job) return reply.status(404).send({ error: 'Job not found' });
+    return job;
+  });
+
+  app.post('/scheduler/jobs', async (request, reply) => {
+    const body = request.body as any;
+    try {
+      const job = scheduler.addJob(body);
+      return reply.status(201).send(job);
+    } catch (err) {
+      return reply.status(400).send({ error: (err as Error).message });
+    }
+  });
+
+  app.delete<{ Params: { id: string } }>('/scheduler/jobs/:id', async (request, reply) => {
+    const removed = scheduler.removeJob(request.params.id);
+    if (!removed) return reply.status(404).send({ error: 'Job not found' });
+    return { removed: true };
+  });
+
+  app.post<{ Params: { id: string } }>('/scheduler/jobs/:id/enable', async (request, reply) => {
+    if (!scheduler.enableJob(request.params.id)) return reply.status(404).send({ error: 'Job not found' });
+    return { enabled: true };
+  });
+
+  app.post<{ Params: { id: string } }>('/scheduler/jobs/:id/disable', async (request, reply) => {
+    if (!scheduler.disableJob(request.params.id)) return reply.status(404).send({ error: 'Job not found' });
+    return { disabled: true };
+  });
+}

package/src/daemon/server.ts

@@ -30,6 +30,11 @@ import { registerMemoryRoutes } from './routes/memory.js';
 import { registerHealthRoutes } from './routes/health.js';
 import { registerTemplateRoutes } from './routes/templates.js';
 import { registerWebhookRoutes } from './routes/webhooks.js';
+import { Scheduler } from './services/scheduler.js';
+import { ReplayManager } from './services/replay.js';
+import { registerSchedulerRoutes } from './routes/scheduler.js';
+import { registerReplayRoutes } from './routes/replay.js';
+import { registerExportImportRoutes } from './routes/export-import.js';
 
 interface ServerOptions {
   dbPath?: string;
@@ -65,6 +70,8 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   const templateEngine = new TemplateEngine();
   templateEngine.seedDefaults();
   const webhookManager = new WebhookManager();
+  const scheduler = new Scheduler();
+  const replayManager = new ReplayManager(taskRepo, comboRepo, executor, comboExecutor, router, agentManager);
 
   const app = Fastify({
     logger: false,
@@ -82,6 +89,9 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   registerHealthRoutes(app, metrics, agentManager, cbRegistry, taskRepo, costRepo, config);
   registerTemplateRoutes(app, templateEngine, executor, router, agentManager);
   registerWebhookRoutes(app, webhookManager);
+  registerSchedulerRoutes(app, scheduler);
+  registerReplayRoutes(app, replayManager);
+  registerExportImportRoutes(app, templateEngine, webhookManager, scheduler, memoryRepo);
 
   app.register(import('./routes/ui.js'));
 
@@ -93,6 +103,7 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
       taskRepo.updateStatus(t.taskId, 'failed');
       auditRepo.log(t.taskId, 'task.failed', { reason: 'daemon shutdown' });
     }
+    scheduler.stopAll();
     db.close();
   });
 

package/src/daemon/services/export-import.ts

@@ -0,0 +1,62 @@
+/**
+ * Export/Import — serialize AGW configuration and data for sharing/backup.
+ *
+ * Exports: templates, combo presets, webhooks, memory entries, scheduled jobs.
+ * Does NOT export: tasks, audit logs, cost records (runtime data).
+ */
+
+import type { TaskTemplate } from './template-engine.js';
+import type { WebhookConfig } from './webhook-manager.js';
+import type { ScheduledJob } from './scheduler.js';
+import type { MemoryEntry } from '../../store/memory-repo.js';
+import type { ComboPreset } from '../../types.js';
+
+export interface AgwExport {
+  version: string;
+  exportedAt: string;
+  templates: TaskTemplate[];
+  comboPresets: ComboPreset[];
+  webhooks: WebhookConfig[];
+  memory: MemoryEntry[];
+  scheduledJobs: Omit<ScheduledJob, 'id' | 'intervalMs' | 'nextRun' | 'runCount' | 'lastRun'>[];
+}
+
+export function createExport(data: {
+  templates: TaskTemplate[];
+  comboPresets: ComboPreset[];
+  webhooks: WebhookConfig[];
+  memory: MemoryEntry[];
+  scheduledJobs: ScheduledJob[];
+  version: string;
+}): AgwExport {
+  return {
+    version: data.version,
+    exportedAt: new Date().toISOString(),
+    templates: data.templates,
+    comboPresets: data.comboPresets,
+    webhooks: data.webhooks.map(w => ({ ...w, secret: undefined })), // Strip secrets
+    memory: data.memory,
+    scheduledJobs: data.scheduledJobs.map(j => ({
+      name: j.name,
+      type: j.type,
+      target: j.target,
+      params: j.params,
+      interval: j.interval,
+      agent: j.agent,
+      priority: j.priority,
+      workingDirectory: j.workingDirectory,
+      enabled: j.enabled,
+    })),
+  };
+}
+
+export function validateImport(data: unknown): data is AgwExport {
+  if (!data || typeof data !== 'object') return false;
+  const d = data as Record<string, unknown>;
+  return (
+    typeof d.version === 'string' &&
+    typeof d.exportedAt === 'string' &&
+    Array.isArray(d.templates) &&
+    Array.isArray(d.memory)
+  );
+}

package/src/daemon/services/replay.ts

@@ -0,0 +1,53 @@
+/**
+ * Replay — re-run a completed/failed task or combo with the same parameters.
+ */
+
+import type { TaskDescriptor, ComboDescriptor, CreateComboRequest } from '../../types.js';
+import type { TaskExecutor } from './task-executor.js';
+import type { ComboExecutor } from './combo-executor.js';
+import type { TaskRepo } from '../../store/task-repo.js';
+import type { ComboRepo } from '../../store/combo-repo.js';
+import type { LlmRouter } from '../../router/llm-router.js';
+import type { AgentManager } from './agent-manager.js';
+
+export class ReplayManager {
+  constructor(
+    private taskRepo: TaskRepo,
+    private comboRepo: ComboRepo,
+    private taskExecutor: TaskExecutor,
+    private comboExecutor: ComboExecutor,
+    private router: LlmRouter,
+    private agentManager: AgentManager,
+  ) {}
+
+  async replayTask(taskId: string): Promise<TaskDescriptor> {
+    const original = this.taskRepo.getById(taskId);
+    if (!original) throw new Error(`Task ${taskId} not found`);
+
+    const availableAgents = this.agentManager.getAvailableAgents();
+    return this.taskExecutor.execute(
+      {
+        prompt: original.prompt,
+        preferredAgent: original.assignedAgent,
+        workingDirectory: original.workingDirectory,
+        priority: original.priority,
+      },
+      async (p) => this.router.route(p, availableAgents, original.assignedAgent),
+    );
+  }
+
+  replayCombo(comboId: string): string {
+    const original = this.comboRepo.getById(comboId);
+    if (!original) throw new Error(`Combo ${comboId} not found`);
+
+    const request: CreateComboRequest = {
+      name: `${original.name} (replay)`,
+      pattern: original.pattern,
+      steps: original.steps,
+      input: original.input,
+      maxIterations: original.maxIterations,
+    };
+
+    return this.comboExecutor.start(request);
+  }
+}

package/src/daemon/services/scheduler.ts

@@ -0,0 +1,115 @@
+/**
+ * Scheduler — run tasks, combos, or templates on cron-like intervals.
+ *
+ * Supports: interval-based scheduling (every N minutes/hours).
+ * Cron expressions are parsed as simple patterns: "every 5m", "every 1h", "every 30s".
+ */
+
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+
+export interface ScheduledJob {
+  id: string;
+  name: string;
+  type: 'task' | 'combo-preset' | 'template';
+  target: string;           // prompt for task, presetId for combo, templateId for template
+  params?: Record<string, string>;  // for templates
+  interval: string;         // "every 5m", "every 1h"
+  intervalMs: number;       // parsed interval in ms
+  agent?: string;
+  priority?: number;
+  workingDirectory?: string;
+  enabled: boolean;
+  lastRun?: string;
+  nextRun: string;
+  runCount: number;
+}
+
+export function parseInterval(expr: string): number {
+  const match = expr.match(/^every\s+(\d+)\s*(s|m|h|d)$/i);
+  if (!match) throw new Error(`Invalid interval: "${expr}". Use "every Ns/m/h/d"`);
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  const multipliers: Record<string, number> = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+  return value * multipliers[unit];
+}
+
+export class Scheduler extends EventEmitter {
+  private jobs = new Map<string, ScheduledJob>();
+  private timers = new Map<string, NodeJS.Timeout>();
+
+  addJob(job: Omit<ScheduledJob, 'id' | 'intervalMs' | 'nextRun' | 'runCount'>): ScheduledJob {
+    const id = nanoid(8);
+    const intervalMs = parseInterval(job.interval);
+    const scheduled: ScheduledJob = {
+      ...job,
+      id,
+      intervalMs,
+      nextRun: new Date(Date.now() + intervalMs).toISOString(),
+      runCount: 0,
+    };
+
+    this.jobs.set(id, scheduled);
+
+    if (scheduled.enabled) {
+      this.startTimer(scheduled);
+    }
+
+    return scheduled;
+  }
+
+  removeJob(id: string): boolean {
+    const timer = this.timers.get(id);
+    if (timer) { clearInterval(timer); this.timers.delete(id); }
+    return this.jobs.delete(id);
+  }
+
+  enableJob(id: string): boolean {
+    const job = this.jobs.get(id);
+    if (!job) return false;
+    job.enabled = true;
+    this.startTimer(job);
+    return true;
+  }
+
+  disableJob(id: string): boolean {
+    const job = this.jobs.get(id);
+    if (!job) return false;
+    job.enabled = false;
+    const timer = this.timers.get(id);
+    if (timer) { clearInterval(timer); this.timers.delete(id); }
+    return true;
+  }
+
+  getJob(id: string): ScheduledJob | undefined {
+    return this.jobs.get(id);
+  }
+
+  listJobs(): ScheduledJob[] {
+    return Array.from(this.jobs.values());
+  }
+
+  private startTimer(job: ScheduledJob): void {
+    const existing = this.timers.get(job.id);
+    if (existing) clearInterval(existing);
+
+    const timer = setInterval(() => {
+      job.runCount++;
+      job.lastRun = new Date().toISOString();
+      job.nextRun = new Date(Date.now() + job.intervalMs).toISOString();
+      this.emit('job:trigger', job);
+    }, job.intervalMs);
+
+    // Don't keep process alive just for scheduling
+    timer.unref();
+    this.timers.set(job.id, timer);
+  }
+
+  stopAll(): void {
+    for (const [id, timer] of this.timers) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+  }
+}