@aion0/forge 0.4.15 → 0.5.0

package/CLAUDE.md

@@ -9,7 +9,7 @@ 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 3000)
+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

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="app/icon.svg" width="80" height="80" alt="Forge">
+  <img src="app/icon.ico" width="80" height="80" alt="Forge">
 </p>
 
 <h1 align="center">Forge</h1>
@@ -32,7 +32,7 @@ npm install -g @aion0/forge
 forge server start
 ```
 
-Open `http://localhost:3000`. First launch prompts you to set an admin password.
+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)
 

package/RELEASE_NOTES.md

@@ -1,25 +1,182 @@
-# Forge v0.4.15
+# Forge v0.5.0
 
-Released: 2026-03-23
+Released: 2026-03-28
 
-## Changes since v0.4.14
+## Changes since v0.4.16
 
 ### Features
-- feat: record token usage from task, pipeline, and mobile sources
-- feat: Usage dashboard — token cost by project, model, day, source
-- feat: token usage tracking — scanner, DB, API
+- feat: watch actions (log/analyze/approve) + config UI
+- feat: agent watch — autonomous periodic monitoring
+- feat: Workspace — multi-agent terminal view per project
+- feat: requires-driven scheduling for delivery engine
+- feat: standardized envelope format + request/response audit trail
+- feat: visible data contracts on flow editor — artifact names on edges and nodes
+- feat: ReactFlow-based delivery role editor — drag & connect agent topology
+- feat: customizable delivery roles — users compose agent phases from presets
+- feat: show all 4 agent panels in 2x2 grid with SVG flow arrows
+- feat: Delivery Workspace — multi-agent orchestrated software delivery
+- feat: conversation terminal view with inline input and data flow
+- feat: Conversation Mode — multi-agent dialogue with graph view and live logs
+- feat: Pipeline editor node edit modal has Agent + Mode selectors
+- feat: Pipeline UI shows agent per node
+- feat: per-doc-root agent config (Settings + Docs toolbar)
+- feat: Telegram default agent + Docs agent config
+- feat: TTY support for agents that need terminal (e.g. Codex)
+- feat: per-agent skip permissions flag with presets
+- feat: Telegram agent support — @agent syntax + /agents command
+- feat: agent selection for Pipeline, Mobile, Help
+- feat: per-scene model config for each agent
+- feat: model config moved from global to per-agent
+- feat: task system uses agent adapter + agent selector in NewTaskModal
+- feat: terminal tab agent selection
+- feat: Agents management UI in Settings
+- feat: multi-agent foundation — registry, adapters, API
 
 ### Bug Fixes
