claude-code-workflow 6.0.2 → 6.0.4

package/ccw/src/commands/view.js

@@ -1,14 +1,105 @@
 import { serveCommand } from './serve.js';
+import { launchBrowser } from '../utils/browser-launcher.js';
+import { validatePath } from '../utils/path-resolver.js';
+import chalk from 'chalk';
 
 /**
- * View command handler - starts dashboard server (unified with serve mode)
+ * Check if server is already running on the specified port
+ * @param {number} port - Port to check
+ * @returns {Promise<boolean>} True if server is running
+ */
+async function isServerRunning(port) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1000);
+
+    const response = await fetch(`http://localhost:${port}/api/health`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Switch workspace on running server
+ * @param {number} port - Server port
+ * @param {string} path - New workspace path
+ * @returns {Promise<Object>} Result with success status
+ */
+async function switchWorkspace(port, path) {
+  try {
+    const response = await fetch(
+      `http://localhost:${port}/api/switch-path?path=${encodeURIComponent(path)}`
+    );
+    return await response.json();
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * View command handler - opens dashboard for current workspace
+ * If server is already running, switches workspace and opens browser
+ * If not running, starts a new server
  * @param {Object} options - Command options
  */
 export async function viewCommand(options) {
-  // Forward to serve command with same options
-  await serveCommand({
-    path: options.path,
-    port: options.port || 3456,
-    browser: options.browser
-  });
+  const port = options.port || 3456;
+
+  // Resolve workspace path
+  let workspacePath = process.cwd();
+  if (options.path) {
+    const pathValidation = validatePath(options.path, { mustExist: true });
+    if (!pathValidation.valid) {
+      console.error(chalk.red(`\n  Error: ${pathValidation.error}\n`));
+      process.exit(1);
+    }
+    workspacePath = pathValidation.path;
+  }
+
+  // Check if server is already running
+  const serverRunning = await isServerRunning(port);
+
+  if (serverRunning) {
+    // Server is running - switch workspace and open browser
+    console.log(chalk.blue.bold('\n  CCW Dashboard\n'));
+    console.log(chalk.gray(`  Server already running on port ${port}`));
+    console.log(chalk.cyan(`  Switching workspace to: ${workspacePath}`));
+
+    const result = await switchWorkspace(port, workspacePath);
+
+    if (result.success) {
+      console.log(chalk.green(`  Workspace switched successfully`));
+
+      // Open browser with the new path
+      const url = `http://localhost:${port}/?path=${encodeURIComponent(result.path)}`;
+
+      if (options.browser !== false) {
+        console.log(chalk.cyan('  Opening in browser...'));
+        try {
+          await launchBrowser(url);
+          console.log(chalk.green.bold('\n  Dashboard opened!\n'));
+        } catch (err) {
+          console.log(chalk.yellow(`\n  Could not open browser: ${err.message}`));
+          console.log(chalk.gray(`  Open manually: ${url}\n`));
+        }
+      } else {
+        console.log(chalk.gray(`\n  URL: ${url}\n`));
+      }
+    } else {
+      console.error(chalk.red(`\n  Failed to switch workspace: ${result.error}\n`));
+      process.exit(1);
+    }
+  } else {
+    // Server not running - start new server
+    await serveCommand({
+      path: workspacePath,
+      port: port,
+      browser: options.browser
+    });
+  }
 }

package/ccw/src/core/server.js

@@ -126,6 +126,40 @@ export async function startServer(options = {}) {
         return;
       }
 
+      // API: Switch workspace path (for ccw view command)
+      if (pathname === '/api/switch-path') {
+        const newPath = url.searchParams.get('path');
+        if (!newPath) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Path is required' }));
+          return;
+        }
+
+        const resolved = resolvePath(newPath);
+        if (!existsSync(resolved)) {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Path does not exist' }));
+          return;
+        }
+
+        // Track the path and return success
+        trackRecentPath(resolved);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          success: true,
+          path: resolved,
+          recentPaths: getRecentPaths()
+        }));
+        return;
+      }
+
+      // API: Health check (for ccw view to detect running server)
+      if (pathname === '/api/health') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ status: 'ok', timestamp: Date.now() }));
+        return;
+      }
+
       // API: Remove a recent path
       if (pathname === '/api/remove-recent-path' && req.method === 'POST') {
         handlePostRequest(req, res, async (body) => {

package/ccw/src/templates/dashboard-js/main.js

@@ -20,7 +20,17 @@ document.addEventListener('DOMContentLoaded', async () => {
   // Server mode: load data from API
   try {
     if (window.SERVER_MODE) {
-      await switchToPath(window.INITIAL_PATH || projectPath);
+      // Check URL for path parameter (from ccw view command)
+      const urlParams = new URLSearchParams(window.location.search);
+      const urlPath = urlParams.get('path');
+      const initialPath = urlPath || window.INITIAL_PATH || projectPath;
+
+      await switchToPath(initialPath);
+
+      // Clean up URL after loading (remove query param)
+      if (urlPath && window.history.replaceState) {
+        window.history.replaceState({}, '', window.location.pathname);
+      }
     } else {
       renderDashboard();
     }

package/ccw/src/templates/dashboard.css

@@ -7929,3 +7929,186 @@ code.ctx-meta-chip-value {
   width: 16px;
   border-radius: 3px;
 }
+
+/* ===================================
+   Path Selection Modal
+   =================================== */
+
+.path-modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+  backdrop-filter: blur(2px);
+}
+
+.path-modal {
+  background: hsl(var(--card));
+  border: 1px solid hsl(var(--border));
+  border-radius: 0.75rem;
+  width: 90%;
+  max-width: 480px;
+  box-shadow: 0 20px 40px rgba(0, 0, 0, 0.2);
+  animation: modal-enter 0.2s ease-out;
+}
+
+@keyframes modal-enter {
+  from {
+    opacity: 0;
+    transform: scale(0.95) translateY(-10px);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1) translateY(0);
+  }
+}
+
+.path-modal-header {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 1.25rem 1.5rem;
+  border-bottom: 1px solid hsl(var(--border));
+}
+
+.path-modal-icon {
+  font-size: 1.5rem;
+  color: hsl(var(--primary));
+}
+
+.path-modal-header h3 {
+  margin: 0;
+  font-size: 1.1rem;
+  font-weight: 600;
+  color: hsl(var(--foreground));
+}
+
+.path-modal-body {
+  padding: 1.5rem;
+}
+
+.path-modal-body p {
+  margin: 0 0 1rem;
+  color: hsl(var(--muted-foreground));
+  font-size: 0.9rem;
+  line-height: 1.5;
+}
+
+.path-modal-command {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  background: hsl(var(--muted));
+  padding: 0.75rem 1rem;
+  border-radius: 0.5rem;
+  font-family: var(--font-mono);
+}
+
+.path-modal-command code {
+  flex: 1;
+  font-size: 0.85rem;
+  color: hsl(var(--foreground));
+  word-break: break-all;
+}
+
+.path-modal-command .copy-btn {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+  padding: 0.375rem 0.75rem;
+  background: hsl(var(--primary));
+  color: white;
+  border: none;
+  border-radius: 0.375rem;
+  font-size: 0.8rem;
+  cursor: pointer;
+  transition: all 0.15s;
+  white-space: nowrap;
+}
+
+.path-modal-command .copy-btn:hover {
+  background: hsl(var(--primary) / 0.9);
+}
+
+.path-modal-note {
+  font-size: 0.85rem !important;
+  color: hsl(var(--muted-foreground)) !important;
+}
+
+.path-modal-note code {
+  background: hsl(var(--muted));
+  padding: 0.125rem 0.375rem;
+  border-radius: 0.25rem;
+  font-size: 0.8rem;
+}
+
+.path-modal-input {
+  width: 100%;
+  padding: 0.75rem 1rem;
+  background: hsl(var(--background));
+  border: 1px solid hsl(var(--border));
+  border-radius: 0.5rem;
+  font-size: 0.9rem;
+  color: hsl(var(--foreground));
+  outline: none;
+  transition: border-color 0.15s;
+}
+
+.path-modal-input:focus {
+  border-color: hsl(var(--primary));
+}
+
+.path-modal-input::placeholder {
+  color: hsl(var(--muted-foreground));
+}
+
+.path-modal-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 0.75rem;
+  padding: 1rem 1.5rem;
+  border-top: 1px solid hsl(var(--border));
+  background: hsl(var(--muted) / 0.3);
+  border-radius: 0 0 0.75rem 0.75rem;
+}
+
+.path-modal-close {
+  padding: 0.5rem 1.25rem;
+  background: hsl(var(--muted));
+  color: hsl(var(--foreground));
+  border: none;
+  border-radius: 0.375rem;
+  font-size: 0.875rem;
+  cursor: pointer;
+  transition: all 0.15s;
+}
+
+.path-modal-close:hover {
+  background: hsl(var(--hover));
+}
+
+.path-modal-confirm {
+  padding: 0.5rem 1.25rem;
+  background: hsl(var(--primary));
+  color: white;
+  border: none;
+  border-radius: 0.375rem;
+  font-size: 0.875rem;
+  cursor: pointer;
+  transition: all 0.15s;
+}
+
+.path-modal-confirm:hover {
+  background: hsl(var(--primary) / 0.9);
+}
+
+.path-modal-confirm:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-workflow",
-  "version": "6.0.2",
+  "version": "6.0.4",
   "description": "JSON-driven multi-agent development framework with intelligent CLI orchestration (Gemini/Qwen/Codex), context-first architecture, and automated workflow execution",
   "type": "module",
   "main": "ccw/src/index.js",