@aion0/forge 0.1.0

package/lib/cloudflared.ts

@@ -0,0 +1,218 @@
+/**
+ * Cloudflare Tunnel (cloudflared) integration.
+ * Zero-config mode: no account needed, gives a temporary public URL.
+ */
+
+import { spawn, execSync, type ChildProcess } from 'node:child_process';
+import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync } from 'node:fs';
+import { homedir, platform, arch } from 'node:os';
+import { join } from 'node:path';
+import https from 'node:https';
+import http from 'node:http';
+
+const BIN_DIR = join(homedir(), '.my-workflow', 'bin');
+const BIN_NAME = platform() === 'win32' ? 'cloudflared.exe' : 'cloudflared';
+const BIN_PATH = join(BIN_DIR, BIN_NAME);
+
+// ─── Download URL resolution ────────────────────────────────────
+
+function getDownloadUrl(): string {
+  const os = platform();
+  const cpu = arch();
+  const base = 'https://github.com/cloudflare/cloudflared/releases/latest/download';
+
+  if (os === 'darwin') {
+    // macOS universal binary
+    return `${base}/cloudflared-darwin-amd64.tgz`;
+  }
+  if (os === 'linux') {
+    if (cpu === 'arm64') return `${base}/cloudflared-linux-arm64`;
+    return `${base}/cloudflared-linux-amd64`;
+  }
+  if (os === 'win32') {
+    return `${base}/cloudflared-windows-amd64.exe`;
+  }
+  throw new Error(`Unsupported platform: ${os}/${cpu}`);
+}
+
+// ─── Download helper ────────────────────────────────────────────
+
+function followRedirects(url: string, dest: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith('https') ? https : http;
+    client.get(url, { headers: { 'User-Agent': 'my-workflow' } }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        followRedirects(res.headers.location, dest).then(resolve, reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        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);
+  });
+}
+
+export async function downloadCloudflared(): Promise<string> {
+  if (existsSync(BIN_PATH)) return BIN_PATH;
+
+  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);
+
+  if (isTgz) {
+    // Extract tgz (macOS)
+    execSync(`tar -xzf "${tmpPath}" -C "${BIN_DIR}"`, { encoding: 'utf-8' });
+    try { unlinkSync(tmpPath); } catch {}
+  }
+
+  if (platform() !== 'win32') {
+    chmodSync(BIN_PATH, 0o755);
+  }
+
+  console.log(`[cloudflared] Installed to ${BIN_PATH}`);
+  return BIN_PATH;
+}
+
+export function isInstalled(): boolean {
+  return existsSync(BIN_PATH);
+}
+
+// ─── Tunnel process management ──────────────────────────────────
+// Use globalThis to persist state across hot-reloads
+
+interface TunnelState {
+  process: ChildProcess | null;
+  url: string | null;
+  status: 'stopped' | 'starting' | 'running' | 'error';
+  error: string | null;
+  log: string[];
+}
+
+const stateKey = Symbol.for('mw-tunnel-state');
+const gAny = globalThis as any;
+if (!gAny[stateKey]) {
+  gAny[stateKey] = { process: null, url: null, status: 'stopped', error: null, log: [] } as TunnelState;
+}
+const state: TunnelState = gAny[stateKey];
+
+const MAX_LOG_LINES = 100;
+
+function pushLog(line: string) {
+  state.log.push(line);
+  if (state.log.length > MAX_LOG_LINES) state.log.shift();
+}
+
+export async function startTunnel(localPort: number = 3000): Promise<{ url?: string; error?: string }> {
+  if (state.process) {
+    return state.url ? { url: state.url } : { error: 'Tunnel is starting...' };
+  }
+
+  state.status = 'starting';
+  state.url = null;
+  state.error = null;
+  state.log = [];
+
+  let binPath: string;
+  try {
+    binPath = await downloadCloudflared();
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    state.status = 'error';
+    state.error = msg;
+    return { error: msg };
+  }
+
+  return new Promise((resolve) => {
+    let resolved = false;
+
+    state.process = spawn(binPath, ['tunnel', '--url', `http://localhost:${localPort}`], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    const handleOutput = (data: Buffer) => {
+      const text = data.toString();
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        pushLog(line);
+
+        const urlMatch = line.match(/(https:\/\/[a-z0-9-]+\.trycloudflare\.com)/);
+        if (urlMatch && !state.url) {
+          state.url = urlMatch[1];
+          state.status = 'running';
+          console.log(`[cloudflared] Tunnel URL: ${state.url}`);
+          if (!resolved) {
+            resolved = true;
+            resolve({ url: state.url });
+          }
+        }
+      }
+    };
+
+    state.process.stdout?.on('data', handleOutput);
+    state.process.stderr?.on('data', handleOutput);
+
+    state.process.on('error', (err) => {
+      state.status = 'error';
+      state.error = err.message;
+      pushLog(`[error] ${err.message}`);
+      if (!resolved) {
+        resolved = true;
+        resolve({ error: err.message });
+      }
+    });
+
+    state.process.on('exit', (code) => {
+      state.process = null;
+      if (state.status !== 'error') {
+        state.status = 'stopped';
+      }
+      state.url = null;
+      pushLog(`[exit] cloudflared exited with code ${code}`);
+      if (!resolved) {
+        resolved = true;
+        resolve({ error: `cloudflared exited with code ${code}` });
+      }
+    });
+
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        if (!state.url) {
+          state.status = 'error';
+          state.error = 'Timeout waiting for tunnel URL';
+          resolve({ error: 'Timeout waiting for tunnel URL (30s)' });
+        }
+      }
+    }, 30000);
+  });
+}
+
+export function stopTunnel() {
+  if (state.process) {
+    state.process.kill('SIGTERM');
+    state.process = null;
+  }
+  state.url = null;
+  state.status = 'stopped';
+  state.error = null;
+}
+
+export function getTunnelStatus() {
+  return {
+    status: state.status,
+    url: state.url,
+    error: state.error,
+    installed: isInstalled(),
+    log: state.log.slice(-20),
+  };
+}

