@hienlh/ppm 0.1.0

package/src/server/ws/chat.ts

@@ -0,0 +1,130 @@
+import { chatService } from "../../services/chat.service.ts";
+import { providerRegistry } from "../../providers/registry.ts";
+import { resolveProjectPath } from "../helpers/resolve-project.ts";
+import type { ChatWsClientMessage } from "../../types/api.ts";
+
+/** Tracks active chat WS connections: sessionId -> ws + abort controller + project context */
+const activeSessions = new Map<
+  string,
+  { providerId: string; ws: ChatWsSocket; abort?: AbortController; projectPath?: string }
+>();
+
+type ChatWsSocket = {
+  data: { type: string; sessionId: string; projectName?: string };
+  send: (data: string) => void;
+};
+
+/**
+ * Chat WebSocket handler for Bun.serve().
+ * Protocol: JSON messages as defined in ChatWsClientMessage / ChatWsServerMessage.
+ */
+export const chatWebSocket = {
+  open(ws: ChatWsSocket) {
+    const { sessionId, projectName } = ws.data;
+    // Look up session's actual provider, default to "claude-sdk"
+    const session = chatService.getSession(sessionId);
+    const providerId = session?.providerId ?? "claude-sdk";
+
+    // Resolve projectPath for skills/settings support
+    let projectPath: string | undefined;
+    if (projectName) {
+      try { projectPath = resolveProjectPath(projectName); } catch { /* ignore */ }
+    }
+
+    // Backfill projectPath on existing session
+    if (session && !session.projectPath && projectPath) {
+      session.projectPath = projectPath;
+    }
+
+    activeSessions.set(sessionId, { providerId, ws, projectPath });
+    ws.send(JSON.stringify({ type: "connected", sessionId }));
+  },
+
+  async message(ws: ChatWsSocket, msg: string | ArrayBuffer | Uint8Array) {
+    const { sessionId } = ws.data;
+    const text =
+      typeof msg === "string" ? msg : new TextDecoder().decode(msg as ArrayBuffer);
+
+    let parsed: ChatWsClientMessage;
+    try {
+      parsed = JSON.parse(text) as ChatWsClientMessage;
+    } catch {
+      ws.send(JSON.stringify({ type: "error", message: "Invalid JSON" }));
+      return;
+    }
+
+    const entry = activeSessions.get(sessionId);
+    const providerId = entry?.providerId ?? "mock";
+
+    if (parsed.type === "message") {
+      // Ensure provider session has projectPath for skills/settings support
+      if (entry?.projectPath) {
+        const provider = providerRegistry.get(providerId);
+        if (provider && "ensureProjectPath" in provider) {
+          (provider as any).ensureProjectPath(sessionId, entry.projectPath);
+        }
+      }
+
+      const abortController = new AbortController();
+      const entryRef = activeSessions.get(sessionId);
+      if (entryRef) entryRef.abort = abortController;
+
+      try {
+        for await (const event of chatService.sendMessage(
+          providerId,
+          sessionId,
+          parsed.content,
+        )) {
+          if (abortController.signal.aborted) break;
+          ws.send(JSON.stringify(event));
+        }
+      } catch (e) {
+        if (!abortController.signal.aborted) {
+          ws.send(
+            JSON.stringify({
+              type: "error",
+              message: (e as Error).message,
+            }),
+          );
+        }
+      } finally {
+        if (entryRef) entryRef.abort = undefined;
+      }
+    } else if (parsed.type === "cancel") {
+      // Only abort the underlying SDK query — don't break the for-await loop.
+      // This lets Claude send its final message before the iterator ends naturally.
+      const provider = providerRegistry.get(providerId);
+      if (provider && "abortQuery" in provider && typeof (provider as any).abortQuery === "function") {
+        (provider as any).abortQuery(sessionId);
+      }
+    } else if (parsed.type === "approval_response") {
+      // Route approval response to the provider
+      const provider = providerRegistry.get(providerId);
+      if (provider && typeof provider.resolveApproval === "function") {
+        provider.resolveApproval(
+          parsed.requestId,
+          parsed.approved,
+          (parsed as any).data,
+        );
+      }
+    }
+  },
+
+  close(ws: ChatWsSocket) {
+    const { sessionId } = ws.data;
+    const entry = activeSessions.get(sessionId);
+    if (entry) {
+      // Force-break the for-await loop — no client to receive events anymore
+      if (entry.abort) {
+        entry.abort.abort();
+        entry.abort = undefined;
+      }
+      // Also abort the underlying SDK query so Claude stops working
+      const provider = providerRegistry.get(entry.providerId);
+      if (provider && "abortQuery" in provider && typeof (provider as any).abortQuery === "function") {
+        (provider as any).abortQuery(sessionId);
+      }
+    }
+    activeSessions.delete(sessionId);
+  },
+};

