@hienlh/ppm 0.1.0

package/src/providers/claude-process-registry.ts

@@ -0,0 +1,106 @@
+/**
+ * Registry for tracking active Claude CLI processes.
+ * Mirrors opcode's ProcessRegistry — enables cancel/kill support.
+ */
+
+export interface ProcessInfo {
+  runId: number;
+  sessionId: string;
+  pid: number;
+  startedAt: Date;
+  projectPath: string;
+  prompt: string;
+  model: string;
+}
+
+interface ProcessHandle {
+  info: ProcessInfo;
+  proc: ReturnType<typeof Bun.spawn> | null;
+}
+
+class ProcessRegistry {
+  private processes = new Map<string, ProcessHandle>(); // sessionId -> handle
+
+  /** Register a running Claude CLI process */
+  register(
+    sessionId: string,
+    proc: ReturnType<typeof Bun.spawn>,
+    meta: { projectPath?: string; prompt: string; model?: string },
+  ): void {
+    const pid = proc.pid;
+    this.processes.set(sessionId, {
+      info: {
+        runId: Date.now(),
+        sessionId,
+        pid,
+        startedAt: new Date(),
+        projectPath: meta.projectPath ?? process.cwd(),
+        prompt: meta.prompt,
+        model: meta.model ?? "default",
+      },
+      proc,
+    });
+  }
+
+  /** Unregister a process (called when it completes) */
+  unregister(sessionId: string): void {
+    this.processes.delete(sessionId);
+  }
+
+  /** Get process info for a session */
+  get(sessionId: string): ProcessInfo | null {
+    return this.processes.get(sessionId)?.info ?? null;
+  }
+
+  /** List all running sessions */
+  listRunning(): ProcessInfo[] {
+    return Array.from(this.processes.values()).map((h) => h.info);
+  }
+
+  /**
+   * Kill a running process. Mirrors opcode's graceful shutdown:
+   *   SIGTERM → wait 2s → SIGKILL
+   */
+  async kill(sessionId: string): Promise<boolean> {
+    const handle = this.processes.get(sessionId);
+    if (!handle?.proc) return false;
+
+    const { proc } = handle;
+    const pid = proc.pid;
+
+    try {
+      // Try graceful SIGTERM first
+      proc.kill("SIGTERM");
+
+      // Wait up to 2s for exit
+      const exited = await Promise.race([
+        proc.exited.then(() => true),
+        new Promise<false>((r) => setTimeout(() => r(false), 2000)),
+      ]);
+
+      if (!exited) {
+        // Force kill with SIGKILL
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+          // Fallback: system kill command
+          Bun.spawnSync(["kill", "-KILL", String(pid)]);
+        }
+      }
+
+      this.processes.delete(sessionId);
+      return true;
+    } catch {
+      this.processes.delete(sessionId);
+      return false;
+    }
+  }
+
+  /** Check if a session has a running process */
+  isRunning(sessionId: string): boolean {
+    return this.processes.has(sessionId);
+  }
+}
+
+/** Singleton process registry */
+export const processRegistry = new ProcessRegistry();

package/src/providers/mock-provider.ts

