@hienlh/ppm 0.1.4 → 0.2.0

package/schemas/ppm-config.schema.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "PPM Configuration",
+  "description": "Configuration file for PPM (Project & Process Manager)",
+  "type": "object",
+  "properties": {
+    "port": {
+      "type": "integer",
+      "default": 8080,
+      "description": "Server port"
+    },
+    "host": {
+      "type": "string",
+      "default": "0.0.0.0",
+      "description": "Server bind address"
+    },
+    "auth": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": true },
+        "token": { "type": "string" }
+      }
+    },
+    "projects": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "path": { "type": "string" },
+          "name": { "type": "string" }
+        },
+        "required": ["path", "name"]
+      }
+    },
+    "ai": {
+      "type": "object",
+      "properties": {
+        "default_provider": { "type": "string", "default": "claude" },
+        "providers": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/AIProviderConfig"
+          }
+        }
+      }
+    }
+  },
+  "$defs": {
+    "AIProviderConfig": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["agent-sdk", "mock"]
+        },
+        "api_key_env": { "type": "string" },
+        "model": {
+          "type": "string",
+          "description": "Model ID (e.g. claude-sonnet-4-6, claude-opus-4-6)",
+          "examples": ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
+        },
+        "effort": {
+          "type": "string",
+          "enum": ["low", "medium", "high", "max"],
+          "default": "high"
+        },
+        "max_turns": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 500,
+          "default": 100
+        },
+        "max_budget_usd": {
+          "type": "number",
+          "minimum": 0.01,
+          "maximum": 50
+        },
+        "thinking_budget_tokens": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "0 = disabled"
+        }
+      },
+      "required": ["type"]
+    }
+  }
+}

package/src/cli/commands/init.ts

@@ -1,57 +1,200 @@
 import { resolve } from "node:path";
 import { homedir } from "node:os";
 import { existsSync } from "node:fs";
+import { input, confirm, select, password } from "@inquirer/prompts";
 import { configService } from "../../services/config.service.ts";
 import { projectService } from "../../services/project.service.ts";
 
