claude-mux 0.7.0 → 0.7.1

package/web/.svelte-kit/adapter-node/entries/endpoints/api/auth/login/_server.ts.js

@@ -0,0 +1,22 @@
+import { json } from "@sveltejs/kit";
+import { i as isAuthEnabled, v as validatePassword, c as createAuthToken, A as AUTH_COOKIE } from "../../../../../chunks/auth.js";
+const POST = async ({ request, cookies, url }) => {
+  if (!isAuthEnabled()) {
+    return json({ success: true, message: "Auth not enabled" });
+  }
+  const body = await request.json().catch(() => ({}));
+  const password = body.password;
+  if (!password || typeof password !== "string") {
+    return json({ error: "Password required" }, { status: 400 });
+  }
+  if (!validatePassword(password)) {
+    return json({ error: "Invalid password" }, { status: 401 });
+  }
+  const token = createAuthToken();
+  const isSecure = url.protocol === "https:";
+  cookies.set(AUTH_COOKIE.name, token, AUTH_COOKIE.options(isSecure));
+  return json({ success: true });
+};
+export {
+  POST
+};

package/web/.svelte-kit/adapter-node/entries/endpoints/api/auth/logout/_server.ts.js

@@ -0,0 +1,9 @@
+import { json } from "@sveltejs/kit";
+import { A as AUTH_COOKIE } from "../../../../../chunks/auth.js";
+const POST = async ({ cookies }) => {
+  cookies.delete(AUTH_COOKIE.name, { path: "/" });
+  return json({ success: true });
+};
+export {
+  POST
+};

package/web/.svelte-kit/adapter-node/entries/endpoints/api/beads/_server.ts.js

@@ -0,0 +1,22 @@
+import { json } from "@sveltejs/kit";
+import { g as getBeadsIssues } from "../../../../chunks/ws-handlers.js";
+const GET = async ({ url }) => {
+  const project = url.searchParams.get("project");
+  if (!project) {
+    return json({ error: "Missing project parameter" }, { status: 400 });
+  }
+  try {
+    const projectPath = decodeURIComponent(project);
+    const issues = getBeadsIssues(projectPath);
+    return json({
+      issues,
+      project: projectPath,
+      timestamp: Date.now()
+    });
+  } catch (err) {
+    return json({ error: "Failed to fetch beads issues" }, { status: 500 });
+  }
+};
+export {
+  GET
+};

package/web/.svelte-kit/adapter-node/entries/endpoints/api/chrome/_server.ts.js

