prjct-cli 0.18.2 → 0.19.0

package/packages/web/server.ts

@@ -1,312 +0,0 @@
-/**
- * Custom Next.js server with WebSocket support for PTY
- *
- * PTY sessions are managed here (not in API routes) to share memory context
- */
-
-import { createServer } from 'http'
-import next from 'next'
-import { WebSocketServer, WebSocket } from 'ws'
-import * as pty from 'node-pty'
-import type { IPty } from 'node-pty'
-
-const dev = process.env.NODE_ENV !== 'production'
-const hostname = 'localhost'
-// Dev: 9471, Prod: 9472 (allows running both simultaneously for testing)
-const defaultPort = dev ? 9471 : 9472
-const port = parseInt(process.env.PORT || String(defaultPort), 10)
-
-// PTY Sessions stored in server memory
-interface Session {
-  pty: IPty
-  projectDir: string
-  createdAt: Date
-  hasStartedClaude: boolean  // Track if claude command was sent
-}
-
-const sessions = new Map<string, Session>()
-
-function createSession(sessionId: string, projectDir: string): { pty: IPty; isNew: boolean } {
-  const existing = sessions.get(sessionId)
-
-  // If session exists for this project, reuse it (allows multiple tabs)
-  if (existing) {
-    console.log(`[PTY] Reusing existing session: ${sessionId}`)
-    return { pty: existing.pty, isNew: false }
-  }
-
-  // Use user's default shell (zsh, bash, etc.) - respects $SHELL env var
-  const shell = process.platform === 'win32'
-    ? 'cmd.exe'
-    : process.env.SHELL || '/bin/zsh'
-
-  // -l for login shell (loads .zshrc, .bashrc, etc.)
-  // -i for interactive shell (enables job control, aliases)
-  const args = process.platform === 'win32' ? [] : ['-l', '-i']
-
-  const ptyProcess = pty.spawn(shell, args, {
-    name: 'xterm-256color',
-    cols: 120,
-    rows: 30,
-    cwd: projectDir,
-    env: {
-      ...process.env,
-      TERM: 'xterm-256color',
-      COLORTERM: 'truecolor',
-      // Ensure shell knows it's interactive
-      SHELL: shell
-    }
-  })
-
-  sessions.set(sessionId, {
-    pty: ptyProcess,
-    projectDir,
-    createdAt: new Date(),
-    hasStartedClaude: false
-  })
-
-  // NOTE: Don't auto-start claude here - let the WebSocket handler do it
-  // once the client is connected and ready to receive output
-
-  return { pty: ptyProcess, isNew: true }
-}
-
-function getSession(sessionId: string): IPty | null {
-  return sessions.get(sessionId)?.pty || null
-}
-
-function killSession(sessionId: string): void {
-  const session = sessions.get(sessionId)
-  if (session) {
-    try { session.pty.kill() } catch {}
-    sessions.delete(sessionId)
-  }
-}
-
-function resizeSession(sessionId: string, cols: number, rows: number): void {
-  const session = sessions.get(sessionId)
-  if (session) {
-    try { session.pty.resize(cols, rows) } catch {}
-  }
-}
-
-const app = next({ dev, hostname, port })
-const handle = app.getRequestHandler()
-
-app.prepare().then(() => {
-  const server = createServer(async (req, res) => {
-    const url = new URL(req.url || '', `http://${req.headers.host}`)
-
-    // Handle session creation directly in server (bypasses API route isolation)
-    if (url.pathname === '/api/claude/sessions' && req.method === 'POST') {
-      let body = ''
-      let bodySize = 0
-      const MAX_BODY_SIZE = 1024 * 1024 // 1MB limit
-
-      req.on('data', chunk => {
-        bodySize += chunk.length
-        if (bodySize > MAX_BODY_SIZE) {
-          res.statusCode = 413
-          res.setHeader('Content-Type', 'application/json')
-          res.end(JSON.stringify({ success: false, error: 'Request body too large' }))
-          req.destroy()
-          return
-        }
-        body += chunk
-      })
-      req.on('end', () => {
-        try {
-          const { sessionId, projectDir } = JSON.parse(body)
-          if (!sessionId || !projectDir) {
-            res.statusCode = 400
-            res.setHeader('Content-Type', 'application/json')
-            res.end(JSON.stringify({ success: false, error: 'sessionId and projectDir required' }))
-            return
-          }
-
-          const { isNew } = createSession(sessionId, projectDir)
-          console.log(`[PTY] ${isNew ? 'Created' : 'Reusing'} session: ${sessionId} for ${projectDir}`)
-
-          res.statusCode = 200
-          res.setHeader('Content-Type', 'application/json')
-          res.end(JSON.stringify({ success: true, data: { sessionId, projectDir, isNew } }))
-        } catch (err) {
-          console.error('[PTY] Error creating session:', err)
-          res.statusCode = 500
-          res.setHeader('Content-Type', 'application/json')
-          res.end(JSON.stringify({ success: false, error: 'Failed to create session' }))
-        }
-      })
-      return
-    }
-
-    // Handle session list
-    if (url.pathname === '/api/claude/sessions' && req.method === 'GET') {
-      const list = Array.from(sessions.entries()).map(([id, s]) => ({
-        sessionId: id,
-        projectDir: s.projectDir,
-        createdAt: s.createdAt
-      }))
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'application/json')
-      res.end(JSON.stringify({ success: true, data: list }))
-      return
-    }
-
-    // All other requests go to Next.js
-    try {
-      await handle(req, res)
-    } catch (err) {
-      console.error('Error handling request:', err)
-      res.statusCode = 500
-      res.end('Internal Server Error')
-    }
-  })
-
-  // WebSocket server for PTY communication
-  const wss = new WebSocketServer({ noServer: true })
-
-  // Heartbeat interval to detect dead connections (30 seconds)
-  const HEARTBEAT_INTERVAL = 30000
-
-  const heartbeatInterval = setInterval(() => {
-    wss.clients.forEach((ws) => {
-      const extWs = ws as WebSocket & { isAlive?: boolean; sessionId?: string }
-      if (extWs.isAlive === false) {
-        console.log(`[WS] Terminating dead connection: ${extWs.sessionId}`)
-        if (extWs.sessionId) {
-          killSession(extWs.sessionId)
-        }
-        return ws.terminate()
-      }
-      extWs.isAlive = false
-      ws.ping()
-    })
-  }, HEARTBEAT_INTERVAL)
-
-  // Cleanup on WSS close
-  wss.on('close', () => {
-    clearInterval(heartbeatInterval)
-  })
-
-  // Cleanup on server close
-  server.on('close', () => {
-    clearInterval(heartbeatInterval)
-    // Kill all active sessions
-    sessions.forEach((_, sessionId) => killSession(sessionId))
-  })
-
-  server.on('upgrade', (request, socket, head) => {
-    const url = new URL(request.url || '', `http://${request.headers.host}`)
-
-    if (url.pathname.startsWith('/ws/claude/')) {
-      wss.handleUpgrade(request, socket, head, (ws) => {
-        wss.emit('connection', ws, request)
-      })
-    }
-    // Other upgrades (HMR) pass through to Next.js
-  })
-
-  wss.on('connection', (ws: WebSocket, request) => {
-    const url = new URL(request.url || '', `http://${request.headers.host}`)
-    const sessionId = url.pathname.replace('/ws/claude/', '')
-
-    console.log(`[WS] New PTY connection for session: ${sessionId}`)
-
-    // Mark connection as alive and store sessionId for heartbeat
-    const extWs = ws as WebSocket & { isAlive?: boolean; sessionId?: string }
-    extWs.isAlive = true
-    extWs.sessionId = sessionId
-
-    // Handle pong response
-    ws.on('pong', () => {
-      extWs.isAlive = true
-    })
-
-    const session = sessions.get(sessionId)
-
-    if (!session) {
-      console.log(`[WS] Session not found: ${sessionId}`)
-      ws.send(JSON.stringify({ type: 'error', message: 'Session not found' }))
-      ws.close()
-      return
-    }
-
-    const ptyProcess = session.pty
-
-    // Output buffering for smooth terminal rendering
-    // Batches PTY output and flushes every 16ms (one animation frame)
-    const outputBuffer: string[] = []
-    let flushTimer: NodeJS.Timeout | null = null
-    const BATCH_MS = 16
-
-    const flushBuffer = () => {
-      if (outputBuffer.length > 0 && ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({ type: 'output', data: outputBuffer.join('') }))
-        outputBuffer.length = 0
-      }
-      flushTimer = null
-    }
-
-    // Register data handler FIRST before sending any commands
-    const dataHandler = ptyProcess.onData((data: string) => {
-      outputBuffer.push(data)
-      if (!flushTimer) {
-        flushTimer = setTimeout(flushBuffer, BATCH_MS)
-      }
-    })
-
-    ws.send(JSON.stringify({ type: 'connected', sessionId }))
-
-    // Auto-start Claude CLI only once, when first client connects
-    if (!session.hasStartedClaude) {
-      session.hasStartedClaude = true
-      console.log(`[WS] Starting Claude CLI for session: ${sessionId}`)
-      setTimeout(() => {
-        ptyProcess.write('claude\r')
-      }, 200)  // Small delay to ensure client is ready
-    }
-
-    const exitHandler = ptyProcess.onExit(({ exitCode }) => {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({ type: 'exit', code: exitCode }))
-      }
-      killSession(sessionId)
-    })
-
-    ws.on('message', (message: Buffer) => {
-      try {
-        const { type, data, cols, rows } = JSON.parse(message.toString())
-        switch (type) {
-          case 'input':
-            ptyProcess?.write(data)
-            break
-          case 'resize':
-            if (cols && rows) resizeSession(sessionId, cols, rows)
-            break
-        }
-      } catch (err) {
-        console.error('[WS] Error:', err)
-      }
-    })
-
-    ws.on('close', () => {
-      console.log(`[WS] PTY connection closed: ${sessionId}`)
-      // Clear buffer flush timer
-      if (flushTimer) {
-        clearTimeout(flushTimer)
-        flushTimer = null
-      }
-      dataHandler.dispose()
-      exitHandler.dispose()
-    })
-
-    ws.on('error', (error) => {
-      console.error(`[WS] Error for ${sessionId}:`, error)
-    })
-  })
-
-  server.listen(port, () => {
-    console.log(`> prjct ready on http://${hostname}:${port}`)
-  })
-})

