@aion0/forge 0.2.7 → 0.2.9

package/app/api/telegram/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { loadSettings } from '@/lib/settings';
+import { handleTelegramMessage } from '@/lib/telegram-bot';
+
+// POST /api/telegram — receives messages from telegram-standalone process
+export async function POST(req: NextRequest) {
+  const settings = loadSettings();
+
+  // Verify the request comes from our standalone process
+  const secret = req.headers.get('x-telegram-secret');
+  if (!secret || secret !== settings.telegramBotToken) {
+    return NextResponse.json({ error: 'unauthorized' }, { status: 401 });
+  }
+
+  const message = await req.json();
+
+  try {
+    await handleTelegramMessage(message);
+    return NextResponse.json({ ok: true });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/tunnel/route.ts

@@ -1,12 +1,10 @@
 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' };
 

package/app/login/page.tsx

@@ -11,9 +11,13 @@ export default function LoginPage() {
     e.preventDefault();
     const result = await signIn('credentials', {
       password,
-      callbackUrl: window.location.origin + '/',
-    }) as { error?: string } | undefined;
-    if (result?.error) setError('Wrong password');
+      redirect: false,
+    }) as { error?: string; ok?: boolean } | undefined;
+    if (result?.error) {
+      setError('Wrong password');
+    } else if (result?.ok) {
+      window.location.href = window.location.origin + '/';
+    }
   };
 
   return (

package/bin/forge-server.mjs

@@ -93,8 +93,70 @@ if (resetTerminal) {
   }
 }
 
