npm - @hyperdrive.bot/fleet-server - Versions diffs - 0.3.99 - Mend

@hyperdrive.bot/fleet-server 0.3.99

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (991) hide show

package/dist/server/web-ui/index.html ADDED Viewed

@@ -0,0 +1,196 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="robots" content="noindex,nofollow" />
+    <meta name="theme-color" content="#181B1A" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-title" content="Paseo" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, shrink-to-fit=no, viewport-fit=cover"
+    />
+    <link rel="manifest" href="/manifest.json" />
+    <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+    <title>Paseo</title>
+    <!-- The `react-native-web` recommended style reset: https://necolas.github.io/react-native-web/docs/setup/#root-element -->
+    <style id="expo-reset">
+      /* Keep the app shell fixed to the viewport. */
+      html,
+      body {
+        width: 100%;
+        height: 100%;
+        margin: 0;
+        padding: 0;
+        overflow: hidden;
+        overscroll-behavior: none;
+      }
+      /* These styles smooth text rendering in the app shell. */
+      body {
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+      }
+      /* Prevent white flash before React mounts */
+      @media (prefers-color-scheme: dark) {
+        html,
+        body {
+          background-color: #181b1a;
+        }
+      }
+      /* These styles make the root element full-height */
+      #root {
+        display: flex;
+        width: 100%;
+        height: 100%;
+        flex: 1;
+        min-width: 0;
+        min-height: 0;
+        overflow: hidden;
+      }
+    </style>
+    <style>
+      button,
+      a,
+      input,
+      textarea,
+      select,
+      [role="button"],
+      [role="link"],
+      [role="textbox"],
+      [role="combobox"],
+      [role="tab"],
+      [role="switch"],
+      [role="checkbox"],
+      [role="slider"],
+      [role="menuitem"],
+      [tabindex],
+      [contenteditable="true"] {
+        -webkit-app-region: no-drag !important;
+      }
+      /* Suppress the browser's default focus outline: it appears on mouse
+         clicks and looks out of place against our themed surfaces. Keep a
+         themed ring for keyboard users via :focus-visible. */
+      *:focus {
+        outline: none;
+      }
+      /* `!important` is deliberate, and it is an accessibility floor rather than
+         a style preference.
+         Several components set `outlineStyle: "none"` in their own styles to
+         kill the mouse-click outline. That declaration beat this universal
+         selector, so on 0.3.33 the composer and the command-center search
+         reported `outline-style: none; outline-width: 0px` from
+         getComputedStyle while `:focus-visible` was matching — a keyboard user
+         got NO focus indicator on the two most-used inputs in the product
+         (WCAG 2.4.7 Focus Visible, AA). Those components keep the behaviour
+         they actually wanted through the plain `*:focus` rule above; what they
+         can no longer do is silently delete the keyboard ring.
+         The colour follows the active theme's accent — see
+         src/screens/settings/appearance/apply-focus-ring.web.ts. */
+      *:focus-visible {
+        outline: 2px solid var(--paseo-focus-ring, #20744a) !important;
+        outline-offset: 2px !important;
+      }
+      /* Inputs sit flush inside bordered containers, where a 2px offset collides
+         with the container border. */
+      input:focus-visible,
+      textarea:focus-visible {
+        outline-offset: 1px !important;
+      }
+      /* Make every control feel tactile for the cost of one rule.
+         React Native has no CSS transitions, so a `pressed` or `hovered` style
+         SNAPS between states: the app's own press feedback (opacity 0.85) and
+         every hover background change landed in a single frame, which reads as
+         a flicker rather than as a response. Components can opt into Reanimated
+         per instance, but that means a shared value and an animated style for
+         every button on screen, which is a real cost in the dense lists this
+         app is mostly made of.
+         On web the platform will do it for free. One rule gives every
+         interactive element eased transitions, so the transform and colour
+         changes components ALREADY declare become motion instead of jumps, with
+         no per-component state and no JS on the interaction path.
+         140ms with a slight overshoot-free ease-out: fast enough that a
+         developer clicking through the app many times a day never waits on it,
+         slow enough to register as physical. `transform` is listed first
+         because it is the one that carries the sense of touch.
+         Deliberately NOT applied to `opacity` alone-changing overlays or to
+         `[data-pmono]` code surfaces, where a transition on scroll-driven
+         repaints would cost more than it gives. */
+      button,
+      a,
+      [role="button"],
+      [role="link"],
+      [role="tab"],
+      [role="menuitem"],
+      [role="switch"],
+      [role="checkbox"] {
+        transition:
+          transform 140ms cubic-bezier(0.2, 0, 0, 1),
+          background-color 140ms cubic-bezier(0.2, 0, 0, 1),
+          border-color 140ms cubic-bezier(0.2, 0, 0, 1),
+          box-shadow 140ms cubic-bezier(0.2, 0, 0, 1),
+          opacity 140ms cubic-bezier(0.2, 0, 0, 1);
+      }
+      /* Opt-in card lift. Any Pressable can take it with
+         `dataSet={{ paseoLift: "card" }}`.
+         This is CSS rather than a React Native style because `transform` and
+         `boxShadow` could not be delivered through the style prop on an element
+         that is also a Reanimated animated component: measured with
+         getComputedStyle, both came back "none" via the unistyles StyleSheet
+         (array and string form) and via a plain inline object. Hover is also a
+         pointer-only concept, so :hover / :active is its natural home - no
+         state, no re-render, no JS on the interaction path. Touch platforms
+         keep the background change declared in the component's StyleSheet. */
+      [data-paseo-lift="card"]:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.06);
+      }
+      [data-paseo-lift="card"]:active {
+        transform: translateY(1px) scale(0.985);
+        box-shadow: none;
+      }
+      /* The focus ring should arrive with the focus, not a frame later. */
+      *:focus-visible {
+        transition-property: outline-color, outline-offset;
+        transition-duration: 90ms;
+      }
+      /* Respect the OS "reduce motion" setting for CSS-driven movement: the
+         shimmer keyframes, hover/press transitions, and smooth scrolling.
+         Reanimated animations are handled separately by <ReducedMotionConfig>
+         in src/app/_layout.tsx; between the two, the whole app now honours a
+         setting nothing in the codebase previously consulted.
+         Durations collapse to ~0 rather than to `none` so that animation and
+         transition END events still fire: code that waits for one to finish
+         before revealing content keeps working instead of hanging. */
+      @media (prefers-reduced-motion: reduce) {
+        *,
+        *::before,
+        *::after {
+          animation-duration: 0.01ms !important;
+          animation-iteration-count: 1 !important;
+          transition-duration: 0.01ms !important;
+          scroll-behavior: auto !important;
+        }
+      }
+    </style>
+  <link rel="preload" href="/_expo/static/css/xterm-3bb1704bf6cb0876640973dc0244b4cb.css" as="style"><link rel="stylesheet" href="/_expo/static/css/xterm-3bb1704bf6cb0876640973dc0244b4cb.css"><link rel="icon" href="/favicon.ico" /></head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+  <script src="/_expo/static/js/web/index-dc1e81e7cbad84d30a01c48dcc9a5a3e.js" defer></script>
+</body>
+</html>

