@hyperdrive.bot/fleet-server 0.3.99

package/dist/src/server/pid-lock.js

@@ -0,0 +1,170 @@
+import { open, readFile, unlink, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { hostname } from "node:os";
+import { z } from "zod";
+export const pidLockInfoSchema = z.object({
+    pid: z.number(),
+    startedAt: z.string(),
+    hostname: z.string(),
+    uid: z.number(),
+    listen: z.string().nullable(),
+    desktopManaged: z.boolean().optional(),
+});
+function parsePidLockInfo(raw) {
+    const result = pidLockInfoSchema.safeParse(raw);
+    return result.success ? result.data : null;
+}
+function isErrnoException(err) {
+    return err instanceof Error && "code" in err;
+}
+export class PidLockError extends Error {
+    constructor(message, existingLock) {
+        super(message);
+        this.existingLock = existingLock;
+        this.name = "PidLockError";
+    }
+}
+function isPidRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getPidFilePath(paseoHome) {
+    return join(paseoHome, "paseo.pid");
+}
+function resolveOwnerPid(ownerPid) {
+    if (typeof ownerPid === "number" && Number.isInteger(ownerPid) && ownerPid > 0) {
+        return ownerPid;
+    }
+    return process.pid;
+}
+export async function acquirePidLock(paseoHome, listen, options) {
+    const pidPath = getPidFilePath(paseoHome);
+    // Ensure paseoHome directory exists
+    if (!existsSync(paseoHome)) {
+        await mkdir(paseoHome, { recursive: true });
+    }
+    // Try to read existing lock
+    let existingLock = null;
+    try {
+        const content = await readFile(pidPath, "utf-8");
+        existingLock = parsePidLockInfo(JSON.parse(content));
+    }
+    catch {
+        // No existing lock or invalid JSON - that's fine
+    }
+    // Check if existing lock is stale
+    const lockOwnerPid = resolveOwnerPid(options?.ownerPid);
+    if (existingLock) {
+        if (isPidRunning(existingLock.pid)) {
+            if (existingLock.pid === lockOwnerPid) {
+                return;
+            }
+            throw new PidLockError(`Another Paseo daemon is already running (PID ${existingLock.pid}, started ${existingLock.startedAt})`, existingLock);
+        }
+        // Stale lock - remove it
+        await unlink(pidPath).catch(() => { });
+    }
+    // Create new lock with exclusive flag
+    const lockInfo = {
+        pid: lockOwnerPid,
+        startedAt: new Date().toISOString(),
+        hostname: hostname(),
+        uid: process.getuid?.() ?? 0,
+        listen,
+        ...(process.env.PASEO_DESKTOP_MANAGED === "1" ? { desktopManaged: true } : {}),
+    };
+    let fd;
+    try {
+        fd = await open(pidPath, "wx");
+        await fd.write(JSON.stringify(lockInfo));
+    }
+    catch (err) {
+        if (isErrnoException(err) && err.code === "EEXIST") {
+            // Race condition - another process created the file
+            // Re-read and check
+            try {
+                const content = await readFile(pidPath, "utf-8");
+                const raceLock = parsePidLockInfo(JSON.parse(content));
+                if (raceLock) {
+                    throw new PidLockError(`Another Paseo daemon is already running (PID ${raceLock.pid})`, raceLock);
+                }
+                throw new PidLockError("Failed to acquire PID lock due to race condition");
+            }
+            catch (innerErr) {
+                if (innerErr instanceof PidLockError)
+                    throw innerErr;
+                throw new PidLockError("Failed to acquire PID lock due to race condition");
+            }
+        }
+        throw err;
+    }
+    finally {
+        await fd?.close();
+    }
+}
+export async function updatePidLock(paseoHome, patch, options) {
+    const pidPath = getPidFilePath(paseoHome);
+    const lockOwnerPid = resolveOwnerPid(options?.ownerPid);
+    const content = await readFile(pidPath, "utf-8");
+    const existingLock = parsePidLockInfo(JSON.parse(content));
+    if (!existingLock) {
+        throw new PidLockError("Cannot update PID lock: invalid lock file");
+    }
+    if (existingLock.pid !== lockOwnerPid) {
+        throw new PidLockError(`Cannot update PID lock owned by PID ${existingLock.pid}`, existingLock);
+    }
+    const updatedLock = {
+        ...existingLock,
+        ...patch,
+    };
+    const fd = await open(pidPath, "r+");
+    try {
+        await fd.truncate(0);
+        await fd.writeFile(JSON.stringify(updatedLock));
+    }
+    finally {
+        await fd.close();
+    }
+}
+export async function releasePidLock(paseoHome, options) {
+    const pidPath = getPidFilePath(paseoHome);
+    const lockOwnerPid = resolveOwnerPid(options?.ownerPid);
+    try {
+        // Only remove if it's our lock
+        const content = await readFile(pidPath, "utf-8");
+        const lock = parsePidLockInfo(JSON.parse(content));
+        if (lock?.pid === lockOwnerPid) {
+            await unlink(pidPath);
+        }
+    }
+    catch {
+        // Ignore errors - lock may already be gone
+    }
+}
+export async function getPidLockInfo(paseoHome) {
+    const pidPath = getPidFilePath(paseoHome);
+    try {
+        const content = await readFile(pidPath, "utf-8");
+        return parsePidLockInfo(JSON.parse(content));
+    }
+    catch {
+        return null;
+    }
+}
+export async function isLocked(paseoHome) {
+    const info = await getPidLockInfo(paseoHome);
+    if (!info) {
+        return { locked: false };
+    }
+    if (!isPidRunning(info.pid)) {
+        return { locked: false, info };
+    }
+    return { locked: true, info };
+}
+//# sourceMappingURL=pid-lock.js.map

package/dist/src/server/private-files.js

@@ -0,0 +1,37 @@
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+export const PRIVATE_DIRECTORY_MODE = 0o700;
+export const PRIVATE_FILE_MODE = 0o600;
+function chmodBestEffort(targetPath, mode) {
+    if (process.platform === "win32") {
+        return;
+    }
+    try {
+        chmodSync(targetPath, mode);
+    }
+    catch {
+        // Keep startup resilient if the filesystem does not support POSIX modes.
+    }
+}
+export function ensurePrivateDirectory(directoryPath) {
+    mkdirSync(directoryPath, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+    chmodBestEffort(directoryPath, PRIVATE_DIRECTORY_MODE);
+}
+export function ensurePrivateFile(filePath) {
+    chmodBestEffort(filePath, PRIVATE_FILE_MODE);
+}
+export function writePrivateFileAtomicSync(filePath, data) {
+    ensurePrivateDirectory(path.dirname(filePath));
+    const tmpPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        writeFileSync(tmpPath, data, { mode: PRIVATE_FILE_MODE });
+        renameSync(tmpPath, filePath);
+        ensurePrivateFile(filePath);
+    }
+    catch (error) {
+        rmSync(tmpPath, { force: true });
+        throw error;
+    }
+}
+//# sourceMappingURL=private-files.js.map

package/dist/src/server/speech/providers/local/sherpa/sherpa-runtime-env.js

@@ -0,0 +1,84 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+export function sherpaPlatformArch(platform = process.platform, arch = process.arch) {
+    const normalizedPlatform = platform === "win32" ? "win" : platform;
+    return `${normalizedPlatform}-${arch}`;
+}
+export function sherpaPlatformPackageName(platform = process.platform, arch = process.arch) {
+    return `sherpa-onnx-${sherpaPlatformArch(platform, arch)}`;
+}
+export function sherpaLoaderEnvKey(platform = process.platform) {
+    if (platform === "linux") {
+        return "LD_LIBRARY_PATH";
+    }
+    if (platform === "darwin") {
+        return "DYLD_LIBRARY_PATH";
+    }
+    if (platform === "win32") {
+        return "PATH";
+    }
+    return null;
+}
+export function prependEnvPath(existing, value) {
+    const parts = (existing ?? "").split(path.delimiter).filter(Boolean);
+    if (parts.includes(value)) {
+        return parts.join(path.delimiter);
+    }
+    return [value, ...parts].join(path.delimiter);
+}
+export function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch) {
+    const key = sherpaLoaderEnvKey(platform);
+    if (!key) {
+        return null;
+    }
+    const packageName = sherpaPlatformPackageName(platform, arch);
+    const require = createRequire(import.meta.url);
+    try {
+        const pkgJson = require.resolve(`${packageName}/package.json`);
+        return {
+            key,
+            libDir: path.dirname(pkgJson),
+            packageName,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find the actual case-sensitive key in a plain object that matches the given
+ * key case-insensitively. On Windows, `{...process.env}` produces a plain
+ * (case-sensitive) object where PATH is typically stored as `Path`. Using a
+ * hardcoded `"PATH"` would miss the existing key and create a duplicate,
+ * breaking the child process's PATH.
+ */
+function findEnvKey(env, key) {
+    const lower = key.toLowerCase();
+    for (const k of Object.keys(env)) {
+        if (k.toLowerCase() === lower)
+            return k;
+    }
+    return key;
+}
+export function applySherpaLoaderEnv(env, platform = process.platform, arch = process.arch) {
+    const resolved = resolveSherpaLoaderEnv(platform, arch);
+    if (!resolved) {
+        return {
+            changed: false,
+            key: null,
+            libDir: null,
+            packageName: null,
+        };
+    }
+    const actualKey = findEnvKey(env, resolved.key);
+    const next = prependEnvPath(env[actualKey], resolved.libDir);
+    const changed = next !== (env[actualKey] ?? "");
+    env[actualKey] = next;
+    return {
+        changed,
+        key: resolved.key,
+        libDir: resolved.libDir,
+        packageName: resolved.packageName,
+    };
+}
+//# sourceMappingURL=sherpa-runtime-env.js.map

package/dist/src/server/update/slots.js

@@ -0,0 +1,97 @@
+import { existsSync, readlinkSync, statSync } from "node:fs";
+import path from "node:path";
+/**
+ * Self-update slot layout, rooted at the paseo home.
+ *
+ *   <home>/versions/<version>/      an `npm install --prefix` tree
+ *   <home>/current   -> versions/<version>   symlink, atomically swapped
+ *   <home>/previous  -> versions/<version>   symlink, the rollback target
+ *   <home>/update-state.json                 channel, pinned version, failures
+ *
+ * Slots live under the paseo home rather than the npm global prefix on purpose:
+ * that prefix is nvm-versioned (`~/.nvm/versions/node/<v>/lib/node_modules`), so a
+ * node switch would strand the daemon, and `npm i -g` writes in place, which
+ * forecloses rollback. The paseo home is already the unit the pid lock isolates on.
+ */
+export const SLOT_CURRENT = "current";
+export const SLOT_PREVIOUS = "previous";
+export const SLOT_VERSIONS_DIR = "versions";
+export const UPDATE_STATE_FILE = "update-state.json";
+export function slotsRoot(paseoHome) {
+    return path.join(paseoHome, SLOT_VERSIONS_DIR);
+}
+export function slotPath(paseoHome, version) {
+    return path.join(slotsRoot(paseoHome), version);
+}
+export function currentLinkPath(paseoHome) {
+    return path.join(paseoHome, SLOT_CURRENT);
+}
+export function previousLinkPath(paseoHome) {
+    return path.join(paseoHome, SLOT_PREVIOUS);
+}
+export function updateStatePath(paseoHome) {
+    return path.join(paseoHome, UPDATE_STATE_FILE);
+}
+/**
+ * Worker entry candidates inside an installed slot.
+ *
+ * Two layouts, because npm does not guarantee where a transitive dependency lands:
+ * `@hyperdrive.bot/fleet-server` is nested under the CLI in the layout observed on
+ * this box, but npm is free to hoist it to the top of the prefix instead. Both are
+ * checked rather than assumed.
+ *
+ * The `dist/server/server/` doubling is real: the published tarball ships
+ * `dist/server/server/daemon-worker.js`, verified against the installed 0.3.3 tree.
+ */
+export function slotWorkerEntryCandidates(slotRoot) {
+    const modules = path.join(slotRoot, "lib", "node_modules");
+    const tail = path.join("dist", "server", "server", "daemon-worker.js");
+    return [
+        // Nested under the CLI (observed layout for `npm i @hyperdrive.bot/fleet-cli`).
+        path.join(modules, "@hyperdrive.bot", "fleet-cli", "node_modules", "@hyperdrive.bot", "fleet-server", tail),
+        // Hoisted to the prefix root.
+        path.join(modules, "@hyperdrive.bot", "fleet-server", tail),
+    ];
+}
+/**
+ * The worker entry for the active slot, or null when no usable slot is installed.
+ *
+ * Returning null is the normal case for an npm-global or checkout install, and the
+ * caller must fall back to its own resolution so those installs behave exactly as
+ * they did before slots existed.
+ */
+export function resolveSlotWorkerEntry(paseoHome) {
+    const link = currentLinkPath(paseoHome);
+    // `existsSync` follows symlinks, so a dangling `current` (mid-swap, or a rollback
+    // that removed the target) correctly reports false and we fall back.
+    if (!existsSync(link)) {
+        return null;
+    }
+    try {
+        if (!statSync(link).isDirectory()) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    for (const candidate of slotWorkerEntryCandidates(link)) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/** Version a slot symlink points at, or null when absent or dangling. */
+export function readSlotVersion(paseoHome, link) {
+    const linkPath = path.join(paseoHome, link);
+    try {
+        const target = readlinkSync(linkPath);
+        const base = path.basename(target);
+        return base.length > 0 ? base : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=slots.js.map

package/dist/src/terminal/shell-integration/zsh/.zshenv

@@ -0,0 +1,17 @@
+typeset -g PASEO_SHELL_INTEGRATION_DIR="${${(%):-%N}:A:h}"
+
+if [[ -n "${PASEO_ZSH_ZDOTDIR-}" ]]; then
+  export ZDOTDIR="${PASEO_ZSH_ZDOTDIR}"
+else
+  unset ZDOTDIR
+fi
+
+if [[ -n "${ZDOTDIR-}" ]]; then
+  if [[ -f "${ZDOTDIR}/.zshenv" ]]; then
+    source "${ZDOTDIR}/.zshenv"
+  fi
+elif [[ -f "${HOME}/.zshenv" ]]; then
+  source "${HOME}/.zshenv"
+fi
+
+source "${PASEO_SHELL_INTEGRATION_DIR}/paseo-integration.zsh"

package/dist/src/terminal/shell-integration/zsh/paseo-integration.zsh

@@ -0,0 +1,32 @@
+if [[ -n "${_PASEO_ZSH_INTEGRATION_LOADED-}" ]]; then
+  return
+fi
+typeset -g _PASEO_ZSH_INTEGRATION_LOADED=1
+
+autoload -Uz add-zsh-hook
+
+typeset -g _PASEO_ZSH_COMMAND_ACTIVE=0
+
+function _paseo_osc633() {
+  printf '\e]633;%s\a' "$1"
+}
+
+function _paseo_precmd() {
+  local command_status=$?
+  if [[ "$_PASEO_ZSH_COMMAND_ACTIVE" == "1" ]]; then
+    _paseo_osc633 "D;${command_status}"
+    _PASEO_ZSH_COMMAND_ACTIVE=0
+  fi
+  printf '\e]2;%s\a' "${PWD/#$HOME/~}"
+  _paseo_osc633 "A"
+}
+
+function _paseo_preexec() {
+  _PASEO_ZSH_COMMAND_ACTIVE=1
+  _paseo_osc633 "B"
+  _paseo_osc633 "C"
+  printf '\e]2;%s\a' "$1"
+}
+
+add-zsh-hook precmd _paseo_precmd
+add-zsh-hook preexec _paseo_preexec

package/dist/src/utils/spawn.js

@@ -0,0 +1,71 @@
+import { execFile, spawn } from "node:child_process";
+import { extname } from "node:path";
+import { promisify } from "node:util";
+import { createExternalCommandProcessEnv } from "../server/paseo-env.js";
+import { isWindowsCommandScript, quoteWindowsArgument, quoteWindowsCommand, } from "./windows-command.js";
+const execFileAsync = promisify(execFile);
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+function shouldUseWindowsShell(command, requestedShell) {
+    if (isWindowsCommandScript(command)) {
+        return true;
+    }
+    if (requestedShell !== undefined) {
+        return requestedShell;
+    }
+    return process.platform === "win32" && !hasPathSeparator(command) && !extname(command);
+}
+export function spawnProcess(command, args, options) {
+    const { baseEnv, env, envOverlay, ...spawnOptions } = options ?? {};
+    const resolvedBaseEnv = env ?? baseEnv ?? process.env;
+    const isWindows = process.platform === "win32";
+    const shell = shouldUseWindowsShell(command, spawnOptions.shell);
+    const shouldQuoteForShell = isWindows && shell !== false;
+    const resolvedCommand = shouldQuoteForShell ? quoteWindowsCommand(command) : command;
+    const resolvedArgs = shouldQuoteForShell ? args.map(quoteWindowsArgument) : args;
+    const childEnv = options?.envMode === "internal"
+        ? { ...resolvedBaseEnv, ...envOverlay }
+        : createExternalCommandProcessEnv(command, resolvedBaseEnv, ...(envOverlay ? [envOverlay] : []));
+    return spawn(resolvedCommand, resolvedArgs, {
+        ...spawnOptions,
+        env: childEnv,
+        shell,
+        windowsHide: true,
+    });
+}
+export async function execCommand(command, args, options) {
+    const { baseEnv, env, envOverlay } = options ?? {};
+    const resolvedBaseEnv = env ?? baseEnv ?? process.env;
+    const isWindows = process.platform === "win32";
+    const shell = shouldUseWindowsShell(command, options?.shell);
+    const shouldQuoteForShell = isWindows && shell !== false;
+    const resolvedCommand = shouldQuoteForShell ? quoteWindowsCommand(command) : command;
+    const resolvedArgs = shouldQuoteForShell ? args.map(quoteWindowsArgument) : args;
+    const childEnv = options?.envMode === "internal"
+        ? { ...resolvedBaseEnv, ...envOverlay }
+        : createExternalCommandProcessEnv(command, resolvedBaseEnv, ...(envOverlay ? [envOverlay] : []));
+    return execFileAsync(resolvedCommand, resolvedArgs, {
+        cwd: options?.cwd,
+        env: childEnv,
+        encoding: options?.encoding ?? "utf8",
+        killSignal: options?.killSignal,
+        timeout: options?.timeout,
+        maxBuffer: options?.maxBuffer,
+        shell,
+        windowsHide: true,
+    });
+}
+export function platformShell() {
+    if (process.platform === "win32") {
+        return { command: "cmd.exe", flag: ["/c"] };
+    }
+    return { command: "/bin/sh", flag: ["-lc"] };
+}
+export function platformBash() {
+    if (process.platform === "win32") {
+        return { command: "cmd.exe", flag: ["/c"] };
+    }
+    return { command: "/bin/bash", flag: ["-lc"] };
+}
+//# sourceMappingURL=spawn.js.map

package/dist/src/utils/windows-command.js

@@ -0,0 +1,41 @@
+import { extname } from "node:path";
+export function isWindowsCommandScript(executablePath) {
+    const extension = extname(executablePath).toLowerCase();
+    return process.platform === "win32" && (extension === ".cmd" || extension === ".bat");
+}
+function escapeWindowsCmdValue(value) {
+    if (process.platform !== "win32")
+        return value;
+    const isQuoted = value.startsWith('"') && value.endsWith('"');
+    const unquoted = isQuoted ? value.slice(1, -1) : value;
+    // Do NOT double `%` here. cmd.exe only collapses `%%` → `%` inside batch
+    // files; on the command line / `cmd /c "..."` `%%` stays literal, which
+    // breaks args like git's `--format=%(refname)` (git treats `%%` as the
+    // escape for a literal `%`, so the format atoms become literals).
+    const escaped = unquoted.replace(/([&|^<>()!])/g, "^$1");
+    if (isQuoted || /[\s"]/u.test(unquoted)) {
+        const quoted = escaped
+            .replace(/(\\*)"/g, (_match, slashes) => `${slashes}${slashes}\\"`)
+            .replace(/\\+$/u, (slashes) => `${slashes}${slashes}`);
+        return `"${quoted}"`;
+    }
+    return escaped;
+}
+/**
+ * When spawning with `shell: true` on Windows, the command is passed to
+ * `cmd.exe /d /s /c "command args"`. The `/s` strips outer quotes, so a
+ * command path with spaces (e.g. `C:\Program Files\...`) is split at the
+ * space. Wrapping it in quotes produces the correct `"C:\Program Files\..." args`.
+ */
+export function quoteWindowsCommand(command) {
+    return escapeWindowsCmdValue(command);
+}
+/**
+ * `spawn(..., { shell: true })` on Windows also passes argv through `cmd.exe`.
+ * Any argument containing spaces must be quoted or it will be split before the
+ * child process sees it.
+ */
+export function quoteWindowsArgument(argument) {
+    return escapeWindowsCmdValue(argument);
+}
+//# sourceMappingURL=windows-command.js.map