package/packages/web/tsconfig.json

@@ -1,34 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2017",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "react-jsx",
-    "incremental": true,
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
-    "paths": {
-      "@/*": ["./*"]
-    }
-  },
-  "include": [
-    "next-env.d.ts",
-    "**/*.ts",
-    "**/*.tsx",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts",
-    "**/*.mts"
-  ],
-  "exclude": ["node_modules"]
-}

package/templates/commands/serve.md

@@ -1,121 +0,0 @@
----
-allowed-tools: [Bash]
-description: 'Start prjct web server'
----
-
-# /p:serve - Start Web Server
-
-## Overview
-Starts the prjct web interface with Claude Code CLI integration.
-
-**CRITICAL**: Uses your Claude subscription via PTY - NO API costs!
-
-## Usage
-
-```bash
-# Start with defaults (port 3333)
-prjct-serve
-
-# Custom port
-prjct-serve --port=8080
-```
-
-## What It Does
-
-1. **Starts API Server** (Hono)
-   - REST endpoints for projects, sessions, tasks
-   - WebSocket for Claude Code CLI interaction
-   - SSE for real-time updates
-
-2. **Starts Web App** (React + Vite)
-   - Dashboard with metrics
-   - Terminal with xterm.js
-   - Session history
-
-3. **PTY Manager**
-   - Spawns Claude Code CLI in pseudo-terminal
-   - Streams I/O via WebSocket
-   - Uses YOUR subscription - $0 API costs
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────┐
-│  Browser (localhost:3000)                               │
-│  ┌─────────────────────────────────────────────────┐   │
-│  │  React App                                       │   │
-│  │  ├── Dashboard (metrics, projects)              │   │
-│  │  ├── Terminal (xterm.js)                        │   │
-│  │  └── Sessions (history)                         │   │
-│  └─────────────────────────────────────────────────┘   │
-│                         │                               │
-│                    WebSocket                            │
-│                         │                               │
-│  ┌─────────────────────────────────────────────────┐   │
-│  │  Hono Server (localhost:3333)                   │   │
-│  │  ├── /api/projects                              │   │
-│  │  ├── /api/sessions                              │   │
-│  │  ├── /api/claude/sessions                       │   │
-│  │  └── /ws/claude/:sessionId                      │   │
-│  └─────────────────────────────────────────────────┘   │
-│                         │                               │
-│                   PTY (node-pty)                        │
-│                         │                               │
-│  ┌─────────────────────────────────────────────────┐   │
-│  │  Claude Code CLI                                │   │
-│  │  (your subscription, no API costs)              │   │
-│  └─────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────┘
-```
-
-## Endpoints
-
-### REST API
-
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/api/projects` | GET | List all projects |
-| `/api/projects/:id` | GET | Get project details |
-| `/api/projects/:id/status` | GET | Get project status |
-| `/api/sessions` | GET | List sessions |
-| `/api/sessions/current` | GET | Get current session |
-| `/api/sessions` | POST | Create session |
-| `/api/sessions/:id/pause` | POST | Pause session |
-| `/api/sessions/:id/resume` | POST | Resume session |
-| `/api/sessions/:id/complete` | POST | Complete session |
-| `/api/claude/status` | GET | Check Claude CLI availability |
-| `/api/claude/sessions` | GET | List PTY sessions |
-| `/api/claude/sessions` | POST | Create PTY session |
-
-### WebSocket
-
-| Endpoint | Description |
-|----------|-------------|
-| `/ws/claude/:sessionId` | Real-time Claude CLI interaction |
-
-**Messages:**
-- `{ type: 'input', data: string }` - Send input to CLI
-- `{ type: 'resize', cols: number, rows: number }` - Resize terminal
-- `{ type: 'output', data: string }` - Receive CLI output
-
-## Requirements
-
-- Node.js 18+
-- Claude Code CLI installed (`claude` command available)
-- Active Claude subscription (Max or similar)
-
-## Output
-
-```
-╔═══════════════════════════════════════════════════════════╗
-║                                                           ║
-║   ⚡ prjct - Developer Momentum                          ║
-║                                                           ║
-║   API:     http://localhost:3333                          ║
-║   Web:     http://localhost:3000                          ║
-║   Claude:  ws://localhost:3333/ws/claude                  ║
-║                                                           ║
-║   Using your Claude subscription - $0 API costs           ║
-║                                                           ║
-╚═══════════════════════════════════════════════════════════╝
-```