@aion0/forge 0.1.4 → 0.1.7

package/README.md

@@ -166,7 +166,8 @@ All config lives in `~/.forge/`:
 
 ```
 ~/.forge/
-  settings.yaml       # Main configuration
+  .env.local           # Environment variables (AUTH_SECRET, API keys, etc.)
+  settings.yaml        # Main configuration
   password.json        # Daily auto-generated login password
   data.db              # SQLite database (tasks, sessions)
   terminal-state.json  # Terminal tab layout
@@ -174,6 +175,18 @@ All config lives in `~/.forge/`:
   bin/                 # Auto-downloaded binaries (cloudflared)
 ```
 
+### .env.local (optional)
+
+```env
+# Fixed auth secret (optional — auto-generated if not set)
+AUTH_SECRET=<random-string>
+
+# Optional: AI provider API keys for multi-model chat
+# ANTHROPIC_API_KEY=sk-ant-...
+# OPENAI_API_KEY=sk-...
+# GOOGLE_GENERATIVE_AI_API_KEY=AI...
+```
+
 ### settings.yaml
 
 ```yaml

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

@@ -28,6 +28,20 @@ const isStop = process.argv.includes('--stop');
 process.chdir(ROOT);
 mkdirSync(DATA_DIR, { recursive: true });
 
+// ── Load ~/.forge/.env.local ──
+const envFile = join(DATA_DIR, '.env.local');
+if (existsSync(envFile)) {
+  for (const line of readFileSync(envFile, 'utf-8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const val = trimmed.slice(eq + 1).trim();
+    if (!process.env[key]) process.env[key] = val;
+  }
+}
+
 // ── Stop ──
 if (isStop) {
   try {

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/instrumentation.ts

@@ -5,10 +5,27 @@
 export async function register() {
   // Only run on server, not Edge
   if (process.env.NEXT_RUNTIME === 'nodejs') {
+    // Load ~/.forge/.env.local if it exists (works for both pnpm dev and forge-server)
+    const { existsSync, readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const { homedir } = await import('node:os');
+    const envFile = join(homedir(), '.forge', '.env.local');
+    if (existsSync(envFile)) {
+      for (const line of readFileSync(envFile, 'utf-8').split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eq = trimmed.indexOf('=');
+        if (eq === -1) continue;
+        const key = trimmed.slice(0, eq).trim();
+        const val = trimmed.slice(eq + 1).trim();
+        if (!process.env[key]) process.env[key] = val;
+      }
+    }
+
     const { getPassword } = await import('./lib/password');
     const password = getPassword();
     process.env.MW_PASSWORD = password;
     console.log(`[init] Login password: ${password}`);
-    console.log('[init] Forgot password? Run: mw password');
+    console.log('[init] Forgot password? Run: forge password');
   }
 }

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 ──────────────────────────────────────────
 
@@ -352,18 +380,7 @@ wss.on('connection', (ws: WebSocket) => {
     if (sessionName) trackDetach(ws, sessionName);
     createdAt.delete(ws);
 
-    // Grace period cleanup: if no client reconnects within 10s, kill the session (unless renamed)
-    if (disconnectedSession) {
-      setTimeout(() => {
-        const clients = sessionClients.get(disconnectedSession)?.size ?? 0;
-        if (clients === 0 && tmuxSessionExists(disconnectedSession)) {
-          const renamed = getRenamedSessions();
-          if (!renamed.has(disconnectedSession)) {
-            console.log(`[terminal] Auto-killing orphaned session "${disconnectedSession}" (no clients after 10s, not renamed)`);
-            killTmuxSession(disconnectedSession);
-          }
-        }
-      }, 10_000);
-    }
+    // Orphan cleanup is handled by the periodic cleanupOrphanedSessions() (every 30s)
+    // which checks sessionClients and getRenamedSessions() from terminal-state.json
   });
 });

package/package.json

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