@aion0/forge 0.5.49 → 0.5.50

package/app/api/craft-system/publish/route.ts

@@ -0,0 +1,50 @@
+import { NextResponse } from 'next/server';
+import { bundleCraftForPublish } from '@/lib/crafts/registry';
+import { loadSettings } from '@/lib/settings';
+
+// POST /api/craft-system/publish   body: { projectPath, name }
+// Bundles the craft files + a registry-entry snippet ready to drop into the
+// forge-crafts registry repo. Returns { entry, files, instructions }.
+export async function POST(req: Request) {
+  const { projectPath, name } = await req.json() as { projectPath: string; name: string };
+  if (!projectPath || !name) return NextResponse.json({ error: 'projectPath + name required' }, { status: 400 });
+
+  const bundle = bundleCraftForPublish(projectPath, name);
+  if (bundle.error) return NextResponse.json({ error: bundle.error }, { status: 400 });
+
+  const repo = (loadSettings() as any).craftsRepoUrl || 'https://raw.githubusercontent.com/aiwatching/forge-crafts/main';
+  const repoMatch = repo.match(/github\.com\/([^/]+)\/([^/]+)|raw\.githubusercontent\.com\/([^/]+)\/([^/]+)/);
+  const ownerRepo = repoMatch ? `${repoMatch[1] || repoMatch[3]}/${(repoMatch[2] || repoMatch[4]).replace(/\.git$/, '')}` : 'aiwatching/forge-crafts';
+
+  // GitHub web-edit deep links — clicking "create file" without write access
+  // makes GitHub auto-fork the repo into the user's account, create the file
+  // in the fork, and prompt to open a PR. Zero local-clone required.
+  const ghBase = `https://github.com/${ownerRepo}`;
+  const editFileUrl = (path: string) => `${ghBase}/edit/main/${encodeURIComponent(path)}`;
+
+  // GitHub's /new/<branch>/<dir>?filename=<name>&value=<...> — dir + filename
+  // are independent so we split nested paths into prefix dir / leaf name.
+  const fileLinks = bundle.files.map(f => {
+    const lastSlash = f.path.lastIndexOf('/');
+    const subdir = lastSlash >= 0 ? f.path.slice(0, lastSlash) : '';
+    const filename = lastSlash >= 0 ? f.path.slice(lastSlash + 1) : f.path;
+    const dirPath = subdir ? `${bundle.entry.name}/${subdir}` : bundle.entry.name;
+    const githubUrl = `${ghBase}/new/main/${dirPath.split('/').map(encodeURIComponent).join('/')}?filename=${encodeURIComponent(filename)}&value=${encodeURIComponent(f.content)}`;
+    return { path: f.path, githubUrl };
+  });
+
+  return NextResponse.json({
+    entry: bundle.entry,
+    files: bundle.files,
+    fileLinks,
+    repo: { owner: ownerRepo.split('/')[0], name: ownerRepo.split('/')[1], url: ghBase },
+    registryEditUrl: editFileUrl('registry.json'),
+    instructions: [
+      `All publishes go through a pull request — direct pushes to main are not accepted, even from maintainers.`,
+      `1. Click each file's "Open in GitHub" button. GitHub auto-forks ${ownerRepo} into your account (if you don't have write access) and creates the file there.`,
+      `2. After all files are created, open registry.json and append the JSON entry from the "registry.json entry" tab.`,
+      `3. In each commit dialog, pick "Create a new branch for this commit and start a pull request" — never commit to main directly.`,
+      `4. After the last commit, GitHub takes you straight to the PR. Submit it; once merged, the craft appears in every Forge user's marketplace.`,
+    ],
+  });
+}

package/app/api/craft-system/registry/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from 'next/server';
+import { fetchRegistry } from '@/lib/crafts/registry';
+
+// GET /api/craft-system/registry?refresh=1
+// Project-agnostic — returns the raw registry. Used by the global Marketplace
+// browser where there's no single project context.
+export async function GET(req: Request) {
+  const u = new URL(req.url);
+  const refresh = u.searchParams.get('refresh') === '1';
+  try {
+    const items = await fetchRegistry(refresh);
+    return NextResponse.json({ items });
+  } catch (e: any) {
+    return NextResponse.json({ items: [], error: e?.message || String(e) });
+  }
+}

