prjct-cli 1.22.0 → 1.24.0

package/core/server/routes.ts

@@ -1,176 +0,0 @@
-/**
- * REST API Routes for prjct-cli
- *
- * Provides endpoints for reading and managing project state.
- *
- * @version 1.0.0
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { Hono } from 'hono'
-import * as jsonc from 'jsonc-parser'
-import pathManager from '../infrastructure/path-manager'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-import log from '../utils/logger'
-
-// Storage paths relative to project data directory
-const STORAGE_PATHS = {
-  state: 'storage/state.json',
-  queue: 'storage/queue.json',
-  ideas: 'storage/ideas.json',
-  shipped: 'storage/shipped.json',
-  roadmap: 'planning/roadmap.json',
-}
-
-/**
- * Read JSON file with JSONC support
- */
-async function readJsonFile<T>(filePath: string): Promise<T | null> {
-  try {
-    const content = await fs.readFile(filePath, 'utf-8')
-    const errors: jsonc.ParseError[] = []
-    const result = jsonc.parse(content, errors)
-    return errors.length > 0 ? null : result
-  } catch (error) {
-    // ENOENT or parse error - expected for new projects
-    if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
-      log.error(`JSON read error: ${getErrorMessage(error)}`)
-    }
-    return null
-  }
-}
-
-/**
- * Write JSON file
- */
-async function writeJsonFile(filePath: string, data: unknown): Promise<boolean> {
-  try {
-    await fs.mkdir(path.dirname(filePath), { recursive: true })
-    await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf-8')
-    return true
-  } catch (error) {
-    log.error(`JSON write error: ${getErrorMessage(error)}`)
-    return false
-  }
-}
-
-/**
- * Get global project path
- */
-function getProjectDataPath(projectId: string): string {
-  return pathManager.getGlobalProjectPath(projectId)
-}
-
-/**
- * Create API routes for a project
- */
-export function createRoutes(projectId: string, _projectPath: string): Hono {
-  const api = new Hono()
-  const dataPath = getProjectDataPath(projectId)
-
-  // GET /state - Current task state
-  api.get('/state', async (c) => {
-    const data = await readJsonFile(path.join(dataPath, STORAGE_PATHS.state))
-    if (!data) {
-      return c.json({ currentTask: null, lastUpdated: '' })
-    }
-    return c.json(data)
-  })
-
-  // GET /queue - Task queue
-  api.get('/queue', async (c) => {
-    const data = await readJsonFile(path.join(dataPath, STORAGE_PATHS.queue))
-    if (!data) {
-      return c.json({ tasks: [], lastUpdated: '' })
-    }
-    return c.json(data)
-  })
-
-  // GET /ideas - Ideas backlog
-  api.get('/ideas', async (c) => {
-    const data = await readJsonFile(path.join(dataPath, STORAGE_PATHS.ideas))
-    if (!data) {
-      return c.json({ ideas: [], lastUpdated: '' })
-    }
-    return c.json(data)
-  })
-
-  // GET /roadmap - Feature roadmap
-  api.get('/roadmap', async (c) => {
-    const data = await readJsonFile(path.join(dataPath, STORAGE_PATHS.roadmap))
-    if (!data) {
-      return c.json({ features: [], backlog: [], lastUpdated: '' })
-    }
-    return c.json(data)
-  })
-
-  // GET /shipped - Shipped items
-  api.get('/shipped', async (c) => {
-    const data = await readJsonFile(path.join(dataPath, STORAGE_PATHS.shipped))
-    if (!data) {
-      return c.json({ items: [], lastUpdated: '' })
-    }
-    return c.json(data)
-  })
-
-  // GET /dashboard - Combined dashboard data
-  api.get('/dashboard', async (c) => {
-    const [state, queue, ideas, roadmap, shipped] = await Promise.all([
-      readJsonFile(path.join(dataPath, STORAGE_PATHS.state)),
-      readJsonFile(path.join(dataPath, STORAGE_PATHS.queue)),
-      readJsonFile(path.join(dataPath, STORAGE_PATHS.ideas)),
-      readJsonFile(path.join(dataPath, STORAGE_PATHS.roadmap)),
-      readJsonFile(path.join(dataPath, STORAGE_PATHS.shipped)),
-    ])
-
-    return c.json({
-      projectId,
-      state: state || { currentTask: null, lastUpdated: '' },
-      queue: queue || { tasks: [], lastUpdated: '' },
-      ideas: ideas || { ideas: [], lastUpdated: '' },
-      roadmap: roadmap || { features: [], backlog: [], lastUpdated: '' },
-      shipped: shipped || { items: [], lastUpdated: '' },
-      timestamp: new Date().toISOString(),
-    })
-  })
-
-  // POST /state - Update state (for future use)
-  api.post('/state', async (c) => {
-    try {
-      const body = await c.req.json()
-      const filePath = path.join(dataPath, STORAGE_PATHS.state)
-      const success = await writeJsonFile(filePath, body)
-      if (success) {
-        return c.json({ success: true })
-      }
-      return c.json({ success: false, error: 'Failed to write' }, 500)
-    } catch (e) {
-      return c.json({ success: false, error: String(e) }, 400)
-    }
-  })
-
-  // GET /context - Read context markdown files
-  api.get('/context/:name', async (c) => {
-    const name = c.req.param('name')
-    const allowedFiles = ['now', 'next', 'ideas', 'shipped']
-
-    if (!allowedFiles.includes(name)) {
-      return c.json({ error: 'Invalid context file' }, 400)
-    }
-
-    try {
-      const filePath = path.join(dataPath, 'context', `${name}.md`)
-      const content = await fs.readFile(filePath, 'utf-8')
-      return c.text(content, 200, { 'Content-Type': 'text/markdown' })
-    } catch (error) {
-      // ENOENT - context file doesn't exist yet (expected)
-      if (!isNotFoundError(error)) {
-        log.error(`Context read error: ${getErrorMessage(error)}`)
-      }
-      return c.text('', 200, { 'Content-Type': 'text/markdown' })
-    }
-  })
-
-  return api
-}

