@aion0/forge 0.1.6 → 0.1.8

package/app/api/terminal-state/route.ts

@@ -0,0 +1,15 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { NextResponse } from 'next/server';
+
+const STATE_FILE = join(homedir(), '.forge', 'terminal-state.json');
+
+export async function GET() {
+  try {
+    const data = JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+    return NextResponse.json(data);
+  } catch {
+    return NextResponse.json(null);
+  }
+}

package/bin/forge-server.mjs

@@ -24,6 +24,7 @@ const LOG_FILE = join(DATA_DIR, 'forge.log');
 const isDev = process.argv.includes('--dev');
 const isBackground = process.argv.includes('--background');
 const isStop = process.argv.includes('--stop');
+const isRebuild = process.argv.includes('--rebuild');
 
 process.chdir(ROOT);
 mkdirSync(DATA_DIR, { recursive: true });
@@ -55,6 +56,25 @@ if (isStop) {
   process.exit(0);
 }
 
+// ── Rebuild ──
+if (isRebuild || existsSync(join(ROOT, '.next', 'BUILD_ID'))) {
+  // Always rebuild after npm install (new version)
+  const buildIdFile = join(ROOT, '.next', 'BUILD_ID');
+  const pkgVersion = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8')).version;
+  const versionFile = join(ROOT, '.next', '.forge-version');
+  const lastBuiltVersion = existsSync(versionFile) ? readFileSync(versionFile, 'utf-8').trim() : '';
+  if (isRebuild || lastBuiltVersion !== pkgVersion) {
+    console.log(`[forge] Rebuilding (v${pkgVersion})...`);
+    execSync('rm -rf .next', { cwd: ROOT });
+    execSync('npx next build', { cwd: ROOT, stdio: 'inherit' });
+    writeFileSync(versionFile, pkgVersion);
+    if (isRebuild) {
+      console.log('[forge] Rebuild complete');
+      process.exit(0);
+    }
+  }
+}
+
 // ── Background ──
 if (isBackground) {
   // Build if needed

package/components/WebTerminal.tsx

@@ -46,35 +46,19 @@ function getWsUrl() {
   return `${wsProtocol}//${wsHost}:3001`;
 }
 
-/** Load shared terminal state from server */
-function loadSharedState(): Promise<{ tabs: TabState[]; activeTabId: number; sessionLabels: Record<string, string> } | null> {
-  return new Promise((resolve) => {
-    const timeout = setTimeout(() => resolve(null), 3000);
-    try {
-      const ws = new WebSocket(getWsUrl());
-      ws.onopen = () => ws.send(JSON.stringify({ type: 'load-state' }));
-      ws.onmessage = (e) => {
-        clearTimeout(timeout);
-        try {
-          const msg = JSON.parse(e.data);
-          if (msg.type === 'terminal-state' && msg.data) {
-            const d = msg.data;
-            if (Array.isArray(d.tabs) && d.tabs.length > 0 && typeof d.activeTabId === 'number') {
-              resolve({ tabs: d.tabs, activeTabId: d.activeTabId, sessionLabels: d.sessionLabels || {} });
-              ws.close();
-              return;
-            }
-          }
-        } catch {}
-        resolve(null);
-        ws.close();
-      };
-      ws.onerror = () => { clearTimeout(timeout); resolve(null); };
-    } catch {
-      clearTimeout(timeout);
-      resolve(null);
+/** Load shared terminal state via API (always available, doesn't depend on terminal WebSocket server) */
+async function loadSharedState(): Promise<{ tabs: TabState[]; activeTabId: number; sessionLabels: Record<string, string> } | null> {
+  try {
+    const res = await fetch('/api/terminal-state');
+    if (!res.ok) return null;
+    const d = await res.json();
+    if (d && Array.isArray(d.tabs) && d.tabs.length > 0 && typeof d.activeTabId === 'number') {
+      return { tabs: d.tabs, activeTabId: d.activeTabId, sessionLabels: d.sessionLabels || {} };
     }
-  });
+    return null;
+  } catch {
+    return null;
+  }
 }
 
 /** Save shared terminal state to server (fire-and-forget) */
@@ -179,6 +163,7 @@ const WebTerminal = forwardRef<WebTerminalHandle>(function WebTerminal(_props, r
   });
   const [activeTabId, setActiveTabId] = useState(() => tabs[0]?.id || 1);
   const [hydrated, setHydrated] = useState(false);
+  const stateLoadedRef = useRef(false);
   const [tmuxSessions, setTmuxSessions] = useState<TmuxSession[]>([]);
   const [showSessionPicker, setShowSessionPicker] = useState(false);
   const [editingTabId, setEditingTabId] = useState<number | null>(null);
@@ -196,6 +181,7 @@ const WebTerminal = forwardRef<WebTerminalHandle>(function WebTerminal(_props, r
         setTabs(saved.tabs);
         setActiveTabId(saved.activeTabId);
         sessionLabelsRef.current = saved.sessionLabels || {};
+        stateLoadedRef.current = true;
       }
       setHydrated(true);
     });
@@ -345,6 +331,7 @@ const WebTerminal = forwardRef<WebTerminalHandle>(function WebTerminal(_props, r
   }, [activeTabId]);
 
   const onSessionConnected = useCallback((paneId: number, sessionName: string) => {
+    stateLoadedRef.current = true; // Allow saving once a session is connected
     setTabs(prev => prev.map(t => ({
       ...t,
       tree: updateSessionName(t.tree, paneId, sessionName),

package/lib/terminal-standalone.ts

@@ -182,23 +182,51 @@ function trackDetach(ws: WebSocket, sessionName: string) {
 
 // ─── Periodic orphan cleanup ─────────────────────────────────
 
-/** Clean up detached tmux sessions that no WS client is connected to (skip renamed ones) */
+/** Clean up detached tmux sessions that are not tracked in terminal-state.json */
 function cleanupOrphanedSessions() {
-  const renamed = getRenamedSessions();
+  const knownSessions = getKnownSessions();
   const sessions = listTmuxSessions();
   for (const s of sessions) {
     if (s.attached) continue;
-    if (renamed.has(s.name)) continue; // user renamed — preserve
+    if (knownSessions.has(s.name)) continue; // saved in terminal state — preserve
     const clients = sessionClients.get(s.name)?.size ?? 0;
     if (clients === 0) {
-      console.log(`[terminal] Cleanup: killing orphaned session "${s.name}" (no clients, not renamed)`);
       killTmuxSession(s.name);
     }
   }
 }
 
-// Run cleanup every 30 seconds
-setInterval(cleanupOrphanedSessions, 30_000);
+/** Get all session names referenced in terminal-state.json (tabs + labels) */
+function getKnownSessions(): Set<string> {
+  try {
+    const state = loadTerminalState() as any;
+    if (!state) return new Set();
+    const known = new Set<string>();
+    // From sessionLabels
+    if (state.sessionLabels) {
+      for (const name of Object.keys(state.sessionLabels)) known.add(name);
+    }
+    // From tab trees
+    if (state.tabs) {
+      for (const tab of state.tabs) {
+        collectTreeSessions(tab.tree, known);
+      }
+    }
+    return known;
+  } catch {
+    return new Set();
+  }
+}
+
+function collectTreeSessions(node: any, set: Set<string>) {
+  if (!node) return;
+  if (node.type === 'terminal' && node.sessionName) set.add(node.sessionName);
+  if (node.first) collectTreeSessions(node.first, set);
+  if (node.second) collectTreeSessions(node.second, set);
+}
+
+// Run cleanup every 60 seconds, with a 60s initial delay to let clients reconnect after restart
+setTimeout(() => setInterval(cleanupOrphanedSessions, 60_000), 60_000);
 
 // ─── WebSocket server ──────────────────────────────────────────
 

package/package.json

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