package/app/api/craft-system/runtime/react/route.ts

@@ -0,0 +1,26 @@
+// Re-export host's React instance to crafts (avoids two-React problem).
+// CraftTabs sets `window.__forge_react` before any craft module is imported.
+
+export async function GET() {
+  const code = `
+const R = (typeof window !== 'undefined' && window.__forge_react) || null;
+if (!R) throw new Error('Forge React shim not initialized');
+export default R;
+export const useState = R.useState;
+export const useEffect = R.useEffect;
+export const useCallback = R.useCallback;
+export const useMemo = R.useMemo;
+export const useRef = R.useRef;
+export const useContext = R.useContext;
+export const useReducer = R.useReducer;
+export const useLayoutEffect = R.useLayoutEffect;
+export const createContext = R.createContext;
+export const createElement = R.createElement;
+export const Fragment = R.Fragment;
+export const memo = R.memo;
+export const lazy = R.lazy;
+export const Suspense = R.Suspense;
+export const forwardRef = R.forwardRef;
+`;
+  return new Response(code, { headers: { 'Content-Type': 'text/javascript; charset=utf-8' } });
+}

package/app/api/craft-system/runtime/react-jsx/route.ts

@@ -0,0 +1,11 @@
+// jsx-runtime shim — re-exports from host's React.
+export async function GET() {
+  const code = `
+const J = (typeof window !== 'undefined' && window.__forge_jsx) || null;
+if (!J) throw new Error('Forge JSX runtime shim not initialized');
+export const jsx = J.jsx;
+export const jsxs = J.jsxs;
+export const Fragment = J.Fragment;
+`;
+  return new Response(code, { headers: { 'Content-Type': 'text/javascript; charset=utf-8' } });
+}

package/app/api/craft-system/runtime/sdk/route.ts

@@ -0,0 +1,18 @@
+// SDK shim — re-exports the SDK that the host page injected on window.__forge_sdk.
+export async function GET() {
+  const code = `
+const S = (typeof window !== 'undefined' && window.__forge_sdk) || null;
+if (!S) throw new Error('Forge SDK shim not initialized');
+export const useProject = S.useProject;
+export const useForgeFetch = S.useForgeFetch;
+export const useInject = S.useInject;
+export const useTask = S.useTask;
+export const useStore = S.useStore;
+export const useOpenAPI = S.useOpenAPI;
+export const useFile = S.useFile;
+export const useShell = S.useShell;
+export const useGit = S.useGit;
+export const useToast = S.useToast;
+`;
+  return new Response(code, { headers: { 'Content-Type': 'text/javascript; charset=utf-8' } });
+}

package/app/api/craft-system/scaffold/route.ts

