@aion0/forge 0.3.0 → 0.3.2

package/CLAUDE.md

@@ -7,7 +7,8 @@
 ./start.sh dev           # development (hot-reload)
 forge server start              # production via npm link/install
 forge server start --dev        # dev mode
-forge server start --background # background, logs to ~/.forge/forge.log
+forge server start              # background by default, logs to ~/.forge/forge.log
+forge server start --foreground # foreground mode
 forge server stop               # stop background server
 forge server restart            # stop + start (safe for remote)
 forge server rebuild            # force rebuild
@@ -34,7 +35,7 @@ npm login && npm publish --access public --otp=<code>
 # ── CLI ──
 forge                    # help
 forge --version          # show version
-forge password           # show today's login password
+forge tcode              # show tunnel URL + session code
 forge tasks              # list tasks
 forge task <project> "prompt"  # submit task
 forge watch <id>         # live stream task output
@@ -54,3 +55,9 @@ forge watch <id>         # live stream task output
 Location: /Users/zliu/MyDocuments/obsidian-project/Projects/Bastion
 When I ask about my notes, use bash to search and read files from this directory.
 Example: find /Users/zliu/MyDocuments/obsidian-project -name "*.md" | head -20
+
+<!-- forge:template:obsidian-vault -->
+## Obsidian Vault
+When I ask about my notes, use bash to search and read files from the vault directory.
+Example: find <vault_path> -name "*.md" | head -20
+<!-- /forge:template:obsidian-vault -->

package/README.md

@@ -58,19 +58,19 @@ No API keys required. Uses your existing Claude Code subscription. Code never le
 | **Pipelines** | YAML DAG workflows with parallel execution & visual editor |
 | **Remote Access** | Cloudflare Tunnel with 2FA (password + session code) |
 | **Docs Viewer** | Obsidian / markdown rendering with AI assistant |
-| **Projects** | File browser, git operations, code viewer |
-| **Skills** | Browse & install Claude Code skills from registry |
+| **Projects** | File browser, git operations, code viewer with syntax highlighting, diff view |
+| **Skills** | Marketplace for skills & commands — browse, install, update, version tracking |
 | **Telegram** | Tasks, sessions, notes, tunnel control from mobile |
 | **CLI** | `forge task`, `forge watch`, `forge status`, and more |
 
 ## Quick Start
 
 ```bash
-forge server start          # start
-forge server start --dev    # dev mode with hot-reload
-forge server start --background  # run in background
-forge server stop           # stop
-forge server restart        # restart
+forge server start              # start (background by default)
+forge server start --foreground # run in foreground
+forge server start --dev        # dev mode with hot-reload
+forge server stop               # stop
+forge server restart            # restart
 ```
 
 ### From source
@@ -89,11 +89,11 @@ forge task <project> <prompt>   # submit a task
 forge tasks                     # list tasks
 forge watch <id>                # live stream output
 forge status                    # process status
-forge password                  # show login password
+forge tcode                     # show tunnel URL + session code
 forge projects                  # list projects
 forge flows                     # list workflows
 forge run <flow>                # run a workflow