@@ -0,0 +1,30 @@
+import { json } from "@sveltejs/kit";
+import { execSync } from "child_process";
+const DELETE = async () => {
+  try {
+    let killed = 0;
+    try {
+      const psOutput = execSync(
+        "ps aux | grep -E '(chrome|chromium|brave)' | grep -E 'remote-debugging-(pipe|port)' | grep -v grep | awk '{print $2}'",
+        { encoding: "utf-8" }
+      ).trim();
+      if (psOutput) {
+        const pids = psOutput.split("\n").filter(Boolean);
+        for (const pid of pids) {
+          try {
+            execSync(`kill ${pid}`, { stdio: "ignore" });
+            killed++;
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return json({ ok: true, killed });
+  } catch {
+    return json({ error: "Failed to close Chrome" }, { status: 500 });
+  }
+};
+export {
+  DELETE
+};

package/web/.svelte-kit/adapter-node/entries/endpoints/api/files/image/_server.ts.js

@@ -0,0 +1,53 @@
+import { json } from "@sveltejs/kit";
+import { existsSync, statSync, readFileSync } from "fs";
+import { extname } from "path";
+const MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+const GET = async ({ url }) => {
+  const path = url.searchParams.get("path");
+  if (!path) {
+    return json({ error: "path parameter required" }, { status: 400 });
+  }
+  if (path.includes("..")) {
+    return json({ error: "Invalid path" }, { status: 400 });
+  }
+  try {
+    if (!existsSync(path)) {
+      return json({ error: "File not found" }, { status: 404 });
+    }
+    const stat = statSync(path);
+    if (!stat.isFile()) {
+      return json({ error: "Not a file" }, { status: 400 });
+    }
+    if (stat.size > 50 * 1024 * 1024) {
+      return json({ error: "File too large" }, { status: 413 });
+    }
+    const ext = extname(path).toLowerCase();
+    const mimeType = MIME_TYPES[ext];
+    if (!mimeType) {
+      return json({ error: "Unsupported image format" }, { status: 400 });
+    }
+    const content = readFileSync(path);
+    return new Response(content, {
+      headers: {
+        "Content-Type": mimeType,
+        "Content-Length": String(content.length),
+        "Cache-Control": "public, max-age=300"
+      }
+    });
+  } catch (err) {
+    const e = err;
+    if (e.code === "EACCES") {
+      return json({ error: "Permission denied" }, { status: 403 });
+    }
+    return json({ error: "Failed to read file" }, { status: 500 });
+  }
+};
+export {
+  GET
+};

package/web/.svelte-kit/adapter-node/entries/endpoints/api/sessions/_id_/kill/_server.ts.js

@@ -1,16 +1,22 @@
 import { json } from "@sveltejs/kit";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { d as deleteSession } from "../../../../../../chunks/sessions-json.js";
 const POST = async ({ params, request }) => {
   const id = decodeURIComponent(params.id);
   const body = await request.json().catch(() => ({}));
   const { pid, tmux_target } = body;
   try {
-    if (tmux_target) {
-      const session = tmux_target.split(":")[0];
-      execSync(`tmux kill-session -t "${session}" 2>/dev/null || true`, { stdio: "ignore" });
-    } else if (pid && pid > 0) {
-      execSync(`kill ${pid} 2>/dev/null || true`, { stdio: "ignore" });
+    if (typeof pid === "number" && pid > 0 && Number.isInteger(pid)) {
+      try {
+        execFileSync("kill", [String(pid)], { stdio: "ignore" });
+      } catch {
+      }
+    }
+    if (tmux_target && typeof tmux_target === "string") {
+      try {
+        execFileSync("tmux", ["kill-pane", "-t", tmux_target], { stdio: "ignore" });
+      } catch {
+      }
     }
     try {
       deleteSession(id);

package/web/.svelte-kit/adapter-node/entries/endpoints/api/sessions/_id_/restart/_server.ts.js

@@ -0,0 +1,40 @@
+import { json } from "@sveltejs/kit";
+import { execFileSync } from "child_process";
+import { d as deleteSession } from "../../../../../../chunks/sessions-json.js";
+const POST = async ({ params, request }) => {
+  const id = decodeURIComponent(params.id);
+  const body = await request.json().catch(() => ({}));
+  const { pid, tmux_target, cwd } = body;
+  if (!tmux_target || typeof tmux_target !== "string") {
+    return json({ error: "tmux_target required" }, { status: 400 });
+  }
+  if (!cwd || typeof cwd !== "string") {
+    return json({ error: "cwd required" }, { status: 400 });
+  }
+  try {
+    if (typeof pid === "number" && pid > 0 && Number.isInteger(pid)) {
+      try {
+        execFileSync("kill", ["-9", String(pid)], { stdio: "ignore" });
+      } catch {
+      }
+    }
+    try {
+      deleteSession(id);
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    execFileSync("tmux", ["send-keys", "-t", tmux_target, "C-c"], {
+      stdio: "ignore"
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    execFileSync("tmux", ["send-keys", "-t", tmux_target, `cd "${cwd}" && claude --dangerously-skip-permissions`, "Enter"], {
+      stdio: "ignore"
+    });
+    return json({ ok: true });
+  } catch (err) {
+    return json({ error: "Failed to restart session" }, { status: 500 });
+  }
+};
+export {
+  POST
+};

package/web/.svelte-kit/adapter-node/entries/endpoints/api/sessions/_id_/screenshots/_server.ts.js

@@ -0,0 +1,28 @@
+import { json } from "@sveltejs/kit";
+import { b as getSession, r as removeScreenshot } from "../../../../../../chunks/sessions-json.js";
+const DELETE = async ({ params, url }) => {
+  const id = decodeURIComponent(params.id);
+  const path = url.searchParams.get("path");
+  if (!id) {
+    return json({ error: "Session ID required" }, { status: 400 });
+  }
+  if (!path) {
+    return json({ error: "Screenshot path required" }, { status: 400 });
+  }
+  try {
+    const session = getSession(id);
+    if (!session) {
+      return json({ error: "Session not found" }, { status: 404 });
+    }
+    const removed = removeScreenshot(id, path);
+    if (!removed) {
+      return json({ error: "Screenshot not found" }, { status: 404 });
+    }
+    return json({ ok: true });
+  } catch {
+    return json({ error: "Failed to remove screenshot" }, { status: 500 });
+  }
+};
+export {
+  DELETE
+};

package/web/.svelte-kit/adapter-node/entries/endpoints/api/sessions/_id_/send/_server.ts.js

@@ -1,5 +1,5 @@
 import { json } from "@sveltejs/kit";
-import { execSync } from "child_process";
+import { execSync, execFileSync } from "child_process";
 const POST = async ({ params, request }) => {
   const target = decodeURIComponent(params.id);
   const body = await request.json();
@@ -7,10 +7,17 @@ const POST = async ({ params, request }) => {
   const text = body.text;
   try {
     if (text) {
-      execSync(`tmux send-keys -t "${target}" -l ${JSON.stringify(text)}`, { stdio: "ignore" });
-      execSync(`tmux send-keys -t "${target}" Enter`, { stdio: "ignore" });
+      execSync(`tmux load-buffer -b claude-mux-input -`, {
+        input: text,
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+      execFileSync("tmux", ["paste-buffer", "-b", "claude-mux-input", "-t", target], {
+        stdio: "ignore"
+      });
+      execFileSync("tmux", ["delete-buffer", "-b", "claude-mux-input"], { stdio: "ignore" });
+      execFileSync("tmux", ["send-keys", "-t", target, "Enter"], { stdio: "ignore" });
     } else {
-      execSync(`tmux send-keys -t "${target}" ${keys}`, { stdio: "ignore" });
+      execFileSync("tmux", ["send-keys", "-t", target, keys], { stdio: "ignore" });
     }
     return json({ ok: true });
   } catch {

package/web/.svelte-kit/adapter-node/entries/endpoints/api/sessions/_server.ts.js

@@ -1,83 +1,6 @@
 import { json } from "@sveltejs/kit";
 import { g as getAllSessions, a as updateSession } from "../../../../chunks/sessions-json.js";
-import { execSync } from "child_process";
-function isInTmux() {
-  return !!process.env.TMUX;
-}
-function getPaneTitle(target) {
-  try {
-    const result = execSync(`tmux display-message -p -t "${target}" "#{pane_title}"`, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e3
-    });
-    return result.trim() || null;
-  } catch {
-    return null;
-  }
-}
-function capturePaneContent(target) {
-  if (!isInTmux()) {
-    return null;
-  }
-  try {
-    const result = execSync(`tmux capture-pane -p -t "${target}"`, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e3
-    });
-    return result;
-  } catch {
-    return null;
-  }
-}
-function detectRecentInterruption(content) {
-  if (!content) return null;
-  const lines = content.split("\n");
-  const bottomLines = lines.slice(-5).join("\n");
-  if (bottomLines.includes("Esc to cancel") || bottomLines.includes("Esc to interrupt")) {
-    return null;
-  }
-  let bottomSepIdx = -1;
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (lines[i].startsWith("─────")) {
-      bottomSepIdx = i;
-      break;
-    }
-  }
-  if (bottomSepIdx === -1) return null;
-  let topSepIdx = -1;
-  for (let i = bottomSepIdx - 1; i >= 0; i--) {
-    if (lines[i].startsWith("─────")) {
-      topSepIdx = i;
-      break;
-    }
-  }
-  if (topSepIdx === -1) return null;
-  let interactionStartIdx = -1;
-  const maxScan = Math.max(0, topSepIdx - 15);
-  for (let i = topSepIdx - 1; i >= maxScan; i--) {
-    const line = lines[i];
-    if (line.startsWith("●") || line.startsWith("❯")) {
-      interactionStartIdx = i;
-      break;
-    }
-  }
-  if (interactionStartIdx === -1) return null;
-  const slice = lines.slice(interactionStartIdx, topSepIdx).join("\n");
-  if (slice.includes("Interrupted")) return "interrupted";
-  if (slice.includes("User declined to answer")) return "declined";
-  return null;
-}
-function checkForInterruption(tmuxTarget) {
-  const content = capturePaneContent(tmuxTarget);
-  if (!content) return null;
-  const interruption = detectRecentInterruption(content);
-  if (interruption) {
-    return { state: "idle", current_action: null, prompt_text: null };
-  }
-  return null;
-}
+import { g as getPaneTitle, c as checkForInterruption } from "../../../../chunks/pane.js";
 function syncSessionStates() {
   const sessions = getAllSessions().filter((s) => s.tmux_target);
   for (const session of sessions) {

package/web/.svelte-kit/adapter-node/entries/endpoints/api/sessions/_target_/output/_server.ts.js

@@ -1,9 +1,9 @@
 import { json } from "@sveltejs/kit";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 const GET = async ({ params }) => {
   const target = decodeURIComponent(params.target);
   try {
-    const output = execSync(`tmux capture-pane -t "${target}" -p -S -100`, { encoding: "utf-8" });
+    const output = execFileSync("tmux", ["capture-pane", "-t", target, "-p", "-S", "-100"], { encoding: "utf-8" });
     return json({ output, timestamp: Date.now() });
   } catch {
     return json({ error: "Failed to capture pane" }, { status: 500 });

package/web/.svelte-kit/adapter-node/entries/endpoints/api/tmux/panes/_server.ts.js

@@ -0,0 +1,21 @@
+import { json } from "@sveltejs/kit";
+import { execSync } from "child_process";
+const GET = async () => {
+  try {
+    const output = execSync(
+      'tmux list-panes -a -F "#{session_name}:#{window_index}.#{pane_index}	#{pane_current_command}"',
+      { encoding: "utf-8" }
+    );
+    const panes = output.trim().split("\n").filter(Boolean).map((line) => {
+      const [target, command] = line.split("	");
+      const session = target.split(":")[0];
+      return { target, session, command };
+    });
+    return json(panes);
+  } catch {
+    return json([]);
+  }
+};
+export {
+  GET
+};

package/web/.svelte-kit/adapter-node/entries/fallbacks/error.svelte.js

@@ -1,24 +1,7 @@
 import { g as getContext, e as escape_html } from "../../chunks/context.js";
 import "clsx";
 import "../../chunks/state.svelte.js";
-import "@sveltejs/kit/internal";
-import "../../chunks/exports.js";
-import "../../chunks/utils.js";
-import { w as writable } from "../../chunks/index.js";
-import "@sveltejs/kit/internal/server";
-function create_updated_store() {
-  const { set, subscribe } = writable(false);
-  {
-    return {
-      subscribe,
-      // eslint-disable-next-line @typescript-eslint/require-await
-      check: async () => false
-    };
-  }
-}
-const stores = {
-  updated: /* @__PURE__ */ create_updated_store()
-};
+import { s as stores } from "../../chunks/client.js";
 ({
   check: stores.updated.check
 });

package/web/.svelte-kit/adapter-node/entries/hooks.server.js

@@ -0,0 +1,105 @@
+import { redirect } from "@sveltejs/kit";
+import { S as SessionsWsManager, T as TerminalWsManager, B as BeadsWsManager, p as parseWsPath, h as handleWsMessage, r as resizePane } from "../chunks/ws-handlers.js";
+import { i as isAuthEnabled, A as AUTH_COOKIE, a as validateAuthToken } from "../chunks/auth.js";
+const sessionsWsManager = new SessionsWsManager({ debug: true });
+const terminalWsManager = new TerminalWsManager({ debug: true });
+const beadsWsManager = new BeadsWsManager({ debug: true });
+const wsDataMap = /* @__PURE__ */ new WeakMap();
+const handle = async ({ event, resolve }) => {
+  const pathname = event.url.pathname;
+  const isAuthRoute = pathname.startsWith("/login") || pathname.startsWith("/api/auth");
+  if (isAuthEnabled() && !isAuthRoute) {
+    const token = event.cookies.get(AUTH_COOKIE.name);
+    const isAuthenticated = validateAuthToken(token);
+    if (!isAuthenticated) {
+      if (pathname.startsWith("/api/")) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      throw redirect(302, "/login");
+    }
+  }
+  const connectionHeader = event.request.headers.get("connection");
+  const upgradeHeader = event.request.headers.get("upgrade");
+  if (connectionHeader?.toLowerCase().includes("upgrade") && upgradeHeader?.toLowerCase() === "websocket") {
+    const url = new URL(event.request.url);
+    const parsed = parseWsPath(url.pathname, url.searchParams);
+    if (parsed) {
+      await event.platform.server.upgrade(event.platform.request, {
+        data: parsed
+      });
+      return new Response(null, { status: 101 });
+    }
+  }
+  return resolve(event);
+};
+const websocket = {
+  open(ws) {
+    const data = ws.data;
+    if (!data) return;
+    const client = {
+      send: (msg) => ws.send(msg),
+      isOpen: () => ws.readyState === WebSocket.OPEN,
+      close: () => ws.close(),
+      getBufferedAmount: () => ws.bufferedAmount
+    };
+    wsDataMap.set(ws, { ...data, client });
+    let accepted = false;
+    if (data.type === "sessions") {
+      accepted = sessionsWsManager.addClient(client);
+    } else if (data.type === "terminal" && data.target) {
+      accepted = terminalWsManager.addClient(client, data.target);
+    } else if (data.type === "beads" && data.project) {
+      accepted = beadsWsManager.addClient(client, data.project);
+    }
+    if (!accepted) {
+      ws.close(1013, "Max clients reached");
+    }
+  },
+  message(ws, message) {
+    const msgStr = message.toString();
+    const data = wsDataMap.get(ws);
+    const response = handleWsMessage(
+      msgStr,
+      data?.type === "terminal" && data.target ? (cols, rows) => resizePane(data.target, cols, rows) : void 0
+    );
+    if (response === "pong") {
+      ws.send("pong");
+    }
+  },
+  close(ws) {
+    const data = wsDataMap.get(ws);
+    if (!data) return;
+    if (data.type === "sessions") {
+      sessionsWsManager.removeClient(data.client);
+    } else if (data.type === "terminal") {
+      terminalWsManager.removeClient(data.client, data.target);
+    } else if (data.type === "beads") {
+      beadsWsManager.removeClient(data.client, data.project);
+    }
+    wsDataMap.delete(ws);
+  },
+  error(ws, error) {
+    const data = wsDataMap.get(ws);
+    console.log(`[ws:${data?.type ?? "unknown"}] WebSocket error`, {
+      code: error.code,
+      message: error.message
+    });
+    if (data) {
+      if (data.type === "sessions") {
+        sessionsWsManager.removeClient(data.client);
+      } else if (data.type === "terminal") {
+        terminalWsManager.removeClient(data.client, data.target);
+      } else if (data.type === "beads") {
+        beadsWsManager.removeClient(data.client, data.project);
+      }
+      wsDataMap.delete(ws);
+    }
+  }
+};
+export {
+  handle,
+  websocket
+};