@@ -0,0 +1,164 @@
+import { NextResponse } from 'next/server';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import * as YAML from 'yaml';
+import { listAgents } from '@/lib/agents';
+
+interface ScaffoldRequest {
+  projectPath: string;
+  projectName?: string;
+  name: string;                  // kebab-case craft id (also dir name)
+  displayName?: string;
+  description: string;           // user's natural-language description
+  agentId?: string;              // 'claude' | 'codex' | 'aider' | custom — defaults to first detected
+}
+
+const NAME_RE = /^[a-z][a-z0-9-]{1,40}$/;
+
+// Tmux name prefix for craft-builder sessions; lives alongside Forge's "mw-" prefix
+const SESSION_PREFIX = 'mw-craft-';
+
+function buildScaffoldPrompt(displayName: string, description: string, name: string): string {
+  return [
+    `# Build the Forge Craft \`${name}\``,
+    '',
+    `**Display name**: ${displayName}`,
+    '',
+    'You are working inside the craft directory directly (cwd is `<project>/.forge/crafts/' + name + '/`).',
+    'Use the `craft-builder` skill loaded in your environment for the full SDK reference and rules.',
+    '',
+    '## Files to write',
+    '',
+    '- `ui.tsx` — React component (default export). Import only from `@forge/craft`.',
+    '- `server.ts` — optional. Only if you need server-side work. Import from `@forge/craft/server`.',
+    '- Update `craft.yaml` if you need to change displayName / icon / showWhen.',
+    '- Update `README.md` with a 1-paragraph description.',
+    '- Append your work notes to `prompt.md` so future refines have context.',
+    '',
+    '## User\'s request',
+    '',
+    '```',
+    description,
+    '```',
+    '',
+    '## After you finish',
+    '',
+    'The craft will hot-reload in Forge as soon as the files exist. Tell the user to switch to the new tab in Forge to test it.',
+    'Refer to the "Minimum viable example" in the `craft-builder` skill for the file shape and SDK use.',
+    '',
+    'Begin by reading `prompt.md` (this file) and the craft-builder skill, then write `ui.tsx`. End with `[FORGE_DONE]`.',
+  ].join('\n');
+}
+
+function tmuxSessionName(projectPath: string, craftName: string): string {
+  const projHash = createHash('md5').update(projectPath).digest('hex').slice(0, 6);
+  return `${SESSION_PREFIX}${projHash}-${craftName}`;
+}
+
+export async function POST(req: Request) {
+  const body = await req.json() as ScaffoldRequest;
+  const { projectPath, projectName, name, displayName, description, agentId } = body;
+
+  if (!projectPath || !name || !description) {
+    return NextResponse.json({ error: 'projectPath, name, description required' }, { status: 400 });
+  }
+  if (!NAME_RE.test(name)) {
+    return NextResponse.json({ error: 'name must be kebab-case: starts with letter, lowercase + digits + hyphens, 2-41 chars' }, { status: 400 });
+  }
+
+  const craftDir = join(projectPath, '.forge', 'crafts', name);
+  if (existsSync(craftDir)) {
+    return NextResponse.json({ error: `craft "${name}" already exists at ${craftDir} — pick a different name or delete it first` }, { status: 409 });
+  }
+
+  // Resolve agent
+  const agents = listAgents();
+  const enabled = agents.filter(a => a.enabled);
+  if (enabled.length === 0) {
+    return NextResponse.json({ error: 'no agents detected; install Claude Code, Codex, or Aider first' }, { status: 400 });
+  }
+  const agent = (agentId && enabled.find(a => a.id === agentId)) || enabled[0];
+
+  // ── Scaffold files ────────────────────────────────────
+  mkdirSync(craftDir, { recursive: true });
+  mkdirSync(join(craftDir, 'data'), { recursive: true });
+
+  const manifest = {
+    name,
+    displayName: displayName || `🛠 ${name}`,
+    description: description.split('\n')[0].slice(0, 120),
+    version: '0.1.0',
+    ui: { tab: 'ui.tsx' },
+  };
+  writeFileSync(join(craftDir, 'craft.yaml'), YAML.stringify(manifest));
+
+  // Stub UI so the tab appears immediately while the agent is still working
+  writeFileSync(join(craftDir, 'ui.tsx'), `import { useProject } from '@forge/craft';
+
+export default function Tab() {
+  const { projectName } = useProject();
+  return (
+    <div className="flex-1 flex items-center justify-center p-8 text-xs text-[var(--text-secondary)]">
+      <div className="text-center">
+        <div className="text-2xl mb-2">🛠</div>
+        <div>Craft <b className="text-[var(--text-primary)]">${name}</b> is being generated by ${agent.name || agent.id}.</div>
+        <div className="mt-2 opacity-60">Once the agent writes ui.tsx, this tab will hot-reload.</div>
+      </div>
+    </div>
+  );
+}
+`);
+
+  const prompt = buildScaffoldPrompt(manifest.displayName, description, name);
+  writeFileSync(join(craftDir, 'prompt.md'), prompt);
+
+  writeFileSync(join(craftDir, 'README.md'), `# ${manifest.displayName}\n\n_Generation pending — agent ${agent.id} is working in tmux session ${tmuxSessionName(projectPath, name)}._\n`);
+
+  // ── Launch tmux session + agent ───────────────────────
+  const sessionName = tmuxSessionName(projectPath, name);
+  try {
+    // Kill any stale session with the same name (defensive)
+    try { execSync(`tmux kill-session -t "${sessionName}" 2>/dev/null`, { timeout: 2000 }); } catch {}
+
+    execSync(`tmux new-session -d -s "${sessionName}" -c "${craftDir}" -x 200 -y 50`, { timeout: 5000 });
+
+    // Build CLI command — start the agent
+    const cli = (agent as any).command || (agent as any).path || agent.id;
+    let launchCmd = '';
+    if (agent.id === 'claude') {
+      launchCmd = `${cli} --dangerously-skip-permissions`;
+    } else if (agent.id === 'codex') {
+      launchCmd = `${cli}`;
+    } else if (agent.id === 'aider') {
+      launchCmd = `${cli} --yes`;
+    } else {
+      launchCmd = cli;
+    }
+    execSync(`tmux send-keys -t "${sessionName}" '${launchCmd}' Enter`, { timeout: 3000 });
+
+    // Wait a moment for CLI to boot, then paste prompt + Enter
+    setTimeout(() => {
+      try {
+        const buf = join(tmpdir(), `forge-craft-prompt-${Date.now()}.txt`);
+        writeFileSync(buf, prompt);
+        execSync(`tmux load-buffer -t "${sessionName}" "${buf}" && tmux paste-buffer -t "${sessionName}" && sleep 0.3 && tmux send-keys -t "${sessionName}" Enter`, { timeout: 5000 });
+        try { require('node:fs').unlinkSync(buf); } catch {}
+      } catch (e) {
+        console.warn('[craft scaffold] failed to inject prompt', e);
+      }
+    }, 2500);
+  } catch (e: any) {
+    return NextResponse.json({ error: `failed to launch tmux session: ${e?.message || String(e)}` }, { status: 500 });
+  }
+
+  return NextResponse.json({
+    ok: true,
+    name,
+    craftDir,
+    sessionName,
+    agent: { id: agent.id, displayName: agent.name || agent.id },
+  });
+}

