@aion0/forge 0.1.7 → 0.1.9

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { getTask, cancelTask, deleteTask, retryTask } from '@/lib/task-manager';
+import { getTask, cancelTask, deleteTask, retryTask, updateTask } from '@/lib/task-manager';
 
 // Get task details (including full log)
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -28,6 +28,15 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
 }
 
+// Edit a queued task
+export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+  const updated = updateTask(id, body);
+  if (!updated) return NextResponse.json({ error: 'Cannot edit (only queued tasks)' }, { status: 400 });
+  return NextResponse.json(updated);
+}
+
 // Delete a task
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;

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/NewTaskModal.tsx

@@ -17,29 +17,33 @@ interface SessionInfo {
   gitBranch?: string;
 }
 
+interface TaskData {
+  projectName: string;
+  prompt: string;
+  priority?: number;
+  conversationId?: string;
+  newSession?: boolean;
+  scheduledAt?: string;
+  mode?: TaskMode;
+  watchConfig?: WatchConfig;
+}
+
 export default function NewTaskModal({
   onClose,
   onCreate,
+  editTask,
 }: {
   onClose: () => void;
-  onCreate: (data: {
-    projectName: string;
-    prompt: string;
-    priority?: number;
-    conversationId?: string;
-    newSession?: boolean;
-    scheduledAt?: string;
-    mode?: TaskMode;
-    watchConfig?: WatchConfig;
-  }) => void;
+  onCreate: (data: TaskData) => void;
+  editTask?: { id: string; projectName: string; prompt: string; priority: number; mode: TaskMode };
 }) {
   const [projects, setProjects] = useState<Project[]>([]);
-  const [selectedProject, setSelectedProject] = useState('');
-  const [prompt, setPrompt] = useState('');
-  const [priority, setPriority] = useState(0);
+  const [selectedProject, setSelectedProject] = useState(editTask?.projectName || '');
+  const [prompt, setPrompt] = useState(editTask?.prompt || '');
+  const [priority, setPriority] = useState(editTask?.priority || 0);
 
   // Task mode
-  const [taskMode, setTaskMode] = useState<TaskMode>('prompt');
+  const [taskMode, setTaskMode] = useState<TaskMode>(editTask?.mode || 'prompt');
 
   // Monitor config
   const [watchCondition, setWatchCondition] = useState<WatchConfig['condition']>('change');
@@ -63,7 +67,7 @@ export default function NewTaskModal({
   useEffect(() => {
     fetch('/api/projects').then(r => r.json()).then((p: Project[]) => {
       setProjects(p);
-      if (p.length > 0) setSelectedProject(p[0].name);
+      if (!selectedProject && p.length > 0) setSelectedProject(p[0].name);
     });
   }, []);
 
@@ -135,7 +139,7 @@ export default function NewTaskModal({
     <div className="fixed inset-0 bg-black/60 flex items-center justify-center z-50" onClick={onClose}>
       <div className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg w-[560px] max-h-[80vh] overflow-auto" onClick={e => e.stopPropagation()}>
         <div className="p-4 border-b border-[var(--border)]">
-          <h2 className="text-sm font-semibold">New Task</h2>
+          <h2 className="text-sm font-semibold">{editTask ? 'Edit Task' : 'New Task'}</h2>
           <p className="text-[11px] text-[var(--text-secondary)] mt-0.5">
             Submit a task for Claude Code to work on autonomously
           </p>
@@ -446,7 +450,7 @@ export default function NewTaskModal({
               disabled={!selectedProject || (taskMode === 'prompt' && !prompt.trim()) || (taskMode === 'monitor' && !selectedSessionId)}
               className="text-xs px-4 py-1.5 bg-[var(--accent)] text-white rounded hover:opacity-90 disabled:opacity-50"
             >
-              {taskMode === 'monitor' ? 'Start Monitor' : scheduleMode === 'now' ? 'Submit Task' : 'Schedule Task'}
+              {editTask ? 'Save & Restart' : taskMode === 'monitor' ? 'Start Monitor' : scheduleMode === 'now' ? 'Submit Task' : 'Schedule Task'}
             </button>
           </div>
         </form>

package/components/TaskDetail.tsx

@@ -2,6 +2,7 @@
 
 import { useState, useEffect, useRef } from 'react';
 import MarkdownContent from './MarkdownContent';
+import NewTaskModal from './NewTaskModal';
 import type { Task, TaskLogEntry } from '@/src/types';
 
 export default function TaskDetail({
@@ -18,6 +19,7 @@ export default function TaskDetail({
   const [tab, setTab] = useState<'log' | 'diff' | 'result'>('log');
   const [expandedTools, setExpandedTools] = useState<Set<number>>(new Set());
   const [followUpText, setFollowUpText] = useState('');
+  const [editing, setEditing] = useState(false);
   const logEndRef = useRef<HTMLDivElement>(null);
 
   // SSE stream for running tasks
@@ -90,6 +92,9 @@ export default function TaskDetail({
             <span className="text-[10px] text-[var(--text-secondary)] font-mono">{task.id}</span>
           </div>
           <div className="flex items-center gap-2">
+            <button onClick={() => setEditing(true)} className="text-[10px] px-2 py-0.5 text-[var(--accent)] border border-[var(--accent)]/30 rounded hover:bg-[var(--accent)] hover:text-white">
+              Edit
+            </button>
             {(liveStatus === 'running' || liveStatus === 'queued') && (
               <button onClick={() => handleAction('cancel')} className="text-[10px] px-2 py-0.5 text-[var(--red)] border border-[var(--red)]/30 rounded hover:bg-[var(--red)] hover:text-white">
                 Cancel
@@ -223,6 +228,22 @@ export default function TaskDetail({
           </p>
         </div>
       )}
+
+      {editing && (
+        <NewTaskModal
+          editTask={{ id: task.id, projectName: task.projectName, prompt: task.prompt, priority: task.priority, mode: task.mode }}
+          onClose={() => setEditing(false)}
+          onCreate={async (data) => {
+            await fetch(`/api/tasks/${task.id}`, {
+              method: 'PATCH',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ ...data, restart: true }),
+            });
+            setEditing(false);
+            onRefresh();
+          }}
+        />
+      )}
     </div>
   );
 }

package/lib/cloudflared.ts

@@ -150,6 +150,7 @@ export async function startTunnel(localPort: number = 3000): Promise<{ url?: str
           state.url = urlMatch[1];
           state.status = 'running';
           console.log(`[cloudflared] Tunnel URL: ${state.url}`);
+          startHealthCheck();
           if (!resolved) {
             resolved = true;
             resolve({ url: state.url });
@@ -198,6 +199,7 @@ export async function startTunnel(localPort: number = 3000): Promise<{ url?: str
 }
 
 export function stopTunnel() {
+  stopHealthCheck();
   if (state.process) {
     state.process.kill('SIGTERM');
     state.process = null;
@@ -216,3 +218,92 @@ export function getTunnelStatus() {
     log: state.log.slice(-20),
   };
 }
+
+// ─── Tunnel health check ──────────────────────────────────────
+
+let healthCheckTimer: ReturnType<typeof setInterval> | null = null;
+let consecutiveFailures = 0;
+const MAX_FAILURES = 3;
+const HEALTH_CHECK_INTERVAL = 60_000; // 60s
+
+async function checkTunnelHealth() {
+  if (state.status !== 'running' || !state.url) return;
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    const res = await fetch(state.url, {
+      method: 'HEAD',
+      signal: controller.signal,
+      redirect: 'manual',
+    });
+    clearTimeout(timeout);
+
+    // Any response (including 302 to login) means tunnel is alive
+    if (res.status > 0) {
+      if (consecutiveFailures > 0) {
+        pushLog(`[health] Tunnel recovered after ${consecutiveFailures} failures`);
+      }
+      consecutiveFailures = 0;
+      return;
+    }
+  } catch {
+    // fetch failed — tunnel likely down
+  }
+
+  consecutiveFailures++;
+  pushLog(`[health] Tunnel unreachable (${consecutiveFailures}/${MAX_FAILURES})`);
+
+  if (consecutiveFailures >= MAX_FAILURES) {
+    pushLog('[health] Tunnel appears dead — restarting...');
+    state.status = 'error';
+    state.error = 'Tunnel unreachable — restarting';
+
+    // Kill old process and restart
+    if (state.process) {
+      state.process.kill('SIGTERM');
+      state.process = null;
+    }
+    state.url = null;
+    consecutiveFailures = 0;
+
+    // Restart after a short delay
+    setTimeout(async () => {
+      const result = await startTunnel();
+      if (result.url) {
+        pushLog(`[health] Tunnel restarted: ${result.url}`);
+        // Notify via Telegram if configured
+        try {
+          const { loadSettings } = await import('./settings');
+          const settings = loadSettings();
+          if (settings.telegramBotToken && settings.telegramChatId) {
+            await fetch(`https://api.telegram.org/bot${settings.telegramBotToken}/sendMessage`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                chat_id: settings.telegramChatId,
+                text: `🔄 Tunnel restarted\n\nNew URL: ${result.url}`,
+                disable_web_page_preview: true,
+              }),
+            });
+          }
+        } catch {}
+      } else {
+        pushLog(`[health] Tunnel restart failed: ${result.error}`);
+      }
+    }, 3000);
+  }
+}
+
+export function startHealthCheck() {
+  if (healthCheckTimer) return;
+  healthCheckTimer = setInterval(checkTunnelHealth, HEALTH_CHECK_INTERVAL);
+}
+
+export function stopHealthCheck() {
+  if (healthCheckTimer) {
+    clearInterval(healthCheckTimer);
+    healthCheckTimer = null;
+  }
+  consecutiveFailures = 0;
+}

package/lib/task-manager.ts

@@ -133,6 +133,35 @@ export function deleteTask(id: string): boolean {
   return true;
 }
 
+export function updateTask(id: string, updates: { prompt?: string; projectName?: string; projectPath?: string; priority?: number; restart?: boolean }): Task | null {
+  const task = getTask(id);
+  if (!task) return null;
+
+  // If running, cancel first
+  if (task.status === 'running') cancelTask(id);
+
+  const fields: string[] = [];
+  const values: any[] = [];
+  if (updates.prompt !== undefined) { fields.push('prompt = ?'); values.push(updates.prompt); }
+  if (updates.projectName !== undefined) { fields.push('project_name = ?'); values.push(updates.projectName); }
+  if (updates.projectPath !== undefined) { fields.push('project_path = ?'); values.push(updates.projectPath); }
+  if (updates.priority !== undefined) { fields.push('priority = ?'); values.push(updates.priority); }
+
+  // Reset to queued so it runs again
+  if (updates.restart) {
+    fields.push("status = 'queued'", 'started_at = NULL', 'completed_at = NULL', 'error = NULL', "log = '[]'", 'result_summary = NULL', 'git_diff = NULL', 'cost_usd = NULL');
+  }
+
+  if (fields.length === 0) return task;
+
+  values.push(id);
+  db().prepare(`UPDATE tasks SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+
+  if (updates.restart) ensureRunnerStarted();
+
+  return getTask(id);
+}
+
 export function retryTask(id: string): Task | null {
   const task = getTask(id);
   if (!task) return null;
@@ -506,21 +535,43 @@ function startMonitorTask(task: Task) {
     }, 30_000);
   }
 
+  // Notification throttling: batch updates and send at most once per interval
+  const notifyInterval = (config.notifyIntervalSeconds || 60) * 1000;
+  let lastNotifyTime = 0;
+  let pendingContext: string[] = [];
+  let notifyTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function scheduleNotify(context: string, immediate?: boolean) {
+    pendingContext.push(context);
+    if (immediate) {
+      flushNotify();
+      return;
+    }
+    if (notifyTimer) return; // already scheduled
+    const elapsed = Date.now() - lastNotifyTime;
+    const delay = Math.max(0, notifyInterval - elapsed);
+    notifyTimer = setTimeout(flushNotify, delay);
+  }
+
+  function flushNotify() {
+    if (notifyTimer) { clearTimeout(notifyTimer); notifyTimer = null; }
+    if (pendingContext.length === 0) return;
+    const summary = pendingContext.length === 1
+      ? pendingContext[0]
+      : `${pendingContext.length} updates:\n\n${pendingContext.slice(-5).join('\n\n')}`;
+    pendingContext = [];
+    lastNotifyTime = Date.now();
+    triggerMonitorAction(task, summary);
+  }
+
   // Tail the file for changes (uses fs.watch + 5s polling fallback)
   const stopTail = tailSessionFile(fp, (newEntries) => {
     lastActivityTime = Date.now();
     lastEntryCount += newEntries.length;
-    // Monitor entries tracked in task log only
-
-    appendLog(task.id, {
-      type: 'system', subtype: 'text',
-      content: `+${newEntries.length} entries (${lastEntryCount} total)`,
-      timestamp: new Date().toISOString(),
-    });
 
     // Check conditions
     if (config.condition === 'change') {
-      triggerMonitorAction(task, summarizeNewEntries(newEntries));
+      scheduleNotify(summarizeNewEntries(newEntries));
       if (!config.repeat) stopMonitor(task.id);
     }
 
@@ -528,7 +579,7 @@ function startMonitorTask(task: Task) {
       const kw = config.keyword.toLowerCase();
       const matched = newEntries.find(e => e.content.toLowerCase().includes(kw));
       if (matched) {
-        triggerMonitorAction(task, `Keyword "${config.keyword}" found: ${matched.content.slice(0, 200)}`);
+        scheduleNotify(`Keyword "${config.keyword}" found: ${matched.content.slice(0, 200)}`, true);
         if (!config.repeat) stopMonitor(task.id);
       }
     }
@@ -538,7 +589,7 @@ function startMonitorTask(task: Task) {
         e.type === 'system' && e.content.toLowerCase().includes('error')
       );
       if (errors.length > 0) {
-        triggerMonitorAction(task, `Error detected: ${errors[0].content.slice(0, 200)}`);
+        scheduleNotify(`Error detected: ${errors[0].content.slice(0, 200)}`, true);
         if (!config.repeat) stopMonitor(task.id);
       }
     }
@@ -554,7 +605,7 @@ function startMonitorTask(task: Task) {
           // Wait a bit to see if more entries come
           setTimeout(() => {
             if (Date.now() - lastActivityTime > 30_000) {
-              triggerMonitorAction(task, `Session appears complete.\n\nLast: ${lastAssistant.content.slice(0, 300)}`);
+              scheduleNotify(`Session appears complete.\n\nLast: ${lastAssistant.content.slice(0, 300)}`, true);
               if (!config.repeat) stopMonitor(task.id);
             }
           }, 35_000);
@@ -573,6 +624,7 @@ function startMonitorTask(task: Task) {
   const cleanup = () => {
     stopTail();
     if (idleTimer) clearInterval(idleTimer);
+    flushNotify(); // send any remaining batched notifications
   };
 
   activeMonitors.set(task.id, cleanup);

package/package.json

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

package/src/types/index.ts

@@ -86,6 +86,7 @@ export interface WatchConfig {
   actionPrompt?: string;     // message to send or task prompt
   actionProject?: string;    // for 'task' action
   repeat?: boolean;          // keep watching after trigger (default false)
+  notifyIntervalSeconds?: number; // min seconds between notifications (default 60)
 }
 
 export interface Task {