package/core/server/server.ts

@@ -1,149 +0,0 @@
-/**
- * HTTP Server for prjct-cli
- *
- * Hono-based server for web dashboard and API access.
- * Provides REST endpoints for project state and real-time updates via SSE.
- * Supports both Bun and Node.js runtimes.
- *
- * @version 1.1.0
- */
-
-import { Hono } from 'hono'
-import { cors } from 'hono/cors'
-import { logger } from 'hono/logger'
-import type { ServerConfig, ServerHandle, ServerInstance } from '../types'
-import { isBun } from '../utils/runtime'
-import { createRoutes } from './routes'
-import { createExtendedRoutes } from './routes-extended'
-import { createSSEManager } from './sse'
-
-/**
- * Create and configure the HTTP server
- */
-export function createServer(config: ServerConfig): ServerInstance {
-  const app = new Hono()
-  const sseManager = createSSEManager()
-
-  // Middleware
-  if (config.enableCors !== false) {
-    app.use(
-      '*',
-      cors({
-        origin: '*',
-        allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-        allowHeaders: ['Content-Type', 'Authorization'],
-      })
-    )
-  }
-
-  if (config.enableLogging !== false) {
-    app.use('*', logger())
-  }
-
-  // Health check
-  app.get('/health', (c) => c.json({ status: 'ok', timestamp: new Date().toISOString() }))
-
-  // API info
-  app.get('/', (c) =>
-    c.json({
-      name: 'prjct-cli',
-      version: '0.20.0',
-      projectId: config.projectId,
-      endpoints: {
-        health: '/health',
-        state: '/api/state',
-        queue: '/api/queue',
-        ideas: '/api/ideas',
-        roadmap: '/api/roadmap',
-        shipped: '/api/shipped',
-        events: '/api/events',
-        // Extended endpoints for status-bar
-        projects: '/api/projects',
-        projectFull: '/api/projects/:id/full',
-        statusBarCompact: '/api/status-bar/compact',
-        globalStats: '/api/stats/global',
-      },
-    })
-  )
-
-  // Mount API routes
-  const routes = createRoutes(config.projectId, config.projectPath)
-  app.route('/api', routes)
-
-  // Mount extended routes for status-bar
-  const extendedRoutes = createExtendedRoutes()
-  app.route('/api', extendedRoutes)
-
-  // SSE endpoint for real-time updates
-  app.get('/api/events', (c) => {
-    return sseManager.handleConnection(c)
-  })
-
-  let server: ServerHandle = null
-
-  return {
-    app,
-
-    async start() {
-      const port = config.port
-      const host = config.host || '0.0.0.0'
-
-      if (isBun()) {
-        // Use Bun's native server (faster)
-        server = Bun.serve({
-          port,
-          hostname: host,
-          fetch: app.fetch,
-        })
-      } else {
-        // Use @hono/node-server for Node.js
-        const { serve } = await import('@hono/node-server')
-        const nodeServer = serve({
-          fetch: app.fetch,
-          port,
-          hostname: host,
-        })
-        server = {
-          stop: () => nodeServer.close(),
-        }
-      }
-
-      console.log(`🚀 prjct server running at http://${host}:${port}`)
-      console.log(`   Project: ${config.projectId}`)
-      console.log(`   Runtime: ${isBun() ? 'Bun' : 'Node.js'}`)
-      console.log(`   Dashboard: http://localhost:${port}`)
-    },
-
-    stop() {
-      sseManager.shutdown()
-      if (server) {
-        server.stop()
-        server = null
-        console.log('Server stopped')
-      }
-    },
-
-    broadcast(event: string, data: unknown) {
-      sseManager.broadcast(event, data)
-    },
-  }
-}
-
-/**
- * Default port for prjct server
- */
-export const DEFAULT_PORT = 3478 // "prjct" on phone keypad
-
-/**
- * Quick start server with minimal config
- */
-export async function startServer(projectId: string, projectPath: string, port = DEFAULT_PORT) {
-  const server = createServer({
-    port,
-    projectId,
-    projectPath,
-  })
-
-  await server.start()
-  return server
-}

