@aion0/forge 0.5.25 → 0.5.26

package/.forge/worktrees/pipeline-e97c13c7/app/api/skills/local/route.ts

@@ -0,0 +1,228 @@
+import { NextResponse } from 'next/server';
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { getClaudeDir } from '@/lib/dirs';
+
+const SKILLS_DIR = join(getClaudeDir(), 'skills');
+const COMMANDS_DIR = join(getClaudeDir(), 'commands');
+
+function md5(content: string): string {
+  return createHash('md5').update(content).digest('hex');
+}
+
+/** Recursively list files in a directory */
+function listFiles(dir: string, prefix = ''): { path: string; size: number }[] {
+  const files: { path: string; size: number }[] = [];
+  if (!existsSync(dir)) return files;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const fullPath = join(dir, entry.name);
+    if (entry.isFile()) {
+      files.push({ path: relPath, size: statSync(fullPath).size });
+    } else if (entry.isDirectory()) {
+      files.push(...listFiles(fullPath, relPath));
+    }
+  }
+  return files;
+}
+
+function resolveDir(name: string, type: string, projectPath?: string): string {
+  if (type === 'skill') {
+    return projectPath
+      ? join(projectPath, '.claude', 'skills', name)
+      : join(SKILLS_DIR, name);
+  }
+  // Command: could be single file or directory
+  const base = projectPath ? join(projectPath, '.claude', 'commands') : COMMANDS_DIR;
+  const dirPath = join(base, name);
+  if (existsSync(dirPath) && statSync(dirPath).isDirectory()) return dirPath;
+  // Single file — return parent dir
+  return base;
+}
+
+/** Scan a directory for all installed skills/commands */
+function scanLocalItems(projectPath?: string): { name: string; type: 'skill' | 'command'; scope: string; fileCount: number; projectPath?: string }[] {
+  const items: { name: string; type: 'skill' | 'command'; scope: string; fileCount: number; projectPath?: string }[] = [];
+
+  // Scan skills directories
+  const skillsDirs = [
+    { dir: SKILLS_DIR, scope: 'global' as const },
+    ...(projectPath ? [{ dir: join(projectPath, '.claude', 'skills'), scope: 'project' as const }] : []),
+  ];
+  for (const { dir, scope } of skillsDirs) {
+    if (!existsSync(dir)) continue;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
+        const files = listFiles(join(dir, entry.name));
+        items.push({ name: entry.name, type: 'skill', scope, fileCount: files.length });
+      }
+    }
+  }
+
+  // Scan commands directories
+  const cmdDirs = [
+    { dir: COMMANDS_DIR, scope: 'global' as const },
+    ...(projectPath ? [{ dir: join(projectPath, '.claude', 'commands'), scope: 'project' as const }] : []),
+  ];
+  for (const { dir, scope } of cmdDirs) {
+    if (!existsSync(dir)) continue;
+    // Collect names, merge file + dir with same name
+    const seen = new Map<string, { name: string; type: 'command'; scope: typeof scope; fileCount: number }>();
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith('.')) continue;
+      const cmdName = entry.isFile() ? entry.name.replace(/\.md$/, '') : entry.name;
+      if (entry.isFile() && !entry.name.endsWith('.md')) continue;
+      const existing = seen.get(cmdName);
+      if (entry.isDirectory()) {
+        const files = listFiles(join(dir, entry.name));
+        const count = files.length + (existing?.fileCount || 0);
+        seen.set(cmdName, { name: cmdName, type: 'command', scope, fileCount: count });
+      } else if (entry.isFile()) {
+        if (existing) {
+          existing.fileCount += 1;
+        } else {
+          seen.set(cmdName, { name: cmdName, type: 'command', scope, fileCount: 1 });
+        }
+      }
+    }
+    items.push(...seen.values());
+  }
+
+  return items;
+}
+
+// GET /api/skills/local?name=X&type=skill|command&project=PATH
+//   action=scan → list ALL locally installed skills/commands
+//   action=files → list installed files for a specific item
+//   action=read&path=FILE → read file content + hash
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const action = searchParams.get('action') || 'files';
+  const name = searchParams.get('name') || '';
+  const type = searchParams.get('type') || 'command';
+  const projectPath = searchParams.get('project') || '';
+
+  if (action === 'scan') {
+    const scanAll = searchParams.get('all') === '1';
+    if (scanAll) {
+      // Scan global + all configured projects
+      const { loadSettings } = require('@/lib/settings');
+      const settings = loadSettings();
+      const allItems: any[] = [];
+      // Global
+      allItems.push(...scanLocalItems());
+      // All projects
+      for (const root of (settings.projectRoots || [])) {
+        const resolvedRoot = root.replace(/^~/, homedir());
+        if (!existsSync(resolvedRoot)) continue;
+        for (const entry of readdirSync(resolvedRoot, { withFileTypes: true })) {
+          if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+          const pp = join(resolvedRoot, entry.name);
+          const projItems = scanLocalItems(pp)
+            .filter(i => i.scope === 'project')
+            .map(i => ({ ...i, projectPath: pp, scope: entry.name }));
+          allItems.push(...projItems);
+        }
+      }
+      return NextResponse.json({ items: allItems });
+    }
+    const items = scanLocalItems(projectPath || undefined);
+    return NextResponse.json({ items });
+  }
+
+  if (action === 'files') {
+    if (type === 'skill') {
+      const dir = resolveDir(name, type, projectPath || undefined);
+      return NextResponse.json({ files: listFiles(dir) });
+    } else {
+      // Command: collect both single .md file and directory contents
+      const base = projectPath ? join(projectPath, '.claude', 'commands') : COMMANDS_DIR;
+      const singleFile = join(base, `${name}.md`);
+      const dirPath = join(base, name);
+      const files: { path: string; size: number }[] = [];
+      // Single .md file at root
+      if (existsSync(singleFile)) {
+        files.push({ path: `${name}.md`, size: statSync(singleFile).size });
+      }
+      // Directory contents
+      if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
+        files.push(...listFiles(dirPath).map(f => ({ path: `${name}/${f.path}`, size: f.size })));
+      }
+      return NextResponse.json({ files });
+    }
+  }
+
+  if (action === 'read') {
+    const filePath = searchParams.get('path') || '';
+    let fullPath: string;
+    if (type === 'skill') {
+      const dir = resolveDir(name, type, projectPath || undefined);
+      fullPath = join(dir, filePath);
+    } else {
+      // filePath from files action is like "name.md" or "name/sub/file.md"
+      // Resolve relative to commands base directory
+      const base = projectPath ? join(projectPath, '.claude', 'commands') : COMMANDS_DIR;
+      fullPath = join(base, filePath);
+    }
+
+    if (!existsSync(fullPath)) return NextResponse.json({ content: '', hash: '' });
+    const content = readFileSync(fullPath, 'utf-8');
+    return NextResponse.json({ content, hash: md5(content) });
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}
+
+// POST /api/skills/local — save, install-local, delete-local
+export async function POST(req: Request) {
+  const body = await req.json();
+  const action = body.action || 'save';
+
+  // Install local skill/command to another project or global
+  if (action === 'install-local') {
+    const { installLocal } = require('@/lib/skills');
+    const { name, type, sourceProject, target, force } = body;
+    const result = installLocal(name, type, sourceProject || undefined, target, !!force);
+    return NextResponse.json(result, { status: result.ok ? 200 : 400 });
+  }
+
+  // Delete local skill/command
+  if (action === 'delete-local') {
+    const { deleteLocal } = require('@/lib/skills');
+    const { name, type, project } = body;
+    const ok = deleteLocal(name, type, project || undefined);
+    return NextResponse.json({ ok });
+  }
+
+  // Save edited file (default action)
+  const { name, type, project, path: filePath, content, expectedHash } = body;
+
+  let fullPath: string;
+  if (type === 'skill') {
+    const dir = project
+      ? join(project, '.claude', 'skills', name)
+      : join(SKILLS_DIR, name);
+    fullPath = join(dir, filePath);
+  } else {
+    const base = project ? join(project, '.claude', 'commands') : COMMANDS_DIR;
+    const dirPath = join(base, name);
+    if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
+      fullPath = join(dirPath, filePath);
+    } else {
+      fullPath = join(base, filePath);
+    }
+  }
+
+  // Check for concurrent modification
+  if (expectedHash && existsSync(fullPath)) {
+    const current = readFileSync(fullPath, 'utf-8');
+    if (md5(current) !== expectedHash) {
+      return NextResponse.json({ ok: false, error: 'File was modified externally. Reload and try again.' }, { status: 409 });
+    }
+  }
+
+  writeFileSync(fullPath, content, 'utf-8');
+  return NextResponse.json({ ok: true, hash: md5(content) });
+}

