@aion0/forge 0.5.24 → 0.5.26

package/.forge/worktrees/pipeline-e97c13c7/src/types/index.ts

@@ -0,0 +1,129 @@
+export type MemoryStrategy = 'none' | 'sliding_window' | 'full' | 'full_with_summary' | 'external';
+
+export type SessionStatus = 'running' | 'idle' | 'paused' | 'archived' | 'error';
+
+export type ProviderName = 'anthropic' | 'google' | 'openai' | 'grok';
+
+export interface ProviderConfig {
+  name: ProviderName;
+  displayName: string;
+  apiKey?: string;
+  defaultModel: string;
+  models: string[];
+  enabled: boolean;
+}
+
+export interface MemoryConfig {
+  strategy: MemoryStrategy;
+  windowSize?: number;       // for sliding_window
+  compressAfter?: number;    // for full — compress after N messages
+  summaryModel?: string;     // model to use for summarization
+}
+
+export interface SessionTemplate {
+  id: string;
+  name: string;
+  description: string;
+  provider: ProviderName;
+  model?: string;
+  fallbackProvider?: ProviderName;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  context?: {
+    files?: string[];
+  };
+  commands?: Record<string, { description: string; action: string; prompt?: string }>;
+  ui?: {
+    icon?: string;
+    color?: string;
+    pinned?: boolean;
+  };
+}
+
+export interface Message {
+  id: number;
+  sessionId: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  provider: ProviderName;
+  model: string;
+  tokenCount?: number;
+  createdAt: string;
+}
+
+export interface Session {
+  id: string;
+  name: string;
+  templateId: string;
+  provider: ProviderName;
+  model: string;
+  status: SessionStatus;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  messageCount: number;
+  createdAt: string;
+  updatedAt: string;
+  lastMessage?: string;
+}
+
+export interface UsageRecord {
+  provider: ProviderName;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  date: string;
+}
+
+export type TaskStatus = 'queued' | 'running' | 'done' | 'failed' | 'cancelled';
+export type TaskMode = 'prompt' | 'monitor' | 'shell';
+
+export interface WatchConfig {
+  condition: 'change' | 'idle' | 'complete' | 'error' | 'keyword';
+  keyword?: string;          // for 'keyword' condition
+  idleMinutes?: number;      // for 'idle' condition (default 10)
+  action: 'notify' | 'message' | 'task';
+  actionPrompt?: string;     // message to send or task prompt
+  actionProject?: string;    // for 'task' action
+  repeat?: boolean;          // keep watching after trigger (default false)
+  notifyIntervalSeconds?: number; // min seconds between notifications (default 60)
+}
+
+export interface Task {
+  id: string;
+  projectName: string;
+  projectPath: string;
+  prompt: string;
+  mode: TaskMode;
+  status: TaskStatus;
+  priority: number;
+  conversationId?: string;
+  watchConfig?: WatchConfig;
+  log: TaskLogEntry[];
+  resultSummary?: string;
+  gitDiff?: string;
+  gitBranch?: string;
+  costUSD?: number;
+  error?: string;
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  scheduledAt?: string;
+}
+
+export interface TaskLogEntry {
+  type: 'system' | 'assistant' | 'result';
+  subtype?: string;
+  content: string;
+  tool?: string;
+  timestamp: string;
+}
+
+export interface AppConfig {
+  dataDir: string;
+  providers: Record<ProviderName, ProviderConfig>;
+  server: {
+    host: string;
+    port: number;
+  };
+}

package/.forge/worktrees/pipeline-e97c13c7/start.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# start.sh — Start Forge locally (kill old processes, build, start)
+#
+# Usage:
+#   ./start.sh          # production mode
+#   ./start.sh dev      # dev mode (hot-reload)
+
+# Kill all old forge processes
+pkill -f 'telegram-standalone' 2>/dev/null
+pkill -f 'terminal-standalone' 2>/dev/null
+pkill -f 'workspace-standalone' 2>/dev/null
+pkill -f 'cloudflared tunnel' 2>/dev/null
+# Wait for workspace daemon port to be released
+for i in 1 2 3; do
+  lsof -ti:${WORKSPACE_PORT:-8405} >/dev/null 2>&1 || break
+  sleep 1
+done
+pkill -f 'next-server' 2>/dev/null
+pkill -f 'next start' 2>/dev/null
+pkill -f 'next dev' 2>/dev/null
+sleep 1
+
+export PORT=${PORT:-8403}
+export TERMINAL_PORT=${TERMINAL_PORT:-8404}
+export WORKSPACE_PORT=${WORKSPACE_PORT:-8405}
+
+if [ "$1" = "dev" ]; then
+  pnpm dev
+else
+  pnpm build && pnpm start
+fi

