@punkcode/cli 0.1.16 → 0.1.18

package/dist/cli.js

@@ -1,1738 +1,23 @@
 #!/usr/bin/env node
+import {
+  PunkConnection,
+  clearAuth,
+  createPunkStore,
+  logger,
+  loginWithQr,
+  refreshIdToken,
+  signIn,
+  version
+} from "./chunk-NW32U73H.js";
 
 // 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";
-import { execaSync as execaSync2 } from "execa";
-
-// src/lib/claude-sdk.ts
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { readdir, readFile } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-
-// src/utils/logger.ts
-import pino from "pino";
-var level = process.env.LOG_LEVEL ?? "info";
-var format = process.env.PUNK_LOG_FORMAT ?? (process.stdout.isTTY ? "pretty" : "json");
-var transport = format === "pretty" ? pino.transport({
-  target: "pino-pretty",
-  options: { colorize: true }
-}) : void 0;
-var logger = pino({ level }, transport);
-function createChildLogger(bindings) {
-  return logger.child(bindings);
-}
-
-// src/lib/claude-sdk.ts
-async function* promptWithImages(text, images, sessionId) {
-  yield {
-    type: "user",
-    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/commands/connect.ts
-import fs3 from "fs";
-import os3 from "os";
-
-// 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 getDefaultWorkingDirectory() {
-  try {
-    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
-    if (config.defaultWorkingDirectory) return config.defaultWorkingDirectory;
-  } catch {
-  }
-  return path.join(os.homedir(), "punk");
-}
-function collectDeviceInfo(deviceId, customName, customTags, defaultCwd) {
-  if (customName) {
-    saveConfigField("deviceName", customName);
-  }
-  if (customTags && customTags.length > 0) {
-    saveConfigField("tags", customTags);
-  }
-  const cpus = os.cpus();
-  return {
-    deviceId,
-    name: customName || getDeviceName(),
-    tags: customTags && customTags.length > 0 ? customTags : getTags(),
-    platform: process.platform,
-    arch: process.arch,
-    username: os.userInfo().username,
-    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    defaultWorkingDirectory: defaultCwd || getDefaultWorkingDirectory(),
-    model: getModel(),
-    cpuModel: cpus.length > 0 ? cpus[0].model : "Unknown",
-    memoryGB: Math.round(os.totalmem() / 1024 ** 3),
-    battery: parseBattery(),
-    claudeCodeVersion: getClaudeVersion()
-  };
-}
-function getDeviceName() {
-  try {
-    const config = JSON.parse(fs.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 os.hostname();
-}
-function getTags() {
-  try {
-    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
-    if (Array.isArray(config.tags)) return config.tags;
-  } catch {
-  }
-  return [];
-}
-function saveConfigField(key, value) {
-  fs.mkdirSync(PUNK_DIR, { recursive: true });
-  let config = {};
-  try {
-    config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
-  } catch {
-  }
-  config[key] = value;
-  fs.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 = 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 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 prompt2 = `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) {
-    prompt2 += "\n\nThe user rejected these previous suggestions:";
-    for (const r of rejections) {
-      prompt2 += `
-- ${r.path}${r.feedback ? ` (user said: "${r.feedback}")` : ""}`;
-    }
-    prompt2 += "\n\nFind different matches based on their feedback.";
-  }
-  const q = query2({
-    prompt: prompt2,
-    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 prompt2 = `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: prompt2,
-    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/commands/connect.ts
-import path3 from "path";
-
-// 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/lib/sleep-inhibitor.ts
-import { spawn } from "child_process";
-function preventIdleSleep() {
-  const platform = process.platform;
-  let child = null;
-  if (platform === "darwin") {
-    child = spawn("caffeinate", ["-i", "-w", String(process.pid)], {
-      stdio: "ignore",
-      detached: false
-    });
-  } else if (platform === "linux") {
-    child = spawn(
-      "systemd-inhibit",
-      [
-        "--what=idle",
-        "--who=punk-connect",
-        "--why=Device connected for remote access",
-        "cat"
-      ],
-      { stdio: ["pipe", "ignore", "ignore"], detached: false }
-    );
-  } else if (platform === "win32") {
-    const script = `
-$sig = '[DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint esFlags);';
-$t = Add-Type -MemberDefinition $sig -Name WinAPI -Namespace Punk -PassThru;
-while($true) {
-  $t::SetThreadExecutionState(0x80000001) | Out-Null;
-  try { $null = Read-Host } catch { break };
-  Start-Sleep -Seconds 30;
-}`.trim();
-    child = spawn("powershell", ["-NoProfile", "-Command", script], {
-      stdio: ["pipe", "ignore", "ignore"],
-      detached: false
-    });
-  }
-  child?.unref();
-  child?.on("error", () => {
-  });
-  return {
-    release: () => {
-      if (child && !child.killed) {
-        child.kill();
-        child = null;
-      }
-    }
-  };
-}
-
-// src/commands/connect.ts
-async function connect(server, options) {
-  logger.info("Checking prerequisites...");
-  try {
-    execaSync2("claude", ["--version"], { timeout: 5e3 });
-    logger.info("  \u2713 Claude Code is installed");
-  } catch {
-    logger.error("  \u2717 Claude Code is not installed. Install it from https://docs.anthropic.com/en/docs/claude-code");
-    process.exit(1);
-  }
-  logger.info("All checks passed");
-  const deviceId = options.deviceId || getOrCreateDeviceId();
-  const defaultCwd = options.cwd || getDefaultWorkingDirectory();
-  fs3.mkdirSync(defaultCwd, { recursive: true });
-  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: (cb) => {
-      refreshIdToken().then((token) => cb({ token })).catch(() => cb({ token: idToken }));
-    },
-    reconnection: true,
-    reconnectionAttempts: Infinity,
-    reconnectionDelay: 1e3,
-    reconnectionDelayMax: 5e3,
-    perMessageDeflate: { threshold: 1024 }
-  });
-  const activeSessions = /* @__PURE__ */ new Map();
-  const sleepLock = preventIdleSleep();
-  logger.info("Sleep inhibitor active");
-  const heartbeatInterval = setInterval(() => {
-    if (socket.connected) {
-      socket.emit("heartbeat");
-    }
-  }, 3e4);
-  socket.on("connect", () => {
-    logger.info("Connected");
-    const deviceInfo = collectDeviceInfo(deviceId, options.name, options.tag, defaultCwd);
-    socket.emit("register", deviceInfo, (response) => {
-      if (response.success) {
-        logger.info({ deviceId }, "Registered");
-      } else {
-        logger.warn("Registration failed, retrying in 2s...");
-        setTimeout(() => {
-          if (socket.connected) {
-            socket.emit("register", collectDeviceInfo(deviceId, options.name, options.tag, defaultCwd), (r) => {
-              if (r.success) logger.info({ deviceId }, "Registered (retry)");
-              else logger.error("Registration failed after retry");
-            });
-          }
-        }, 2e3);
-      }
-    });
-  });
-  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, defaultCwd);
-    }
-  });
-  socket.on("get-context", (msg) => {
-    if (msg.type === "get-context") {
-      handleGetContext(socket, msg, defaultCwd);
-    }
-  });
-  socket.on("get-commands", (msg) => {
-    if (msg.type === "get-commands") {
-      handleGetCommands(socket, msg);
-    }
-  });
-  socket.on("find-project", (msg) => {
-    if (msg.type === "find-project") {
-      handleFindProject(socket, msg, defaultCwd, activeSessions);
-    }
-  });
-  socket.on("suggest-project-location", (msg) => {
-    if (msg.type === "suggest-project-location") {
-      handleSuggestProjectLocation(socket, msg, activeSessions);
-    }
-  });
-  socket.on("create-project", (msg) => {
-    if (msg.type === "create-project") {
-      handleCreateProject(socket, msg);
-    }
-  });
-  socket.on("check-path", (msg) => {
-    if (msg.type === "check-path") {
-      handleCheckPath(socket, msg);
-    }
-  });
-  socket.on("cancel", (msg) => {
-    handleCancel(msg.id, activeSessions);
-  });
-  socket.on("permission-response", (msg) => {
-    const log2 = createChildLogger({ sessionId: msg.requestId });
-    log2.info({ toolUseId: msg.toolUseId, allowed: msg.allow, permissionMode: msg.permissionMode }, msg.allow ? "Permission accepted" : "Permission denied");
-    const session = activeSessions.get(msg.requestId);
-    if (session) {
-      if (msg.permissionMode) {
-        session.setPermissionMode(msg.permissionMode).catch(() => {
-        });
-      }
-      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...");
-  });
-  socket.on("connect_error", (err) => {
-    const { reason, ...detail } = formatConnectionError(err);
-    logger.error(detail, `Connection error: ${reason}`);
-    logger.debug({ err }, "Connection error (raw)");
-  });
-  socket.on("error", (err) => {
-    logger.error({ err }, "Socket error");
-  });
-  const refreshInterval = setInterval(async () => {
-    try {
-      const token = await refreshIdToken();
-      socket.emit("re-auth", { token });
-    } catch {
-    }
-  }, 50 * 60 * 1e3);
-  const cleanup = () => {
-    clearInterval(refreshInterval);
-    clearInterval(heartbeatInterval);
-    sleepLock.release();
-    for (const session of activeSessions.values()) {
-      session.abort();
-    }
-    socket.disconnect();
-  };
-  process.on("SIGINT", () => {
-    logger.info("Shutting down...");
-    cleanup();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    logger.info("Shutting down...");
-    cleanup();
-    process.exit(0);
-  });
-  process.on("SIGCONT", () => {
-    logger.info("Resumed from sleep, reconnecting...");
-    socket.disconnect().connect();
-  });
-  await new Promise(() => {
-  });
-}
-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 send(socket, event, msg) {
-  if (!socket.connected) return;
-  socket.emit(event, msg);
-}
-function handlePrompt(socket, msg, activeSessions) {
-  const { id, prompt: prompt2, sessionId, workingDirectory, images, options } = msg;
-  const log2 = createChildLogger({ sessionId: id });
-  log2.info({ prompt: prompt2.slice(0, 80) }, "Session started");
-  const handle = runClaude(
-    { prompt: prompt2, sessionId, workingDirectory, images, options },
-    {
-      onSessionCreated: (info) => {
-        send(socket, "response", { type: "session_created", data: info, requestId: id });
-        log2.info({ sessionId: info.sessionId }, "New session created");
-      },
-      onText: (text) => {
-        send(socket, "response", { type: "text", text, requestId: id });
-      },
-      onSlashCommandOutput: (output) => {
-        send(socket, "response", { type: "command_output", output, 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, result) => {
-        send(socket, "response", { type: "result", session_id: sid, ...result && { result }, 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({ toolUseId: req.toolUseId, toolName: req.toolName }, "Permission requested");
-        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) => {
-        log2.info({ taskId, toolUseId, description }, "Task started");
-        send(socket, "response", { type: "task_started", taskId, description, toolUseId, requestId: id });
-      },
-      onTaskNotification: (taskId, status, summary, toolUseId) => {
-        log2.info({ taskId, toolUseId, status, summary }, "Task notification");
-        send(socket, "response", { type: "task_notification", taskId, status, summary, toolUseId, requestId: id });
-      }
-    }
-  );
-  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");
-  } else {
-    logger.warn({ sessionId: id }, "Cancel: session not found in activeSessions");
-  }
-}
-async function handleListSessions(socket, msg, defaultCwd) {
-  const { id } = msg;
-  const workingDirectory = msg.workingDirectory ?? defaultCwd;
-  logger.info("Listing sessions...");
-  const sessions = await listSessions(workingDirectory);
-  send(socket, "response", { type: "sessions_list", sessions, requestId: id });
-  logger.info({ count: sessions.length }, "Listed sessions");
-}
-var DEFAULT_HISTORY_LIMIT = 30;
-var MAX_PAYLOAD_BYTES = 19.5 * 1024 * 1024;
-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);
-}
-async function handleLoadSession(socket, msg) {
-  const { id, sessionId, limit = DEFAULT_HISTORY_LIMIT } = msg;
-  const log2 = createChildLogger({ sessionId });
-  log2.info("Loading session...");
-  const all = await loadSession(sessionId);
-  if (all) {
-    const sliced = limit > 0 && all.length > limit ? all.slice(-limit) : all;
-    const messages = fitToPayloadLimit(sliced);
-    if (messages.length < sliced.length) {
-      log2.warn({ requested: sliced.length, sent: messages.length }, "Session payload trimmed to fit size limit");
-    }
-    send(socket, "response", { type: "history", messages, total: all.length, requestId: id });
-    log2.info({ count: messages.length, total: all.length }, "Session loaded");
-  } else {
-    send(socket, "response", { type: "session_not_found", session_id: sessionId, requestId: id });
-    log2.warn("Session not found");
-  }
-}
-async function handleGetCommands(socket, msg) {
-  const { id, workingDirectory } = msg;
-  const log2 = createChildLogger({ requestId: id });
-  log2.info("Getting commands...");
-  try {
-    const commands = await getProjectCommands(workingDirectory);
-    send(socket, "response", { type: "commands", commands, requestId: id });
-    log2.info({ count: commands.length }, "Commands retrieved");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    send(socket, "response", { type: "error", message, requestId: id });
-    log2.error({ err }, "Commands error");
-  }
-}
-async function handleFindProject(socket, msg, _defaultCwd, activeSessions) {
-  const { id, description, rootDirectory, rejections } = msg;
-  const searchRoot = rootDirectory ?? os3.homedir();
-  const log2 = createChildLogger({ requestId: id });
-  log2.info({ description, searchRoot }, "Finding project directory...");
-  const ac = new AbortController();
-  const handle = {
-    abort: () => ac.abort(),
-    resolvePermission: () => {
-    },
-    setPermissionMode: async () => {
-    }
-  };
-  activeSessions.set(id, handle);
-  try {
-    const suggestions = await findProjectDirectory(description, searchRoot, rejections, ac.signal);
-    send(socket, "response", { type: "project_suggestions", suggestions, requestId: id });
-    log2.info({ count: suggestions.length }, "Project suggestions sent");
-  } catch (err) {
-    if (ac.signal.aborted) {
-      log2.info("Find project cancelled");
-      return;
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    send(socket, "response", { type: "error", message, requestId: id });
-    log2.error({ err }, "Find project error");
-  } finally {
-    activeSessions.delete(id);
-  }
-}
-async function handleSuggestProjectLocation(socket, msg, activeSessions) {
-  const { id, description, name, rootDirectory } = msg;
-  const searchRoot = rootDirectory ?? os3.homedir();
-  const log2 = createChildLogger({ requestId: id });
-  log2.info({ description, name, searchRoot }, "Suggesting project location...");
-  const ac = new AbortController();
-  const handle = {
-    abort: () => ac.abort(),
-    resolvePermission: () => {
-    },
-    setPermissionMode: async () => {
-    }
-  };
-  activeSessions.set(id, handle);
-  try {
-    const suggestions = await suggestProjectLocation(description, searchRoot, name, ac.signal);
-    send(socket, "response", { type: "project_suggestions", suggestions, requestId: id });
-    log2.info({ count: suggestions.length }, "Location suggestions sent");
-  } catch (err) {
-    if (ac.signal.aborted) {
-      log2.info("Suggest project location cancelled");
-      return;
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    send(socket, "response", { type: "error", message, requestId: id });
-    log2.error({ err }, "Suggest project location error");
-  } finally {
-    activeSessions.delete(id);
-  }
-}
-function handleCreateProject(socket, msg) {
-  const { id, path: projectPath } = msg;
-  const log2 = createChildLogger({ requestId: id });
-  log2.info({ path: projectPath }, "Creating project directory...");
-  try {
-    fs3.mkdirSync(projectPath, { recursive: true });
-    send(socket, "response", { type: "project_created", path: projectPath, requestId: id });
-    log2.info({ path: projectPath }, "Project directory created");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    send(socket, "response", { type: "error", message, requestId: id });
-    log2.error({ err }, "Create project error");
-  }
-}
-function handleCheckPath(socket, msg) {
-  const { id, path: checkTarget } = msg;
-  const log2 = createChildLogger({ requestId: id });
-  log2.info({ path: checkTarget }, "Checking path...");
-  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 {
-  }
-  send(socket, "response", { type: "path_check", exists, isDirectory, parentExists, requestId: id });
-  log2.info({ exists, isDirectory, parentExists }, "Path check complete");
-}
-async function handleGetContext(socket, msg, defaultCwd) {
-  const { id, sessionId } = msg;
-  const workingDirectory = msg.workingDirectory ?? defaultCwd;
-  const log2 = createChildLogger({ sessionId });
-  log2.info("Getting context...");
-  try {
-    const data = await getContext(sessionId, workingDirectory);
-    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";
-
-// src/lib/qr-login.ts
-import qrcode from "qrcode-terminal";
-var BACKEND_URL = process.env.BACKEND_URL || "https://api.punkcode.dev";
-var POLL_INTERVAL_MS = 3e3;
-var MAX_POLL_ATTEMPTS = 100;
-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() {
-  const res = await fetch(`${BACKEND_URL}/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 qrLines = [];
-  qrcode.generate(qrPayload, { small: true }, (code) => {
-    qrLines = code.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;
-  let attempts = 0;
-  let backoffMs = POLL_INTERVAL_MS;
-  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 {
-    while (attempts < MAX_POLL_ATTEMPTS) {
-      process.stdout.write(`\r  Waiting for confirmation... ${spinner[spinIdx++ % spinner.length]}  `);
-      await sleep(backoffMs);
-      let poll;
-      try {
-        const pollRes = await fetch(
-          `${BACKEND_URL}/auth/qr/poll?pairingCode=${pairingCode}&secret=${secret}`,
-          { signal: abort.signal }
-        );
-        if (!pollRes.ok) {
-          if (pollRes.status === 429) {
-            backoffMs = Math.min(backoffMs * 2, 3e4);
-            continue;
-          }
-          throw new Error(`Poll failed: HTTP ${pollRes.status}`);
-        }
-        poll = await pollRes.json();
-        backoffMs = POLL_INTERVAL_MS;
-      } catch {
-        if (abort.signal.aborted) return;
-        backoffMs = Math.min(backoffMs * 2, 3e4);
-        continue;
-      }
-      attempts++;
-      if (poll.status === "pending") {
-        continue;
-      }
-      if (poll.status === "expired") {
-        process.stdout.write("\r\x1B[K");
-        throw new Error("QR code expired. Run `punk login` to try again.");
-      }
-      if (poll.status === "confirmed") {
-        process.stdout.write("\r\x1B[K");
-        saveAuth({
-          idToken: poll.idToken,
-          refreshToken: poll.refreshToken,
-          expiresAt: Date.now() + parseInt(poll.expiresIn, 10) * 1e3,
-          email: poll.email,
-          uid: poll.uid
-        });
-        logger.info({ success: true, email: poll.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));
-}
-
-// src/commands/login.ts
 function prompt(question, hidden = false) {
   if (!hidden) {
     const rl = readline.createInterface({
@@ -1806,9 +91,104 @@ function logout() {
   logger.info({ success: true }, "Logged out");
 }
 
+// src/commands/connect.ts
+async function connect(server, options) {
+  if (!options.background) {
+    logger.level = "silent";
+  }
+  if (options.background) logger.info("Checking prerequisites...");
+  try {
+    execaSync("claude", ["--version"], { timeout: 5e3 });
+    if (options.background) logger.info("  \u2713 Claude Code is installed");
+  } catch {
+    console.error("Claude Code is not installed. Install it from https://docs.anthropic.com/en/docs/claude-code");
+    process.exit(1);
+  }
+  if (options.background) logger.info("All checks passed");
+  if (options.background) {
+    const idToken = await getAuthToken(server, options);
+    await runHeadless(server, idToken, options);
+  } else {
+    await runTui(server, options);
+  }
+}
+async function runHeadless(server, idToken, options) {
+  const store = createPunkStore(server);
+  store.subscribe((state, prev) => {
+    if (state.connection !== prev.connection) {
+      if (state.connection === "connected") logger.info("Connected");
+      else if (state.connection === "error") logger.error(state.connectionError ?? "Connection error");
+      else if (state.connection === "connecting") logger.info("Reconnecting...");
+      else logger.info({ reason: state.connectionError }, "Disconnected");
+    }
+    if (state.activityLog.length > prev.activityLog.length) {
+      const newEntries = state.activityLog.slice(prev.activityLog.length);
+      for (const entry of newEntries) {
+        logger.info({ sessionId: entry.sessionId }, entry.message);
+      }
+    }
+  });
+  new PunkConnection(server, idToken, options, store);
+  await new Promise(() => {
+  });
+}
+async function runTui(server, options) {
+  const { render } = await import("ink");
+  const { createElement } = await import("react");
+  const { App } = await import("./App-GTPBJCS2.js");
+  const idToken = options.token ? options.token : void 0;
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1B[H");
+  const { waitUntilExit } = render(
+    createElement(App, { server, idToken, options })
+  );
+  try {
+    await waitUntilExit();
+  } finally {
+    process.stdout.write("\x1B[?1049l");
+  }
+}
+async function getAuthToken(server, options) {
+  if (options.token) return options.token;
+  try {
+    return await refreshIdToken();
+  } catch {
+    logger.info("Not logged in. Let's get you set up.\n");
+    const method = await prompt("  Login method \u2014 (1) QR code  (2) Email: ");
+    if (method === "2") {
+      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 {
+        await signIn(email, password);
+        logger.info("Logged in successfully.\n");
+      } catch (err) {
+        logger.error({ err }, "Login failed");
+        process.exit(1);
+      }
+    } else {
+      try {
+        await loginWithQr(server);
+      } catch (err) {
+        logger.error({ err }, "QR login failed");
+        process.exit(1);
+      }
+    }
+    try {
+      return await refreshIdToken();
+    } catch (err) {
+      logger.error({ err }, "Auth failed after login");
+      process.exit(1);
+    }
+  }
+}
+
 // src/commands/index.ts
 function registerCommands(program2) {
-  program2.command("connect").argument("[server]", "Backend server URL", "https://api.punkcode.dev").description("Connect to backend server").option("-t, --token <token>", "Authentication token").option("-d, --device-id <deviceId>", "Device identifier (defaults to hostname)").option("-n, --name <name>", "Custom device display name").option("--tag <tag>", "Device tag (repeatable, e.g. --tag home --tag mac --tag docker)", (val, acc) => [...acc, val], []).option("--cwd <directory>", "Working directory for sessions (default: ~/punk)").action(connect);
+  program2.command("connect").argument("[server]", "Backend server URL", "https://api.punkcode.dev").description("Connect to backend server").option("-t, --token <token>", "Authentication token").option("-d, --device-id <deviceId>", "Device identifier (defaults to hostname)").option("-n, --name <name>", "Custom device display name").option("--tag <tag>", "Device tag (repeatable, e.g. --tag home --tag mac --tag docker)", (val, acc) => [...acc, val], []).option("--cwd <directory>", "Working directory for sessions (default: ~/punk)").option("-b, --background", "Run without interactive UI (headless mode)").action(connect);
   program2.command("login").description("Log in to your account").option("--email", "Use email/password login instead of QR code").action(login);
   program2.command("logout").description("Log out and clear stored credentials").action(logout);
 }