package/.forge/worktrees/pipeline-e97c13c7/app/api/skills/route.ts

@@ -0,0 +1,182 @@
+import { NextResponse } from 'next/server';
+import {
+  syncSkills,
+  listSkills,
+  installGlobal,
+  installProject,
+  uninstallGlobal,
+  uninstallProject,
+  refreshInstallState,
+  checkLocalModified,
+  purgeDeletedSkill,
+} from '@/lib/skills';
+import { loadSettings } from '@/lib/settings';
+import { homedir } from 'node:os';
+
+function getProjectPaths(): string[] {
+  const settings = loadSettings();
+  const roots = (settings.projectRoots || []).map(r => r.replace(/^~/, homedir()));
+  const paths: string[] = [];
+  for (const root of roots) {
+    try {
+      const { readdirSync, statSync } = require('node:fs');
+      const { join } = require('node:path');
+      for (const name of readdirSync(root)) {
+        const p = join(root, name);
+        try { if (statSync(p).isDirectory() && !name.startsWith('.')) paths.push(p); } catch {}
+      }
+    } catch {}
+  }
+  return paths;
+}
+
+// GET /api/skills — list skills, get file list, or get file content
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const action = searchParams.get('action');
+  const name = searchParams.get('name');
+
+  // List files in a skill/command directory
+  if (action === 'files' && name) {
+    try {
+      const settings = loadSettings();
+      const repoUrl = settings.skillsRepoUrl || 'https://raw.githubusercontent.com/aiwatching/forge-skills/main';
+      const matchRepo = repoUrl.match(/github\.com\/([^/]+\/[^/]+)/);
+      const repo = matchRepo ? matchRepo[1] : 'aiwatching/forge-skills';
+
+      // Try skills/ first, then commands/ (repo may not have commands/ dir)
+      let res = await fetch(`https://api.github.com/repos/${repo}/contents/skills/${name}`, {
+        headers: { 'Accept': 'application/vnd.github.v3+json' },
+      });
+      if (!res.ok) {
+        res = await fetch(`https://api.github.com/repos/${repo}/contents/commands/${name}`, {
+          headers: { 'Accept': 'application/vnd.github.v3+json' },
+        });
+      }
+      if (!res.ok) return NextResponse.json({ files: [] });
+
+      const items = await res.json();
+      const files: { name: string; path: string; type: string }[] = [];
+
+      const recurse = async (list: any[], prefix = '') => {
+        for (const item of list) {
+          if (item.type === 'file') {
+            files.push({ name: item.name, path: prefix + item.name, type: 'file' });
+          } else if (item.type === 'dir') {
+            files.push({ name: item.name + '/', path: prefix + item.name, type: 'dir' });
+            // Fetch subdirectory contents
+            try {
+              const subRes = await fetch(item.url, {
+                headers: { 'Accept': 'application/vnd.github.v3+json' },
+              });
+              if (subRes.ok) {
+                const subItems = await subRes.json();
+                if (Array.isArray(subItems)) {
+                  await recurse(subItems, prefix + item.name + '/');
+                }
+              }
+            } catch {}
+          }
+        }
+      };
+      await recurse(Array.isArray(items) ? items : []);
+
+      // Sort: dirs first, then files
+      files.sort((a, b) => {
+        if (a.type !== b.type) return a.type === 'dir' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      return NextResponse.json({ files });
+    } catch {
+      return NextResponse.json({ files: [] });
+    }
+  }
+
+  // Get content of a specific file
+  if (action === 'file' && name) {
+    const filePath = searchParams.get('path') || 'skill.md';
+    try {
+      const settings = loadSettings();
+      const baseUrl = settings.skillsRepoUrl || 'https://raw.githubusercontent.com/aiwatching/forge-skills/main';
+      // Try skills/ first, then commands/
+      let res = await fetch(`${baseUrl}/skills/${name}/${filePath}`);
+      if (!res.ok) {
+        res = await fetch(`${baseUrl}/commands/${name}/${filePath}`);
+      }
+      if (!res.ok) return NextResponse.json({ content: '(Not found)' });
+      const content = await res.text();
+      return NextResponse.json({ content });
+    } catch {
+      return NextResponse.json({ content: '(Failed to load)' });
+    }
+  }
+  const skills = listSkills();
+  const projects = getProjectPaths().map(p => ({ path: p, name: p.split('/').pop() || p }));
+  return NextResponse.json({ skills, projects });
+}
+
+// POST /api/skills — sync, install, uninstall
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  if (body.action === 'sync') {
+    const result = await syncSkills();
+    if (result.synced > 0) {
+      refreshInstallState(getProjectPaths());
+    }
+    return NextResponse.json(result);
+  }
+
+  if (body.action === 'check-modified') {
+    try {
+      const modified = await checkLocalModified(body.name);
+      return NextResponse.json({ modified });
+    } catch (e) {
+      return NextResponse.json({ modified: false, error: String(e) });
+    }
+  }
+
+  if (body.action === 'install') {
+    const { name, target } = body; // target: 'global' | projectPath
+    if (!name || !target) return NextResponse.json({ ok: false, error: 'name and target required' }, { status: 400 });
+    try {
+      if (target === 'global') {
+        await installGlobal(name);
+      } else {
+        await installProject(name, target);
+      }
+      return NextResponse.json({ ok: true });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
+  if (body.action === 'uninstall') {
+    const { name, target } = body;
+    if (!name || !target) return NextResponse.json({ ok: false, error: 'name and target required' }, { status: 400 });
+    try {
+      if (target === 'global') {
+        uninstallGlobal(name);
+      } else {
+        uninstallProject(name, target);
+      }
+      return NextResponse.json({ ok: true });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
+  if (body.action === 'purge-deleted') {
+    const { name } = body;
+    if (!name) return NextResponse.json({ ok: false, error: 'name required' }, { status: 400 });
+    try {
+      purgeDeletedSkill(name);
+      return NextResponse.json({ ok: true });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-e97c13c7/app/api/smith-templates/route.ts

@@ -0,0 +1,81 @@
+import { NextResponse } from 'next/server';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir } from '@/lib/dirs';
+
+function getTemplatesDir(): string {
+  const dir = join(getDataDir(), 'smith-templates');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export interface SmithTemplate {
+  id: string;
+  name: string;
+  icon: string;
+  description?: string;
+  config: Record<string, any>; // agent config without id/dependsOn/boundSessionId
+  createdAt: number;
+  updatedAt: number;
+}
+
+// List all smith templates
+export async function GET() {
+  const dir = getTemplatesDir();
+  const files = readdirSync(dir).filter(f => f.endsWith('.json'));
+  const templates: SmithTemplate[] = [];
+  for (const f of files) {
+    try {
+      const data = JSON.parse(readFileSync(join(dir, f), 'utf-8'));
+      templates.push(data);
+    } catch {}
+  }
+  templates.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+  return NextResponse.json({ templates });
+}
+
+// Save or delete a smith template
+export async function POST(req: Request) {
+  const body = await req.json();
+  const { action } = body;
+
+  if (action === 'delete') {
+    const { id } = body;
+    if (!id) return NextResponse.json({ error: 'id required' }, { status: 400 });
+    const fp = join(getTemplatesDir(), `${id}.json`);
+    if (existsSync(fp)) unlinkSync(fp);
+    return NextResponse.json({ ok: true });
+  }
+
+  // Save (create or update)
+  const { config, name, icon, description } = body;
+  if (!config || !name) {
+    return NextResponse.json({ error: 'config and name required' }, { status: 400 });
+  }
+
+  // Strip runtime/instance-specific fields
+  const cleanConfig = { ...config };
+  delete cleanConfig.id;
+  delete cleanConfig.dependsOn;
+  delete cleanConfig.boundSessionId;
+  delete cleanConfig.tmuxSession;
+  delete cleanConfig.content;
+  delete cleanConfig.entries;
+  delete cleanConfig.type;
+
+  const id = body.id || `smith-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`;
+  const now = Date.now();
+
+  const template: SmithTemplate = {
+    id,
+    name: name.trim(),
+    icon: icon || cleanConfig.icon || '🤖',
+    description: description?.trim() || '',
+    config: cleanConfig,
+    createdAt: body.id ? (body.createdAt || now) : now,
+    updatedAt: now,
+  };
+
+  writeFileSync(join(getTemplatesDir(), `${id}.json`), JSON.stringify(template, null, 2));
+  return NextResponse.json({ ok: true, template });
+}

package/.forge/worktrees/pipeline-e97c13c7/app/api/status/route.ts

@@ -0,0 +1,12 @@
+import { NextResponse } from 'next/server';
+import { getSessionManager } from '@/lib/session-manager';
+import { listAvailableProviders } from '@/src/core/providers/registry';
+
+export async function GET() {
+  const manager = getSessionManager();
+  return NextResponse.json({
+    sessions: manager.list(),
+    providers: listAvailableProviders(),
+    usage: manager.getUsageSummary(),
+  });
+}

package/.forge/worktrees/pipeline-e97c13c7/app/api/tabs/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+
+function db() { return getDb(getDbPath()); }
+
+export async function GET(req: NextRequest) {
+  const type = req.nextUrl.searchParams.get('type') || 'projects';
+  try {
+    const row = db().prepare('SELECT data FROM tab_state WHERE type = ?').get(type) as any;
+    if (row?.data) return NextResponse.json(JSON.parse(row.data));
+  } catch {}
+  return NextResponse.json({ tabs: [], activeTabId: 0 });
+}
+
+export async function POST(req: NextRequest) {
+  const type = req.nextUrl.searchParams.get('type') || 'projects';
+  try {
+    const body = await req.json();
+    db().prepare('INSERT OR REPLACE INTO tab_state (type, data) VALUES (?, ?)').run(type, JSON.stringify(body));
+    return NextResponse.json({ ok: true });
+  } catch (e: any) {
+    return NextResponse.json({ ok: false, error: e.message }, { status: 500 });
+  }
+}

package/.forge/worktrees/pipeline-e97c13c7/app/api/tasks/[id]/route.ts

@@ -0,0 +1,51 @@
+import { NextResponse } from 'next/server';
+import { getTask, cancelTask, deleteTask, retryTask, updateTask } from '@/lib/task-manager';
+import { getProjectInfo } from '@/lib/projects';
+
+// Get task details (including full log)
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const task = getTask(id);
+  if (!task) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  return NextResponse.json(task);
+}
+
+// Actions: cancel, retry
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const { action } = await req.json();
+
+  if (action === 'cancel') {
+    const ok = cancelTask(id);
+    return NextResponse.json({ ok });
+  }
+
+  if (action === 'retry') {
+    const newTask = retryTask(id);
+    if (!newTask) return NextResponse.json({ error: 'Cannot retry this task' }, { status: 400 });
+    return NextResponse.json(newTask);
+  }
+
+  return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+}
+
+// Edit a task
+export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+  // Resolve projectName to projectPath if changed
+  if (body.projectName && !body.projectPath) {
+    const project = getProjectInfo(body.projectName);
+    if (project) body.projectPath = project.path;
+  }
+  const updated = updateTask(id, body);
+  if (!updated) return NextResponse.json({ error: 'Cannot edit this task' }, { status: 400 });
+  return NextResponse.json(updated);
+}
+
+// Delete a task
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  deleteTask(id);
+  return NextResponse.json({ ok: true });
+}

package/.forge/worktrees/pipeline-e97c13c7/app/api/tasks/[id]/stream/route.ts

@@ -0,0 +1,77 @@
+import { getTask } from '@/lib/task-manager';
+import { onTaskEvent } from '@/lib/task-manager';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+// SSE stream for real-time task log updates
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  const task = getTask(id);
+  if (!task) {
+    return new Response('Task not found', { status: 404 });
+  }
+
+  const encoder = new TextEncoder();
+  let unsubscribe: (() => void) | null = null;
+  let heartbeat: ReturnType<typeof setInterval> | null = null;
+  let closed = false;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      // Send existing log entries
+      for (const entry of task.log) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'log', entry })}\n\n`));
+      }
+
+      // Send current status
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'status', status: task.status })}\n\n`));
+
+      // Heartbeat
+      heartbeat = setInterval(() => {
+        if (!closed) {
+          try { controller.enqueue(encoder.encode(': heartbeat\n\n')); } catch { cleanup(); }
+        }
+      }, 15000);
+
+      // Listen for new events
+      unsubscribe = onTaskEvent((taskId, event, data) => {
+        if (taskId !== id || closed) return;
+        try {
+          if (event === 'log') {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'log', entry: data })}\n\n`));
+          } else if (event === 'status') {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'status', status: data })}\n\n`));
+            // Close stream when task is done
+            if (data === 'done' || data === 'failed' || data === 'cancelled') {
+              // Send final task data
+              const finalTask = getTask(id);
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'complete', task: finalTask })}\n\n`));
+              cleanup();
+              controller.close();
+            }
+          }
+        } catch { cleanup(); }
+      });
+    },
+    cancel() {
+      cleanup();
+    },
+  });
+
+  function cleanup() {
+    closed = true;
+    if (heartbeat) { clearInterval(heartbeat); heartbeat = null; }
+    if (unsubscribe) { unsubscribe(); unsubscribe = null; }
+  }
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}