@aion0/forge 0.2.3 → 0.2.4

package/CLAUDE.md

@@ -19,11 +19,15 @@ npm install -g /Users/zliu/IdeaProjects/my-workflow
 npm install -g @aion0/forge
 
 # Run via npm global install
-forge-server              # foreground (auto-builds if needed)
-forge-server --dev        # dev mode
-forge-server --background # background, logs to ~/.forge/forge.log
-forge-server --stop       # stop background server
-forge-server --rebuild    # force rebuild
+forge-server                          # foreground (default port 3000)
+forge-server --dev                    # dev mode
+forge-server --background             # background, logs to ~/.forge/forge.log
+forge-server --stop                   # stop background server
+forge-server --restart                # stop + start (safe for remote)
+forge-server --rebuild                # force rebuild
+forge-server --port 4000              # custom web port
+forge-server --terminal-port 4001     # custom terminal port
+forge-server --dir ~/.forge-staging   # custom data directory
 
 # CLI
 forge                     # help

package/bin/forge-server.mjs

@@ -3,10 +3,19 @@
  * forge-server — Start the Forge web platform.
  *
  * Usage:
- *   forge-server                Start in foreground (production mode)
- *   forge-server --dev          Start in foreground (development mode)
- *   forge-server --background   Start in background (production mode), logs to ~/.forge/forge.log
- *   forge-server --stop         Stop background server
+ *   forge-server                          Start in foreground (production)
+ *   forge-server --dev                    Start in foreground (development)
+ *   forge-server --background             Start in background
+ *   forge-server --stop                   Stop background server
+ *   forge-server --restart                Stop + start (safe for remote)
+ *   forge-server --rebuild                Force rebuild
+ *   forge-server --port 4000              Custom web port (default: 3000)
+ *   forge-server --terminal-port 4001     Custom terminal port (default: 3001)
+ *   forge-server --dir ~/.forge-test      Custom data directory (default: ~/.forge)
+ *
+ * Examples:
+ *   forge-server --background --port 4000 --terminal-port 4001 --dir ~/.forge-staging
+ *   forge-server --restart
  */
 
 import { execSync, spawn } from 'node:child_process';
@@ -17,19 +26,32 @@ import { homedir } from 'node:os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(__dirname, '..');
-const DATA_DIR = join(homedir(), '.forge');
-const PID_FILE = join(DATA_DIR, 'forge.pid');
-const LOG_FILE = join(DATA_DIR, 'forge.log');
+
+// ── Parse arguments ──
+
+function getArg(name) {
+  const idx = process.argv.indexOf(name);
+  if (idx === -1 || idx + 1 >= process.argv.length) return null;
+  return process.argv[idx + 1];
+}
 
 const isDev = process.argv.includes('--dev');
 const isBackground = process.argv.includes('--background');
 const isStop = process.argv.includes('--stop');
+const isRestart = process.argv.includes('--restart');
 const isRebuild = process.argv.includes('--rebuild');
 
+const webPort = parseInt(getArg('--port')) || 3000;
+const terminalPort = parseInt(getArg('--terminal-port')) || 3001;
+const DATA_DIR = getArg('--dir')?.replace(/^~/, homedir()) || join(homedir(), '.forge');
+
+const PID_FILE = join(DATA_DIR, 'forge.pid');
+const LOG_FILE = join(DATA_DIR, 'forge.log');
+
 process.chdir(ROOT);
 mkdirSync(DATA_DIR, { recursive: true });
 