package/lib/flows.ts

@@ -0,0 +1,86 @@
+/**
+ * Workflow (Flow) engine — loads YAML flow definitions and executes them.
+ *
+ * Flow files live in ~/.my-workflow/flows/*.yaml
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import YAML from 'yaml';
+import { createTask } from './task-manager';
+import { getProjectInfo } from './projects';
+import type { Task } from '@/src/types';
+
+const FLOWS_DIR = join(homedir(), '.my-workflow', 'flows');
+
+export interface FlowStep {
+  project: string;
+  prompt: string;
+  priority?: number;
+  dependsOn?: string;  // step name to wait for
+}
+
+export interface Flow {
+  name: string;
+  description?: string;
+  schedule?: string;    // cron expression for auto-trigger
+  steps: FlowStep[];
+}
+
+export function listFlows(): Flow[] {
+  if (!existsSync(FLOWS_DIR)) return [];
+
+  return readdirSync(FLOWS_DIR)
+    .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
+    .map(f => {
+      try {
+        const raw = readFileSync(join(FLOWS_DIR, f), 'utf-8');
+        const parsed = YAML.parse(raw);
+        return {
+          name: parsed.name || f.replace(/\.ya?ml$/, ''),
+          description: parsed.description,
+          schedule: parsed.schedule,
+          steps: parsed.steps || [],
+        } as Flow;
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean) as Flow[];
+}
+
+export function getFlow(name: string): Flow | null {
+  return listFlows().find(f => f.name === name) || null;
+}
+
+/**
+ * Run a flow — creates tasks for each step.
+ * Steps without dependsOn run immediately (queued).
+ * Steps with dependsOn will be handled by a follow-up mechanism.
+ */
+export function runFlow(name: string): { flow: Flow; tasks: Task[] } {
+  const flow = getFlow(name);
+  if (!flow) throw new Error(`Flow not found: ${name}`);
+
+  const tasks: Task[] = [];
+
+  for (const step of flow.steps) {
+    const project = getProjectInfo(step.project);
+    if (!project) {
+      console.error(`[flow] Project not found: ${step.project}, skipping step`);
+      continue;
+    }
+
+    const task = createTask({
+      projectName: project.name,
+      projectPath: project.path,
+      prompt: step.prompt,
+      priority: step.priority || 0,
+    });
+
+    tasks.push(task);
+  }
+
+  return { flow, tasks };
+}

package/lib/init.ts