+// ── Kill orphan standalone processes ──
+function cleanupOrphans() {
+  try {
+    const out = execSync("ps aux | grep -E 'telegram-standalone|terminal-standalone|next-server|next start|next dev' | grep -v grep | awk '{print $2}'", {
+      encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    if (out) {
+      const myPid = String(process.pid);
+      for (const pid of out.split('\n').filter(Boolean)) {
+        if (pid.trim() === myPid) continue; // don't kill ourselves
+        try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
+      }
+      // Force kill any remaining
+      setTimeout(() => {
+        for (const pid of out.split('\n').filter(Boolean)) {
+          if (pid.trim() === myPid) continue;
+          try { process.kill(parseInt(pid), 'SIGKILL'); } catch {}
+        }
+      }, 2000);
+      console.log('[forge] Cleaned up orphan processes');
+    }
+  } catch {}
+}
+
+// ── Start standalone services (single instance each) ──
+const services = [];
+
+function startServices() {
+  cleanupOrphans();
+
+  // Terminal server
+  const termScript = join(ROOT, 'lib', 'terminal-standalone.ts');
+  const termChild = spawn('npx', ['tsx', termScript], {
+    cwd: ROOT,
+    stdio: ['ignore', 'inherit', 'inherit'],
+    env: { ...process.env },
+  });
+  services.push(termChild);
+  console.log(`[forge] Terminal server started (pid: ${termChild.pid})`);
+
+  // Telegram bot
+  const telegramScript = join(ROOT, 'lib', 'telegram-standalone.ts');
+  const telegramChild = spawn('npx', ['tsx', telegramScript], {
+    cwd: ROOT,
+    stdio: ['ignore', 'inherit', 'inherit'],
+    env: { ...process.env },
+  });
+  services.push(telegramChild);
+  console.log(`[forge] Telegram bot started (pid: ${telegramChild.pid})`);
+}
+
+function stopServices() {
+  for (const child of services) {
+    try { child.kill('SIGTERM'); } catch {}
+  }
+  services.length = 0;
+  cleanupOrphans();
+}
+
 // ── Helper: stop running instance ──
 function stopServer() {
+  stopServices();
+  try { unlinkSync(join(DATA_DIR, 'tunnel-state.json')); } catch {}
+
   try {
     const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim());
     process.kill(pid, 'SIGTERM');
@@ -109,7 +171,7 @@ function stopServer() {
 
 // ── Helper: start background server ──
 function startBackground() {
-  if (!existsSync(join(ROOT, '.next'))) {
+  if (!existsSync(join(ROOT, '.next', 'BUILD_ID'))) {
     console.log('[forge] Building...');
     execSync('npx next build', { cwd: ROOT, stdio: 'inherit', env: { ...process.env } });
   }
@@ -124,6 +186,10 @@ function startBackground() {
 
   writeFileSync(PID_FILE, String(child.pid));
   child.unref();
+
+  // Start services in background too
+  startServices();
+
   console.log(`[forge] Started in background (pid ${child.pid})`);
   console.log(`[forge] Web: http://localhost:${webPort}`);
   console.log(`[forge] Terminal: ws://localhost:${terminalPort}`);
@@ -171,24 +237,31 @@ if (isBackground) {
 }
 
 // ── Foreground ──
+
+// Clean up services on exit
+process.on('SIGINT', () => { stopServices(); process.exit(0); });
+process.on('SIGTERM', () => { stopServices(); process.exit(0); });
+
 if (isDev) {
   console.log(`[forge] Starting dev mode (port ${webPort}, terminal ${terminalPort}, data ${DATA_DIR})`);
+  startServices();
   const child = spawn('npx', ['next', 'dev', '--turbopack', '-p', String(webPort)], {
     cwd: ROOT,
     stdio: 'inherit',
-    env: { ...process.env },
+    env: { ...process.env, FORGE_EXTERNAL_SERVICES: '1' },
   });
-  child.on('exit', (code) => process.exit(code || 0));
+  child.on('exit', (code) => { stopServices(); process.exit(code || 0); });
 } else {
   if (!existsSync(join(ROOT, '.next', 'BUILD_ID'))) {
     console.log('[forge] Building...');
     execSync('npx next build', { cwd: ROOT, stdio: 'inherit', env: { ...process.env } });
   }
   console.log(`[forge] Starting server (port ${webPort}, terminal ${terminalPort}, data ${DATA_DIR})`);
+  startServices();
   const child = spawn('npx', ['next', 'start', '-p', String(webPort)], {
     cwd: ROOT,
     stdio: 'inherit',
-    env: { ...process.env },
+    env: { ...process.env, FORGE_EXTERNAL_SERVICES: '1' },
   });
-  child.on('exit', (code) => process.exit(code || 0));
+  child.on('exit', (code) => { stopServices(); process.exit(code || 0); });
 }

package/components/SettingsModal.tsx

@@ -2,6 +2,33 @@
 
 import { useState, useEffect, useCallback } from 'react';
 
+function SecretInput({ value, onChange, placeholder, className }: {
+  value: string;
+  onChange: (v: string) => void;
+  placeholder?: string;
+  className?: string;
+}) {
+  const [show, setShow] = useState(false);
+  return (
+    <div className="relative">
+      <input
+        type={show ? 'text' : 'password'}
+        value={value}
+        onChange={e => onChange(e.target.value)}
+        placeholder={placeholder}
+        className={className}
+      />
+      <button
+        type="button"
+        onClick={() => setShow(v => !v)}
+        className="absolute right-2 top-1/2 -translate-y-1/2 text-[10px] text-[var(--text-secondary)] hover:text-[var(--text-primary)]"
+      >
+        {show ? '🙈' : '👁'}
+      </button>
+    </div>
+  );
+}
+
 interface Settings {
   projectRoots: string[];
   docRoots: string[];
@@ -213,11 +240,11 @@ export default function SettingsModal({ onClose }: { onClose: () => void }) {
           <p className="text-[10px] text-[var(--text-secondary)]">
             Get notified when tasks complete or fail. Create a bot via @BotFather, then send /start to it and use the test button below to get your chat ID.
           </p>
-          <input
+          <SecretInput
             value={settings.telegramBotToken}
-            onChange={e => setSettings({ ...settings, telegramBotToken: e.target.value })}
+            onChange={v => setSettings({ ...settings, telegramBotToken: v })}
             placeholder="Bot token (from @BotFather)"
-            className="w-full px-2 py-1.5 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-xs text-[var(--text-primary)] font-mono focus:outline-none focus:border-[var(--accent)]"
+            className="w-full px-2 py-1.5 pr-8 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-xs text-[var(--text-primary)] font-mono focus:outline-none focus:border-[var(--accent)]"
           />
           <input
             value={settings.telegramChatId}
@@ -446,11 +473,11 @@ export default function SettingsModal({ onClose }: { onClose: () => void }) {
             <label className="text-[10px] text-[var(--text-secondary)]">
               Telegram tunnel password (for /tunnel_password command)
             </label>
-            <input
+            <SecretInput
               value={settings.telegramTunnelPassword}
-              onChange={e => setSettings({ ...settings, telegramTunnelPassword: e.target.value })}
+              onChange={v => setSettings({ ...settings, telegramTunnelPassword: v })}
               placeholder="Set a password to get login credentials via Telegram"
-              className="w-full px-2 py-1.5 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-xs text-[var(--text-primary)] font-mono focus:outline-none focus:border-[var(--accent)]"
+              className="w-full px-2 py-1.5 pr-8 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-xs text-[var(--text-primary)] font-mono focus:outline-none focus:border-[var(--accent)]"
             />
           </div>
         </div>

package/dev-test.sh

@@ -2,4 +2,4 @@
 # dev-test.sh — Start Forge test instance (port 4000, data ~/.forge-test)
 
 mkdir -p ~/.forge-test
-PORT=4000 TERMINAL_PORT=4001 FORGE_DATA_DIR=~/.forge-test npx next dev --turbopack -p 4000
+PORT=4000 TERMINAL_PORT=4001 FORGE_DATA_DIR=~/.forge-test FORGE_EXTERNAL_SERVICES=0 npx next dev --turbopack -p 4000

package/lib/cloudflared.ts

@@ -4,7 +4,7 @@
  */
 
 import { spawn, execSync, type ChildProcess } from 'node:child_process';
-import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync } from 'node:fs';
+import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync, writeFileSync, readFileSync } from 'node:fs';
 import { homedir, platform, arch } from 'node:os';
 import { join } from 'node:path';
 import https from 'node:https';
@@ -105,6 +105,23 @@ if (!gAny[stateKey]) {
 const state: TunnelState = gAny[stateKey];
 
 const MAX_LOG_LINES = 100;
+const TUNNEL_STATE_FILE = join(homedir(), '.forge', 'tunnel-state.json');
+
+function saveTunnelState() {
+  try {
+    writeFileSync(TUNNEL_STATE_FILE, JSON.stringify({
+      url: state.url, status: state.status, error: state.error, pid: state.process?.pid || null,
+    }));
+  } catch {}
+}
+
+function loadTunnelState(): { url: string | null; status: string; error: string | null; pid: number | null } {
+  try {
+    return JSON.parse(readFileSync(TUNNEL_STATE_FILE, 'utf-8'));
+  } catch {
+    return { url: null, status: 'stopped', error: null, pid: null };
+  }
+}
 
 function pushLog(line: string) {
   state.log.push(line);
@@ -112,10 +129,26 @@ function pushLog(line: string) {
 }
 
 export async function startTunnel(localPort: number = 3000): Promise<{ url?: string; error?: string }> {
+  // Check if this worker already has a process
   if (state.process) {
     return state.url ? { url: state.url } : { error: 'Tunnel is starting...' };
   }
 
+  // Check if another process already has a tunnel running
+  const saved = loadTunnelState();
+  if (saved.pid && saved.status === 'running' && saved.url) {
+    try { process.kill(saved.pid, 0); return { url: saved.url }; } catch {}
+  }
+
+  // Kill ALL existing cloudflared processes to prevent duplicates
+  try {
+    const { execSync } = require('node:child_process');
+    const pids = execSync("pgrep -f 'cloudflared tunnel'", { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    for (const pid of pids.split('\n').filter(Boolean)) {
+      try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
+    }
+  } catch {}
+
   state.status = 'starting';
   state.url = null;
   state.error = null;
@@ -149,6 +182,7 @@ export async function startTunnel(localPort: number = 3000): Promise<{ url?: str
         if (urlMatch && !state.url) {
           state.url = urlMatch[1];
           state.status = 'running';
+          saveTunnelState();
           console.log(`[cloudflared] Tunnel URL: ${state.url}`);
           startHealthCheck();
           if (!resolved) {
@@ -178,6 +212,7 @@ export async function startTunnel(localPort: number = 3000): Promise<{ url?: str
         state.status = 'stopped';
       }
       state.url = null;
+      saveTunnelState();
       pushLog(`[exit] cloudflared exited with code ${code}`);
       if (!resolved) {
         resolved = true;
@@ -204,16 +239,40 @@ export function stopTunnel() {
     state.process.kill('SIGTERM');
     state.process = null;
   }
+  // Also kill by saved PID in case another worker started it
+  const saved = loadTunnelState();
+  if (saved.pid) {
+    try { process.kill(saved.pid, 'SIGTERM'); } catch {}
+  }
   state.url = null;
   state.status = 'stopped';
   state.error = null;
+  saveTunnelState();
 }
 
 export function getTunnelStatus() {
+  // If this worker has the process, use in-memory state
+  if (state.process) {
+    return {
+      status: state.status,
+      url: state.url,
+      error: state.error,
+      installed: isInstalled(),
+      log: state.log.slice(-20),
+    };
+  }
+  // Otherwise read from file (another worker may have started it)
+  const saved = loadTunnelState();
+  if (saved.pid && saved.status === 'running') {
+    try { process.kill(saved.pid, 0); } catch {
+      // Process dead — clear stale state
+      return { status: 'stopped' as const, url: null, error: null, installed: isInstalled(), log: [] };
+    }
+  }
   return {
-    status: state.status,
-    url: state.url,
-    error: state.error,
+    status: (saved.status || 'stopped') as TunnelState['status'],
+    url: saved.url,
+    error: saved.error,
     installed: isInstalled(),
     log: state.log.slice(-20),
   };

package/lib/init.ts

@@ -1,6 +1,7 @@
 /**
- * Server-side initialization — called once on first API request.
- * Starts background services: task runner, Telegram bot.
+ * Server-side initialization — called once on first API request per worker.
+ * When FORGE_EXTERNAL_SERVICES=1 (set by forge-server), telegram/terminal/tunnel
+ * are managed externally — only task runner starts here.
  */
 
 import { ensureRunnerStarted } from './task-manager';
@@ -19,24 +20,30 @@ export function ensureInitialized() {
   if (gInit[initKey]) return;
   gInit[initKey] = true;
 
-  // Display login password (auto-generated, rotates daily)
+  // Task runner is safe in every worker (DB-level coordination)
+  ensureRunnerStarted();
+
+  // Session watcher is safe (file-based, idempotent)
+  startWatcherLoop();
+
+  // If services are managed externally (forge-server), skip
+  if (process.env.FORGE_EXTERNAL_SERVICES === '1') {
+    // Password display only once
+    const password = getPassword();
+    console.log(`[init] Login password: ${password} (valid today)`);
+    console.log('[init] Forgot? Run: forge password');
+    return;
+  }
+
+  // Standalone mode (pnpm dev without forge-server) — start everything here
   const password = getPassword();
   console.log(`[init] Login password: ${password} (valid today)`);
   console.log('[init] Forgot? Run: forge password');
 
-  // Start background task runner
-  ensureRunnerStarted();
-
-  // Start Telegram bot if configured
-  startTelegramBot();
-
-  // Start terminal WebSocket server as separate process (node-pty needs native module)
+  startTelegramBot(); // registers task event listener only
   startTerminalProcess();
+  startTelegramProcess(); // spawns telegram-standalone
 
-  // Start session watcher loop
-  startWatcherLoop();
-
-  // Auto-start tunnel if configured
   const settings = loadSettings();
   if (settings.tunnelAutoStart) {
     startTunnel().then(result => {
@@ -54,6 +61,23 @@ export function restartTelegramBot() {
   startTelegramBot();
 }
 
+let telegramChild: ReturnType<typeof spawn> | null = null;
+
+function startTelegramProcess() {
+  if (telegramChild) return;
+  const settings = loadSettings();
+  if (!settings.telegramBotToken || !settings.telegramChatId) return;
+
+  const script = join(process.cwd(), 'lib', 'telegram-standalone.ts');
+  telegramChild = spawn('npx', ['tsx', script], {
+    stdio: ['ignore', 'inherit', 'inherit'],
+    env: { ...process.env, PORT: String(process.env.PORT || 3000) },
+    detached: false,
+  });
+  telegramChild.on('exit', () => { telegramChild = null; });
+  console.log('[telegram] Started standalone (pid:', telegramChild.pid, ')');
+}
+
 let terminalChild: ReturnType<typeof spawn> | null = null;
 
 function startTerminalProcess() {
@@ -61,11 +85,9 @@ function startTerminalProcess() {
 
   const termPort = Number(process.env.TERMINAL_PORT) || 3001;
 
-  // Check if port is already in use — kill stale process if needed
   const net = require('node:net');
   const tester = net.createServer();
   tester.once('error', () => {
-    // Port in use — terminal server already running, reuse it
     console.log(`[terminal] Port ${termPort} already in use, reusing existing`);
   });
   tester.once('listening', () => {

package/lib/telegram-bot.ts

@@ -16,11 +16,11 @@ import { startTunnel, stopTunnel, getTunnelStatus } from './cloudflared';
 import { getPassword } from './password';
 import type { Task, TaskLogEntry } from '@/src/types';
 
-// Prevent duplicate polling and state loss across hot-reloads
+// Persist state across hot-reloads
 const globalKey = Symbol.for('mw-telegram-state');
 const g = globalThis as any;
-if (!g[globalKey]) g[globalKey] = { polling: false, pollTimer: null, lastUpdateId: 0, taskListenerAttached: false, pollActive: false, processedMsgIds: new Set<number>(), pollGeneration: 0 };
-const botState: { polling: boolean; pollTimer: ReturnType<typeof setTimeout> | null; lastUpdateId: number; taskListenerAttached: boolean; pollActive: boolean; processedMsgIds: Set<number>; pollGeneration: number } = g[globalKey];
+if (!g[globalKey]) g[globalKey] = { taskListenerAttached: false, processedMsgIds: new Set<number>() };
+const botState: { taskListenerAttached: boolean; processedMsgIds: Set<number> } = g[globalKey];
 
 // Track which Telegram message maps to which task (for reply-based interaction)
 const taskMessageMap = new Map<number, string>(); // messageId → taskId
@@ -45,31 +45,22 @@ const logBuffers = new Map<string, { entries: string[]; timer: ReturnType<typeof
 
 // ─── Start/Stop ──────────────────────────────────────────────
 
+// telegram-standalone process is managed by forge-server.mjs
+
 export function startTelegramBot() {
   const settings = loadSettings();
   if (!settings.telegramBotToken || !settings.telegramChatId) return;
 
-  // Kill any existing poll loop (handles hot-reload creating duplicates)
-  if (botState.polling) {
-    botState.pollGeneration++;
-    if (botState.pollTimer) { clearTimeout(botState.pollTimer); botState.pollTimer = null; }
-    botState.pollActive = false;
-  }
-
-  botState.polling = true;
-  console.log('[telegram] Bot started');
-
   // Set bot command menu
   setBotCommands(settings.telegramBotToken);
 
-  // Listen for task events → stream to Telegram (only once)
+  // Listen for task events → stream to Telegram (only once per worker)
   if (!botState.taskListenerAttached) {
     botState.taskListenerAttached = true;
     onTaskEvent((taskId, event, data) => {
       const settings = loadSettings();
       if (!settings.telegramBotToken || !settings.telegramChatId) return;
 
-      // Skip pipeline tasks — they have their own notification
       try {
         const { pipelineTaskIds } = require('./pipeline');
         if (pipelineTaskIds.has(taskId)) return;
@@ -85,75 +76,20 @@ export function startTelegramBot() {
     });
   }
 
-  // Skip stale updates on startup — set offset to -1 to get only new messages
-  if (botState.lastUpdateId === 0) {
-    fetch(`https://api.telegram.org/bot${settings.telegramBotToken}/getUpdates?offset=-1`)
-      .then(r => r.json())
-      .then(data => {
-        if (data.ok && data.result?.length > 0) {
-          botState.lastUpdateId = data.result[data.result.length - 1].update_id;
-        }
-        poll();
-      })
-      .catch(() => poll());
-  } else {
-    poll();
-  }
+  // Note: telegram-standalone process is started by forge-server.mjs, not here.
+  // This function only sets up the task event listener and bot commands.
 }
 
 export function stopTelegramBot() {
-  botState.polling = false;
-  botState.pollActive = false;
-  if (botState.pollTimer) { clearTimeout(botState.pollTimer); botState.pollTimer = null; }
-}
-
-// ─── Polling ─────────────────────────────────────────────────
-
-function schedulePoll(delay: number = 1000) {
-  if (botState.pollTimer) clearTimeout(botState.pollTimer);
-  botState.pollTimer = setTimeout(poll, delay);
-}
-
-async function poll() {
-  const myGeneration = botState.pollGeneration;
-
-  // Prevent concurrent polls
-  if (!botState.polling || botState.pollActive) return;
-  botState.pollActive = true;
-
-  try {
-    const settings = loadSettings();
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 35000);
-
-    const url = `https://api.telegram.org/bot${settings.telegramBotToken}/getUpdates?offset=${botState.lastUpdateId + 1}&timeout=30`;
-    const res = await fetch(url, { signal: controller.signal });
-    clearTimeout(timeout);
-
-    const data = await res.json();
-
-    if (data.ok && data.result && data.result.length > 0) {
-      console.log(`[telegram] Poll got ${data.result.length} updates, lastId=${botState.lastUpdateId}`);
-      for (const update of data.result) {
-        if (update.update_id <= botState.lastUpdateId) continue;
-        botState.lastUpdateId = update.update_id;
-        if (update.message?.text) {
-          console.log(`[telegram] Processing msg ${update.message.message_id}: ${update.message.text.slice(0, 30)}`);
-          await handleMessage(update.message);
-        }
-      }
-    }
-  } catch {
-    // Network errors during sleep/wake — silent
-  }
-
-  botState.pollActive = false;
-  // Only continue polling if this is still the current generation
-  if (botState.polling && myGeneration === botState.pollGeneration) schedulePoll(1000);
+  // telegram-standalone is managed by forge-server.mjs
+  // This is a no-op now, kept for API compatibility
 }
 
 // ─── Message Handler ─────────────────────────────────────────
 
+// Exported for API route — called by telegram-standalone via /api/telegram
+export async function handleTelegramMessage(msg: any) { return handleMessage(msg); }
+
 async function handleMessage(msg: any) {
   const chatId = msg.chat.id;
 

package/lib/telegram-standalone.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone Telegram bot process.
+ * Runs as a single process — no duplication from Next.js workers.
+ */
+
+import { loadSettings } from './settings';
+import { getPassword } from './password';
+
+const settings = loadSettings();
+if (!settings.telegramBotToken || !settings.telegramChatId) {
+  console.log('[telegram] No token or chatId configured, exiting');
+  process.exit(0);
+}
+
+const TOKEN = settings.telegramBotToken;
+const ALLOWED_IDS = settings.telegramChatId.split(',').map(s => s.trim()).filter(Boolean);
+let lastUpdateId = 0;
+let polling = true;
+const processedMsgIds = new Set<number>();
+
+// Skip stale messages on startup
+async function init() {
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${TOKEN}/getUpdates?offset=-1`);
+    const data = await res.json();
+    if (data.ok && data.result?.length > 0) {
+      lastUpdateId = data.result[data.result.length - 1].update_id;
+    }
+  } catch {}
+  console.log('[telegram] Bot started (standalone)');
+  poll();
+}
+
+async function poll() {
+  if (!polling) return;
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 35000);
+
+    const res = await fetch(
+      `https://api.telegram.org/bot${TOKEN}/getUpdates?offset=${lastUpdateId + 1}&timeout=30`,
+      { signal: controller.signal }
+    );
+    clearTimeout(timeout);
+
+    const data = await res.json();
+    if (data.ok && data.result) {
+      for (const update of data.result) {
+        if (update.update_id <= lastUpdateId) continue;
+        lastUpdateId = update.update_id;
+
+        if (update.message?.text) {
+          const msgId = update.message.message_id;
+          if (processedMsgIds.has(msgId)) continue;
+          processedMsgIds.add(msgId);
+          if (processedMsgIds.size > 200) {
+            const oldest = [...processedMsgIds].slice(0, 100);
+            oldest.forEach(id => processedMsgIds.delete(id));
+          }
+
+          // Forward to Next.js API for processing
+          try {
+            await fetch(`http://localhost:${process.env.PORT || 3000}/api/telegram`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json', 'x-telegram-secret': TOKEN },
+              body: JSON.stringify(update.message),
+            });
+          } catch {}
+        }
+      }
+    }
+  } catch {
+    // Network error — silent retry
+  }
+
+  setTimeout(poll, 1000);
+}
+
+process.on('SIGTERM', () => { polling = false; process.exit(0); });
+process.on('SIGINT', () => { polling = false; process.exit(0); });
+
+init();

package/middleware.ts

@@ -7,6 +7,7 @@ export function middleware(req: NextRequest) {
   if (
     pathname.startsWith('/login') ||
     pathname.startsWith('/api/auth') ||
+    pathname.startsWith('/api/telegram') ||
     pathname.startsWith('/_next') ||
     pathname === '/favicon.ico'
   ) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {

package/start.sh

@@ -0,0 +1,21 @@
+#!/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 'cloudflared tunnel' 2>/dev/null
+pkill -f 'next-server' 2>/dev/null
+pkill -f 'next start' 2>/dev/null
+pkill -f 'next dev' 2>/dev/null
+sleep 1
+
+if [ "$1" = "dev" ]; then
+  pnpm dev
+else
+  pnpm build && pnpm start
+fi