package/dist/server/web-ui/index.html.br ADDED Viewed

Binary file

package/dist/server/web-ui/index.html.gz ADDED Viewed

Binary file

package/dist/server/web-ui/manifest.json ADDED Viewed

@@ -0,0 +1,27 @@
+{
+  "id": "/",
+  "name": "Paseo",
+  "short_name": "Paseo",
+  "description": "Monitor and control local AI coding agents from anywhere.",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "orientation": "portrait",
+  "theme_color": "#181B1A",
+  "background_color": "#181B1A",
+  "categories": ["developer", "productivity", "utilities"],
+  "icons": [
+    {
+      "src": "/pwa-icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any maskable"
+    },
+    {
+      "src": "/pwa-icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ]
+}

package/dist/server/web-ui/manifest.json.br ADDED Viewed

Binary file

package/dist/server/web-ui/manifest.json.gz ADDED Viewed

Binary file

package/dist/server/web-ui/metadata.json ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":0,"bundler":"metro","fileMetadata":{}}

package/dist/server/web-ui/metadata.json.br ADDED Viewed

	@@ -0,0 +1 @@
1	+ �{"version":0,"bundler":"metro","fileMetadata":{}}

package/dist/server/web-ui/metadata.json.gz ADDED Viewed

Binary file

package/dist/server/web-ui/pwa-icon-192.png ADDED Viewed

Binary file

package/dist/server/web-ui/pwa-icon-512.png ADDED Viewed

Binary file

package/dist/server/web-ui/robots.txt ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ User-agent: *
2	+ Disallow: /

package/dist/server/web-ui/service-worker.js ADDED Viewed

@@ -0,0 +1,87 @@
+/* global self, clients */
+/**
+ * Paseo Web Push service worker — Story PASEO-CHAT-ACTIONS-V1-story-1.004.
+ *
+ * Receives Web Push messages from the paseo daemon's VAPID-signed dispatcher
+ * (see packages/server/src/server/push/web-worker.ts). Renders an OS-level
+ * notification via the Notifications API. On click, opens or focuses the
+ * `deepLink` URL (Story 1.5 will handle the in-app routing).
+ */
+self.addEventListener("install", (event) => {
+  // Activate immediately on first install so the very next push event fires.
+  event.waitUntil(self.skipWaiting());
+});
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+self.addEventListener("push", (event) => {
+  if (!event.data) return;
+  let payload;
+  try {
+    payload = event.data.json();
+  } catch {
+    payload = { title: "Paseo", body: event.data.text() };
+  }
+  const title = payload.title || "Paseo";
+  const options = {
+    body: payload.body || "",
+    data: payload.data || {},
+    icon: "/favicon.ico",
+    badge: "/favicon.ico",
+  };
+  event.waitUntil(
+    Promise.all([
+      self.registration.showNotification(title, options),
+      // Optional test/instrumentation hook: clients listen for these messages
+      // to assert end-to-end latency (E2E spec, Task 6).
+      self.clients
+        .matchAll({ includeUncontrolled: true, type: "window" })
+        .then((cs) =>
+          cs.forEach((c) =>
+            // `c` is a ServiceWorker WindowClient — Client.postMessage(message, transfer)
+            // has no targetOrigin argument (that's Window.postMessage). The oxlint rule
+            // cannot disambiguate; this is a documented false positive.
+            // oxlint-disable-next-line unicorn/require-post-message-target-origin
+            c.postMessage({ type: "paseo:push:rendered", at: Date.now(), data: options.data }),
+          ),
+        )
+        .catch(() => {}),
+    ]),
+  );
+});
+self.addEventListener("notificationclick", (event) => {
+  event.notification.close();
+  const data = event.notification.data || {};
+  const deepLink = data.deepLink;
+  // Browsers cannot openWindow() a custom-scheme URL — Story 1.5 ships
+  // `webPath` (e.g. `/agent/<sessionId>`) alongside the native deepLink.
+  // Prefer webPath for openWindow; fall back to deepLink when an older
+  // daemon omitted it. postMessage always ships the deepLink so the
+  // foregrounded client can resolve it via the same in-app router.
+  const openUrl = data.webPath || deepLink;
+  if (!deepLink && !openUrl) return;
+  event.waitUntil(
+    self.clients
+      .matchAll({ type: "window", includeUncontrolled: true })
+      .then((cs) => {
+        for (const c of cs) {
+          if ("focus" in c) {
+            // `c` is a ServiceWorker WindowClient — Client.postMessage(message, transfer)
+            // has no targetOrigin argument (that's Window.postMessage). The oxlint rule
+            // cannot disambiguate; this is a documented false positive.
+            // oxlint-disable-next-line unicorn/require-post-message-target-origin
+            c.postMessage({ type: "paseo:push:click", deepLink, data });
+            return c.focus();
+          }
+        }
+        if (openUrl && self.clients.openWindow) return self.clients.openWindow(openUrl);
+        return undefined;
+      })
+      .catch(() => {}),
+  );
+});

package/dist/server/web-ui/service-worker.js.br ADDED Viewed

Binary file

package/dist/server/web-ui/service-worker.js.gz ADDED Viewed

Binary file

package/dist/src/executable-resolution/executable-resolution.js ADDED Viewed

@@ -0,0 +1,118 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { execCommand } from "../utils/spawn.js";
+import { isWindowsCommandScript } from "../utils/windows-command.js";
+import { windowsExecutableResolution } from "./windows.js";
+export { quoteWindowsArgument, quoteWindowsCommand } from "../utils/windows-command.js";
+const require = createRequire(import.meta.url);
+const which = require("which");
+const PROBE_TIMEOUT_MS = 2000;
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+async function enumerateCandidates(name) {
+    if (process.platform !== "win32" && existsSync("/usr/bin/which")) {
+        return enumerateCandidatesViaSystemWhich(name);
+    }
+    return enumerateCandidatesViaLibrary(name);
+}
+async function enumerateCandidatesViaSystemWhich(name) {
+    try {
+        const { stdout } = await execCommand("/usr/bin/which", ["-a", name], {
+            timeout: 3000,
+            killSignal: "SIGKILL",
+        });
+        return Array.from(new Set(stdout.trim().split("\n").filter(Boolean)));
+    }
+    catch {
+        return [];
+    }
+}
+async function enumerateCandidatesViaLibrary(name) {
+    let candidates;
+    try {
+        candidates = await which(name, { all: true });
+    }
+    catch (error) {
+        // `which` throws ENOENT when the command is absent from PATH.
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        if (seen.has(candidate)) {
+            return false;
+        }
+        seen.add(candidate);
+        return true;
+    });
+}
+export async function probeExecutable(executablePath, timeoutMs = PROBE_TIMEOUT_MS) {
+    try {
+        await execCommand(executablePath, ["--version"], {
+            timeout: timeoutMs,
+            killSignal: "SIGKILL",
+            maxBuffer: 64 * 1024,
+            shell: isWindowsCommandScript(executablePath),
+        });
+        return true;
+    }
+    catch (error) {
+        return classifyProbeError(error);
+    }
+}
+function classifyProbeError(error) {
+    const err = error;
+    if (err.killed) {
+        return true;
+    }
+    if (typeof err.code === "number") {
+        return true;
+    }
+    if (err.code === "ENOENT" ||
+        err.code === "EACCES" ||
+        err.code === "ENOEXEC" ||
+        err.code === "UNKNOWN") {
+        return false;
+    }
+    return false;
+}
+/**
+ * Check a literal executable path. PATH search is handled by findExecutable().
+ */
+export function executableExists(executablePath, exists = existsSync) {
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.exists(executablePath, { exists });
+    }
+    return exists(executablePath) ? executablePath : null;
+}
+export async function findExecutable(name, probeTimeoutMs = PROBE_TIMEOUT_MS) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.find(trimmed, {
+            enumeratePathCandidates: enumerateCandidates,
+            probeExecutable,
+            exists: existsSync,
+            probeTimeoutMs,
+        });
+    }
+    if (hasPathSeparator(trimmed)) {
+        return (await probeExecutable(trimmed, probeTimeoutMs)) ? trimmed : null;
+    }
+    const candidates = await enumerateCandidates(trimmed);
+    for (const candidate of candidates) {
+        if (await probeExecutable(candidate, probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export async function isCommandAvailable(command) {
+    return (await findExecutable(command)) !== null;
+}
+//# sourceMappingURL=executable-resolution.js.map

package/dist/src/executable-resolution/windows.js ADDED Viewed

@@ -0,0 +1,65 @@
+import { readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+function enumerateLiteralPathCandidates(executablePath) {
+    if (extname(executablePath)) {
+        return [executablePath];
+    }
+    return [executablePath, `${executablePath}.exe`, `${executablePath}.cmd`];
+}
+function enumerateWingetPackageCandidates(name, localAppData) {
+    if (!localAppData) {
+        return [];
+    }
+    const wingetPackages = join(localAppData, "Microsoft", "WinGet", "Packages");
+    let packageDirs;
+    try {
+        packageDirs = readdirSync(wingetPackages, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+    const exeName = `${name}.exe`;
+    return packageDirs.map((packageDir) => join(wingetPackages, packageDir, exeName));
+}
+async function find(input, options) {
+    if (hasPathSeparator(input)) {
+        return findFirstProbeable(enumerateLiteralPathCandidates(input), options);
+    }
+    const pathCandidates = await options.enumeratePathCandidates(input);
+    const wingetCandidates = enumerateWingetPackageCandidates(input, options.localAppData ?? process.env.LOCALAPPDATA).filter(options.exists);
+    return findFirstProbeable([...pathCandidates, ...wingetCandidates], options);
+}
+async function findFirstProbeable(candidates, options) {
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate)) {
+            continue;
+        }
+        seen.add(candidate);
+        if (!options.exists(candidate)) {
+            continue;
+        }
+        if (await options.probeExecutable(candidate, options.probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function exists(executablePath, options) {
+    for (const candidate of enumerateLiteralPathCandidates(executablePath)) {
+        if (options.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export const windowsExecutableResolution = {
+    exists,
+    find,
+};
+//# sourceMappingURL=windows.js.map