@hienlh/ppm 0.7.28 → 0.7.30

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.7.30] - 2026-03-23
+
+### Fixed
+- **Restart from PPM terminal**: worker and restart command now ignore SIGHUP — killing the old server destroys the terminal PTY which sends SIGHUP to the process group, previously killing the worker before it could spawn the new server
+
+## [0.7.29] - 2026-03-22
+
+### Added
+- **Auto-start on boot**: `ppm autostart enable/disable/status` registers PPM to start automatically via OS-native mechanisms — macOS launchd, Linux systemd, Windows Registry Run key
+- **Cross-platform support**: auto-detects compiled binary vs bun runtime, resolves paths correctly on all platforms
+- **VBScript hidden wrapper**: Windows auto-start runs PPM without visible console window
+- **GitHub Actions CI**: test matrix for macOS, Linux, and Windows with unit + integration tests
+
+### Technical
+- 2-layer architecture: generator (pure functions, testable) + register (OS interaction)
+- 40 unit tests + 20 integration tests (platform-specific with `describe.if`)
+- KeepAlive/Restart-on-failure for crash recovery on all platforms
+
 ## [0.7.28] - 2026-03-22
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.7.28",
+  "version": "0.7.30",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "MIT",

package/src/cli/commands/autostart.ts

@@ -0,0 +1,94 @@
+import type { Command } from "commander";
+import { configService } from "../../services/config.service.ts";
+
+export function registerAutoStartCommands(program: Command): void {
+  const cmd = program
+    .command("autostart")
+    .description("Manage auto-start on boot (enable/disable/status)");
+
+  cmd
+    .command("enable")
+    .description("Register PPM to start automatically on boot")
+    .option("-p, --port <port>", "Override port")
+    .option("-s, --share", "Enable Cloudflare tunnel on boot")
+    .option("-c, --config <path>", "Config file path")
+    .option("--profile <name>", "DB profile name")
+    .action(async (options) => {
+      const { enableAutoStart } = await import("../../services/autostart-register.ts");
+
+      configService.load(options.config);
+      const port = parseInt(options.port ?? String(configService.get("port")), 10);
+      const host = configService.get("host") ?? "0.0.0.0";
+
+      const config = {
+        port,
+        host,
+        share: !!options.share,
+        configPath: options.config,
+        profile: options.profile,
+      };
+
+      try {
+        console.log("  Registering auto-start...\n");
+        const servicePath = await enableAutoStart(config);
+        console.log(`  ✓  Auto-start enabled`);
+        console.log(`     Service: ${servicePath}`);
+        console.log(`     Port: ${port}`);
+        if (options.share) console.log(`     Tunnel: enabled`);
+        console.log(`\n  PPM will start automatically on boot.`);
+
+        if (process.platform === "darwin") {
+          console.log(`\n  Note: On macOS Ventura+, you may need to allow PPM in`);
+          console.log(`  System Settings > General > Login Items.`);
+        }
+        if (process.platform === "linux") {
+          console.log(`\n  Note: 'loginctl enable-linger' was called to allow`);
+          console.log(`  boot-time start without login.`);
+        }
+        console.log();
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  ✗  Failed to enable auto-start: ${msg}\n`);
+        process.exit(1);
+      }
+    });
+
+  cmd
+    .command("disable")
+    .description("Remove PPM auto-start registration")
+    .action(async () => {
+      const { disableAutoStart } = await import("../../services/autostart-register.ts");
+
+      try {
+        await disableAutoStart();
+        console.log("  ✓  Auto-start disabled. PPM will no longer start on boot.\n");
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  ✗  Failed to disable auto-start: ${msg}\n`);
+        process.exit(1);
+      }
+    });
+
+  cmd
+    .command("status")
+    .description("Show auto-start status")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const { getAutoStartStatus } = await import("../../services/autostart-register.ts");
+
+      const status = getAutoStartStatus();
+
+      if (options.json) {
+        console.log(JSON.stringify(status));
+        return;
+      }
+
+      console.log(`\n  Auto-start status\n`);
+      console.log(`  Platform:  ${status.platform}`);
+      console.log(`  Enabled:   ${status.enabled ? "yes" : "no"}`);
+      console.log(`  Running:   ${status.running ? "yes" : "no"}`);
+      if (status.servicePath) console.log(`  Service:   ${status.servicePath}`);
+      console.log(`  Details:   ${status.details}`);
+      console.log();
+    });
+}

package/src/cli/commands/restart.ts

