claude-mux 0.7.0

package/web/.svelte-kit/adapter-bun/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-bun/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-bun/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-bun/entries/endpoints/api/browse/_server.ts.js

@@ -0,0 +1,50 @@
+import { json } from "@sveltejs/kit";
+import { homedir } from "os";
+import { existsSync, statSync, readdirSync } from "fs";
+import { resolve, join, dirname } from "path";
+const GET = async ({ url }) => {
+  let targetPath = url.searchParams.get("path") || homedir();
+  const showHidden = url.searchParams.get("showHidden") === "true";
+  if (targetPath.startsWith("~")) {
+    targetPath = targetPath.replace("~", homedir());
+  }
+  targetPath = resolve(targetPath);
+  try {
+    if (!existsSync(targetPath)) {
+      return json({ error: "Directory not found" }, { status: 404 });
+    }
+    const stat = statSync(targetPath);
+    if (!stat.isDirectory()) {
+      return json({ error: "Not a directory" }, { status: 400 });
+    }
+    const entries = readdirSync(targetPath, { withFileTypes: true });
+    const folders = entries.filter((e) => {
+      if (!e.isDirectory()) return false;
+      if (!showHidden && e.name.startsWith(".")) return false;
+      return true;
+    }).map((e) => ({
+      name: e.name,
+      path: join(targetPath, e.name)
+    })).sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    const parent = dirname(targetPath);
+    const isRoot = targetPath === "/" || targetPath === parent;
+    return json({
+      current: targetPath,
+      parent: isRoot ? null : parent,
+      isRoot,
+      folders
+    });
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT") {
+      return json({ error: "Directory not found" }, { status: 404 });
+    }
+    if (error.code === "EACCES") {
+      return json({ error: "Permission denied" }, { status: 403 });
+    }
+    return json({ error: "Failed to read directory" }, { status: 500 });
+  }
+};
+export {
+  GET
+};

package/web/.svelte-kit/adapter-bun/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-bun/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-bun/entries/endpoints/api/health/_server.ts.js

@@ -0,0 +1,7 @@
+import { json } from "@sveltejs/kit";
+const GET = async () => {
+  return json({ status: "ok", timestamp: Date.now() });
+};
+export {
+  GET
+};

package/web/.svelte-kit/adapter-bun/entries/endpoints/api/projects/new-session/_server.ts.js

@@ -0,0 +1,44 @@
+import { json } from "@sveltejs/kit";
+import { existsSync, statSync } from "fs";
+import { execSync } from "child_process";
+import { u as upsertSession } from "../../../../../chunks/sessions-json.js";
+const POST = async ({ request }) => {
+  const { cwd } = await request.json();
+  if (!cwd) {
+    return json({ error: "cwd required" }, { status: 400 });
+  }
+  if (!existsSync(cwd)) {
+    return json({ error: "Folder does not exist" }, { status: 400 });
+  }
+  const stat = statSync(cwd);
+  if (!stat.isDirectory()) {
+    return json({ error: "Path is not a directory" }, { status: 400 });
+  }
+  try {
+    const sessionName = "claude-" + Date.now();
+    const tmuxTarget = sessionName + ":1.1";
+    execSync(`tmux new-session -d -s "${sessionName}" -c "${cwd}" -- claude --dangerously-skip-permissions`, {
+      stdio: "ignore"
+    });
+    try {
+      const id = crypto.randomUUID();
+      console.log("[new-session] Creating session:", { id, cwd, tmuxTarget });
+      upsertSession({
+        id,
+        pid: 0,
+        cwd,
+        tmux_target: tmuxTarget,
+        state: "idle"
+      });
+      console.log("[new-session] Session created successfully");
+    } catch (err) {
+      console.error("[new-session] Session creation failed:", err);
+    }
+    return json({ ok: true, session: sessionName });
+  } catch {
+    return json({ error: "Failed to create session" }, { status: 500 });
+  }
+};
+export {
+  POST
+};

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