-- fix: exclude cache tokens from cost estimate
-- fix: usage stored per day+model for accurate daily breakdown
-- fix: usage query uses local timezone for daily grouping
+- fix: tolerate Next.js 16 _global-error prerender bug in build
+- fix: Log panel reads from persistent logs.jsonl + clear logs button
+- fix: restart watch loop when agent config is updated
+- fix: watch directory picker uses correct tree type and flattens nested dirs
+- fix: send block only when message is still running, not after done
+- fix: block forge-send reply to message sender + skill prompt hint
+- fix: hasRunning check uses worker's current message, not all bus log
+- fix: no extra reply message when processing downstream request
+- fix: smith send API returns messageId for outbox tracking
+- fix: inject FORGE_AGENT_ID/WORKSPACE_ID/PORT into manual terminal env
+- fix: forge skills use $FORGE_AGENT_ID instead of hardcoded 'unknown'
+- fix: deduplicate bus_message SSE events by message ID
+- fix: emit done before markMessageDone so causedBy can read messageId
+- fix: remove notifyDownstreamForRevalidation + prevent multiple running messages
+- fix: abort_message no longer errors on already-aborted messages
+- fix: getAllAgentStates returns worker state with entry mode override
+- fix: manual stays in mode field, displayed as purple 'manual' on node
+- fix: show 'manual' task status when agent is in manual mode
+- fix: close terminal uses close_terminal action instead of reset
+- fix: restartAgentDaemon recreates worker after resetAgent kills it
+- fix: parseBusMarkers re-scanning entire history causes message loops
+- fix: restartAgentDaemon aligned with simplified setManualMode
+- fix: manual mode shows down because worker async cleanup overrides state
+- fix: buffered wake prevents lost messages in daemon loop
+- fix: simplify retry — reset original message to pending, no emit
+- fix: retry creates new message, preserves original for history
+- fix: message retry causing duplicate execution
+- fix: PTY spawn in ESM — use createRequire for node-pty
+- fix: TTY detection for codex profiles + clear agent cache on terminal open
+- fix: project terminal dialog loads sessions from claude-sessions API
+- fix: bypass GitHub CDN cache on skills sync
+- fix: merge tags from info.json during v2 registry sync
+- fix: enable allowProposedApi for search decorations
+- fix: profile env/model propagation across all terminal launch paths
+- fix: saveAgentConfig preserves profile fields (base/env/model/type)
+- fix: sessions API uses orch.projectPath, ESM imports, non-claude compat
+- fix: stricter workDir validation — block .. and sibling dir escape
+- fix: workDir with leading / treated as relative to project, not absolute
+- fix: workDir normalize strips ./ prefix, default to smith label
+- fix: only use claude -c (resume) if existing session exists
+- fix: handle unknown agentId in smith send API
+- fix: whitelist /api/workspace in middleware for forge skill auto-discover
+- fix: install skills as directories with SKILL.md (Claude Code format)
+- fix: use imported resolve instead of require('node:path') in ESM context
+- fix: orchestrator actively manages smith lifecycle in start/stop daemon
+- fix: startDaemon error handling + stopDaemon cleanup
+- fix: close terminal should enter listening, not execute steps
+- fix: workspace terminal uses correct message types from terminal server
+- fix: workspace terminal input + keep alive when switching tabs
+- fix: rewrite WorkspaceView — each agent is a real interactive terminal
+- fix: move ssr:false dynamic import to client wrapper component
+- fix: disable SSR for Dashboard to eliminate hydration mismatch
+- fix: default phases missing _outputArtifactName/_label/_icon metadata
+- fix: data flow arrows based on requires/produces, not sequential order
+- fix: suppress hydration warning from locale/extension mismatch
+- fix: pipeline node shows 'default' instead of 'claude' when no agent set
+- fix: PTY onExit/onData registered once, fixes stuck tasks after cancel
+- fix: auto-kill PTY agents after 15s idle
+- fix: strip ANSI/terminal control codes from PTY agent output
+- fix: retryTask preserves original agent selection
+- fix: use pipe stdin for task spawn, close immediately after
+- fix: non-claude agents no longer fallback to claude or show claude model
+- fix: settings agent config debounced save + unsaved warning on close
+- fix: generic agents use taskFlags from settings, log raw text output
+- fix: only pass model flag to agents that support it, show agent in task
+- fix: settings agent colors match terminal — use API detected status
+- fix: show all configured agents, not just detected ones
 
 ### Performance
-- perf: usage scan interval from 5min to 1 hour
+- perf: watch heartbeat only logs to console, not to files/history
+- perf: watch uses timestamp comparison instead of full snapshot
+
+### Refactoring
+- refactor: remove Delivery tab, keep only Workspace
+
+### Documentation
+- docs: update workspace help with message system design
+- docs: add workspace help, update settings/projects/overview docs
 
 ### Other
