@aion0/forge 0.1.0

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

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+import { getSessionManager } from '@/lib/session-manager';
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const manager = getSessionManager();
+  const session = manager.get(id) || manager.getByName(id);
+  if (!session) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  return NextResponse.json(session);
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const manager = getSessionManager();
+  manager.delete(id);
+  return NextResponse.json({ ok: true });
+}

package/app/api/sessions/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from 'next/server';
+import { getSessionManager } from '@/lib/session-manager';
+import { loadAllTemplates } from '@/src/config';
+
+export async function GET() {
+  const manager = getSessionManager();
+  const sessions = manager.list();
+  return NextResponse.json(sessions);
+}
+
+export async function POST(req: Request) {
+  const body = await req.json();
+  const manager = getSessionManager();
+  try {
+    const session = manager.create(body);
+    return NextResponse.json(session);
+  } catch (err: any) {
+    return NextResponse.json({ error: err.message }, { status: 400 });
+  }
+}

package/app/api/settings/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from 'next/server';
+import { loadSettings, saveSettings, type Settings } from '@/lib/settings';
+import { restartTelegramBot } from '@/lib/init';
+
+export async function GET() {
+  return NextResponse.json(loadSettings());
+}
+
+export async function PUT(req: Request) {
+  const body = await req.json() as Settings;
+  saveSettings(body);
+  // Restart Telegram bot in case token/chatId changed
+  restartTelegramBot();
+  return NextResponse.json({ ok: true });
+}

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

@@ -0,0 +1,36 @@
+import { NextResponse } from 'next/server';
+import { getTask, cancelTask, deleteTask, retryTask } from '@/lib/task-manager';
+
+// 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 });
+}
+
+// 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/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',
+    },
+  });
+}

package/app/api/tasks/link/route.ts

@@ -0,0 +1,37 @@
+import { NextResponse } from 'next/server';
+import { createTask } from '@/lib/task-manager';
+import { getProjectInfo } from '@/lib/projects';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+
+/**
+ * Link an existing local Claude Code session to a project.
+ * Creates a placeholder task with the conversation_id so future tasks
+ * for this project automatically continue that session.
+ */
+export async function POST(req: Request) {
+  const { projectName, conversationId } = await req.json();
+
+  if (!projectName || !conversationId) {
+    return NextResponse.json({ error: 'projectName and conversationId required' }, { status: 400 });
+  }
+
+  const project = getProjectInfo(projectName);
+  if (!project) {
+    return NextResponse.json({ error: `Project not found: ${projectName}` }, { status: 404 });
+  }
+
+  // Create a placeholder "done" task that carries the conversation_id
+  const db = getDb(getDbPath());
+  const id = `link-${Date.now().toString(36)}`;
+  db.prepare(`
+    INSERT INTO tasks (id, project_name, project_path, prompt, status, priority, conversation_id, log, result_summary, completed_at)
+    VALUES (?, ?, ?, ?, 'done', 0, ?, '[]', ?, datetime('now'))
+  `).run(id, project.name, project.path, '(linked from local CLI)', conversationId, `Session ${conversationId} linked from local CLI`);
+
+  return NextResponse.json({
+    id,
+    projectName: project.name,
+    conversationId,
+  });
+}

package/app/api/tasks/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server';
+import { createTask, listTasks } from '@/lib/task-manager';
+import { ensureInitialized } from '@/lib/init';
+import { getProjectInfo } from '@/lib/projects';
+import type { TaskStatus } from '@/src/types';
+
+// List tasks — optionally filter by status
+export async function GET(req: Request) {
+  ensureInitialized();
+  const url = new URL(req.url);
+  const status = url.searchParams.get('status') as TaskStatus | null;
+  return NextResponse.json(listTasks(status || undefined));
+}
+
+// Create a new task
+export async function POST(req: Request) {
+  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig } = await req.json();
+
+  if (!projectName || !prompt) {
+    return NextResponse.json({ error: 'projectName and prompt are required' }, { status: 400 });
+  }
+
+  const project = getProjectInfo(projectName);
+  if (!project) {
+    return NextResponse.json({ error: `Project not found: ${projectName}` }, { status: 404 });
+  }
+
+  // conversationId: explicit value → use it; newSession → empty string (force new); otherwise → auto-inherit
+  const convId = conversationId || (newSession ? '' : undefined);
+
+  const task = createTask({
+    projectName: project.name,
+    projectPath: project.path,
+    prompt,
+    priority: priority || 0,
+    conversationId: convId,
+    scheduledAt: scheduledAt || undefined,
+    mode: mode || 'prompt',
+    watchConfig: watchConfig || undefined,
+  });
+
+  return NextResponse.json(task);
+}

