@aion0/forge 0.2.1 → 0.2.2

package/components/WebTerminal.tsx

@@ -26,7 +26,7 @@ interface TmuxSession {
 }
 
 type SplitNode =
-  | { type: 'terminal'; id: number; sessionName?: string }
+  | { type: 'terminal'; id: number; sessionName?: string; projectPath?: string }
   | { type: 'split'; id: number; direction: 'horizontal' | 'vertical'; ratio: number; first: SplitNode; second: SplitNode };
 
 interface TabState {
@@ -35,6 +35,7 @@ interface TabState {
   tree: SplitNode;
   ratios: Record<number, number>;
   activeId: number;
+  projectPath?: string;  // If set, auto-run claude --resume in this dir on session create
 }
 
 // ─── Layout persistence ──────────────────────────────────────
@@ -99,8 +100,8 @@ function initNextIdFromTabs(tabs: TabState[]) {
   }
 }
 
-function makeTerminal(sessionName?: string): SplitNode {
-  return { type: 'terminal', id: nextId++, sessionName };
+function makeTerminal(sessionName?: string, projectPath?: string): SplitNode {
+  return { type: 'terminal', id: nextId++, sessionName, projectPath };
 }
 
 function makeSplit(direction: 'horizontal' | 'vertical', first: SplitNode, second: SplitNode): SplitNode {
@@ -178,6 +179,10 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
   const dragTabRef = useRef<number | null>(null);
   const [refreshKeys, setRefreshKeys] = useState<Record<number, number>>({});
   const [tabCodeOpen, setTabCodeOpen] = useState<Record<number, boolean>>({});
+  const [showNewTabModal, setShowNewTabModal] = useState(false);
+  const [projectRoots, setProjectRoots] = useState<string[]>([]);
+  const [allProjects, setAllProjects] = useState<{ name: string; path: string; root: string }[]>([]);
+  const [expandedRoot, setExpandedRoot] = useState<string | null>(null);
 
   // Restore shared state from server after mount
   useEffect(() => {
@@ -191,6 +196,15 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
       }
       setHydrated(true);
     });
+    // Fetch projects and derive roots
+    fetch('/api/projects').then(r => r.json())
+      .then((p: { name: string; path: string; root: string }[]) => {
+        if (!Array.isArray(p)) return;
+        setAllProjects(p);
+        const roots = [...new Set(p.map(proj => proj.root))];
+        setProjectRoots(roots);
+      })
+      .catch(() => {});
   }, []);
 
   // Persist to server on changes (debounced, only after hydration)
@@ -248,10 +262,11 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
 
   // ─── Tab operations ───────────────────────────────────
 
-  const addTab = useCallback(() => {
-    const tree = makeTerminal();
+  const addTab = useCallback((projectPath?: string) => {
+    const tree = makeTerminal(undefined, projectPath);
     const tabNum = tabs.length + 1;
-    const newTab: TabState = { id: nextId++, label: `Terminal ${tabNum}`, tree, ratios: {}, activeId: firstTerminalId(tree) };
+    const label = projectPath ? projectPath.split('/').pop() || `Terminal ${tabNum}` : `Terminal ${tabNum}`;
+    const newTab: TabState = { id: nextId++, label, tree, ratios: {}, activeId: firstTerminalId(tree), projectPath };
     setTabs(prev => [...prev, newTab]);
     setActiveTabId(newTab.id);
   }, [tabs.length]);
@@ -486,9 +501,9 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
             </div>
           ))}
           <button
-            onClick={addTab}
+            onClick={() => setShowNewTabModal(true)}
             className="px-2 py-1 text-[11px] text-gray-500 hover:text-white hover:bg-[#2a2a4a]"
-            title="New terminal tab"
+            title="New tab"
           >
             +
           </button>
@@ -631,6 +646,75 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
         </div>
       )}
 