package/app/api/craft-system/sessions/route.ts

@@ -0,0 +1,45 @@
+import { NextResponse } from 'next/server';
+import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { projectPathToClaudeDir } from '@/lib/claude-sessions';
+
+// GET /api/craft-system/sessions?cwd=<absolute path>
+// Returns the Claude sessions stored under that cwd's project encoding.
+// Used by CraftTerminalPicker so the user picks among sessions valid in
+// the craft's cwd (not the project root's, which are scoped differently).
+export async function GET(req: Request) {
+  const u = new URL(req.url);
+  const cwd = u.searchParams.get('cwd');
+  if (!cwd) return NextResponse.json([], { status: 400 });
+
+  const dir = projectPathToClaudeDir(cwd);
+  if (!existsSync(dir)) return NextResponse.json([]);
+
+  try {
+    const files = readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+    const sessions = files.map(f => {
+      const sessionId = f.replace('.jsonl', '');
+      const fp = join(dir, f);
+      const stat = statSync(fp);
+      return { id: sessionId, modified: stat.mtime.toISOString(), size: stat.size };
+    }).sort((a, b) => b.modified.localeCompare(a.modified));
+
+    // Optional: enrich with sessions-index.json metadata if present
+    const idx = join(dir, 'sessions-index.json');
+    if (existsSync(idx)) {
+      try {
+        const data = JSON.parse(readFileSync(idx, 'utf-8'));
+        const map = new Map<string, any>();
+        for (const e of (data.entries || [])) if (e.sessionId) map.set(e.sessionId, e);
+        for (const s of sessions) {
+          const m = map.get(s.id);
+          if (m?.firstPrompt) (s as any).firstPrompt = m.firstPrompt;
+          if (m?.summary) (s as any).summary = m.summary;
+        }
+      } catch {}
+    }
+    return NextResponse.json(sessions);
+  } catch {
+    return NextResponse.json([]);
+  }
+}

