@aion0/forge 0.3.3 → 0.3.5

package/lib/pipeline.ts

@@ -30,8 +30,10 @@ export interface WorkflowNode {
   id: string;
   project: string;
   prompt: string;
+  mode?: 'claude' | 'shell';  // default: 'claude' (claude -p), 'shell' runs raw shell command
+  branch?: string;             // auto checkout this branch before running (supports templates)
   dependsOn: string[];
-  outputs: { name: string; extract: 'result' | 'git_diff' }[];
+  outputs: { name: string; extract: 'result' | 'git_diff' | 'stdout' }[];
   routes: { condition: string; next: string }[];
   maxIterations: number;
 }
@@ -70,21 +72,183 @@ export interface Pipeline {
 
 // ─── Workflow Loading ─────────────────────────────────────
 
-export function listWorkflows(): Workflow[] {
-  if (!existsSync(WORKFLOWS_DIR)) return [];
-  return readdirSync(WORKFLOWS_DIR)
-    .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
-    .map(f => {
+// ─── Built-in workflows ──────────────────────────────────
+
+export const BUILTIN_WORKFLOWS: Record<string, string> = {
+  'issue-auto-fix': `
+name: issue-auto-fix
+description: "Fetch a GitHub issue → fix code on a new branch → create PR"
+input:
+  issue_id: "GitHub issue number"
+  project: "Project name"
+  base_branch: "Base branch (default: auto-detect)"
+  extra_context: "Additional instructions for the fix (optional)"
+nodes:
+  setup:
+    mode: shell
+    project: "{{input.project}}"
+    prompt: |
+      cd "$(git rev-parse --show-toplevel)" && \
+      if [ -n "$(git status --porcelain)" ]; then echo "ERROR: Working directory has uncommitted changes. Please commit or stash first." && exit 1; fi && \
+      ORIG_BRANCH=$(git branch --show-current || git rev-parse --short HEAD) && \
+      REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || git remote get-url origin | sed 's/.*github.com[:/]//;s/.git$//') && \
+      BASE={{input.base_branch}} && \
+      if [ -z "$BASE" ] || [ "$BASE" = "auto-detect" ]; then BASE=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo main); fi && \
+      git checkout "$BASE" 2>/dev/null || true && \
+      git pull origin "$BASE" 2>/dev/null || true && \
+      OLD_BRANCH=$(git branch --list "fix/{{input.issue_id}}-*" | head -1 | tr -d ' *') && \
+      if [ -n "$OLD_BRANCH" ]; then git branch -D "$OLD_BRANCH" 2>/dev/null || true; fi && \
+      echo "REPO=$REPO" && echo "BASE=$BASE" && echo "ORIG_BRANCH=$ORIG_BRANCH"
+    outputs:
+      - name: info
+        extract: stdout
+  fetch-issue:
+    mode: shell
+    project: "{{input.project}}"
+    depends_on: [setup]
+    prompt: |
+      REPO=$(echo '{{nodes.setup.outputs.info}}' | grep REPO= | cut -d= -f2) && \
+      gh issue view {{input.issue_id}} --json title,body,labels,number -R "$REPO"
+    outputs:
+      - name: issue_json
+        extract: stdout
+  fix-code:
+    project: "{{input.project}}"
+    depends_on: [fetch-issue]
+    prompt: |
+      A GitHub issue needs to be fixed. Here is the issue data:
+
+      {{nodes.fetch-issue.outputs.issue_json}}
+
+      Steps:
+      1. Create a new branch from the current branch (which is already on the base). Name format: fix/{{input.issue_id}}-<short-description> (e.g. fix/3-add-validation, fix/15-null-pointer). Any old branch for this issue has been cleaned up.
+      2. Analyze the issue and fix the code.
+      3. Stage and commit with a message referencing #{{input.issue_id}}.
+
+      Base branch info: {{nodes.setup.outputs.info}}
+
+      Additional context from user: {{input.extra_context}}
+    outputs:
+      - name: summary
+        extract: result
+      - name: diff
+        extract: git_diff
+  push-and-pr:
+    mode: shell
+    project: "{{input.project}}"
+    depends_on: [fix-code]
+    prompt: |
+      REPO=$(echo '{{nodes.setup.outputs.info}}' | grep REPO= | cut -d= -f2) && \
+      BRANCH=$(git branch --show-current) && \
+      git push -u origin "$BRANCH" --force-with-lease 2>&1 && \
+      PR_URL=$(gh pr create --title 'Fix #{{input.issue_id}}' \
+        --body 'Auto-fix by Forge Pipeline for issue #{{input.issue_id}}.' -R "$REPO" 2>/dev/null || \
+        gh pr view "$BRANCH" --json url -q .url -R "$REPO" 2>/dev/null) && \
+      echo "$PR_URL"
+    outputs:
+      - name: pr_url
+        extract: stdout
+  notify:
+    mode: shell
+    project: "{{input.project}}"
+    depends_on: [push-and-pr]
+    prompt: |
+      ORIG=$(echo '{{nodes.setup.outputs.info}}' | grep ORIG_BRANCH= | cut -d= -f2) && \
+      if [ -n "$(git status --porcelain)" ]; then
+        echo "PR created for issue #{{input.issue_id}}: {{nodes.push-and-pr.outputs.pr_url}} (staying on $(git branch --show-current) - uncommitted changes)"
+      else
+        git checkout "$ORIG" 2>/dev/null || true
+        echo "PR created for issue #{{input.issue_id}}: {{nodes.push-and-pr.outputs.pr_url}} (switched back to $ORIG)"
+      fi
+`,
+  'pr-review': `
+name: pr-review
+description: "Review a PR → approve or request changes → notify"
+input:
+  pr_number: "Pull request number"
+  project: "Project name"
+nodes:
+  setup:
+    mode: shell
+    project: "{{input.project}}"
+    prompt: |
+      REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || git remote get-url origin | sed 's/.*github.com[:/]//;s/.git$//') && \
+      echo "REPO=$REPO"
+    outputs:
+      - name: info
+        extract: stdout
+  fetch-pr:
+    mode: shell
+    project: "{{input.project}}"
+    depends_on: [setup]
+    prompt: |
+      REPO=$(echo '{{nodes.setup.outputs.info}}' | grep REPO= | cut -d= -f2) && \
+      gh pr diff {{input.pr_number}} -R "$REPO"
+    outputs:
+      - name: diff
+        extract: stdout
+  review:
+    project: "{{input.project}}"
+    depends_on: [fetch-pr]
+    prompt: |
+      Review the following pull request diff carefully. Check for:
+      - Bugs and logic errors
+      - Security vulnerabilities
+      - Performance issues
+      - Code style and best practices
+
+      PR #{{input.pr_number}} diff:
+      {{nodes.fetch-pr.outputs.diff}}
+
+      Respond with:
+      1. APPROVED or CHANGES_REQUESTED
+      2. Detailed list of specific issues found with file paths and line numbers
+      3. Suggestions for improvement
+    outputs:
+      - name: review_result
+        extract: result
+  post-review:
+    mode: shell
+    project: "{{input.project}}"
+    depends_on: [review]
+    prompt: "echo 'Review complete for PR #{{input.pr_number}}'"
+    outputs:
+      - name: status
+        extract: stdout
+`,
+};
+
+export interface WorkflowWithMeta extends Workflow {
+  builtin?: boolean;
+}
+
+export function listWorkflows(): WorkflowWithMeta[] {
+  // User workflows
+  const userWorkflows: WorkflowWithMeta[] = [];
+  if (existsSync(WORKFLOWS_DIR)) {
+    for (const f of readdirSync(WORKFLOWS_DIR).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
       try {
-        return parseWorkflow(readFileSync(join(WORKFLOWS_DIR, f), 'utf-8'));
-      } catch {
-        return null;
+        userWorkflows.push({ ...parseWorkflow(readFileSync(join(WORKFLOWS_DIR, f), 'utf-8')), builtin: false });
+      } catch {}
+    }
+  }
+
+  // Built-in workflows (don't override user ones with same name)
+  const userNames = new Set(userWorkflows.map(w => w.name));
+  const builtins: WorkflowWithMeta[] = [];
+  for (const [, yaml] of Object.entries(BUILTIN_WORKFLOWS)) {
+    try {
+      const w = parseWorkflow(yaml);
+      if (!userNames.has(w.name)) {
+        builtins.push({ ...w, builtin: true });
       }
-    })
-    .filter(Boolean) as Workflow[];
+    } catch {}
+  }
+
+  return [...builtins, ...userWorkflows];
 }
 
-export function getWorkflow(name: string): Workflow | null {
+export function getWorkflow(name: string): WorkflowWithMeta | null {
   return listWorkflows().find(w => w.name === name) || null;
 }
 
@@ -98,6 +262,8 @@ function parseWorkflow(raw: string): Workflow {
       id,
       project: n.project || '',
       prompt: n.prompt || '',
+      mode: n.mode || 'claude',
+      branch: n.branch || undefined,
       dependsOn: n.depends_on || n.dependsOn || [],
       outputs: (n.outputs || []).map((o: any) => ({
         name: o.name,
@@ -167,31 +333,61 @@ export function listPipelines(): Pipeline[] {
 
 // ─── Template Resolution ──────────────────────────────────
 
+/** Escape a string for safe embedding in shell commands (single-quote wrapping) */
+function shellEscape(s: string): string {
+  // Replace single quotes with '\'' (end quote, escaped quote, start quote)
+  return s.replace(/'/g, "'\\''");
+}
+
 function resolveTemplate(template: string, ctx: {
   input: Record<string, string>;
   vars: Record<string, string>;
   nodes: Record<string, PipelineNodeState>;
-}): string {
+}, shellMode?: boolean): string {
   return template.replace(/\{\{(.*?)\}\}/g, (_, expr) => {
     const path = expr.trim();
+    let value = '';
 
     // {{input.xxx}}
-    if (path.startsWith('input.')) return ctx.input[path.slice(6)] || '';
-
+    if (path.startsWith('input.')) value = ctx.input[path.slice(6)] || '';
     // {{vars.xxx}}
-    if (path.startsWith('vars.')) return ctx.vars[path.slice(5)] || '';
-
+    else if (path.startsWith('vars.')) value = ctx.vars[path.slice(5)] || '';
     // {{nodes.xxx.outputs.yyy}}
-    const nodeMatch = path.match(/^nodes\.(\w+)\.outputs\.(\w+)$/);
-    if (nodeMatch) {
-      const [, nodeId, outputName] = nodeMatch;
-      return ctx.nodes[nodeId]?.outputs[outputName] || '';
+    else {
+      const nodeMatch = path.match(/^nodes\.([\w-]+)\.outputs\.([\w-]+)$/);
+      if (nodeMatch) {
+        const [, nodeId, outputName] = nodeMatch;
+        value = ctx.nodes[nodeId]?.outputs[outputName] || '';
+      } else {
+        return `{{${path}}}`;
+      }
     }
 
-    return `{{${path}}}`;
+    return shellMode ? shellEscape(value) : value;
   });
 }
 
+// ─── Project-level pipeline lock ─────────────────────────
+const projectPipelineLocks = new Map<string, string>(); // projectPath → pipelineId
+
+function acquireProjectLock(projectPath: string, pipelineId: string): boolean {
+  const existing = projectPipelineLocks.get(projectPath);
+  if (existing && existing !== pipelineId) {
+    // Check if the existing pipeline is still running
+    const p = getPipeline(existing);
+    if (p && p.status === 'running') return false;
+    // Stale lock, clear it
+  }
+  projectPipelineLocks.set(projectPath, pipelineId);
+  return true;
+}
+
+function releaseProjectLock(projectPath: string, pipelineId: string) {
+  if (projectPipelineLocks.get(projectPath) === pipelineId) {
+    projectPipelineLocks.delete(projectPath);
+  }
+}
+
 // ─── Pipeline Execution ───────────────────────────────────
 
 export function startPipeline(workflowName: string, input: Record<string, string>): Pipeline {
@@ -254,7 +450,7 @@ function recoverStuckPipelines() {
           const nodeDef = workflow.nodes[nodeId];
           if (nodeDef) {
             for (const outputDef of nodeDef.outputs) {
-              if (outputDef.extract === 'result') node.outputs[outputDef.name] = task.resultSummary || '';
+              if (outputDef.extract === 'result' || outputDef.extract === 'stdout') node.outputs[outputDef.name] = task.resultSummary || '';
               else if (outputDef.extract === 'git_diff') node.outputs[outputDef.name] = task.gitDiff || '';
             }
           }
@@ -337,8 +533,9 @@ function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
     if (!depsReady) continue;
 
     // Resolve templates
+    const isShell = nodeDef.mode === 'shell';
     const project = resolveTemplate(nodeDef.project, ctx);
-    const prompt = resolveTemplate(nodeDef.prompt, ctx);
+    const prompt = resolveTemplate(nodeDef.prompt, ctx, isShell);
 
     const projectInfo = getProjectInfo(project);
     if (!projectInfo) {
@@ -349,16 +546,41 @@ function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
       continue;
     }
 
-    // Create task with pipeline model
+    // Auto checkout branch if specified
+    if (nodeDef.branch) {
+      const branchName = resolveTemplate(nodeDef.branch, ctx);
+      try {
+        const { execSync } = require('node:child_process');
+        // Create branch if not exists, or switch to it
+        try {
+          execSync(`git checkout -b ${branchName}`, { cwd: projectInfo.path, stdio: 'pipe' });
+        } catch {
+          execSync(`git checkout ${branchName}`, { cwd: projectInfo.path, stdio: 'pipe' });
+        }
+        console.log(`[pipeline] Checked out branch: ${branchName}`);
+      } catch (e: any) {
+        nodeState.status = 'failed';
+        nodeState.error = `Branch checkout failed: ${e.message}`;
+        savePipeline(pipeline);
+        notifyStep(pipeline, nodeId, 'failed', nodeState.error);
+        continue;
+      }
+    }
+
+    // Create task — mode: 'shell' runs raw command, 'claude' runs claude -p
+    const taskMode = nodeDef.mode === 'shell' ? 'shell' : 'prompt';
     const task = createTask({
       projectName: projectInfo.name,
       projectPath: projectInfo.path,
       prompt,
+      mode: taskMode as any,
     });
     pipelineTaskIds.add(task.id);
-    const pipelineModel = loadSettings().pipelineModel;
-    if (pipelineModel && pipelineModel !== 'default') {
-      taskModelOverrides.set(task.id, pipelineModel);
+    if (taskMode !== 'shell') {
+      const pipelineModel = loadSettings().pipelineModel;
+      if (pipelineModel && pipelineModel !== 'default') {
+        taskModelOverrides.set(task.id, pipelineModel);
+      }
     }
 
     nodeState.status = 'running';
@@ -384,6 +606,50 @@ function checkPipelineCompletion(pipeline: Pipeline) {
     pipeline.completedAt = new Date().toISOString();
     savePipeline(pipeline);
     notifyPipelineComplete(pipeline);
+
+    // Update issue_autofix_processed status
+    if (pipeline.workflowName === 'issue-auto-fix') {
+      try {
+        const { updateProcessedStatus } = require('./issue-scanner');
+        const issueId = parseInt(pipeline.input.issue_id);
+        const projectInfo = getProjectInfo(pipeline.input.project);
+        if (projectInfo && issueId) {
+          const prOutput = pipeline.nodes['push-and-pr']?.outputs?.pr_url || '';
+          const prMatch = prOutput.match(/\/pull\/(\d+)/);
+          const prNumber = prMatch ? parseInt(prMatch[1]) : undefined;
+          updateProcessedStatus(projectInfo.path, issueId, pipeline.status, prNumber);
+        }
+      } catch {}
+    }
+
+    // Auto-chain: issue-auto-fix → pr-review
+    if (pipeline.workflowName === 'issue-auto-fix' && pipeline.status === 'done') {
+      try {
+        // Extract PR number from push-and-pr output
+        const prOutput = pipeline.nodes['push-and-pr']?.outputs?.pr_url || '';
+        const prMatch = prOutput.match(/\/pull\/(\d+)/);
+        if (prMatch) {
+          const prNumber = prMatch[1];
+          console.log(`[pipeline] Auto-triggering pr-review for PR #${prNumber}`);
+          startPipeline('pr-review', {
+            pr_number: prNumber,
+            project: pipeline.input.project || '',
+          });
+        }
+      } catch (e) {
+        console.error('[pipeline] Failed to auto-trigger pr-review:', e);
+      }
+    }
+
+    // Release project lock
+    const workflow = getWorkflow(pipeline.workflowName);
+    if (workflow) {
+      const projectNames = new Set(Object.values(workflow.nodes).map(n => n.project));
+      for (const pName of projectNames) {
+        const pInfo = getProjectInfo(resolveTemplate(pName, { input: pipeline.input, vars: pipeline.vars, nodes: pipeline.nodes }));
+        if (pInfo) releaseProjectLock(pInfo.path, pipeline.id);
+      }
+    }
   }
 }
 
@@ -422,6 +688,8 @@ function setupTaskListener(pipelineId: string) {
       for (const outputDef of nodeDef.outputs) {
         if (outputDef.extract === 'result') {
           nodeState.outputs[outputDef.name] = task.resultSummary || '';
+        } else if (outputDef.extract === 'stdout') {
+          nodeState.outputs[outputDef.name] = task.resultSummary || '';
         } else if (outputDef.extract === 'git_diff') {
           nodeState.outputs[outputDef.name] = task.gitDiff || '';
         }

package/lib/settings.ts

@@ -26,6 +26,7 @@ export interface Settings {
   skillsRepoUrl: string;              // GitHub raw URL for skills registry
   displayName: string;                  // User display name (shown in header)
   displayEmail: string;                 // User email (for session/future integrations)
+  favoriteProjects: string[];           // Favorite project paths (shown at top of sidebar)
 }
 
 const defaults: Settings = {
@@ -47,6 +48,7 @@ const defaults: Settings = {
   skillsRepoUrl: 'https://raw.githubusercontent.com/aiwatching/forge-skills/main',
   displayName: 'Forge',
   displayEmail: '',
+  favoriteProjects: [],
 };
 
 /** Load settings with secrets decrypted (for internal use) */

package/lib/skills.ts

@@ -34,6 +34,7 @@ export interface SkillItem {
   installedProjects: string[];
   installedVersion: string;  // version currently installed (empty if not installed)
   hasUpdate: boolean;         // true if registry version > installed version
+  deletedRemotely: boolean;   // true if removed from remote registry but still installed locally
 }
 
 function db() {
@@ -182,13 +183,16 @@ export async function syncSkills(): Promise<{ synced: number; error?: string }>
     });
     tx();
 
-    // Remove items no longer in registry (not installed locally)
+    // Handle items no longer in registry
     const registryNames = new Set(items.map(s => s.name));
     const dbItems = db().prepare('SELECT name, installed_global, installed_projects FROM skills').all() as any[];
     for (const row of dbItems) {
       if (!registryNames.has(row.name)) {
         const hasLocal = !!row.installed_global || JSON.parse(row.installed_projects || '[]').length > 0;
-        if (!hasLocal) {
+        if (hasLocal) {
+          // Still installed locally — mark as deleted remotely so the user can decide
+          db().prepare('UPDATE skills SET deleted_remotely = 1 WHERE name = ?').run(row.name);
+        } else {
           db().prepare('DELETE FROM skills WHERE name = ?').run(row.name);
         }
       }
@@ -223,6 +227,7 @@ export function listSkills(): SkillItem[] {
       installedProjects: JSON.parse(r.installed_projects || '[]'),
       installedVersion,
       hasUpdate: isInstalled && !!registryVersion && !!installedVersion && compareVersions(registryVersion, installedVersion) > 0,
+      deletedRemotely: !!r.deleted_remotely,
     };
   });
 }
@@ -529,6 +534,29 @@ export function installLocal(name: string, type: string, sourceProject: string |
   return { ok: true };
 }
 
+/** Remove all local files for a skill deleted from the remote registry, then drop its DB record. */
+export function purgeDeletedSkill(name: string): void {
+  const row = db().prepare('SELECT type, installed_projects FROM skills WHERE name = ?').get(name) as any;
+  if (!row) return;
+  const type: string = row.type || 'skill';
+  const projects: string[] = JSON.parse(row.installed_projects || '[]');
+
+  // Remove global files
+  try { rmSync(join(GLOBAL_SKILLS_DIR, name), { recursive: true }); } catch {}
+  try { unlinkSync(join(GLOBAL_COMMANDS_DIR, `${name}.md`)); } catch {}
+  try { rmSync(join(GLOBAL_COMMANDS_DIR, name), { recursive: true }); } catch {}
+
+  // Remove project-local files
+  for (const pp of projects) {
+    try { rmSync(join(pp, '.claude', 'skills', name), { recursive: true }); } catch {}
+    try { unlinkSync(join(pp, '.claude', 'commands', `${name}.md`)); } catch {}
+    try { rmSync(join(pp, '.claude', 'commands', name), { recursive: true }); } catch {}
+  }
+
+  // Remove DB record entirely
+  db().prepare('DELETE FROM skills WHERE name = ?').run(name);
+}
+
 /** Delete a local skill/command from a specific project or global */
 export function deleteLocal(name: string, type: string, projectPath?: string): boolean {
   const base = projectPath ? join(projectPath, '.claude') : getClaudeDir();

package/lib/task-manager.ts

@@ -235,7 +235,46 @@ async function processNextTask() {
   }
 }
 
+function executeShellTask(task: Task): Promise<void> {
+  return new Promise((resolve) => {
+    updateTaskStatus(task.id, 'running');
+    db().prepare('UPDATE tasks SET started_at = datetime(\'now\') WHERE id = ?').run(task.id);
+    console.log(`[task:shell] ${task.projectName}: "${task.prompt.slice(0, 80)}"`);
+
+    const child = spawn('bash', ['-c', task.prompt], {
+      cwd: task.projectPath,
+      env: { ...process.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk: Buffer) => {
+      const text = chunk.toString();
+      stdout += text;
+      appendLog(task.id, { type: 'system', subtype: 'text', content: text, timestamp: new Date().toISOString() });
+    });
+    child.stderr.on('data', (chunk: Buffer) => { stderr += chunk.toString(); });
+
+    child.on('exit', (code) => {
+      if (code === 0) {
+        db().prepare('UPDATE tasks SET status = ?, result_summary = ?, completed_at = datetime(\'now\') WHERE id = ?')
+          .run('done', stdout.trim(), task.id);
+        emit(task.id, 'status', 'done');
+      } else {
+        const errMsg = stderr.trim() || `Exit code ${code}`;
+        db().prepare('UPDATE tasks SET status = ?, error = ?, completed_at = datetime(\'now\') WHERE id = ?')
+          .run('failed', errMsg, task.id);
+        emit(task.id, 'status', 'failed');
+      }
+      resolve();
+    });
+  });
+}
+
 function executeTask(task: Task): Promise<void> {
+  if (task.mode === 'shell') return executeShellTask(task);
+
   return new Promise((resolve, reject) => {
     const settings = loadSettings();
     const claudePath = settings.claudePath || process.env.CLAUDE_PATH || 'claude';

package/lib/terminal-standalone.ts

@@ -28,12 +28,16 @@ import { WebSocketServer, WebSocket } from 'ws';
 import * as pty from 'node-pty';
 import { execSync } from 'node:child_process';
 import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { getDataDir } from './dirs';
 import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 const PORT = Number(process.env.TERMINAL_PORT) || 3001;
-const SESSION_PREFIX = 'mw-';
+// Session prefix based on DATA_DIR hash — default instance keeps 'mw-' for backward compat
+const _dataDir = process.env.FORGE_DATA_DIR || '';
+const _isDefault = !_dataDir || _dataDir.endsWith('/data') || _dataDir.endsWith('/.forge');
+const SESSION_PREFIX = _isDefault ? 'mw-' : `mw${createHash('md5').update(_dataDir).digest('hex').slice(0, 6)}-`;
 
 // Remove CLAUDECODE env so Claude Code can run inside terminal sessions
 delete process.env.CLAUDECODE;

package/next.config.ts

@@ -1,5 +1,7 @@
 import type { NextConfig } from 'next';
 
+const terminalPort = parseInt(process.env.TERMINAL_PORT || '') || 3001;
+
 const nextConfig: NextConfig = {
   serverExternalPackages: ['better-sqlite3'],
   async rewrites() {
@@ -7,7 +9,7 @@ const nextConfig: NextConfig = {
       {
         // Proxy terminal WebSocket through Next.js so it works via Cloudflare Tunnel
         source: '/terminal-ws',
-        destination: 'http://localhost:3001',
+        destination: `http://localhost:${terminalPort}`,
       },
     ];
   },

package/package.json

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

package/src/core/db/database.ts

@@ -33,6 +33,7 @@ function initSchema(db: Database.Database) {
   migrate('ALTER TABLE skills ADD COLUMN archive TEXT');
   migrate("ALTER TABLE skills ADD COLUMN installed_version TEXT NOT NULL DEFAULT ''");
   migrate('ALTER TABLE skills ADD COLUMN rating REAL DEFAULT 0');
+  migrate('ALTER TABLE skills ADD COLUMN deleted_remotely INTEGER NOT NULL DEFAULT 0');
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS sessions (
@@ -148,6 +149,18 @@ function initSchema(db: Database.Database) {
       synced_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
 
+    -- Tab state (projects, docs, etc)
+    CREATE TABLE IF NOT EXISTS tab_state (
+      type TEXT PRIMARY KEY,
+      data TEXT NOT NULL DEFAULT '{}'
+    );
+
+    -- Project favorites
+    CREATE TABLE IF NOT EXISTS project_favorites (
+      project_path TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
     -- Session watchers — monitor sessions and notify via Telegram
     CREATE TABLE IF NOT EXISTS session_watchers (
       id TEXT PRIMARY KEY,

package/src/types/index.ts

@@ -76,7 +76,7 @@ export interface UsageRecord {
 }
 
 export type TaskStatus = 'queued' | 'running' | 'done' | 'failed' | 'cancelled';
-export type TaskMode = 'prompt' | 'monitor';
+export type TaskMode = 'prompt' | 'monitor' | 'shell';
 
 export interface WatchConfig {
   condition: 'change' | 'idle' | 'complete' | 'error' | 'keyword';