package/.forge/worktrees/pipeline-e97c13c7/templates/smith-lead.json

@@ -0,0 +1,45 @@
+{
+  "name": "Lead",
+  "icon": "👑",
+  "description": "Primary coordinator — SOP-driven requirement intake, delegation, gap coverage, and quality gate",
+  "config": {
+    "label": "Lead",
+    "icon": "👑",
+    "backend": "cli",
+    "agentId": "claude",
+    "primary": true,
+    "persistentSession": true,
+    "workDir": "./",
+    "outputs": ["docs/lead/"],
+    "plugins": ["playwright", "shell-command"],
+    "role": "You are the Lead — primary coordinator of this workspace.\n\nYour context automatically includes a \"Workspace Team\" section showing all agents, their roles, status, and missing standard roles. Read it before every action.\n\n## SOP: Requirement Intake\n\nWhen you receive a requirement (from user input or inbox message):\n\n```\n1. Read the Workspace Team section in your context\n2. Classify the requirement:\n   - Single task → one request document\n   - Multi-module → break into independent request documents, group in a batch\n3. Route based on available roles:\n\n   HAS Architect?\n   └─ YES → create_request with full description → Architect breaks it down further\n   └─ NO → you break it down yourself, then:\n\n        HAS Engineer?\n        └─ YES → create_request for each module (status: open)\n                 Engineers claim via claim_request\n        └─ NO → implement it yourself in src/\n                 Record files_changed in docs/lead/impl-notes.md\n\n4. After implementation (by you or Engineer):\n\n   HAS QA?\n   └─ YES → update_response(section: engineer) triggers auto-notify to QA\n   └─ NO → you test it:\n          - Read acceptance_criteria from the request\n          - Write tests in tests/ or run manually\n          - Record results: update_response(section: qa, result: passed/failed)\n\n5. After testing:\n\n   HAS Reviewer?\n   └─ YES → auto-notified when QA passes\n   └─ NO → you review it:\n          - Check code quality, security, PRD compliance\n          - Record: update_response(section: review, result: approved/changes_requested)\n          - If changes_requested → send_message to Engineer or fix yourself\n```\n\n## SOP: Monitoring & Coordination\n\nWhile work is in progress:\n\n```\n1. get_status → check all agents' smith/task status\n2. list_requests → check request progress\n\nIF agent taskStatus = failed:\n   → Read their error from get_status\n   → send_message asking what went wrong\n   → If no response or unfixable: handle the request yourself\n\nIF agent taskStatus = running for too long:\n   → send_message to check progress\n\nIF request stuck in one status:\n   → Check which agent should be handling it\n   → send_message to nudge, or cover it yourself\n\nIF multiple Engineers exist and request unclaimed:\n   → send_message to available Engineer suggesting they claim_request\n```\n\n## SOP: Quality Gate (before declaring done)\n\n```\n1. list_requests(batch: current_batch)\n2. ALL requests status = done?\n   └─ NO → identify stuck ones, apply Monitoring SOP\n   └─ YES → continue\n3. Any request with review.result = changes_requested?\n   └─ YES → verify changes were made, re-review if no Reviewer\n4. Any request with qa.result = failed?\n   └─ YES → verify fix was applied, re-test if no QA\n5. Write summary to docs/lead/delivery-summary.md:\n   - Requirements covered\n   - Requests created and their final status\n   - Roles you covered due to gaps\n   - Any open issues\n```\n\n## Gap Coverage Reference\n\nWhen you cover a missing role, follow that role's standards:\n\n| Missing Role | What You Do | Output |\n|---|---|---|\n| PM/Architect | Break requirements into modules with acceptance_criteria | request documents via create_request |\n| Engineer | Read request → implement in src/ → update_response(section: engineer) | source code + files_changed |\n| QA | Read acceptance_criteria → write/run tests → update_response(section: qa) | test results in tests/ or docs/qa/ |\n| Reviewer | Read code changes → check quality/security → update_response(section: review) | review findings |\n\n## Rules\n\n- Workspace Team is in your context — don't call get_agents redundantly at start, just read it\n- DO call get_agents/get_status when you need live status updates mid-task\n- Every delegated task MUST go through request documents (create_request) — never just send_message with vague instructions\n- Each request needs concrete acceptance_criteria that QA can verify\n- Do NOT duplicate work an active agent is already doing — check status first\n- When covering a gap, be thorough — don't half-do it just because it's not your \"main\" role",
+    "steps": [
+      {
+        "id": "intake",
+        "label": "Intake & Analyze",
+        "prompt": "Read the Workspace Team section in your context. Identify: (1) which standard roles are present and missing, (2) incoming requirements from upstream input or inbox. For each requirement, decide scope: single task or multi-module. List what you will delegate vs handle yourself."
+      },
+      {
+        "id": "delegate",
+        "label": "Create Requests & Route",
+        "prompt": "For each module/task: create_request with title, description, acceptance_criteria, and batch name. If Architect exists, create high-level requests for them to break down. If only Engineers exist, create implementation-ready requests. If no one to delegate to, note which requests you will implement yourself. Verify with list_requests that all were created."
+      },
+      {
+        "id": "cover-gaps",
+        "label": "Cover Missing Roles",
+        "prompt": "Handle all work for missing roles. If no Engineer: implement code, then update_response(section: engineer). If no QA: write/run tests against acceptance_criteria, then update_response(section: qa). If no Reviewer: review code changes for quality and security, then update_response(section: review). Use get_status between tasks to check if other agents have completed their work."
+      },
+      {
+        "id": "monitor",
+        "label": "Monitor & Unblock",
+        "prompt": "Run get_status and list_requests. For each stuck/failed agent: diagnose and send_message to unblock, or take over the request yourself. For unclaimed requests: nudge available agents. Continue until all requests show progress."
+      },
+      {
+        "id": "gate",
+        "label": "Quality Gate & Summary",
+        "prompt": "list_requests for the current batch. Verify ALL requests are status=done with review.result=approved and qa.result=passed. If any are not: apply gap coverage. Write docs/lead/delivery-summary.md with: requirements covered, request statuses, roles you covered, open issues."
+      }
+    ]
+  },
+  "exportedAt": 1743724800000
+}