package/src/server/ws/terminal.ts

@@ -0,0 +1,89 @@
+import { terminalService } from "../../services/terminal.service.ts";
+import { resolveProjectPath } from "../helpers/resolve-project.ts";
+
+/** Control message prefix for resize commands */
+const RESIZE_PREFIX = "\x01RESIZE:";
+
+/**
+ * WebSocket handler configuration for Bun.serve().
+ * Handles terminal session attach, input, resize, and disconnect.
+ */
+export const terminalWebSocket = {
+  open(ws: { data: { type: string; id: string; projectName?: string }; send: (data: string) => void }) {
+    const { id, projectName } = ws.data;
+
+    let session = id !== "new" ? terminalService.get(id) : undefined;
+
+    // If session doesn't exist and projectName is provided, create one
+    if (!session && projectName) {
+      try {
+        const projectPath = resolveProjectPath(projectName);
+        // Create session with the requested ID — but TerminalService generates its own ID.
+        // Instead, create and return the new session ID to client.
+        const newId = terminalService.create(projectPath);
+        session = terminalService.get(newId);
+        if (session) {
+          // Update ws.data to reflect actual session ID
+          ws.data.id = newId;
+        }
+      } catch (e) {
+        ws.send(JSON.stringify({ type: "error", message: (e as Error).message }));
+        return;
+      }
+    }
+
+    if (!session) {
+      ws.send(JSON.stringify({ type: "error", message: "Session not found" }));
+      return;
+    }
+
+    const sessionId = ws.data.id;
+
+    // Mark connected
+    terminalService.setConnected(sessionId, ws);
+
+    // Send session info
+    ws.send(JSON.stringify({ type: "session", id: sessionId }));
+
+    // Send buffered output for reconnect
+    const buffer = terminalService.getBuffer(sessionId);
+    if (buffer) {
+      ws.send(buffer);
+    }
+
+    // Wire output listener
+    terminalService.onOutput(sessionId, (_id, data) => {
+      try {
+        ws.send(data);
+      } catch {
+        // WS closed
+      }
+    });
+  },
+
+  message(
+    ws: { data: { type: string; id: string } },
+    msg: string | ArrayBuffer | Uint8Array,
+  ) {
+    const sessionId = ws.data.id;
+    const text = typeof msg === "string" ? msg : new TextDecoder().decode(msg as ArrayBuffer);
+
+    // Check for resize control message
+    if (text.startsWith(RESIZE_PREFIX)) {
+      const parts = text.slice(RESIZE_PREFIX.length).split(",");
+      const cols = parseInt(parts[0] ?? "80", 10);
+      const rows = parseInt(parts[1] ?? "24", 10);
+      terminalService.resize(sessionId, cols, rows);
+      return;
+    }
+
+    // Regular input — write to PTY
+    terminalService.write(sessionId, text);
+  },
+
+  close(ws: { data: { type: string; id: string } }) {
+    const sessionId = ws.data.id;
+    terminalService.removeOutputListener(sessionId);
+    terminalService.setDisconnected(sessionId);
+  },
+};

package/src/services/chat.service.ts