-// ── Load ~/.forge/.env.local ──
+// ── Load <data-dir>/.env.local ──
 const envFile = join(DATA_DIR, '.env.local');
 if (existsSync(envFile)) {
   for (const line of readFileSync(envFile, 'utf-8').split('\n')) {
@@ -43,30 +65,74 @@ if (existsSync(envFile)) {
   }
 }
 
-// ── Stop ──
-if (isStop) {
+// Set env vars for Next.js and terminal server
+process.env.PORT = String(webPort);
+process.env.TERMINAL_PORT = String(terminalPort);
+process.env.FORGE_DATA_DIR = DATA_DIR;
+
+// ── Helper: stop running instance ──
+function stopServer() {
   try {
     const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim());
     process.kill(pid, 'SIGTERM');
     unlinkSync(PID_FILE);
     console.log(`[forge] Stopped (pid ${pid})`);
+    return true;
   } catch {
     console.log('[forge] No running server found');
+    return false;
   }
+}
+
+// ── Helper: start background server ──
+function startBackground() {
+  if (!existsSync(join(ROOT, '.next'))) {
+    console.log('[forge] Building...');
+    execSync('npx next build', { cwd: ROOT, stdio: 'inherit', env: { ...process.env } });
+  }
+
+  const logFd = openSync(LOG_FILE, 'a');
+  const child = spawn('npx', ['next', 'start', '-p', String(webPort)], {
+    cwd: ROOT,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env },
+    detached: true,
+  });
+
+  writeFileSync(PID_FILE, String(child.pid));
+  child.unref();
+  console.log(`[forge] Started in background (pid ${child.pid})`);
+  console.log(`[forge] Web: http://localhost:${webPort}`);
+  console.log(`[forge] Terminal: ws://localhost:${terminalPort}`);
+  console.log(`[forge] Data: ${DATA_DIR}`);
+  console.log(`[forge] Log: ${LOG_FILE}`);
+  console.log(`[forge] Stop: forge-server --stop${DATA_DIR !== join(homedir(), '.forge') ? ` --dir ${DATA_DIR}` : ''}`);
+}
+
+// ── Stop ──
+if (isStop) {
+  stopServer();
+  process.exit(0);
+}
+
+// ── Restart ──
+if (isRestart) {
+  stopServer();
+  // Brief delay to let port release
+  await new Promise(r => setTimeout(r, 1500));
+  startBackground();
   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' });
+    execSync('npx next build', { cwd: ROOT, stdio: 'inherit', env: { ...process.env } });
     writeFileSync(versionFile, pkgVersion);
     if (isRebuild) {
       console.log('[forge] Rebuild complete');
@@ -77,32 +143,14 @@ if (isRebuild || existsSync(join(ROOT, '.next', 'BUILD_ID'))) {
 
 // ── Background ──
 if (isBackground) {
-  // Build if needed
-  if (!existsSync(join(ROOT, '.next'))) {
-    console.log('[forge] Building...');
-    execSync('npx next build', { cwd: ROOT, stdio: 'inherit' });
-  }
-
-  const logFd = openSync(LOG_FILE, 'a');
-  const child = spawn('npx', ['next', 'start'], {
-    cwd: ROOT,
-    stdio: ['ignore', logFd, logFd],
-    env: { ...process.env },
-    detached: true,
-  });
-
-  writeFileSync(PID_FILE, String(child.pid));
-  child.unref();
-  console.log(`[forge] Started in background (pid ${child.pid})`);
-  console.log(`[forge] Log: ${LOG_FILE}`);
-  console.log(`[forge] Stop: forge-server --stop`);
+  startBackground();
   process.exit(0);
 }
 
 // ── Foreground ──
 if (isDev) {
-  console.log('[forge] Starting in development mode...');
-  const child = spawn('npx', ['next', 'dev', '--turbopack'], {
+  console.log(`[forge] Starting dev mode (port ${webPort}, terminal ${terminalPort}, data ${DATA_DIR})`);
+  const child = spawn('npx', ['next', 'dev', '--turbopack', '-p', String(webPort)], {
     cwd: ROOT,
     stdio: 'inherit',
     env: { ...process.env },
@@ -111,10 +159,10 @@ if (isDev) {
 } else {
   if (!existsSync(join(ROOT, '.next'))) {
     console.log('[forge] Building...');
-    execSync('npx next build', { cwd: ROOT, stdio: 'inherit' });
+    execSync('npx next build', { cwd: ROOT, stdio: 'inherit', env: { ...process.env } });
   }
-  console.log('[forge] Starting server...');
-  const child = spawn('npx', ['next', 'start'], {
+  console.log(`[forge] Starting server (port ${webPort}, terminal ${terminalPort}, data ${DATA_DIR})`);
+  const child = spawn('npx', ['next', 'start', '-p', String(webPort)], {
     cwd: ROOT,
     stdio: 'inherit',
     env: { ...process.env },

package/components/Dashboard.tsx

@@ -91,7 +91,7 @@ export default function Dashboard({ user }: { user: any }) {
   return (
     <div className="h-screen flex flex-col">
       {/* Top bar */}
-      <header className="h-10 border-b border-[var(--border)] flex items-center justify-between px-4 shrink-0">
+      <header className="h-12 border-b-2 border-[var(--border)] flex items-center justify-between px-4 shrink-0 bg-[var(--bg-secondary)]">
         <div className="flex items-center gap-4">
           <span className="text-sm font-bold text-[var(--accent)]">Forge</span>
 

package/components/NewTaskModal.tsx

@@ -155,7 +155,7 @@ export default function NewTaskModal({
               className="w-full px-3 py-2 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded text-xs text-[var(--text-primary)] focus:outline-none focus:border-[var(--accent)]"
             >
               {projects.map(p => (
-                <option key={p.name} value={p.name}>
+                <option key={`${p.name}-${p.path}`} value={p.name}>
                   {p.name} {p.language ? `(${p.language})` : ''}
                 </option>
               ))}

package/dev-test.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# dev-test.sh — Start Forge test instance (port 4000, data ~/.forge-test)
+
+mkdir -p ~/.forge-test
+PORT=4000 TERMINAL_PORT=4001 FORGE_DATA_DIR=~/.forge-test pnpm dev -- -p 4000

package/lib/init.ts

@@ -59,16 +59,16 @@ let terminalChild: ReturnType<typeof spawn> | null = null;
 function startTerminalProcess() {
   if (terminalChild) return;
 
-  // Check if port 3001 is already in use
+  const termPort = Number(process.env.TERMINAL_PORT) || 3001;
+
+  // Check if port 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');
+    console.log(`[terminal] Port ${termPort} 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'],
@@ -78,5 +78,5 @@ function startTerminalProcess() {
     terminalChild.on('exit', () => { terminalChild = null; });
     console.log('[terminal] Started standalone server (pid:', terminalChild.pid, ')');
   });
-  tester.listen(3001);
+  tester.listen(termPort);
 }

package/lib/settings.ts

@@ -3,7 +3,8 @@ import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import YAML from 'yaml';
 
-const SETTINGS_FILE = join(homedir(), '.forge', 'settings.yaml');
+const DATA_DIR = process.env.FORGE_DATA_DIR || join(homedir(), '.forge');
+const SETTINGS_FILE = join(DATA_DIR, 'settings.yaml');
 
 export interface Settings {
   projectRoots: string[];       // Multiple project directories

package/lib/telegram-bot.ts

@@ -16,13 +16,11 @@ import { startTunnel, stopTunnel, getTunnelStatus } from './cloudflared';
 import { getPassword } from './password';
 import type { Task, TaskLogEntry } from '@/src/types';
 
-let polling = false;
-let pollTimer: ReturnType<typeof setTimeout> | null = null;
-let lastUpdateId = 0;
-
-// Prevent duplicate polling across hot-reloads
-const globalKey = Symbol.for('mw-telegram-polling');
+// Prevent duplicate polling and state loss across hot-reloads
+const globalKey = Symbol.for('mw-telegram-state');
 const g = globalThis as any;
+if (!g[globalKey]) g[globalKey] = { polling: false, pollTimer: null, lastUpdateId: 0 };
+const botState: { polling: boolean; pollTimer: ReturnType<typeof setTimeout> | null; lastUpdateId: number } = g[globalKey];
 
 // Track which Telegram message maps to which task (for reply-based interaction)
 const taskMessageMap = new Map<number, string>(); // messageId → taskId
@@ -48,12 +46,11 @@ const logBuffers = new Map<string, { entries: string[]; timer: ReturnType<typeof
 // ─── Start/Stop ──────────────────────────────────────────────
 
 export function startTelegramBot() {
-  if (polling || g[globalKey]) return;
+  if (botState.polling) return;
   const settings = loadSettings();
   if (!settings.telegramBotToken || !settings.telegramChatId) return;
 
-  polling = true;
-  g[globalKey] = true;
+  botState.polling = true;
   console.log('[telegram] Bot started');
 
   // Set bot command menu
@@ -76,39 +73,37 @@ export function startTelegramBot() {
 }
 
 export function stopTelegramBot() {
-  polling = false;
-  g[globalKey] = false;
-  if (pollTimer) { clearTimeout(pollTimer); pollTimer = null; }
+  botState.polling = false;
+  if (botState.pollTimer) { clearTimeout(botState.pollTimer); botState.pollTimer = null; }
 }
 
 // ─── Polling ─────────────────────────────────────────────────
 
 async function poll() {
-  if (!polling) return;
+  if (!botState.polling) return;
 
   try {
     const settings = loadSettings();
-    const url = `https://api.telegram.org/bot${settings.telegramBotToken}/getUpdates?offset=${lastUpdateId + 1}&timeout=30`;
+    const url = `https://api.telegram.org/bot${settings.telegramBotToken}/getUpdates?offset=${botState.lastUpdateId + 1}&timeout=30`;
     const res = await fetch(url);
     const data = await res.json();
 
     if (data.ok && data.result) {
       for (const update of data.result) {
-        lastUpdateId = update.update_id;
+        botState.lastUpdateId = update.update_id;
         if (update.message?.text) {
           await handleMessage(update.message);
         }
       }
     }
   } catch (err: any) {
-    // Network errors (ECONNRESET, fetch failed) are normal during sleep/wake — silent retry
     const isNetworkError = err?.cause?.code === 'ECONNRESET' || err?.message?.includes('fetch failed');
     if (!isNetworkError) {
       console.error('[telegram] Poll error:', err);
     }
   }
 
-  pollTimer = setTimeout(poll, 1000);
+  botState.pollTimer = setTimeout(poll, 1000);
 }
 
 // ─── Message Handler ─────────────────────────────────────────

package/package.json

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

package/publish.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# publish.sh — Bump version, commit, and publish to npm
+#
+# Usage:
+#   ./publish.sh          # patch bump (0.2.3 → 0.2.4)
+#   ./publish.sh minor    # minor bump (0.2.3 → 0.3.0)
+#   ./publish.sh major    # major bump (0.2.3 → 1.0.0)
+#   ./publish.sh 0.5.0    # explicit version
+
+set -e
+
+VERSION_ARG=${1:-patch}
+CURRENT=$(node -p "require('./package.json').version")
+
+# Calculate new version
+if [[ "$VERSION_ARG" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+  NEW_VERSION=$VERSION_ARG
+elif [ "$VERSION_ARG" = "patch" ]; then
+  IFS='.' read -r major minor patch <<< "$CURRENT"
+  NEW_VERSION="$major.$minor.$((patch + 1))"
+elif [ "$VERSION_ARG" = "minor" ]; then
+  IFS='.' read -r major minor patch <<< "$CURRENT"
+  NEW_VERSION="$major.$((minor + 1)).0"
+elif [ "$VERSION_ARG" = "major" ]; then
+  IFS='.' read -r major minor patch <<< "$CURRENT"
+  NEW_VERSION="$((major + 1)).0.0"
+else
+  echo "Usage: ./publish.sh [patch|minor|major|x.y.z]"
+  exit 1
+fi
+
+echo "Version: $CURRENT → $NEW_VERSION"
+echo ""
+
+# Update package.json
+sed -i '' "s/\"version\": \"$CURRENT\"/\"version\": \"$NEW_VERSION\"/" package.json
+
+# Commit
+git add -A
+git commit -m "v$NEW_VERSION"
+git tag "v$NEW_VERSION"
+
+echo ""
+echo "Ready to publish @aion0/forge@$NEW_VERSION"
+echo "Run: npm login && npm publish --access public --otp=<code>"