@punkcode/cli 0.1.8 → 0.1.9

package/dist/cli.js

@@ -12,6 +12,24 @@ import { execaSync as execaSync2 } from "execa";
 
 // src/lib/claude-sdk.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/utils/logger.ts
+import pino from "pino";
+var level = process.env.LOG_LEVEL ?? "info";
+var format = process.env.PUNK_LOG_FORMAT ?? (process.stdout.isTTY ? "pretty" : "json");
+var transport = format === "pretty" ? pino.transport({
+  target: "pino-pretty",
+  options: { colorize: true }
+}) : void 0;
+var logger = pino({ level }, transport);
+function createChildLogger(bindings) {
+  return logger.child(bindings);
+}
+
+// src/lib/claude-sdk.ts
 async function* promptWithImages(text, images, sessionId) {
   yield {
     type: "user",
@@ -33,32 +51,100 @@ async function* promptWithImages(text, images, sessionId) {
     session_id: sessionId
   };
 }
-async function getSessionInfo(sessionId, cwd) {
+async function loadGlobalSkills(cwd) {
+  const claudeDir = join(homedir(), ".claude");
+  const skills = [];
+  async function collectSkillsFromDir(dir) {
+    const result = [];
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+        try {
+          const md = await readFile(join(dir, entry.name, "SKILL.md"), "utf-8");
+          const fmMatch = md.match(/^---\n([\s\S]*?)(\n---|\n*$)/);
+          if (!fmMatch) continue;
+          const fm = fmMatch[1];
+          const nameMatch = fm.match(/^name:\s*(.+)$/m);
+          if (!nameMatch) continue;
+          let description = "";
+          const descMatch = fm.match(/^description:\s*(.+)$/m);
+          if (descMatch) {
+            description = descMatch[1].trim();
+          } else {
+            const blockMatch = fm.match(/^description:\s*\n((?:[ \t]+.+\n?)+)/m);
+            if (blockMatch) {
+              description = blockMatch[1].replace(/^[ \t]+/gm, "").trim().replace(/\n/g, " ");
+            }
+          }
+          result.push({ name: nameMatch[1].trim(), description });
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  const globalSkills = await collectSkillsFromDir(join(claudeDir, "skills"));
+  const projectSkills = cwd ? await collectSkillsFromDir(join(cwd, ".claude", "skills")) : [];
+  const projectNames = new Set(projectSkills.map((s) => s.name));
+  for (const s of globalSkills) {
+    if (!projectNames.has(s.name)) {
+      skills.push(s);
+    }
+  }
+  skills.push(...projectSkills);
+  try {
+    const settings = JSON.parse(await readFile(join(claudeDir, "settings.json"), "utf-8"));
+    const plugins = settings.enabledPlugins;
+    if (plugins && typeof plugins === "object") {
+      for (const [key, enabled] of Object.entries(plugins)) {
+        if (!enabled) continue;
+        const [name, source] = key.split("@");
+        if (!name) continue;
+        let description = "";
+        if (source) {
+          try {
+            const cacheDir = join(claudeDir, "plugins", "cache", source, name);
+            const versions = await readdir(cacheDir);
+            const latest = versions.filter((v) => !v.startsWith(".")).sort().pop();
+            if (latest) {
+              const md = await readFile(join(cacheDir, latest, "skills", name, "SKILL.md"), "utf-8");
+              const descMatch = md.match(/^description:\s*(.+)$/m);
+              if (descMatch) description = descMatch[1].trim();
+            }
+          } catch {
+          }
+        }
+        skills.push({ name, description });
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+async function getProjectCommands(workingDirectory) {
   const q = query({
-    prompt: "",
+    prompt: "/load-session-info",
     options: {
-      resume: sessionId,
-      ...cwd && { cwd }
+      persistSession: false,
+      ...workingDirectory && { cwd: workingDirectory }
     }
   });
   try {
-    const [init, commands, mcpServers] = await Promise.all([
-      q.initializationResult(),
+    const [commands, skills] = await Promise.all([
       q.supportedCommands(),
-      q.mcpServerStatus()
+      loadGlobalSkills(workingDirectory)
     ]);
-    const cmdList = commands.length >= init.commands.length ? commands : init.commands;
-    return {
-      sessionId,
-      tools: [],
-      slashCommands: cmdList.map((c) => ({ name: c.name, description: c.description })),
-      skills: [],
-      mcpServers: mcpServers.map((s) => ({ name: s.name, status: s.status })),
-      model: init.models?.[0]?.value ?? "",
-      cwd: cwd ?? "",
-      claudeCodeVersion: "",
-      permissionMode: "default"
-    };
+    const slashCommands = commands.map((c) => ({ name: c.name, description: c.description }));
+    const knownNames = new Set(slashCommands.map((c) => c.name));
+    for (const skill of skills) {
+      if (!knownNames.has(skill.name)) {
+        slashCommands.push(skill);
+      }
+    }
+    logger.info({ commands: slashCommands.length }, "Project commands retrieved");
+    return slashCommands;
   } finally {
     q.close();
   }
@@ -80,7 +166,7 @@ function runClaude(options, callbacks) {
         ...opts.disallowedTools && { disallowedTools: opts.disallowedTools },
         ...opts.maxTurns && { maxTurns: opts.maxTurns },
         systemPrompt: opts.systemPrompt ?? { type: "preset", preset: "claude_code" },
-        ...options.cwd && { cwd: options.cwd },
+        ...options.workingDirectory && { cwd: options.workingDirectory },
         ...options.sessionId && { resume: options.sessionId },
         maxThinkingTokens: 1e4,
         includePartialMessages: true,
@@ -179,25 +265,27 @@ function runClaude(options, callbacks) {
           case "system": {
             const sys = message;
             if (sys.subtype === "init" && callbacks.onSessionCreated) {
-              let slashCommands = (sys.slash_commands ?? []).map((cmd) => ({ name: cmd, description: "" }));
-              try {
-                const cmds = await q.supportedCommands();
-                if (cmds.length > 0) {
-                  slashCommands = cmds.map((c) => ({ name: c.name, description: c.description }));
+              const initCommands = (sys.slash_commands ?? []).map((cmd) => ({ name: cmd, description: "" }));
+              const globalSkills = await loadGlobalSkills(sys.cwd);
+              const knownNames = new Set(initCommands.map((c) => c.name));
+              for (const skill of globalSkills) {
+                if (!knownNames.has(skill.name)) {
+                  initCommands.push(skill);
                 }
-              } catch {
               }
-              callbacks.onSessionCreated({
+              const sessionInfo = {
                 sessionId: sys.session_id ?? "",
                 tools: sys.tools ?? [],
-                slashCommands,
+                slashCommands: initCommands,
                 skills: sys.skills ?? [],
                 mcpServers: sys.mcp_servers ?? [],
                 model: sys.model ?? "",
-                cwd: sys.cwd ?? "",
+                workingDirectory: sys.cwd ?? "",
                 claudeCodeVersion: sys.claude_code_version ?? "",
                 permissionMode: sys.permissionMode ?? "default"
-              });
+              };
+              logger.info({ sessionId: sessionInfo.sessionId, commands: sessionInfo.slashCommands.length }, "New chat session info");
+              callbacks.onSessionCreated(sessionInfo);
             }
             break;
           }
@@ -273,7 +361,7 @@ function collectDeviceInfo(deviceId, customName, customTags) {
     arch: process.arch,
     username: os.userInfo().username,
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    cwd: process.cwd(),
+    defaultWorkingDirectory: process.cwd(),
     model: getModel(),
     cpuModel: cpus.length > 0 ? cpus[0].model : "Unknown",
     memoryGB: Math.round(os.totalmem() / 1024 ** 3),
@@ -385,10 +473,10 @@ function getModel() {
 }
 
 // src/lib/session.ts
-import { readdir, readFile, stat, open } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-var CLAUDE_DIR = join(homedir(), ".claude", "projects");
+import { readdir as readdir2, readFile as readFile2, stat, open } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CLAUDE_DIR = join2(homedir2(), ".claude", "projects");
 function pathToProjectDir(dir) {
   return dir.replace(/\//g, "-");
 }
@@ -396,14 +484,14 @@ async function loadSession(sessionId) {
   const sessionFile = `${sessionId}.jsonl`;
   let projectDirs;
   try {
-    projectDirs = await readdir(CLAUDE_DIR);
+    projectDirs = await readdir2(CLAUDE_DIR);
   } catch {
     return null;
   }
   for (const projectDir of projectDirs) {
-    const sessionPath = join(CLAUDE_DIR, projectDir, sessionFile);
+    const sessionPath = join2(CLAUDE_DIR, projectDir, sessionFile);
     try {
-      const content = await readFile(sessionPath, "utf-8");
+      const content = await readFile2(sessionPath, "utf-8");
       return parseSessionFile(content);
     } catch {
     }
@@ -420,17 +508,17 @@ async function listSessions(workingDirectory) {
     if (workingDirectory) {
       projectDirs = [pathToProjectDir(workingDirectory)];
     } else {
-      projectDirs = await readdir(CLAUDE_DIR);
+      projectDirs = await readdir2(CLAUDE_DIR);
     }
   } catch {
     return [];
   }
   const candidates = [];
   for (const projectDir of projectDirs) {
-    const projectPath = join(CLAUDE_DIR, projectDir);
+    const projectPath = join2(CLAUDE_DIR, projectDir);
     let files;
     try {
-      files = await readdir(projectPath);
+      files = await readdir2(projectPath);
     } catch {
       continue;
     }
@@ -440,8 +528,10 @@ async function listSessions(workingDirectory) {
       if (!isValidSessionUUID(sessionId)) continue;
       candidates.push({
         sessionId,
-        project: projectDir,
-        filePath: join(projectPath, file)
+        // When a workingDirectory is provided, return the original path so it
+        // matches the device's defaultWorkingDirectory on the mobile side.
+        project: workingDirectory ?? projectDir,
+        filePath: join2(projectPath, file)
       });
     }
   }
@@ -695,23 +785,8 @@ function parseSessionFile(content) {
 
 // src/lib/context.ts
 import { execa } from "execa";
-
-// src/utils/logger.ts
-import pino from "pino";
-var level = process.env.LOG_LEVEL ?? "info";
-var format = process.env.PUNK_LOG_FORMAT ?? (process.stdout.isTTY ? "pretty" : "json");
-var transport = format === "pretty" ? pino.transport({
-  target: "pino-pretty",
-  options: { colorize: true }
-}) : void 0;
-var logger = pino({ level }, transport);
-function createChildLogger(bindings) {
-  return logger.child(bindings);
-}
-
-// src/lib/context.ts
 var log = createChildLogger({ component: "context" });
-async function getContext(sessionId, cwd) {
+async function getContext(sessionId, workingDirectory) {
   let stdout;
   try {
     const result = await execa("claude", [
@@ -723,7 +798,7 @@ async function getContext(sessionId, cwd) {
       sessionId,
       "/context"
     ], {
-      cwd: cwd || process.cwd(),
+      cwd: workingDirectory || process.cwd(),
       timeout: 3e4,
       stdin: "ignore"
     });
@@ -902,6 +977,54 @@ async function refreshIdToken() {
   return updated.idToken;
 }
 
+// src/lib/sleep-inhibitor.ts
+import { spawn } from "child_process";
+function preventIdleSleep() {
+  const platform = process.platform;
+  let child = null;
+  if (platform === "darwin") {
+    child = spawn("caffeinate", ["-i", "-w", String(process.pid)], {
+      stdio: "ignore",
+      detached: false
+    });
+  } else if (platform === "linux") {
+    child = spawn(
+      "systemd-inhibit",
+      [
+        "--what=idle",
+        "--who=punk-connect",
+        "--why=Device connected for remote access",
+        "cat"
+      ],
+      { stdio: ["pipe", "ignore", "ignore"], detached: false }
+    );
+  } else if (platform === "win32") {
+    const script = `
+$sig = '[DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint esFlags);';
+$t = Add-Type -MemberDefinition $sig -Name WinAPI -Namespace Punk -PassThru;
+while($true) {
+  $t::SetThreadExecutionState(0x80000001) | Out-Null;
+  try { $null = Read-Host } catch { break };
+  Start-Sleep -Seconds 30;
+}`.trim();
+    child = spawn("powershell", ["-NoProfile", "-Command", script], {
+      stdio: ["pipe", "ignore", "ignore"],
+      detached: false
+    });
+  }
+  child?.unref();
+  child?.on("error", () => {
+  });
+  return {
+    release: () => {
+      if (child && !child.killed) {
+        child.kill();
+        child = null;
+      }
+    }
+  };
+}
+
 // src/commands/connect.ts
 async function connect(server, options) {
   logger.info("Checking prerequisites...");
@@ -937,6 +1060,13 @@ async function connect(server, options) {
     reconnectionDelayMax: 5e3
   });
   const activeSessions = /* @__PURE__ */ new Map();
+  const sleepLock = preventIdleSleep();
+  logger.info("Sleep inhibitor active");
+  const heartbeatInterval = setInterval(() => {
+    if (socket.connected) {
+      socket.emit("heartbeat");
+    }
+  }, 3e4);
   socket.on("connect", () => {
     logger.info("Connected");
     const deviceInfo = collectDeviceInfo(deviceId, options.name, options.tag);
@@ -966,15 +1096,17 @@ async function connect(server, options) {
       handleGetContext(socket, msg);
     }
   });
-  socket.on("get-session-info", (msg) => {
-    if (msg.type === "get-session-info") {
-      handleGetSessionInfo(socket, msg);
+  socket.on("get-commands", (msg) => {
+    if (msg.type === "get-commands") {
+      handleGetCommands(socket, msg);
     }
   });
   socket.on("cancel", (msg) => {
     handleCancel(msg.id, activeSessions);
   });
   socket.on("permission-response", (msg) => {
+    const log2 = createChildLogger({ sessionId: msg.requestId });
+    log2.info({ toolUseId: msg.toolUseId, allowed: msg.allow }, msg.allow ? "Permission accepted" : "Permission denied");
     const session = activeSessions.get(msg.requestId);
     if (session) {
       session.resolvePermission(msg.toolUseId, msg.allow, msg.answers, msg.feedback);
@@ -995,7 +1127,9 @@ async function connect(server, options) {
     socket.emit("register", collectDeviceInfo(deviceId, options.name, options.tag));
   });
   socket.on("connect_error", (err) => {
-    logger.error({ err }, "Connection error");
+    const { reason, ...detail } = formatConnectionError(err);
+    logger.error(detail, `Connection error: ${reason}`);
+    logger.debug({ err }, "Connection error (raw)");
   });
   const refreshInterval = setInterval(async () => {
     try {
@@ -1006,6 +1140,8 @@ async function connect(server, options) {
   }, 50 * 60 * 1e3);
   const cleanup = () => {
     clearInterval(refreshInterval);
+    clearInterval(heartbeatInterval);
+    sleepLock.release();
     for (const session of activeSessions.values()) {
       session.abort();
     }
@@ -1016,6 +1152,15 @@ async function connect(server, options) {
     cleanup();
     process.exit(0);
   });
+  process.on("SIGTERM", () => {
+    logger.info("Shutting down...");
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGCONT", () => {
+    logger.info("Resumed from sleep, reconnecting...");
+    socket.disconnect().connect();
+  });
   await new Promise(() => {
   });
 }
@@ -1026,15 +1171,52 @@ function buildUrl(server) {
   }
   return url.origin + url.pathname;
 }
+function formatConnectionError(err) {
+  const errRecord = err;
+  const description = errRecord.description;
+  const message = description?.message ?? description?.error?.message ?? err.message;
+  const result = { message };
+  let reason = "unknown";
+  if (errRecord.type === "TransportError" && description) {
+    const target = description.target;
+    const req = target?._req;
+    const res = req?.res;
+    const statusCode = res?.statusCode;
+    if (statusCode) {
+      result.statusCode = statusCode;
+      if (statusCode === 401 || statusCode === 403) {
+        reason = "authentication failed";
+      } else if (statusCode >= 500) {
+        reason = "server unavailable";
+      } else {
+        reason = `server responded ${statusCode}`;
+      }
+    } else if (/ENOTFOUND|ECONNREFUSED|EAI_AGAIN/.test(message)) {
+      reason = "server unreachable";
+    } else {
+      reason = "transport error";
+    }
+  } else if (err.message === "timeout") {
+    reason = "timed out";
+  } else if (errRecord.data) {
+    result.data = errRecord.data;
+    reason = "rejected by server";
+  } else if (err.message.includes("v2.x")) {
+    reason = "server version mismatch";
+  } else {
+    reason = "failed";
+  }
+  return { reason, ...result };
+}
 function send(socket, event, msg) {
   socket.emit(event, msg);
 }
 function handlePrompt(socket, msg, activeSessions) {
-  const { id, prompt: prompt2, sessionId, cwd, images, options } = msg;
+  const { id, prompt: prompt2, sessionId, workingDirectory, images, options } = msg;
   const log2 = createChildLogger({ sessionId: id });
   log2.info({ prompt: prompt2.slice(0, 80) }, "Session started");
   const handle = runClaude(
-    { prompt: prompt2, sessionId, cwd, images, options },
+    { prompt: prompt2, sessionId, workingDirectory, images, options },
     {
       onSessionCreated: (info) => {
         send(socket, "response", { type: "session_created", data: info, requestId: id });
@@ -1066,7 +1248,7 @@ function handlePrompt(socket, msg, activeSessions) {
         log2.error({ error: message }, "Session error");
       },
       onPermissionRequest: (req) => {
-        log2.info({ toolName: req.toolName }, "Permission blocked");
+        log2.info({ toolUseId: req.toolUseId, toolName: req.toolName }, "Permission requested");
         socket.emit("permission-request", {
           requestId: id,
           toolUseId: req.toolUseId,
@@ -1109,26 +1291,26 @@ async function handleLoadSession(socket, msg) {
     log2.warn("Session not found");
   }
 }
-async function handleGetSessionInfo(socket, msg) {
-  const { id, sessionId, cwd } = msg;
-  const log2 = createChildLogger({ sessionId });
-  log2.info("Getting session info...");
+async function handleGetCommands(socket, msg) {
+  const { id, workingDirectory } = msg;
+  const log2 = createChildLogger({ requestId: id });
+  log2.info("Getting commands...");
   try {
-    const data = await getSessionInfo(sessionId, cwd);
-    send(socket, "response", { type: "session_info", data, requestId: id });
-    log2.info("Session info retrieved");
+    const commands = await getProjectCommands(workingDirectory);
+    send(socket, "response", { type: "commands", commands, requestId: id });
+    log2.info({ count: commands.length }, "Commands retrieved");
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     send(socket, "response", { type: "error", message, requestId: id });
-    log2.error({ err }, "Session info error");
+    log2.error({ err }, "Commands error");
   }
 }
 async function handleGetContext(socket, msg) {
-  const { id, sessionId, cwd } = msg;
+  const { id, sessionId, workingDirectory } = msg;
   const log2 = createChildLogger({ sessionId });
   log2.info("Getting context...");
   try {
-    const data = await getContext(sessionId, cwd);
+    const data = await getContext(sessionId, workingDirectory);
     send(socket, "response", { type: "context", data, requestId: id });
     log2.info({ totalTokens: data.totalTokens }, "Context retrieved");
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punkcode/cli",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Control Claude Code from your phone",
   "type": "module",
   "bin": {