@@ -0,0 +1,82 @@
+/**
+ * Server-side initialization — called once on first API request.
+ * Starts background services: task runner, Telegram bot.
+ */
+
+import { ensureRunnerStarted } from './task-manager';
+import { startTelegramBot, stopTelegramBot } from './telegram-bot';
+import { startWatcherLoop } from './session-watcher';
+import { getPassword } from './password';
+import { loadSettings } from './settings';
+import { startTunnel } from './cloudflared';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+
+const initKey = Symbol.for('mw-initialized');
+const gInit = globalThis as any;
+
+export function ensureInitialized() {
+  if (gInit[initKey]) return;
+  gInit[initKey] = true;
+
+  // Display login password (auto-generated, rotates daily)
+  const password = getPassword();
+  console.log(`[init] Login password: ${password} (valid today)`);
+  console.log('[init] Forgot? Run: mw password');
+
+  // Start background task runner
+  ensureRunnerStarted();
+
+  // Start Telegram bot if configured
+  startTelegramBot();
+
+  // Start terminal WebSocket server as separate process (node-pty needs native module)
+  startTerminalProcess();
+
+  // Start session watcher loop
+  startWatcherLoop();
+
+  // Auto-start tunnel if configured
+  const settings = loadSettings();
+  if (settings.tunnelAutoStart) {
+    startTunnel().then(result => {
+      if (result.url) console.log(`[init] Tunnel started: ${result.url}`);
+      else if (result.error) console.log(`[init] Tunnel failed: ${result.error}`);
+    });
+  }
+
+  console.log('[init] Background services started');
+}
+
+/** Restart Telegram bot (e.g. after settings change) */
+export function restartTelegramBot() {
+  stopTelegramBot();
+  startTelegramBot();
+}
+
+let terminalChild: ReturnType<typeof spawn> | null = null;
+
+function startTerminalProcess() {
+  if (terminalChild) return;
+
+  // Check if port 3001 is already in use
+  const net = require('node:net');
+  const tester = net.createServer();
+  tester.once('error', () => {
+    // Port in use — terminal server already running
+    console.log('[terminal] Port 3001 already in use, skipping');
+  });
+  tester.once('listening', () => {
+    tester.close();
+    // Port free — start terminal server
+    const script = join(process.cwd(), 'lib', 'terminal-standalone.ts');
+    terminalChild = spawn('npx', ['tsx', script], {
+      stdio: ['ignore', 'inherit', 'inherit'],
+      env: { ...Object.fromEntries(Object.entries(process.env).filter(([k]) => k !== 'CLAUDECODE')) } as NodeJS.ProcessEnv,
+      detached: false,
+    });
+    terminalChild.on('exit', () => { terminalChild = null; });
+    console.log('[terminal] Started standalone server (pid:', terminalChild.pid, ')');
+  });
+  tester.listen(3001);
+}

package/lib/notify.ts

