claude-ws 0.1.20 → 0.1.23

package/README.md

@@ -1,5 +1,7 @@
 # Claude Workspace
 
+> ⚠️ **DISCLAIMER:** This software is provided "AS IS" without warranty. The owners and contributors accept **no liability** for any damages or claims arising from its use. [Read full disclaimer](./DISCLAIMER.md).
+
 **Visual workspace for Claude Code with Kanban board, code editor, and Git integration.**
 
 Local-first SQLite database. Real-time streaming. Plugin system for custom agents and skills.
@@ -102,6 +104,143 @@ Open [http://localhost:8556](http://localhost:8556)
 
 ---
 
+## Configuration
+
+### API Authentication (Optional)
+
+For secure deployments, you can enable API authentication by setting an `API_ACCESS_KEY`:
+
+1. Create a `.env` file in your project directory (or use the global one in `~/.claude-ws/.env`)
+2. Add your API access key:
+
+```bash
+# .env
+API_ACCESS_KEY=your-secret-key-here
+```
+
+3. All API requests must include the key in the `x-api-key` header:
+
+```bash
+curl -H "x-api-key: your-secret-key-here" http://localhost:8556/api/conversations
+```
+
+**Note:** Leave `API_ACCESS_KEY` empty to disable authentication (default for local development).
+
+### Claude Code CLI Path
+
+Claude Workspace requires the Claude Code CLI to be installed. Set the `CLAUDE_PATH` environment variable to point to your Claude executable:
+
+**Linux/Ubuntu:**
+```bash
+CLAUDE_PATH=/home/$(whoami)/.local/bin/claude
+```
+
+**macOS (Homebrew):**
+```bash
+CLAUDE_PATH=/opt/homebrew/bin/claude
+```
+
+**Windows:**
+```bash
+CLAUDE_PATH=%USERPROFILE%\.local\bin\claude.exe
+```
+
+Add this to your `.env` file in the project directory, or the global `.env` at `~/.claude-ws/.env`.
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `CLAUDE_PATH` | Path to Claude Code CLI executable | Auto-detected |
+| `PORT` | Server port | `3000` |
+| `NODE_ENV` | Environment mode | `development` |
+| `API_ACCESS_KEY` | API authentication key | (empty, no auth) |
+| `DATABASE_URL` | SQLite database path | `./data.db` |
+| `AGENT_FACTORY_DIR` | Agent Factory plugins directory | `~/.claude/agentfactory` |
+
+---
+
+## Work Everywhere with Cloudflare Tunnel
+
+Access Claude Workspace securely from anywhere using Cloudflare Tunnel + Access.
+
+### 1. Install cloudflared
+
+```bash
+# macOS
+brew install cloudflared
+
+# Linux
+curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o cloudflared
+chmod +x cloudflared && sudo mv cloudflared /usr/local/bin/
+
+# Windows
+winget install Cloudflare.cloudflared
+```
+
+### 2. Authenticate with Cloudflare
+
+```bash
+cloudflared tunnel login
+```
+
+### 3. Create Tunnel
+
+```bash
+cloudflared tunnel create claude-workspace
+```
+
+### 4. Configure Tunnel
+
+Create `~/.cloudflared/config.yml`:
+
+```yaml
+tunnel: claude-workspace
+credentials-file: ~/.cloudflared/<TUNNEL_ID>.json
+
+ingress:
+  - hostname: claude-ws.yourdomain.com
+    service: http://localhost:8556
+  - service: http_status:404
+```
+
+### 5. Add DNS Record
+
+```bash
+cloudflared tunnel route dns claude-workspace claude-ws.yourdomain.com
+```
+
+### 6. Run Tunnel
+
+```bash
+# Foreground
+cloudflared tunnel run claude-workspace
+
+# Or as service (recommended)
+sudo cloudflared service install
+sudo systemctl enable cloudflared
+sudo systemctl start cloudflared
+```
+
+### 7. Setup Cloudflare Access (Authentication)
+
+1. Go to [Cloudflare Zero Trust Dashboard](https://one.dash.cloudflare.com/)
+2. Navigate to **Access** → **Applications** → **Add an application**
+3. Select **Self-hosted**
+4. Configure:
+   - **Application name**: Claude Workspace
+   - **Session duration**: 24 hours (or your preference)
+   - **Application domain**: `claude-ws.yourdomain.com`
+5. Add **Access Policy**:
+   - **Policy name**: Allowed Users
+   - **Action**: Allow
+   - **Include**: Emails ending in `@yourdomain.com` or specific email addresses
+6. Save and deploy
+
+Now access `https://claude-ws.yourdomain.com` from anywhere with Cloudflare authentication.
+
+---
+
 ## Updating
 
 ### Check current version
@@ -142,6 +281,41 @@ npm install -g claude-ws@latest
 | `pnpm start` | Start production server |
 | `pnpm lint` | Run ESLint |
 | `pnpm db:migrate` | Run database migrations |
+| `pnpm pm2:start` | Start with PM2 process manager |
+| `pnpm pm2:stop` | Stop PM2 process |
+| `pnpm pm2:restart` | Restart PM2 process |
+| `pnpm pm2:logs` | View PM2 logs |
+| `pnpm pm2:monit` | Monitor PM2 process |
+
+### Running with PM2
+
+For production deployments with auto-restart and process management:
+
+```bash
+# Install PM2 globally (if not already installed)
+npm install -g pm2
+
+# Start the server
+pnpm pm2:start
+
+# View logs
+pnpm pm2:logs
+
+# Monitor process
+pnpm pm2:monit
+
+# Restart
+pnpm pm2:restart
+
+# Stop
+pnpm pm2:stop
+```
+
+PM2 Features:
+- Auto-restart on crash (max 10 attempts)
+- Memory limit monitoring (500MB)
+- Log rotation and management
+- Process status tracking
 
 ---
 

package/drizzle.config.ts

@@ -1,11 +1,17 @@
 import type { Config } from 'drizzle-kit';
 import path from 'path';
 import os from 'os';
+import fs from 'fs';
 
 // Database location in user's home directory for persistence
 const DB_DIR = path.join(os.homedir(), '.claude-ws');
 const DB_PATH = path.join(DB_DIR, 'claude-ws.db');
 
+// Ensure directory exists before drizzle-kit tries to connect
+if (!fs.existsSync(DB_DIR)) {
+  fs.mkdirSync(DB_DIR, { recursive: true });
+}
+
 export default {
   schema: './src/lib/db/schema.ts',
   out: './drizzle',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-ws",
-  "version": "0.1.20",
+  "version": "0.1.23",
   "private": false,
   "description": "A beautifully crafted workspace interface for Claude Code with real-time streaming and local SQLite database",
   "keywords": [
@@ -62,6 +62,12 @@
     "lint": "eslint",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
+    "pm2:start": "pm2 start ecosystem.config.cjs",
+    "pm2:stop": "pm2 stop claude-ws",
+    "pm2:restart": "pm2 restart claude-ws",
+    "pm2:delete": "pm2 delete claude-ws",
+    "pm2:logs": "pm2 logs claude-ws",
+    "pm2:monit": "pm2 monit",
     "version:patch": "npm version patch --no-git-tag-version",
     "version:minor": "npm version minor --no-git-tag-version",
     "version:major": "npm version major --no-git-tag-version",
@@ -143,5 +149,6 @@
     "@types/react-dom": "^19",
     "eslint": "^9",
     "eslint-config-next": "^16.1.3"
-  }
+  },
+  "packageManager": "pnpm@10.28.0+sha512.05df71d1421f21399e053fde567cea34d446fa02c76571441bfc1c7956e98e363088982d940465fd34480d4d90a0668bc12362f8aa88000a64e83d0b0e47be48"
 }

package/server.ts

@@ -7,6 +7,7 @@ import { createServer } from 'http';
 import { parse } from 'url';
 import next from 'next';
 import { Server as SocketIOServer } from 'socket.io';
+import { homedir } from 'os';
 import { agentManager } from './src/lib/agent-manager';
 import { sessionManager } from './src/lib/session-manager';
 import { checkpointManager } from './src/lib/checkpoint-manager';
@@ -65,20 +66,170 @@ app.prepare().then(async () => {
     // Start new attempt
     socket.on(
       'attempt:start',
-      async (data: { taskId: string; prompt: string; displayPrompt?: string; fileIds?: string[] }) => {
-        const { taskId, prompt, displayPrompt, fileIds = [] } = data;
+      async (data: {
+        taskId: string;
+        prompt: string;
+        displayPrompt?: string;
+        fileIds?: string[];
+        force_create?: boolean;
+        projectId?: string;
+        projectName?: string;
+        taskTitle?: string;
+        projectRootPath?: string;
+      }) => {
+        const {
+          taskId,
+          prompt,
+          displayPrompt,
+          fileIds = [],
+          force_create,
+          projectId,
+          projectName,
+          taskTitle,
+          projectRootPath
+        } = data;
+
+        console.log('[Socket] attempt:start received:', {
+          taskId,
+          prompt,
+          force_create,
+          projectId,
+          projectName,
+          taskTitle,
+          projectRootPath
+        });
 
         try {
-          // Get task and project info
-          const task = await db.query.tasks.findFirst({
+          let task = await db.query.tasks.findFirst({
             where: eq(schema.tasks.id, taskId),
           });
 
+          // Handle force_create logic
+          if (force_create && !task) {
+            console.log('[Socket] Task not found, force_create=true');
+
+            if (!projectId) {
+              socket.emit('error', { message: 'projectId required' });
+              return;
+            }
+
+            // Check if project exists
+            let project = await db.query.projects.findFirst({
+              where: eq(schema.projects.id, projectId),
+            });
+
+            console.log('[Socket] Project exists?', !!project);
+
+            // Create project if it doesn't exist
+            if (!project) {
+              console.log('[Socket] Project does not exist, checking projectName...');
+              console.log('[Socket] projectName value:', projectName);
+
+              if (!projectName || projectName.trim() === '') {
+                console.log('[Socket] Project name required but not provided');
+                socket.emit('error', { message: 'projectName required' });
+                return;
+              }
+
+              // Create project directory and record
+              const { mkdir } = await import('fs/promises');
+              const { join } = await import('path');
+
+              const projectDirName = `${projectId}-${projectName}`;
+              const projectPath = projectRootPath
+                ? join(projectRootPath, projectDirName)
+                : join(homedir(), '.claude-ws', 'projects', projectDirName);
+
+              try {
+                await mkdir(projectPath, { recursive: true });
+                console.log('[Socket] Created project directory:', projectPath);
+              } catch (mkdirError: any) {
+                if (mkdirError?.code !== 'EEXIST') {
+                  console.error('[Socket] Failed to create project folder:', mkdirError);
+                  socket.emit('error', { message: 'Failed to create project folder: ' + mkdirError.message });
+                  return;
+                }
+              }
+
+              try {
+                await db.insert(schema.projects).values({
+                  id: projectId,
+                  name: projectName,
+                  path: projectPath,
+                  createdAt: Date.now(),
+                });
+                console.log('[Socket] Created project:', projectId);
+              } catch (error) {
+                console.error('[Socket] Failed to create project:', error);
+                socket.emit('error', { message: 'Failed to create project' });
+                return;
+              }
+
+              // Project created, fetch it
+              project = await db.query.projects.findFirst({
+                where: eq(schema.projects.id, projectId),
+              });
+            }
+
+            // Check taskTitle
+            if (!taskTitle || taskTitle.trim() === '') {
+              console.log('[Socket] Task title required but not provided');
+              socket.emit('error', { message: 'taskTitle required' });
+              return;
+            }
+
+            // Create task
+            const { and, desc } = await import('drizzle-orm');
+
+            // Get next position for todo status
+            const tasksInStatus = await db
+              .select()
+              .from(schema.tasks)
+              .where(
+                and(
+                  eq(schema.tasks.projectId, projectId),
+                  eq(schema.tasks.status, 'todo')
+                )
+              )
+              .orderBy(desc(schema.tasks.position))
+              .limit(1);
+
+            const position = tasksInStatus.length > 0 ? tasksInStatus[0].position + 1 : 0;
+
+            try {
+              await db.insert(schema.tasks).values({
+                id: taskId,
+                projectId,
+                title: taskTitle,
+                description: null,
+                status: 'todo',
+                position,
+                chatInit: false,
+                rewindSessionId: null,
+                rewindMessageUuid: null,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+              });
+              console.log('[Socket] Created task:', taskId);
+
+              // Fetch the created task
+              task = await db.query.tasks.findFirst({
+                where: eq(schema.tasks.id, taskId),
+              });
+            } catch (error) {
+              console.error('[Socket] Failed to create task:', error);
+              socket.emit('error', { message: 'Failed to create task' });
+              return;
+            }
+          }
+
+          // Validate task exists
           if (!task) {
             socket.emit('error', { message: 'Task not found' });
             return;
           }
 
+          // Get project info
           const project = await db.query.projects.findFirst({
             where: eq(schema.projects.id, task.projectId),
           });

package/src/app/api/attempts/route.ts

@@ -1,13 +1,35 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { db, schema } from '@/lib/db';
 import { nanoid } from 'nanoid';
+import { eq, and, desc } from 'drizzle-orm';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
 
 // POST /api/attempts - Create a new attempt (only creates record)
 // Actual execution happens via WebSocket
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json();
-    const { taskId, prompt } = body;
+    const {
+      taskId,
+      prompt,
+      force_create,
+      projectId,
+      projectName,
+      taskTitle,
+      projectRootPath
+    } = body;
+
+    console.log('POST /api/attempts received:', {
+      taskId,
+      prompt,
+      force_create,
+      projectId,
+      projectName,
+      taskTitle,
+      projectRootPath
+    });
 
     if (!taskId || !prompt) {
       return NextResponse.json(
@@ -16,26 +38,149 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    const newAttempt = {
-      id: nanoid(),
-      taskId,
-      prompt,
-      status: 'running' as const,
-      branch: null,
-      diffAdditions: 0,
-      diffDeletions: 0,
-      createdAt: Date.now(),
-      completedAt: null,
-    };
+    // Step 1: If force_create is not true, skip validation and create attempt directly
+    if (!force_create) {
+      // Validate task exists (current behavior)
+      const task = await db.query.tasks.findFirst({
+        where: eq(schema.tasks.id, taskId)
+      });
+
+      if (!task) {
+        return NextResponse.json(
+          { error: 'Task not found' },
+          { status: 404 }
+        );
+      }
+
+      // Create attempt with existing task
+      return await createAttempt(task, prompt);
+    }
+
+    // Step 2: Check if taskId exists
+    const existingTask = await db.query.tasks.findFirst({
+      where: eq(schema.tasks.id, taskId)
+    });
+
+    if (existingTask) {
+      // Task exists, create attempt directly
+      return await createAttempt(existingTask, prompt);
+    }
+
+    // Step 3: Task doesn't exist, need to validate and create
+    // First, get the projectId from the request body
+    if (!projectId) {
+      return NextResponse.json(
+        { error: 'projectId required' },
+        { status: 400 }
+      );
+    }
+
+    // Step 4: Check if projectId exists
+    let existingProject;
+    try {
+      existingProject = await db.query.projects.findFirst({
+        where: eq(schema.projects.id, projectId)
+      });
+    } catch (dbError) {
+      console.error('Database error checking project:', dbError);
+      return NextResponse.json(
+        { error: 'Database error checking project' },
+        { status: 500 }
+      );
+    }
+
+    console.log('Project exists?', !!existingProject);
+
+    let finalProjectId = projectId;
+
+    if (!existingProject) {
+      console.log('Project does not exist, checking projectName...');
+      console.log('projectName value:', projectName);
+      console.log('projectName type:', typeof projectName);
+      console.log('projectName === undefined:', projectName === undefined);
+      console.log('projectName === null:', projectName === null);
+      console.log('projectName === "":', projectName === "");
+
+      // Project doesn't exist, check if projectName provided
+      if (!projectName || projectName.trim() === '') {
+        console.log('Project name required but not provided');
+        return NextResponse.json(
+          { error: 'projectName required' },
+          { status: 400 }
+        );
+      }
 
-    await db.insert(schema.attempts).values(newAttempt);
+      // Determine project path based on projectRootPath
+      const projectDirName = `${projectId}-${projectName}`;
+      const projectPath = projectRootPath
+        ? join(projectRootPath, projectDirName)
+        : join(homedir(), '.claude-ws', 'projects', projectDirName);
+
+      // Create the project folder
+      try {
+        await mkdir(projectPath, { recursive: true });
+      } catch (mkdirError: any) {
+        // If folder already exists, that's okay
+        if (mkdirError?.code !== 'EEXIST') {
+          console.error('Failed to create project folder:', mkdirError);
+          return NextResponse.json(
+            { error: 'Failed to create project folder: ' + mkdirError.message },
+            { status: 500 }
+          );
+        }
+      }
+
+      // Create new project
+      const newProject = {
+        id: projectId,
+        name: projectName,
+        path: projectPath,
+        createdAt: Date.now(),
+      };
+
+      try {
+        await db.insert(schema.projects).values(newProject);
+      } catch (error) {
+        console.error('Failed to create project:', error);
+        return NextResponse.json(
+          { error: 'Failed to create project' },
+          { status: 500 }
+        );
+      }
+    }
+
+    // Step 5: At this point, project exists (either was existing or was just created)
+    // Check if taskTitle is provided
+    if (!taskTitle || taskTitle.trim() === '') {
+      console.log('Task title required but not provided');
+      return NextResponse.json(
+        { error: 'taskTitle required' },
+        { status: 400 }
+      );
+    }
+
+    // Create new task
+    const newTask = await createNewTask(taskId, finalProjectId, taskTitle);
+
+    if (!newTask) {
+      return NextResponse.json(
+        { error: 'Failed to create task' },
+        { status: 500 }
+      );
+    }
+
+    // Step 6: Create attempt with the newly created task
+    return await createAttempt(newTask, prompt);
 
-    return NextResponse.json(newAttempt, { status: 201 });
   } catch (error: any) {
     console.error('Failed to create attempt:', error);
+    console.error('Error code:', error?.code);
+    console.error('Error message:', error?.message);
+    console.error('Error stack:', error?.stack);
 
     // Handle foreign key constraint (invalid taskId)
     if (error?.code === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
+      console.error('Foreign key constraint violation');
       return NextResponse.json(
         { error: 'Task not found' },
         { status: 404 }
@@ -48,3 +193,61 @@ export async function POST(request: NextRequest) {
     );
   }
 }
+
+// Helper function to create attempt
+async function createAttempt(task: any, prompt: string) {
+  const newAttempt = {
+    id: nanoid(),
+    taskId: task.id,
+    prompt,
+    status: 'running' as const,
+    branch: null,
+    diffAdditions: 0,
+    diffDeletions: 0,
+    createdAt: Date.now(),
+    completedAt: null,
+  };
+
+  await db.insert(schema.attempts).values(newAttempt);
+  return NextResponse.json(newAttempt, { status: 201 });
+}
+
+// Helper function to create new task
+async function createNewTask(taskId: string, projectId: string, taskTitle: string) {
+  // Get next position for todo status
+  const tasksInStatus = await db
+    .select()
+    .from(schema.tasks)
+    .where(
+      and(
+        eq(schema.tasks.projectId, projectId),
+        eq(schema.tasks.status, 'todo')
+      )
+    )
+    .orderBy(desc(schema.tasks.position))
+    .limit(1);
+
+  const position = tasksInStatus.length > 0 ? tasksInStatus[0].position + 1 : 0;
+
+  const newTask = {
+    id: taskId,
+    projectId,
+    title: taskTitle,
+    description: null,
+    status: 'todo' as const,
+    position,
+    chatInit: false,
+    rewindSessionId: null,
+    rewindMessageUuid: null,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+
+  try {
+    await db.insert(schema.tasks).values(newTask);
+    return newTask;
+  } catch (error) {
+    console.error('Failed to create task:', error);
+    return null;
+  }
+}