@aion0/forge 0.3.6 → 0.3.7

package/app/api/logs/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from 'next/server';
+import { existsSync, statSync, openSync, readSync, closeSync, writeFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir } from '@/lib/dirs';
+import { execSync } from 'node:child_process';
+
+const LOG_FILE = join(getDataDir(), 'forge.log');
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB — auto-rotate above this
+
+/** Read last N bytes from file (efficient tail) */
+function tailFile(filePath: string, maxBytes: number): string {
+  const stat = statSync(filePath);
+  const size = stat.size;
+  const readSize = Math.min(size, maxBytes);
+  const buf = Buffer.alloc(readSize);
+  const fd = openSync(filePath, 'r');
+  readSync(fd, buf, 0, readSize, size - readSize);
+  closeSync(fd);
+  // Skip partial first line
+  const str = buf.toString('utf-8');
+  const firstNewline = str.indexOf('\n');
+  return firstNewline > 0 ? str.slice(firstNewline + 1) : str;
+}
+
+/** Rotate log if too large: forge.log → forge.log.old, start fresh */
+function rotateIfNeeded() {
+  if (!existsSync(LOG_FILE)) return;
+  const stat = statSync(LOG_FILE);
+  if (stat.size > MAX_LOG_SIZE) {
+    const oldFile = LOG_FILE + '.old';
+    try { renameSync(LOG_FILE, oldFile); } catch {}
+    writeFileSync(LOG_FILE, `[forge] Log rotated at ${new Date().toISOString()} (previous: ${(stat.size / 1024 / 1024).toFixed(1)}MB)\n`, 'utf-8');
+  }
+}
+
+// GET /api/logs?lines=200&search=keyword
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const lines = Math.min(parseInt(searchParams.get('lines') || '200'), 1000);
+  const search = searchParams.get('search') || '';
+
+  rotateIfNeeded();
+
+  if (!existsSync(LOG_FILE)) {
+    return NextResponse.json({ lines: [], total: 0, size: 0 });
+  }
+
+  try {
+    const stat = statSync(LOG_FILE);
+    // Read last 512KB max (enough for ~5000 lines)
+    const raw = tailFile(LOG_FILE, 512 * 1024);
+    let allLines = raw.split('\n').filter(Boolean);
+
+    if (search) {
+      allLines = allLines.filter(l => l.toLowerCase().includes(search.toLowerCase()));
+    }
+
+    const result = allLines.slice(-lines);
+
+    return NextResponse.json({
+      lines: result,
+      total: allLines.length,
+      size: stat.size,
+      file: LOG_FILE,
+    });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+// POST /api/logs — actions
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  if (body.action === 'clear') {
+    try {
+      writeFileSync(LOG_FILE, `[forge] Log cleared at ${new Date().toISOString()}\n`, 'utf-8');
+      return NextResponse.json({ ok: true });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+  }
+
+  if (body.action === 'processes') {
+    try {
+      const out = execSync("ps aux | grep -E 'next-server|telegram-standalone|terminal-standalone|cloudflared' | grep -v grep", {
+        encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      const processes = out.split('\n').filter(Boolean).map(line => {
+        const parts = line.trim().split(/\s+/);
+        return { pid: parts[1], cpu: parts[2], mem: parts[3], cmd: parts.slice(10).join(' ').slice(0, 80) };
+      });
+      return NextResponse.json({ processes });
+    } catch {
+      return NextResponse.json({ processes: [] });
+    }
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}

package/app/api/settings/route.ts

@@ -56,6 +56,8 @@ export async function PUT(req: Request) {
   // Remove internal fields
   delete (updated as any)._secretStatus;
 
+  const changed = Object.keys(updated).filter(k => JSON.stringify((updated as any)[k]) !== JSON.stringify((settings as any)[k]) && !['telegramTunnelPassword', 'telegramBotToken'].includes(k));
+  if (changed.length > 0) console.log(`[settings] Updated: ${changed.join(', ')}`);
   saveSettings(updated);
   restartTelegramBot();
   return NextResponse.json({ ok: true });

package/bin/forge-server.mjs

@@ -72,6 +72,15 @@ const LOG_FILE = join(DATA_DIR, 'forge.log');
 
 process.chdir(ROOT);
 
+// ── Add timestamps to all console output ──
+const origLog = console.log;
+const origError = console.error;
+const origWarn = console.warn;
+const ts = () => new Date().toISOString().replace('T', ' ').slice(0, 19);
+console.log = (...args) => origLog(`[${ts()}]`, ...args);
+console.error = (...args) => origError(`[${ts()}]`, ...args);
+console.warn = (...args) => origWarn(`[${ts()}]`, ...args);
+
 // ── Migrate old layout (~/.forge/*) to new (~/.forge/data/*) ──
 if (!getArg('--dir')) {
   const oldSettings = join(homedir(), '.forge', 'settings.yaml');

package/components/Dashboard.tsx

@@ -19,6 +19,7 @@ const ProjectManager = lazy(() => import('./ProjectManager'));
 const PreviewPanel = lazy(() => import('./PreviewPanel'));
 const PipelineView = lazy(() => import('./PipelineView'));
 const HelpDialog = lazy(() => import('./HelpDialog'));
+const LogViewer = lazy(() => import('./LogViewer'));
 const SkillsPanel = lazy(() => import('./SkillsPanel'));
 
 interface UsageSummary {
@@ -42,7 +43,7 @@ interface ProjectInfo {
 }
 
 export default function Dashboard({ user }: { user: any }) {
-  const [viewMode, setViewMode] = useState<'tasks' | 'sessions' | 'terminal' | 'docs' | 'projects' | 'preview' | 'pipelines' | 'skills'>('terminal');
+  const [viewMode, setViewMode] = useState<'tasks' | 'sessions' | 'terminal' | 'docs' | 'projects' | 'preview' | 'pipelines' | 'skills' | 'logs'>('terminal');
   const [tasks, setTasks] = useState<Task[]>([]);
   const [activeTaskId, setActiveTaskId] = useState<string | null>(null);
   const [showNewTask, setShowNewTask] = useState(false);
@@ -427,6 +428,12 @@ export default function Dashboard({ user }: { user: any }) {
                   >
                     Settings
                   </button>
+                  <button
+                    onClick={() => { setViewMode('logs'); setShowUserMenu(false); }}
+                    className="w-full text-left text-[11px] px-3 py-1.5 text-[var(--text-secondary)] hover:text-[var(--text-primary)] hover:bg-[var(--bg-tertiary)]"
+                  >
+                    Logs
+                  </button>
                   <div className="border-t border-[var(--border)] my-1" />
                   <button
                     onClick={() => signOut({ callbackUrl: '/login' })}
@@ -573,6 +580,13 @@ export default function Dashboard({ user }: { user: any }) {
           </Suspense>
         )}
 
+        {/* Logs */}
+        {viewMode === 'logs' && (
+          <Suspense fallback={<div className="flex-1 flex items-center justify-center text-[var(--text-secondary)]">Loading...</div>}>
+            <LogViewer />
+          </Suspense>
+        )}
+
         {/* Docs — always mounted to keep terminal session alive */}
         <div className={viewMode === 'docs' ? 'flex-1 min-h-0 flex' : 'hidden'}>
           <Suspense fallback={<div className="flex-1 flex items-center justify-center text-[var(--text-secondary)]">Loading...</div>}>

package/components/LogViewer.tsx

@@ -0,0 +1,194 @@
+'use client';
+
+import { useState, useEffect, useRef, useCallback } from 'react';
+
+export default function LogViewer() {
+  const [lines, setLines] = useState<string[]>([]);
+  const [total, setTotal] = useState(0);
+  const [fileSize, setFileSize] = useState(0);
+  const [filePath, setFilePath] = useState('');
+  const [search, setSearch] = useState('');
+  const [maxLines, setMaxLines] = useState(200);
+  const [autoRefresh, setAutoRefresh] = useState(true);
+  const [processes, setProcesses] = useState<{ pid: string; cpu: string; mem: string; cmd: string }[]>([]);
+  const [showProcesses, setShowProcesses] = useState(false);
+  const bottomRef = useRef<HTMLDivElement>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [autoScroll, setAutoScroll] = useState(true);
+
+  const fetchLogs = useCallback(async () => {
+    try {
+      const res = await fetch(`/api/logs?lines=${maxLines}${search ? `&search=${encodeURIComponent(search)}` : ''}`);
+      const data = await res.json();
+      setLines(data.lines || []);
+      setTotal(data.total || 0);
+      setFileSize(data.size || 0);
+      if (data.file) setFilePath(data.file);
+    } catch {}
+  }, [maxLines, search]);
+
+  const fetchProcesses = async () => {
+    try {
+      const res = await fetch('/api/logs', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'processes' }),
+      });
+      const data = await res.json();
+      setProcesses(data.processes || []);
+    } catch {}
+  };
+
+  const clearLogs = async () => {
+    if (!confirm('Clear all logs?')) return;
+    await fetch('/api/logs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'clear' }),
+    });
+    fetchLogs();
+  };
+
+  // Initial + auto refresh
+  useEffect(() => { fetchLogs(); }, [fetchLogs]);
+  useEffect(() => {
+    if (!autoRefresh) return;
+    const id = setInterval(fetchLogs, 3000);
+    return () => clearInterval(id);
+  }, [autoRefresh, fetchLogs]);
+
+  // Auto scroll
+  useEffect(() => {
+    if (autoScroll) bottomRef.current?.scrollIntoView({ behavior: 'smooth' });
+  }, [lines, autoScroll]);
+
+  // Detect manual scroll
+  const onScroll = () => {
+    const el = containerRef.current;
+    if (!el) return;
+    const atBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 50;
+    setAutoScroll(atBottom);
+  };
+
+  const formatSize = (bytes: number) => {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  };
+
+  const getLineColor = (line: string) => {
+    if (line.includes('[error]') || line.includes('Error') || line.includes('FATAL')) return 'text-red-400';
+    if (line.includes('[warn]') || line.includes('Warning') || line.includes('WARN')) return 'text-yellow-400';
+    if (line.includes('[forge]') || line.includes('[init]')) return 'text-cyan-400';
+    if (line.includes('[task]') || line.includes('[pipeline]')) return 'text-green-400';
+    if (line.includes('[telegram]') || line.includes('[terminal]')) return 'text-purple-400';
+    if (line.includes('[issue-scanner]') || line.includes('[watcher]')) return 'text-orange-300';
+    return 'text-[var(--text-primary)]';
+  };
+
+  return (
+    <div className="flex-1 flex flex-col min-h-0">
+      {/* Toolbar */}
+      <div className="flex items-center gap-2 px-4 py-2 border-b border-[var(--border)] shrink-0 flex-wrap">
+        <span className="text-xs font-semibold text-[var(--text-primary)]">Logs</span>
+        <span className="text-[8px] text-[var(--text-secondary)]">{total} lines · {formatSize(fileSize)}</span>
+
+        {/* Search */}
+        <input
+          type="text"
+          value={search}
+          onChange={e => setSearch(e.target.value)}
+          placeholder="Filter..."
+          className="px-2 py-0.5 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-[10px] text-[var(--text-primary)] w-32 focus:outline-none focus:border-[var(--accent)]"
+        />
+
+        {/* Max lines */}
+        <select
+          value={maxLines}
+          onChange={e => setMaxLines(Number(e.target.value))}
+          className="px-1 py-0.5 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-[10px] text-[var(--text-primary)]"
+        >
+          <option value={100}>100 lines</option>
+          <option value={200}>200 lines</option>
+          <option value={500}>500 lines</option>
+          <option value={1000}>1000 lines</option>
+        </select>
+
+        <div className="ml-auto flex items-center gap-2">
+          {/* Auto refresh toggle */}
+          <label className="flex items-center gap-1 text-[9px] text-[var(--text-secondary)] cursor-pointer">
+            <input type="checkbox" checked={autoRefresh} onChange={e => setAutoRefresh(e.target.checked)} className="accent-[var(--accent)]" />
+            Auto (3s)
+          </label>
+
+          {/* Processes */}
+          <button
+            onClick={() => { setShowProcesses(v => !v); fetchProcesses(); }}
+            className={`text-[9px] px-2 py-0.5 rounded ${showProcesses ? 'bg-[var(--accent)]/20 text-[var(--accent)]' : 'text-[var(--text-secondary)] hover:text-[var(--text-primary)]'}`}
+          >Processes</button>
+
+          {/* Refresh */}
+          <button onClick={fetchLogs} className="text-[9px] text-[var(--text-secondary)] hover:text-[var(--text-primary)]">↻</button>
+
+          {/* Clear */}
+          <button onClick={clearLogs} className="text-[9px] text-[var(--red)] hover:underline">Clear</button>
+        </div>
+      </div>
+
+      {/* Processes panel */}
+      {showProcesses && processes.length > 0 && (
+        <div className="border-b border-[var(--border)] bg-[var(--bg-tertiary)] max-h-32 overflow-y-auto shrink-0">
+          <div className="px-4 py-1 text-[8px] text-[var(--text-secondary)] uppercase">Running Processes</div>
+          {processes.map(p => (
+            <div key={p.pid} className="px-4 py-0.5 text-[10px] font-mono flex gap-3">
+              <span className="text-[var(--accent)] w-12 shrink-0">{p.pid}</span>
+              <span className="text-green-400 w-10 shrink-0">{p.cpu}%</span>
+              <span className="text-yellow-400 w-10 shrink-0">{p.mem}%</span>
+              <span className="text-[var(--text-secondary)] truncate">{p.cmd}</span>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {/* Log content */}
+      <div
+        ref={containerRef}
+        onScroll={onScroll}
+        className="flex-1 overflow-auto bg-[var(--bg-primary)] font-mono text-[11px] leading-[1.6]"
+      >
+        {lines.length === 0 ? (
+          <div className="flex items-center justify-center h-full text-[var(--text-secondary)] text-xs">
+            {filePath ? 'No log entries' : 'Log file not found — server running in foreground?'}
+          </div>
+        ) : (
+          <div className="p-3">
+            {lines.map((line, i) => (
+              <div key={i} className={`${getLineColor(line)} hover:bg-[var(--bg-tertiary)] px-1`}>
+                {search ? (
+                  // Highlight search matches
+                  line.split(new RegExp(`(${search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'gi')).map((part, j) =>
+                    part.toLowerCase() === search.toLowerCase()
+                      ? <span key={j} className="bg-[var(--yellow)]/30 text-[var(--yellow)]">{part}</span>
+                      : part
+                  )
+                ) : line}
+              </div>
+            ))}
+            <div ref={bottomRef} />
+          </div>
+        )}
+      </div>
+
+      {/* Footer */}
+      <div className="px-4 py-1 border-t border-[var(--border)] shrink-0 flex items-center gap-2 text-[8px] text-[var(--text-secondary)]">
+        <span>{filePath}</span>
+        {!autoScroll && (
+          <button
+            onClick={() => { setAutoScroll(true); bottomRef.current?.scrollIntoView({ behavior: 'smooth' }); }}
+            className="ml-auto text-[var(--accent)] hover:underline"
+          >↓ Scroll to bottom</button>
+        )}
+      </div>
+    </div>
+  );
+}

package/components/ProjectManager.tsx

@@ -192,9 +192,18 @@ export default function ProjectManager() {
   };
 
   // Group projects by root
+  const [collapsedRoots, setCollapsedRoots] = useState<Set<string>>(new Set());
   const roots = [...new Set(projects.map(p => p.root))];
   const favoriteProjects = projects.filter(p => favorites.includes(p.path));
 
+  const toggleRoot = (root: string) => {
+    setCollapsedRoots(prev => {
+      const next = new Set(prev);
+      if (next.has(root)) next.delete(root); else next.add(root);
+      return next;
+    });
+  };
+
   return (
     <div className="flex-1 flex min-h-0">
       {/* Left sidebar — project list */}
@@ -234,10 +243,14 @@ export default function ProjectManager() {
           {/* Favorites section */}
           {favoriteProjects.length > 0 && (
             <div>
-              <div className="px-3 py-1 text-[9px] text-[var(--yellow)] uppercase bg-[var(--bg-tertiary)] flex items-center gap-1">
-                <span>★</span> Favorites
-              </div>
-              {favoriteProjects.map(p => (
+              <button
+                onClick={() => toggleRoot('__favorites__')}
+                className="w-full px-3 py-1 text-[9px] text-[var(--yellow)] uppercase bg-[var(--bg-tertiary)] flex items-center gap-1 hover:bg-[var(--border)]/30"
+              >
+                <span className="text-[8px]">{collapsedRoots.has('__favorites__') ? '▸' : '▾'}</span>
+                <span>★</span> Favorites ({favoriteProjects.length})
+              </button>
+              {!collapsedRoots.has('__favorites__') && favoriteProjects.map(p => (
                 <button
                   key={`fav-${p.path}`}
                   onClick={() => openProjectTab(p)}
@@ -262,12 +275,17 @@ export default function ProjectManager() {
           {roots.map(root => {
             const rootName = root.split('/').pop() || root;
             const rootProjects = projects.filter(p => p.root === root).sort((a, b) => a.name.localeCompare(b.name));
+            const isCollapsed = collapsedRoots.has(root);
             return (
               <div key={root}>
-                <div className="px-3 py-1 text-[9px] text-[var(--text-secondary)] uppercase bg-[var(--bg-tertiary)]">
-                  {rootName}
-                </div>
-                {rootProjects.map(p => (
+                <button
+                  onClick={() => toggleRoot(root)}
+                  className="w-full px-3 py-1 text-[9px] text-[var(--text-secondary)] uppercase bg-[var(--bg-tertiary)] flex items-center gap-1 hover:bg-[var(--border)]/30"
+                >
+                  <span className="text-[8px]">{isCollapsed ? '▸' : '▾'}</span>
+                  {rootName} ({rootProjects.length})
+                </button>
+                {!isCollapsed && rootProjects.map(p => (
                   <button
                     key={p.path}
                     onClick={() => openProjectTab(p)}

package/lib/auth.ts

@@ -37,8 +37,10 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         if (verifyLogin(password, sessionCode, isRemote)) {
           const { loadSettings } = await import('./settings');
           const settings = loadSettings();
+          console.log(`[auth] Login success (${isRemote ? 'remote' : 'local'})`);
           return { id: 'local', name: settings.displayName || 'Forge', email: settings.displayEmail || 'local@forge' };
         }
+        console.warn(`[auth] Login failed (${isRemote ? 'remote' : 'local'})`);
         return null;
       },
     }),

package/lib/cloudflared.ts

@@ -23,11 +23,13 @@ function getDownloadUrl(): string {
   const base = 'https://github.com/cloudflare/cloudflared/releases/latest/download';
 
   if (os === 'darwin') {
-    // macOS universal binary
-    return `${base}/cloudflared-darwin-amd64.tgz`;
+    return cpu === 'arm64'
+      ? `${base}/cloudflared-darwin-arm64.tgz`
+      : `${base}/cloudflared-darwin-amd64.tgz`;
   }
   if (os === 'linux') {
     if (cpu === 'arm64') return `${base}/cloudflared-linux-arm64`;
+    if (cpu === 'arm') return `${base}/cloudflared-linux-arm`;
     return `${base}/cloudflared-linux-amd64`;
   }
   if (os === 'win32') {
@@ -38,49 +40,87 @@ function getDownloadUrl(): string {
 
 // ─── Download helper ────────────────────────────────────────────
 
-function followRedirects(url: string, dest: string): Promise<void> {
+const DOWNLOAD_TIMEOUT_MS = 120_000; // 2 minutes total per redirect hop
+
+function followRedirects(url: string, dest: string, redirectsLeft = 10): Promise<void> {
   return new Promise((resolve, reject) => {
     const client = url.startsWith('https') ? https : http;
-    client.get(url, { headers: { 'User-Agent': 'forge' } }, (res) => {
+    const req = client.get(url, { headers: { 'User-Agent': 'forge/1.0' } }, (res) => {
       if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        followRedirects(res.headers.location, dest).then(resolve, reject);
+        res.resume(); // drain redirect response
+        if (redirectsLeft <= 0) {
+          reject(new Error('Too many redirects'));
+          return;
+        }
+        followRedirects(res.headers.location, dest, redirectsLeft - 1).then(resolve, reject);
         return;
       }
       if (res.statusCode !== 200) {
+        res.resume();
         reject(new Error(`Download failed: HTTP ${res.statusCode}`));
         return;
       }
       const file = createWriteStream(dest);
       res.pipe(file);
       file.on('finish', () => file.close(() => resolve()));
-      file.on('error', reject);
-    }).on('error', reject);
+      file.on('error', (err) => { try { unlinkSync(dest); } catch {} reject(err); });
+      res.on('error', (err) => { try { unlinkSync(dest); } catch {} reject(err); });
+    });
+    req.setTimeout(DOWNLOAD_TIMEOUT_MS, () => {
+      req.destroy(new Error(`Download timed out after ${DOWNLOAD_TIMEOUT_MS / 1000}s`));
+    });
+    req.on('error', reject);
   });
 }
 
+// Guard against concurrent downloads
+let downloadPromise: Promise<string> | null = null;
+
 export async function downloadCloudflared(): Promise<string> {
   if (existsSync(BIN_PATH)) return BIN_PATH;
+  if (downloadPromise) return downloadPromise;
 
-  mkdirSync(BIN_DIR, { recursive: true });
-  const url = getDownloadUrl();
-  const isTgz = url.endsWith('.tgz');
-  const tmpPath = isTgz ? `${BIN_PATH}.tgz` : BIN_PATH;
-
-  console.log(`[cloudflared] Downloading from ${url}...`);
-  await followRedirects(url, tmpPath);
+  downloadPromise = (async () => {
+    mkdirSync(BIN_DIR, { recursive: true });
+    const url = getDownloadUrl();
+    const isTgz = url.endsWith('.tgz');
+    const tmpPath = isTgz ? `${BIN_PATH}.tgz` : `${BIN_PATH}.tmp`;
 
-  if (isTgz) {
-    // Extract tgz (macOS)
-    execSync(`tar -xzf "${tmpPath}" -C "${BIN_DIR}"`, { encoding: 'utf-8' });
+    // Clean up any leftover partial files from a previous failed attempt
     try { unlinkSync(tmpPath); } catch {}
-  }
 
-  if (platform() !== 'win32') {
-    chmodSync(BIN_PATH, 0o755);
-  }
+    console.log(`[cloudflared] Downloading from ${url}...`);
+    try {
+      await followRedirects(url, tmpPath);
+    } catch (e) {
+      try { unlinkSync(tmpPath); } catch {}
+      throw e;
+    }
+
+    if (isTgz) {
+      // Extract tgz (macOS)
+      try {
+        execSync(`tar -xzf "${tmpPath}" -C "${BIN_DIR}"`, { encoding: 'utf-8' });
+      } finally {
+        try { unlinkSync(tmpPath); } catch {}
+      }
+    } else {
+      // Rename .tmp to final name atomically
+      const { renameSync } = require('node:fs');
+      renameSync(tmpPath, BIN_PATH);
+    }
+
+    if (platform() !== 'win32') {
+      chmodSync(BIN_PATH, 0o755);
+    }
+
+    console.log(`[cloudflared] Installed to ${BIN_PATH}`);
+    return BIN_PATH;
+  })().finally(() => {
+    downloadPromise = null;
+  });
 
-  console.log(`[cloudflared] Installed to ${BIN_PATH}`);
-  return BIN_PATH;
+  return downloadPromise;
 }
 
 export function isInstalled(): boolean {
@@ -130,6 +170,7 @@ function pushLog(line: string) {
 }
 
 export async function startTunnel(localPort: number = parseInt(process.env.PORT || '3000')): Promise<{ url?: string; error?: string }> {
+  console.log(`[tunnel] Starting tunnel on port ${localPort}...`);
   // Check if this worker already has a process
   if (state.process) {
     return state.url ? { url: state.url } : { error: 'Tunnel is starting...' };
@@ -207,6 +248,7 @@ export async function startTunnel(localPort: number = parseInt(process.env.PORT
       state.status = 'error';
       state.error = err.message;
       pushLog(`[error] ${err.message}`);
+      console.error(`[tunnel] Error: ${err.message}`);
       if (!resolved) {
         resolved = true;
         resolve({ error: err.message });
@@ -214,16 +256,19 @@ export async function startTunnel(localPort: number = parseInt(process.env.PORT
     });
 
     state.process.on('exit', (code) => {
+      const recentLog = state.log.slice(-5).join(' ').slice(0, 200);
+      const reason = code !== 0 ? `cloudflared failed (exit ${code}): ${recentLog || 'no output'}` : 'cloudflared stopped';
+      console.log(`[tunnel] ${reason}`);
       state.process = null;
       if (state.status !== 'error') {
         state.status = 'stopped';
       }
       state.url = null;
       saveTunnelState();
-      pushLog(`[exit] cloudflared exited with code ${code}`);
+      pushLog(`[exit] ${reason}`);
       if (!resolved) {
         resolved = true;
-        resolve({ error: `cloudflared exited with code ${code}` });
+        resolve({ error: reason });
       }
     });
 
@@ -241,6 +286,7 @@ export async function startTunnel(localPort: number = parseInt(process.env.PORT
 }
 
 export function stopTunnel() {
+  console.log('[tunnel] Stopping tunnel');
   stopHealthCheck();
   if (state.process) {
     state.process.kill('SIGTERM');

package/lib/init.ts

@@ -64,6 +64,9 @@ export function ensureInitialized() {
   if (gInit[initKey]) return;
   gInit[initKey] = true;
 
+  // Add timestamps to all console output
+  try { const { initLogger } = require('./logger'); initLogger(); } catch {}
+
   // Migrate old data layout (~/.forge/* → ~/.forge/data/*) on first run
   try { const { migrateDataDir } = require('./dirs'); migrateDataDir(); } catch {}
 

package/lib/logger.ts

@@ -0,0 +1,73 @@
+/**
+ * Logger — adds timestamps + writes to forge.log file.
+ * Call `initLogger()` once at startup.
+ * Works in both dev mode (terminal + file) and production (file via redirect).
+ */
+
+import { appendFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+let initialized = false;
+
+export function initLogger() {
+  if (initialized) return;
+  initialized = true;
+
+  // Determine log file path
+  let logFile: string | null = null;
+  try {
+    const { getDataDir } = require('./dirs');
+    const dataDir = getDataDir();
+    if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true });
+    logFile = join(dataDir, 'forge.log');
+  } catch {}
+
+  const origLog = console.log;
+  const origError = console.error;
+  const origWarn = console.warn;
+
+  const ts = () => new Date().toISOString().replace('T', ' ').slice(0, 19);
+
+  const writeToFile = (line: string) => {
+    if (!logFile) return;
+    try { appendFileSync(logFile, line + '\n'); } catch {}
+  };
+
+  const SENSITIVE_PATTERNS = [
+    /(\d{8,})/g,                                    // session codes (8+ digits)
+    /(bot\d+:[A-Za-z0-9_-]{30,})/gi,               // telegram bot tokens
+    /(enc:[A-Za-z0-9+/=.]+)/g,                      // encrypted values
+    /(sk-ant-[A-Za-z0-9_-]+)/g,                     // anthropic API keys
+    /(sk-[A-Za-z0-9]{20,})/g,                       // openai API keys
+  ];
+
+  const sanitize = (str: string): string => {
+    let result = str;
+    for (const pattern of SENSITIVE_PATTERNS) {
+      result = result.replace(pattern, (match) => match.slice(0, 4) + '****');
+    }
+    return result;
+  };
+
+  const format = (...args: any[]): string => {
+    return args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+  };
+
+  console.log = (...args: any[]) => {
+    const line = `[${ts()}] ${format(...args)}`;
+    origLog(line);
+    writeToFile(sanitize(line));
+  };
+
+  console.error = (...args: any[]) => {
+    const line = `[${ts()}] [ERROR] ${format(...args)}`;
+    origError(line);
+    writeToFile(sanitize(line));
+  };
+
+  console.warn = (...args: any[]) => {
+    const line = `[${ts()}] [WARN] ${format(...args)}`;
+    origWarn(line);
+    writeToFile(sanitize(line));
+  };
+}

package/lib/password.ts

@@ -59,7 +59,7 @@ export function getSessionCode(): string {
 export function rotateSessionCode(): string {
   const code = generateSessionCode();
   saveSessionCode(code);
-  console.log(`[password] New session code: ${code}`);
+  console.log(`[password] New session code: ****${code.slice(-2)}`);
   return code;
 }
 

package/lib/skills.ts

@@ -87,6 +87,7 @@ function getInstalledVersion(name: string, type: string, basePath?: string): str
 // ─── Sync from registry ──────────────────────────────────────
 
 export async function syncSkills(): Promise<{ synced: number; error?: string }> {
+  console.log('[skills] Syncing from registry...');
   const baseUrl = getBaseUrl();
 
   try {
@@ -198,6 +199,7 @@ export async function syncSkills(): Promise<{ synced: number; error?: string }>
       }
     }
 
+    console.log(`[skills] Synced ${items.length} items`);
     return { synced: items.length };
   } catch (e) {
     return { synced: 0, error: e instanceof Error ? e.message : String(e) };
@@ -284,6 +286,7 @@ async function downloadToDir(files: { path: string; download_url: string }[], de
 // ─── Install ─────────────────────────────────────────────────
 
 export async function installGlobal(name: string): Promise<void> {
+  console.log(`[skills] Installing "${name}" globally`);
   const row = db().prepare('SELECT type, version FROM skills WHERE name = ?').get(name) as any;
   if (!row) throw new Error(`Not found: ${name}`);
   const type: ItemType = row.type || 'skill';
@@ -318,6 +321,7 @@ export async function installGlobal(name: string): Promise<void> {
 }
 
 export async function installProject(name: string, projectPath: string): Promise<void> {
+  console.log(`[skills] Installing "${name}" to ${projectPath.split('/').pop()}`);
   const row = db().prepare('SELECT type, version FROM skills WHERE name = ?').get(name) as any;
   if (!row) throw new Error(`Not found: ${name}`);
   const type: ItemType = row.type || 'skill';
@@ -357,6 +361,7 @@ export async function installProject(name: string, projectPath: string): Promise
 // ─── Uninstall ───────────────────────────────────────────────
 
 export function uninstallGlobal(name: string): void {
+  console.log(`[skills] Uninstalling "${name}" from global`);
   // Remove from all possible locations
   try { rmSync(join(GLOBAL_SKILLS_DIR, name), { recursive: true }); } catch {}
   try { unlinkSync(join(GLOBAL_COMMANDS_DIR, `${name}.md`)); } catch {}
@@ -367,6 +372,7 @@ export function uninstallGlobal(name: string): void {
 }
 
 export function uninstallProject(name: string, projectPath: string): void {
+  console.log(`[skills] Uninstalling "${name}" from ${projectPath.split('/').pop()}`);
   // Remove from all possible locations
   try { rmSync(join(projectPath, '.claude', 'skills', name), { recursive: true }); } catch {}
   try { unlinkSync(join(projectPath, '.claude', 'commands', `${name}.md`)); } catch {}

package/lib/task-manager.ts

@@ -405,12 +405,14 @@ function executeTask(task: Task): Promise<void> {
           WHERE id = ?
         `).run(resultText, totalCost, task.id);
         emit(task.id, 'status', 'done');
+        console.log(`[task] Done: ${task.id} ${task.projectName} (cost: $${totalCost?.toFixed(4) || '0'})`);
         const doneTask = getTask(task.id);
         if (doneTask) notifyTaskComplete(doneTask).catch(() => {});
         notifyTerminalSession(task, 'done', sessionId);
         resolve();
       } else {
         const errMsg = `Process exited with code ${code}`;
+        console.error(`[task] Failed: ${task.id} ${task.projectName} — ${errMsg}`);
         updateTaskStatus(task.id, 'failed', errMsg);
         const failedTask = getTask(task.id);
         if (failedTask) notifyTaskFailed(failedTask).catch(() => {});

package/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

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