@@ -0,0 +1,75 @@
+/**
+ * Notification module — sends task updates via Telegram.
+ */
+
+import { loadSettings } from './settings';
+import type { Task } from '@/src/types';
+
+export async function notifyTaskComplete(task: Task) {
+  const settings = loadSettings();
+  if (!settings.notifyOnComplete) return;
+
+  const cost = task.costUSD != null ? `$${task.costUSD.toFixed(4)}` : 'unknown';
+  const duration = task.startedAt && task.completedAt
+    ? formatDuration(new Date(task.completedAt).getTime() - new Date(task.startedAt).getTime())
+    : 'unknown';
+
+  await sendTelegram(
+    `✅ *Task Done*\n\n` +
+    `*Project:* ${esc(task.projectName)}\n` +
+    `*Task:* ${esc(task.prompt.slice(0, 200))}\n` +
+    `*Duration:* ${duration}\n` +
+    `*Cost:* ${cost}\n\n` +
+    `${task.resultSummary ? `*Result:*\n${esc(task.resultSummary.slice(0, 500))}` : '_No summary_'}`
+  );
+}
+
+export async function notifyTaskFailed(task: Task) {
+  const settings = loadSettings();
+  if (!settings.notifyOnFailure) return;
+
+  await sendTelegram(
+    `❌ *Task Failed*\n\n` +
+    `*Project:* ${esc(task.projectName)}\n` +
+    `*Task:* ${esc(task.prompt.slice(0, 200))}\n` +
+    `*Error:* ${esc(task.error || 'Unknown error')}`
+  );
+}
+
+async function sendTelegram(text: string) {
+  const settings = loadSettings();
+  const { telegramBotToken, telegramChatId } = settings;
+
+  if (!telegramBotToken || !telegramChatId) return;
+
+  try {
+    const url = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: telegramChatId,
+        text,
+        parse_mode: 'Markdown',
+        disable_web_page_preview: true,
+      }),
+    });
+
+    if (!res.ok) {
+      console.error('[notify] Telegram error:', res.status, await res.text());
+    }
+  } catch (err) {
+    console.error('[notify] Telegram send failed:', err);
+  }
+}
+
+// Escape Markdown special characters
+function esc(s: string): string {
+  return s.replace(/[_*[\]()~`>#+=|{}.!-]/g, '\\$&');
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 60000) return `${Math.round(ms / 1000)}s`;
+  if (ms < 3600000) return `${Math.floor(ms / 60000)}m ${Math.round((ms % 60000) / 1000)}s`;
+  return `${Math.floor(ms / 3600000)}h ${Math.floor((ms % 3600000) / 60000)}m`;
+}

package/lib/password.ts

@@ -0,0 +1,77 @@
+/**
+ * Auto-generated login password.
+ * Rotates daily. Saved to ~/.my-workflow/password.json with date.
+ * CLI can read it via `mw password`.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+const PASSWORD_FILE = join(homedir(), '.my-workflow', 'password.json');
+
+function generatePassword(): string {
+  // 8-char alphanumeric, easy to type
+  return randomBytes(6).toString('base64url').slice(0, 8);
+}
+
+function todayStr(): string {
+  return new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+}
+
+interface PasswordData {
+  password: string;
+  date: string;
+}
+
+function readPasswordData(): PasswordData | null {
+  try {
+    if (!existsSync(PASSWORD_FILE)) return null;
+    return JSON.parse(readFileSync(PASSWORD_FILE, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function savePasswordData(data: PasswordData) {
+  const dir = dirname(PASSWORD_FILE);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(PASSWORD_FILE, JSON.stringify(data), { mode: 0o600 });
+}
+
+/**
+ * Get the current password. Priority:
+ * 1. MW_PASSWORD env var (user explicitly set, never rotates)
+ * 2. Saved password file if still valid today
+ * 3. Generate new one, save with today's date
+ */
+export function getPassword(): string {
+  // If user explicitly set MW_PASSWORD, use it (no rotation)
+  if (process.env.MW_PASSWORD && process.env.MW_PASSWORD !== 'auto') {
+    return process.env.MW_PASSWORD;
+  }
+
+  const today = todayStr();
+  const saved = readPasswordData();
+
+  // Valid for today
+  if (saved && saved.date === today && saved.password) {
+    return saved.password;
+  }
+
+  // Expired or missing — generate new
+  const password = generatePassword();
+  savePasswordData({ password, date: today });
+  console.log(`[password] New daily password generated for ${today}`);
+  return password;
+}
+
+/** Read password from file (for CLI use) */
+export function readPasswordFile(): string | null {
+  const data = readPasswordData();
+  if (!data) return null;
+  // Only return if still valid today
+  if (data.date !== todayStr()) return null;
+  return data.password;
+}

package/lib/projects.ts

@@ -0,0 +1,86 @@
+import { readdirSync, existsSync, statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadSettings } from './settings';
+
+export interface LocalProject {
+  name: string;
+  path: string;
+  root: string;              // Which project root it came from
+  hasGit: boolean;
+  hasClaudeMd: boolean;
+  language: string | null;
+  lastModified: string;
+}
+
+export function scanProjects(): LocalProject[] {
+  const settings = loadSettings();
+  const roots = settings.projectRoots;
+
+  if (roots.length === 0) return [];
+
+  const projects: LocalProject[] = [];
+
+  for (const root of roots) {
+    if (!existsSync(root)) continue;
+
+    const entries = readdirSync(root, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.')) continue;
+
+      const projectPath = join(root, entry.name);
+
+      try {
+        const hasGit = existsSync(join(projectPath, '.git'));
+        const hasClaudeMd = existsSync(join(projectPath, 'CLAUDE.md'));
+        const language = detectLanguage(projectPath);
+        const stat = statSync(projectPath);
+
+        projects.push({
+          name: entry.name,
+          path: projectPath,
+          root,
+          hasGit,
+          hasClaudeMd,
+          language,
+          lastModified: stat.mtime.toISOString(),
+        });
+      } catch {
+        // Skip inaccessible directories
+      }
+    }
+  }
+
+  return projects.sort((a, b) => b.lastModified.localeCompare(a.lastModified));
+}
+
+function detectLanguage(projectPath: string): string | null {
+  const markers: [string, string][] = [
+    ['pom.xml', 'java'],
+    ['build.gradle', 'java'],
+    ['build.gradle.kts', 'kotlin'],
+    ['package.json', 'typescript'],
+    ['tsconfig.json', 'typescript'],
+    ['requirements.txt', 'python'],
+    ['pyproject.toml', 'python'],
+    ['go.mod', 'go'],
+    ['Cargo.toml', 'rust'],
+  ];
+
+  for (const [file, lang] of markers) {
+    if (existsSync(join(projectPath, file))) return lang;
+  }
+  return null;
+}
+
+export function getProjectInfo(name: string): LocalProject | null {
+  const projects = scanProjects();
+  return projects.find(p => p.name === name) || null;
+}
+
+export function getProjectClaudeMd(projectPath: string): string | null {
+  const claudeMdPath = join(projectPath, 'CLAUDE.md');
+  if (!existsSync(claudeMdPath)) return null;
+  return readFileSync(claudeMdPath, 'utf-8');
+}