package/app/api/tasks/session/route.ts

@@ -0,0 +1,14 @@
+import { NextResponse } from 'next/server';
+import { getProjectConversationId } from '@/lib/task-manager';
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const project = url.searchParams.get('project');
+
+  if (!project) {
+    return NextResponse.json({ error: 'project parameter required' }, { status: 400 });
+  }
+
+  const conversationId = getProjectConversationId(project);
+  return NextResponse.json({ conversationId });
+}

package/app/api/templates/route.ts

@@ -0,0 +1,6 @@
+import { NextResponse } from 'next/server';
+import { loadAllTemplates } from '@/src/config';
+
+export async function GET() {
+  return NextResponse.json(loadAllTemplates());
+}

package/app/api/tunnel/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from 'next/server';
+import { startTunnel, stopTunnel, getTunnelStatus } from '@/lib/cloudflared';
+
+/** GET /api/tunnel — current tunnel status */
+export async function GET() {
+  return NextResponse.json(getTunnelStatus());
+}
+
+/** POST /api/tunnel — start or stop tunnel */
+export async function POST(req: Request) {
+  const { action } = await req.json() as { action: 'start' | 'stop' };
+
+  if (action === 'stop') {
+    stopTunnel();
+    return NextResponse.json({ ok: true, ...getTunnelStatus() });
+  }
+
+  const result = await startTunnel();
+  return NextResponse.json({ ok: !result.error, ...getTunnelStatus() });
+}

package/app/api/watchers/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server';
+import { ensureInitialized } from '@/lib/init';
+import { listWatchers, createWatcher, deleteWatcher, toggleWatcher } from '@/lib/session-watcher';
+
+export async function GET() {
+  ensureInitialized();
+  return NextResponse.json(listWatchers());
+}
+
+export async function POST(req: Request) {
+  ensureInitialized();
+  const body = await req.json();
+
+  if (body.action === 'delete') {
+    deleteWatcher(body.id);
+    return NextResponse.json({ ok: true });
+  }
+
+  if (body.action === 'toggle') {
+    toggleWatcher(body.id, body.active);
+    return NextResponse.json({ ok: true });
+  }
+
+  // Create new watcher
+  const watcher = createWatcher({
+    projectName: body.projectName,
+    sessionId: body.sessionId,
+    label: body.label,
+    checkInterval: body.checkInterval || 60,
+  });
+
+  return NextResponse.json(watcher);
+}

package/app/globals.css

@@ -0,0 +1,26 @@
+@import "tailwindcss";
+
+:root {
+  --bg-primary: #0a0a0a;
+  --bg-secondary: #141414;
+  --bg-tertiary: #1e1e1e;
+  --border: #2a2a2a;
+  --text-primary: #e5e5e5;
+  --text-secondary: #999;
+  --accent: #3b82f6;
+  --green: #22c55e;
+  --yellow: #eab308;
+  --red: #ef4444;
+}
+
+body {
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  font-family: 'SF Mono', 'Fira Code', 'Cascadia Code', monospace;
+}
+
+/* Scrollbar */
+::-webkit-scrollbar { width: 6px; }
+::-webkit-scrollbar-track { background: var(--bg-primary); }
+::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
+

package/app/icon.svg