@@ -0,0 +1,171 @@
+import type {
+  AIProvider,
+  Session,
+  SessionConfig,
+  SessionInfo,
+  ChatEvent,
+  ChatMessage,
+} from "./provider.interface.ts";
+
+const MOCK_RESPONSES = [
+  "I can help you with that! Let me take a look at the code.",
+  "Here's what I found after analyzing the project structure.",
+  "I'll make those changes for you. Let me update the file.",
+  "That looks like a good approach. Here's my suggestion:",
+  "I've reviewed the code and here are my findings.",
+];
+
+/**
+ * Mock AI provider for development/testing.
+ * Simulates streaming chat responses without needing a real API key.
+ */
+export class MockProvider implements AIProvider {
+  id = "mock";
+  name = "Mock AI (Dev)";
+
+  private sessions = new Map<string, Session>();
+  private messageHistory = new Map<string, ChatMessage[]>();
+  /** Active abort controllers for cancel support */
+  private activeAborts = new Map<string, AbortController>();
+
+  async createSession(config: SessionConfig): Promise<Session> {
+    const id = crypto.randomUUID();
+    const session: Session = {
+      id,
+      providerId: this.id,
+      title: config.title ?? "New Chat",
+      projectName: config.projectName,
+      createdAt: new Date().toISOString(),
+    };
+    this.sessions.set(id, session);
+    this.messageHistory.set(id, []);
+    return session;
+  }
+
+  async resumeSession(sessionId: string): Promise<Session> {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    return session;
+  }
+
+  async listSessions(): Promise<SessionInfo[]> {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      providerId: s.providerId,
+      title: s.title,
+      projectName: s.projectName,
+      createdAt: s.createdAt,
+    }));
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    this.sessions.delete(sessionId);
+    this.messageHistory.delete(sessionId);
+  }
+
+  async *sendMessage(
+    sessionId: string,
+    message: string,
+  ): AsyncIterable<ChatEvent> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      yield { type: "error", message: "Session not found" };
+      return;
+    }
+
+    // Update title from first message
+    if (session.title === "New Chat") {
+      session.title = message.slice(0, 50) + (message.length > 50 ? "..." : "");
+    }
+
+    // Store user message
+    const history = this.messageHistory.get(sessionId) ?? [];
+    history.push({
+      id: crypto.randomUUID(),
+      role: "user",
+      content: message,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Track abort controller for this session
+    const abortController = new AbortController();
+    this.activeAborts.set(sessionId, abortController);
+
+    // Simulate thinking delay
+    await sleep(300);
+
+    // Pick a response
+    const responseText =
+      MOCK_RESPONSES[Math.floor(Math.random() * MOCK_RESPONSES.length)] ??
+      MOCK_RESPONSES[0]!;
+
+    // Simulate tool use for messages containing "file" or "code"
+    const lowerMsg = message.toLowerCase();
+    if (lowerMsg.includes("file") || lowerMsg.includes("code")) {
+      yield { type: "tool_use", tool: "Read", input: { path: "src/index.ts" } };
+      await sleep(200);
+      yield { type: "tool_result", output: '// Main entry point\nconsole.log("Hello");' };
+      await sleep(100);
+    }
+
+    // Simulate approval request for messages containing "delete" or "remove"
+    if (lowerMsg.includes("delete") || lowerMsg.includes("remove")) {
+      yield {
+        type: "approval_request",
+        requestId: crypto.randomUUID(),
+        tool: "Bash",
+        input: { command: "rm -rf /tmp/test" },
+      };
+      // In real usage, we'd wait for approval response.
+      // Mock just continues after a delay.
+      await sleep(500);
+    }
+
+    // Stream response text word by word
+    const words = responseText.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      if (abortController.signal.aborted) break;
+      const chunk = (i === 0 ? "" : " ") + words[i];
+      yield { type: "text", content: chunk };
+      await sleep(50);
+    }
+
+    // Add a mock code block for variety
+    if (lowerMsg.includes("code") || lowerMsg.includes("example")) {
+      yield {
+        type: "text",
+        content: "\n\n```typescript\nfunction hello() {\n  console.log('Hello from PPM!');\n}\n```\n",
+      };
+      await sleep(50);
+    }
+
+    // Store assistant message
+    history.push({
+      id: crypto.randomUUID(),
+      role: "assistant",
+      content: responseText,
+      timestamp: new Date().toISOString(),
+    });
+    this.messageHistory.set(sessionId, history);
+
+    this.activeAborts.delete(sessionId);
+    yield { type: "done", sessionId };
+  }
+
+  /** Abort an active query for a session (for cancel support) */
+  abortQuery(sessionId: string): void {
+    const controller = this.activeAborts.get(sessionId);
+    if (controller) {
+      controller.abort();
+      this.activeAborts.delete(sessionId);
+    }
+  }
+
+  getMessages(sessionId: string): ChatMessage[] {
+    return this.messageHistory.get(sessionId) ?? [];
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/providers/provider.interface.ts

@@ -0,0 +1,10 @@
+export type {
+  AIProvider,
+  Session,
+  SessionConfig,
+  SessionInfo,
+  ChatEvent,
+  ChatMessage,
+  ToolApprovalHandler,
+  UsageInfo,
+} from "../types/chat.ts";

package/src/providers/registry.ts

@@ -0,0 +1,45 @@
+import type { AIProvider } from "./provider.interface.ts";
+import { MockProvider } from "./mock-provider.ts";
+import { ClaudeCodeCliProvider } from "./claude-code-cli.ts";
+import { ClaudeAgentSdkProvider } from "./claude-agent-sdk.ts";
+
+export interface ProviderInfo {
+  id: string;
+  name: string;
+}
+
+class ProviderRegistry {
+  private providers = new Map<string, AIProvider>();
+  private defaultId: string | null = null;
+
+  register(provider: AIProvider): void {
+    this.providers.set(provider.id, provider);
+    if (!this.defaultId) {
+      this.defaultId = provider.id;
+    }
+  }
+
+  get(id: string): AIProvider | undefined {
+    return this.providers.get(id);
+  }
+
+  list(): ProviderInfo[] {
+    return Array.from(this.providers.values()).map((p) => ({
+      id: p.id,
+      name: p.name,
+    }));
+  }
+
+  getDefault(): AIProvider {
+    if (!this.defaultId) throw new Error("No providers registered");
+    const provider = this.providers.get(this.defaultId);
+    if (!provider) throw new Error("Default provider not found");
+    return provider;
+  }
+}
+
+/** Singleton registry — first registered = default */
+export const providerRegistry = new ProviderRegistry();
+providerRegistry.register(new ClaudeAgentSdkProvider()); // default — real streaming, multi-turn
+providerRegistry.register(new ClaudeCodeCliProvider());   // fallback — spawns claude CLI
+providerRegistry.register(new MockProvider());            // testing only

package/src/server/helpers/resolve-project.ts

@@ -0,0 +1,22 @@
+import { resolve } from "node:path";
+import { configService } from "../../services/config.service.ts";
+
+/**
+ * Resolve a project name or path to an absolute filesystem path.
+ * Name lookup first, then path fallback with security validation.
+ */
+export function resolveProjectPath(nameOrPath: string): string {
+  const projects = configService.get("projects");
+
+  // Try name lookup first
+  const byName = projects.find((p) => p.name === nameOrPath);
+  if (byName) return resolve(byName.path);
+
+  // Path fallback — must be within a registered project
+  const abs = resolve(nameOrPath);
+  const allowed = projects.some(
+    (p) => abs === resolve(p.path) || abs.startsWith(resolve(p.path) + "/"),
+  );
+  if (!allowed) throw new Error(`Project not found: ${nameOrPath}`);
+  return abs;
+}

package/src/server/index.ts

@@ -0,0 +1,181 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { configService } from "../services/config.service.ts";
+import { authMiddleware } from "./middleware/auth.ts";
+import { projectRoutes } from "./routes/projects.ts";
+import { staticRoutes } from "./routes/static.ts";
+import { projectScopedRouter } from "./routes/project-scoped.ts";
+import { terminalWebSocket } from "./ws/terminal.ts";
+import { chatWebSocket } from "./ws/chat.ts";
+import { ok } from "../types/api.ts";
+
+export const app = new Hono();
+
+// CORS for dev
+app.use("*", cors());
+
+// Health check (before auth)
+app.get("/api/health", (c) => c.json(ok({ status: "running" })));
+
+// Auth check endpoint (behind auth middleware)
+app.use("/api/*", authMiddleware);
+app.get("/api/auth/check", (c) => c.json(ok(true)));
+
+// API routes
+app.route("/api/projects", projectRoutes);
+app.route("/api/project/:projectName", projectScopedRouter);
+
+// Static files / SPA fallback (non-API routes)
+app.route("/", staticRoutes);
+
+export async function startServer(options: {
+  port?: string;
+  daemon?: boolean;
+  config?: string;
+}) {
+  // Load config
+  configService.load(options.config);
+  const port = parseInt(options.port ?? String(configService.get("port")), 10);
+  const host = configService.get("host");
+
+  if (options.daemon) {
+    // Daemon mode: spawn detached child process, write PID file
+    const { resolve } = await import("node:path");
+    const { homedir } = await import("node:os");
+    const { writeFileSync, mkdirSync, existsSync } = await import("node:fs");
+
+    const ppmDir = resolve(homedir(), ".ppm");
+    if (!existsSync(ppmDir)) mkdirSync(ppmDir, { recursive: true });
+    const pidFile = resolve(ppmDir, "ppm.pid");
+
+    const child = Bun.spawn({
+      cmd: ["bun", "run", import.meta.dir + "/index.ts", "__serve__", String(port), host, options.config ?? ""],
+      stdio: ["ignore", "ignore", "ignore"],
+      env: process.env,
+    });
+
+    // Unref so parent can exit
+    child.unref();
+    writeFileSync(pidFile, String(child.pid));
+    console.log(`PPM daemon started (PID: ${child.pid}) on http://${host}:${port}`);
+    console.log(`PID file: ${pidFile}`);
+    process.exit(0);
+  }
+
+  // Foreground mode — with WebSocket support
+  const server = Bun.serve({
+    port,
+    hostname: host,
+    fetch(req, server) {
+      const url = new URL(req.url);
+
+      // WebSocket upgrade: /ws/project/:projectName/terminal/:id
+      if (url.pathname.startsWith("/ws/project/")) {
+        const parts = url.pathname.split("/");
+        // parts: ["", "ws", "project", projectName, type, id]
+        const projectName = parts[3] ?? "";
+        const wsType = parts[4] ?? "";
+        const id = parts[5] ?? "";
+
+        if (wsType === "terminal") {
+          const upgraded = server.upgrade(req, {
+            data: { type: "terminal", id, projectName },
+          });
+          if (upgraded) return undefined;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+
+        if (wsType === "chat") {
+          const sessionId = id;
+          const upgraded = server.upgrade(req, {
+            data: { type: "chat", sessionId, projectName },
+          });
+          if (upgraded) return undefined;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+      }
+
+      // Fall through to Hono for all other requests
+      return app.fetch(req, server);
+    },
+    websocket: {
+      open(ws: any) {
+        if (ws.data?.type === "chat") chatWebSocket.open(ws);
+        else terminalWebSocket.open(ws);
+      },
+      message(ws: any, msg: any) {
+        if (ws.data?.type === "chat") chatWebSocket.message(ws, msg);
+        else terminalWebSocket.message(ws, msg);
+      },
+      close(ws: any) {
+        if (ws.data?.type === "chat") chatWebSocket.close(ws);
+        else terminalWebSocket.close(ws);
+      },
+    } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
+  });
+
+  console.log(`PPM server running on http://${host}:${server.port}`);
+  console.log(`Auth: ${configService.get("auth").enabled ? "enabled" : "disabled"}`);
+  if (configService.get("auth").enabled) {
+    console.log(`Token: ${configService.get("auth").token}`);
+  }
+}
+
+// Internal entry point for daemon child process
+if (process.argv.includes("__serve__")) {
+  const idx = process.argv.indexOf("__serve__");
+  const port = parseInt(process.argv[idx + 1] ?? "8080", 10);
+  const host = process.argv[idx + 2] ?? "0.0.0.0";
+  const configPath = process.argv[idx + 3] || undefined;
+
+  configService.load(configPath);
+
+  Bun.serve({
+    port,
+    hostname: host,
+    fetch(req, server) {
+      const url = new URL(req.url);
+
+      // WebSocket upgrade: /ws/project/:projectName/terminal/:id
+      if (url.pathname.startsWith("/ws/project/")) {
+        const parts = url.pathname.split("/");
+        const projectName = parts[3] ?? "";
+        const wsType = parts[4] ?? "";
+        const id = parts[5] ?? "";
+
+        if (wsType === "terminal") {
+          const upgraded = server.upgrade(req, {
+            data: { type: "terminal", id, projectName },
+          });
+          if (upgraded) return undefined;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+
+        if (wsType === "chat") {
+          const sessionId = id;
+          const upgraded = server.upgrade(req, {
+            data: { type: "chat", sessionId, projectName },
+          });
+          if (upgraded) return undefined;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+      }
+
+      return app.fetch(req, server);
+    },
+    websocket: {
+      open(ws: any) {
+        if (ws.data?.type === "chat") chatWebSocket.open(ws);
+        else terminalWebSocket.open(ws);
+      },
+      message(ws: any, msg: any) {
+        if (ws.data?.type === "chat") chatWebSocket.message(ws, msg);
+        else terminalWebSocket.message(ws, msg);
+      },
+      close(ws: any) {
+        if (ws.data?.type === "chat") chatWebSocket.close(ws);
+        else terminalWebSocket.close(ws);
+      },
+    } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
+  });
+}

package/src/server/middleware/auth.ts

@@ -0,0 +1,30 @@
+import type { Context, Next } from "hono";
+import { configService } from "../../services/config.service.ts";
+import { err } from "../../types/api.ts";
+
+/** Auth middleware — checks Bearer token against config */
+export async function authMiddleware(c: Context, next: Next) {
+  const authConfig = configService.get("auth");
+
+  // Skip auth if disabled
+  if (!authConfig.enabled) {
+    return next();
+  }
+
+  // Allow health check without auth
+  if (c.req.path === "/api/health") {
+    return next();
+  }
+
+  const header = c.req.header("Authorization");
+  if (!header || !header.startsWith("Bearer ")) {
+    return c.json(err("Unauthorized"), 401);
+  }
+
+  const token = header.slice(7);
+  if (token !== authConfig.token) {
+    return c.json(err("Unauthorized"), 401);
+  }
+
+  return next();
+}