package/app/api/craft-system/storage/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from 'next/server';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+function storageDir(projectPath: string, craft: string): string {
+  return join(projectPath, '.forge', 'crafts', craft, 'data');
+}
+
+function safeFile(name: string): string | null {
+  // Block path traversal; allow alphanumeric + dashes + underscores + .json suffix
+  if (!/^[\w.\-]+$/.test(name)) return null;
+  return name;
+}
+
+// GET /api/crafts/_storage?projectPath=...&craft=...&file=...
+export async function GET(req: Request) {
+  const u = new URL(req.url);
+  const projectPath = u.searchParams.get('projectPath');
+  const craft = u.searchParams.get('craft');
+  const file = u.searchParams.get('file');
+  if (!projectPath || !craft || !file) return NextResponse.json({ error: 'missing args' }, { status: 400 });
+  const safe = safeFile(file);
+  if (!safe) return NextResponse.json({ error: 'invalid file name' }, { status: 400 });
+  const f = join(storageDir(projectPath, craft), safe);
+  if (!existsSync(f)) return NextResponse.json({ value: null });
+  try { return NextResponse.json({ value: JSON.parse(readFileSync(f, 'utf8')) }); }
+  catch { return NextResponse.json({ value: null }); }
+}
+
+// POST /api/crafts/_storage?projectPath=...&craft=...&file=...  body: { value }
+export async function POST(req: Request) {
+  const u = new URL(req.url);
+  const projectPath = u.searchParams.get('projectPath');
+  const craft = u.searchParams.get('craft');
+  const file = u.searchParams.get('file');
+  if (!projectPath || !craft || !file) return NextResponse.json({ error: 'missing args' }, { status: 400 });
+  const safe = safeFile(file);
+  if (!safe) return NextResponse.json({ error: 'invalid file name' }, { status: 400 });
+  const dir = storageDir(projectPath, craft);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const { value } = await req.json();
+  writeFileSync(join(dir, safe), JSON.stringify(value, null, 2), 'utf8');
+  return NextResponse.json({ ok: true });
+}

package/app/api/craft-system/tmux-sessions/route.ts

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server';
+import { execSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+
+// GET /api/craft-system/tmux-sessions?projectPath=...
+// Lists active mw-* tmux sessions and partitions by whether their
+// pane_current_path falls under projectPath. Used by CraftTerminal to let
+// the user pick a session to attach to.
+
+interface SessionInfo { name: string; cwd: string; windows: number; attached: boolean; }
+
+function listMwSessions(): { name: string; windows: number; attached: boolean }[] {
+  try {
+    const out = execSync(
+      `tmux list-sessions -F '#{session_name}|#{session_windows}|#{session_attached}'`,
+      { timeout: 2000, encoding: 'utf8' }
+    );
+    return out.trim().split('\n').filter(Boolean).map(line => {
+      const [name, w, att] = line.split('|');
+      return { name, windows: Number(w) || 1, attached: att === '1' };
+    }).filter(s => /^mw[a-z0-9]*-/.test(s.name));
+  } catch {
+    return [];
+  }
+}
+
+function paneCwd(name: string): string | null {
+  try {
+    const out = execSync(`tmux display-message -p -t '${name}' '#{pane_current_path}'`, {
+      timeout: 2000, encoding: 'utf8',
+    });
+    return out.trim();
+  } catch {
+    return null;
+  }
+}
+
+function normalize(p: string): string {
+  try { return realpathSync(p); } catch { return p; }
+}
+
+export async function GET(req: Request) {
+  const u = new URL(req.url);
+  const projectPath = u.searchParams.get('projectPath');
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+
+  const target = normalize(projectPath).replace(/\/+$/, '');
+  const all = listMwSessions();
+  const matches: SessionInfo[] = [];
+  const others: SessionInfo[] = [];
+
+  for (const s of all) {
+    const cwd = paneCwd(s.name);
+    if (!cwd) continue;
+    const real = normalize(cwd);
+    const info: SessionInfo = { name: s.name, cwd: real, windows: s.windows, attached: s.attached };
+    if (real === target || real.startsWith(target + '/')) matches.push(info);
+    else others.push(info);
+  }
+  matches.sort((a, b) => Number(b.attached) - Number(a.attached) || a.name.localeCompare(b.name));
+  return NextResponse.json({ matches, others });
+}

package/app/api/craft-system/ui/route.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from 'next/server';
+import { getCraft } from '@/lib/crafts/loader';
+import { transpileUi } from '@/lib/crafts/runtime';
+
+// GET /api/crafts/_ui?projectPath=...&name=... → returns transpiled JS module
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  const name = url.searchParams.get('name');
+  if (!projectPath || !name) return new NextResponse('projectPath + name required', { status: 400 });
+
+  const craft = getCraft(projectPath, name);
+  if (!craft) return new NextResponse('craft not found', { status: 404 });
+  if (!craft.hasUi) return new NextResponse('craft has no UI', { status: 404 });
+
+  try {
+    const code = await transpileUi(craft);
+    return new NextResponse(code, {
+      headers: {
+        'Content-Type': 'text/javascript; charset=utf-8',
+        'Cache-Control': 'no-cache',
+      },
+    });
+  } catch (e: any) {
+    return new NextResponse(`/* craft transpile error */\nconsole.error(${JSON.stringify('Craft ' + name + ' transpile failed: ' + (e?.message || String(e)))});\nexport default function ErrorTab() { return null; }`, {
+      status: 200,
+      headers: { 'Content-Type': 'text/javascript; charset=utf-8' },
+    });
+  }
+}

