@punkcode/cli 0.1.16 → 0.1.18

package/dist/chunk-NW32U73H.js

@@ -0,0 +1,1775 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var version = "0.1.18";
+
+// src/lib/auth.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var FIREBASE_API_KEY = "AIzaSyDI5_jEY2s4UDB04av_p3RNkgZu3G7Sl18";
+var AUTH_FILE = path.join(os.homedir(), ".punk", "auth.json");
+function loadAuth() {
+  try {
+    return JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveAuth(auth) {
+  const dir = path.dirname(AUTH_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2) + "\n", "utf-8");
+}
+function clearAuth() {
+  try {
+    fs.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/lib/connection.ts
+import { io } from "socket.io-client";
+import fs3 from "fs";
+import os3 from "os";
+import path3 from "path";
+
+// 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",
+    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
+  };
+}
+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: "/load-session-info",
+    options: {
+      persistSession: false,
+      ...workingDirectory && { cwd: workingDirectory }
+    }
+  });
+  try {
+    const [commands, skills] = await Promise.all([
+      q.supportedCommands(),
+      loadGlobalSkills(workingDirectory)
+    ]);
+    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();
+  }
+}
+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",
+        settingSources: ["user", "project"],
+        ...isBypass && { allowDangerouslySkipPermissions: true },
+        ...opts.model && { model: opts.model },
+        ...opts.allowedTools && { allowedTools: opts.allowedTools },
+        ...opts.disallowedTools && { disallowedTools: opts.disallowedTools },
+        ...opts.effort && { effort: opts.effort },
+        ...opts.maxTurns && { maxTurns: opts.maxTurns },
+        systemPrompt: opts.systemPrompt ?? { type: "preset", preset: "claude_code" },
+        ...options.workingDirectory && { cwd: options.workingDirectory },
+        ...options.sessionId && { resume: options.sessionId },
+        thinking: { type: "adaptive" },
+        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: () => {
+      },
+      setPermissionMode: async () => {
+      }
+    };
+  }
+  (async () => {
+    let sentCompactSummary = false;
+    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 (typeof userContent === "string") {
+              const match = userContent.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
+              if (match) {
+                if (sentCompactSummary && match[1].trim() === "Compacted") {
+                  sentCompactSummary = false;
+                } else {
+                  callbacks.onSlashCommandOutput?.(match[1]);
+                }
+              } else if (userContent.startsWith("This session is being continued")) {
+                sentCompactSummary = true;
+                callbacks.onSlashCommandOutput?.(userContent);
+              }
+            } else 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 "system": {
+            const sys = message;
+            if (sys.subtype === "init" && callbacks.onSessionCreated) {
+              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);
+                }
+              }
+              const sessionInfo = {
+                sessionId: sys.session_id ?? "",
+                tools: sys.tools ?? [],
+                slashCommands: initCommands,
+                skills: sys.skills ?? [],
+                mcpServers: sys.mcp_servers ?? [],
+                model: sys.model ?? "",
+                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);
+            } else if (sys.subtype === "task_started" && callbacks.onTaskStarted) {
+              callbacks.onTaskStarted(sys.task_id, sys.description ?? "", sys.tool_use_id);
+            } else if (sys.subtype === "task_notification" && callbacks.onTaskNotification) {
+              callbacks.onTaskNotification(sys.task_id, sys.status ?? "completed", sys.summary ?? "", sys.tool_use_id);
+            }
+            break;
+          }
+          case "tool_use_summary": {
+            const summary = message.summary;
+            if (summary) {
+              callbacks.onSlashCommandOutput?.(summary);
+            }
+            break;
+          }
+          case "result": {
+            const resultText = message.subtype === "success" ? message.result : void 0;
+            callbacks.onResult(message.session_id, resultText);
+            return;
+          }
+        }
+      }
+    } catch (err) {
+      callbacks.onError(`Query error: ${err}`);
+    }
+  })();
+  return {
+    abort: () => {
+      try {
+        q.close();
+      } catch {
+      }
+    },
+    resolvePermission: (toolUseId, allow, answers, feedback) => {
+      pendingPermissions.get(toolUseId)?.({ allow, answers, feedback });
+    },
+    setPermissionMode: (mode) => q.setPermissionMode(mode)
+  };
+}
+
+// src/lib/device-info.ts
+import os2 from "os";
+import path2 from "path";
+import fs2 from "fs";
+import crypto from "crypto";
+import { execaSync } from "execa";
+var PUNK_DIR = path2.join(os2.homedir(), ".punk");
+var CONFIG_FILE = path2.join(PUNK_DIR, "config.json");
+function getOrCreateDeviceId() {
+  try {
+    const config2 = JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+    if (config2.deviceId) return config2.deviceId;
+  } catch {
+  }
+  const id = crypto.randomUUID();
+  fs2.mkdirSync(PUNK_DIR, { recursive: true });
+  let config = {};
+  try {
+    config = JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+  }
+  config.deviceId = id;
+  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return id;
+}
+function getDefaultWorkingDirectory() {
+  try {
+    const config = JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+    if (config.defaultWorkingDirectory) return config.defaultWorkingDirectory;
+  } catch {
+  }
+  return path2.join(os2.homedir(), "punk");
+}
+function collectDeviceInfo(deviceId, customName, customTags, defaultCwd) {
+  if (customName) {
+    saveConfigField("deviceName", customName);
+  }
+  if (customTags && customTags.length > 0) {
+    saveConfigField("tags", customTags);
+  }
+  const cpus = os2.cpus();
+  return {
+    deviceId,
+    name: customName || getDeviceName(),
+    tags: customTags && customTags.length > 0 ? customTags : getTags(),
+    platform: process.platform,
+    arch: process.arch,
+    username: os2.userInfo().username,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    defaultWorkingDirectory: defaultCwd || getDefaultWorkingDirectory(),
+    model: getModel(),
+    cpuModel: cpus.length > 0 ? cpus[0].model : "Unknown",
+    memoryGB: Math.round(os2.totalmem() / 1024 ** 3),
+    battery: parseBattery(),
+    claudeCodeVersion: getClaudeVersion()
+  };
+}
+function getDeviceName() {
+  try {
+    const config = JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+    if (config.deviceName) return config.deviceName;
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    try {
+      const { stdout } = execaSync("scutil", ["--get", "ComputerName"], { timeout: 3e3 });
+      const name = stdout.trim();
+      if (name) return name;
+    } catch {
+    }
+  }
+  return os2.hostname();
+}
+function getTags() {
+  try {
+    const config = JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+    if (Array.isArray(config.tags)) return config.tags;
+  } catch {
+  }
+  return [];
+}
+function saveConfigField(key, value) {
+  fs2.mkdirSync(PUNK_DIR, { recursive: true });
+  let config = {};
+  try {
+    config = JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+  }
+  config[key] = value;
+  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+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 = fs2.readFileSync("/sys/class/power_supply/BAT0/capacity", "utf-8").trim();
+      const status = fs2.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 fs2.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 as readdir2, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { listSessions as sdkListSessions } from "@anthropic-ai/claude-agent-sdk";
+var CLAUDE_DIR = join2(homedir2(), ".claude", "projects");
+async function loadSession(sessionId) {
+  const sessionFile = `${sessionId}.jsonl`;
+  let projectDirs;
+  try {
+    projectDirs = await readdir2(CLAUDE_DIR);
+  } catch {
+    return null;
+  }
+  for (const projectDir of projectDirs) {
+    const sessionPath = join2(CLAUDE_DIR, projectDir, sessionFile);
+    try {
+      const content = await readFile2(sessionPath, "utf-8");
+      const messages = parseSessionFile(content);
+      const subagentsDir = join2(CLAUDE_DIR, projectDir, sessionId, "subagents");
+      await attachSubagentData(messages, subagentsDir);
+      return messages;
+    } catch {
+    }
+  }
+  return null;
+}
+var AGENT_ID_RE = /agentId: (\w+)/;
+async function attachSubagentData(messages, subagentsDir) {
+  const taskBlocks = [];
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    const blocks = msg.content;
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (block.type !== "tool_use" || block.name !== "Task") continue;
+      const result = block.result;
+      if (typeof result !== "string") continue;
+      const match = result.match(AGENT_ID_RE);
+      if (match) {
+        taskBlocks.push({ block, agentId: match[1] });
+      }
+    }
+  }
+  if (taskBlocks.length === 0) return;
+  await Promise.all(taskBlocks.map(async ({ block, agentId }) => {
+    try {
+      const content = await readFile2(join2(subagentsDir, `agent-${agentId}.jsonl`), "utf-8");
+      block.subagentMessages = parseSessionFile(content);
+    } catch {
+    }
+  }));
+}
+async function listSessions(workingDirectory) {
+  try {
+    const sdkSessions = await sdkListSessions({
+      ...workingDirectory && { dir: workingDirectory },
+      limit: 50
+    });
+    return sdkSessions.map((s) => ({
+      sessionId: s.sessionId,
+      project: workingDirectory ?? s.cwd ?? "",
+      title: s.summary,
+      lastModified: s.lastModified,
+      cwd: s.cwd,
+      gitBranch: s.gitBranch,
+      fileSize: s.fileSize
+    }));
+  } catch {
+    return [];
+  }
+}
+var TOOL_RESULT_PREVIEW_BYTES = 2048;
+var ANSI_RE = /\u001b\[\d*m/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+function parseSessionFile(content) {
+  const messages = [];
+  const lines = content.split("\n").filter((line) => line.trim());
+  const metaUuids = /* @__PURE__ */ new Set();
+  const taskNotifications = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.isMeta || entry.parentUuid && metaUuids.has(entry.parentUuid)) {
+        if (entry.uuid && entry.message?.role !== "assistant") {
+          metaUuids.add(entry.uuid);
+        }
+        if (entry.message?.role === "user" && typeof entry.message.content === "string") {
+          const content2 = entry.message.content;
+          const cmdMatch = content2.match(/<command-name>\/(.+?)<\/command-name>/);
+          if (cmdMatch) {
+            messages.push({
+              role: "user",
+              content: [{ type: "text", text: `/${cmdMatch[1]}` }],
+              timestamp: entry.timestamp,
+              isMeta: entry.isMeta,
+              uuid: entry.uuid,
+              parentUuid: entry.parentUuid,
+              type: entry.type
+            });
+          }
+          const outMatch = content2.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
+          if (outMatch && outMatch[1].trim()) {
+            const text = stripAnsi(outMatch[1].trim());
+            if (text) {
+              messages.push({
+                role: "assistant",
+                content: [{ type: "text", text }],
+                timestamp: entry.timestamp,
+                isMeta: entry.isMeta,
+                uuid: entry.uuid,
+                parentUuid: entry.parentUuid,
+                type: entry.type
+              });
+            }
+          }
+        }
+        continue;
+      }
+      if (entry.type === "system" && entry.subtype === "compact_boundary") {
+        messages.push({
+          role: "system",
+          content: [],
+          timestamp: entry.timestamp,
+          type: "system",
+          subtype: entry.subtype,
+          uuid: entry.uuid,
+          parentUuid: entry.parentUuid
+        });
+        continue;
+      }
+      if (entry.isCompactSummary && entry.message) {
+        const summaryContent = entry.message.content;
+        let summaryText = "";
+        if (typeof summaryContent === "string") {
+          summaryText = summaryContent;
+        } else if (Array.isArray(summaryContent)) {
+          summaryText = summaryContent.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
+        }
+        if (summaryText) {
+          for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].subtype === "compact_boundary") {
+              messages[i].content = [{ type: "text", text: summaryText }];
+              break;
+            }
+          }
+        }
+        continue;
+      }
+      if (entry.type === "user" && typeof entry.message?.content === "string") {
+        const raw = entry.message.content;
+        const notifMatch = raw.match(/<task-notification>([\s\S]*?)<\/task-notification>/);
+        if (notifMatch) {
+          const inner = notifMatch[1];
+          const toolUseId = inner.match(/<tool-use-id>(.*?)<\/tool-use-id>/)?.[1];
+          if (toolUseId) {
+            const taskId = inner.match(/<task-id>(.*?)<\/task-id>/)?.[1] ?? "";
+            const status = inner.match(/<status>(.*?)<\/status>/)?.[1] ?? "completed";
+            const summary = inner.match(/<summary>([\s\S]*?)<\/summary>/)?.[1]?.trim() ?? "";
+            taskNotifications.set(toolUseId, { taskId, status, summary });
+          }
+          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,
+          uuid: entry.uuid,
+          parentUuid: entry.parentUuid,
+          type: entry.type
+        });
+      }
+    } 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") continue;
+      const content2 = block.content;
+      let dataUri;
+      if (Array.isArray(content2)) {
+        const imgBlock = content2.find(
+          (b) => b?.type === "image" && b?.source?.type === "base64" && b?.source?.data
+        );
+        if (imgBlock) {
+          dataUri = `data:${imgBlock.source.media_type};base64,${imgBlock.source.data}`;
+        }
+      }
+      let resultText;
+      if (typeof content2 === "string") {
+        resultText = content2 || void 0;
+      } else if (Array.isArray(content2)) {
+        const texts = content2.filter((b) => b?.type === "text" && typeof b?.text === "string").map((b) => b.text);
+        resultText = texts.join("\n") || void 0;
+      }
+      if (!dataUri && !resultText) continue;
+      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) {
+          if (dataUri) toolUse.imageUri = dataUri;
+          if (resultText) toolUse.result = resultText.length > TOOL_RESULT_PREVIEW_BYTES ? resultText.slice(0, TOOL_RESULT_PREVIEW_BYTES) + "\u2026" : resultText;
+          break;
+        }
+      }
+    }
+  }
+  if (taskNotifications.size > 0) {
+    for (const msg of messages) {
+      if (msg.role !== "assistant") continue;
+      const blocks = msg.content;
+      if (!Array.isArray(blocks)) continue;
+      for (const block of blocks) {
+        if (block.type !== "tool_use" || block.name !== "Task") continue;
+        const notif = taskNotifications.get(block.id);
+        if (notif) {
+          block.taskStatus = notif.status;
+          block.taskSummary = notif.summary;
+        }
+      }
+    }
+  }
+  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";
+var log = createChildLogger({ component: "context" });
+async function getContext(sessionId, workingDirectory) {
+  let stdout;
+  try {
+    const result = await execa("claude", [
+      "-p",
+      "--output-format",
+      "json",
+      "--verbose",
+      "--resume",
+      sessionId,
+      "/context"
+    ], {
+      cwd: workingDirectory || 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/directory-discovery.ts
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+async function findProjectDirectory(description, searchRoot, rejections, signal) {
+  let prompt = `Find up to 3 project directories on this machine that best match: "${description}"
+
+Search starting from ${searchRoot}. Rank by relevance. Include a brief reason for each match.`;
+  if (rejections?.length) {
+    prompt += "\n\nThe user rejected these previous suggestions:";
+    for (const r of rejections) {
+      prompt += `
+- ${r.path}${r.feedback ? ` (user said: "${r.feedback}")` : ""}`;
+    }
+    prompt += "\n\nFind different matches based on their feedback.";
+  }
+  const q = query2({
+    prompt,
+    options: {
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        append: "IMPORTANT: When searching for directories, always try listing likely parent directories with ls FIRST (e.g. ls ~/github, ls ~/projects). Only use find as a last resort, and always with -maxdepth 3. Never scan the entire home directory."
+      },
+      permissionMode: "bypassPermissions",
+      persistSession: false,
+      cwd: searchRoot,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            suggestions: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  path: { type: "string", description: "Absolute path to the project directory" },
+                  name: { type: "string", description: "Human-readable project name" },
+                  reason: { type: "string", description: 'Brief reason why this matches (e.g. "Direct match under github folder")' }
+                },
+                required: ["path", "name", "reason"]
+              }
+            }
+          },
+          required: ["suggestions"]
+        }
+      }
+    }
+  });
+  const onAbort = () => q.close();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for await (const msg of q) {
+      if (msg.type === "result") {
+        const resultMsg = msg;
+        if (resultMsg.subtype === "success") {
+          const structured = resultMsg.structured_output;
+          if (structured?.suggestions?.length) {
+            logger.info({ count: structured.suggestions.length }, "Project directories found (structured)");
+            return structured.suggestions;
+          }
+          const result = resultMsg.result?.trim();
+          if (result && result !== "null" && result.startsWith("/")) {
+            const path4 = result.split("\n")[0].trim();
+            const name = path4.split("/").pop() ?? path4;
+            logger.info({ path: path4, name }, "Project directory found (text fallback)");
+            return [{ path: path4, name, reason: "Best match" }];
+          }
+          logger.info("No matching directories found");
+          return [];
+        }
+        logger.warn({ subtype: resultMsg.subtype }, "Directory search query failed");
+        return [];
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    q.close();
+  }
+  return [];
+}
+async function suggestProjectLocation(description, searchRoot, name, signal) {
+  const prompt = `Suggest up to 3 suitable locations on this machine to create a new project.
+
+User's description: "${description}"
+${name ? `Desired project name: "${name}"` : ""}
+
+Search starting from ${searchRoot}. Look at common project directories (e.g. ~/github, ~/projects, ~/code, ~/Desktop).
+For each suggestion, provide the full path WHERE the project folder would be created (including the project name as the last segment), a human-readable name, and a brief reason.`;
+  const q = query2({
+    prompt,
+    options: {
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        append: "IMPORTANT: When searching for directories, always try listing likely parent directories with ls FIRST (e.g. ls ~/github, ls ~/projects). Only use find as a last resort, and always with -maxdepth 3. Never scan the entire home directory. The path in each suggestion must be the FULL path including the new project folder name."
+      },
+      permissionMode: "bypassPermissions",
+      persistSession: false,
+      cwd: searchRoot,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            suggestions: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  path: { type: "string", description: "Absolute path for the new project directory (including project folder name)" },
+                  name: { type: "string", description: "Human-readable project name" },
+                  reason: { type: "string", description: "Brief reason why this location is suitable" }
+                },
+                required: ["path", "name", "reason"]
+              }
+            }
+          },
+          required: ["suggestions"]
+        }
+      }
+    }
+  });
+  const onAbort = () => q.close();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for await (const msg of q) {
+      if (msg.type === "result") {
+        const resultMsg = msg;
+        if (resultMsg.subtype === "success") {
+          const structured = resultMsg.structured_output;
+          if (structured?.suggestions?.length) {
+            logger.info({ count: structured.suggestions.length }, "Location suggestions found (structured)");
+            return structured.suggestions;
+          }
+          logger.info("No location suggestions found");
+          return [];
+        }
+        logger.warn({ subtype: resultMsg.subtype }, "Location suggestion query failed");
+        return [];
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    q.close();
+  }
+  return [];
+}
+
+// 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/lib/connection.ts
+var DEFAULT_HISTORY_LIMIT = 30;
+var MAX_PAYLOAD_BYTES = 19.5 * 1024 * 1024;
+var PunkConnection = class {
+  socket;
+  activeSessions = /* @__PURE__ */ new Map();
+  store;
+  sleepLock;
+  heartbeatInterval;
+  refreshInterval;
+  deviceId;
+  defaultCwd;
+  options;
+  constructor(server, idToken, options, store) {
+    this.store = store;
+    this.options = options;
+    this.deviceId = options.deviceId || getOrCreateDeviceId();
+    this.defaultCwd = options.cwd || getDefaultWorkingDirectory();
+    fs3.mkdirSync(this.defaultCwd, { recursive: true });
+    const url = buildUrl(server);
+    store.getState().setReconnecting();
+    store.getState().addActivity({ icon: "\u25CF", message: "Connecting..." });
+    this.socket = io(url, {
+      path: "/socket.io",
+      transports: ["websocket"],
+      auth: (cb) => {
+        refreshIdToken().then((token) => cb({ token })).catch(() => cb({ token: idToken }));
+      },
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      perMessageDeflate: { threshold: 1024 }
+    });
+    this.sleepLock = preventIdleSleep();
+    this.heartbeatInterval = setInterval(() => {
+      if (this.socket.connected) this.socket.emit("heartbeat");
+    }, 3e4);
+    this.refreshInterval = setInterval(async () => {
+      try {
+        const token = await refreshIdToken();
+        this.socket.emit("re-auth", { token });
+      } catch {
+      }
+    }, 50 * 60 * 1e3);
+    this.attachSocketHandlers();
+    this.attachSignalHandlers();
+  }
+  disconnect() {
+    this.cleanup();
+  }
+  reconnect() {
+    this.socket.disconnect().connect();
+    this.store.getState().setReconnecting();
+    this.store.getState().addActivity({ icon: "\u27F3", message: "Reconnecting..." });
+  }
+  resolvePermission(requestId, toolUseId, allow, answers, feedback, permissionMode) {
+    const session = this.activeSessions.get(requestId);
+    if (session) {
+      if (permissionMode) {
+        session.setPermissionMode(permissionMode).catch(() => {
+        });
+      }
+      session.resolvePermission(toolUseId, allow, answers, feedback);
+    }
+  }
+  // --- Private ---
+  attachSocketHandlers() {
+    const { socket, store } = this;
+    socket.on("connect", () => {
+      store.getState().setConnected();
+      const deviceInfo = collectDeviceInfo(this.deviceId, this.options.name, this.options.tag, this.defaultCwd);
+      store.getState().setDeviceInfo(deviceInfo);
+      store.getState().addActivity({ icon: "\u25CF", message: `Connected to ${store.getState().server}` });
+      socket.emit("register", deviceInfo, (response) => {
+        if (response.success) {
+          store.getState().addActivity({ icon: "\u2713", message: `Registered as ${deviceInfo.name}` });
+        } else {
+          setTimeout(() => {
+            if (socket.connected) {
+              socket.emit("register", collectDeviceInfo(this.deviceId, this.options.name, this.options.tag, this.defaultCwd), (r) => {
+                if (r.success) store.getState().addActivity({ icon: "\u2713", message: "Registered (retry)" });
+              });
+            }
+          }, 2e3);
+        }
+      });
+    });
+    socket.on("disconnect", (reason) => {
+      store.getState().setDisconnected(reason);
+      store.getState().addActivity({ icon: "\u2717", message: `Disconnected: ${reason}` });
+    });
+    socket.io.on("reconnect_attempt", () => {
+      store.getState().setReconnecting();
+      store.getState().addActivity({ icon: "\u27F3", message: "Reconnecting..." });
+    });
+    socket.on("connect_error", (err) => {
+      const { reason } = formatConnectionError(err);
+      store.getState().setError(`Connection error: ${reason}`);
+      store.getState().addActivity({ icon: "\u2717", message: `Connection error: ${reason}` });
+    });
+    socket.on("error", (err) => {
+      store.getState().addActivity({ icon: "\u2717", message: `Socket error: ${err.message}` });
+    });
+    socket.on("prompt", (msg) => {
+      if (msg.type === "prompt") this.handlePrompt(msg);
+    });
+    socket.on("load-session", (msg) => {
+      if (msg.type === "load-session") this.handleLoadSession(msg);
+    });
+    socket.on("list-sessions", (msg) => {
+      if (msg.type === "list-sessions") this.handleListSessions(msg);
+    });
+    socket.on("get-context", (msg) => {
+      if (msg.type === "get-context") this.handleGetContext(msg);
+    });
+    socket.on("get-commands", (msg) => {
+      if (msg.type === "get-commands") this.handleGetCommands(msg);
+    });
+    socket.on("find-project", (msg) => {
+      if (msg.type === "find-project") this.handleFindProject(msg);
+    });
+    socket.on("suggest-project-location", (msg) => {
+      if (msg.type === "suggest-project-location") this.handleSuggestProjectLocation(msg);
+    });
+    socket.on("create-project", (msg) => {
+      if (msg.type === "create-project") this.handleCreateProject(msg);
+    });
+    socket.on("check-path", (msg) => {
+      if (msg.type === "check-path") this.handleCheckPath(msg);
+    });
+    socket.on("cancel", (msg) => {
+      this.handleCancel(msg.id);
+    });
+    socket.on("permission-response", (msg) => {
+      const icon = msg.allow ? "\u2713" : "\u2717";
+      this.store.getState().addActivity({
+        icon,
+        message: msg.allow ? "Permission accepted" : "Permission denied",
+        sessionId: msg.requestId
+      });
+      this.resolvePermission(msg.requestId, msg.toolUseId, msg.allow, msg.answers, msg.feedback, msg.permissionMode);
+    });
+  }
+  attachSignalHandlers() {
+    const onShutdown = () => {
+      this.store.getState().addActivity({ icon: "\u25CF", message: "Shutting down..." });
+      this.cleanup();
+      process.exit(0);
+    };
+    process.on("SIGINT", onShutdown);
+    process.on("SIGTERM", onShutdown);
+    process.on("SIGCONT", () => {
+      this.reconnect();
+    });
+  }
+  send(event, msg) {
+    if (!this.socket.connected) return;
+    this.socket.emit(event, msg);
+  }
+  handlePrompt(msg) {
+    const { id, prompt, sessionId, workingDirectory, images, options } = msg;
+    const { store } = this;
+    const projectName = workingDirectory ? path3.basename(workingDirectory) : id.slice(0, 8);
+    store.getState().registerSession(id, projectName);
+    store.getState().addSession(id, {
+      requestId: id,
+      prompt,
+      workingDirectory,
+      status: "running",
+      startedAt: Date.now(),
+      model: options?.model,
+      effort: options?.effort
+    });
+    store.getState().addActivity({
+      icon: "\u25B6",
+      message: "Session started",
+      sessionId: id,
+      detail: workingDirectory ? path3.basename(workingDirectory) : void 0,
+      data: { prompt: prompt.slice(0, 500), workingDirectory, model: options?.model, effort: options?.effort }
+    });
+    const handle = runClaude(
+      { prompt, sessionId, workingDirectory, images, options },
+      {
+        onSessionCreated: (info) => {
+          this.send("response", { type: "session_created", data: info, requestId: id });
+        },
+        onText: (text) => {
+          this.send("response", { type: "text", text, requestId: id });
+        },
+        onSlashCommandOutput: (output) => {
+          this.send("response", { type: "command_output", output, requestId: id });
+        },
+        onThinking: (thinking) => {
+          this.send("response", { type: "thinking", thinking, requestId: id });
+        },
+        onToolUse: (toolId, name, input, parentToolUseId) => {
+          this.send("response", { type: "tool_use", id: toolId, name, input, requestId: id, parent_tool_use_id: parentToolUseId ?? null });
+          const inputStr = typeof input === "string" ? input : JSON.stringify(input);
+          store.getState().addActivity({
+            icon: "\u25B6",
+            message: `Tool: ${name}`,
+            sessionId: id,
+            data: { toolName: name, input: inputStr?.slice(0, 500) }
+          });
+        },
+        onToolResult: (toolUseId, content, isError) => {
+          this.send("response", { type: "tool_result", tool_use_id: toolUseId, content, is_error: isError, requestId: id });
+        },
+        onResult: (sid, result) => {
+          this.send("response", { type: "result", session_id: sid, ...result && { result }, requestId: id });
+          this.activeSessions.delete(id);
+          store.getState().removeSession(id);
+          store.getState().addActivity({ icon: "\u2713", message: "Session done", sessionId: id });
+        },
+        onError: (message) => {
+          this.send("response", { type: "error", message, requestId: id });
+          this.activeSessions.delete(id);
+          store.getState().updateSession(id, { status: "error" });
+          store.getState().addActivity({ icon: "\u2717", message: `Error: ${message}`, sessionId: id, data: { error: message } });
+        },
+        onPermissionRequest: (req) => {
+          store.getState().addActivity({
+            icon: "\u25CF",
+            message: `Permission: ${req.toolName}`,
+            sessionId: id,
+            data: { toolName: req.toolName, input: JSON.stringify(req.input).slice(0, 500), reason: req.reason, blockedPath: req.blockedPath }
+          });
+          this.socket.emit("permission-request", {
+            requestId: id,
+            toolUseId: req.toolUseId,
+            toolName: req.toolName,
+            input: req.input,
+            reason: req.reason,
+            blockedPath: req.blockedPath
+          });
+        },
+        onTaskStarted: (taskId, description, toolUseId) => {
+          this.send("response", { type: "task_started", taskId, description, toolUseId, requestId: id });
+        },
+        onTaskNotification: (taskId, status, summary, toolUseId) => {
+          this.send("response", { type: "task_notification", taskId, status, summary, toolUseId, requestId: id });
+        }
+      }
+    );
+    this.activeSessions.set(id, handle);
+  }
+  handleCancel(id) {
+    const session = this.activeSessions.get(id);
+    if (session) {
+      session.abort();
+      this.activeSessions.delete(id);
+      this.store.getState().removeSession(id);
+      this.store.getState().addActivity({ icon: "\u2717", message: "Session cancelled", sessionId: id });
+    }
+  }
+  async handleListSessions(msg) {
+    const workingDirectory = msg.workingDirectory ?? this.defaultCwd;
+    const sessions = await listSessions(workingDirectory);
+    this.send("response", { type: "sessions_list", sessions, requestId: msg.id });
+  }
+  async handleLoadSession(msg) {
+    const { id, sessionId, limit = DEFAULT_HISTORY_LIMIT } = msg;
+    const all = await loadSession(sessionId);
+    if (all) {
+      const sliced = limit > 0 && all.length > limit ? all.slice(-limit) : all;
+      const messages = fitToPayloadLimit(sliced);
+      this.send("response", { type: "history", messages, total: all.length, requestId: id });
+    } else {
+      this.send("response", { type: "session_not_found", session_id: sessionId, requestId: id });
+    }
+  }
+  async handleGetCommands(msg) {
+    try {
+      const commands = await getProjectCommands(msg.workingDirectory);
+      this.send("response", { type: "commands", commands, requestId: msg.id });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.send("response", { type: "error", message, requestId: msg.id });
+    }
+  }
+  async handleFindProject(msg) {
+    const { id, description, rootDirectory, rejections } = msg;
+    const searchRoot = rootDirectory ?? os3.homedir();
+    const ac = new AbortController();
+    const handle = { abort: () => ac.abort(), resolvePermission: () => {
+    }, setPermissionMode: async () => {
+    } };
+    this.activeSessions.set(id, handle);
+    try {
+      const suggestions = await findProjectDirectory(description, searchRoot, rejections, ac.signal);
+      this.send("response", { type: "project_suggestions", suggestions, requestId: id });
+    } catch (err) {
+      if (!ac.signal.aborted) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.send("response", { type: "error", message, requestId: id });
+      }
+    } finally {
+      this.activeSessions.delete(id);
+    }
+  }
+  async handleSuggestProjectLocation(msg) {
+    const { id, description, name, rootDirectory } = msg;
+    const searchRoot = rootDirectory ?? os3.homedir();
+    const ac = new AbortController();
+    const handle = { abort: () => ac.abort(), resolvePermission: () => {
+    }, setPermissionMode: async () => {
+    } };
+    this.activeSessions.set(id, handle);
+    try {
+      const suggestions = await suggestProjectLocation(description, searchRoot, name, ac.signal);
+      this.send("response", { type: "project_suggestions", suggestions, requestId: id });
+    } catch (err) {
+      if (!ac.signal.aborted) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.send("response", { type: "error", message, requestId: id });
+      }
+    } finally {
+      this.activeSessions.delete(id);
+    }
+  }
+  handleCreateProject(msg) {
+    const { id, path: projectPath } = msg;
+    try {
+      fs3.mkdirSync(projectPath, { recursive: true });
+      this.send("response", { type: "project_created", path: projectPath, requestId: id });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.send("response", { type: "error", message, requestId: id });
+    }
+  }
+  handleCheckPath(msg) {
+    const { id, path: checkTarget } = msg;
+    let exists = false;
+    let isDirectory = false;
+    let parentExists = false;
+    try {
+      const stat = fs3.statSync(checkTarget);
+      exists = true;
+      isDirectory = stat.isDirectory();
+    } catch {
+    }
+    try {
+      const parentStat = fs3.statSync(path3.dirname(checkTarget));
+      parentExists = parentStat.isDirectory();
+    } catch {
+    }
+    this.send("response", { type: "path_check", exists, isDirectory, parentExists, requestId: id });
+  }
+  async handleGetContext(msg) {
+    const { id, sessionId } = msg;
+    const workingDirectory = msg.workingDirectory ?? this.defaultCwd;
+    try {
+      const data = await getContext(sessionId, workingDirectory);
+      this.send("response", { type: "context", data, requestId: id });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("not found") || message.includes("No such session")) {
+        this.send("response", { type: "session_not_found", session_id: sessionId, requestId: id });
+      } else {
+        this.send("response", { type: "error", message, requestId: id });
+      }
+    }
+  }
+  cleanup() {
+    clearInterval(this.refreshInterval);
+    clearInterval(this.heartbeatInterval);
+    this.sleepLock.release();
+    for (const session of this.activeSessions.values()) {
+      session.abort();
+    }
+    this.socket.disconnect();
+  }
+};
+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 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 fitToPayloadLimit(messages) {
+  if (Buffer.byteLength(JSON.stringify(messages), "utf8") <= MAX_PAYLOAD_BYTES) {
+    return messages;
+  }
+  let lo = 0;
+  let hi = messages.length;
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi + 1) / 2);
+    const slice = messages.slice(messages.length - mid);
+    if (Buffer.byteLength(JSON.stringify(slice), "utf8") <= MAX_PAYLOAD_BYTES) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return messages.slice(messages.length - lo);
+}
+
+// src/ui/store.ts
+import { createStore, useStore } from "zustand";
+var MAX_ACTIVITY_ENTRIES = 500;
+var SESSION_COLORS = ["magenta", "blue", "magentaBright", "blueBright", "white", "gray"];
+var createPunkStore = (server) => createStore((set) => ({
+  // Initial state
+  screen: "login",
+  auth: null,
+  connection: "disconnected",
+  connectionError: void 0,
+  deviceInfo: null,
+  server,
+  connectedAt: null,
+  sessions: {},
+  activityLog: [],
+  sessionProjects: {},
+  // Actions
+  setScreen: (screen) => set({ screen }),
+  setAuth: (auth) => set({ auth }),
+  setConnected: () => set({ connection: "connected", connectedAt: Date.now(), connectionError: void 0 }),
+  setDisconnected: (reason) => set({ connection: "disconnected", connectionError: reason, connectedAt: null }),
+  setReconnecting: () => set({ connection: "connecting" }),
+  setError: (message) => set({ connection: "error", connectionError: message }),
+  setDeviceInfo: (info) => set({ deviceInfo: info }),
+  addSession: (id, session) => set((s) => ({ sessions: { ...s.sessions, [id]: session } })),
+  updateSession: (id, updates) => set((s) => {
+    const existing = s.sessions[id];
+    if (!existing) return s;
+    return { sessions: { ...s.sessions, [id]: { ...existing, ...updates } } };
+  }),
+  removeSession: (id) => set((s) => {
+    const rest = { ...s.sessions };
+    delete rest[id];
+    return { sessions: rest };
+  }),
+  addActivity: (entry) => set((s) => ({
+    activityLog: [
+      ...s.activityLog.slice(-(MAX_ACTIVITY_ENTRIES - 1)),
+      { ...entry, timestamp: Date.now() }
+    ]
+  })),
+  clearActivity: () => set({ activityLog: [] }),
+  registerSession: (id, project) => set((s) => {
+    if (s.sessionProjects[id]) return s;
+    const colorIdx = Object.keys(s.sessionProjects).length % SESSION_COLORS.length;
+    return {
+      sessionProjects: {
+        ...s.sessionProjects,
+        [id]: { project, color: SESSION_COLORS[colorIdx] }
+      }
+    };
+  })
+}));
+function usePunkStore(store, selector) {
+  return useStore(store, selector);
+}
+
+// src/lib/qr-login.ts
+import qrcode from "qrcode-terminal";
+var DEFAULT_BACKEND_URL = "https://api.punkcode.dev";
+var POLL_INTERVAL_MS = 3e3;
+var MAX_POLL_ATTEMPTS = 100;
+function resolveBackendUrl(backendUrl) {
+  return backendUrl ?? process.env.BACKEND_URL ?? DEFAULT_BACKEND_URL;
+}
+async function initQrSession(backendUrl) {
+  const baseUrl = resolveBackendUrl(backendUrl);
+  const res = await fetch(`${baseUrl}/auth/qr/init`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body?.message ?? `Failed to init QR login: HTTP ${res.status}`);
+  }
+  const { pairingCode, secret, qrPayload } = await res.json();
+  let qrString = "";
+  qrcode.generate(qrPayload, { small: true }, (code) => {
+    qrString = code;
+  });
+  async function* poll(signal) {
+    let attempts = 0;
+    let backoffMs = POLL_INTERVAL_MS;
+    while (attempts < MAX_POLL_ATTEMPTS) {
+      await sleep(backoffMs);
+      if (signal?.aborted) return;
+      try {
+        const pollRes = await fetch(
+          `${baseUrl}/auth/qr/poll?pairingCode=${pairingCode}&secret=${secret}`,
+          { signal }
+        );
+        if (!pollRes.ok) {
+          if (pollRes.status === 429) {
+            backoffMs = Math.min(backoffMs * 2, 3e4);
+            continue;
+          }
+          throw new Error(`Poll failed: HTTP ${pollRes.status}`);
+        }
+        const result = await pollRes.json();
+        backoffMs = POLL_INTERVAL_MS;
+        attempts++;
+        yield result;
+        if (result.status !== "pending") return;
+      } catch {
+        if (signal?.aborted) return;
+        backoffMs = Math.min(backoffMs * 2, 3e4);
+        continue;
+      }
+    }
+    yield { status: "expired" };
+  }
+  return { pairingCode, qrPayload, qrString, poll };
+}
+var QR_COLORS = [
+  "\x1B[36m",
+  // cyan
+  "\x1B[35m",
+  // magenta
+  "\x1B[34m",
+  // blue
+  "\x1B[32m",
+  // green
+  "\x1B[33m",
+  // yellow
+  "\x1B[91m",
+  // bright red
+  "\x1B[96m",
+  // bright cyan
+  "\x1B[95m"
+  // bright magenta
+];
+var RESET = "\x1B[0m";
+async function loginWithQr(backendUrl) {
+  const session = await initQrSession(backendUrl);
+  const qrLines = session.qrString.split("\n").filter(Boolean);
+  console.log();
+  console.log("  Scan this QR code with the Punk app:");
+  console.log();
+  let colorIdx = 0;
+  for (const line of qrLines) {
+    console.log(`  ${QR_COLORS[0]}${line}${RESET}`);
+  }
+  console.log();
+  const spinner = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let spinIdx = 0;
+  const recolorQr = () => {
+    colorIdx = (colorIdx + 1) % QR_COLORS.length;
+    const color = QR_COLORS[colorIdx];
+    const moveUp = qrLines.length + 1;
+    process.stdout.write(`\x1B[${moveUp}A`);
+    for (const line of qrLines) {
+      process.stdout.write(`\r  ${color}${line}${RESET}
+`);
+    }
+    process.stdout.write("\n");
+  };
+  const colorTimer = setInterval(recolorQr, 800);
+  const abort = new AbortController();
+  const onSigint = () => {
+    abort.abort();
+    clearInterval(colorTimer);
+    process.stdout.write("\r\x1B[K");
+    console.log("  Login cancelled.");
+    process.exit(0);
+  };
+  process.on("SIGINT", onSigint);
+  try {
+    for await (const result of session.poll(abort.signal)) {
+      process.stdout.write(`\r  Waiting for confirmation... ${spinner[spinIdx++ % spinner.length]}  `);
+      if (result.status === "pending") continue;
+      if (result.status === "expired") {
+        process.stdout.write("\r\x1B[K");
+        throw new Error("QR code expired. Run `punk login` to try again.");
+      }
+      if (result.status === "confirmed") {
+        process.stdout.write("\r\x1B[K");
+        saveAuth({
+          idToken: result.idToken,
+          refreshToken: result.refreshToken,
+          expiresAt: Date.now() + parseInt(result.expiresIn, 10) * 1e3,
+          email: result.email,
+          uid: result.uid
+        });
+        logger.info({ success: true, email: result.email }, "Logged in");
+        return;
+      }
+    }
+    process.stdout.write("\r\x1B[K");
+    throw new Error("QR code expired. Run `punk login` to try again.");
+  } finally {
+    clearInterval(colorTimer);
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  version,
+  loadAuth,
+  saveAuth,
+  clearAuth,
+  signIn,
+  refreshIdToken,
+  logger,
+  initQrSession,
+  loginWithQr,
+  PunkConnection,
+  createPunkStore,
+  usePunkStore
+};