-export async function initProject() {
-  const ppmDir = resolve(homedir(), ".ppm");
-  const globalConfig = resolve(ppmDir, "config.yaml");
+const DEFAULT_PORT = 3210;
 
-  // Load existing or create default
-  configService.load();
-  console.log(`Config: ${configService.getConfigPath()}`);
-
-  // Scan CWD for git repos
-  const cwd = process.cwd();
-  console.log(`\nScanning ${cwd} for git repositories...`);
-  const repos = projectService.scanForGitRepos(cwd);
-
-  if (repos.length === 0) {
-    console.log("No git repositories found.");
-  } else {
-    console.log(`Found ${repos.length} git repo(s):\n`);
-    const existing = configService.get("projects");
-
-    let added = 0;
-    for (const repoPath of repos) {
-      const name = repoPath.split("/").pop() ?? "unknown";
-      const alreadyRegistered = existing.some(
-        (p) => resolve(p.path) === repoPath || p.name === name,
-      );
-
-      if (alreadyRegistered) {
-        console.log(`  [skip] ${name} (${repoPath}) — already registered`);
-        continue;
-      }
-
-      try {
-        projectService.add(repoPath, name);
-        console.log(`  [added] ${name} (${repoPath})`);
-        added++;
-      } catch (e) {
-        console.log(`  [error] ${name}: ${(e as Error).message}`);
-      }
+export interface InitOptions {
+  port?: string;
+  scan?: string;
+  auth?: boolean;
+  password?: string;
+  share?: boolean;
+  /** Skip prompts, use defaults + flags only (for VPS/scripts) */
+  yes?: boolean;
+}
+
+/** Check if config already exists */
+export function hasConfig(): boolean {
+  const globalConfig = resolve(homedir(), ".ppm", "config.yaml");
+  const localConfig = resolve(process.cwd(), "ppm.yaml");
+  return existsSync(globalConfig) || existsSync(localConfig);
+}
+
+export async function initProject(options: InitOptions = {}) {
+  const nonInteractive = options.yes ?? false;
+
+  // Check if already initialized
+  if (hasConfig() && !nonInteractive) {
+    const overwrite = await confirm({
+      message: "PPM is already configured. Re-initialize? (this will overwrite your config)",
+      default: false,
+    });
+    if (!overwrite) {
+      console.log("  Cancelled.");
+      return;
     }
+  }
+
+  console.log("\n  🔧 PPM Setup\n");
 
-    console.log(`\nAdded ${added} project(s).`);
+  // 1. Port
+  const portValue = options.port
+    ? parseInt(options.port, 10)
+    : nonInteractive
+      ? DEFAULT_PORT
+      : parseInt(await input({
+          message: "Port:",
+          default: String(DEFAULT_PORT),
+          validate: (v) => /^\d+$/.test(v) && +v > 0 && +v < 65536 ? true : "Enter valid port (1-65535)",
+        }), 10);
+
+  // 2. Scan directory
+  const scanDir = options.scan
+    ?? (nonInteractive
+      ? homedir()
+      : await input({
+          message: "Projects directory to scan:",
+          default: homedir(),
+        }));
+
+  // 3. Auth
+  const authEnabled = options.auth
+    ?? (nonInteractive
+      ? true
+      : await confirm({
+          message: "Enable authentication?",
+          default: true,
+        }));
+
+  // 4. Password (if auth enabled)
+  let authToken = "";
+  if (authEnabled) {
+    authToken = options.password
+      ?? (nonInteractive
+        ? generateToken()
+        : await password({
+            message: "Set access password (leave empty to auto-generate):",
+          }));
+    if (!authToken) authToken = generateToken();
   }
 
-  const auth = configService.get("auth");
-  console.log(`\nAuth: ${auth.enabled ? "enabled" : "disabled"}`);
-  if (auth.enabled) {
-    console.log(`Token: ${auth.token}`);
+  // 5. Share (install cloudflared)
+  const wantShare = options.share
+    ?? (nonInteractive
+      ? false
+      : await confirm({
+          message: "Install cloudflared for public sharing (--share)?",
+          default: false,
+        }));
+
+  // 6. Advanced settings
+  let aiModel = "claude-sonnet-4-6";
+  let aiEffort: "low" | "medium" | "high" | "max" = "high";
+  let aiMaxTurns = 100;
+  let aiApiKeyEnv = "ANTHROPIC_API_KEY";
+
+  if (!nonInteractive) {
+    const wantAdvanced = await confirm({
+      message: "Configure advanced AI settings?",
+      default: false,
+    });
+
+    if (wantAdvanced) {
+      aiModel = await select({
+        message: "AI model:",
+        choices: [
+          { value: "claude-sonnet-4-6", name: "Claude Sonnet 4.6 (fast, recommended)" },
+          { value: "claude-opus-4-6", name: "Claude Opus 4.6 (powerful)" },
+          { value: "claude-haiku-4-5", name: "Claude Haiku 4.5 (cheap)" },
+        ],
+        default: "claude-sonnet-4-6",
+      });
+
+      aiEffort = await select({
+        message: "Thinking effort:",
+        choices: [
+          { value: "low" as const, name: "Low" },
+          { value: "medium" as const, name: "Medium" },
+          { value: "high" as const, name: "High (recommended)" },
+          { value: "max" as const, name: "Max" },
+        ],
+        default: "high" as const,
+      });
+
+      aiMaxTurns = parseInt(await input({
+        message: "Max turns per chat:",
+        default: "100",
+        validate: (v) => /^\d+$/.test(v) && +v >= 1 && +v <= 500 ? true : "Enter 1-500",
+      }), 10);
+
+      aiApiKeyEnv = await input({
+        message: "API key env variable:",
+        default: "ANTHROPIC_API_KEY",
+      });
+    }
+  }
+
+  // Apply config
+  configService.load();
+  configService.set("port", portValue);
+  configService.set("auth", { enabled: authEnabled, token: authToken });
+  configService.set("ai", {
+    default_provider: "claude",
+    providers: {
+      claude: {
+        type: "agent-sdk",
+        api_key_env: aiApiKeyEnv,
+        model: aiModel,
+        effort: aiEffort,
+        max_turns: aiMaxTurns,
+      },
+    },
+  });
+  configService.save();
+
+  // Scan for projects
+  console.log(`\n  Scanning ${scanDir} for git repositories...`);
+  const repos = projectService.scanForGitRepos(scanDir);
+  const existing = configService.get("projects");
+  let added = 0;
+
+  for (const repoPath of repos) {
+    const name = repoPath.split("/").pop() ?? "unknown";
+    if (existing.some((p) => resolve(p.path) === repoPath || p.name === name)) continue;
+    try {
+      projectService.add(repoPath, name);
+      added++;
+    } catch {}
+  }
+  console.log(`  Found ${repos.length} repo(s), added ${added} new project(s).`);
+
+  // Install cloudflared if requested
+  if (wantShare) {
+    console.log("\n  Installing cloudflared...");
+    const { ensureCloudflared } = await import("../../services/cloudflared.service.ts");
+    await ensureCloudflared();
+    console.log("  ✓ cloudflared ready");
   }
 
-  console.log(`\nRun "ppm start" to start the server.`);
+  // 8. Next steps
+  console.log(`\n  ✓ Config saved to ${configService.getConfigPath()}\n`);
+  console.log("  Next steps:");
+  console.log(`    ppm start              # Start (daemon, port ${portValue})`);
+  console.log(`    ppm start -f           # Start in foreground`);
+  if (wantShare) {
+    console.log(`    ppm start --share      # Start + public URL`);
+  }
+  if (authEnabled) {
+    console.log(`\n  Access password: ${authToken}`);
+  }
+  console.log();
+}
+
+function generateToken(): string {
+  const { randomBytes } = require("node:crypto");
+  return randomBytes(16).toString("hex");
 }

package/src/cli/commands/status.ts

@@ -0,0 +1,73 @@
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { readFileSync, existsSync } from "node:fs";
+
+const STATUS_FILE = resolve(homedir(), ".ppm", "status.json");
+const PID_FILE = resolve(homedir(), ".ppm", "ppm.pid");
+
+interface DaemonStatus {
+  running: boolean;
+  pid: number | null;
+  port: number | null;
+  host: string | null;
+  shareUrl: string | null;
+}
+
+function getDaemonStatus(): DaemonStatus {
+  const notRunning: DaemonStatus = { running: false, pid: null, port: null, host: null, shareUrl: null };
+
+  // Try status.json first
+  if (existsSync(STATUS_FILE)) {
+    try {
+      const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+      const pid = data.pid as number;
+      // Check if process is actually alive
+      try {
+        process.kill(pid, 0); // signal 0 = check existence
+        return { running: true, pid, port: data.port, host: data.host, shareUrl: data.shareUrl ?? null };
+      } catch {
+        return notRunning; // stale status file
+      }
+    } catch {
+      return notRunning;
+    }
+  }
+
+  // Fallback to ppm.pid
+  if (existsSync(PID_FILE)) {
+    try {
+      const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+      process.kill(pid, 0);
+      return { running: true, pid, port: null, host: null, shareUrl: null };
+    } catch {
+      return notRunning;
+    }
+  }
+
+  return notRunning;
+}
+
+export async function showStatus(options: { json?: boolean }) {
+  const status = getDaemonStatus();
+
+  if (options.json) {
+    console.log(JSON.stringify(status));
+    return;
+  }
+
+  if (!status.running) {
+    console.log("  PPM is not running.");
+    return;
+  }
+
+  console.log(`\n  PPM daemon is running\n`);
+  console.log(`  PID:     ${status.pid}`);
+  if (status.port) console.log(`  Local:   http://localhost:${status.port}/`);
+  if (status.shareUrl) {
+    console.log(`  Share:   ${status.shareUrl}`);
+    const qr = await import("qrcode-terminal");
+    console.log();
+    qr.generate(status.shareUrl, { small: true });
+  }
+  console.log();
+}

package/src/cli/commands/stop.ts

@@ -3,29 +3,43 @@ import { homedir } from "node:os";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 
 const PID_FILE = resolve(homedir(), ".ppm", "ppm.pid");
+const STATUS_FILE = resolve(homedir(), ".ppm", "status.json");
 
 export async function stopServer() {
-  if (!existsSync(PID_FILE)) {
-    console.log("No PPM daemon running (PID file not found).");
-    return;
+  let pid: number | null = null;
+
+  // Try status.json first (new format)
+  if (existsSync(STATUS_FILE)) {
+    try {
+      const status = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+      pid = status.pid;
+    } catch {}
+  }
+
+  // Fallback to ppm.pid (compat)
+  if (!pid && existsSync(PID_FILE)) {
+    pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
   }
 
-  const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
-  if (isNaN(pid)) {
-    console.log("Invalid PID file. Removing it.");
-    unlinkSync(PID_FILE);
+  if (!pid || isNaN(pid)) {
+    console.log("No PPM daemon running.");
+    // Cleanup stale files
+    if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
+    if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
     return;
   }
 
   try {
     process.kill(pid);
-    unlinkSync(PID_FILE);
+    if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
+    if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
     console.log(`PPM daemon stopped (PID: ${pid}).`);
   } catch (e) {
     const error = e as NodeJS.ErrnoException;
     if (error.code === "ESRCH") {
-      console.log(`Process ${pid} not found. Cleaning up PID file.`);
-      unlinkSync(PID_FILE);
+      console.log(`Process ${pid} not found. Cleaning up stale files.`);
+      if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
+      if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
     } else {
       console.error(`Failed to stop process ${pid}: ${error.message}`);
     }

package/src/index.ts

@@ -10,11 +10,18 @@ program
 
 program
   .command("start")
-  .description("Start the PPM server")
+  .description("Start the PPM server (background by default)")
   .option("-p, --port <port>", "Port to listen on")
-  .option("-d, --daemon", "Run as background daemon")
+  .option("-f, --foreground", "Run in foreground (default: background daemon)")
+  .option("-d, --daemon", "Run as background daemon (default, kept for compat)")
+  .option("-s, --share", "Share via public URL (Cloudflare tunnel)")
   .option("-c, --config <path>", "Path to config file")
   .action(async (options) => {
+    // Auto-init on first run
+    const { hasConfig, initProject } = await import("./cli/commands/init.ts");
+    if (!hasConfig()) {
+      await initProject();
+    }
     const { startServer } = await import("./server/index.ts");
     await startServer(options);
   });
@@ -27,6 +34,15 @@ program
     await stopServer();
   });
 
+program
+  .command("status")
+  .description("Show PPM daemon status")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { showStatus } = await import("./cli/commands/status.ts");
+    await showStatus(options);
+  });
+
 program
   .command("open")
   .description("Open PPM in browser")
@@ -38,10 +54,17 @@ program
 
 program
   .command("init")
-  .description("Initialize PPM configuration — scan for git repos, create config")
-  .action(async () => {
+  .description("Initialize PPM configuration (interactive or via flags)")
+  .option("-p, --port <port>", "Port to listen on")
+  .option("--scan <path>", "Directory to scan for git repos")
+  .option("--auth", "Enable authentication")
+  .option("--no-auth", "Disable authentication")
+  .option("--password <pw>", "Set access password")
+  .option("--share", "Pre-install cloudflared for sharing")
+  .option("-y, --yes", "Non-interactive mode (use defaults + flags)")
+  .action(async (options) => {
     const { initProject } = await import("./cli/commands/init.ts");
-    await initProject();
+    await initProject(options);
   });
 
 const { registerProjectsCommands } = await import("./cli/commands/projects.ts");

package/src/providers/claude-agent-sdk.ts

@@ -12,6 +12,7 @@ import type {
   ChatMessage,
   UsageInfo,
 } from "./provider.interface.ts";
+import { configService } from "../services/config.service.ts";
 
 /**
  * Pending approval: canUseTool callback creates a promise,
@@ -39,6 +40,13 @@ export class ClaudeAgentSdkProvider implements AIProvider {
   /** Latest known usage/rate-limit info (shared across all sessions) */
   private latestUsage: UsageInfo = {};
 
+  /** Read current provider config from yaml (fresh each call) */
+  private getProviderConfig(): Partial<import("../types/config.ts").AIProviderConfig> {
+    const ai = configService.get("ai");
+    const providerId = ai.default_provider ?? "claude";
+    return ai.providers[providerId] ?? {};
+  }
+
   async createSession(config: SessionConfig): Promise<Session> {
     const id = crypto.randomUUID();
     const meta: Session = {
@@ -176,9 +184,17 @@ export class ClaudeAgentSdkProvider implements AIProvider {
 
       const requestId = crypto.randomUUID();
 
+      const APPROVAL_TIMEOUT_MS = 60_000;
       const approvalPromise = new Promise<{ approved: boolean; data?: unknown }>(
         (resolve) => {
           this.pendingApprovals.set(requestId, { resolve });
+          // Auto-deny after timeout if FE doesn't respond
+          setTimeout(() => {
+            if (this.pendingApprovals.has(requestId)) {
+              this.pendingApprovals.delete(requestId);
+              resolve({ approved: false });
+            }
+          }, APPROVAL_TIMEOUT_MS);
         },
       );
 
@@ -191,7 +207,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       });
       approvalNotify?.();
 
-      // Wait for FE to send back answers
+      // Wait for FE to send back answers (or timeout)
       const result = await approvalPromise;
 
       if (result.approved && result.data) {
@@ -204,21 +220,46 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     };
 
     let assistantContent = "";
+    let resultSubtype: string | undefined;
+    let resultNumTurns: number | undefined;
 
     try {
+      const providerConfig = this.getProviderConfig();
+
       const q = query({
         prompt: message,
         options: {
           sessionId: isFirstMessage ? sessionId : undefined,
           resume: isFirstMessage ? undefined : sessionId,
           cwd: meta.projectPath,
-          settingSources: meta.projectPath ? ["project"] : undefined,
+          // Use full Claude Code system prompt (coding guidelines, security, response style)
+          systemPrompt: { type: "preset", preset: "claude_code" },
+          // Load project CLAUDE.md, skills, and hooks from project directory
+          settingSources: ["project"],
+          // Neutralize Anthropic env vars so SDK uses subscription, not project .env keys.
+          env: {
+            ...process.env,
+            ANTHROPIC_API_KEY: "",
+            ANTHROPIC_BASE_URL: "",
+            ANTHROPIC_AUTH_TOKEN: "",
+          },
+          // Override project-local Claude settings that may restrict tool permissions
+          settings: { permissions: { allow: [], deny: [] } },
           allowedTools: [
             "Read", "Write", "Edit", "Bash", "Glob", "Grep",
             "WebSearch", "WebFetch", "AskUserQuestion",
+            "Agent", "Skill", "TodoWrite", "ToolSearch",
           ],
           permissionMode: "bypassPermissions",
           allowDangerouslySkipPermissions: true,
+          // Config-driven values from ppm.yaml
+          ...(providerConfig.model && { model: providerConfig.model }),
+          ...(providerConfig.effort && { effort: providerConfig.effort }),
+          maxTurns: providerConfig.max_turns ?? 100,
+          ...(providerConfig.max_budget_usd && { maxBudgetUsd: providerConfig.max_budget_usd }),
+          ...(providerConfig.thinking_budget_tokens != null && {
+            thinkingBudgetTokens: providerConfig.thinking_budget_tokens,
+          }),
           canUseTool,
           includePartialMessages: true,
         } as any,
@@ -232,11 +273,27 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       let pendingToolCount = 0;
 
       for await (const msg of q) {
+        // Debug: log all SDK events to understand flow
+
         // Yield any queued approval events
         while (approvalEvents.length > 0) {
           yield approvalEvents.shift()!;
         }
 
+        // Capture SDK session metadata from init message
+        if (msg.type === "system" && (msg as any).subtype === "init") {
+          const initMsg = msg as any;
+          // SDK may assign a different session_id than our UUID
+          if (initMsg.session_id && initMsg.session_id !== sessionId) {
+            // Update our mapping so resume works with SDK's actual ID
+            const oldMeta = this.activeSessions.get(sessionId);
+            if (oldMeta) {
+              this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
+            }
+          }
+          continue;
+        }
+
         // When tools were pending and a new assistant/stream_event arrives,
         // the SDK has finished executing tools. Fetch tool_results from session history.
         if (pendingToolCount > 0 && (msg.type === "assistant" || (msg as any).type === "partial" || (msg as any).type === "stream_event")) {
@@ -369,12 +426,31 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           }
 
           const result = msg as any;
+          const subtype = result.subtype as string | undefined;
+
           // Yield final cost + any rate limit info from result
           const usage: Record<string, unknown> = {};
           if (result.total_cost_usd != null) usage.totalCostUsd = result.total_cost_usd;
           if (Object.keys(usage).length > 0) {
             yield { type: "usage", usage };
           }
+
+          // Surface non-success subtypes as errors so FE can display them
+          if (subtype && subtype !== "success") {
+            const errorMessages: Record<string, string> = {
+              error_max_turns: "Agent reached maximum turn limit.",
+              error_max_budget_usd: "Agent reached budget limit.",
+              error_during_execution: "Agent encountered an error during execution.",
+            };
+            yield {
+              type: "error",
+              message: errorMessages[subtype] ?? `Agent stopped: ${subtype}`,
+            };
+          }
+
+          // Store subtype and numTurns for the done event
+          resultSubtype = subtype;
+          resultNumTurns = result.num_turns as number | undefined;
           break;
         }
       }
@@ -393,7 +469,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       this.activeQueries.delete(sessionId);
     }
 
-    yield { type: "done", sessionId };
+    yield {
+      type: "done",
+      sessionId,
+      resultSubtype: resultSubtype as any,
+      numTurns: resultNumTurns,
+    };
   }
 
   /** Get latest cached usage/rate-limit info */