package/core/server/sse.ts

@@ -1,192 +0,0 @@
-/**
- * Server-Sent Events (SSE) Manager
- *
- * Handles real-time updates to connected clients.
- * Broadcasts state changes, task updates, and notifications.
- *
- * @version 2.0.0
- */
-
-import type { Context } from 'hono'
-import { streamSSE } from 'hono/streaming'
-import type { SSEClient, SSEInternalClient, SSEManager } from '../types'
-
-/** Maximum client connection lifetime in ms (1 hour) */
-const MAX_CLIENT_TTL_MS = 60 * 60 * 1000
-
-/** Reaper interval in ms (5 minutes) */
-const REAPER_INTERVAL_MS = 5 * 60 * 1000
-
-/** Heartbeat interval in ms (30 seconds) */
-const HEARTBEAT_INTERVAL_MS = 30_000
-
-/**
- * Create an SSE manager for handling real-time connections
- */
-export function createSSEManager(): SSEManager {
-  const clients = new Map<string, SSEInternalClient>()
-  let reaperInterval: ReturnType<typeof setInterval> | null = null
-
-  /**
-   * Single cleanup function — all disconnect paths go through here.
-   * Safe to call multiple times for the same clientId.
-   */
-  function removeClient(clientId: string): void {
-    const entry = clients.get(clientId)
-    if (!entry) return
-
-    clearInterval(entry.heartbeatInterval)
-    clearTimeout(entry.ttlTimeout)
-    entry.abortController.abort()
-    clients.delete(clientId)
-  }
-
-  /** Periodic reaper that removes zombie clients */
-  function startReaper(): void {
-    if (reaperInterval) return
-
-    reaperInterval = setInterval(() => {
-      const now = Date.now()
-      for (const [id, entry] of clients) {
-        const connectedMs = now - new Date(entry.client.connectedAt).getTime()
-        if (connectedMs > MAX_CLIENT_TTL_MS) {
-          removeClient(id)
-        }
-      }
-    }, REAPER_INTERVAL_MS)
-
-    // Don't block process exit
-    if (reaperInterval && typeof reaperInterval === 'object' && 'unref' in reaperInterval) {
-      reaperInterval.unref()
-    }
-  }
-
-  function stopReaper(): void {
-    if (reaperInterval) {
-      clearInterval(reaperInterval)
-      reaperInterval = null
-    }
-  }
-
-  startReaper()
-
-  return {
-    /**
-     * Handle a new SSE connection
-     */
-    handleConnection(c: Context) {
-      return streamSSE(c, async (stream) => {
-        const clientId = crypto.randomUUID()
-        const connectedAt = new Date().toISOString()
-        const abortController = new AbortController()
-
-        // Register client
-        const client: SSEClient = {
-          id: clientId,
-          connectedAt,
-          send: (event, data) => {
-            stream.writeSSE({
-              event,
-              data: JSON.stringify(data),
-            })
-          },
-          close: () => {
-            removeClient(clientId)
-          },
-        }
-
-        // Heartbeat — detects dead connections
-        const heartbeatInterval = setInterval(async () => {
-          try {
-            await stream.writeSSE({
-              event: 'heartbeat',
-              data: JSON.stringify({ timestamp: new Date().toISOString() }),
-            })
-          } catch {
-            removeClient(clientId)
-          }
-        }, HEARTBEAT_INTERVAL_MS)
-
-        // TTL — force-disconnect after max lifetime
-        const ttlTimeout = setTimeout(() => {
-          removeClient(clientId)
-        }, MAX_CLIENT_TTL_MS)
-
-        // Don't block process exit
-        if (typeof heartbeatInterval === 'object' && 'unref' in heartbeatInterval) {
-          heartbeatInterval.unref()
-        }
-        if (typeof ttlTimeout === 'object' && 'unref' in ttlTimeout) {
-          ttlTimeout.unref()
-        }
-
-        clients.set(clientId, {
-          client,
-          heartbeatInterval,
-          ttlTimeout,
-          abortController,
-        } as SSEInternalClient)
-
-        // Send initial connection event
-        await stream.writeSSE({
-          event: 'connected',
-          data: JSON.stringify({
-            clientId,
-            timestamp: connectedAt,
-            message: 'Connected to prjct-cli server',
-          }),
-        })
-
-        // Handle stream abort (graceful disconnect)
-        stream.onAbort(() => {
-          removeClient(clientId)
-        })
-
-        // Wait until abort signal fires instead of infinite promise
-        await new Promise<void>((resolve) => {
-          abortController.signal.addEventListener('abort', () => resolve(), { once: true })
-        })
-      })
-    },
-
-    /**
-     * Broadcast an event to all connected clients
-     */
-    broadcast(event: string, data: unknown) {
-      const message = {
-        event,
-        data,
-        timestamp: new Date().toISOString(),
-      }
-
-      for (const [id, entry] of clients) {
-        try {
-          entry.client.send(event, message)
-        } catch {
-          removeClient(id)
-        }
-      }
-    },
-
-    /**
-     * Get current connected client count
-     */
-    getClientCount() {
-      return clients.size
-    },
-
-    /**
-     * Shut down all clients and stop the reaper.
-     * Called on server stop.
-     */
-    shutdown() {
-      stopReaper()
-      for (const id of [...clients.keys()]) {
-        removeClient(id)
-      }
-    },
-  }
-}
-
-export type { SSEEventType } from '../types/server'
-export { SSE_EVENTS } from '../types/server'