+      {/* New tab modal */}
+      {showNewTabModal && (
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50" onClick={() => { setShowNewTabModal(false); setExpandedRoot(null); }}>
+          <div className="bg-[#1a1a2e] border border-[#2a2a4a] rounded-lg shadow-xl w-[350px] max-h-[70vh] flex flex-col" onClick={e => e.stopPropagation()}>
+            <div className="px-4 py-3 border-b border-[#2a2a4a]">
+              <h3 className="text-sm font-semibold text-white">New Tab</h3>
+            </div>
+            <div className="flex-1 overflow-y-auto p-2">
+              {/* Plain terminal */}
+              <button
+                onClick={() => { addTab(); setShowNewTabModal(false); setExpandedRoot(null); }}
+                className="w-full text-left px-3 py-2 rounded hover:bg-[#2a2a4a] text-[12px] text-gray-300 flex items-center gap-2"
+              >
+                <span className="text-gray-500">▸</span> Terminal
+              </button>
+
+              {/* Project roots */}
+              {projectRoots.length > 0 && (
+                <div className="mt-2 pt-2 border-t border-[#2a2a4a]">
+                  <div className="px-3 py-1 text-[9px] text-gray-500 uppercase">Claude in Project</div>
+                  {projectRoots.map(root => {
+                    const rootName = root.split('/').pop() || root;
+                    const isExpanded = expandedRoot === root;
+                    const rootProjects = allProjects.filter(p => p.root === root);
+                    return (
+                      <div key={root}>
+                        <button
+                          onClick={() => setExpandedRoot(isExpanded ? null : root)}
+                          className="w-full text-left px-3 py-2 rounded hover:bg-[#2a2a4a] text-[12px] text-gray-300 flex items-center gap-2"
+                        >
+                          <span className="text-gray-500 text-[10px] w-3">{isExpanded ? '▾' : '▸'}</span>
+                          <span>{rootName}</span>
+                          <span className="text-[9px] text-gray-600 ml-auto">{rootProjects.length}</span>
+                        </button>
+                        {isExpanded && (
+                          <div className="ml-4">
+                            {rootProjects.map(p => (
+                              <button
+                                key={p.path}
+                                onClick={() => { addTab(p.path); setShowNewTabModal(false); setExpandedRoot(null); }}
+                                className="w-full text-left px-3 py-1.5 rounded hover:bg-[#2a2a4a] text-[11px] text-gray-300 flex items-center gap-2 truncate"
+                                title={p.path}
+                              >
+                                <span className="text-gray-600 text-[10px]">↳</span> {p.name}
+                              </button>
+                            ))}
+                            {rootProjects.length === 0 && (
+                              <div className="px-3 py-1.5 text-[10px] text-gray-600">No projects</div>
+                            )}
+                          </div>
+                        )}
+                      </div>
+                    );
+                  })}
+                </div>
+              )}
+            </div>
+            <div className="px-4 py-2 border-t border-[#2a2a4a]">
+              <button
+                onClick={() => { setShowNewTabModal(false); setExpandedRoot(null); }}
+                className="w-full text-center text-[11px] text-gray-500 hover:text-gray-300 py-1"
+              >
+                Cancel
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
       {/* Close confirmation dialog */}
       {closeConfirm && (
         <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50" onClick={() => setCloseConfirm(null)}>
@@ -706,7 +790,7 @@ function PaneRenderer({
   if (node.type === 'terminal') {
     return (
       <div className={`h-full w-full ${activeId === node.id ? 'ring-1 ring-[#7c5bf0]/50 ring-inset' : ''}`} onMouseDown={() => onFocus(node.id)}>
-        <MemoTerminalPane key={`${node.id}-${refreshKeys[node.id] || 0}`} id={node.id} sessionName={node.sessionName} onSessionConnected={onSessionConnected} />
+        <MemoTerminalPane key={`${node.id}-${refreshKeys[node.id] || 0}`} id={node.id} sessionName={node.sessionName} projectPath={node.projectPath} onSessionConnected={onSessionConnected} />
       </div>
     );
   }
@@ -836,15 +920,19 @@ function DraggableSplit({
 const MemoTerminalPane = memo(function TerminalPane({
   id,
   sessionName,
+  projectPath,
   onSessionConnected,
 }: {
   id: number;
   sessionName?: string;
+  projectPath?: string;
   onSessionConnected: (paneId: number, sessionName: string) => void;
 }) {
   const containerRef = useRef<HTMLDivElement>(null);
   const sessionNameRef = useRef(sessionName);
   sessionNameRef.current = sessionName;
+  const projectPathRef = useRef(projectPath);
+  projectPathRef.current = projectPath;
 
   useEffect(() => {
     if (!containerRef.current) return;
@@ -921,6 +1009,7 @@ const MemoTerminalPane = memo(function TerminalPane({
     let createRetries = 0;
     const MAX_CREATE_RETRIES = 2;
     let reconnectAttempts = 0;
+    let isNewlyCreated = false;
 
     function connect() {
       if (disposed) return;
@@ -942,6 +1031,7 @@ const MemoTerminalPane = memo(function TerminalPane({
             socket.send(JSON.stringify({ type: 'attach', sessionName: sn, cols, rows }));
           } else if (createRetries < MAX_CREATE_RETRIES) {
             createRetries++;
+            isNewlyCreated = true;
             socket.send(JSON.stringify({ type: 'create', cols, rows }));
           } else {
             term.write('\r\n\x1b[91m[failed to create session — check server logs]\x1b[0m\r\n');
@@ -960,6 +1050,16 @@ const MemoTerminalPane = memo(function TerminalPane({
             createRetries = 0;
             reconnectAttempts = 0;
             onSessionConnected(id, msg.sessionName);
+            // Auto-run claude --resume for project tabs on new session
+            if (isNewlyCreated && projectPathRef.current) {
+              isNewlyCreated = false;
+              setTimeout(() => {
+                if (!disposed && ws?.readyState === WebSocket.OPEN) {
+                  ws.send(JSON.stringify({ type: 'input', data: `cd "${projectPathRef.current}" && claude --resume\n` }));
+                }
+              }, 300);
+            }
+            isNewlyCreated = false;
             // Force tmux to redraw by toggling size, then send reset
             setTimeout(() => {
               if (disposed || ws?.readyState !== WebSocket.OPEN) return;

package/lib/task-manager.ts

@@ -12,8 +12,10 @@ import { loadSettings } from './settings';
 import { notifyTaskComplete, notifyTaskFailed } from './notify';
 import type { Task, TaskLogEntry, TaskStatus, TaskMode, WatchConfig } from '@/src/types';
 
-let runner: ReturnType<typeof setInterval> | null = null;
-let currentTaskId: string | null = null;
+const runnerKey = Symbol.for('mw-task-runner');
+const gRunner = globalThis as any;
+if (!gRunner[runnerKey]) gRunner[runnerKey] = { runner: null, currentTaskId: null };
+const runnerState: { runner: ReturnType<typeof setInterval> | null; currentTaskId: string | null } = gRunner[runnerKey];
 
 // Per-project concurrency: track which projects have a running prompt task
 const runningProjects = new Set<string>();
@@ -133,7 +135,7 @@ 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 {
+export function updateTask(id: string, updates: { prompt?: string; projectName?: string; projectPath?: string; priority?: number; scheduledAt?: string; restart?: boolean }): Task | null {
   const task = getTask(id);
   if (!task) return null;
 
@@ -146,6 +148,7 @@ export function updateTask(id: string, updates: { prompt?: string; projectName?:
   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); }
+  if (updates.scheduledAt !== undefined) { fields.push('scheduled_at = ?'); values.push(updates.scheduledAt || null); }
 
   // Reset to queued so it runs again
   if (updates.restart) {
@@ -179,16 +182,16 @@ export function retryTask(id: string): Task | null {
 // ─── Background Runner ───────────────────────────────────────
 
 export function ensureRunnerStarted() {
-  if (runner) return;
-  runner = setInterval(processNextTask, 3000);
+  if (runnerState.runner) return;
+  runnerState.runner = setInterval(processNextTask, 3000);
   // Also try immediately
   processNextTask();
 }
 
 export function stopRunner() {
-  if (runner) {
-    clearInterval(runner);
-    runner = null;
+  if (runnerState.runner) {
+    clearInterval(runnerState.runner);
+    runnerState.runner = null;
   }
 }
 
@@ -196,7 +199,7 @@ async function processNextTask() {
   // Find all queued tasks ready to run
   const queued = db().prepare(`
     SELECT * FROM tasks WHERE status = 'queued'
-    AND (scheduled_at IS NULL OR scheduled_at <= datetime('now'))
+    AND (scheduled_at IS NULL OR replace(replace(scheduled_at, 'T', ' '), 'Z', '') <= datetime('now'))
     ORDER BY priority DESC, created_at ASC
   `).all() as any[];
 
@@ -214,7 +217,7 @@ async function processNextTask() {
 
     // Run this task
     runningProjects.add(task.projectName);
-    currentTaskId = task.id;
+    runnerState.currentTaskId = task.id;
 
     // Execute async — don't await so we can process tasks for other projects in parallel
     executeTask(task)
@@ -224,7 +227,7 @@ async function processNextTask() {
       })
       .finally(() => {
         runningProjects.delete(task.projectName);
-        if (currentTaskId === task.id) currentTaskId = null;
+        if (runnerState.currentTaskId === task.id) runnerState.currentTaskId = null;
       });
   }
 }
@@ -234,7 +237,7 @@ function executeTask(task: Task): Promise<void> {
     const settings = loadSettings();
     const claudePath = settings.claudePath || process.env.CLAUDE_PATH || 'claude';
 
-    const args = ['-p', '--verbose', '--output-format', 'stream-json'];
+    const args = ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions'];
 
     // Resume specific session to continue the conversation
     if (task.conversationId) {
@@ -352,12 +355,14 @@ function executeTask(task: Task): Promise<void> {
         emit(task.id, 'status', 'done');
         const doneTask = getTask(task.id);
         if (doneTask) notifyTaskComplete(doneTask).catch(() => {});
+        notifyTerminalSession(task, 'done', sessionId);
         resolve();
       } else {
         const errMsg = `Process exited with code ${code}`;
         updateTaskStatus(task.id, 'failed', errMsg);
         const failedTask = getTask(task.id);
         if (failedTask) notifyTaskFailed(failedTask).catch(() => {});
+        notifyTerminalSession(task, 'failed', sessionId);
         reject(new Error(errMsg));
       }
     });
@@ -369,6 +374,59 @@ function executeTask(task: Task): Promise<void> {
   });
 }
 
+// ─── Terminal notification ────────────────────────────────────
+
+/**
+ * Notify tmux terminal sessions in the same project directory that a task completed.
+ * Sends a visible bell character so the user knows to resume.
+ */
+function notifyTerminalSession(task: Task, status: 'done' | 'failed', sessionId?: string) {
+  try {
+    const out = execSync(
+      `tmux list-sessions -F "#{session_name}" 2>/dev/null`,
+      { encoding: 'utf-8', timeout: 3000 }
+    ).trim();
+    if (!out) return;
+
+    for (const name of out.split('\n')) {
+      if (!name.startsWith('mw-')) continue;
+      try {
+        const cwd = execSync(
+          `tmux display-message -p -t ${name} '#{pane_current_path}'`,
+          { encoding: 'utf-8', timeout: 2000 }
+        ).trim();
+
+        // Match: same dir, parent dir, or child dir
+        const match = cwd && (
+          cwd === task.projectPath ||
+          cwd.startsWith(task.projectPath + '/') ||
+          task.projectPath.startsWith(cwd + '/')
+        );
+        if (!match) continue;
+
+        const paneCmd = execSync(
+          `tmux display-message -p -t ${name} '#{pane_current_command}'`,
+          { encoding: 'utf-8', timeout: 2000 }
+        ).trim();
+
+        if (status === 'done') {
+          const summary = task.prompt.slice(0, 80).replace(/"/g, "'");
+          const msg = `A background task just completed. Task: "${summary}". Please check git diff and continue.`;
+
+          // If a process is running (claude/node), send as input
+          if (paneCmd !== 'zsh' && paneCmd !== 'bash' && paneCmd !== 'fish') {
+            execSync(`tmux send-keys -t ${name} -- "${msg.replace(/"/g, '\\"')}" Enter`, { timeout: 2000 });
+          } else {
+            execSync(`tmux display-message -t ${name} "✅ Task ${task.id} done — changes ready"`, { timeout: 2000 });
+          }
+        } else {
+          execSync(`tmux display-message -t ${name} "❌ Task ${task.id} failed"`, { timeout: 2000 });
+        }
+      } catch {}
+    }
+  } catch {}
+}
+
 // ─── Helpers ─────────────────────────────────────────────────
 
 /**

package/lib/telegram-bot.ts

@@ -39,6 +39,9 @@ const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions' | 'task-c
 // Pending task creation: waiting for prompt text
 const pendingTaskProject = new Map<number, { name: string; path: string }>();  // chatId → project
 
+// Pending note: waiting for content
+const pendingNote = new Set<number>(); // chatIds waiting for note content
+
 // Buffer for streaming logs
 const logBuffers = new Map<string, { entries: string[]; timer: ReturnType<typeof setTimeout> | null }>();
 
@@ -112,10 +115,25 @@ async function poll() {
 
 async function handleMessage(msg: any) {
   const chatId = msg.chat.id;
+
+  // Whitelist check — only allow configured chat IDs, block all if not configured
+  const settings = loadSettings();
+  const allowedIds = settings.telegramChatId.split(',').map((s: string) => s.trim()).filter(Boolean);
+  if (allowedIds.length === 0 || !allowedIds.includes(String(chatId))) {
+    return;
+  }
+
   // Message received (logged silently)
   const text: string = msg.text.trim();
   const replyTo = msg.reply_to_message?.message_id;
 
+  // Check if waiting for note content
+  if (pendingNote.has(chatId) && !text.startsWith('/')) {
+    pendingNote.delete(chatId);
+    await sendNoteToDocsClaude(chatId, text);
+    return;
+  }
+
   // Check if waiting for task prompt
   const pending = pendingTaskProject.get(chatId);
   if (pending && !text.startsWith('/')) {
@@ -186,6 +204,7 @@ async function handleMessage(msg: any) {
   if (text.startsWith('/')) {
     // Any new command cancels pending states
     pendingTaskProject.delete(chatId);
+    pendingNote.delete(chatId);
 
     const [cmd, ...args] = text.split(/\s+/);
     switch (cmd) {
@@ -238,6 +257,10 @@ async function handleMessage(msg: any) {
       case '/doc':
         await handleDocs(chatId, args.join(' '));
         break;
+      case '/note':
+      case '/docs_write':
+        await handleDocsWrite(chatId, args.join(' '));
+        break;
       case '/cancel':
         await handleCancel(chatId, args[0]);
         break;
@@ -293,7 +316,8 @@ async function sendHelp(chatId: number) {
     `📝 Submit task:\nproject-name: your instructions\n\n` +
     `👀 /peek [project] [sessionId] — session summary\n` +
     `📖 /docs — docs session summary\n` +
-    `/docs <filename> — view doc file\n\n` +
+    `/docs <filename> — view doc file\n` +
+    `📝 /note — quick note to docs claude\n\n` +
     `🔧 /cancel <id>  /retry <id>\n` +
     `/projects — list projects\n\n` +
     `🌐 /tunnel — tunnel status\n` +
@@ -1151,6 +1175,79 @@ async function handleDocs(chatId: number, input: string) {
   }
 }
 
+// ─── Docs Write (Quick Notes) ────────────────────────────────
+
+async function handleDocsWrite(chatId: number, content: string) {
+  const settings = loadSettings();
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
+
+  if (!content) {
+    pendingNote.add(chatId);
+    await send(chatId, '📝 Send your note content:');
+    return;
+  }
+
+  await sendNoteToDocsClaude(chatId, content);
+}
+
+async function sendNoteToDocsClaude(chatId: number, content: string) {
+  const settings = loadSettings();
+  const docRoots = (settings.docRoots || []).map((r: string) => r.replace(/^~/, require('os').homedir()));
+
+  if (docRoots.length === 0) {
+    await send(chatId, '⚠️ No document directories configured.');
+    return;
+  }
+
+  const { execSync, spawnSync } = require('child_process');
+  const { writeFileSync, unlinkSync } = require('fs');
+  const { join } = require('path');
+  const { homedir } = require('os');
+  const SESSION_NAME = 'mw-docs-claude';
+
+  // Check if the docs tmux session exists
+  let sessionExists = false;
+  try {
+    execSync(`tmux has-session -t ${SESSION_NAME} 2>/dev/null`);
+    sessionExists = true;
+  } catch {}
+
+  if (!sessionExists) {
+    await send(chatId, '⚠️ Docs Claude session not running. Open the Docs tab first to start it.');
+    return;
+  }
+
+  // Check if Claude is the active process (not shell)
+  let paneCmd = '';
+  try {
+    paneCmd = execSync(`tmux display-message -p -t ${SESSION_NAME} '#{pane_current_command}'`, { encoding: 'utf-8', timeout: 2000 }).trim();
+  } catch {}
+
+  if (paneCmd === 'zsh' || paneCmd === 'bash' || paneCmd === 'fish' || !paneCmd) {
+    await send(chatId, '⚠️ Claude is not running in the Docs session. Open the Docs tab and start Claude first.');
+    return;
+  }
+
+  // Write content to a temp file, then use tmux to send a prompt referencing it
+  const tmpFile = join(homedir(), '.forge', '.note-tmp.txt');
+  try {
+    writeFileSync(tmpFile, content, 'utf-8');
+
+    // Send a single-line prompt to Claude via tmux send-keys using the temp file
+    const prompt = `Please read the file ${tmpFile} and save its content as a note in the appropriate location in my docs. Analyze the content to determine the best file and location. After saving, delete the temp file.`;
+
+    // Use tmux send-keys with literal flag to avoid interpretation issues
+    spawnSync('tmux', ['send-keys', '-t', SESSION_NAME, '-l', prompt], { timeout: 5000 });
+    // Send Enter separately
+    spawnSync('tmux', ['send-keys', '-t', SESSION_NAME, 'Enter'], { timeout: 2000 });
+
+    await send(chatId, `📝 Note sent to Docs Claude:\n\n${content.slice(0, 200)}${content.length > 200 ? '...' : ''}`);
+  } catch (err) {
+    try { unlinkSync(tmpFile); } catch {}
+    await send(chatId, '❌ Failed to send note to Claude session');
+  }
+}
+
 // ─── Real-time Streaming ─────────────────────────────────────
 
 function bufferLogEntry(taskId: string, chatId: number, entry: TaskLogEntry) {
@@ -1283,6 +1380,7 @@ async function setBotCommands(token: string) {
           { command: 'tunnel_password', description: 'Get login password' },
           { command: 'peek', description: 'Session summary (AI + recent)' },
           { command: 'docs', description: 'Docs session summary / view file' },
+          { command: 'note', description: 'Quick note to docs Claude' },
           { command: 'watch', description: 'Monitor session' },
           { command: 'watchers', description: 'List watchers' },
           { command: 'help', description: 'Show help' },

package/package.json

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