@@ -0,0 +1,110 @@
+import { providerRegistry } from "../providers/registry.ts";
+import type {
+  Session,
+  SessionConfig,
+  SessionInfo,
+  ChatEvent,
+  ChatMessage,
+} from "../providers/provider.interface.ts";
+import { MockProvider } from "../providers/mock-provider.ts";
+
+class ChatService {
+  async createSession(
+    providerId?: string,
+    config: SessionConfig = {},
+  ): Promise<Session> {
+    const provider = providerId
+      ? providerRegistry.get(providerId)
+      : providerRegistry.getDefault();
+    if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    return provider.createSession(config);
+  }
+
+  async resumeSession(
+    providerId: string,
+    sessionId: string,
+  ): Promise<Session> {
+    const provider = providerRegistry.get(providerId);
+    if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    return provider.resumeSession(sessionId);
+  }
+
+  async listSessions(providerId?: string, dir?: string): Promise<SessionInfo[]> {
+    if (providerId) {
+      const provider = providerRegistry.get(providerId);
+      if (!provider) throw new Error(`Provider "${providerId}" not found`);
+      // Pass dir to providers that support it (SDK provider)
+      if (dir && "listSessionsByDir" in provider) {
+        return (provider as any).listSessionsByDir(dir);
+      }
+      return provider.listSessions();
+    }
+    // Aggregate from all providers
+    const all: SessionInfo[] = [];
+    for (const info of providerRegistry.list()) {
+      const provider = providerRegistry.get(info.id);
+      if (provider) {
+        if (dir && "listSessionsByDir" in provider) {
+          all.push(...await (provider as any).listSessionsByDir(dir));
+        } else {
+          all.push(...await provider.listSessions());
+        }
+      }
+    }
+    return all.sort(
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+    );
+  }
+
+  async deleteSession(
+    providerId: string,
+    sessionId: string,
+  ): Promise<void> {
+    const provider = providerRegistry.get(providerId);
+    if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    return provider.deleteSession(sessionId);
+  }
+
+  async *sendMessage(
+    providerId: string,
+    sessionId: string,
+    message: string,
+  ): AsyncIterable<ChatEvent> {
+    const provider = providerRegistry.get(providerId);
+    if (!provider) {
+      yield { type: "error", message: `Provider "${providerId}" not found` };
+      return;
+    }
+    yield* provider.sendMessage(sessionId, message);
+  }
+
+  /** Look up a session across all providers (for WS handler) */
+  getSession(sessionId: string): Session | null {
+    for (const info of providerRegistry.list()) {
+      const provider = providerRegistry.get(info.id);
+      if (!provider) continue;
+      const sessions = (provider as any).sessions as Map<string, unknown> | undefined;
+      if (sessions?.has(sessionId)) {
+        const entry = sessions.get(sessionId);
+        // SDK provider stores {meta, sdk}, others store Session directly
+        if (entry && typeof entry === "object" && "meta" in entry) {
+          return (entry as { meta: Session }).meta;
+        }
+        return entry as Session ?? null;
+      }
+    }
+    return null;
+  }
+
+  async getMessages(providerId: string, sessionId: string): Promise<ChatMessage[]> {
+    const provider = providerRegistry.get(providerId);
+    if (!provider) return [];
+    if ("getMessages" in provider && typeof (provider as any).getMessages === "function") {
+      return await (provider as any).getMessages(sessionId);
+    }
+    return [];
+  }
+}
+
+export const chatService = new ChatService();

package/src/services/claude-usage.service.ts