package/.forge/worktrees/pipeline-e97c13c7/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    ".next/dev/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/.forge/worktrees/pipeline-ecd7cb0f/CLAUDE.md

@@ -0,0 +1,86 @@
+## Project: Forge (@aion0/forge)
+
+### Scripts
+```bash
+# ── Start ──
+./start.sh              # production (kill old processes → build → start)
+./start.sh dev           # development (hot-reload)
+forge server start              # production via npm link/install
+forge server start --dev        # dev mode
+forge server start              # background by default, logs to ~/.forge/forge.log
+forge server start --foreground # foreground mode
+forge server stop               # stop default instance (port 8403)
+forge server stop --port 4000 --dir ~/.forge-staging  # stop specific instance
+forge server restart            # stop + start (safe for remote)
+forge server rebuild            # force rebuild
+forge server start --port 4000 --terminal-port 4001 --dir ~/.forge-staging
+forge server start --reset-terminal  # kill terminal server (loses tmux attach)
+forge --version                 # show version
+
+# ── Test ──
+./dev-test.sh            # test instance (port 4000, data ~/.forge-test)
+
+# ── Install ──
+./install.sh             # install from npm
+./install.sh --local     # install from local source (npm link + build)
+
+# ── Publish ──
+./publish.sh             # bump patch version, commit, tag
+./publish.sh minor       # bump minor
+./publish.sh 1.0.0       # explicit version
+npm login && npm publish --access public --otp=<code>
+
+# ── Monitor ──
+./check-forge-status.sh  # show process status + tmux sessions
+
+# ── CLI ──
+forge                    # help
+forge --version          # show version
+forge tcode              # show tunnel URL + session code
+forge tasks              # list tasks
+forge task <project> "prompt"  # submit task
+forge watch <id>         # live stream task output
+```
+
+### Key Paths
+- Data: `~/.forge/` (settings, db, password, terminal-state, flows, bin)
+- npm package: `@aion0/forge`
+- GitHub: `github.com/aiwatching/forge`
+
+### Help Docs Rule
+When adding or changing a feature, check if `lib/help-docs/` needs updating. Each file covers one module:
+- `00-overview.md` — install, start, data paths
+- `01-settings.md` — all settings fields
+- `02-telegram.md` — bot setup and commands
+- `03-tunnel.md` — remote access
+- `04-tasks.md` — background tasks
+- `05-pipelines.md` — DAG workflows
+- `06-skills.md` — marketplace
+- `07-projects.md` — project management
+- `08-rules.md` — CLAUDE.md templates
+- `09-issue-autofix.md` — GitHub issue scanner
+- `10-troubleshooting.md` — common issues
+If a feature change affects user-facing behavior, update the corresponding help doc in the same commit.
+
+### Architecture
+- `forge-server.mjs` starts: Next.js + terminal-standalone + telegram-standalone
+- `pnpm dev` / `start.sh dev` starts: Next.js (init.ts spawns terminal + telegram)
+- `FORGE_EXTERNAL_SERVICES=1` → init.ts skips spawning (forge-server manages them)
+
+## Obsidian Vault
+Location: /Users/zliu/MyDocuments/obsidian-project/Projects/Bastion
+When I ask about my notes, use bash to search and read files from this directory.
+Example: find /Users/zliu/MyDocuments/obsidian-project -name "*.md" | head -20
+
+<!-- forge:template:obsidian-vault -->
+## Obsidian Vault
+When I ask about my notes, use bash to search and read files from the vault directory.
+Example: find <vault_path> -name "*.md" | head -20
+<!-- /forge:template:obsidian-vault -->
+
+
+<!-- FORGE:BEGIN -->
+## Forge Workspace Integration
+When you finish processing a task or message from Forge, end your final response with the marker: [FORGE_DONE]
+This helps Forge detect task completion. Do not include this marker if you are still working.
+<!-- FORGE:END -->

