@hienlh/ppm 0.9.80 → 0.9.82

package/scripts/check-ppm-dir-usage.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Fail if any service file uses hardcoded homedir + .ppm (should use getPpmDir())
+# Allowed exceptions: ppm-dir.ts itself, autostart, ppmbot, fs-browse, git-dirs, claude-usage, slash-discovery
+
+VIOLATIONS=$(grep -rn -E '(resolve|join)\(homedir\(\).*\.ppm' src/ \
+  --include='*.ts' \
+  | grep -v 'ppm-dir.ts' \
+  | grep -v 'autostart-' \
+  | grep -v 'ppmbot/' \
+  | grep -v 'bot-cmd' \
+  | grep -v 'claude-usage' \
+  | grep -v 'fs-browse' \
+  | grep -v 'git-dirs' \
+  | grep -v 'discover-skill-roots')
+
+if [ -n "$VIOLATIONS" ]; then
+  echo "ERROR: Direct homedir() + .ppm usage found. Use getPpmDir() from src/services/ppm-dir.ts instead:"
+  echo "$VIOLATIONS"
+  exit 1
+fi
+echo "OK: All services use getPpmDir()"

package/scripts/generate-ppm-guide.ts

@@ -0,0 +1,92 @@
+#!/usr/bin/env bun
+/**
+ * Generate the bundled PPM guide skill from docs/ and CLAUDE.md.
+ * Output: assets/skills/ppm-guide/SKILL.md
+ *
+ * Usage: bun scripts/generate-ppm-guide.ts
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+
+const ROOT = resolve(dirname(import.meta.path), "..");
+const OUT_DIR = resolve(ROOT, "assets/skills/ppm-guide");
+const OUT_FILE = resolve(OUT_DIR, "SKILL.md");
+const MAX_LINES = 150;
+
+/** Read a file safely, return empty string if missing */
+function read(rel: string): string {
+  const p = resolve(ROOT, rel);
+  return existsSync(p) ? readFileSync(p, "utf-8") : "";
+}
+
+/** Extract first N non-empty lines from content */
+function firstLines(content: string, n: number): string {
+  return content.split("\n").filter((l) => l.trim()).slice(0, n).join("\n");
+}
+
+/** Extract a markdown section by heading (## heading) */
+function extractSection(content: string, heading: string, maxLines = 15): string {
+  const regex = new RegExp(`^##\\s+${heading}.*$`, "mi");
+  const match = content.match(regex);
+  if (!match) return "";
+  const start = content.indexOf(match[0]) + match[0].length;
+  const rest = content.slice(start);
+  const nextHeading = rest.search(/^##\s/m);
+  const section = nextHeading > 0 ? rest.slice(0, nextHeading) : rest;
+  return section.split("\n").slice(0, maxLines).join("\n").trim();
+}
+
+// --- Build guide content ---
+const overview = firstLines(read("docs/project-overview-pdr.md"), 8);
+const claudeMd = read("CLAUDE.md");
+const commands = extractSection(claudeMd, "Commands", 12);
+const devConfig = extractSection(claudeMd, "Dev Config", 10);
+const architecture = extractSection(claudeMd, "Architecture", 8);
+const codeStandards = firstLines(read("docs/code-standards.md"), 10);
+
+const sections = [
+  "---",
+  "name: ppm-guide",
+  "description: PPM project structure, commands, config, and development workflow reference",
+  'argument-hint: "[topic]"',
+  "---",
+  "",
+  "# PPM Guide",
+  "",
+  "## Overview",
+  overview,
+  "",
+  "## CLI Commands",
+  commands || "See `ppm --help` for available commands.",
+  "",
+  "## Dev Config",
+  devConfig || "Config stored in SQLite (~/.ppm/ppm.db). Dev uses ~/.ppm/ppm.dev.db on port 8081.",
+  "",
+  "## Architecture",
+  architecture || "Hono (HTTP) + Bun WebSocket backend, React + Vite frontend, Claude Agent SDK for AI.",
+  "",
+  "## Code Standards",
+  codeStandards || "See docs/code-standards.md for full conventions.",
+  "",
+  "## Slash Commands",
+  "Use `/skills` to list all available skills and commands.",
+  "Use `/help` for session help, `/status` for context usage, `/compact` to reduce context.",
+  "",
+  "## Dev Workflow",
+  "1. `bun dev:server` — Start backend (port 8081, dev DB)",
+  "2. `bun dev:web` — Start Vite frontend (port 5173)",
+  "3. `bun test` — Run all tests",
+  "4. `bun run typecheck` — TypeScript type checking",
+];
+
+// Enforce line cap
+let output = sections.join("\n");
+const lines = output.split("\n");
+if (lines.length > MAX_LINES) {
+  output = lines.slice(0, MAX_LINES).join("\n") + "\n";
+}
+
+// Write output
+if (!existsSync(OUT_DIR)) mkdirSync(OUT_DIR, { recursive: true });
+writeFileSync(OUT_FILE, output, "utf-8");
+console.log(`✓ Generated ${OUT_FILE} (${output.split("\n").length} lines)`);

package/src/cli/commands/init.ts

@@ -1,6 +1,7 @@
 import { resolve, basename } from "node:path";
 import { homedir } from "node:os";
 import { existsSync } from "node:fs";
+import { getPpmDir } from "../../services/ppm-dir.ts";
 import { input, confirm, select, password } from "@inquirer/prompts";
 import { configService } from "../../services/config.service.ts";
 import { projectService } from "../../services/project.service.ts";
@@ -25,7 +26,7 @@ export function hasConfig(): boolean {
     const dbConfig = getAllConfig();
     if (Object.keys(dbConfig).length > 0) return true;
   } catch {}
-  const globalConfig = resolve(homedir(), ".ppm", "config.yaml");
+  const globalConfig = resolve(getPpmDir(), "config.yaml");
   return existsSync(globalConfig);
 }
 