-- ui: show author and source URL in skills detail view
-- ui: move Usage button next to Browser in header right section
+- watch: push heartbeat + alert logs to agent history for Log panel
+- watch: log heartbeat on each check cycle
+- ui: structured watch target builder with directory picker
+- debug: log deleteMessage results for diagnosing message reappearance
+- persist currentMessageId as task trigger identifier
+- inbox: abort all pending button for batch operations
+- inbox/outbox: batch select + delete for completed messages
+- Phase 3: ticket UI, retry limits, ticket API actions
+- Phase 2: causedBy chain + ticket messages + receive rules
+- Phase 1: anti-loop — DAG cycle detection, directional broadcast, disable SEND markers
+- ui: show mode (auto/manual) as separate line on agent node
+- simplify: setManualMode only changes mode, message loop skips manual
+- debug: log when agent message loop skips due to not-listening state
+- skills: auto-loop sync with progress indicator
+- skills: incremental sync — registry fast, info.json in batches
+- terminal: add Ctrl/Cmd+F search in terminal buffer
+- terminal: add WebGL rendering + Unicode 11 support
+- unified terminal launch: resolveTerminalLaunch for both VibeCoding + Workspace
+- settings: agent has profile selector dropdown
+- settings: profiles are global/shared, not per-agent
+- settings: add cliType selector to agent config panel
+- settings: profiles nested inside each agent, not standalone section
+- open_terminal: return cliType + cliCmd from agent registry
+- settings: env var templates per CLI type for profiles
+- agent config: add cliType field (claude-code/codex/aider/generic)
+- vibecoding: profile selector + session picker + env injection for terminal
+- terminal profile: env var injection via export, not settings.json
+- terminal: session picker with recent sessions list
+- terminal: styled launch dialog — New Session / Resume Latest
+- terminal: simple prompt dialog for new/resume before opening
+- terminal: prompt user to choose new session or resume
+- cleanup: simplify resume flag check in FloatingTerminal
+- UI: show resolved workDir path hint below input
+- forge skills: explicit 2-step commands, no env var checks
+- forge skills: inline auto-discover, no separate setup step
+- workDir validation: unique per smith, must be within project, no nesting
+- profile settings: write to smith workDir, not project root
+- profile terminal: apply env/model to .claude/settings.json on open_terminal
+- forge skills: install/update on every forge startup
+- forge skills: auto-discover workspace context with fallback defaults
+- skills: install once in startDaemon, remove per-smith install
+- skills: install to ~/.claude/skills/ globally + fix project deny rules
+- skill installer: auto-fix .claude/settings.json curl permissions
+- forge skills: env var injection + auto-install on smith startup
+- agent profiles: editable profile rows with expand/collapse
+- agent profiles: env vars support for custom CLI configs (e.g., FortiAI)
+- agent profiles UI: settings management + workspace profile selector
+- agent profiles + provider config data layer
+- smith message-driven architecture: independent message loop, inbox management, status simplification
+- multiple agent implementation
+- fix issue
+- fix issue for workspace
+- optmized projects
+- refactoring workspace
+- implement workspace and fix issue
+- implement multiple agents
+- ui: show agent badge on ReactFlow node blocks in pipeline editor
+- simplify: single docs agent instead of per-root
+- ui: remove Docs page agent selector, keep Settings-only config
+- ui: remove leftover model/permissions migration notes from Settings
+- ui: consistent agent colors across terminal and settings
+- ui: agent buttons green=installed, gray=not installed
+- ui: agent buttons ≤3 inline, >3 overflow with dropdown
+- ui: agent buttons inline with project name in new tab modal
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.14...v0.4.15
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.16...v0.5.0

package/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/app/api/delivery/[id]/route.ts

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server';
+import {
+  getDelivery, cancelDelivery, deleteDelivery,
+  approveDeliveryPhase, rejectDeliveryPhase,
+  sendToAgent, retryPhase,
+} from '@/lib/delivery';
+import { listArtifacts, getArtifact } from '@/lib/artifacts';
+import type { PhaseName } from '@/lib/delivery';
+
+// GET /api/delivery/:id — get delivery state + artifacts
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const delivery = getDelivery(id);
+  if (!delivery) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+
+  const artifacts = listArtifacts(id);
+  return NextResponse.json({ ...delivery, artifacts });
+}
+
+// POST /api/delivery/:id — actions
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+  const { action } = body;
+
+  if (action === 'cancel') {
+    return NextResponse.json({ ok: cancelDelivery(id) });
+  }
+
+  if (action === 'delete') {
+    return NextResponse.json({ ok: deleteDelivery(id) });
+  }
+
+  if (action === 'approve') {
+    return NextResponse.json({ ok: approveDeliveryPhase(id, body.feedback) });
+  }
+
+  if (action === 'reject') {
+    if (!body.feedback) return NextResponse.json({ error: 'feedback required' }, { status: 400 });
+    return NextResponse.json({ ok: rejectDeliveryPhase(id, body.feedback) });
+  }
+
+  if (action === 'send') {
+    const { phase, message } = body;
+    if (!phase || !message) return NextResponse.json({ error: 'phase and message required' }, { status: 400 });
+    return NextResponse.json({ ok: sendToAgent(id, phase as PhaseName, message) });
+  }
+
+  if (action === 'retry') {
+    const { phase } = body;
+    if (!phase) return NextResponse.json({ error: 'phase required' }, { status: 400 });
+    return NextResponse.json({ ok: retryPhase(id, phase as PhaseName) });
+  }
+
+  return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+}
+
+// DELETE /api/delivery/:id
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return NextResponse.json({ ok: deleteDelivery(id) });
+}