-forge server start --reset-password  # reset admin password
+forge --reset-password               # reset admin password
 ```
 
 ## Telegram Bot

package/app/api/claude-templates/route.ts

@@ -0,0 +1,145 @@
+import { NextResponse } from 'next/server';
+import {
+  listTemplates,
+  getTemplate,
+  saveTemplate,
+  deleteTemplate,
+  isInjected,
+  getInjectedTemplates,
+  injectTemplate,
+  removeTemplate,
+  setTemplateDefault,
+  applyDefaultTemplates,
+} from '@/lib/claude-templates';
+import { loadSettings } from '@/lib/settings';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+function getProjectPaths(): { name: string; path: string }[] {
+  const settings = loadSettings();
+  const roots = (settings.projectRoots || []).map((r: string) => r.replace(/^~/, homedir()));
+  const projects: { name: string; path: string }[] = [];
+  for (const root of roots) {
+    try {
+      const { readdirSync, statSync } = require('node:fs');
+      for (const name of readdirSync(root)) {
+        const p = join(root, name);
+        try { if (statSync(p).isDirectory() && !name.startsWith('.')) projects.push({ name, path: p }); } catch {}
+      }
+    } catch {}
+  }
+  return projects.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// GET /api/claude-templates
+//   ?action=list — list all templates
+//   ?action=status&project=PATH — get injection status for a project
+//   ?action=read-claude-md&project=PATH — read project's CLAUDE.md content
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const action = searchParams.get('action') || 'list';
+
+  if (action === 'list') {
+    const templates = listTemplates();
+    const projects = getProjectPaths();
+    return NextResponse.json({ templates, projects });
+  }
+
+  if (action === 'status') {
+    const projectPath = searchParams.get('project');
+    if (!projectPath) return NextResponse.json({ error: 'project required' }, { status: 400 });
+    const claudeMd = join(projectPath, 'CLAUDE.md');
+    const injected = getInjectedTemplates(claudeMd);
+    const templates = listTemplates();
+    const status = templates.map(t => ({
+      id: t.id,
+      name: t.name,
+      injected: injected.includes(t.id),
+    }));
+    return NextResponse.json({ status, hasClaudeMd: existsSync(claudeMd) });
+  }
+
+  if (action === 'read-claude-md') {
+    const projectPath = searchParams.get('project');
+    if (!projectPath) return NextResponse.json({ error: 'project required' }, { status: 400 });
+    const claudeMd = join(projectPath, 'CLAUDE.md');
+    if (!existsSync(claudeMd)) return NextResponse.json({ content: '', exists: false });
+    return NextResponse.json({ content: readFileSync(claudeMd, 'utf-8'), exists: true });
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}
+
+// POST /api/claude-templates
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  // Save/create template
+  if (body.action === 'save') {
+    const { id, name, description, tags, content, isDefault } = body;
+    if (!id || !name || !content) return NextResponse.json({ error: 'id, name, content required' }, { status: 400 });
+    saveTemplate(id, name, description || '', tags || [], content, isDefault);
+    return NextResponse.json({ ok: true });
+  }
+
+  // Toggle default flag
+  if (body.action === 'set-default') {
+    const { id, isDefault } = body;
+    if (!id) return NextResponse.json({ error: 'id required' }, { status: 400 });
+    const ok = setTemplateDefault(id, !!isDefault);
+    return NextResponse.json({ ok });
+  }
+
+  // Apply default templates to a project
+  if (body.action === 'apply-defaults') {
+    const { project } = body;
+    if (!project) return NextResponse.json({ error: 'project required' }, { status: 400 });
+    const injected = applyDefaultTemplates(project);
+    return NextResponse.json({ ok: true, injected });
+  }
+
+  // Delete template
+  if (body.action === 'delete') {
+    const ok = deleteTemplate(body.id);
+    if (!ok) return NextResponse.json({ error: 'Cannot delete (builtin or not found)' }, { status: 400 });
+    return NextResponse.json({ ok: true });
+  }
+
+  // Inject template into project(s)
+  if (body.action === 'inject') {
+    const { templateId, projects } = body; // projects: string[] of paths
+    if (!templateId || !projects?.length) return NextResponse.json({ error: 'templateId and projects required' }, { status: 400 });
+    const results: { project: string; injected: boolean; reason?: string }[] = [];
+    for (const projectPath of projects) {
+      const claudeMd = join(projectPath, 'CLAUDE.md');
+      if (isInjected(claudeMd, templateId)) {
+        results.push({ project: projectPath, injected: false, reason: 'already exists' });
+      } else {
+        const ok = injectTemplate(claudeMd, templateId);
+        results.push({ project: projectPath, injected: ok });
+      }
+    }
+    return NextResponse.json({ ok: true, results });
+  }
+
+  // Remove template from project
+  if (body.action === 'remove') {
+    const { templateId, project } = body;
+    if (!templateId || !project) return NextResponse.json({ error: 'templateId and project required' }, { status: 400 });
+    const claudeMd = join(project, 'CLAUDE.md');
+    const ok = removeTemplate(claudeMd, templateId);
+    return NextResponse.json({ ok });
+  }
+
+  // Save CLAUDE.md content directly
+  if (body.action === 'save-claude-md') {
+    const { project, content } = body;
+    if (!project) return NextResponse.json({ error: 'project required' }, { status: 400 });
+    const { writeFileSync: wf } = require('node:fs');
+    wf(join(project, 'CLAUDE.md'), content, 'utf-8');
+    return NextResponse.json({ ok: true });
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}

package/app/api/docs/sessions/route.ts

@@ -1,16 +1,16 @@
 import { NextResponse } from 'next/server';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { getClaudeDir } from '@/lib/dirs';
 
 export async function GET(req: Request) {
   const { searchParams } = new URL(req.url);
   const dir = searchParams.get('dir');
   if (!dir) return NextResponse.json({ sessions: [] });
 
-  // Claude stores sessions at ~/.claude/projects/<path-with-dashes>/
+  // Claude stores sessions at <claudeDir>/projects/<path-with-dashes>/
   const hash = dir.replace(/\//g, '-');
-  const claudeDir = join(homedir(), '.claude', 'projects', hash);
+  const claudeDir = join(getClaudeDir(), 'projects', hash);
 
   if (!existsSync(claudeDir)) {
     return NextResponse.json({ sessions: [] });

package/app/api/monitor/route.ts

@@ -26,8 +26,8 @@ export async function GET() {
   try {
     const { readFileSync } = require('fs');
     const { join } = require('path');
-    const { homedir } = require('os');
-    const state = JSON.parse(readFileSync(join(homedir(), '.forge', 'tunnel-state.json'), 'utf-8'));
+    const { getDataDir: _gdd } = require('@/lib/dirs');
+    const state = JSON.parse(readFileSync(join(_gdd(), 'tunnel-state.json'), 'utf-8'));
     tunnelUrl = state.url || '';
   } catch {}
 

package/app/api/pipelines/route.ts

@@ -2,10 +2,10 @@ import { NextResponse } from 'next/server';
 import { listPipelines, listWorkflows, startPipeline } from '@/lib/pipeline';
 import { writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import YAML from 'yaml';
+import { getDataDir } from '@/lib/dirs';
 
-const FLOWS_DIR = join(homedir(), '.forge', 'flows');
+const FLOWS_DIR = join(getDataDir(), 'flows');
 
 // GET /api/pipelines — list all pipelines + available workflows
 export async function GET(req: Request) {

package/app/api/preview/[...path]/route.ts

@@ -1,9 +1,9 @@
 import { NextResponse, type NextRequest } from 'next/server';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { getDataDir } from '@/lib/dirs';
 
-const CONFIG_FILE = join(homedir(), '.forge', 'preview.json');
+const CONFIG_FILE = join(getDataDir(), 'preview.json');
 
 function getPort(): number {
   try {

package/app/api/preview/route.ts

@@ -1,10 +1,10 @@
 import { NextResponse } from 'next/server';
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
 import { spawn, execSync, type ChildProcess } from 'node:child_process';
+import { getDataDir, getConfigDir } from '@/lib/dirs';
 
-const CONFIG_FILE = join(process.env.FORGE_DATA_DIR || join(homedir(), '.forge'), 'preview.json');
+const CONFIG_FILE = join(getDataDir(), 'preview.json');
 
 interface PreviewEntry {
   port: number;
@@ -35,8 +35,7 @@ function saveConfig(entries: PreviewEntry[]) {
 }
 
 function getCloudflaredPath(): string | null {
-  const dataDir = process.env.FORGE_DATA_DIR || join(homedir(), '.forge');
-  const binPath = join(dataDir, 'bin', 'cloudflared');
+  const binPath = join(getConfigDir(), 'bin', 'cloudflared');
   if (existsSync(binPath)) return binPath;
   try {
     return execSync('which cloudflared', { encoding: 'utf-8' }).trim();

package/app/api/projects/route.ts

@@ -1,7 +1,26 @@
 import { NextResponse } from 'next/server';
 import { scanProjects } from '@/lib/projects';
+import { applyDefaultTemplates, listTemplates } from '@/lib/claude-templates';
+
+// Track known projects to detect new ones
+const knownProjects = new Set<string>();
 
 export async function GET() {
   const projects = scanProjects();
+
+  // Auto-apply default templates to newly detected projects
+  const hasDefaults = listTemplates().some(t => t.isDefault);
+  if (hasDefaults) {
+    for (const p of projects) {
+      if (!knownProjects.has(p.path)) {
+        knownProjects.add(p.path);
+        try { applyDefaultTemplates(p.path); } catch {}
+      }
+    }
+  } else {
+    // Still track projects even without defaults
+    for (const p of projects) knownProjects.add(p.path);
+  }
+
   return NextResponse.json(projects);
 }

package/app/api/skills/local/route.ts

@@ -0,0 +1,228 @@
+import { NextResponse } from 'next/server';
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { getClaudeDir } from '@/lib/dirs';
+
+const SKILLS_DIR = join(getClaudeDir(), 'skills');
+const COMMANDS_DIR = join(getClaudeDir(), 'commands');
+
+function md5(content: string): string {
+  return createHash('md5').update(content).digest('hex');
+}
+
+/** Recursively list files in a directory */
+function listFiles(dir: string, prefix = ''): { path: string; size: number }[] {
+  const files: { path: string; size: number }[] = [];
+  if (!existsSync(dir)) return files;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const fullPath = join(dir, entry.name);
+    if (entry.isFile()) {
+      files.push({ path: relPath, size: statSync(fullPath).size });
+    } else if (entry.isDirectory()) {
+      files.push(...listFiles(fullPath, relPath));
+    }
+  }
+  return files;
+}
+
+function resolveDir(name: string, type: string, projectPath?: string): string {
+  if (type === 'skill') {
+    return projectPath
+      ? join(projectPath, '.claude', 'skills', name)
+      : join(SKILLS_DIR, name);
+  }
+  // Command: could be single file or directory
+  const base = projectPath ? join(projectPath, '.claude', 'commands') : COMMANDS_DIR;
+  const dirPath = join(base, name);
+  if (existsSync(dirPath) && statSync(dirPath).isDirectory()) return dirPath;
+  // Single file — return parent dir
+  return base;
+}
+
+/** Scan a directory for all installed skills/commands */
+function scanLocalItems(projectPath?: string): { name: string; type: 'skill' | 'command'; scope: string; fileCount: number; projectPath?: string }[] {
+  const items: { name: string; type: 'skill' | 'command'; scope: string; fileCount: number; projectPath?: string }[] = [];
+
+  // Scan skills directories
+  const skillsDirs = [
+    { dir: SKILLS_DIR, scope: 'global' as const },
+    ...(projectPath ? [{ dir: join(projectPath, '.claude', 'skills'), scope: 'project' as const }] : []),
+  ];
+  for (const { dir, scope } of skillsDirs) {
+    if (!existsSync(dir)) continue;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
+        const files = listFiles(join(dir, entry.name));
+        items.push({ name: entry.name, type: 'skill', scope, fileCount: files.length });
+      }
+    }
+  }
+
+  // Scan commands directories
+  const cmdDirs = [
+    { dir: COMMANDS_DIR, scope: 'global' as const },
+    ...(projectPath ? [{ dir: join(projectPath, '.claude', 'commands'), scope: 'project' as const }] : []),
+  ];
+  for (const { dir, scope } of cmdDirs) {
+    if (!existsSync(dir)) continue;
+    // Collect names, merge file + dir with same name
+    const seen = new Map<string, { name: string; type: 'command'; scope: typeof scope; fileCount: number }>();
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith('.')) continue;
+      const cmdName = entry.isFile() ? entry.name.replace(/\.md$/, '') : entry.name;
+      if (entry.isFile() && !entry.name.endsWith('.md')) continue;
+      const existing = seen.get(cmdName);
+      if (entry.isDirectory()) {
+        const files = listFiles(join(dir, entry.name));
+        const count = files.length + (existing?.fileCount || 0);
+        seen.set(cmdName, { name: cmdName, type: 'command', scope, fileCount: count });
+      } else if (entry.isFile()) {
+        if (existing) {
+          existing.fileCount += 1;
+        } else {
+          seen.set(cmdName, { name: cmdName, type: 'command', scope, fileCount: 1 });
+        }
+      }
+    }
+    items.push(...seen.values());
+  }
+
+  return items;
+}
+
+// GET /api/skills/local?name=X&type=skill|command&project=PATH
+//   action=scan → list ALL locally installed skills/commands
+//   action=files → list installed files for a specific item
+//   action=read&path=FILE → read file content + hash
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const action = searchParams.get('action') || 'files';
+  const name = searchParams.get('name') || '';
+  const type = searchParams.get('type') || 'command';
+  const projectPath = searchParams.get('project') || '';
+
+  if (action === 'scan') {
+    const scanAll = searchParams.get('all') === '1';
+    if (scanAll) {
+      // Scan global + all configured projects
+      const { loadSettings } = require('@/lib/settings');
+      const settings = loadSettings();
+      const allItems: any[] = [];
+      // Global
+      allItems.push(...scanLocalItems());
+      // All projects
+      for (const root of (settings.projectRoots || [])) {
+        const resolvedRoot = root.replace(/^~/, homedir());
+        if (!existsSync(resolvedRoot)) continue;
+        for (const entry of readdirSync(resolvedRoot, { withFileTypes: true })) {
+          if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+          const pp = join(resolvedRoot, entry.name);
+          const projItems = scanLocalItems(pp)
+            .filter(i => i.scope === 'project')
+            .map(i => ({ ...i, projectPath: pp, scope: entry.name }));
+          allItems.push(...projItems);
+        }
+      }
+      return NextResponse.json({ items: allItems });
+    }
+    const items = scanLocalItems(projectPath || undefined);
+    return NextResponse.json({ items });
+  }
+
+  if (action === 'files') {
+    if (type === 'skill') {
+      const dir = resolveDir(name, type, projectPath || undefined);
+      return NextResponse.json({ files: listFiles(dir) });
+    } else {
+      // Command: collect both single .md file and directory contents
+      const base = projectPath ? join(projectPath, '.claude', 'commands') : COMMANDS_DIR;
+      const singleFile = join(base, `${name}.md`);
+      const dirPath = join(base, name);
+      const files: { path: string; size: number }[] = [];
+      // Single .md file at root
+      if (existsSync(singleFile)) {
+        files.push({ path: `${name}.md`, size: statSync(singleFile).size });
+      }
+      // Directory contents
+      if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
+        files.push(...listFiles(dirPath).map(f => ({ path: `${name}/${f.path}`, size: f.size })));
+      }
+      return NextResponse.json({ files });
+    }
+  }
+
+  if (action === 'read') {
+    const filePath = searchParams.get('path') || '';
+    let fullPath: string;
+    if (type === 'skill') {
+      const dir = resolveDir(name, type, projectPath || undefined);
+      fullPath = join(dir, filePath);
+    } else {
+      // filePath from files action is like "name.md" or "name/sub/file.md"
+      // Resolve relative to commands base directory
+      const base = projectPath ? join(projectPath, '.claude', 'commands') : COMMANDS_DIR;
+      fullPath = join(base, filePath);
+    }
+
+    if (!existsSync(fullPath)) return NextResponse.json({ content: '', hash: '' });
+    const content = readFileSync(fullPath, 'utf-8');
+    return NextResponse.json({ content, hash: md5(content) });
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}
+
+// POST /api/skills/local — save, install-local, delete-local
+export async function POST(req: Request) {
+  const body = await req.json();
+  const action = body.action || 'save';
+
+  // Install local skill/command to another project or global
+  if (action === 'install-local') {
+    const { installLocal } = require('@/lib/skills');
+    const { name, type, sourceProject, target, force } = body;
+    const result = installLocal(name, type, sourceProject || undefined, target, !!force);
+    return NextResponse.json(result, { status: result.ok ? 200 : 400 });
+  }
+
+  // Delete local skill/command
+  if (action === 'delete-local') {
+    const { deleteLocal } = require('@/lib/skills');
+    const { name, type, project } = body;
+    const ok = deleteLocal(name, type, project || undefined);
+    return NextResponse.json({ ok });
+  }
+
+  // Save edited file (default action)
+  const { name, type, project, path: filePath, content, expectedHash } = body;
+
+  let fullPath: string;
+  if (type === 'skill') {
+    const dir = project
+      ? join(project, '.claude', 'skills', name)
+      : join(SKILLS_DIR, name);
+    fullPath = join(dir, filePath);
+  } else {
+    const base = project ? join(project, '.claude', 'commands') : COMMANDS_DIR;
+    const dirPath = join(base, name);
+    if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
+      fullPath = join(dirPath, filePath);
+    } else {
+      fullPath = join(base, filePath);
+    }
+  }
+
+  // Check for concurrent modification
+  if (expectedHash && existsSync(fullPath)) {
+    const current = readFileSync(fullPath, 'utf-8');
+    if (md5(current) !== expectedHash) {
+      return NextResponse.json({ ok: false, error: 'File was modified externally. Reload and try again.' }, { status: 409 });
+    }
+  }
+
+  writeFileSync(fullPath, content, 'utf-8');
+  return NextResponse.json({ ok: true, hash: md5(content) });
+}

package/app/api/skills/route.ts

@@ -7,6 +7,7 @@ import {
   uninstallGlobal,
   uninstallProject,
   refreshInstallState,
+  checkLocalModified,
 } from '@/lib/skills';
 import { loadSettings } from '@/lib/settings';
 import { homedir } from 'node:os';
@@ -34,18 +35,23 @@ export async function GET(req: Request) {
   const action = searchParams.get('action');
   const name = searchParams.get('name');
 
-  // List files in a skill directory
+  // List files in a skill/command directory
   if (action === 'files' && name) {
     try {
       const settings = loadSettings();
       const repoUrl = settings.skillsRepoUrl || 'https://raw.githubusercontent.com/aiwatching/forge-skills/main';
-      // Extract owner/repo from raw URL
-      const match = repoUrl.match(/github\.com\/([^/]+\/[^/]+)/);
-      const repo = match ? match[1] : 'aiwatching/forge-skills';
+      const matchRepo = repoUrl.match(/github\.com\/([^/]+\/[^/]+)/);
+      const repo = matchRepo ? matchRepo[1] : 'aiwatching/forge-skills';
 
-      const res = await fetch(`https://api.github.com/repos/${repo}/contents/skills/${name}`, {
+      // Try skills/ first, then commands/ (repo may not have commands/ dir)
+      let res = await fetch(`https://api.github.com/repos/${repo}/contents/skills/${name}`, {
         headers: { 'Accept': 'application/vnd.github.v3+json' },
       });