package/src/cli/commands/logs.ts

@@ -1,24 +1,24 @@
 import { resolve } from "node:path";
-import { homedir } from "node:os";
 import { existsSync, readFileSync, statSync } from "node:fs";
+import { getPpmDir } from "../../services/ppm-dir.ts";
 
-const LOG_FILE = resolve(homedir(), ".ppm", "ppm.log");
+const logFile = () => resolve(getPpmDir(), "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, "");
+    writeFileSync(logFile(), "");
     console.log("Logs cleared.");
     return;
   }
 
-  if (!existsSync(LOG_FILE)) {
+  if (!existsSync(logFile())) {
     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 content = readFileSync(logFile(), "utf-8");
   const allLines = content.split("\n");
   const lastN = allLines.slice(-lines).join("\n");
 
@@ -32,14 +32,14 @@ export async function showLogs(options: { tail?: string; follow?: boolean; clear
   if (options.follow) {
     // Tail -f behavior
     const { watch } = await import("node:fs");
-    let lastSize = statSync(LOG_FILE).size;
+    let lastSize = statSync(logFile()).size;
     console.log("\n--- Following logs (Ctrl+C to stop) ---\n");
 
-    watch(LOG_FILE, () => {
+    watch(logFile(), () => {
       try {
-        const newSize = statSync(LOG_FILE).size;
+        const newSize = statSync(logFile()).size;
         if (newSize > lastSize) {
-          const fd = Bun.file(LOG_FILE);
+          const fd = Bun.file(logFile());
           fd.slice(lastSize, newSize).text().then((text) => {
             process.stdout.write(text);
           });
@@ -52,7 +52,7 @@ export async function showLogs(options: { tail?: string; follow?: boolean; clear
 
 /** 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");
+  if (!existsSync(logFile())) return "(no logs)";
+  const content = readFileSync(logFile(), "utf-8");
   return content.split("\n").slice(-lines).join("\n").trim() || "(empty)";
 }

package/src/cli/commands/report.ts

@@ -1,14 +1,15 @@
-import { homedir, platform, arch, release } from "node:os";
+import { platform, arch, release } from "node:os";
 import { resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { getRecentLogs } from "./logs.ts";
+import { getPpmDir } from "../../services/ppm-dir.ts";
 
 const REPO = "hienlh/ppm";
 
 export async function reportBug() {
   const { VERSION: version } = await import("../../version.ts");
   const logs = getRecentLogs(30);
-  const statusFile = resolve(homedir(), ".ppm", "status.json");
+  const statusFile = resolve(getPpmDir(), "status.json");
   let statusInfo = "(not running)";
   if (existsSync(statusFile)) {
     try { statusInfo = readFileSync(statusFile, "utf-8"); } catch {}

package/src/cli/commands/restart.ts

@@ -1,26 +1,25 @@
 import { resolve } from "node:path";
-import { homedir } from "node:os";
 import { readFileSync, writeFileSync, existsSync, openSync, unlinkSync, renameSync } from "node:fs";
+import { getPpmDir } from "../../services/ppm-dir.ts";
 
-const PPM_DIR = resolve(homedir(), ".ppm");
-const STATUS_FILE = resolve(PPM_DIR, "status.json");
-const PID_FILE = resolve(PPM_DIR, "ppm.pid");
-const RESTARTING_FLAG = resolve(PPM_DIR, ".restarting");
-const RESTART_RESULT = resolve(PPM_DIR, ".restart-result");
+const statusFile = () => resolve(getPpmDir(), "status.json");
+const pidFile = () => resolve(getPpmDir(), "ppm.pid");
+const restartingFlag = () => resolve(getPpmDir(), ".restarting");
+const restartResult = () => resolve(getPpmDir(), ".restart-result");
 
 /** Restart only the server process, keeping the tunnel alive */
 export async function restartServer(options: { config?: string; force?: boolean }) {
   // Ignore SIGHUP so this process survives when PPM terminal dies
   process.on("SIGHUP", () => {});
 
-  if (!existsSync(STATUS_FILE)) {
+  if (!existsSync(statusFile())) {
     console.log("No PPM daemon running. Use 'ppm start' instead.");
     process.exit(1);
   }
 
   let status: Record<string, unknown>;
   try {
-    status = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+    status = JSON.parse(readFileSync(statusFile(), "utf-8"));
   } catch {
     console.log("Corrupt status file. Use 'ppm stop && ppm start' instead.");
     process.exit(1);
@@ -45,7 +44,7 @@ export async function restartServer(options: { config?: string; force?: boolean
     // Stopped state: treat restart as resume (send resume command)
     if (state === "stopped") {
       console.log("\n  Server is stopped. Resuming via supervisor...\n");
-      const cmdFile = resolve(PPM_DIR, ".supervisor-cmd");
+      const cmdFile = resolve(getPpmDir(), ".supervisor-cmd");
       writeFileSync(cmdFile, JSON.stringify({ action: "resume" }));
       // Signal supervisor (Windows: polling picks up command file)
       if (process.platform !== "win32") {
@@ -59,7 +58,7 @@ export async function restartServer(options: { config?: string; force?: boolean
       while (Date.now() - rStart < 15_000) {
         await Bun.sleep(500);
         try {
-          const newStatus = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+          const newStatus = JSON.parse(readFileSync(statusFile(), "utf-8"));
           if (newStatus.state === "running" && newStatus.pid) {
             console.log(`  ✓  Server resumed (PID: ${newStatus.pid})`);
             if (newStatus.shareUrl) console.log(`  ➜  Share:   ${newStatus.shareUrl}`);
@@ -85,7 +84,7 @@ export async function restartServer(options: { config?: string; force?: boolean
     while (Date.now() - start < 15_000) {
       await Bun.sleep(500);
       try {
-        const newStatus = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+        const newStatus = JSON.parse(readFileSync(statusFile(), "utf-8"));
         const newPid = newStatus.pid as number | undefined;
         if (newPid && newPid !== oldServerPid) {
           // Verify it's alive
@@ -120,10 +119,10 @@ export async function restartServer(options: { config?: string; force?: boolean
   const host = status.host as string ?? configService.get("host");
 
   // Write restarting flag so tunnel cleanup handler skips killing cloudflared
-  writeFileSync(RESTARTING_FLAG, "");
+  writeFileSync(restartingFlag(), "");
 
   // Clear previous result
-  try { unlinkSync(RESTART_RESULT); } catch {}
+  try { unlinkSync(restartResult()); } catch {}
 
   // Pre-restart message — user sees this before terminal dies (if running inside PPM)
   console.log("\n  Restarting PPM server...");
@@ -135,14 +134,14 @@ export async function restartServer(options: { config?: string; force?: boolean
   const params = JSON.stringify({
     serverPid, port, host, serverScript,
     config: options.config ?? "",
-    statusFile: STATUS_FILE,
-    pidFile: PID_FILE,
-    restartingFlag: RESTARTING_FLAG,
-    resultFile: RESTART_RESULT,
-    ppmDir: PPM_DIR,
+    statusFile: statusFile(),
+    pidFile: pidFile(),
+    restartingFlag: restartingFlag(),
+    resultFile: restartResult(),
+    ppmDir: getPpmDir(),
   });
 
-  const workerPath = resolve(PPM_DIR, ".restart-worker.ts");
+  const workerPath = resolve(getPpmDir(), ".restart-worker.ts");
   writeFileSync(workerPath, `
 import { readFileSync, writeFileSync, openSync, unlinkSync, appendFileSync } from "node:fs";
 import { createServer } from "node:net";
@@ -299,7 +298,7 @@ main();
 `);
 
   // Spawn worker as a fully detached process
-  const logFile = resolve(PPM_DIR, "ppm.log");
+  const logFile = resolve(getPpmDir(), "ppm.log");
   const logFd = openSync(logFile, "a");
   const worker = Bun.spawn({
     cmd: [process.execPath, "run", workerPath],
@@ -313,15 +312,15 @@ main();
   const pollStart = Date.now();
   while (Date.now() - pollStart < 20000) {
     await Bun.sleep(500);
-    if (existsSync(RESTART_RESULT)) {
+    if (existsSync(restartResult())) {
       try {
-        const result = JSON.parse(readFileSync(RESTART_RESULT, "utf-8"));
+        const result = JSON.parse(readFileSync(restartResult(), "utf-8"));
         if (result.ok) {
           console.log(`  ✓  ${result.message}`);
         } else {
           console.error(`  ✗  ${result.message}`);
         }
-        unlinkSync(RESTART_RESULT);
+        unlinkSync(restartResult());
       } catch {}
       process.exit(0);
     }

package/src/cli/commands/skills-cmd.ts

@@ -0,0 +1,123 @@
+import { Command } from "commander";
+
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+};
+
+export function registerSkillsCommands(program: Command): void {
+  const skills = program
+    .command("skills")
+    .description("Manage and inspect discovered skills & commands")
+    .option("--project <path>", "Project path", process.cwd());
+
+  // Default action (no subcommand) → list
+  skills.action(async (opts) => { await listAction(opts); });
+
+  skills
+    .command("list")
+    .description("List all discovered skills and commands")
+    .option("--json", "JSON output")
+    .option("--project <path>", "Project path", process.cwd())
+    .action(async (opts) => { await listAction({ ...skills.opts(), ...opts }); });
+
+  skills
+    .command("search <query>")
+    .description("Fuzzy search skills and commands")
+    .option("--json", "JSON output")
+    .option("--project <path>", "Project path", process.cwd())
+    .action(async (query: string, opts) => {
+      const merged = { ...skills.opts(), ...opts };
+      const { listSlashItems, searchSlashItems } = await import("../../services/slash-discovery/index.ts");
+      const items = listSlashItems(merged.project ?? process.cwd());
+      const results = searchSlashItems(items, query);
+      if (merged.json) { console.log(JSON.stringify(results, null, 2)); return; }
+      if (results.length === 0) {
+        console.log(`${C.yellow}No matches for "${query}"${C.reset}`);
+        return;
+      }
+      console.log(`\n${C.bold}Search results for "${query}"${C.reset} (${results.length} matches)\n`);
+      for (const item of results) {
+        const typeLabel = item.type === "builtin" ? `${C.green}builtin${C.reset}` : item.type === "skill" ? `${C.cyan}skill${C.reset}` : `${C.yellow}command${C.reset}`;
+        console.log(`  ${C.bold}/${item.name}${C.reset}  [${typeLabel}]  ${C.dim}${item.description || ""}${C.reset}`);
+      }
+      console.log();
+    });
+
+  skills
+    .command("info <name>")
+    .description("Show detailed info for a specific skill")
+    .option("--json", "JSON output")
+    .option("--project <path>", "Project path", process.cwd())
+    .action(async (name: string, opts) => {
+      const merged = { ...skills.opts(), ...opts };
+      const { listSlashItemsDetailed } = await import("../../services/slash-discovery/index.ts");
+      const result = listSlashItemsDetailed(merged.project ?? process.cwd());
+      const item = result.active.find((i) => i.name === name)
+        ?? result.shadowed.find((i) => i.name === name);
+      if (!item) {
+        console.error(`${C.red}✗${C.reset} Skill "${name}" not found`);
+        process.exit(1);
+      }
+      if (merged.json) { console.log(JSON.stringify(item, null, 2)); return; }
+      console.log(`\n${C.bold}/${item.name}${C.reset}`);
+      console.log(`  Type:        ${item.type}`);
+      console.log(`  Source:      ${item.source}`);
+      console.log(`  Scope:       ${item.scope}`);
+      console.log(`  Path:        ${item.filePath || "(built-in)"}`);
+      console.log(`  Description: ${item.description || "(none)"}`);
+      if ("shadowedBy" in item) {
+        console.log(`  ${C.yellow}Shadowed by:${C.reset} ${(item as any).shadowedBy.source}`);
+      }
+      console.log();
+    });
+}
+
+async function listAction(opts: any): Promise<void> {
+  const { listSlashItemsDetailed } = await import("../../services/slash-discovery/index.ts");
+  const result = listSlashItemsDetailed(opts.project ?? process.cwd());
+
+  if (opts.json) { console.log(JSON.stringify(result, null, 2)); return; }
+
+  // Roots section
+  if (result.roots.length > 0) {
+    console.log(`\n${C.bold}Skill Roots:${C.reset}`);
+    for (const root of result.roots) {
+      console.log(`  ${root.path}  ${C.dim}(${root.source})${C.reset}`);
+    }
+  }
+
+  const skills = result.active.filter((i) => i.type === "skill");
+  const commands = result.active.filter((i) => i.type === "command");
+  const builtins = result.active.filter((i) => i.type === "builtin");
+  console.log(`\n${skills.length} skills, ${commands.length} commands, ${builtins.length} built-in (${result.shadowed.length} shadowed)\n`);
+
+  // Active items table
+  const nonBuiltin = result.active.filter((i) => i.type !== "builtin");
+  if (nonBuiltin.length > 0) {
+    const nameW = Math.max(4, ...nonBuiltin.map((i) => i.name.length));
+    const typeW = 7;
+    const srcW = Math.max(6, ...nonBuiltin.map((i) => i.source.length));
+    const header = `  ${"Name".padEnd(nameW)}  ${"Type".padEnd(typeW)}  ${"Source".padEnd(srcW)}  Description`;
+    console.log(`${C.bold}${header}${C.reset}`);
+    console.log(`  ${"-".repeat(nameW)}  ${"-".repeat(typeW)}  ${"-".repeat(srcW)}  ${"-".repeat(20)}`);
+    for (const item of nonBuiltin) {
+      const typeLabel = item.type === "skill" ? "skill" : "command";
+      console.log(`  ${item.name.padEnd(nameW)}  ${typeLabel.padEnd(typeW)}  ${item.source.padEnd(srcW)}  ${item.description || ""}`);
+    }
+  }
+
+  // Shadowed items
+  if (result.shadowed.length > 0) {
+    console.log(`\n${C.yellow}Shadowed:${C.reset}`);
+    for (const item of result.shadowed) {
+      console.log(`  ${item.name}  [${item.type}]  ${item.source}  ${C.dim}← shadowed by ${item.shadowedBy.source}${C.reset}`);
+    }
+  }
+  console.log();
+}

package/src/cli/commands/status.ts

@@ -1,9 +1,6 @@
 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");
+import { getPpmDir } from "../../services/ppm-dir.ts";
 
 interface DaemonStatus {
   running: boolean;
@@ -33,9 +30,10 @@ function getDaemonStatus(): DaemonStatus {
     state: null, pausedAt: null, pauseReason: null, lastCrashError: null,
   };
 
-  if (existsSync(STATUS_FILE)) {
+  const statusFile = resolve(getPpmDir(), "status.json");
+  if (existsSync(statusFile)) {
     try {
-      const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+      const data = JSON.parse(readFileSync(statusFile, "utf-8"));
       const pid = data.pid as number;
       const tunnelPid = (data.tunnelPid as number) ?? null;
       const tunnelAlive = tunnelPid ? isAlive(tunnelPid) : false;
@@ -59,9 +57,10 @@ function getDaemonStatus(): DaemonStatus {
     } catch { return dead; }
   }
 
-  if (existsSync(PID_FILE)) {
+  const pidFile = resolve(getPpmDir(), "ppm.pid");
+  if (existsSync(pidFile)) {
     try {
-      const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+      const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
       return { ...dead, running: isAlive(pid), pid };
     } catch { return dead; }
   }

package/src/cli/commands/stop.ts

@@ -1,11 +1,10 @@
 import { resolve } from "node:path";
-import { homedir } from "node:os";
 import { readFileSync, writeFileSync, unlinkSync, existsSync } from "node:fs";
+import { getPpmDir } from "../../services/ppm-dir.ts";
 
-const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
-const PID_FILE = resolve(PPM_DIR, "ppm.pid");
-const STATUS_FILE = resolve(PPM_DIR, "status.json");
-const CMD_FILE = resolve(PPM_DIR, ".supervisor-cmd");
+const pidFile = () => resolve(getPpmDir(), "ppm.pid");
+const statusFile = () => resolve(getPpmDir(), "status.json");
+const cmdFile = () => resolve(getPpmDir(), ".supervisor-cmd");
 
 function killPid(pid: number, label: string): boolean {
   try {
@@ -57,18 +56,18 @@ export async function stopServer(options?: { all?: boolean; kill?: boolean }) {
     console.log("  Stopping all PPM and cloudflared processes...\n");
     const cfKilled = killAllByName("cloudflared");
     let killed = 0;
-    if (existsSync(STATUS_FILE)) {
+    if (existsSync(statusFile())) {
       try {
-        const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+        const data = JSON.parse(readFileSync(statusFile(), "utf-8"));
         // Kill supervisor first (cascades to server + tunnel children)
         if (data.supervisorPid) { killPid(data.supervisorPid, "supervisor"); killed++; }
         if (data.pid) { killPid(data.pid, "server"); killed++; }
         if (data.tunnelPid) { killPid(data.tunnelPid, "tunnel"); killed++; }
       } catch {}
     }
-    if (existsSync(PID_FILE)) {
+    if (existsSync(pidFile())) {
       try {
-        const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+        const pid = parseInt(readFileSync(pidFile(), "utf-8").trim(), 10);
         if (!isNaN(pid)) { killPid(pid, "supervisor/server (pidfile)"); killed++; }
       } catch {}
     }
@@ -89,8 +88,8 @@ export async function stopServer(options?: { all?: boolean; kill?: boolean }) {
 /** Soft stop: write command file + signal supervisor → kills server only */
 async function softStopCmd() {
   let status: Record<string, unknown> | null = null;
-  if (existsSync(STATUS_FILE)) {
-    try { status = JSON.parse(readFileSync(STATUS_FILE, "utf-8")); } catch {}
+  if (existsSync(statusFile())) {
+    try { status = JSON.parse(readFileSync(statusFile(), "utf-8")); } catch {}
   }
 
   const supervisorPid = (status?.supervisorPid as number) ?? null;
@@ -115,7 +114,7 @@ async function softStopCmd() {
   }
 
   // Write soft stop command file + signal supervisor (Windows: polling picks it up)
-  writeFileSync(CMD_FILE, JSON.stringify({ action: "soft_stop" }));
+  writeFileSync(cmdFile(), JSON.stringify({ action: "soft_stop" }));
   if (process.platform !== "win32") {
     try { process.kill(supervisorPid, "SIGUSR2"); } catch (e) {
       console.error(`  Failed to signal supervisor: ${e}`);
@@ -128,7 +127,7 @@ async function softStopCmd() {
   while (Date.now() - start < 5000) {
     await Bun.sleep(500);
     try {
-      const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+      const data = JSON.parse(readFileSync(statusFile(), "utf-8"));
       if (data.state === "stopped") {
         console.log("PPM server stopped. Supervisor still alive (Cloud WS + tunnel).");
         console.log("Use 'ppm start' to restart or 'ppm stop --kill' to fully shut down.");
@@ -143,12 +142,12 @@ async function softStopCmd() {
 async function hardStop() {
   let status: { pid?: number; tunnelPid?: number; supervisorPid?: number } | null = null;
 
-  if (existsSync(STATUS_FILE)) {
-    try { status = JSON.parse(readFileSync(STATUS_FILE, "utf-8")); } catch {}
+  if (existsSync(statusFile())) {
+    try { status = JSON.parse(readFileSync(statusFile(), "utf-8")); } catch {}
   }
 
-  const pidFromFile = existsSync(PID_FILE)
-    ? parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10)
+  const pidFromFile = existsSync(pidFile())
+    ? parseInt(readFileSync(pidFile(), "utf-8").trim(), 10)
     : NaN;
 
   const supervisorPid = status?.supervisorPid ?? null;
@@ -191,6 +190,6 @@ async function hardStop() {
 }
 
 function cleanup() {
-  if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
-  if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
+  if (existsSync(statusFile())) unlinkSync(statusFile());
+  if (existsSync(pidFile())) unlinkSync(pidFile());
 }

package/src/index.ts

@@ -145,6 +145,9 @@ registerAutoStartCommands(program);
 const { registerCloudCommands } = await import("./cli/commands/cloud.ts");
 registerCloudCommands(program);
 
+const { registerSkillsCommands } = await import("./cli/commands/skills-cmd.ts");
+registerSkillsCommands(program);
+
 const { registerExtCommands } = await import("./cli/commands/ext-cmd.ts");
 registerExtCommands(program);
 

package/src/lib/account-crypto.ts

@@ -1,25 +1,30 @@
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { resolve } from "node:path";
-import { homedir } from "node:os";
+import { getPpmDir } from "../services/ppm-dir.ts";
 
 const ALGO = "aes-256-gcm";
 
-let keyPath = resolve(homedir(), ".ppm", "account.key");
+let _keyPathOverride: string | null = null;
+
+function getKeyPath(): string {
+  return _keyPathOverride ?? resolve(getPpmDir(), "account.key");
+}
 
 /** Override key path (for tests) */
 export function setKeyPath(path: string): void {
-  keyPath = path;
+  _keyPathOverride = path;
   _key = null; // invalidate cached key
 }
 
 function loadOrCreateKey(): Buffer {
-  if (existsSync(keyPath)) {
-    return Buffer.from(readFileSync(keyPath, "utf-8").trim(), "hex");
+  const kp = getKeyPath();
+  if (existsSync(kp)) {
+    return Buffer.from(readFileSync(kp, "utf-8").trim(), "hex");
   }
   const key = randomBytes(32);
-  mkdirSync(resolve(keyPath, ".."), { recursive: true });
-  writeFileSync(keyPath, key.toString("hex"), { mode: 0o600 });
+  mkdirSync(resolve(kp, ".."), { recursive: true });
+  writeFileSync(kp, key.toString("hex"), { mode: 0o600 });
   return key;
 }