@@ -0,0 +1,20 @@
+import { json } from "@sveltejs/kit";
+import { b as getSession } from "../../../../../chunks/sessions-json.js";
+const GET = async ({ params }) => {
+  const id = params.id;
+  try {
+    const session = getSession(id);
+    if (!session) {
+      return json({ error: "Session not found", id }, { status: 404 });
+    }
+    return json({
+      session,
+      timestamp: Date.now()
+    });
+  } catch {
+    return json({ error: "Error reading session" }, { status: 500 });
+  }
+};
+export {
+  GET
+};

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

@@ -0,0 +1,36 @@
+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 } = body;
+  try {
+    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);
+    } catch {
+    }
+    return json({ ok: true });
+  } catch {
+    try {
+      deleteSession(id);
+    } catch {
+    }
+    return json({ ok: true });
+  }
+};
+export {
+  POST
+};

package/web/.svelte-kit/adapter-bun/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-bun/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-bun/entries/endpoints/api/sessions/_id_/send/_server.ts.js

@@ -0,0 +1,29 @@
+import { json } from "@sveltejs/kit";
+import { execSync, execFileSync } from "child_process";
+const POST = async ({ params, request }) => {
+  const target = decodeURIComponent(params.id);
+  const body = await request.json();
+  const keys = body.keys || "Escape";
+  const text = body.text;
+  try {
+    if (text) {
+      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 {
+      execFileSync("tmux", ["send-keys", "-t", target, keys], { stdio: "ignore" });
+    }
+    return json({ ok: true });
+  } catch {
+    return json({ error: "Failed to send keys" }, { status: 500 });
+  }
+};
+export {
+  POST
+};

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

@@ -0,0 +1,49 @@
+import { json } from "@sveltejs/kit";
+import { g as getAllSessions, a as updateSession } from "../../../../chunks/sessions-json.js";
+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) {
+    if (!session.tmux_target) continue;
+    const update = checkForInterruption(session.tmux_target);
+    if (update && session.state !== "idle") {
+      updateSession(session.id, update);
+    }
+  }
+}
+function deduplicateByTmuxTarget(sessions) {
+  const byTarget = /* @__PURE__ */ new Map();
+  const noTarget = [];
+  for (const session of sessions) {
+    if (!session.tmux_target) {
+      noTarget.push(session);
+      continue;
+    }
+    const existing = byTarget.get(session.tmux_target);
+    if (!existing || session.last_update > existing.last_update) {
+      byTarget.set(session.tmux_target, session);
+    }
+  }
+  return [...byTarget.values(), ...noTarget];
+}
+const GET = async () => {
+  try {
+    syncSessionStates();
+    const sessions = getAllSessions();
+    const enrichedSessions = sessions.map((s) => ({
+      ...s,
+      pane_title: s.tmux_target ? getPaneTitle(s.tmux_target) : null
+    }));
+    const dedupedSessions = deduplicateByTmuxTarget(enrichedSessions);
+    return json({
+      sessions: dedupedSessions,
+      count: dedupedSessions.length,
+      timestamp: Date.now()
+    });
+  } catch {
+    return json({ error: "Error reading sessions" }, { status: 500 });
+  }
+};
+export {
+  GET
+};

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

@@ -0,0 +1,14 @@
+import { json } from "@sveltejs/kit";
+import { execFileSync } from "child_process";
+const GET = async ({ params }) => {
+  const target = decodeURIComponent(params.target);
+  try {
+    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 });
+  }
+};
+export {
+  GET
+};

package/web/.svelte-kit/adapter-bun/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-bun/entries/fallbacks/error.svelte.js

@@ -0,0 +1,27 @@
+import { g as getContext, e as escape_html } from "../../chunks/context.js";
+import "clsx";
+import "../../chunks/state.svelte.js";
+import { s as stores } from "../../chunks/client.js";
+({
+  check: stores.updated.check
+});
+function context() {
+  return getContext("__request__");
+}
+const page$1 = {
+  get error() {
+    return context().page.error;
+  },
+  get status() {
+    return context().page.status;
+  }
+};
+const page = page$1;
+function Error$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    $$renderer2.push(`<h1>${escape_html(page.status)}</h1> <p>${escape_html(page.error?.message)}</p>`);
+  });
+}
+export {
+  Error$1 as default
+};

package/web/.svelte-kit/adapter-bun/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
+};