@@ -0,0 +1,26 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">
+  <defs>
+    <linearGradient id="g" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#60a5fa"/>
+      <stop offset="100%" stop-color="#3b82f6"/>
+    </linearGradient>
+  </defs>
+  <!-- Background -->
+  <rect width="32" height="32" rx="7" fill="#1a1a2e"/>
+  <!-- Anvil base -->
+  <rect x="6" y="22" width="20" height="3" rx="1" fill="url(#g)"/>
+  <!-- Anvil middle -->
+  <rect x="9" y="18" width="14" height="4" fill="url(#g)" opacity="0.9"/>
+  <!-- Anvil top face -->
+  <polygon points="9,15 23,15 23,18 9,18" fill="url(#g)" opacity="0.85"/>
+  <!-- Anvil horn (left) -->
+  <polygon points="9,15 4,17 4,18 9,18" fill="#60a5fa" opacity="0.8"/>
+  <!-- Hammer handle -->
+  <rect x="19" y="4" width="2.5" height="10" rx="1" fill="#f59e0b" transform="rotate(-35 20.25 9)"/>
+  <!-- Hammer head -->
+  <rect x="17" y="2.5" width="7" height="3.5" rx="1" fill="#f59e0b" transform="rotate(-35 20.5 4.25)"/>
+  <!-- Sparks -->
+  <circle cx="14" cy="12.5" r="1.2" fill="#fbbf24" opacity="0.9"/>
+  <circle cx="11" cy="10.5" r="0.8" fill="#fbbf24" opacity="0.7"/>
+  <circle cx="17" cy="10" r="0.7" fill="#fbbf24" opacity="0.6"/>
+</svg>

package/app/layout.tsx

@@ -0,0 +1,17 @@
+import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: 'Forge',
+  description: 'Unified AI workflow platform',
+};
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en" className="dark">
+      <body className="min-h-screen bg-[var(--bg-primary)]">
+        {children}
+      </body>
+    </html>
+  );
+}

package/app/login/page.tsx

@@ -0,0 +1,61 @@
+'use client';
+
+import { useState } from 'react';
+import { signIn } from 'next-auth/react';
+
+export default function LoginPage() {
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState('');
+
+  const handleLocal = async (e: React.FormEvent) => {
+    e.preventDefault();
+    const result = await signIn('credentials', {
+      password,
+      callbackUrl: window.location.origin + '/',
+    }) as { error?: string } | undefined;
+    if (result?.error) setError('Wrong password');
+  };
+
+  return (
+    <div className="min-h-screen flex items-center justify-center">
+      <div className="w-80 space-y-6">
+        <div className="text-center">
+          <h1 className="text-2xl font-bold text-[var(--text-primary)]">Forge</h1>
+          <p className="text-sm text-[var(--text-secondary)] mt-1">Unified AI Platform</p>
+        </div>
+
+        {/* Local password login */}
+        <form onSubmit={handleLocal} className="space-y-3">
+          <input
+            type="password"
+            value={password}
+            onChange={e => setPassword(e.target.value)}
+            placeholder="Password"
+            className="w-full px-3 py-2 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-sm text-[var(--text-primary)] focus:outline-none focus:border-[var(--accent)]"
+          />
+          {error && <p className="text-xs text-[var(--red)]">{error}</p>}
+          <button
+            type="submit"
+            className="w-full py-2 bg-[var(--accent)] text-white rounded text-sm hover:opacity-90"
+          >
+            Sign In
+          </button>
+        </form>
+
+        <div className="flex items-center gap-3 text-[var(--text-secondary)] text-xs">
+          <div className="flex-1 h-px bg-[var(--border)]" />
+          <span>or</span>
+          <div className="flex-1 h-px bg-[var(--border)]" />
+        </div>
+
+        {/* Google OAuth */}
+        <button
+          onClick={() => signIn('google', { callbackUrl: window.location.origin + '/' })}
+          className="w-full py-2 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-sm text-[var(--text-primary)] hover:bg-[var(--border)] transition-colors"
+        >
+          Sign in with Google
+        </button>
+      </div>
+    </div>
+  );
+}

package/app/page.tsx

@@ -0,0 +1,9 @@
+import { auth } from '@/lib/auth';
+import { redirect } from 'next/navigation';
+import Dashboard from '@/components/Dashboard';
+
+export default async function Home() {
+  const session = await auth();
+  if (!session) redirect('/login');
+  return <Dashboard user={session.user} />;
+}