@@ -10,6 +10,9 @@ const RESTART_RESULT = resolve(PPM_DIR, ".restart-result");
 
 /** Restart only the server process, keeping the tunnel alive */
 export async function restartServer(options: { config?: string }) {
+  // Ignore SIGHUP so this process survives when PPM terminal dies
+  process.on("SIGHUP", () => {});
+
   if (!existsSync(STATUS_FILE)) {
     console.log("No PPM daemon running. Use 'ppm start' instead.");
     process.exit(1);
@@ -51,7 +54,8 @@ export async function restartServer(options: { config?: string }) {
   console.log("  If you're using PPM terminal, wait a few seconds then reload the page.\n");
 
   // Generate a self-contained restart worker script.
-  // Runs as a detached process so it survives when the PPM server (and its terminals) die.
+  // Worker ignores SIGHUP so it survives when killing the server causes the
+  // terminal (and its process group) to receive SIGHUP.
   const params = JSON.stringify({
     serverPid, port, host, serverScript,
     config: options.config ?? "",
@@ -67,6 +71,11 @@ export async function restartServer(options: { config?: string }) {
 import { readFileSync, writeFileSync, openSync, unlinkSync, appendFileSync } from "node:fs";
 import { createServer } from "node:net";
 
+// Ignore SIGHUP — when we kill the old server, the terminal PTY dies and
+// SIGHUP is sent to the entire process group. Without this, the worker
+// would be killed before it can spawn the new server.
+process.on("SIGHUP", () => {});
+
 const P = ${params};
 
 async function main() {
@@ -163,7 +172,8 @@ main();
 `);
 
   // Spawn worker as a fully detached process
-  const logFd = openSync(resolve(PPM_DIR, "ppm.log"), "a");
+  const logFile = resolve(PPM_DIR, "ppm.log");
+  const logFd = openSync(logFile, "a");
   const worker = Bun.spawn({
     cmd: [process.execPath, "run", workerPath],
     stdio: ["ignore", logFd, logFd],
@@ -171,9 +181,8 @@ main();
   });
   worker.unref();
 
-  // Poll for result — if running from external terminal, we'll see the result.
-  // If running from PPM terminal, this process dies when server is killed — that's fine,
-  // the user already saw the pre-restart message above.
+  // Poll for result — works from both PPM terminal (SIGHUP-immune) and external terminal.
+  // Output may not be visible if PPM terminal PTY is dead, but process stays alive.
   const pollStart = Date.now();
   while (Date.now() - pollStart < 20000) {
     await Bun.sleep(500);

package/src/index.ts

@@ -121,4 +121,7 @@ registerGitCommands(program);
 const { registerChatCommands } = await import("./cli/commands/chat-cmd.ts");
 registerChatCommands(program);
 
+const { registerAutoStartCommands } = await import("./cli/commands/autostart.ts");
+registerAutoStartCommands(program);
+
 program.parse();

package/src/services/autostart-generator.ts

@@ -0,0 +1,213 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+
+export interface AutoStartConfig {
+  port: number;
+  host: string;
+  share: boolean;
+  configPath?: string;
+  profile?: string;
+}
+
+/** Detect whether running from compiled binary or bun runtime */
+export function isCompiledBinary(): boolean {
+  // Compiled Bun binaries don't have "bun" in execPath
+  return !process.execPath.includes("bun");
+}
+
+/** Resolve the absolute path to the bun binary */
+export function resolveBunPath(): string {
+  // 1. Current process is bun itself
+  if (process.execPath.includes("bun")) return process.execPath;
+
+  // 2. Check ~/.bun/bin/bun
+  const home = homedir();
+  const bunHome = resolve(home, ".bun", "bin", "bun");
+  try {
+    const { existsSync } = require("node:fs") as typeof import("node:fs");
+    if (existsSync(bunHome)) return bunHome;
+  } catch {}
+
+  // 3. Check PATH via which/where
+  try {
+    const cmd = process.platform === "win32" ? ["where", "bun"] : ["which", "bun"];
+    const result = Bun.spawnSync({ cmd, stdout: "pipe", stderr: "ignore" });
+    const path = result.stdout.toString().trim().split("\n")[0];
+    if (path) return path;
+  } catch {}
+
+  throw new Error("Could not resolve bun binary. Install Bun or add it to PATH.");
+}
+
+/** Build the command array for the PPM server process */
+export function buildExecCommand(config: AutoStartConfig): string[] {
+  if (isCompiledBinary()) {
+    // Compiled binary: just run self with __serve__ args
+    const args = [process.execPath, "__serve__", String(config.port), config.host];
+    if (config.configPath) args.push(config.configPath);
+    if (config.profile) args.push(config.profile);
+    return args;
+  }
+
+  // Bun runtime: bun run <script> __serve__ <port> <host> [config] [profile]
+  const bunPath = resolveBunPath();
+  const scriptPath = resolve(import.meta.dir, "..", "server", "index.ts");
+  const args = [bunPath, "run", scriptPath, "__serve__", String(config.port), config.host];
+  if (config.configPath) args.push(config.configPath);
+  else args.push(""); // placeholder
+  if (config.profile) args.push(config.profile);
+  else args.push(""); // placeholder
+  return args;
+}
+
+// ─── macOS launchd plist ────────────────────────────────────────────────
+
+const PLIST_LABEL = "com.hienlh.ppm";
+
+export function getPlistPath(): string {
+  return resolve(homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+}
+
+/** Generate macOS launchd plist XML content */
+export function generatePlist(config: AutoStartConfig): string {
+  const cmd = buildExecCommand(config);
+  const logPath = resolve(homedir(), ".ppm", "ppm-launchd.log");
+
+  const programArgs = cmd
+    .map((arg) => `        <string>${escapeXml(arg)}</string>`)
+    .join("\n");
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgs}
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${escapeXml(logPath)}</string>
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(logPath)}</string>
+    <key>WorkingDirectory</key>
+    <string>${escapeXml(resolve(homedir(), ".ppm"))}</string>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+</dict>
+</plist>
+`;
+}
+
+// ─── Linux systemd service ──────────────────────────────────────────────
+
+export function getServicePath(): string {
+  return resolve(homedir(), ".config", "systemd", "user", "ppm.service");
+}
+
+/** Generate Linux systemd user service file content */
+export function generateSystemdService(config: AutoStartConfig): string {
+  const cmd = buildExecCommand(config);
+  const execStart = cmd.map(shellEscape).join(" ");
+  const bunDir = isCompiledBinary() ? "" : resolve(resolveBunPath(), "..");
+
+  // Build PATH with bun directory prepended
+  const envPath = bunDir
+    ? `Environment="PATH=${bunDir}:/usr/local/bin:/usr/bin:/bin"`
+    : "";
+
+  return `[Unit]
+Description=PPM - Personal Project Manager
+Documentation=https://github.com/hienlh/ppm
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+Restart=on-failure
+RestartSec=5
+${envPath}
+WorkingDirectory=${homedir()}/.ppm
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+// ─── Windows Registry Run key ───────────────────────────────────────────
+// Uses HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run — no admin needed
+
+const TASK_NAME = "PPM";
+const WIN_REG_KEY = "HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run";
+
+/** Generate Windows VBScript wrapper content to run PPM hidden */
+export function generateVbsWrapper(config: AutoStartConfig): string {
+  const cmd = buildExecCommand(config);
+  const exe = cmd[0]!;
+  const args = cmd.slice(1).join(" ");
+  return `Set objShell = CreateObject("WScript.Shell")
+objShell.Run """${exe.replace(/\\/g, "\\\\")}""` +
+    ` ${args.replace(/"/g, '""')}", 0, False
+`;
+}
+
+export function getVbsPath(): string {
+  return resolve(homedir(), ".ppm", "run-ppm.vbs");
+}
+
+/** Build reg command to add PPM to Windows startup (no admin) */
+export function buildRegAddCommand(vbsPath: string): string[] {
+  return [
+    "reg", "add", WIN_REG_KEY,
+    "/v", TASK_NAME,
+    "/t", "REG_SZ",
+    "/d", `cscript.exe "${vbsPath}"`,
+    "/f",
+  ];
+}
+
+/** Build reg command to remove PPM from Windows startup */
+export function buildRegDeleteCommand(): string[] {
+  return [
+    "reg", "delete", WIN_REG_KEY,
+    "/v", TASK_NAME,
+    "/f",
+  ];
+}
+
+/** Build reg command to query PPM startup entry */
+export function buildRegQueryCommand(): string[] {
+  return [
+    "reg", "query", WIN_REG_KEY,
+    "/v", TASK_NAME,
+  ];
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────
+
+/** Escape special XML characters */
+function escapeXml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+/** Escape a string for shell usage (wrap in quotes if contains spaces) */
+function shellEscape(s: string): string {
+  if (/["\s]/.test(s)) return `"${s.replace(/"/g, '\\"')}"`;
+  return s;
+}
+
+export { PLIST_LABEL, TASK_NAME };

package/src/services/autostart-register.ts

@@ -0,0 +1,348 @@
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import {
+  type AutoStartConfig,
+  PLIST_LABEL,
+  TASK_NAME,
+  generatePlist,
+  getPlistPath,
+  generateSystemdService,
+  getServicePath,
+  generateVbsWrapper,
+  getVbsPath,
+  buildRegAddCommand,
+  buildRegDeleteCommand,
+  buildRegQueryCommand,
+} from "./autostart-generator.ts";
+
+export interface AutoStartStatus {
+  enabled: boolean;
+  running: boolean;
+  platform: string;
+  servicePath: string | null;
+  details: string;
+}
+
+const METADATA_FILE = resolve(homedir(), ".ppm", "autostart.json");
+
+interface AutoStartMetadata {
+  enabled: boolean;
+  platform: string;
+  servicePath: string;
+  createdAt: string;
+  config: AutoStartConfig;
+}
+
+/** Save autostart metadata to ~/.ppm/autostart.json */
+function saveMetadata(meta: AutoStartMetadata): void {
+  const dir = dirname(METADATA_FILE);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(METADATA_FILE, JSON.stringify(meta, null, 2));
+}
+
+/** Load autostart metadata */
+function loadMetadata(): AutoStartMetadata | null {
+  try {
+    if (!existsSync(METADATA_FILE)) return null;
+    return JSON.parse(readFileSync(METADATA_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Remove autostart metadata file */
+function removeMetadata(): void {
+  try {
+    if (existsSync(METADATA_FILE)) unlinkSync(METADATA_FILE);
+  } catch {}
+}
+
+// ─── macOS ──────────────────────────────────────────────────────────────
+
+async function enableMacOS(config: AutoStartConfig): Promise<string> {
+  const plistPath = getPlistPath();
+  const plistDir = dirname(plistPath);
+
+  if (!existsSync(plistDir)) mkdirSync(plistDir, { recursive: true });
+  writeFileSync(plistPath, generatePlist(config));
+
+  // Unload first if already loaded (ignore errors)
+  Bun.spawnSync({
+    cmd: ["launchctl", "bootout", `gui/${process.getuid!()}`, plistPath],
+    stdout: "ignore", stderr: "ignore",
+  });
+
+  // Load the agent
+  const result = Bun.spawnSync({
+    cmd: ["launchctl", "bootstrap", `gui/${process.getuid!()}`, plistPath],
+    stdout: "pipe", stderr: "pipe",
+  });
+
+  if (result.exitCode !== 0) {
+    // Fallback to legacy syntax
+    const legacy = Bun.spawnSync({
+      cmd: ["launchctl", "load", plistPath],
+      stdout: "pipe", stderr: "pipe",
+    });
+    if (legacy.exitCode !== 0) {
+      const err = legacy.stderr.toString().trim();
+      throw new Error(`launchctl load failed: ${err}`);
+    }
+  }
+
+  saveMetadata({
+    enabled: true,
+    platform: "darwin",
+    servicePath: plistPath,
+    createdAt: new Date().toISOString(),
+    config,
+  });
+
+  return plistPath;
+}
+
+async function disableMacOS(): Promise<void> {
+  const plistPath = getPlistPath();
+
+  // Unload
+  Bun.spawnSync({
+    cmd: ["launchctl", "bootout", `gui/${process.getuid!()}`, plistPath],
+    stdout: "ignore", stderr: "ignore",
+  });
+  // Legacy fallback
+  Bun.spawnSync({
+    cmd: ["launchctl", "unload", plistPath],
+    stdout: "ignore", stderr: "ignore",
+  });
+
+  // Remove plist file
+  try { if (existsSync(plistPath)) unlinkSync(plistPath); } catch {}
+  removeMetadata();
+}
+
+function statusMacOS(): AutoStartStatus {
+  const plistPath = getPlistPath();
+  const fileExists = existsSync(plistPath);
+
+  // Check if loaded
+  const result = Bun.spawnSync({
+    cmd: ["launchctl", "list"],
+    stdout: "pipe", stderr: "ignore",
+  });
+  const output = result.stdout.toString();
+  const isLoaded = output.includes(PLIST_LABEL);
+
+  return {
+    enabled: fileExists && isLoaded,
+    running: isLoaded,
+    platform: "darwin (launchd)",
+    servicePath: fileExists ? plistPath : null,
+    details: fileExists
+      ? isLoaded ? "Loaded and enabled" : "Plist exists but not loaded"
+      : "Not configured",
+  };
+}
+
+// ─── Linux ──────────────────────────────────────────────────────────────
+
+async function enableLinux(config: AutoStartConfig): Promise<string> {
+  const servicePath = getServicePath();
+  const serviceDir = dirname(servicePath);
+
+  if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
+  writeFileSync(servicePath, generateSystemdService(config));
+
+  // Reload daemon
+  const reload = Bun.spawnSync({
+    cmd: ["systemctl", "--user", "daemon-reload"],
+    stdout: "ignore", stderr: "pipe",
+  });
+  if (reload.exitCode !== 0) {
+    throw new Error(`systemctl daemon-reload failed: ${reload.stderr.toString().trim()}`);
+  }
+
+  // Enable
+  const enable = Bun.spawnSync({
+    cmd: ["systemctl", "--user", "enable", "ppm.service"],
+    stdout: "pipe", stderr: "pipe",
+  });
+  if (enable.exitCode !== 0) {
+    throw new Error(`systemctl enable failed: ${enable.stderr.toString().trim()}`);
+  }
+
+  // Start
+  Bun.spawnSync({
+    cmd: ["systemctl", "--user", "start", "ppm.service"],
+    stdout: "ignore", stderr: "ignore",
+  });
+
+  // Enable lingering so service runs at boot without login
+  Bun.spawnSync({
+    cmd: ["loginctl", "enable-linger", process.env.USER || ""],
+    stdout: "ignore", stderr: "ignore",
+  });
+
+  saveMetadata({
+    enabled: true,
+    platform: "linux",
+    servicePath,
+    createdAt: new Date().toISOString(),
+    config,
+  });
+
+  return servicePath;
+}
+
+async function disableLinux(): Promise<void> {
+  // Stop + disable
+  Bun.spawnSync({
+    cmd: ["systemctl", "--user", "stop", "ppm.service"],
+    stdout: "ignore", stderr: "ignore",
+  });
+  Bun.spawnSync({
+    cmd: ["systemctl", "--user", "disable", "ppm.service"],
+    stdout: "ignore", stderr: "ignore",
+  });
+
+  // Remove service file
+  const servicePath = getServicePath();
+  try { if (existsSync(servicePath)) unlinkSync(servicePath); } catch {}
+
+  // Reload
+  Bun.spawnSync({
+    cmd: ["systemctl", "--user", "daemon-reload"],
+    stdout: "ignore", stderr: "ignore",
+  });
+
+  removeMetadata();
+}
+
+function statusLinux(): AutoStartStatus {
+  const servicePath = getServicePath();
+  const fileExists = existsSync(servicePath);
+
+  // Check enabled
+  const enabled = Bun.spawnSync({
+    cmd: ["systemctl", "--user", "is-enabled", "ppm.service"],
+    stdout: "pipe", stderr: "ignore",
+  });
+  const isEnabled = enabled.stdout.toString().trim() === "enabled";
+
+  // Check active
+  const active = Bun.spawnSync({
+    cmd: ["systemctl", "--user", "is-active", "ppm.service"],
+    stdout: "pipe", stderr: "ignore",
+  });
+  const isActive = active.stdout.toString().trim() === "active";
+
+  return {
+    enabled: isEnabled,
+    running: isActive,
+    platform: "linux (systemd)",
+    servicePath: fileExists ? servicePath : null,
+    details: !fileExists
+      ? "Not configured"
+      : isEnabled && isActive ? "Enabled and running"
+      : isEnabled ? "Enabled but not running"
+      : "Service file exists but not enabled",
+  };
+}
+
+// ─── Windows ────────────────────────────────────────────────────────────
+
+async function enableWindows(config: AutoStartConfig): Promise<string> {
+  const vbsPath = getVbsPath();
+  const vbsDir = dirname(vbsPath);
+
+  if (!existsSync(vbsDir)) mkdirSync(vbsDir, { recursive: true });
+  writeFileSync(vbsPath, generateVbsWrapper(config));
+
+  // Add to HKCU Run key (no admin required)
+  const cmd = buildRegAddCommand(vbsPath);
+  const result = Bun.spawnSync({ cmd, stdout: "pipe", stderr: "pipe" });
+
+  if (result.exitCode !== 0) {
+    const err = result.stderr.toString().trim();
+    throw new Error(`Registry add failed: ${err}`);
+  }
+
+  saveMetadata({
+    enabled: true,
+    platform: "win32",
+    servicePath: vbsPath,
+    createdAt: new Date().toISOString(),
+    config,
+  });
+
+  return vbsPath;
+}
+
+async function disableWindows(): Promise<void> {
+  // Remove from registry
+  const cmd = buildRegDeleteCommand();
+  Bun.spawnSync({ cmd, stdout: "ignore", stderr: "ignore" });
+
+  // Remove VBS wrapper
+  const vbsPath = getVbsPath();
+  try { if (existsSync(vbsPath)) unlinkSync(vbsPath); } catch {}
+
+  removeMetadata();
+}
+
+function statusWindows(): AutoStartStatus {
+  const vbsPath = getVbsPath();
+  const fileExists = existsSync(vbsPath);
+
+  // Check if registry entry exists
+  const cmd = buildRegQueryCommand();
+  const result = Bun.spawnSync({ cmd, stdout: "pipe", stderr: "ignore" });
+  const regExists = result.exitCode === 0 && result.stdout.toString().includes(TASK_NAME);
+
+  return {
+    enabled: regExists,
+    running: false, // Can't detect running state from registry
+    platform: "windows (Registry Run)",
+    servicePath: fileExists ? vbsPath : null,
+    details: regExists
+      ? "Registered (will run at next logon)"
+      : "Not configured",
+  };
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────
+
+/** Enable auto-start for the current platform */
+export async function enableAutoStart(config: AutoStartConfig): Promise<string> {
+  const platform = process.platform;
+  if (platform === "darwin") return enableMacOS(config);
+  if (platform === "linux") return enableLinux(config);
+  if (platform === "win32") return enableWindows(config);
+  throw new Error(`Auto-start not supported on ${platform}`);
+}
+
+/** Disable auto-start for the current platform */
+export async function disableAutoStart(): Promise<void> {
+  const platform = process.platform;
+  if (platform === "darwin") return disableMacOS();
+  if (platform === "linux") return disableLinux();
+  if (platform === "win32") return disableWindows();
+  throw new Error(`Auto-start not supported on ${platform}`);
+}
+
+/** Get auto-start status for the current platform */
+export function getAutoStartStatus(): AutoStartStatus {
+  const platform = process.platform;
+  if (platform === "darwin") return statusMacOS();
+  if (platform === "linux") return statusLinux();
+  if (platform === "win32") return statusWindows();
+  return {
+    enabled: false,
+    running: false,
+    platform: `${platform} (unsupported)`,
+    servicePath: null,
+    details: `Auto-start not supported on ${platform}`,
+  };
+}
+
+export { loadMetadata, METADATA_FILE };

package/test-claude-oauth-v2.mjs

@@ -1,165 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Claude OAuth PKCE test — fixed version
- *
- * Fixes vs v1:
- *   1. Token endpoint: console.anthropic.com (not api.anthropic.com)
- *   2. Content-Type: application/x-www-form-urlencoded (not JSON)
- *   3. Removed `state` from token exchange body (client-side CSRF only)
- *   4. Only platform.claude.com redirect (confirmed to work with this client_id)
- *
- * Usage: bun test-claude-oauth-v2.mjs
- */
-
-import crypto from 'crypto'
-import readline from 'readline'
-import { execSync } from 'child_process'
-
-const CLIENT_ID   = '9d1c250a-e61b-44d9-88ed-5944d1962f5e'
-const REDIRECT    = 'https://platform.claude.com/oauth/code/callback'
-const SCOPE       = 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload'
-const TOKEN_URL   = 'https://console.anthropic.com/v1/oauth/token'
-
-// ── PKCE ────────────────────────────────────────────────────────────────────
-
-function generatePKCE() {
-  // 32 random bytes → 43 base64url chars (RFC 7636 minimum entropy)
-  const verifier  = crypto.randomBytes(32).toString('base64url')
-  const challenge = crypto.createHash('sha256').update(verifier).digest('base64url')
-  const state     = crypto.randomBytes(16).toString('base64url')
-  return { verifier, challenge, state }
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-function copyToClipboard(text) {
-  try { execSync(`echo ${JSON.stringify(text)} | pbcopy`); return true }
-  catch { return false }
-}
-
-function ask(rl, question) {
-  return new Promise(resolve => rl.question(question, resolve))
-}
-
-function parseCode(input) {
-  input = input.trim()
-  // Full URL
-  try {
-    const url  = new URL(input)
-    const code = url.searchParams.get('code')
-    if (code) return code.split('#')[0]
-  } catch {}
-  // platform.claude.com format: CODE#STATE
-  if (input.includes('#')) return input.split('#')[0]
-  // raw code
-  return input.split('?')[0].split('&')[0]
-}
-
-// ── Token exchange ───────────────────────────────────────────────────────────
-
-async function exchangeCode({ code, verifier }) {
-  console.log(`\nPOST ${TOKEN_URL}`)
-
-  const body = new URLSearchParams({
-    grant_type:    'authorization_code',
-    client_id:     CLIENT_ID,
-    code,
-    redirect_uri:  REDIRECT,
-    code_verifier: verifier,
-  })
-
-  const res  = await fetch(TOKEN_URL, {
-    method:  'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-      'Accept':        'application/json',
-    },
-    body,
-  })
-
-  const data = await res.json()
-  return { ok: res.ok, status: res.status, data }
-}
-
-// ── Main ─────────────────────────────────────────────────────────────────────
-
-const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-
-console.log('\n╔══════════════════════════════════════════╗')
-console.log('║   Claude OAuth PKCE Test — v2 (fixed)   ║')
-console.log('╚══════════════════════════════════════════╝\n')
-
-const { verifier, challenge, state } = generatePKCE()
-
-console.log(`verifier  (${verifier.length} chars): ${verifier.slice(0, 20)}...`)
-console.log(`challenge (${challenge.length} chars): ${challenge}`)
-console.log(`state     (${state.length}  chars): ${state}\n`)
-
-// Build auth URL — code=true tells claude.ai to show a code page instead of redirecting
-const params = new URLSearchParams({
-  code:                  'true',
-  client_id:             CLIENT_ID,
-  response_type:         'code',
-  redirect_uri:          REDIRECT,
-  scope:                 SCOPE,
-  code_challenge:        challenge,
-  code_challenge_method: 'S256',
-  state,
-})
-const authUrl = `https://claude.ai/oauth/authorize?${params}`
-
-console.log('┌─ Authorization URL ──────────────────────────────────────────────')
-console.log(`│ ${authUrl}`)
-console.log('└─────────────────────────────────────────────────────────────────\n')
-
-const copied = copyToClipboard(authUrl)
-if (copied) console.log('✓ Copied to clipboard\n')
-
-console.log('1. Mở URL trong browser')
-console.log('2. Login / approve')
-console.log('3. platform.claude.com sẽ hiển thị code dạng: XXXX#STATE\n')
-
-const input = await ask(rl, 'Paste code/URL: ')
-const code  = parseCode(input)
-
-if (!code) {
-  console.error('❌ Không parse được code')
-  rl.close()
-  process.exit(1)
-}
-
-console.log(`\n✓ code = ${code.slice(0, 30)}...`)
-
-// Validate state (CSRF check — client-side only, not sent to server)
-const returnedState = input.includes('#') ? input.split('#')[1]?.split('&')[0] : null
-if (returnedState && returnedState !== state) {
-  console.warn(`⚠️  State mismatch! Expected: ${state}, Got: ${returnedState}`)
-} else if (returnedState) {
-  console.log(`✓ state OK`)
-}
-
-console.log('\nExchanging code for token...')
-const { ok, status, data } = await exchangeCode({ code, verifier })
-
-console.log(`\nHTTP ${status}`)
-
-if (ok) {
-  console.log('\n✅ SUCCESS!')
-  console.log('─'.repeat(50))
-  console.log(`access_token:  ${(data.access_token ?? data.accessToken)?.slice(0, 35)}...`)
-  console.log(`refresh_token: ${(data.refresh_token ?? data.refreshToken)?.slice(0, 35)}...`)
-  console.log(`token_type:    ${data.token_type}`)
-  console.log(`expires_in:    ${data.expires_in}s`)
-  if (data.account) {
-    console.log(`email:         ${data.account.email_address}`)
-    console.log(`account_uuid:  ${data.account.uuid}`)
-  }
-  console.log('─'.repeat(50))
-  console.log('\nFull response:')
-  console.log(JSON.stringify(data, null, 2))
-} else {
-  console.log('\n❌ FAILED')
-  console.log(JSON.stringify(data, null, 2))
-}
-
-rl.close()

package/test-claude-oauth.mjs

@@ -1,175 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Test Claude OAuth flow — manual copy/paste approach
- * Usage: bun test-claude-oauth.mjs
- */
-
-import crypto from 'crypto'
-import readline from 'readline'
-import { execSync } from 'child_process'
-
-const CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e'
-const SCOPE = 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload'
-
-// Redirect URIs to test (in order)
-const REDIRECT_URI_OPTIONS = [
-  { label: 'platform.claude.com (manual code page)', uri: 'https://platform.claude.com/oauth/code/callback' },
-  { label: 'localhost:54545 (CLIProxyAPI style)',     uri: 'http://localhost:54545/callback' },
-  { label: 'localhost (no port)',                     uri: 'http://localhost/callback' },
-]
-
-// Token endpoints to try
-const TOKEN_ENDPOINTS = [
-  'https://api.anthropic.com/v1/oauth/token',
-  'https://claude.ai/api/oauth/token',
-]
-
-// ── PKCE ────────────────────────────────────────────────────────────────────
-
-function generatePKCE() {
-  // 96 bytes → 128 base64url chars (matches CLIProxyAPI exactly)
-  const verifierBytes = crypto.randomBytes(96)
-  const verifier = verifierBytes.toString('base64url')
-  const challenge = crypto.createHash('sha256').update(verifier).digest('base64url')
-  const state = crypto.randomBytes(16).toString('base64url')
-  return { verifier, challenge, state }
-}
-
-// ── CLI helpers ──────────────────────────────────────────────────────────────
-
-function copyToClipboard(text) {
-  try {
-    execSync(`echo ${JSON.stringify(text)} | pbcopy`)
-    return true
-  } catch { return false }
-}
-
-function ask(rl, question) {
-  return new Promise(resolve => rl.question(question, resolve))
-}
-
-function parseCode(input) {
-  input = input.trim()
-  // Full URL: http://localhost/callback?code=XXX&state=YYY
-  try {
-    const url = new URL(input)
-    const code = url.searchParams.get('code')
-    if (code) return code.split('#')[0]
-  } catch {}
-  // code#state format (platform.claude.com)
-  if (input.includes('#')) return input.split('#')[0]
-  // Raw code
-  return input.split('?')[0].split('&')[0]
-}
-
-// ── Token exchange ───────────────────────────────────────────────────────────
-
-async function exchangeCode({ code, verifier, state, redirectUri }) {
-  const body = {
-    grant_type:    'authorization_code',
-    client_id:     CLIENT_ID,
-    code,
-    redirect_uri:  redirectUri,
-    code_verifier: verifier,
-    state,
-  }
-
-  for (const endpoint of TOKEN_ENDPOINTS) {
-    process.stdout.write(`  → POST ${endpoint} ... `)
-    const res = await fetch(endpoint, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
-      body: JSON.stringify(body),
-    })
-    const data = await res.json()
-    console.log(`HTTP ${res.status}`)
-
-    if (res.ok) return { endpoint, data }
-    console.log(`     error: ${JSON.stringify(data?.error || data)}`)
-  }
-  return null
-}
-
-// ── Main ─────────────────────────────────────────────────────────────────────
-
-const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-
-console.log('\n╔══════════════════════════════════════════╗')
-console.log('║     Claude OAuth Test — PPM              ║')
-console.log('╚══════════════════════════════════════════╝\n')
-
-// Pick redirect URI
-console.log('Redirect URI options:')
-REDIRECT_URI_OPTIONS.forEach((o, i) => console.log(`  ${i + 1}. ${o.label}`))
-const choice = parseInt(await ask(rl, '\nChọn (1-3) [default: 1]: ') || '1') - 1
-const { uri: redirectUri, label } = REDIRECT_URI_OPTIONS[choice] || REDIRECT_URI_OPTIONS[0]
-console.log(`✓ Using: ${redirectUri}\n`)
-
-// Generate PKCE + URL
-const { verifier, challenge, state } = generatePKCE()
-console.log(`code_verifier length: ${verifier.length} chars`)
-
-const params = new URLSearchParams({
-  client_id:             CLIENT_ID,
-  response_type:         'code',
-  redirect_uri:          redirectUri,
-  scope:                 SCOPE,
-  code_challenge:        challenge,
-  code_challenge_method: 'S256',
-  state,
-  prompt:                'login',
-})
-// platform.claude.com redirect uses special `code=true` trigger
-if (redirectUri.includes('platform.claude.com')) {
-  params.set('code', 'true')
-}
-const authUrl = `https://claude.ai/oauth/authorize?${params}`
-
-console.log('\n┌─ Authorization URL ──────────────────────────────────────────────')
-console.log(`│ ${authUrl}`)
-console.log('└─────────────────────────────────────────────────────────────────\n')
-
-const copied = copyToClipboard(authUrl)
-if (copied) console.log('✓ Copied to clipboard (pbcopy)\n')
-
-console.log('Mở URL trong browser → authorize → copy code/URL trả về\n')
-if (label.includes('platform')) {
-  console.log('  platform.claude.com sẽ hiện code dạng: XXXX#STATE')
-} else {
-  console.log('  Browser sẽ redirect về localhost (lỗi kết nối là bình thường)')
-  console.log('  Copy toàn bộ URL từ address bar: http://localhost.../callback?code=XXX')
-}
-
-const input = await ask(rl, '\nPaste code/URL: ')
-const code = parseCode(input)
-if (!code) { console.error('❌ Không parse được code'); process.exit(1) }
-console.log(`✓ code = ${code.slice(0, 20)}...\n`)
-
-// Exchange
-console.log('Thử exchange token:')
-const result = await exchangeCode({ code, verifier, state, redirectUri })
-
-if (result) {
-  const { endpoint, data } = result
-  console.log(`\n✅ Success! Endpoint: ${endpoint}`)
-  console.log('\n── Token info ──────────────────────────────────────')
-  console.log(`  access_token:  ${data.access_token?.slice(0, 30)}...`)
-  console.log(`  refresh_token: ${data.refresh_token?.slice(0, 30)}...`)
-  console.log(`  token_type:    ${data.token_type}`)
-  console.log(`  expires_in:    ${data.expires_in}s`)
-  if (data.account) {
-    console.log(`  email:         ${data.account.email_address}`)
-    console.log(`  account_uuid:  ${data.account.uuid}`)
-  }
-  if (data.organization) {
-    console.log(`  org_name:      ${data.organization.name}`)
-    console.log(`  org_uuid:      ${data.organization.uuid}`)
-  }
-  console.log('────────────────────────────────────────────────────')
-  console.log('\nFull response:')
-  console.log(JSON.stringify(data, null, 2))
-} else {
-  console.log('\n❌ Tất cả endpoints đều fail')
-}
-
-rl.close()

package/test-verify-oat.mjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Test verify sk-ant-oat token — see what APIs return
- * Usage: bun test-verify-oat.mjs [TOKEN]
- * If no TOKEN arg, reads TEST_OAUTH_TOKEN_1 from .env.test
- */
-
-import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dir = dirname(fileURLToPath(import.meta.url));
-
-// Token from CLI arg or .env.test
-let token = process.argv[2];
-if (!token) {
-  const envPath = resolve(__dir, ".env.test");
-  const env = Object.fromEntries(
-    readFileSync(envPath, "utf-8")
-      .split("\n")
-      .filter((l) => l && !l.startsWith("#"))
-      .map((l) => l.split("=").map((s) => s.trim()))
-      .filter(([k, v]) => k && v),
-  );
-  token = env.TEST_OAUTH_TOKEN_1;
-}
-
-if (!token || token.startsWith("REPLACE")) {
-  console.error("Usage: bun test-verify-oat.mjs [TOKEN]");
-  process.exit(1);
-}
-
-console.log(`Token: ${token.slice(0, 30)}...`);
-
-// ── Helper ──────────────────────────────────────────────
-async function tryEndpoint({ label, url, method = "GET", headers = {}, body }) {
-  console.log(`\n── ${label} ──`);
-  try {
-    const opts = {
-      method,
-      headers: {
-        Accept: "application/json",
-        Authorization: `Bearer ${token}`,
-        ...headers,
-      },
-      signal: AbortSignal.timeout(10_000),
-    };
-    if (body) opts.body = typeof body === "string" ? body : JSON.stringify(body);
-    const res = await fetch(url, opts);
-    const text = await res.text();
-    console.log(`HTTP ${res.status}`);
-    try {
-      console.log(JSON.stringify(JSON.parse(text), null, 2));
-    } catch {
-      console.log(text.slice(0, 500));
-    }
-  } catch (e) {
-    console.log(`ERROR: ${e.message}`);
-  }
-}
-
-// ── 1. claude auth status (CLI) ─────────────────────────
-console.log("\n── claude auth status (CLI) ──");
-try {
-  const proc = Bun.spawn(["claude", "auth", "status"], {
-    env: { ...process.env, CLAUDE_CODE_OAUTH_TOKEN: token, ANTHROPIC_API_KEY: "" },
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  await proc.exited;
-  console.log("stdout:", stdout);
-  if (stderr) console.log("stderr:", stderr);
-} catch (e) {
-  console.log(`ERROR: ${e.message}`);
-}
-
-// ── 2. /api/oauth/usage ─────────────────────────────────
-await tryEndpoint({
-  label: "GET /api/oauth/usage",
-  url: "https://api.anthropic.com/api/oauth/usage",
-  headers: { "anthropic-beta": "oauth-2025-04-20", "User-Agent": "ppm/1.0" },
-});
-
-// ── 3. /v1/organizations (org info) ─────────────────────
-await tryEndpoint({
-  label: "GET /v1/organizations",
-  url: "https://api.anthropic.com/v1/organizations",
-  headers: { "anthropic-version": "2023-06-01" },
-});
-
-// ── 4. /api/auth/session (claude.ai session) ────────────
-await tryEndpoint({
-  label: "GET /api/auth/session (claude.ai)",
-  url: "https://claude.ai/api/auth/session",
-});
-
-// ── 5. /v1/messages (minimal — test if token works) ─────
-await tryEndpoint({
-  label: "POST /v1/messages (1 token test)",
-  url: "https://api.anthropic.com/v1/messages",
-  method: "POST",
-  headers: { "Content-Type": "application/json", "anthropic-version": "2023-06-01" },
-  body: { model: "claude-sonnet-4-20250514", max_tokens: 1, messages: [{ role: "user", content: "hi" }] },
-});