@@ -0,0 +1,113 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+
+export interface LimitBucket {
+  utilization: number;
+  budgetPace: number;
+  resetsAt: string;
+  resetsInMinutes: number | null;
+  resetsInHours: number | null;
+  windowHours: number;
+  status: string;
+}
+
+export interface ClaudeUsage {
+  timestamp?: string;
+  session?: LimitBucket;
+  weekly?: LimitBucket;
+  weeklyOpus?: LimitBucket;
+  weeklySonnet?: LimitBucket;
+}
+
+/** Cache to avoid spawning ccburn too often */
+let cache: { data: ClaudeUsage; timestamp: number } | null = null;
+const CACHE_TTL = 30_000; // 30 seconds
+
+/** Cached resolved path */
+let ccburnBin: string | undefined;
+
+/**
+ * Resolve ccburn binary. Checks:
+ * 1. node_modules/.bin/ccburn (relative to cwd — works for dev & prod)
+ * 2. Sibling to compiled binary (dist/node_modules/.bin/ccburn)
+ * 3. import.meta.dir based resolution
+ */
+function getCcburnPath(): string {
+  if (ccburnBin) return ccburnBin;
+  const candidates = [
+    resolve(process.cwd(), "node_modules/.bin/ccburn"),
+    resolve(dirname(process.argv[1] ?? ""), "../node_modules/.bin/ccburn"),
+    resolve(dirname(process.argv[1] ?? ""), "node_modules/.bin/ccburn"),
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      ccburnBin = p;
+      return p;
+    }
+  }
+  throw new Error("ccburn not found — run: bun install");
+}
+
+/**
+ * Fetch current usage/rate-limit info via ccburn (bundled dependency).
+ * ccburn handles credential retrieval (Keychain on macOS, etc.)
+ * and calls Anthropic's internal usage endpoint.
+ */
+export async function fetchClaudeUsage(): Promise<ClaudeUsage> {
+  if (cache && Date.now() - cache.timestamp < CACHE_TTL) {
+    return cache.data;
+  }
+
+  try {
+    const bin = getCcburnPath();
+    const raw = execFileSync(bin, ["--json"], {
+      encoding: "utf-8",
+      timeout: 10_000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+
+    // Extract JSON (skip any warnings before it)
+    const jsonStart = raw.indexOf("{");
+    const jsonStr = jsonStart > 0 ? raw.slice(jsonStart) : raw;
+    if (!jsonStr) return cache?.data ?? {};
+
+    const json = JSON.parse(jsonStr) as Record<string, unknown>;
+    const limits = json.limits as Record<string, unknown> | undefined;
+    if (!limits) return cache?.data ?? {};
+
+    const data: ClaudeUsage = {
+      timestamp: json.timestamp as string | undefined,
+    };
+
+    if (limits.session && typeof limits.session === "object") {
+      data.session = parseBucket(limits.session as Record<string, unknown>);
+    }
+    if (limits.weekly && typeof limits.weekly === "object") {
+      data.weekly = parseBucket(limits.weekly as Record<string, unknown>);
+    }
+    if (limits.weekly_opus && typeof limits.weekly_opus === "object") {
+      data.weeklyOpus = parseBucket(limits.weekly_opus as Record<string, unknown>);
+    }
+    if (limits.weekly_sonnet && typeof limits.weekly_sonnet === "object") {
+      data.weeklySonnet = parseBucket(limits.weekly_sonnet as Record<string, unknown>);
+    }
+
+    cache = { data, timestamp: Date.now() };
+    return data;
+  } catch {
+    return cache?.data ?? {};
+  }
+}
+
+function parseBucket(raw: Record<string, unknown>): LimitBucket {
+  return {
+    utilization: (raw.utilization as number) ?? 0,
+    budgetPace: (raw.budget_pace as number) ?? 0,
+    resetsAt: (raw.resets_at as string) ?? "",
+    resetsInMinutes: (raw.resets_in_minutes as number) ?? null,
+    resetsInHours: (raw.resets_in_hours as number) ?? null,
+    windowHours: (raw.window_hours as number) ?? 0,
+    status: (raw.status as string) ?? "",
+  };
+}

package/src/services/config.service.ts

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+import yaml from "js-yaml";
+import type { PpmConfig } from "../types/config.ts";
+import { DEFAULT_CONFIG } from "../types/config.ts";
+
+const PPM_DIR = resolve(homedir(), ".ppm");
+const GLOBAL_CONFIG_PATH = resolve(PPM_DIR, "config.yaml");
+const LOCAL_CONFIG_PATH = resolve(process.cwd(), "ppm.yaml");
+
+class ConfigService {
+  private config: PpmConfig = structuredClone(DEFAULT_CONFIG);
+  private configPath: string = GLOBAL_CONFIG_PATH;
+
+  /** Load config from: explicit path → ./ppm.yaml → ~/.ppm/config.yaml */
+  load(explicitPath?: string): PpmConfig {
+    const searchPaths = [
+      explicitPath,
+      LOCAL_CONFIG_PATH,
+      GLOBAL_CONFIG_PATH,
+    ].filter(Boolean) as string[];
+
+    for (const p of searchPaths) {
+      if (existsSync(p)) {
+        const raw = readFileSync(p, "utf-8");
+        const parsed = yaml.load(raw) as Partial<PpmConfig> | null;
+        if (parsed) {
+          this.config = { ...structuredClone(DEFAULT_CONFIG), ...parsed };
+          this.configPath = p;
+          // Auto-generate token if auth enabled but token is empty
+          if (this.config.auth.enabled && !this.config.auth.token) {
+            this.config.auth.token = randomBytes(16).toString("hex");
+            this.save();
+          }
+          return this.config;
+        }
+      }
+    }
+
+    // No config found — create default
+    this.config = this.createDefault();
+    return this.config;
+  }
+
+  /** Save current config to disk */
+  save(): void {
+    const dir = dirname(this.configPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(this.configPath, yaml.dump(this.config), "utf-8");
+  }
+
+  /** Get a top-level config key */
+  get<K extends keyof PpmConfig>(key: K): PpmConfig[K] {
+    return this.config[key];
+  }
+
+  /** Set a top-level config key */
+  set<K extends keyof PpmConfig>(key: K, value: PpmConfig[K]): void {
+    this.config[key] = value;
+  }
+
+  /** Get the full config object */
+  getAll(): PpmConfig {
+    return this.config;
+  }
+
+  /** Get the path config was loaded from */
+  getConfigPath(): string {
+    return this.configPath;
+  }
+
+  /** Set the config path explicitly (for init command) */
+  setConfigPath(p: string): void {
+    this.configPath = p;
+  }
+
+  /** Create default config with auto-generated auth token */
+  private createDefault(): PpmConfig {
+    const config = structuredClone(DEFAULT_CONFIG);
+    config.auth.token = randomBytes(16).toString("hex");
+    this.configPath = GLOBAL_CONFIG_PATH;
+    this.save();
+    return config;
+  }
+}
+
+/** Singleton config service */
+export const configService = new ConfigService();