@punkcode/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 punkcode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @punkcode/cli
+
+Control Claude Code from your phone with [punk](https://punkcode.dev).
+
+## Getting started
+
+1. Download the punk app on your phone and create an account
+2. Install the CLI on your dev machine:
+
+   ```bash
+   npm install -g @punkcode/cli
+   ```
+
+3. Log in:
+
+   ```bash
+   punk login
+   ```
+
+4. Connect:
+
+   ```bash
+   punk connect
+   ```
+
+Your machine will appear in the punk app — you can now send prompts to Claude Code from your phone.
+
+## Commands
+
+| Command         | Description                          |
+|-----------------|--------------------------------------|
+| `punk login`    | Log in with your punk account        |
+| `punk connect`  | Connect this machine to punk         |
+| `punk logout`   | Log out and clear stored credentials |
+
+## Requirements
+
+- Node 18+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) CLI installed
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,1030 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { program } from "commander";
+
+// src/version.ts
+var version = "0.1.0";
+
+// src/commands/connect.ts
+import { io } from "socket.io-client";
+
+// src/lib/claude-sdk.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+async function* promptWithImages(text, images, sessionId) {
+  yield {
+    type: "user",
+    message: {
+      role: "user",
+      content: [
+        ...images.map((img) => ({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: img.media_type,
+            data: img.data
+          }
+        })),
+        ...text ? [{ type: "text", text }] : []
+      ]
+    },
+    parent_tool_use_id: null,
+    session_id: sessionId
+  };
+}
+function runClaude(options, callbacks) {
+  const opts = options.options || {};
+  const isBypass = opts.permissionMode === "bypassPermissions";
+  const pendingPermissions = /* @__PURE__ */ new Map();
+  let q;
+  try {
+    q = query({
+      prompt: options.images?.length ? promptWithImages(options.prompt, options.images, options.sessionId || "") : options.prompt,
+      options: {
+        permissionMode: opts.permissionMode || "default",
+        ...isBypass && { allowDangerouslySkipPermissions: true },
+        ...opts.model && { model: opts.model },
+        ...opts.allowedTools && { allowedTools: opts.allowedTools },
+        ...opts.disallowedTools && { disallowedTools: opts.disallowedTools },
+        ...opts.maxTurns && { maxTurns: opts.maxTurns },
+        ...options.cwd && { cwd: options.cwd },
+        ...options.sessionId && { resume: options.sessionId },
+        maxThinkingTokens: 1e4,
+        includePartialMessages: true,
+        canUseTool: async (toolName, input, toolOpts) => {
+          if (!callbacks.onPermissionRequest) {
+            return { behavior: "allow", updatedInput: input };
+          }
+          const promise = new Promise((resolve) => {
+            pendingPermissions.set(toolOpts.toolUseID, resolve);
+          });
+          callbacks.onPermissionRequest({
+            toolUseId: toolOpts.toolUseID,
+            toolName,
+            input,
+            reason: toolOpts.decisionReason,
+            blockedPath: toolOpts.blockedPath
+          });
+          const result = await promise;
+          pendingPermissions.delete(toolOpts.toolUseID);
+          if (!result.allow) {
+            return { behavior: "deny", message: result.feedback || "Denied by user" };
+          }
+          if (toolName === "AskUserQuestion" && result.answers) {
+            return {
+              behavior: "allow",
+              updatedInput: { ...input, answers: result.answers }
+            };
+          }
+          return { behavior: "allow", updatedInput: input };
+        }
+      }
+    });
+  } catch (err) {
+    callbacks.onError(`Failed to create query: ${err}`);
+    return {
+      abort: () => {
+      },
+      resolvePermission: () => {
+      }
+    };
+  }
+  (async () => {
+    try {
+      for await (const message of q) {
+        switch (message.type) {
+          case "assistant": {
+            const content = message.message?.content ?? [];
+            for (const block of content) {
+              if (block.type === "tool_use") {
+                const tb = block;
+                callbacks.onToolUse(tb.id, tb.name, tb.input, message.parent_tool_use_id);
+              }
+            }
+            break;
+          }
+          case "stream_event": {
+            const evt = message.event;
+            if (evt.type === "content_block_delta") {
+              if (evt.delta.type === "text_delta") {
+                callbacks.onText(evt.delta.text);
+              } else if (evt.delta.type === "thinking_delta") {
+                callbacks.onThinking?.(evt.delta.thinking);
+              }
+            }
+            break;
+          }
+          case "user": {
+            const userContent = message.message?.content;
+            if (Array.isArray(userContent)) {
+              for (const block of userContent) {
+                if (typeof block === "object" && block !== null && "type" in block && block.type === "tool_result") {
+                  const tr = block;
+                  callbacks.onToolResult(
+                    tr.tool_use_id,
+                    tr.content,
+                    tr.is_error === true
+                  );
+                }
+              }
+            }
+            break;
+          }
+          case "result": {
+            callbacks.onResult(message.session_id);
+            break;
+          }
+        }
+      }
+    } catch (err) {
+      callbacks.onError(`Query error: ${err}`);
+    }
+  })();
+  return {
+    abort: () => {
+      try {
+        q.close();
+      } catch {
+      }
+    },
+    resolvePermission: (toolUseId, allow, answers, feedback) => {
+      pendingPermissions.get(toolUseId)?.({ allow, answers, feedback });
+    }
+  };
+}
+
+// src/lib/device-info.ts
+import os from "os";
+import path from "path";
+import fs from "fs";
+import crypto from "crypto";
+import { execaSync } from "execa";
+var PUNK_DIR = path.join(os.homedir(), ".punk");
+var CONFIG_FILE = path.join(PUNK_DIR, "config.json");
+function getOrCreateDeviceId() {
+  try {
+    const config2 = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    if (config2.deviceId) return config2.deviceId;
+  } catch {
+  }
+  const id = crypto.randomUUID();
+  fs.mkdirSync(PUNK_DIR, { recursive: true });
+  let config = {};
+  try {
+    config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+  }
+  config.deviceId = id;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return id;
+}
+function collectDeviceInfo(deviceId) {
+  const cpus = os.cpus();
+  return {
+    deviceId,
+    name: getDeviceName(),
+    platform: process.platform,
+    arch: process.arch,
+    username: os.userInfo().username,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    cwd: process.cwd(),
+    model: getModel(),
+    cpuModel: cpus.length > 0 ? cpus[0].model : "Unknown",
+    memoryGB: Math.round(os.totalmem() / 1024 ** 3),
+    battery: parseBattery(),
+    claudeCodeVersion: getClaudeVersion()
+  };
+}
+function getDeviceName() {
+  if (process.platform === "darwin") {
+    try {
+      const { stdout } = execaSync("scutil", ["--get", "ComputerName"], { timeout: 3e3 });
+      const name = stdout.trim();
+      if (name) return name;
+    } catch {
+    }
+  }
+  return os.hostname();
+}
+function parseBattery() {
+  try {
+    if (process.platform === "darwin") {
+      const { stdout: out } = execaSync("pmset", ["-g", "batt"], { timeout: 3e3 });
+      const match = out.match(/(\d+)%;\s*(charging|discharging|charged|finishing charge)/i);
+      if (match) {
+        return {
+          level: parseInt(match[1], 10),
+          charging: match[2].toLowerCase() !== "discharging"
+        };
+      }
+    } else if (process.platform === "linux") {
+      const capacity = fs.readFileSync("/sys/class/power_supply/BAT0/capacity", "utf-8").trim();
+      const status = fs.readFileSync("/sys/class/power_supply/BAT0/status", "utf-8").trim();
+      return {
+        level: parseInt(capacity, 10),
+        charging: status.toLowerCase() !== "discharging"
+      };
+    } else if (process.platform === "win32") {
+      const { stdout: out } = execaSync("wmic", [
+        "path",
+        "Win32_Battery",
+        "get",
+        "EstimatedChargeRemaining,BatteryStatus",
+        "/format:csv"
+      ], { timeout: 3e3 });
+      const lines = out.trim().split("\n").filter(Boolean);
+      if (lines.length >= 2) {
+        const parts = lines[lines.length - 1].split(",");
+        if (parts.length >= 3) {
+          return {
+            level: parseInt(parts[2], 10),
+            charging: parts[1] !== "1"
+            // 1 = discharging
+          };
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function getClaudeVersion() {
+  try {
+    const { stdout } = execaSync("claude", ["--version"], { timeout: 5e3 });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getModel() {
+  try {
+    if (process.platform === "darwin") {
+      return execaSync("sysctl", ["-n", "hw.model"], { timeout: 3e3 }).stdout.trim() || null;
+    } else if (process.platform === "linux") {
+      return fs.readFileSync("/sys/devices/virtual/dmi/id/product_name", "utf-8").trim() || null;
+    } else if (process.platform === "win32") {
+      const { stdout: out } = execaSync("wmic", ["csproduct", "get", "name", "/format:csv"], { timeout: 3e3 });
+      const lines = out.trim().split("\n").filter(Boolean);
+      if (lines.length >= 2) {
+        const parts = lines[lines.length - 1].split(",");
+        return parts.length >= 2 ? parts[1].trim() || null : null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// 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");
+async function loadSession(sessionId) {
+  const sessionFile = `${sessionId}.jsonl`;
+  let projectDirs;
+  try {
+    projectDirs = await readdir(CLAUDE_DIR);
+  } catch {
+    return null;
+  }
+  for (const projectDir of projectDirs) {
+    const sessionPath = join(CLAUDE_DIR, projectDir, sessionFile);
+    try {
+      const content = await readFile(sessionPath, "utf-8");
+      return parseSessionFile(content);
+    } catch {
+    }
+  }
+  return null;
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidSessionUUID(name) {
+  return UUID_RE.test(name);
+}
+async function listSessions() {
+  let projectDirs;
+  try {
+    projectDirs = await readdir(CLAUDE_DIR);
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  for (const projectDir of projectDirs) {
+    const projectPath = join(CLAUDE_DIR, projectDir);
+    let files;
+    try {
+      files = await readdir(projectPath);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const sessionId = file.replace(".jsonl", "");
+      if (!isValidSessionUUID(sessionId)) continue;
+      candidates.push({
+        sessionId,
+        project: projectDir,
+        filePath: join(projectPath, file)
+      });
+    }
+  }
+  const results = await Promise.all(
+    candidates.map(async (c) => {
+      try {
+        const fileStat = await stat(c.filePath);
+        const [titleInfo, turnCount] = await Promise.all([
+          extractTitle(c.filePath),
+          countTurns(c.filePath)
+        ]);
+        return {
+          sessionId: c.sessionId,
+          project: c.project,
+          title: titleInfo.title,
+          lastModified: fileStat.mtimeMs,
+          turnCount,
+          ...titleInfo.summary && { summary: titleInfo.summary }
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  const sessions = results.filter((s) => s !== null);
+  sessions.sort((a, b) => b.lastModified - a.lastModified);
+  return sessions.slice(0, 50);
+}
+var HEAD_READ_BYTES = 8192;
+var TAIL_READ_BYTES = 16384;
+async function extractTitle(filePath) {
+  const fh = await open(filePath, "r");
+  try {
+    const tailResult = await extractFromTail(fh, filePath);
+    if (tailResult) return tailResult;
+    const firstMsg = await extractFirstUserMessage(fh);
+    return { title: firstMsg };
+  } finally {
+    await fh.close();
+  }
+}
+async function extractFromTail(fh, filePath) {
+  const fileStat = await stat(filePath);
+  const fileSize = fileStat.size;
+  if (fileSize === 0) return null;
+  const readSize = Math.min(TAIL_READ_BYTES, fileSize);
+  const offset = fileSize - readSize;
+  const buf = Buffer.alloc(readSize);
+  const { bytesRead } = await fh.read(buf, 0, readSize, offset);
+  const chunk = buf.toString("utf-8", 0, bytesRead);
+  const lines = chunk.split("\n");
+  let customTitle = null;
+  let summary = null;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "custom-title" && entry.title && !customTitle) {
+        customTitle = entry.title;
+      }
+      if (entry.type === "summary" && entry.summary && !summary) {
+        summary = typeof entry.summary === "string" ? entry.summary : null;
+      }
+      if (customTitle && summary) break;
+    } catch {
+    }
+  }
+  if (customTitle) return { title: customTitle, summary: summary ?? void 0 };
+  if (summary) return { title: summary, summary };
+  return null;
+}
+async function extractFirstUserMessage(fh) {
+  const buf = Buffer.alloc(HEAD_READ_BYTES);
+  const { bytesRead } = await fh.read(buf, 0, HEAD_READ_BYTES, 0);
+  const chunk = buf.toString("utf-8", 0, bytesRead);
+  const lines = chunk.split("\n");
+  const metaUuids = /* @__PURE__ */ new Set();
+  for (const line of lines.slice(0, 20)) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.isMeta || entry.parentUuid && metaUuids.has(entry.parentUuid)) {
+        if (entry.uuid) metaUuids.add(entry.uuid);
+        continue;
+      }
+      if (entry.type === "user" && entry.message?.role === "user") {
+        const content = entry.message.content;
+        if (typeof content === "string" && content.trim()) {
+          return content.trim().slice(0, 100);
+        }
+        if (Array.isArray(content)) {
+          const textBlock = content.find(
+            (b) => b.type === "text" && b.text && !b.text.startsWith("[Request interrupted")
+          );
+          if (textBlock?.text) {
+            return textBlock.text.slice(0, 100);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return "Untitled session";
+}
+async function countTurns(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.split("\n");
+  let count = 0;
+  const metaUuids = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.isMeta || entry.parentUuid && metaUuids.has(entry.parentUuid)) {
+        if (entry.uuid) metaUuids.add(entry.uuid);
+        continue;
+      }
+      if (entry.type !== "user" || !entry.message || entry.message.role !== "user") continue;
+      const msgContent = entry.message.content;
+      if (typeof msgContent === "string") {
+        const trimmed = msgContent.trim();
+        if (trimmed && !trimmed.startsWith("<") && !trimmed.startsWith("[") && !trimmed.startsWith("/")) {
+          count++;
+        }
+      } else if (Array.isArray(msgContent)) {
+        const textBlock = msgContent.find(
+          (b) => b.type === "text" && b.text
+        );
+        if (textBlock?.text) {
+          const text = textBlock.text.trim();
+          if (text && !text.startsWith("<") && !text.startsWith("[") && !text.startsWith("/")) {
+            count++;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return count;
+}
+function parseSessionFile(content) {
+  const messages = [];
+  const lines = content.split("\n").filter((line) => line.trim());
+  const metaUuids = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.isMeta || entry.parentUuid && metaUuids.has(entry.parentUuid)) {
+        if (entry.uuid) metaUuids.add(entry.uuid);
+        continue;
+      }
+      if ((entry.type === "user" || entry.type === "assistant") && entry.message) {
+        const msgContent = entry.message.content;
+        messages.push({
+          role: entry.message.role,
+          content: typeof msgContent === "string" ? [{ type: "text", text: msgContent }] : msgContent,
+          timestamp: entry.timestamp
+        });
+      }
+    } catch {
+    }
+  }
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "user") continue;
+    const blocks = msg.content;
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (block.type !== "tool_result" || !Array.isArray(block.content)) continue;
+      const imgBlock = block.content.find(
+        (b) => b?.type === "image" && b?.source?.type === "base64" && b?.source?.data
+      );
+      if (!imgBlock) continue;
+      const dataUri = `data:${imgBlock.source.media_type};base64,${imgBlock.source.data}`;
+      for (let j = i - 1; j >= 0; j--) {
+        if (messages[j].role !== "assistant") continue;
+        const aBlocks = messages[j].content;
+        if (!Array.isArray(aBlocks)) break;
+        const toolUse = aBlocks.find(
+          (b) => b.type === "tool_use" && b.id === block.tool_use_id
+        );
+        if (toolUse) toolUse.imageUri = dataUri;
+        break;
+      }
+    }
+  }
+  const merged = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const blocks = msg.content;
+      const hasText = blocks.some((b) => b.type === "text" && b.text?.trim());
+      if (!hasText) continue;
+    }
+    const prev = merged[merged.length - 1];
+    if (msg.role === "assistant" && prev?.role === "assistant") {
+      prev.content = [...prev.content, ...msg.content];
+      continue;
+    }
+    merged.push({ ...msg, content: [...msg.content] });
+  }
+  return merged;
+}
+
+// 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) {
+  let stdout;
+  try {
+    const result = await execa("claude", [
+      "-p",
+      "--output-format",
+      "json",
+      "--verbose",
+      "--resume",
+      sessionId,
+      "/context"
+    ], {
+      cwd: cwd || process.cwd(),
+      timeout: 3e4,
+      stdin: "ignore"
+    });
+    stdout = result.stdout;
+    if (result.stderr) {
+      log.warn({ stderr: result.stderr.trim() }, "Command stderr");
+    }
+  } catch (err) {
+    const execErr = err;
+    log.error({
+      exitCode: execErr.exitCode ?? null,
+      stderr: execErr.stderr?.trim(),
+      stdout: execErr.stdout?.slice(0, 500)
+    }, "Command failed");
+    throw err;
+  }
+  log.debug({ chars: stdout.length }, "Raw stdout");
+  const markdown = extractMarkdown(stdout);
+  log.debug({ chars: markdown.length }, "Parsed markdown");
+  return parseContextMarkdown(markdown);
+}
+function extractMarkdown(stdout) {
+  const parsed = JSON.parse(stdout);
+  const block = parsed[1];
+  const content = block?.message?.content ?? "";
+  const match = content.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
+  return match ? match[1] : content;
+}
+function parseTokenValue(raw) {
+  const trimmed = raw.trim().replace(/,/g, "");
+  const kMatch = trimmed.match(/^([\d.]+)k$/i);
+  if (kMatch) {
+    return Math.round(parseFloat(kMatch[1]) * 1e3);
+  }
+  return parseInt(trimmed, 10) || 0;
+}
+function parseContextMarkdown(markdown) {
+  const data = {
+    model: "",
+    totalTokens: 0,
+    contextWindow: 0,
+    usedPercentage: 0,
+    categories: [],
+    mcpTools: [],
+    memoryFiles: [],
+    skills: [],
+    rawMarkdown: markdown
+  };
+  const modelMatch = markdown.match(/\*\*Model:\*\*\s*(.+)/);
+  if (modelMatch) {
+    data.model = modelMatch[1].trim();
+  }
+  const tokenMatch = markdown.match(/\*\*Tokens:\*\*\s*([\d.,]+k?)\s*\/\s*([\d.,]+k?)\s*\((\d+)%\)/i);
+  if (tokenMatch) {
+    data.totalTokens = parseTokenValue(tokenMatch[1]);
+    data.contextWindow = parseTokenValue(tokenMatch[2]);
+    data.usedPercentage = parseInt(tokenMatch[3], 10);
+  }
+  data.categories = parseTable(markdown, "Estimated usage by category", ["category", "tokens", "percentage"]);
+  data.mcpTools = parseTable(markdown, "MCP Tools", ["tool", "server", "tokens"]);
+  data.memoryFiles = parseTable(markdown, "Memory Files", ["type", "path", "tokens"]);
+  data.skills = parseTable(markdown, "Skills", ["skill", "source", "tokens"]);
+  return data;
+}
+function parseTable(markdown, sectionHeader, keys) {
+  const headerPattern = new RegExp(`#{2,3}\\s*${escapeRegex(sectionHeader)}`, "i");
+  const headerMatch = markdown.match(headerPattern);
+  if (!headerMatch || headerMatch.index === void 0) return [];
+  const afterHeader = markdown.slice(headerMatch.index + headerMatch[0].length);
+  const nextSection = afterHeader.search(/\n#{2,3}\s/);
+  const sectionText = nextSection !== -1 ? afterHeader.slice(0, nextSection) : afterHeader;
+  const lines = sectionText.split("\n").filter((line) => line.trim().startsWith("|"));
+  if (lines.length < 3) return [];
+  const dataRows = lines.slice(2);
+  return dataRows.map((row) => {
+    const cells = row.split("|").slice(1, -1).map((c) => c.trim());
+    const obj = {};
+    keys.forEach((key, i) => {
+      const cell = cells[i] ?? "";
+      if (key === "tokens") {
+        obj[key] = parseTokenValue(cell);
+      } else if (key === "percentage") {
+        obj[key] = parseInt(cell.replace("%", ""), 10) || 0;
+      } else {
+        obj[key] = cell;
+      }
+    });
+    return obj;
+  });
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/lib/auth.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+var FIREBASE_API_KEY = "AIzaSyDI5_jEY2s4UDB04av_p3RNkgZu3G7Sl18";
+var AUTH_FILE = path2.join(os2.homedir(), ".punk", "auth.json");
+function loadAuth() {
+  try {
+    return JSON.parse(fs2.readFileSync(AUTH_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveAuth(auth) {
+  const dir = path2.dirname(AUTH_FILE);
+  fs2.mkdirSync(dir, { recursive: true });
+  fs2.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2) + "\n", "utf-8");
+}
+function clearAuth() {
+  try {
+    fs2.unlinkSync(AUTH_FILE);
+  } catch {
+  }
+}
+async function signIn(email, password) {
+  const res = await fetch(
+    `https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=${FIREBASE_API_KEY}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password, returnSecureToken: true })
+    }
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    const code = body?.error?.message ?? `HTTP ${res.status}`;
+    throw new Error(`Login failed: ${code}`);
+  }
+  const data = await res.json();
+  const auth = {
+    idToken: data.idToken,
+    refreshToken: data.refreshToken,
+    expiresAt: Date.now() + parseInt(data.expiresIn, 10) * 1e3,
+    email: data.email,
+    uid: data.localId
+  };
+  saveAuth(auth);
+  return auth;
+}
+async function refreshIdToken() {
+  const auth = loadAuth();
+  if (!auth) {
+    throw new Error("Not logged in. Run `punk login` first.");
+  }
+  if (auth.expiresAt - Date.now() > 5 * 60 * 1e3) {
+    return auth.idToken;
+  }
+  const res = await fetch(
+    `https://securetoken.googleapis.com/v1/token?key=${FIREBASE_API_KEY}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "refresh_token",
+        refresh_token: auth.refreshToken
+      })
+    }
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    const code = body?.error?.message ?? `HTTP ${res.status}`;
+    throw new Error(`Token refresh failed: ${code}. Run \`punk login\` again.`);
+  }
+  const data = await res.json();
+  const updated = {
+    ...auth,
+    idToken: data.id_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + parseInt(data.expires_in, 10) * 1e3
+  };
+  saveAuth(updated);
+  return updated.idToken;
+}
+
+// src/commands/connect.ts
+async function connect(server, options) {
+  const deviceId = options.deviceId || getOrCreateDeviceId();
+  const url = buildUrl(server);
+  let idToken;
+  if (options.token) {
+    idToken = options.token;
+  } else {
+    try {
+      idToken = await refreshIdToken();
+    } catch (err) {
+      logger.error({ err }, "Auth failed");
+      process.exit(1);
+    }
+  }
+  logger.info("Connecting...");
+  const socket = io(url, {
+    path: "/socket.io",
+    transports: ["websocket"],
+    auth: { token: idToken },
+    reconnection: true,
+    reconnectionAttempts: Infinity,
+    reconnectionDelay: 1e3,
+    reconnectionDelayMax: 5e3
+  });
+  const activeSessions = /* @__PURE__ */ new Map();
+  socket.on("connect", () => {
+    logger.info("Connected");
+    const deviceInfo = collectDeviceInfo(deviceId);
+    socket.emit("register", deviceInfo, (response) => {
+      if (response.success) {
+        logger.info({ deviceId }, "Registered");
+      }
+    });
+  });
+  socket.on("prompt", (msg) => {
+    if (msg.type === "prompt") {
+      handlePrompt(socket, msg, activeSessions);
+    }
+  });
+  socket.on("load-session", (msg) => {
+    if (msg.type === "load-session") {
+      handleLoadSession(socket, msg);
+    }
+  });
+  socket.on("list-sessions", async (msg) => {
+    if (msg.type === "list-sessions") {
+      handleListSessions(socket, msg);
+    }
+  });
+  socket.on("get-context", (msg) => {
+    if (msg.type === "get-context") {
+      handleGetContext(socket, msg);
+    }
+  });
+  socket.on("cancel", (msg) => {
+    handleCancel(msg.id, activeSessions);
+  });
+  socket.on("permission-response", (msg) => {
+    const session = activeSessions.get(msg.requestId);
+    if (session) {
+      session.resolvePermission(msg.toolUseId, msg.allow, msg.answers, msg.feedback);
+    }
+  });
+  socket.on("disconnect", (reason) => {
+    logger.info({ reason }, "Disconnected");
+  });
+  socket.io.on("reconnect_attempt", () => {
+    logger.info("Reconnecting...");
+    refreshIdToken().then((token) => {
+      socket.auth = { token };
+    }).catch(() => {
+    });
+  });
+  socket.on("reconnect", (attemptNumber) => {
+    logger.info({ attemptNumber }, "Reconnected");
+    socket.emit("register", collectDeviceInfo(deviceId));
+  });
+  socket.on("connect_error", (err) => {
+    logger.error({ err }, "Connection error");
+  });
+  const refreshInterval = setInterval(async () => {
+    try {
+      const token = await refreshIdToken();
+      socket.emit("re-auth", { token });
+    } catch {
+    }
+  }, 50 * 60 * 1e3);
+  const cleanup = () => {
+    clearInterval(refreshInterval);
+    for (const session of activeSessions.values()) {
+      session.abort();
+    }
+    socket.disconnect();
+  };
+  process.on("SIGINT", () => {
+    logger.info("Shutting down...");
+    cleanup();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+function buildUrl(server) {
+  const url = new URL(server);
+  if (!url.pathname.endsWith("/device")) {
+    url.pathname = url.pathname.replace(/\/$/, "") + "/device";
+  }
+  return url.origin + url.pathname;
+}
+function send(socket, event, msg) {
+  socket.emit(event, msg);
+}
+function handlePrompt(socket, msg, activeSessions) {
+  const { id, prompt: prompt2, sessionId, cwd, 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 },
+    {
+      onText: (text) => {
+        send(socket, "response", { type: "text", text, requestId: id });
+      },
+      onThinking: (thinking) => {
+        send(socket, "response", { type: "thinking", thinking, requestId: id });
+      },
+      onToolUse: (toolId, name, input, parentToolUseId) => {
+        send(socket, "response", { type: "tool_use", id: toolId, name, input, requestId: id, parent_tool_use_id: parentToolUseId ?? null });
+      },
+      onToolResult: (toolUseId, content, isError) => {
+        send(socket, "response", { type: "tool_result", tool_use_id: toolUseId, content, is_error: isError, requestId: id });
+      },
+      onResult: (sid) => {
+        send(socket, "response", { type: "result", session_id: sid, requestId: id });
+        activeSessions.delete(id);
+        log2.info("Session done");
+      },
+      onError: (message) => {
+        send(socket, "response", { type: "error", message, requestId: id });
+        activeSessions.delete(id);
+        log2.error({ error: message }, "Session error");
+      },
+      onPermissionRequest: (req) => {
+        log2.info({ toolName: req.toolName }, "Permission blocked");
+        socket.emit("permission-request", {
+          requestId: id,
+          toolUseId: req.toolUseId,
+          toolName: req.toolName,
+          input: req.input,
+          reason: req.reason,
+          blockedPath: req.blockedPath
+        });
+      }
+    }
+  );
+  activeSessions.set(id, handle);
+}
+function handleCancel(id, activeSessions) {
+  const session = activeSessions.get(id);
+  if (session) {
+    session.abort();
+    activeSessions.delete(id);
+    logger.info({ sessionId: id }, "Session cancelled");
+  }
+}
+async function handleListSessions(socket, msg) {
+  const { id } = msg;
+  logger.info("Listing sessions...");
+  const sessions = await listSessions();
+  send(socket, "response", { type: "sessions_list", sessions, requestId: id });
+  logger.info({ count: sessions.length }, "Listed sessions");
+}
+async function handleLoadSession(socket, msg) {
+  const { id, sessionId } = msg;
+  const log2 = createChildLogger({ sessionId });
+  log2.info("Loading session...");
+  const messages = await loadSession(sessionId);
+  if (messages) {
+    send(socket, "response", { type: "history", messages, requestId: id });
+    log2.info({ count: messages.length }, "Session loaded");
+  } else {
+    send(socket, "response", { type: "session_not_found", session_id: sessionId, requestId: id });
+    log2.warn("Session not found");
+  }
+}
+async function handleGetContext(socket, msg) {
+  const { id, sessionId, cwd } = msg;
+  const log2 = createChildLogger({ sessionId });
+  log2.info("Getting context...");
+  try {
+    const data = await getContext(sessionId, cwd);
+    send(socket, "response", { type: "context", data, requestId: id });
+    log2.info({ totalTokens: data.totalTokens }, "Context retrieved");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("not found") || message.includes("No such session")) {
+      send(socket, "response", { type: "session_not_found", session_id: sessionId, requestId: id });
+      log2.warn("Session not found");
+    } else {
+      send(socket, "response", { type: "error", message, requestId: id });
+      log2.error({ err }, "Context error");
+    }
+  }
+}
+
+// src/commands/login.ts
+import readline from "readline";
+function prompt(question, hidden = false) {
+  if (!hidden) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    let input = "";
+    const onData = (ch) => {
+      const c = ch.toString("utf8");
+      if (c === "\n" || c === "\r") {
+        stdin.removeListener("data", onData);
+        stdin.setRawMode(wasRaw ?? false);
+        stdin.pause();
+        process.stdout.write("\n");
+        resolve(input);
+      } else if (c === "") {
+        process.exit(0);
+      } else if (c === "\x7F" || c === "\b") {
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+      } else {
+        input += c;
+        process.stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function login() {
+  const email = await prompt("Email: ");
+  const password = await prompt("Password: ", true);
+  if (!email || !password) {
+    logger.error("Email and password are required.");
+    process.exit(1);
+  }
+  try {
+    const auth = await signIn(email, password);
+    logger.info({ success: true, email: auth.email }, "Logged in");
+  } catch (err) {
+    logger.error({ err }, "Login failed");
+    process.exit(1);
+  }
+}
+function logout() {
+  clearAuth();
+  logger.info({ success: true }, "Logged out");
+}
+
+// src/commands/index.ts
+function registerCommands(program2) {
+  program2.command("connect <server>").description("Connect to backend server").option("-t, --token <token>", "Authentication token").option("-d, --device-id <deviceId>", "Device identifier (defaults to hostname)").action(connect);
+  program2.command("login").description("Log in with your email and password").action(login);
+  program2.command("logout").description("Log out and clear stored credentials").action(logout);
+}
+
+// src/cli.ts
+program.name("punk").version(version).description("Punk CLI");
+registerCommands(program);
+async function main() {
+  try {
+    await program.parseAsync();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@punkcode/cli",
+  "version": "0.1.0",
+  "description": "Control Claude Code from your phone",
+  "type": "module",
+  "bin": {
+    "punk": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "dev:connect": "npx tsx src/cli.ts connect",
+    "dev:login": "npx tsx src/cli.ts login",
+    "dev:logout": "npx tsx src/cli.ts logout",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "cli",
+    "punk",
+    "punkcode",
+    "claude",
+    "ai",
+    "mobile",
+    "remote"
+  ],
+  "license": "MIT",
+  "author": "punkcode",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/makeapop/punk-cli.git"
+  },
+  "homepage": "https://github.com/makeapop/punk-cli#readme",
+  "bugs": {
+    "url": "https://github.com/makeapop/punk-cli/issues"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^25.2.0",
+    "eslint": "^9.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.37",
+    "@anthropic-ai/sdk": "^0.72.1",
+    "commander": "^14.0.3",
+    "execa": "^9.6.1",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "socket.io-client": "^4.8.3",
+    "zod": "^4.3.6"
+  }
+}