+      if (!res.ok) {
+        res = await fetch(`https://api.github.com/repos/${repo}/contents/commands/${name}`, {
+          headers: { 'Accept': 'application/vnd.github.v3+json' },
+        });
+      }
       if (!res.ok) return NextResponse.json({ files: [] });
 
       const items = await res.json();
@@ -80,7 +86,11 @@ export async function GET(req: Request) {
     try {
       const settings = loadSettings();
       const baseUrl = settings.skillsRepoUrl || 'https://raw.githubusercontent.com/aiwatching/forge-skills/main';
-      const res = await fetch(`${baseUrl}/skills/${name}/${filePath}`);
+      // Try skills/ first, then commands/
+      let res = await fetch(`${baseUrl}/skills/${name}/${filePath}`);
+      if (!res.ok) {
+        res = await fetch(`${baseUrl}/commands/${name}/${filePath}`);
+      }
       if (!res.ok) return NextResponse.json({ content: '(Not found)' });
       const content = await res.text();
       return NextResponse.json({ content });
@@ -107,8 +117,18 @@ export async function POST(req: Request) {
     return NextResponse.json(result);
   }
 
+  if (body.action === 'check-modified') {
+    try {
+      const modified = await checkLocalModified(body.name);
+      return NextResponse.json({ modified });
+    } catch (e) {
+      return NextResponse.json({ modified: false, error: String(e) });
+    }
+  }
+
   if (body.action === 'install') {
     const { name, target } = body; // target: 'global' | projectPath
+    if (!name || !target) return NextResponse.json({ ok: false, error: 'name and target required' }, { status: 400 });
     try {
       if (target === 'global') {
         await installGlobal(name);
@@ -123,12 +143,17 @@ export async function POST(req: Request) {
 
   if (body.action === 'uninstall') {
     const { name, target } = body;
-    if (target === 'global') {
-      uninstallGlobal(name);
-    } else {
-      uninstallProject(name, target);
+    if (!name || !target) return NextResponse.json({ ok: false, error: 'name and target required' }, { status: 400 });
+    try {
+      if (target === 'global') {
+        uninstallGlobal(name);
+      } else {
+        uninstallProject(name, target);
+      }
+      return NextResponse.json({ ok: true });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
     }
-    return NextResponse.json({ ok: true });
   }
 
   return NextResponse.json({ error: 'Invalid action' }, { status: 400 });

package/app/api/terminal-state/route.ts

@@ -1,9 +1,9 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { NextResponse } from 'next/server';
+import { getDataDir } from '@/lib/dirs';
 
-const STATE_FILE = join(homedir(), '.forge', 'terminal-state.json');
+const STATE_FILE = join(getDataDir(), 'terminal-state.json');
 
 export async function GET() {
   try {

package/app/login/page.tsx

@@ -88,7 +88,7 @@ export default function LoginPage() {
             {showHelp && (
               <p className="text-[10px] text-[var(--text-secondary)] mt-1 bg-[var(--bg-tertiary)] rounded p-2">
                 Run in terminal:<br />
-                <code className="text-[var(--accent)]">forge server start --reset-password</code>
+                <code className="text-[var(--accent)]">forge --reset-password</code>
               </p>
             )}
           </div>