package/.forge/worktrees/pipeline-ecd7cb0f/README.md

@@ -0,0 +1,136 @@
+<p align="center">
+  <img src="app/icon.ico" width="80" height="80" alt="Forge">
+</p>
+
+<h1 align="center">Forge</h1>
+
+<p align="center">
+  <strong>Self-hosted Vibe Coding platform for Claude Code</strong><br>
+  Browser terminal · AI tasks · Remote access · Telegram bot
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@aion0/forge"><img src="https://img.shields.io/npm/v/@aion0/forge" alt="npm"></a>
+  <a href="https://github.com/aiwatching/forge/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@aion0/forge" alt="MIT"></a>
+  <a href="https://github.com/aiwatching/forge"><img src="https://img.shields.io/github/stars/aiwatching/forge?style=social" alt="stars"></a>
+</p>
+
+<p align="center">
+  <a href="https://www.youtube.com/watch?v=F3fiSiP3pZY">Watch Demo →</a>
+</p>
+
+---
+
+## Demo & Install Guide
+
+[![Forge Install Guide](https://img.youtube.com/vi/F3fiSiP3pZY/maxresdefault.jpg)](https://www.youtube.com/watch?v=F3fiSiP3pZY)
+
+## Install
+
+```bash
+npm install -g @aion0/forge
+forge server start
+```
+
+Open `http://localhost:8403`. First launch prompts you to set an admin password.
+
+**Requirements:** Node.js ≥ 20, tmux, [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)
+
+## What is Forge?
+
+Forge turns Claude Code into a remote-accessible coding platform. Run it on your machine, access from any device.
+
+- **Vibe Code anywhere** — iPad, phone, any browser. Persistent tmux sessions survive refresh/restart
+- **Background AI tasks** — Submit prompts that run while you sleep. Live output, cost tracking
+- **Pipeline workflows** — Chain Claude Code steps in YAML (design → implement → review)
+- **Remote access** — One-click Cloudflare Tunnel, no account needed
+- **Telegram bot** — Create tasks, check status, take notes from your phone
+- **Skills marketplace** — Browse & install Claude Code slash commands
+
+No API keys required. Uses your existing Claude Code subscription. Code never leaves your machine.
+
+## Multi-Agent Workspace <sup>v0.5.0</sup>
+
+Define agent teams with roles, dependencies, and steps. Agents run as daemons and communicate via a structured message bus.
+
+```mermaid
+graph LR
+    Input["📋 Requirements"] --> PM["🎯 PM"]
+    PM --> Eng["🔨 Engineer"]
+    Eng --> QA["🧪 QA"]
+    Eng --> Rev["👁 Reviewer"]
+    QA --> Rev
+
+    style Input fill:#f0883e,stroke:#f0883e,color:#fff
+    style PM fill:#a371f7,stroke:#a371f7,color:#fff
+    style Eng fill:#58a6ff,stroke:#58a6ff,color:#fff
+    style QA fill:#3fb950,stroke:#3fb950,color:#fff
+    style Rev fill:#f778ba,stroke:#f778ba,color:#fff
+```
+
+- **Agent profiles** — Reusable configs with env vars, model overrides, custom API endpoints (Claude, Codex, Aider)
+- **Message system** — Notifications (follow DAG) + Tickets (any direction, retry limits) with causedBy tracing
+- **Manual mode** — Open a terminal on any agent, work interactively, return to auto
+- **Watch manager** — Monitor files, git, or commands. Auto-analyze or require approval on changes
+
+## Features
+
+| | |
+|---|---|
+| **Multi-Agent Workspace** | Agent teams with DAG dependencies, message bus, watch monitoring, manual/auto mode |
+| **Vibe Coding** | Browser tmux terminal, multi-tab, split panes, WebGL, Ctrl+F search |
+| **AI Tasks** | Background Claude Code execution with live streaming output |
+| **Pipelines** | YAML DAG workflows with parallel execution & visual editor |
+| **Remote Access** | Cloudflare Tunnel with 2FA (password + session code) |
+| **Docs Viewer** | Obsidian / markdown rendering with AI assistant |
+| **Projects** | File browser, git operations, code viewer with syntax highlighting, diff view |
+| **Skills** | Marketplace for skills & commands — browse, install, update, version tracking |
+| **Telegram** | Tasks, sessions, notes, tunnel control from mobile |
+| **CLI** | `forge task`, `forge watch`, `forge status`, and more |
+
+## Quick Start
+
+```bash
+forge server start              # start (background by default)
+forge server start --foreground # run in foreground
+forge server start --dev        # dev mode with hot-reload
+forge server stop               # stop
+forge server restart            # restart
+```
+
+### From source
+
+```bash
+git clone https://github.com/aiwatching/forge.git
+cd forge && pnpm install
+./start.sh          # production
+./start.sh dev      # development
+```
+
+## CLI
+
+```bash
+forge task <project> <prompt>   # submit a task
+forge tasks                     # list tasks
+forge watch <id>                # live stream output
+forge status                    # process status
+forge tcode                     # show tunnel URL + session code
+forge projects                  # list projects
+forge flows                     # list workflows
+forge run <flow>                # run a workflow
+forge --reset-password               # reset admin password
+```
+
+## Telegram Bot
+
+Create a bot via [@BotFather](https://t.me/botfather), add the token in Settings.
+
+`/task` — create task · `/tasks` — list · `/sessions` — AI summary · `/note` — quick note · `/tunnel_start` — start tunnel · `/watch` — monitor session
+
+## Data
+
+All data in `~/.forge/` — settings, database, terminal state, workflows, logs. Configurable via `--dir` flag.
+
+## License
+
+[MIT](LICENSE)

package/.forge/worktrees/pipeline-ecd7cb0f/RELEASE_NOTES.md

@@ -0,0 +1,11 @@
+# Forge v0.5.25
+
+Released: 2026-04-05
+
+## Changes since v0.5.24
+
+### Bug Fixes
+- fix: replace @/src path alias with relative import in project-sessions.ts
+
+
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.24...v0.5.25

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/agents/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+import { listAgents, getDefaultAgentId, resolveTerminalLaunch } from '@/lib/agents';
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const resolve = url.searchParams.get('resolve');
+
+  // GET /api/agents?resolve=claude → resolve terminal launch info for an agent
+  if (resolve) {
+    const info = resolveTerminalLaunch(resolve);
+    return NextResponse.json(info);
+  }
+
+  const agents = listAgents();
+  const defaultAgent = getDefaultAgentId();
+  return NextResponse.json({ agents, defaultAgent });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,3 @@
+import { handlers } from '@/lib/auth';
+
+export const { GET, POST } = handlers;

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/auth/verify/route.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server';
+import { randomUUID } from 'node:crypto';
+
+// In-memory valid tokens — shared across API routes in the same process
+const tokenKey = Symbol.for('forge-api-tokens');
+const g = globalThis as any;
+if (!g[tokenKey]) g[tokenKey] = new Set<string>();
+export const validTokens: Set<string> = g[tokenKey];
+
+/** Verify a token is valid (for use in other API routes) */
+export function isValidToken(req: Request): boolean {
+  // Check header
+  const headerToken = new Headers(req.headers).get('x-forge-token');
+  if (headerToken && validTokens.has(headerToken)) return true;
+  // Check cookie
+  const cookieHeader = new Headers(req.headers).get('cookie') || '';
+  const match = cookieHeader.match(/forge-api-token=([^;]+)/);
+  if (match && validTokens.has(match[1])) return true;
+  return false;
+}
+
+export async function POST(req: Request) {
+  const body = await req.json();
+  const { password } = body;
+
+  if (!password) {
+    return NextResponse.json({ error: 'password required' }, { status: 400 });
+  }
+
+  const { verifyAdmin } = await import('@/lib/password');
+  if (!verifyAdmin(password)) {
+    return NextResponse.json({ error: 'invalid password' }, { status: 401 });
+  }
+
+  const token = randomUUID();
+  validTokens.add(token);
+
+  const res = NextResponse.json({ ok: true, token });
+  res.cookies.set('forge-api-token', token, {
+    httpOnly: true,
+    sameSite: 'lax',
+    maxAge: 86400,
+    path: '/',
+  });
+  return res;
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/claude/[id]/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import { getProcess, sendToClaudeSession, killProcess } from '@/lib/claude-process';
+
+// Get session info
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const proc = getProcess(id);
+  if (!proc) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  return NextResponse.json(proc);
+}
+
+// Send a message to the Claude session
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+
+  if (body.type === 'message') {
+    const ok = sendToClaudeSession(id, body.content, body.conversationId);
+    if (!ok) {
+      return NextResponse.json({ error: 'Session not found or already running' }, { status: 400 });
+    }
+    return NextResponse.json({ ok: true });
+  }
+
+  if (body.type === 'kill') {
+    killProcess(id);
+    return NextResponse.json({ ok: true });
+  }
+
+  return NextResponse.json({ error: 'Unknown type' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/claude/[id]/stream/route.ts

@@ -0,0 +1,63 @@
+import { attachToProcess } from '@/lib/claude-process';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+// SSE stream of Claude Code structured messages
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  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) {
+      // Heartbeat every 15s to keep connection alive
+      heartbeat = setInterval(() => {
+        if (!closed) {
+          try {
+            controller.enqueue(encoder.encode(': heartbeat\n\n'));
+          } catch {
+            // Controller closed
+            cleanup();
+          }
+        }
+      }, 15000);
+
+      unsubscribe = attachToProcess(id, (msg) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(msg)}\n\n`));
+        } catch {
+          cleanup();
+        }
+      });
+
+      if (!unsubscribe) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'system', subtype: 'error', content: 'Session not found' })}\n\n`));
+        cleanup();
+        controller.close();
+      }
+    },
+    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',
+    },
+  });
+}