claude-cwc 0.2.0

package/dist/src/server/api/exported-workflows.js

@@ -0,0 +1,53 @@
+import { Router as createRouter } from 'express';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import matter from 'gray-matter';
+const WORKFLOW_ID_REGEX = /<!-- cwc:workflow:([^:\s>]+) -->/;
+export function exportedWorkflowsRouter(homeDir) {
+    const router = createRouter();
+    const skillsDir = path.join(homeDir, '.claude', 'skills');
+    router.get('/', async (_req, res) => {
+        const results = [];
+        try {
+            const dirs = await fs.readdir(skillsDir);
+            for (const slug of dirs) {
+                const skillFile = path.join(skillsDir, slug, 'SKILL.md');
+                try {
+                    const raw = await fs.readFile(skillFile, 'utf-8');
+                    if (!WORKFLOW_ID_REGEX.test(raw))
+                        continue;
+                    const { data } = matter(raw);
+                    results.push({
+                        slug,
+                        name: String(data['name'] ?? slug),
+                        description: String(data['description'] ?? ''),
+                        skillDir: path.join(skillsDir, slug),
+                    });
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* skills dir missing */ }
+        res.json(results);
+    });
+    router.delete('/', async (req, res) => {
+        const slug = req.query['slug'];
+        if (!slug)
+            return void res.status(400).json({ error: 'slug required' });
+        const skillDir = path.join(skillsDir, slug);
+        try {
+            await fs.access(skillDir);
+        }
+        catch {
+            return void res.status(404).json({ error: 'not found' });
+        }
+        try {
+            await fs.rm(skillDir, { recursive: true, force: true });
+            res.json({ deleted: skillDir });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    return router;
+}

package/dist/src/server/api/file-content.js

@@ -0,0 +1,31 @@
+import { Router as createRouter } from 'express';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+export function fileContentRouter() {
+    const router = createRouter();
+    router.get('/', async (req, res) => {
+        const filePath = req.query['path'];
+        if (!filePath) {
+            res.status(400).json({ error: 'path query parameter required' });
+            return;
+        }
+        // Restrict to .claude directory to prevent arbitrary file reads.
+        // Use claudeDir + path.sep to avoid matching ~/.claudeevil/ etc.
+        const homeDir = os.homedir();
+        const claudeDir = path.join(homeDir, '.claude');
+        const resolved = path.resolve(filePath);
+        if (!resolved.startsWith(claudeDir + path.sep)) {
+            res.status(403).json({ error: 'Access restricted to .claude directory' });
+            return;
+        }
+        try {
+            const content = await fs.readFile(resolved, 'utf-8');
+            res.json({ content });
+        }
+        catch {
+            res.status(404).json({ error: 'File not found' });
+        }
+    });
+    return router;
+}

package/dist/src/server/api/health.js

@@ -0,0 +1,8 @@
+import { Router as createRouter } from 'express';
+export function healthRouter() {
+    const router = createRouter();
+    router.get('/', (_req, res) => {
+        res.json({ status: 'ok', version: '0.1.0' });
+    });
+    return router;
+}

package/dist/src/server/api/open-file.js

@@ -0,0 +1,32 @@
+import { Router as createRouter } from 'express';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { exec } from 'node:child_process';
+export function openFileRouter() {
+    const router = createRouter();
+    router.post('/', (req, res) => {
+        const { path: filePath } = req.body;
+        if (!filePath) {
+            res.status(400).json({ error: 'path body field required' });
+            return;
+        }
+        // Restrict to .claude directory.
+        // Use claudeDir + path.sep to avoid matching ~/.claudeevil/ etc.
+        const claudeDir = path.join(os.homedir(), '.claude');
+        const resolved = path.resolve(filePath);
+        if (!resolved.startsWith(claudeDir + path.sep)) {
+            res.status(403).json({ error: 'Access restricted to .claude directory' });
+            return;
+        }
+        // Use platform-appropriate open command
+        const cmd = process.platform === 'darwin' ? `open "${resolved}"` : `xdg-open "${resolved}"`;
+        exec(cmd, (err) => {
+            if (err) {
+                res.status(500).json({ error: 'Failed to open file' });
+                return;
+            }
+            res.json({ opened: true });
+        });
+    });
+    return router;
+}

package/dist/src/server/api/recents.js

@@ -0,0 +1,40 @@
+import { Router as createRouter } from 'express';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+const MAX_RECENTS = 10;
+export function recentsRouter(recentsPath) {
+    const router = createRouter();
+    async function readRecents() {
+        try {
+            const raw = await fs.readFile(recentsPath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return [];
+        }
+    }
+    router.get('/', async (_req, res) => {
+        res.json(await readRecents());
+    });
+    router.delete('/', async (req, res) => {
+        const filePath = req.query['path'];
+        if (!filePath)
+            return void res.status(400).json({ error: 'path required' });
+        const existing = await readRecents();
+        const updated = existing.filter((p) => p !== filePath);
+        await fs.mkdir(path.dirname(recentsPath), { recursive: true });
+        await fs.writeFile(recentsPath, JSON.stringify(updated, null, 2), 'utf-8');
+        res.json(updated);
+    });
+    router.post('/', async (req, res) => {
+        const { path: filePath } = req.body;
+        if (!filePath)
+            return void res.status(400).json({ error: 'path required' });
+        const existing = await readRecents();
+        const updated = [filePath, ...existing.filter((p) => p !== filePath)].slice(0, MAX_RECENTS);
+        await fs.mkdir(path.dirname(recentsPath), { recursive: true });
+        await fs.writeFile(recentsPath, JSON.stringify(updated, null, 2), 'utf-8');
+        res.json(updated);
+    });
+    return router;
+}

package/dist/src/server/api/skills.js

@@ -0,0 +1,55 @@
+import { Router as createRouter } from 'express';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import matter from 'gray-matter';
+export function skillsRouter(userHomeDir) {
+    const router = createRouter();
+    router.get('/', async (_req, res) => {
+        const userSkillsDir = path.join(userHomeDir, '.claude', 'skills');
+        const pluginCacheDir = path.join(userHomeDir, '.claude', 'plugins', 'cache');
+        const skills = [];
+        const CWC_WORKFLOW_MARKER = /<!-- cwc:workflow:[^:\s>]+ -->/;
+        // User skills — each subdir of userSkillsDir is a skill slug
+        try {
+            const dirs = await fs.readdir(userSkillsDir);
+            for (const slug of dirs) {
+                const skillFile = path.join(userSkillsDir, slug, 'SKILL.md');
+                try {
+                    const raw = await fs.readFile(skillFile, 'utf-8');
+                    if (CWC_WORKFLOW_MARKER.test(raw))
+                        continue; // skip workflow-exported skills
+                    const { data } = matter(raw);
+                    skills.push({ slug, name: String(data['name'] ?? slug), description: String(data['description'] ?? ''), source: 'user', namespacedSlug: slug, filePath: skillFile });
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* dir missing */ }
+        // Plugin skills — walk cache/<publisher>/<plugin>/<version>/skills/
+        try {
+            const publishers = await fs.readdir(pluginCacheDir);
+            for (const publisher of publishers) {
+                const pluginNames = await fs.readdir(path.join(pluginCacheDir, publisher)).catch(() => []);
+                for (const pluginName of pluginNames) {
+                    const versions = await fs.readdir(path.join(pluginCacheDir, publisher, pluginName)).catch(() => []);
+                    const latestVersion = versions.sort().at(-1);
+                    if (!latestVersion)
+                        continue;
+                    const skillsDir = path.join(pluginCacheDir, publisher, pluginName, latestVersion, 'skills');
+                    const slugs = await fs.readdir(skillsDir).catch(() => []);
+                    for (const slug of slugs) {
+                        const skillFile = path.join(skillsDir, slug, 'SKILL.md');
+                        try {
+                            const { data } = matter(await fs.readFile(skillFile, 'utf-8'));
+                            skills.push({ slug, name: String(data['name'] ?? slug), description: String(data['description'] ?? ''), source: 'plugin', namespacedSlug: `${pluginName}:${slug}`, filePath: skillFile });
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+            }
+        }
+        catch { /* no plugins */ }
+        res.json(skills);
+    });
+    return router;
+}

package/dist/src/server/api/workflows.js

@@ -0,0 +1,107 @@
+import { Router as createRouter } from 'express';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { slugify } from '../../slugify.js';
+export function workflowsRouter(workflowsDir, recentsPath) {
+    const router = createRouter();
+    router.get('/default-path', (req, res) => {
+        const name = req.query['name'] || 'untitled';
+        const slug = slugify(name) || 'untitled';
+        res.json({ path: path.join(os.homedir(), '.cwc', 'workflows', `${slug}.cwc`) });
+    });
+    router.get('/list', async (_req, res) => {
+        try {
+            await fs.mkdir(workflowsDir, { recursive: true });
+            const entries = await fs.readdir(workflowsDir);
+            const items = await Promise.all(entries
+                .filter((f) => f.endsWith('.cwc'))
+                .map(async (f) => {
+                const fullPath = path.join(workflowsDir, f);
+                try {
+                    const raw = await fs.readFile(fullPath, 'utf-8');
+                    const cwc = JSON.parse(raw);
+                    return { path: fullPath, name: cwc.meta.name, updated: cwc.meta.updated, nodeCount: cwc.nodes.length };
+                }
+                catch {
+                    return null;
+                }
+            }));
+            res.json(items.filter(Boolean));
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    router.get('/', async (req, res) => {
+        const filePath = req.query['path'];
+        if (!filePath)
+            return void res.status(400).json({ error: 'path required' });
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            res.json(JSON.parse(raw));
+        }
+        catch {
+            res.status(404).json({ error: 'not found' });
+        }
+    });
+    router.post('/', async (req, res) => {
+        const { path: filePath, content } = req.body;
+        if (!filePath || !content)
+            return void res.status(400).json({ error: 'path and content required' });
+        try {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, JSON.stringify(content, null, 2), 'utf-8');
+            res.json({ saved: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    router.delete('/', async (req, res) => {
+        const filePath = req.query['path'];
+        if (!filePath)
+            return void res.status(400).json({ error: 'path required' });
+        try {
+            await fs.unlink(filePath);
+            res.json({ deleted: true });
+        }
+        catch {
+            res.status(404).json({ error: 'not found' });
+        }
+    });
+    router.post('/rename', async (req, res) => {
+        const { oldPath, newName } = req.body;
+        if (!oldPath || !newName)
+            return void res.status(400).json({ error: 'oldPath and newName required' });
+        const newSlug = slugify(newName) || 'untitled';
+        const dir = path.dirname(oldPath);
+        const newPath = path.join(dir, `${newSlug}.cwc`);
+        if (newPath === oldPath)
+            return void res.json({ path: oldPath, renamed: false });
+        if (await fs.access(newPath).then(() => true).catch(() => false)) {
+            return void res.status(400).json({ error: 'A workflow with that name already exists' });
+        }
+        let raw;
+        try {
+            raw = await fs.readFile(oldPath, 'utf-8');
+        }
+        catch {
+            return void res.status(404).json({ error: 'not found' });
+        }
+        const cwc = JSON.parse(raw);
+        cwc.meta.name = newName;
+        cwc.meta.updated = new Date().toISOString();
+        await fs.writeFile(newPath, JSON.stringify(cwc, null, 2), 'utf-8');
+        await fs.unlink(oldPath);
+        try {
+            const recentsRaw = await fs.readFile(recentsPath, 'utf-8');
+            const recents = JSON.parse(recentsRaw);
+            const updated = recents.map((p) => (p === oldPath ? newPath : p));
+            await fs.writeFile(recentsPath, JSON.stringify(updated, null, 2), 'utf-8');
+        }
+        catch { /* recents file missing or corrupt — skip */ }
+        res.json({ path: newPath, renamed: true });
+    });
+    return router;
+}

package/dist/src/server/index.js

@@ -0,0 +1,59 @@
+import express from 'express';
+import cors from 'cors';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import { healthRouter } from './api/health.js';
+import { claudeCheckRouter } from './api/claude-check.js';
+import { workflowsRouter } from './api/workflows.js';
+import { agentsRouter } from './api/agents.js';
+import { recentsRouter } from './api/recents.js';
+import { exportRouter } from './api/export.js';
+import { exportPreviewRouter } from './api/export-preview.js';
+import { exportDeleteRouter } from './api/export-delete.js';
+import { skillsRouter } from './api/skills.js';
+import { fileContentRouter } from './api/file-content.js';
+import { openFileRouter } from './api/open-file.js';
+import { exportedWorkflowsRouter } from './api/exported-workflows.js';
+export function createApp(opts) {
+    const app = express();
+    app.use(cors());
+    app.use(express.json({ limit: '10mb' }));
+    app.use('/api/health', healthRouter());
+    app.use('/api/claude-check', claudeCheckRouter());
+    const wfDir = opts.workflowsDir ?? path.join(os.homedir(), '.cwc', 'workflows');
+    const recPath = opts.recentsPath ?? path.join(os.homedir(), '.cwc', 'recents.json');
+    app.use('/api/workflows', workflowsRouter(wfDir, recPath));
+    const homeDir = opts.userHomeDir ?? os.homedir();
+    app.use('/api/agents', agentsRouter(homeDir));
+    app.use('/api/recents', recentsRouter(recPath));
+    app.use('/api/export/preview', exportPreviewRouter());
+    app.use('/api/export/delete', exportDeleteRouter());
+    app.use('/api/export', exportRouter());
+    app.use('/api/skills', skillsRouter(homeDir));
+    app.use('/api/file-content', fileContentRouter());
+    app.use('/api/open-file', openFileRouter());
+    app.use('/api/exported-workflows', exportedWorkflowsRouter(homeDir));
+    if (opts.staticDir && fs.existsSync(opts.staticDir)) {
+        app.use(express.static(opts.staticDir));
+        app.get('/{*path}', (_req, res) => {
+            res.sendFile(path.join(opts.staticDir, 'index.html'));
+        });
+    }
+    return app;
+}
+export function startServer(port, staticDir) {
+    const app = createApp({ staticDir });
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, () => {
+            console.log(`CWC server running on http://localhost:${port}`);
+            resolve();
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.error(`Port ${port} is already in use. Run 'cwc stop' to kill the existing server.`);
+            }
+            reject(err);
+        });
+    });
+}

package/dist/src/server/start.js

@@ -0,0 +1,6 @@
+import { startServer } from './index.js';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const port = parseInt(process.argv[2] ?? '3579', 10);
+const staticDir = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'client');
+await startServer(port, staticDir);

package/dist/src/skill-resolver.js

@@ -0,0 +1,52 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import matter from 'gray-matter';
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readSkillDescription(skillMdPath) {
+    try {
+        const content = await fs.readFile(skillMdPath, 'utf-8');
+        const { data } = matter(content);
+        return typeof data.description === 'string' ? data.description : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveSkill(slug) {
+    const home = process.env.HOME ?? '';
+    if (slug.includes(':')) {
+        const [pluginKey, skillSlug] = slug.split(':');
+        // Look up installPath from installed_plugins.json
+        const pluginsJsonPath = path.join(home, '.claude', 'plugins', 'installed_plugins.json');
+        try {
+            const raw = await fs.readFile(pluginsJsonPath, 'utf-8');
+            const installed = JSON.parse(raw);
+            // Find plugin entry — key may be "pluginKey@publisher" or just "pluginKey"
+            const entry = Object.entries(installed).find(([k]) => k === pluginKey || k.startsWith(`${pluginKey}@`));
+            if (!entry)
+                return { slug, description: null, found: false };
+            const skillMdPath = path.join(entry[1].installPath, 'skills', skillSlug, 'SKILL.md');
+            if (!(await fileExists(skillMdPath)))
+                return { slug, description: null, found: false };
+            const description = await readSkillDescription(skillMdPath);
+            return { slug, description, found: true };
+        }
+        catch {
+            return { slug, description: null, found: false };
+        }
+    }
+    // Non-namespaced: ~/.claude/skills/<slug>/SKILL.md
+    const skillMdPath = path.join(home, '.claude', 'skills', slug, 'SKILL.md');
+    if (!(await fileExists(skillMdPath)))
+        return { slug, description: null, found: false };
+    const description = await readSkillDescription(skillMdPath);
+    return { slug, description, found: true };
+}

package/dist/src/slugify.js

@@ -0,0 +1,9 @@
+export function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[\s_]+/g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 64);
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "claude-cwc",
+  "version": "0.2.0",
+  "description": "Visual composer for Claude Code multi-agent workflows",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/"
+  ],
+  "bin": {
+    "cwc": "dist/bin/cwc.js"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "npm run build:server && npm run build:client",
+    "build:server": "tsc",
+    "build:client": "vite build --config client/vite.config.ts",
+    "dev:server": "tsc --watch",
+    "dev:client": "vite --config client/vite.config.ts",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p client/tsconfig.json",
+    "start": "node dist/bin/cwc.js",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^20.0.0",
+    "@types/open": "^6.1.0",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^4.7.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  },
+  "dependencies": {
+    "@xyflow/react": "^12.10.2",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "gray-matter": "^4.0.3",
+    "open": "^11.0.0",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "uuid": "^9.0.0",
+    "ws": "^8.21.0"
+  }
+}