claude-mux 0.7.0 → 0.7.1

package/web/.svelte-kit/adapter-node/chunks/auth.js

@@ -0,0 +1,59 @@
+import { createHmac } from "crypto";
+const COOKIE_NAME = "claude-mux-session";
+const MAX_AGE = 60 * 60 * 24 * 7;
+function isAuthEnabled() {
+  return !!process.env.CLAUDE_WATCH_PASSWORD;
+}
+function getPassword() {
+  return process.env.CLAUDE_WATCH_PASSWORD || "";
+}
+function validatePassword(password) {
+  const expected = getPassword();
+  if (!expected) return false;
+  if (password.length !== expected.length) return false;
+  let result = 0;
+  for (let i = 0; i < password.length; i++) {
+    result |= password.charCodeAt(i) ^ expected.charCodeAt(i);
+  }
+  return result === 0;
+}
+function createAuthToken() {
+  const timestamp = Date.now().toString();
+  const signature = createHmac("sha256", getPassword()).update(timestamp).digest("hex");
+  return `${timestamp}:${signature}`;
+}
+function validateAuthToken(token) {
+  if (!token || !isAuthEnabled()) return false;
+  const parts = token.split(":");
+  if (parts.length !== 2) return false;
+  const [timestamp, signature] = parts;
+  const tokenAge = Date.now() - parseInt(timestamp, 10);
+  if (isNaN(tokenAge) || tokenAge > MAX_AGE * 1e3 || tokenAge < 0) {
+    return false;
+  }
+  const expectedSignature = createHmac("sha256", getPassword()).update(timestamp).digest("hex");
+  if (signature.length !== expectedSignature.length) return false;
+  let result = 0;
+  for (let i = 0; i < signature.length; i++) {
+    result |= signature.charCodeAt(i) ^ expectedSignature.charCodeAt(i);
+  }
+  return result === 0;
+}
+const AUTH_COOKIE = {
+  name: COOKIE_NAME,
+  maxAge: MAX_AGE,
+  options: (isSecure) => ({
+    httpOnly: true,
+    sameSite: "lax",
+    path: "/",
+    maxAge: MAX_AGE,
+    secure: isSecure
+  })
+};
+export {
+  AUTH_COOKIE as A,
+  validateAuthToken as a,
+  createAuthToken as c,
+  isAuthEnabled as i,
+  validatePassword as v
+};

package/web/.svelte-kit/adapter-node/chunks/button.js

