@hienlh/ppm 0.1.6 → 0.2.1

package/src/cli/commands/init.ts

@@ -1,57 +1,210 @@
 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");
+
+  // 1. Device name
+  const defaultHostname = (await import("node:os")).hostname();
+  const deviceName = nonInteractive
+    ? (options as any).deviceName ?? defaultHostname
+    : await input({
+        message: "Device name (shown in UI to identify this machine):",
+        default: defaultHostname,
+      });
+
+  // 2. 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();
+  }
+
+  // 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",
+      });
     }
+  }
 
-    console.log(`\nAdded ${added} project(s).`);
+  // Apply config
+  configService.load();
+  configService.set("device_name", deviceName);
+  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).`);
 
-  const auth = configService.get("auth");
-  console.log(`\nAuth: ${auth.enabled ? "enabled" : "disabled"}`);
-  if (auth.enabled) {
-    console.log(`Token: ${auth.token}`);
+  // 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/logs.ts

@@ -0,0 +1,58 @@
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, readFileSync, statSync } from "node:fs";
+
+const LOG_FILE = resolve(homedir(), ".ppm", "ppm.log");
+
+export async function showLogs(options: { tail?: string; follow?: boolean; clear?: boolean }) {
+  if (options.clear) {
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(LOG_FILE, "");
+    console.log("Logs cleared.");
+    return;
+  }
+
+  if (!existsSync(LOG_FILE)) {
+    console.log("No log file found. Start PPM daemon first.");
+    return;
+  }
+
+  const lines = parseInt(options.tail ?? "50", 10);
+  const content = readFileSync(LOG_FILE, "utf-8");
+  const allLines = content.split("\n");
+  const lastN = allLines.slice(-lines).join("\n");
+
+  if (!lastN.trim()) {
+    console.log("Log file is empty.");
+    return;
+  }
+
+  console.log(lastN);
+
+  if (options.follow) {
+    // Tail -f behavior
+    const { watch } = await import("node:fs");
+    let lastSize = statSync(LOG_FILE).size;
+    console.log("\n--- Following logs (Ctrl+C to stop) ---\n");
+
+    watch(LOG_FILE, () => {
+      try {
+        const newSize = statSync(LOG_FILE).size;
+        if (newSize > lastSize) {
+          const fd = Bun.file(LOG_FILE);
+          fd.slice(lastSize, newSize).text().then((text) => {
+            process.stdout.write(text);
+          });
+          lastSize = newSize;
+        }
+      } catch {}
+    });
+  }
+}
+
+/** Get last N lines of log for bug reports */
+export function getRecentLogs(lines = 30): string {
+  if (!existsSync(LOG_FILE)) return "(no logs)";
+  const content = readFileSync(LOG_FILE, "utf-8");
+  return content.split("\n").slice(-lines).join("\n").trim() || "(empty)";
+}

package/src/cli/commands/report.ts

@@ -0,0 +1,60 @@
+import { homedir, platform, arch, release } from "node:os";
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { getRecentLogs } from "./logs.ts";
+
+const REPO = "hienlh/ppm";
+
+export async function reportBug() {
+  const version = "0.2.1";
+  const logs = getRecentLogs(30);
+  const statusFile = resolve(homedir(), ".ppm", "status.json");
+  let statusInfo = "(not running)";
+  if (existsSync(statusFile)) {
+    try { statusInfo = readFileSync(statusFile, "utf-8"); } catch {}
+  }
+
+  const body = [
+    "## Environment",
+    `- PPM: v${version}`,
+    `- OS: ${platform()} ${arch()} ${release()}`,
+    `- Bun: ${Bun.version}`,
+    "",
+    "## Description",
+    "<!-- Describe the bug -->",
+    "",
+    "## Steps to Reproduce",
+    "1. ",
+    "",
+    "## Expected Behavior",
+    "",
+    "## Daemon Status",
+    "```json",
+    statusInfo,
+    "```",
+    "",
+    "## Recent Logs (last 30 lines)",
+    "```",
+    logs,
+    "```",
+  ].join("\n");
+
+  const title = encodeURIComponent("bug: ");
+  const encodedBody = encodeURIComponent(body);
+  const url = `https://github.com/${REPO}/issues/new?title=${title}&body=${encodedBody}`;
+
+  console.log("  Opening GitHub issue form in browser...\n");
+  console.log("  Environment info and recent logs will be pre-filled.\n");
+
+  const { $ } = await import("bun");
+  try {
+    if (platform() === "darwin") {
+      await $`open ${url}`.quiet();
+    } else {
+      await $`xdg-open ${url}`.quiet();
+    }
+  } catch {
+    console.log("  Could not open browser. Copy this URL:\n");
+    console.log(`  ${url}\n`);
+  }
+}

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

@@ -6,15 +6,22 @@ const program = new Command();
 program
   .name("ppm")
   .description("Personal Project Manager — mobile-first web IDE")
-  .version("0.1.0");
+  .version("0.2.1");
 
 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")
@@ -37,11 +53,37 @@ program
   });
 
 program
-  .command("init")
-  .description("Initialize PPM configuration — scan for git repos, create config")
+  .command("logs")
+  .description("View PPM daemon logs")
+  .option("-n, --tail <lines>", "Number of lines to show", "50")
+  .option("-f, --follow", "Follow log output")
+  .option("--clear", "Clear log file")
+  .action(async (options) => {
+    const { showLogs } = await import("./cli/commands/logs.ts");
+    await showLogs(options);
+  });
+
+program
+  .command("report")
+  .description("Report a bug on GitHub (pre-fills env info + logs)")
   .action(async () => {
+    const { reportBug } = await import("./cli/commands/report.ts");
+    await reportBug();
+  });
+
+program
+  .command("init")
+  .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");