@chrisjowen/wheelhouse 0.2.0 → 0.2.1

package/build/server/chunks/chunks/internal.js-CxWYnS4m.js

@@ -0,0 +1,146 @@
+import { r as root } from './root.js-60iebdW4.js';
+
+let read_implementation = null;
+function set_read_implementation(fn) {
+  read_implementation = fn;
+}
+let public_env = {};
+function set_private_env(environment) {
+}
+function set_public_env(environment) {
+  public_env = environment;
+}
+const error = ({ status, message }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<title>' + message + `</title>
+
+		<style>
+			body {
+				--bg: white;
+				--fg: #222;
+				--divider: #ccc;
+				background: var(--bg);
+				color: var(--fg);
+				font-family:
+					system-ui,
+					-apple-system,
+					BlinkMacSystemFont,
+					'Segoe UI',
+					Roboto,
+					Oxygen,
+					Ubuntu,
+					Cantarell,
+					'Open Sans',
+					'Helvetica Neue',
+					sans-serif;
+				display: flex;
+				align-items: center;
+				justify-content: center;
+				height: 100vh;
+				margin: 0;
+			}
+
+			.error {
+				display: flex;
+				align-items: center;
+				max-width: 32rem;
+				margin: 0 1rem;
+			}
+
+			.status {
+				font-weight: 200;
+				font-size: 3rem;
+				line-height: 1;
+				position: relative;
+				top: -0.05rem;
+			}
+
+			.message {
+				border-left: 1px solid var(--divider);
+				padding: 0 0 0 1rem;
+				margin: 0 0 0 1rem;
+				min-height: 2.5rem;
+				display: flex;
+				align-items: center;
+			}
+
+			.message h1 {
+				font-weight: 400;
+				font-size: 1em;
+				margin: 0;
+			}
+
+			@media (prefers-color-scheme: dark) {
+				body {
+					--bg: #222;
+					--fg: #ddd;
+					--divider: #666;
+				}
+			}
+		</style>
+	</head>
+	<body>
+		<div class="error">
+			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n";
+const options = {
+  app_template_contains_nonce: false,
+  async: false,
+  csp: { "mode": "auto", "directives": { "upgrade-insecure-requests": false, "block-all-mixed-content": false }, "reportOnly": { "upgrade-insecure-requests": false, "block-all-mixed-content": false } },
+  csrf_check_origin: true,
+  csrf_trusted_origins: [],
+  embedded: false,
+  env_public_prefix: "PUBLIC_",
+  env_private_prefix: "",
+  hash_routing: false,
+  hooks: null,
+  // added lazily, via `get_hooks`
+  preload_strategy: "modulepreload",
+  root,
+  service_worker: false,
+  service_worker_options: void 0,
+  server_error_boundaries: false,
+  templates: {
+    app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<meta name="viewport" content="width=device-width, initial-scale=1" />\n		<link rel="icon" href="' + assets + `/favicon.svg" />
+		<script>
+			// Apply the theme before first paint: ?theme=, then the saved choice, then the OS.
+			(function () {
+				var q = new URLSearchParams(location.search).get('theme');
+				var saved = null;
+				try {
+					saved = localStorage.getItem('wheelhouse-theme');
+				} catch (e) {}
+				var t = q === 'dark' || q === 'light' ? q : saved;
+				var dark = t ? t === 'dark' : matchMedia('(prefers-color-scheme: dark)').matches;
+				document.documentElement.classList.toggle('dark', dark);
+				// The left-hand menu folded to its icon rail, as last chosen.
+				try {
+					if (localStorage.getItem('wheelhouse-nav') === 'rail')
+						document.documentElement.dataset.nav = 'rail';
+				} catch (e) {}
+			})();
+		<\/script>
+		` + head + '\n	</head>\n	<body data-sveltekit-preload-data="hover">\n		<div style="display: contents">' + body + "</div>\n	</body>\n</html>\n",
+    error
+  },
+  version_hash: "13n6tx6"
+};
+async function get_hooks() {
+  let handle;
+  let handleFetch;
+  let handleError;
+  let handleValidationError;
+  let init;
+  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('../entries/hooks.server.js-BeVVnKyB.js'));
+  let reroute;
+  let transport;
+  return {
+    handle,
+    handleFetch,
+    handleError,
+    handleValidationError,
+    init,
+    reroute,
+    transport
+  };
+}
+
+export { set_public_env as a, set_read_implementation as b, get_hooks as g, options as o, public_env as p, read_implementation as r, set_private_env as s };
+//# sourceMappingURL=internal.js-CxWYnS4m.js.map

package/build/server/chunks/chunks/keys.js-iHygUPeb.js

@@ -0,0 +1,20 @@
+const slotKey = {
+  fleet: "fleet",
+  project: (id) => `project=${encodeURIComponent(id)}`,
+  task: (id) => `task=${encodeURIComponent(id)}`
+};
+function parseSlotKey(key) {
+  if (key.startsWith("project=")) {
+    return { scope: "project", projectId: decodeURIComponent(key.slice("project=".length)) };
+  }
+  if (key.startsWith("task=")) {
+    return { scope: "task", taskId: decodeURIComponent(key.slice("task=".length)) };
+  }
+  return { scope: "fleet" };
+}
+const slotsUrl = (key) => key === slotKey.fleet ? "/api/slots" : `/api/slots?${key}`;
+const projectTabHref = (projectId, e) => `/projects/${encodeURIComponent(projectId)}/${encodeURIComponent(e.pluginId)}/${encodeURIComponent(e.contributionId)}`;
+const navPageHref = (e) => `/plugins/${encodeURIComponent(e.pluginId)}/${encodeURIComponent(e.contributionId)}`;
+
+export { parseSlotKey as a, slotsUrl as b, navPageHref as n, projectTabHref as p, slotKey as s };
+//# sourceMappingURL=keys.js-iHygUPeb.js.map

package/build/server/chunks/chunks/live.svelte.js-DavJCZVs.js

@@ -0,0 +1,238 @@
+import { p as page } from './index2.js-Bxt1T6_K.js';
+
+const LOST_AFTER_MS = 5e3;
+const REOPEN_MS = 3e3;
+function watchedStream(url, listen, report) {
+  let state = "connecting";
+  let es = null;
+  let lostTimer = null;
+  let reopenTimer = null;
+  const set = (s) => {
+    state = s;
+    report(s);
+  };
+  const lost = () => {
+    if (lostTimer) clearTimeout(lostTimer);
+    lostTimer = null;
+    set("lost");
+  };
+  const open = () => {
+    reopenTimer = null;
+    const source = new EventSource(url);
+    es = source;
+    source.addEventListener("open", () => {
+      if (lostTimer) clearTimeout(lostTimer);
+      lostTimer = null;
+      set("open");
+    });
+    source.addEventListener("error", () => {
+      if (source.readyState === EventSource.CLOSED) {
+        source.close();
+        lost();
+        reopenTimer ??= setTimeout(open, REOPEN_MS);
+        return;
+      }
+      if (state !== "lost") set("connecting");
+      lostTimer ??= setTimeout(lost, LOST_AFTER_MS);
+    });
+    listen(source);
+  };
+  open();
+  return () => {
+    if (lostTimer) clearTimeout(lostTimer);
+    if (reopenTimer) clearTimeout(reopenTimer);
+    es?.close();
+    es = null;
+  };
+}
+const CHANNEL = "wheelhouse-live";
+const LOCK = "wheelhouse-live-leader";
+const CATCH_UP_MS = 2 * 6e4;
+class Live {
+  fleet = null;
+  health = null;
+  messages = null;
+  /** Our own connection to the Wheelhouse server (not Firstmate's state). */
+  connection = "connecting";
+  /** Ticks every 15 s so relative times stay current. */
+  now = Date.now();
+  /** Bumps on every fleet event, for pages that refetch detail. */
+  revision = 0;
+  /** This tab holds the browser's one stream. */
+  leader = false;
+  /**
+   * Set by the ship's bell: called once, in the leader, for each alert the
+   * stream delivers; true when this browser has not rung it before.
+   */
+  claim = () => true;
+  // Plumbing, not page state: nothing renders from these.
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  alertListeners = /* @__PURE__ */ new Set();
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  restartListeners = /* @__PURE__ */ new Set();
+  /** The server process this page has been talking to. */
+  serverId = null;
+  /** The leader's latest of each event, for tabs that open later. */
+  latest = {};
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  recentAlerts = /* @__PURE__ */ new Map();
+  channel = null;
+  stop = null;
+  /** Alerts as they arrive, in every tab. */
+  onAlert(fn) {
+    this.alertListeners.add(fn);
+    return () => this.alertListeners.delete(fn);
+  }
+  /** Called in every tab when the stream comes back from a restarted server. */
+  onRestart(fn) {
+    this.restartListeners.add(fn);
+    return () => this.restartListeners.delete(fn);
+  }
+  connect() {
+    if (this.stop) return () => {
+    };
+    const clock = setInterval(() => this.now = Date.now(), 15e3);
+    const shared = typeof BroadcastChannel !== "undefined" && !!globalThis.navigator?.locks;
+    const end = shared ? this.share() : this.lead();
+    this.stop = () => {
+      clearInterval(clock);
+      end();
+      this.stop = null;
+    };
+    return this.stop;
+  }
+  /** Join the browser's shared stream: lead when this tab gets the lock, else follow. */
+  share() {
+    const channel = new BroadcastChannel(CHANNEL);
+    this.channel = channel;
+    channel.onmessage = (m) => {
+      const msg = m.data;
+      if (msg.t === "hello") {
+        if (this.leader) this.replay();
+      } else if (msg.t === "connection") {
+        if (!this.leader) this.connection = msg.state;
+      } else if (!this.leader) {
+        this.apply(msg.e);
+      }
+    };
+    const abort = new AbortController();
+    let release = () => {
+    };
+    navigator.locks.request(LOCK, { signal: abort.signal }, () => {
+      const stopStream = this.lead();
+      return new Promise((resolve) => {
+        release = () => {
+          stopStream();
+          resolve();
+        };
+      });
+    }).catch(() => {
+    });
+    channel.postMessage({ t: "hello" });
+    return () => {
+      abort.abort();
+      release();
+      channel.close();
+      this.channel = null;
+    };
+  }
+  /** Hold the stream: apply each event here and pass it to the other tabs. */
+  lead() {
+    this.leader = true;
+    const state = (s) => {
+      this.connection = s;
+      this.post({ t: "connection", state: s });
+    };
+    const listen = (es) => {
+      const on = (type, make) => es.addEventListener(type, (e) => {
+        const ev = make(JSON.parse(e.data));
+        this.remember(ev);
+        this.apply(ev);
+        this.post({ t: "event", e: ev });
+        if (ev.type === "fleet") state("open");
+      });
+      on("server", (data) => ({ type: "server", data }));
+      on("fleet", (data) => ({ type: "fleet", data }));
+      on("health", (data) => ({ type: "health", data }));
+      on("messages", (data) => ({ type: "messages", data }));
+      on("alert", (data) => ({ type: "alert", data, fresh: this.claim(data) }));
+      on("settled", (data) => ({ type: "settled", data }));
+      on("alerts", (data) => ({
+        type: "alerts",
+        data: data.map((alert) => {
+          const claimed = this.claim(alert);
+          return {
+            alert,
+            fresh: claimed && Date.now() - Date.parse(alert.at) <= CATCH_UP_MS
+          };
+        })
+      }));
+    };
+    const close = watchedStream("/api/events", listen, state);
+    return () => {
+      close();
+      this.leader = false;
+    };
+  }
+  remember(ev) {
+    if (ev.type === "alert") this.recentAlerts.set(ev.data.id, ev.data);
+    else if (ev.type === "settled") this.recentAlerts.delete(ev.data);
+    else if (ev.type === "alerts") for (const a of ev.data) this.recentAlerts.set(a.alert.id, a.alert);
+    else this.latest[ev.type] = ev.data;
+    for (const id of [...this.recentAlerts.keys()].slice(0, -40)) {
+      this.recentAlerts.delete(id);
+    }
+  }
+  /** A tab has just opened: send it what the leader has (alerts as old news). */
+  replay() {
+    this.post({ t: "connection", state: this.connection });
+    if (this.latest.fleet) this.post({ t: "event", e: { type: "fleet", data: this.latest.fleet } });
+    if (this.latest.health) this.post({ t: "event", e: { type: "health", data: this.latest.health } });
+    if (this.latest.messages) this.post({
+      t: "event",
+      e: { type: "messages", data: this.latest.messages }
+    });
+    if (this.latest.server) this.post({ t: "event", e: { type: "server", data: this.latest.server } });
+    const alerts = [...this.recentAlerts.values()].map((alert) => ({ alert, fresh: false }));
+    this.post({ t: "event", e: { type: "alerts", data: alerts } });
+  }
+  apply(ev) {
+    switch (ev.type) {
+      case "fleet":
+        this.fleet = ev.data;
+        this.revision++;
+        this.connection = "open";
+        break;
+      case "health":
+        this.health = ev.data;
+        break;
+      case "messages":
+        this.messages = ev.data;
+        break;
+      case "server": {
+        const restarted = this.serverId !== null && this.serverId !== ev.data.id;
+        this.serverId = ev.data.id;
+        if (restarted) for (const fn of this.restartListeners) fn();
+        break;
+      }
+      default:
+        for (const fn of this.alertListeners) fn(ev);
+    }
+  }
+  post(msg) {
+    try {
+      this.channel?.postMessage(msg);
+    } catch {
+    }
+  }
+}
+const live = new Live();
+function currentFleet() {
+  return live.fleet ?? page.data.fleet ?? null;
+}
+function currentHealth() {
+  return live.health ?? page.data.health ?? null;
+}
+
+export { currentFleet as a, currentHealth as c, live as l, watchedStream as w };
+//# sourceMappingURL=live.svelte.js-DavJCZVs.js.map

package/build/server/chunks/chunks/pullrequests.js-CWGxTy8C.js

@@ -0,0 +1,68 @@
+import { ac as spread_props } from './index.js-B0NFhRTN.js';
+import { I as Icon } from './Icon.js-CVZZ-yuB.js';
+import { p as page } from './index2.js-Bxt1T6_K.js';
+import { p as pullRequestReview } from './pullrequests2.js-CCzk2sqm.js';
+
+function Compass($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "compass",
+    "size": 24,
+    "node": [
+      ["circle", { "cx": "12", "cy": "12", "r": "10" }],
+      [
+        "path",
+        {
+          "d": "m16.24 7.76-1.804 5.411a2 2 0 0 1-1.265 1.265L7.76 16.24l1.804-5.411a2 2 0 0 1 1.265-1.265z"
+        }
+      ]
+    ]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+function Git_pull_request($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "git-pull-request",
+    "size": 24,
+    "node": [
+      ["circle", { "cx": "18", "cy": "18", "r": "3" }],
+      ["circle", { "cx": "6", "cy": "6", "r": "3" }],
+      ["path", { "d": "M13 6h3a2 2 0 0 1 2 2v7" }],
+      ["line", { "x1": "6", "x2": "6", "y1": "9", "y2": "21" }]
+    ]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+function Monitor_play($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "monitor-play",
+    "size": 24,
+    "node": [
+      [
+        "path",
+        {
+          "d": "M15.033 9.44a.647.647 0 0 1 0 1.12l-4.065 2.352a.645.645 0 0 1-.968-.56V7.648a.645.645 0 0 1 .967-.56z"
+        }
+      ],
+      ["path", { "d": "M12 17v4" }],
+      ["path", { "d": "M8 21h8" }],
+      [
+        "rect",
+        { "x": "2", "y": "3", "width": "20", "height": "14", "rx": "2" }
+      ]
+    ]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+const pullRequests = {
+  /** The Review link for `pr`, one of `projectId`'s pull requests. */
+  review(projectId, pr) {
+    const tabs = page.data?.pullRequestTabs ?? {};
+    return pullRequestReview(tabs, projectId, pr);
+  }
+};
+
+export { Compass as C, Git_pull_request as G, Monitor_play as M, pullRequests as p };
+//# sourceMappingURL=pullrequests.js-CWGxTy8C.js.map

package/build/server/chunks/chunks/pullrequests2.js-CCzk2sqm.js

@@ -0,0 +1,12 @@
+const PR_URL = "{url}";
+function validPullRequestQuery(v) {
+  return typeof v === "string" && v.length <= 200 && /^\?[\x21-\x7e]*$/.test(v) && !v.includes("#") && v.split(PR_URL).length === 2;
+}
+function pullRequestReview(tabs, projectId, pr) {
+  const tab = projectId && Object.hasOwn(tabs, projectId) ? tabs[projectId] : null;
+  if (typeof tab !== "string") return { href: pr.url, external: true };
+  return { href: tab.replace(PR_URL, encodeURIComponent(pr.url)), external: false };
+}
+
+export { pullRequestReview as p, validPullRequestQuery as v };
+//# sourceMappingURL=pullrequests2.js-CCzk2sqm.js.map

package/build/server/chunks/chunks/repo.js-DU-pK5Nw.js

@@ -0,0 +1,33 @@
+import { R as runBounded } from './runtime.js-4msnOWzY.js';
+
+function webUrl(remote) {
+  const s = remote.trim();
+  const scp = /^[\w.-]+@([\w.-]+):([\w.-]+\/[\w.-]+?)(?:\.git)?\/?$/.exec(s);
+  if (scp) return `https://${scp[1]}/${scp[2]}`;
+  let u;
+  try {
+    u = new URL(s);
+  } catch {
+    return null;
+  }
+  if (!["https:", "http:", "ssh:", "git:"].includes(u.protocol)) return null;
+  const repo = /^\/([\w.-]+\/[\w.-]+?)(?:\.git)?\/?$/.exec(u.pathname);
+  if (!repo || !/^[\w.-]+$/.test(u.hostname)) return null;
+  return `https://${u.hostname}/${repo[1]}`;
+}
+const cache = /* @__PURE__ */ new Map();
+const TTL_MS = 6e4;
+function repoUrl(dir, now = Date.now()) {
+  if (!dir) return Promise.resolve(null);
+  const hit = cache.get(dir);
+  if (hit && now - hit.at < TTL_MS) return hit.value;
+  const value = runBounded("git", ["-C", dir, "remote", "get-url", "origin"], {
+    timeoutMs: 2e3,
+    maxOutputBytes: 4096
+  }).then((r) => r.ok ? webUrl(r.stdout) : null);
+  cache.set(dir, { at: now, value });
+  return value;
+}
+
+export { repoUrl as r };
+//# sourceMappingURL=repo.js-DU-pK5Nw.js.map