@@ -0,0 +1,82 @@
+import { a6 as attributes, aa as clsx$1, a7 as bind_props } from "./index2.js";
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+import { tv } from "tailwind-variants";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+const buttonVariants = tv({
+  base: "cursor-pointer focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex shrink-0 items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-all outline-none focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  variants: {
+    variant: {
+      default: "bg-primary text-primary-foreground hover:bg-primary/90 shadow-xs",
+      destructive: "bg-destructive hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60 text-white shadow-xs",
+      outline: "bg-background hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 border shadow-xs",
+      secondary: "bg-[#222] text-stone-100 hover:bg-[#333] shadow-xs",
+      ghost: "text-stone-400 hover:bg-[#222] hover:text-stone-100",
+      "ghost-destructive": "bg-red-900 text-red-300 hover:bg-red-800 hover:text-white",
+      warning: "bg-amber-700 text-amber-100 hover:bg-amber-600 shadow-xs",
+      success: "bg-emerald-600 text-white hover:bg-emerald-500 active:bg-emerald-700 shadow-xs",
+      link: "text-primary underline-offset-4 hover:underline"
+    },
+    size: {
+      default: "h-9 px-4 py-2 has-[>svg]:px-3",
+      sm: "h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5",
+      lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+      icon: "size-9",
+      "icon-sm": "size-8",
+      "icon-lg": "size-10",
+      toolbar: "flex-col gap-0.5 px-2 py-1.5 min-w-11 h-auto [&_svg]:size-[18px] text-[9px] uppercase tracking-wide"
+    }
+  },
+  defaultVariants: { variant: "default", size: "default" }
+});
+function Button($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      class: className,
+      variant = "default",
+      size = "default",
+      ref = null,
+      href = void 0,
+      type = "button",
+      disabled,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    if (href) {
+      $$renderer2.push("<!--[-->");
+      $$renderer2.push(`<a${attributes({
+        "data-slot": "button",
+        class: clsx$1(cn(buttonVariants({ variant, size }), className)),
+        href: disabled ? void 0 : href,
+        "aria-disabled": disabled,
+        role: disabled ? "link" : void 0,
+        tabindex: disabled ? -1 : void 0,
+        ...restProps
+      })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></a>`);
+    } else {
+      $$renderer2.push("<!--[!-->");
+      $$renderer2.push(`<button${attributes({
+        "data-slot": "button",
+        class: clsx$1(cn(buttonVariants({ variant, size }), className)),
+        type,
+        disabled,
+        ...restProps
+      })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></button>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+export {
+  Button as B,
+  buttonVariants as b,
+  cn as c
+};

package/web/.svelte-kit/adapter-node/chunks/client.js

@@ -0,0 +1,29 @@
+import "clsx";
+import "@sveltejs/kit/internal";
+import "./exports.js";
+import "./utils.js";
+import { w as writable } from "./index.js";
+import "@sveltejs/kit/internal/server";
+import "./state.svelte.js";
+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()
+};
+function goto(url, opts = {}) {
+  {
+    throw new Error("Cannot call goto(...) on the server");
+  }
+}
+export {
+  goto as g,
+  stores as s
+};

package/web/.svelte-kit/adapter-node/chunks/context.js

@@ -10,6 +10,9 @@ var get_prototype_of = Object.getPrototypeOf;
 var is_extensible = Object.isExtensible;
 const noop = () => {
 };
+function run(fn) {
+  return fn();
+}
 function run_all(arr) {
   for (var i = 0; i < arr.length; i++) {
     arr[i]();
@@ -70,6 +73,12 @@ function setContext(key, context) {
   get_or_init_context_map().set(key, context);
   return context;
 }
+function hasContext(key) {
+  return get_or_init_context_map().has(key);
+}
+function getAllContexts() {
+  return get_or_init_context_map();
+}
 function get_or_init_context_map(name) {
   if (ssr_context === null) {
     lifecycle_outside_component();
@@ -96,26 +105,29 @@ function get_parent_context(ssr_context2) {
 }
 export {
   array_from as a,
-  safe_not_equal as b,
-  ssr_context as c,
+  get_prototype_of as b,
+  getAllContexts as c,
   define_property as d,
   escape_html as e,
-  deferred as f,
+  ssr_context as f,
   getContext as g,
-  safe_equals as h,
-  includes as i,
-  equals as j,
-  array_prototype as k,
-  get_descriptor as l,
-  get_prototype_of as m,
+  hasContext as h,
+  is_array as i,
+  safe_not_equal as j,
+  run_all as k,
+  deferred as l,
+  includes as m,
   noop as n,
   object_prototype as o,
-  is_array as p,
-  is_extensible as q,
-  run_all as r,
+  safe_equals as p,
+  equals as q,
+  run as r,
   setContext as s,
-  index_of as t,
-  set_ssr_context as u,
-  push as v,
-  pop as w
+  array_prototype as t,
+  get_descriptor as u,
+  is_extensible as v,
+  index_of as w,
+  set_ssr_context as x,
+  push as y,
+  pop as z
 };

package/web/.svelte-kit/adapter-node/chunks/events.js

@@ -0,0 +1,121 @@
+import { n as set_active_reaction, m as set_active_effect, f as active_effect, v as active_reaction, q as queue_micro_task, ad as without_reactive_context } from "./index2.js";
+import { d as define_property } from "./context.js";
+const all_registered_events = /* @__PURE__ */ new Set();
+const root_event_handles = /* @__PURE__ */ new Set();
+function create_event(event_name, dom, handler, options = {}) {
+  function target_handler(event) {
+    if (!options.capture) {
+      handle_event_propagation.call(dom, event);
+    }
+    if (!event.cancelBubble) {
+      return without_reactive_context(() => {
+        return handler?.call(this, event);
+      });
+    }
+  }
+  if (event_name.startsWith("pointer") || event_name.startsWith("touch") || event_name === "wheel") {
+    queue_micro_task(() => {
+      dom.addEventListener(event_name, target_handler, options);
+    });
+  } else {
+    dom.addEventListener(event_name, target_handler, options);
+  }
+  return target_handler;
+}
+function on(element, type, handler, options = {}) {
+  var target_handler = create_event(type, element, handler, options);
+  return () => {
+    element.removeEventListener(type, target_handler, options);
+  };
+}
+let last_propagated_event = null;
+function handle_event_propagation(event) {
+  var handler_element = this;
+  var owner_document = (
+    /** @type {Node} */
+    handler_element.ownerDocument
+  );
+  var event_name = event.type;
+  var path = event.composedPath?.() || [];
+  var current_target = (
+    /** @type {null | Element} */
+    path[0] || event.target
+  );
+  last_propagated_event = event;
+  var path_idx = 0;
+  var handled_at = last_propagated_event === event && event.__root;
+  if (handled_at) {
+    var at_idx = path.indexOf(handled_at);
+    if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
+    window)) {
+      event.__root = handler_element;
+      return;
+    }
+    var handler_idx = path.indexOf(handler_element);
+    if (handler_idx === -1) {
+      return;
+    }
+    if (at_idx <= handler_idx) {
+      path_idx = at_idx;
+    }
+  }
+  current_target = /** @type {Element} */
+  path[path_idx] || event.target;
+  if (current_target === handler_element) return;
+  define_property(event, "currentTarget", {
+    configurable: true,
+    get() {
+      return current_target || owner_document;
+    }
+  });
+  var previous_reaction = active_reaction;
+  var previous_effect = active_effect;
+  set_active_reaction(null);
+  set_active_effect(null);
+  try {
+    var throw_error;
+    var other_errors = [];
+    while (current_target !== null) {
+      var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
+      current_target.host || null;
+      try {
+        var delegated = current_target["__" + event_name];
+        if (delegated != null && (!/** @type {any} */
+        current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+        // -> the target could not have been disabled because it emits the event in the first place
+        event.target === current_target)) {
+          delegated.call(current_target, event);
+        }
+      } catch (error) {
+        if (throw_error) {
+          other_errors.push(error);
+        } else {
+          throw_error = error;
+        }
+      }
+      if (event.cancelBubble || parent_element === handler_element || parent_element === null) {
+        break;
+      }
+      current_target = parent_element;
+    }
+    if (throw_error) {
+      for (let error of other_errors) {
+        queueMicrotask(() => {
+          throw error;
+        });
+      }
+      throw throw_error;
+    }
+  } finally {
+    event.__root = handler_element;
+    delete event.currentTarget;
+    set_active_reaction(previous_reaction);
+    set_active_effect(previous_effect);
+  }
+}
+export {
+  all_registered_events as a,
+  handle_event_propagation as h,
+  on as o,
+  root_event_handles as r
+};

package/web/.svelte-kit/adapter-node/chunks/index.js

@@ -1,4 +1,4 @@
-import { n as noop, b as safe_not_equal } from "./context.js";
+import { n as noop, j as safe_not_equal } from "./context.js";
 import "clsx";
 const subscriber_queue = [];
 function readable(value, start) {