@hienlh/ppm 0.1.6 → 0.2.0

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/server/index.ts

@@ -32,7 +32,9 @@ app.route("/", staticRoutes);
 
 export async function startServer(options: {
   port?: string;
-  daemon?: boolean;
+  foreground?: boolean;
+  daemon?: boolean; // compat, ignored (daemon is now default)
+  share?: boolean;
   config?: string;
 }) {
   // Load config
@@ -40,27 +42,66 @@ export async function startServer(options: {
   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 isDaemon = !options.foreground;
+
+  if (isDaemon) {
     const { resolve } = await import("node:path");
     const { homedir } = await import("node:os");
-    const { writeFileSync, mkdirSync, existsSync } = await import("node:fs");
+    const { writeFileSync, readFileSync, 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 statusFile = resolve(ppmDir, "status.json");
+
+    // If --share, download cloudflared in parent (shows progress to user)
+    if (options.share) {
+      const { ensureCloudflared } = await import("../services/cloudflared.service.ts");
+      await ensureCloudflared();
+    }
 
+    // Spawn child process
     const child = Bun.spawn({
-      cmd: ["bun", "run", import.meta.dir + "/index.ts", "__serve__", String(port), host, options.config ?? ""],
+      cmd: [
+        process.execPath, "run", import.meta.dir + "/index.ts", "__serve__",
+        String(port), host, options.config ?? "", options.share ? "share" : "",
+      ],
       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}`);
+
+    // Poll for status.json (child writes it when ready)
+    const startTime = Date.now();
+    let status: { pid: number; port: number; host: string; shareUrl?: string } | null = null;
+    while (Date.now() - startTime < 30_000) {
+      if (existsSync(statusFile)) {
+        try {
+          status = JSON.parse(readFileSync(statusFile, "utf-8"));
+          break;
+        } catch { /* file not fully written yet */ }
+      }
+      await Bun.sleep(200);
+    }
+
+    if (status) {
+      console.log(`\n  PPM daemon started (PID: ${status.pid})\n`);
+      console.log(`  ➜  Local:   http://localhost:${status.port}/`);
+      if (status.shareUrl) {
+        console.log(`  ➜  Share:   ${status.shareUrl}`);
+        if (!configService.get("auth").enabled) {
+          console.log(`\n  ⚠  Warning: auth is disabled — your IDE is publicly accessible!`);
+          console.log(`     Enable auth in ~/.ppm/config.yaml or restart without --share.`);
+        }
+        const qr = await import("qrcode-terminal");
+        console.log();
+        qr.generate(status.shareUrl, { small: true });
+      }
+    } else {
+      console.log(`\n  PPM daemon started (PID: ${child.pid}) but status not confirmed.`);
+    }
+
     process.exit(0);
   }
 
@@ -74,7 +115,6 @@ export async function startServer(options: {
       // 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] ?? "";
@@ -97,11 +137,10 @@ export async function startServer(options: {
         }
       }
 
-      // Fall through to Hono for all other requests
       return app.fetch(req, server);
     },
     websocket: {
-      idleTimeout: 960, // 16 minutes — keepalive ping handles liveness
+      idleTimeout: 960,
       sendPong: true,
       open(ws: any) {
         if (ws.data?.type === "chat") chatWebSocket.open(ws);
@@ -118,10 +157,9 @@ export async function startServer(options: {
     } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
   });
 
-  console.log(`\n  PPM v0.1.6 ready\n`);
+  console.log(`\n  PPM v0.2.0 ready\n`);
   console.log(`  ➜  Local:   http://localhost:${server.port}/`);
 
-  // List all network interfaces
   const { networkInterfaces } = await import("node:os");
   const nets = networkInterfaces();
   for (const name of Object.keys(nets)) {
@@ -132,6 +170,26 @@ export async function startServer(options: {
     }
   }
 
+  // Share tunnel in foreground mode
+  if (options.share) {
+    try {
+      const { tunnelService } = await import("../services/tunnel.service.ts");
+      console.log("\n  Starting share tunnel...");
+      const shareUrl = await tunnelService.startTunnel(server.port);
+      console.log(`  ➜  Share:   ${shareUrl}`);
+      if (!configService.get("auth").enabled) {
+        console.log(`\n  ⚠  Warning: auth is disabled — your IDE is publicly accessible!`);
+        console.log(`     Enable auth in ~/.ppm/config.yaml or restart without --share.`);
+      }
+      const qr = await import("qrcode-terminal");
+      console.log();
+      qr.generate(shareUrl, { small: true });
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`  ✗  Share failed: ${msg}`);
+    }
+  }
+
   console.log(`\n  Auth: ${configService.get("auth").enabled ? "enabled" : "disabled"}`);
   if (configService.get("auth").enabled) {
     console.log(`  Token: ${configService.get("auth").token}`);
@@ -145,16 +203,23 @@ if (process.argv.includes("__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;
+  const shareFlag = process.argv[idx + 4] === "share";
 
   configService.load(configPath);
 
+  const { resolve } = await import("node:path");
+  const { homedir } = await import("node:os");
+  const { writeFileSync, unlinkSync } = await import("node:fs");
+
+  const statusFile = resolve(homedir(), ".ppm", "status.json");
+  const pidFile = resolve(homedir(), ".ppm", "ppm.pid");
+
   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] ?? "";
@@ -198,4 +263,28 @@ if (process.argv.includes("__serve__")) {
       },
     } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
   });
+
+  // Start tunnel if --share was passed (eagerly import so cleanup doesn't race)
+  let shareUrl: string | undefined;
+  const tunnel = shareFlag
+    ? (await import("../services/tunnel.service.ts")).tunnelService
+    : null;
+  if (tunnel) {
+    try {
+      shareUrl = await tunnel.startTunnel(port);
+    } catch { /* non-fatal: server runs without share URL */ }
+  }
+
+  // Write status file for parent to read
+  writeFileSync(statusFile, JSON.stringify({ pid: process.pid, port, host, shareUrl }));
+
+  // Cleanup on exit
+  const cleanup = () => {
+    try { unlinkSync(statusFile); } catch {}
+    try { unlinkSync(pidFile); } catch {}
+    tunnel?.stopTunnel();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
 }