package/app/api/crafts/[name]/[...route]/route.ts

@@ -0,0 +1,48 @@
+import { NextResponse } from 'next/server';
+import { getCraft } from '@/lib/crafts/loader';
+import { loadServer, findHandler, buildForgeApi } from '@/lib/crafts/runtime';
+
+// /api/crafts/<name>/<...route>  — dispatches to craft.server's matching handler.
+// projectPath comes from query param (so the same URL works across multiple projects).
+
+async function handle(req: Request, ctx: { params: Promise<{ name: string; route: string[] }> }, method: string) {
+  const { name, route } = await ctx.params;
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  if (!projectPath) return NextResponse.json({ error: 'projectPath query param required' }, { status: 400 });
+
+  const craft = getCraft(projectPath, name);
+  if (!craft) return NextResponse.json({ error: `craft "${name}" not found` }, { status: 404 });
+  if (!craft.hasServer) return NextResponse.json({ error: `craft "${name}" has no server` }, { status: 404 });
+
+  const def = await loadServer(craft);
+  if (!def) return NextResponse.json({ error: 'failed to load craft server' }, { status: 500 });
+
+  const path = '/' + (route || []).join('/');
+  const m = findHandler(def, method, path);
+  if (!m) return NextResponse.json({ error: `no handler for ${method} ${path}` }, { status: 404 });
+
+  let body: any;
+  if (method !== 'GET' && method !== 'HEAD') {
+    try { body = await req.json(); } catch { body = undefined; }
+  }
+  const query: Record<string, string> = {};
+  url.searchParams.forEach((v, k) => { if (k !== 'projectPath') query[k] = v; });
+  const headers: Record<string, string> = {};
+  req.headers.forEach((v, k) => { headers[k] = v; });
+
+  try {
+    const forge = buildForgeApi(craft, projectPath);
+    const result = await m.handler({ projectPath, query, params: m.params, body, headers, forge });
+    if (result instanceof Response) return result;
+    return NextResponse.json(result ?? {});
+  } catch (e: any) {
+    return NextResponse.json({ error: e?.message || String(e), stack: e?.stack }, { status: 500 });
+  }
+}
+
+export async function GET(req: Request, ctx: any) { return handle(req, ctx, 'GET'); }
+export async function POST(req: Request, ctx: any) { return handle(req, ctx, 'POST'); }
+export async function PUT(req: Request, ctx: any) { return handle(req, ctx, 'PUT'); }
+export async function DELETE(req: Request, ctx: any) { return handle(req, ctx, 'DELETE'); }
+export async function PATCH(req: Request, ctx: any) { return handle(req, ctx, 'PATCH'); }

package/app/api/crafts/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server';
+import { createHash } from 'node:crypto';
+import { listProjectCrafts, shouldShow } from '@/lib/crafts/loader';
+
+function tmuxSessionName(projectPath: string, craftName: string): string {
+  const projHash = createHash('md5').update(projectPath).digest('hex').slice(0, 6);
+  return `mw-craft-${projHash}-${craftName}`;
+}
+
+// GET /api/crafts?projectPath=...
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+  const all = listProjectCrafts(projectPath);
+  const visible = all.filter(c => shouldShow(c, projectPath));
+  return NextResponse.json({ crafts: visible.map(c => ({
+    name: c.name,
+    displayName: c.displayName || c.name,
+    icon: c.icon,
+    description: c.description,
+    version: c.version,
+    scope: c.__scope,
+    hasUi: c.hasUi,
+    hasServer: c.hasServer,
+    dir: c.__dir,
+    preferredSessionName: tmuxSessionName(projectPath, c.name),
+  })) });
+}