package/app/api/delivery/route.ts

@@ -0,0 +1,40 @@
+import { NextResponse } from 'next/server';
+import { createDelivery, listDeliveries, ROLE_PRESETS } from '@/lib/delivery';
+
+// GET /api/delivery — list deliveries, or get role presets
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+
+  if (searchParams.get('type') === 'presets') {
+    return NextResponse.json(ROLE_PRESETS);
+  }
+
+  const deliveries = listDeliveries();
+  return NextResponse.json(deliveries);
+}
+
+// POST /api/delivery — create new delivery
+export async function POST(req: Request) {
+  const body = await req.json();
+  const { title, project, projectPath, prUrl, description, agentId, phases } = body;
+
+  if (!project || !projectPath) {
+    return NextResponse.json({ error: 'project and projectPath required' }, { status: 400 });
+  }
+
+  try {
+    const delivery = createDelivery({
+      title: title || description?.slice(0, 50) || 'Delivery',
+      project,
+      projectPath,
+      prUrl,
+      description,
+      agentId,
+      customPhases: phases,  // user-defined phases
+    });
+
+    return NextResponse.json(delivery);
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/mobile-chat/route.ts

@@ -7,26 +7,32 @@ export const runtime = 'nodejs';
 
 // POST /api/mobile-chat — send a message to claude and stream response
 export async function POST(req: Request) {
-  const { message, projectPath, resume } = await req.json() as {
+  const { message, projectPath, resume, agent: agentId } = await req.json() as {
     message: string;
     projectPath: string;
     resume?: boolean;
+    agent?: string;
   };
 
   if (!message || !projectPath) {
     return NextResponse.json({ error: 'message and projectPath required' }, { status: 400 });
   }
 
-  const settings = loadSettings();
-  const claudePath = settings.claudePath || 'claude';
+  const { getAgent } = require('@/lib/agents');
+  const adapter = getAgent(agentId);
   const projectName = projectPath.split('/').pop() || projectPath;
 
-  const args = ['-p', '--dangerously-skip-permissions', '--output-format', 'json'];
-  if (resume) args.push('-c');
+  const spawnOpts = adapter.buildTaskSpawn({
+    projectPath,
+    prompt: message,
+    skipPermissions: true,
+    outputFormat: adapter.config.capabilities?.supportsStreamJson ? 'json' : undefined,
+    conversationId: resume ? 'last' : undefined,
+  });
 
-  const child = spawn(claudePath, args, {
+  const child = spawn(spawnOpts.cmd, spawnOpts.args, {
     cwd: projectPath,
-    env: { ...process.env },
+    env: { ...process.env, ...(spawnOpts.env || {}) },
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 

package/app/api/monitor/route.ts

@@ -7,11 +7,13 @@ function run(cmd: string): string {
   } catch { return ''; }
 }
 
-function countProcess(pattern: string): { count: number; pid: string } {
+function countProcess(pattern: string): { count: number; pid: string; startedAt: string } {
   const out = run(`ps aux | grep '${pattern}' | grep -v grep | head -1`);
   const pid = out ? out.split(/\s+/)[1] || '' : '';
   const count = out ? run(`ps aux | grep '${pattern}' | grep -v grep | wc -l`).trim() : '0';
-  return { count: parseInt(count), pid };
+  // Get start time from ps
+  const startedAt = pid ? run(`ps -o lstart= -p ${pid} 2>/dev/null`).trim() : '';
+  return { count: parseInt(count), pid, startedAt };
 }
 
 export async function GET() {
@@ -19,6 +21,7 @@ export async function GET() {
   const nextjs = countProcess('next-server');
   const terminal = countProcess('terminal-standalone');
   const telegram = countProcess('telegram-standalone');
+  const workspace = countProcess('workspace-standalone');
   const tunnel = countProcess('cloudflared tunnel');
 
   // Tunnel URL
@@ -47,10 +50,11 @@ export async function GET() {
 
   return NextResponse.json({
     processes: {
-      nextjs: { running: nextjs.count > 0, pid: nextjs.pid },
-      terminal: { running: terminal.count > 0, pid: terminal.pid },
-      telegram: { running: telegram.count > 0, pid: telegram.pid },
-      tunnel: { running: tunnel.count > 0, pid: tunnel.pid, url: tunnelUrl },
+      nextjs: { running: nextjs.count > 0, pid: nextjs.pid, startedAt: nextjs.startedAt },
+      terminal: { running: terminal.count > 0, pid: terminal.pid, startedAt: terminal.startedAt },
+      telegram: { running: telegram.count > 0, pid: telegram.pid, startedAt: telegram.startedAt },
+      workspace: { running: workspace.count > 0, pid: workspace.pid, startedAt: workspace.startedAt },
+      tunnel: { running: tunnel.count > 0, pid: tunnel.pid, url: tunnelUrl, startedAt: tunnel.startedAt },
     },
     sessions,
     uptime: uptime.replace(/.*up\s+/, '').replace(/,\s+\d+ user.*/, '').trim(),

package/app/api/pipelines/[id]/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { getPipeline, cancelPipeline, deletePipeline } from '@/lib/pipeline';
+import { getPipeline, cancelPipeline, deletePipeline, injectConversationMessage } from '@/lib/pipeline';
 
 // GET /api/pipelines/:id
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -9,10 +9,11 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   return NextResponse.json(pipeline);
 }
 
-// POST /api/pipelines/:id — actions (cancel)
+// POST /api/pipelines/:id — actions (cancel, delete, inject)
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;
-  const { action } = await req.json();
+  const body = await req.json();
+  const { action } = body;
 
   if (action === 'cancel') {
     const ok = cancelPipeline(id);
@@ -24,5 +25,17 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     return NextResponse.json({ ok });
   }
 
+  // Inject a message into a running conversation
+  if (action === 'inject') {
+    const { agentId, message } = body;
+    if (!agentId || !message) return NextResponse.json({ error: 'agentId and message required' }, { status: 400 });
+    try {
+      const ok = injectConversationMessage(id, agentId, message);
+      return NextResponse.json({ ok });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 400 });
+    }
+  }
+
   return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
 }

package/app/api/tasks/route.ts

@@ -14,7 +14,7 @@ export async function GET(req: Request) {
 
 // Create a new task
 export async function POST(req: Request) {
-  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig } = await req.json();
+  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig, agent } = await req.json();
 
   if (!projectName || !prompt) {
     return NextResponse.json({ error: 'projectName and prompt are required' }, { status: 400 });
@@ -37,6 +37,7 @@ export async function POST(req: Request) {
     scheduledAt: scheduledAt || undefined,
     mode: mode || 'prompt',
     watchConfig: watchConfig || undefined,
+    agent: agent || undefined,
   });
 
   return NextResponse.json(task);

package/app/api/workspace/[id]/agents/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Agent operations
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/agents`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}
+
+// Proxy to workspace daemon — Get agent states
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/agents`);
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/app/api/workspace/[id]/memory/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Memory query
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id: workspaceId } = await params;
+  const url = new URL(req.url);
+  const agentId = url.searchParams.get('agentId');
+
+  if (!agentId) {
+    return NextResponse.json({ error: 'agentId required' }, { status: 400 });
+  }
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${workspaceId}/memory?agentId=${encodeURIComponent(agentId)}`);
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/app/api/workspace/[id]/smith/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Smith API (called by forge skills in terminal)
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/smith`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/app/api/workspace/[id]/stream/route.ts

@@ -0,0 +1,28 @@
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// SSE relay — proxy daemon's SSE stream to browser
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  try {
+    const daemonRes = await fetch(`${DAEMON_URL}/workspace/${id}/stream`, {
+      signal: req.signal,
+    });
+
+    if (!daemonRes.ok || !daemonRes.body) {
+      return new Response(daemonRes.statusText || 'Daemon error', { status: daemonRes.status });
+    }
+
+    // Pipe daemon SSE stream directly to browser
+    return new Response(daemonRes.body, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        'Connection': 'keep-alive',
+      },
+    });
+  } catch (err: any) {
+    return new Response('Workspace daemon not available', { status: 503 });
+  }
+}