@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/edge/remote-access/rules.js

@@ -0,0 +1,207 @@
+import { z } from "zod";
+import { httpsPortChoices } from "./model.js";
+export const installLink = "https://tailscale.com/download";
+export const dnsAdminLink = "https://login.tailscale.com/admin/dns";
+const statusShape = z
+    .object({
+    BackendState: z.string(),
+    Self: z
+        .object({ DNSName: z.string().optional(), UserID: z.number().optional() })
+        .loose()
+        .optional(),
+    User: z
+        .record(z.string(), z.object({ LoginName: z.string().optional() }).loose())
+        .nullable()
+        .optional(),
+    CertDomains: z.array(z.string()).nullable().optional(),
+})
+    .loose();
+const handlerShape = z.object({ Proxy: z.string().optional() }).loose();
+const webShape = z.object({ Handlers: z.record(z.string(), handlerShape).optional() }).loose();
+const tcpShape = z.object({ HTTPS: z.boolean().optional(), HTTP: z.boolean().optional() }).loose();
+const configShape = z
+    .object({
+    TCP: z.record(z.string(), tcpShape).nullable().optional(),
+    Web: z.record(z.string(), webShape).nullable().optional(),
+    AllowFunnel: z.record(z.string(), z.boolean()).nullable().optional(),
+})
+    .loose();
+const serveShape = configShape
+    .extend({ Foreground: z.record(z.string(), configShape).nullable().optional() })
+    .loose();
+const deniedPattern = /access denied|permission denied|operator|must be root|not permitted/iu;
+const notRunningPattern = /failed to connect|doesn't appear to be running|is tailscaled running|connection refused|no such file or directory|cannot connect/iu;
+// A failed command's own reason, in the person's words.
+export function problemOf(result, platform) {
+    if (result.missing)
+        return {
+            state: "not-installed",
+            summary: "Tailscale isn't installed on this computer, so Slopify can't open it on your other devices.",
+            fix: "Install Tailscale from tailscale.com/download, sign in, then press Check again.",
+            link: installLink,
+        };
+    if (result.timedOut)
+        return {
+            state: "failed",
+            summary: "Tailscale didn't answer within 10 seconds.",
+            fix: "Make sure the Tailscale app or service is running (open the Tailscale app, or run tailscale status in a terminal), then press Check again.",
+            link: null,
+        };
+    const text = `${result.stderr}\n${result.stdout}`.trim();
+    if (deniedPattern.test(text))
+        return deniedProblem(platform);
+    if (notRunningPattern.test(text))
+        return notRunningProblem();
+    return {
+        state: "failed",
+        summary: `Tailscale refused: ${firstLine(text) || `it stopped with code ${result.code}`}.`,
+        fix: "Run tailscale status in a terminal to see what Tailscale reports, fix that, then press Check again.",
+        link: null,
+    };
+}
+export function deniedProblem(platform) {
+    return {
+        state: "denied",
+        summary: "Tailscale won't let your user change its serve settings.",
+        fix: platform === "linux"
+            ? "On Linux, allow your user once: run sudo tailscale set --operator=$USER in a terminal, then press Check again."
+            : "Open the Tailscale app as the user who signed in to it, then press Check again.",
+        link: null,
+    };
+}
+function notRunningProblem() {
+    return {
+        state: "not-running",
+        summary: "Tailscale is installed but not running.",
+        fix: "Open the Tailscale app and connect, or run tailscale up in a terminal, then press Check again.",
+        link: null,
+    };
+}
+function firstLine(text) {
+    return (text.split("\n").find((line) => line.trim() !== "") ?? "").trim().replace(/\.$/u, "");
+}
+// Which machine this is, or why Tailscale can't serve it yet.
+export function machineOf(stdout) {
+    let parsed;
+    try {
+        parsed = statusShape.parse(JSON.parse(stdout));
+    }
+    catch {
+        return {
+            state: "failed",
+            summary: "Slopify couldn't read tailscale status --json.",
+            fix: "Update Tailscale to a current version (tailscale.com/download), then press Check again.",
+            link: installLink,
+        };
+    }
+    if (parsed.BackendState === "NeedsLogin" || parsed.BackendState === "NeedsMachineAuth")
+        return {
+            state: "signed-out",
+            summary: parsed.BackendState === "NeedsMachineAuth"
+                ? "This computer is waiting for approval in your tailnet."
+                : "Tailscale is signed out on this computer.",
+            fix: parsed.BackendState === "NeedsMachineAuth"
+                ? "Approve this computer in the Tailscale admin console (login.tailscale.com/admin/machines), then press Check again."
+                : "Open the Tailscale app and sign in, or run tailscale up in a terminal, then press Check again.",
+            link: null,
+        };
+    if (parsed.BackendState !== "Running")
+        return notRunningProblem();
+    const dnsName = (parsed.Self?.DNSName ?? "").replace(/\.$/u, "");
+    const certs = parsed.CertDomains ?? [];
+    if (dnsName === "" || !certs.includes(dnsName))
+        return {
+            state: "https-off",
+            summary: "Your tailnet has no HTTPS certificates, so Tailscale can't give Slopify an https address.",
+            fix: "In the Tailscale admin console open DNS (login.tailscale.com/admin/dns), turn on MagicDNS if it is off, then under HTTPS Certificates press Enable HTTPS. Then press Check again.",
+            link: dnsAdminLink,
+        };
+    const userId = parsed.Self?.UserID;
+    const owner = userId === undefined ? undefined : parsed.User?.[String(userId)]?.LoginName;
+    return owner === undefined || owner === "" ? { dnsName } : { dnsName, owner };
+}
+export function isProblem(value) {
+    return "state" in value;
+}
+export function parseServeStatus(stdout) {
+    const text = stdout.trim();
+    if (text === "")
+        return {};
+    try {
+        return serveShape.parse(JSON.parse(text));
+    }
+    catch {
+        return undefined;
+    }
+}
+export const hostPort = (dnsName, httpsPort) => `${dnsName}:${httpsPort}`;
+// The address a browser opens; 443 is https's own port, so it isn't written.
+export function addressOf(dnsName, httpsPort) {
+    return httpsPort === 443 ? `https://${dnsName}` : `https://${dnsName}:${httpsPort}`;
+}
+const normal = (url) => url.replace(/\/+$/u, "");
+function configsOf(status) {
+    return [status, ...Object.values(status.Foreground ?? {})];
+}
+// What uses an HTTPS port on this machine now, in the background config or a foreground
+// `tailscale serve` still running in someone's terminal.
+export function portUse(status, dnsName, httpsPort) {
+    const key = hostPort(dnsName, httpsPort);
+    const used = configsOf(status).filter((config) => config.TCP?.[String(httpsPort)] !== undefined || config.Web?.[key] !== undefined);
+    const [only] = used;
+    if (only === undefined)
+        return { kind: "free" };
+    const handlers = Object.entries(only.Web?.[key]?.Handlers ?? {});
+    const [first] = handlers;
+    if (used.length === 1 &&
+        only.TCP?.[String(httpsPort)]?.HTTPS === true &&
+        handlers.length === 1 &&
+        first !== undefined &&
+        first[0] === "/" &&
+        first[1].Proxy !== undefined)
+        return {
+            kind: "proxy",
+            target: normal(first[1].Proxy),
+            funnel: configsOf(status).some((config) => config.AllowFunnel?.[key] === true),
+        };
+    return {
+        kind: "other",
+        what: handlers.length === 0
+            ? "a TCP forwarder"
+            : handlers
+                .map(([path, handler]) => `${path} → ${handler.Proxy ?? "a file or text"}`)
+                .join(", "),
+    };
+}
+export function sameTarget(a, b) {
+    return normal(a) === normal(b);
+}
+export function freePort(status, dnsName, except) {
+    return (httpsPortChoices.find((port) => port !== except && portUse(status, dnsName, port).kind === "free") ?? null);
+}
+export function portTakenProblem(httpsPort, use, target, suggestedPort) {
+    const instead = suggestedPort === null
+        ? "Choose another HTTPS port below"
+        : `Press Use port ${suggestedPort} to give Slopify its own address`;
+    const what = use.kind === "proxy" ? `a proxy to ${use.target}` : use.what;
+    const yours = use.kind === "proxy" && sameTarget(use.target, target)
+        ? " It already points at this Slopify, but you set it up outside Slopify, so Slopify leaves it alone."
+        : "";
+    return {
+        state: "port-taken",
+        summary: `HTTPS port ${httpsPort} on your tailnet address is already used by another Tailscale serve setting (${what}).${yours}`,
+        fix: `${instead}, or remove the other setting with tailscale serve --https=${httpsPort} off and press Check again.`,
+        link: null,
+    };
+}
+export function serveRefusedProblem(result, platform) {
+    const text = `${result.stderr}\n${result.stdout}`;
+    if (!result.missing && !result.timedOut && /https|cert/iu.test(text) && !deniedPattern.test(text))
+        return {
+            state: "https-off",
+            summary: `Tailscale couldn't give Slopify an https address: ${firstLine(text)}.`,
+            fix: "In the Tailscale admin console open DNS (login.tailscale.com/admin/dns), turn on MagicDNS if it is off, then under HTTPS Certificates press Enable HTTPS. Then press Check again.",
+            link: dnsAdminLink,
+        };
+    return problemOf(result, platform);
+}

package/dist/edge/remote-access/service.js

@@ -0,0 +1,203 @@
+import { tailscaleCommands } from "./cli.js";
+import { freePort, isProblem, machineOf, parseServeStatus, portTakenProblem, portUse, problemOf, sameTarget, serveRefusedProblem, } from "./rules.js";
+import { remoteAccessStore } from "./store.js";
+import { remoteAccessViews } from "./views.js";
+// ceiling: a view is a few CLI calls; an open Settings tab and agents reading it together
+// share one answer for this long.
+const cacheMs = 5_000;
+export function createRemoteAccessService(deps) {
+    const store = remoteAccessStore(deps.db);
+    const { saved, record } = store;
+    const { loopbackTarget, base, fromProblem, dockerView, offView, funnelProblem, onView } = remoteAccessViews(deps, saved);
+    const diagnose = async () => {
+        const status = await deps.run(tailscaleCommands.status());
+        // `status --json` exits 1 while signed out but still prints the state.
+        const machine = status.stdout.trim().startsWith("{") && !status.missing
+            ? machineOf(status.stdout)
+            : problemOf(status, deps.platform);
+        if (isProblem(machine))
+            return machine;
+        const serveStatus = await deps.run(tailscaleCommands.serveStatus());
+        if (serveStatus.code !== 0)
+            return problemOf(serveStatus, deps.platform);
+        const serve = parseServeStatus(serveStatus.stdout);
+        if (serve === undefined)
+            return {
+                state: "failed",
+                summary: "Slopify couldn't read tailscale serve status --json.",
+                fix: "Update Tailscale to a current version (tailscale.com/download), then press Check again.",
+                link: "https://tailscale.com/download",
+            };
+        return { machine, serve };
+    };
+    const ready = (value) => !("state" in value);
+    const ownerOf = (machine) => machine.owner === undefined ? {} : { owner: machine.owner };
+    // Removes the handler Slopify added, only while it is still exactly that.
+    const removeOurs = async (now) => {
+        const ours = store.applied();
+        if (ours === undefined)
+            return undefined;
+        if (ours.dnsName === now.machine.dnsName) {
+            const use = portUse(now.serve, ours.dnsName, ours.httpsPort);
+            if (use.kind === "proxy" && sameTarget(use.target, ours.target)) {
+                const off = await deps.run(tailscaleCommands.serveOff(ours.httpsPort));
+                if (off.code !== 0)
+                    return problemOf(off, deps.platform);
+            }
+            else if (use.kind !== "free")
+                deps.log.write("info", "remote-access.left", {
+                    detail: `port ${ours.httpsPort} was changed outside Slopify, so it is left as it is`,
+                });
+        }
+        record(undefined);
+        return undefined;
+    };
+    const apply = async () => {
+        const want = saved();
+        const target = loopbackTarget();
+        let now = await diagnose();
+        if (!ready(now))
+            return fromProblem(now);
+        const ours = store.applied();
+        if (ours !== undefined &&
+            (ours.httpsPort !== want.httpsPort ||
+                !sameTarget(ours.target, target) ||
+                ours.dnsName !== now.machine.dnsName)) {
+            const removed = await removeOurs(now);
+            if (removed !== undefined)
+                return fromProblem(removed);
+            now = await diagnose();
+            if (!ready(now))
+                return fromProblem(now);
+        }
+        const { dnsName } = now.machine;
+        const use = portUse(now.serve, dnsName, want.httpsPort);
+        const before = store.applied();
+        const mine = before !== undefined && use.kind === "proxy" && sameTarget(use.target, before.target);
+        if (!mine && use.kind !== "free")
+            return fromProblem(portTakenProblem(want.httpsPort, use, target, freePort(now.serve, dnsName, want.httpsPort)), { suggestedPort: freePort(now.serve, dnsName, want.httpsPort) });
+        if (!mine) {
+            const on = await deps.run(tailscaleCommands.serveOn(want.httpsPort, target));
+            if (on.code !== 0)
+                return fromProblem(serveRefusedProblem(on, deps.platform));
+            record({ dnsName, httpsPort: want.httpsPort, target, ...ownerOf(now.machine) });
+        }
+        else if (before !== undefined &&
+            before.owner === undefined &&
+            now.machine.owner !== undefined)
+            record({ ...before, owner: now.machine.owner });
+        const after = await diagnose();
+        if (!ready(after))
+            return fromProblem(after);
+        const check = portUse(after.serve, dnsName, want.httpsPort);
+        if (check.kind !== "proxy" || !sameTarget(check.target, target))
+            return base("not-applied", "Tailscale accepted the command, but Slopify's address isn't in its serve settings.", {
+                fix: "Run tailscale serve status in a terminal to see what Tailscale has, then press Check again.",
+            });
+        if (check.funnel) {
+            await removeOurs(after);
+            return fromProblem(funnelProblem(want.httpsPort));
+        }
+        return onView(dnsName, want.httpsPort);
+    };
+    // A read: what is true now, without changing Tailscale.
+    const read = async () => {
+        if (deps.container)
+            return dockerView();
+        const want = saved();
+        if (!want.enabled)
+            return offView();
+        const now = await diagnose();
+        if (!ready(now))
+            return fromProblem(now);
+        const { dnsName } = now.machine;
+        const use = portUse(now.serve, dnsName, want.httpsPort);
+        const ours = store.applied();
+        if (ours !== undefined &&
+            ours.httpsPort === want.httpsPort &&
+            use.kind === "proxy" &&
+            sameTarget(use.target, ours.target))
+            return use.funnel
+                ? fromProblem(funnelProblem(want.httpsPort))
+                : onView(dnsName, want.httpsPort);
+        if (use.kind !== "free") {
+            const suggested = freePort(now.serve, dnsName, want.httpsPort);
+            return fromProblem(portTakenProblem(want.httpsPort, use, loopbackTarget(), suggested), {
+                suggestedPort: suggested,
+            });
+        }
+        return base("not-applied", "The switch is on, but Slopify's address isn't in Tailscale right now.", {
+            fix: "Press Check again to set it up again.",
+        });
+    };
+    // One change to Tailscale at a time.
+    let queue = Promise.resolve();
+    const serial = (work) => {
+        const next = queue.then(work, work);
+        queue = next.catch(() => undefined);
+        return next;
+    };
+    let cached;
+    const fresh = (view) => {
+        cached = { at: deps.now(), view };
+        view.catch(() => {
+            cached = undefined;
+        });
+        return view;
+    };
+    const turnOff = async () => {
+        if (store.applied() === undefined)
+            return offView();
+        const now = await diagnose();
+        const problem = ready(now) ? await removeOurs(now) : now;
+        if (problem === undefined)
+            return offView();
+        const port = store.applied()?.httpsPort ?? saved().httpsPort;
+        return fromProblem(problem, {
+            state: problem.state,
+            summary: `The switch is off, but Slopify couldn't remove its address from Tailscale yet: ${problem.summary} Slopify tries again at every start.`,
+            fix: `${problem.fix} Or remove it yourself with tailscale serve --https=${port} off.`,
+        });
+    };
+    return {
+        view: () => {
+            if (cached !== undefined && deps.now() - cached.at < cacheMs)
+                return cached.view;
+            return fresh(serial(read));
+        },
+        set: (enabled, httpsPort) => fresh(serial(async () => {
+            if (deps.container)
+                return dockerView();
+            store.save({ enabled, httpsPort: httpsPort ?? saved().httpsPort });
+            return enabled ? apply() : turnOff();
+        })),
+        start: () => serial(async () => {
+            cached = undefined;
+            if (deps.container)
+                return;
+            const view = saved().enabled ? await apply() : await turnOff();
+            if (view.state !== "on" && view.state !== "off")
+                deps.log.write("warn", "remote-access.start", {
+                    detail: `${view.summary} ${view.fix ?? ""}`,
+                });
+        }),
+        stop: () => serial(async () => {
+            cached = undefined;
+            if (deps.container || store.applied() === undefined)
+                return;
+            const now = await diagnose();
+            const problem = ready(now) ? await removeOurs(now) : now;
+            if (problem !== undefined)
+                deps.log.write("warn", "remote-access.stop", { detail: problem.summary });
+        }),
+        owner: () => store.applied()?.owner,
+        remoteHost: () => {
+            const ours = store.applied();
+            return ours === undefined
+                ? undefined
+                : ours.httpsPort === 443
+                    ? ours.dnsName
+                    : `${ours.dnsName}:${ours.httpsPort}`;
+        },
+    };
+}

package/dist/edge/remote-access/store.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { deleteSetting, readSetting, writeSetting } from "../../slices/settings/repo.js";
+import { defaultHttpsPort, remoteAccessAppliedKey, remoteAccessKey } from "./model.js";
+// The two settings rows remote access keeps: the switch as the person set it, and the exact
+// serve handler Slopify added (removed again only when it is still exactly that).
+const savedShape = z.object({
+    enabled: z.boolean(),
+    httpsPort: z.number().int().min(1).max(65535),
+});
+const appliedShape = z.object({
+    dnsName: z.string(),
+    httpsPort: z.number().int(),
+    target: z.string(),
+    // The Tailscale account the computer was signed in to when Slopify added its address: the
+    // only one let in over the tailnet. Absent in what older versions saved.
+    owner: z.string().optional(),
+});
+function readJson(db, key, shape) {
+    const raw = readSetting(db, key);
+    if (raw === undefined)
+        return undefined;
+    try {
+        const parsed = shape.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function remoteAccessStore(db) {
+    let applied = readJson(db, remoteAccessAppliedKey, appliedShape);
+    return {
+        saved: () => readJson(db, remoteAccessKey, savedShape) ?? { enabled: false, httpsPort: defaultHttpsPort },
+        applied: () => applied,
+        record: (next) => {
+            applied = next;
+            if (next === undefined)
+                deleteSetting(db, remoteAccessAppliedKey);
+            else
+                writeSetting(db, remoteAccessAppliedKey, JSON.stringify(next));
+        },
+        save: (next) => writeSetting(db, remoteAccessKey, JSON.stringify(next)),
+    };
+}

package/dist/edge/remote-access/views.js

@@ -0,0 +1,43 @@
+import { addressOf } from "./rules.js";
+export function remoteAccessViews(deps, saved) {
+    const loopbackTarget = () => {
+        const host = deps.listenHost;
+        const name = host === "" || host === "0.0.0.0" || host === "localhost" || host === "127.0.0.1"
+            ? "127.0.0.1"
+            : host === "::" || host === "::1"
+                ? "[::1]"
+                : host.includes(":")
+                    ? `[${host}]`
+                    : host;
+        return `http://${name}:${deps.port()}`;
+    };
+    const local = () => loopbackTarget();
+    const base = (state, summary, rest = {}) => ({
+        available: !deps.container,
+        enabled: saved().enabled,
+        state,
+        address: null,
+        httpsPort: saved().httpsPort,
+        suggestedPort: null,
+        summary,
+        fix: null,
+        link: null,
+        local: local(),
+        changeable: !deps.container,
+        ...rest,
+    });
+    const fromProblem = (problem, rest = {}) => base(problem.state, problem.summary, { fix: problem.fix, link: problem.link, ...rest });
+    const dockerView = () => base("docker", "Slopify runs in Docker here, so it can't set up Tailscale on the computer itself.", {
+        enabled: false,
+        fix: "Remote access needs Slopify started on the computer itself (npx @gentbajko/slopify). Or set Tailscale up yourself on the host: tailscale serve --bg --https=443 http://127.0.0.1:<Slopify's port>.",
+    });
+    const offView = () => base("off", `Off: Slopify answers only on this computer, at ${local()}.`);
+    const funnelProblem = (httpsPort) => ({
+        state: "funnel",
+        summary: "Tailscale Funnel was on for Slopify's address, which would put Slopify on the public internet. Slopify removed its address and refuses every request that comes through Funnel.",
+        fix: `Turn Funnel off with tailscale funnel --https=${httpsPort} off, then press Check again.`,
+        link: null,
+    });
+    const onView = (dnsName, httpsPort) => base("on", "On: any device in your tailnet can open this address, never the public internet. It works while Slopify runs: Slopify removes it when it stops and adds it back when it starts.", { address: addressOf(dnsName, httpsPort) });
+    return { loopbackTarget, base, fromProblem, dockerView, offView, funnelProblem, onView };
+}

package/dist/host-cli/install.js

@@ -2,9 +2,9 @@ import { execFile } from "node:child_process";
 import { access, lstat, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { z } from "zod";
+import { hasErrnoCode } from "../kernel/errors.js";
 import { isStableVersion, updatePackage } from "../updater/model.js";
 import { installArgs, npmCommand } from "../updater/plan.js";
-import { hasCode } from "./paths.js";
 export const nodeHostSetupRunner = {
     exec: (file, args, signal) => new Promise((resolve, reject) => {
         execFile(file, [...args], { signal, timeout: 15 * 60_000, maxBuffer: 1024 * 1024, windowsHide: true }, (error, stdout, stderr) => {
@@ -55,7 +55,7 @@ export async function installHostPackage(options) {
         return { entry: await entryAt(directory, version) };
     }
     catch (error) {
-        if (!hasCode(error, "ENOENT"))
+        if (!hasErrnoCode(error, "ENOENT"))
             throw new Error(`The installed host helper in ${directory} is damaged. Delete that folder and run the launcher again. Nothing else was changed.`);
     }
     await mkdir(versions, { recursive: true, mode: 0o700 });

package/dist/host-cli/open-folder.js

@@ -2,8 +2,8 @@ import { spawn } from "node:child_process";
 import { lstat, readdir } from "node:fs/promises";
 import { isAbsolute, join, relative, sep } from "node:path";
 import { installSchema, readState } from "../edge/docker-install/state.js";
+import { hasErrnoCode } from "../kernel/errors.js";
 import { HostFolderRefused } from "../kernel/ports/host-cli.js";
-import { hasCode } from "./paths.js";
 const again = "run the Docker install again (npx @gentbajko/slopify@latest --docker)";
 /** Starts the desktop's opener and returns once it is running; the file manager is not awaited. */
 export function launchXdgOpen(directory) {
@@ -14,7 +14,7 @@ export function launchXdgOpen(directory) {
             stdio: "ignore",
         });
         child.once("error", (error) => {
-            reject(new Error(hasCode(error, "ENOENT")
+            reject(new Error(hasErrnoCode(error, "ENOENT")
                 ? "xdg-open isn't installed on this machine, so the Slopify host helper can't open a file manager. Install xdg-utils (for example sudo pacman -S xdg-utils or sudo apt install xdg-utils), then use Open folder again."
                 : `The Slopify host helper could not start xdg-open to open ${directory}. Check that you are signed in to this computer's desktop, then use Open folder again.`));
         });

package/dist/host-cli/paths.js

@@ -2,6 +2,7 @@ import { randomBytes } from "node:crypto";
 import { constants } from "node:fs";
 import { chmod, lstat, mkdir, open } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
+import { hasErrnoCode } from "../kernel/errors.js";
 export async function prepareHostPaths(root) {
     if (!isAbsolute(root) || /[\p{Cc}]/u.test(root))
         throw new Error(`Unsafe host helper directory ${JSON.stringify(root)}: it must be a full path. Check XDG_DATA_HOME and HOME, then run the launcher again.`);
@@ -55,7 +56,7 @@ export async function ensureBridgeToken(path) {
         }
     }
     catch (error) {
-        if (!hasCode(error, "EEXIST"))
+        if (!hasErrnoCode(error, "EEXIST"))
             throw error;
     }
     const entry = await lstat(path);
@@ -63,6 +64,3 @@ export async function ensureBridgeToken(path) {
         throw new Error(`The host helper token file ${path} is a link or belongs to another user. Delete it and run the launcher again.`);
     return readBridgeToken(path);
 }
-export function hasCode(error, code) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}

package/dist/host-cli/server.js

@@ -4,7 +4,7 @@ import { connect } from "node:net";
 import { join } from "node:path";
 import { createAdaptorServer } from "@hono/node-server";
 import { hostCliRoutes, hostGate } from "../edge/http/host-cli.js";
-import { hasCode } from "./paths.js";
+import { hasErrnoCode } from "../kernel/errors.js";
 export async function startHostServer(options) {
     const socket = join(options.directory, "cli.sock");
     if (Buffer.byteLength(socket) > 100)
@@ -23,7 +23,7 @@ export async function startHostServer(options) {
         await unlink(socket);
     }
     catch (error) {
-        if (!hasCode(error, "ENOENT"))
+        if (!hasErrnoCode(error, "ENOENT"))
             throw error;
     }
     const gate = hostGate();
@@ -67,7 +67,7 @@ export async function startHostServer(options) {
                         await unlink(socket);
                 }
                 catch (error) {
-                    if (!hasCode(error, "ENOENT"))
+                    if (!hasErrnoCode(error, "ENOENT"))
                         throw error;
                 }
             })();
@@ -89,7 +89,7 @@ function listening(path) {
         });
         socket.once("error", (error) => {
             socket.destroy();
-            if (hasCode(error, "ECONNREFUSED"))
+            if (hasErrnoCode(error, "ECONNREFUSED"))
                 resolve(false);
             else
                 reject(new Error("Could not verify existing host socket."));

package/dist/host-cli/service.js

@@ -3,9 +3,9 @@ import { lstat, mkdir, open, rename, unlink } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { hostRequest, readHostBytes } from "../adapters/host-cli/transport.js";
+import { hasErrnoCode } from "../kernel/errors.js";
 import { bridgeLimits, hostHealthSchema } from "../kernel/ports/host-cli.js";
 import { hostEnvironment } from "./environment.js";
-import { hasCode } from "./paths.js";
 const marker = "# Managed by Slopify host CLI bridge, protocol 1";
 export const hostUnit = "slopify-cli-bridge.service";
 function unitArg(value) {
@@ -51,7 +51,7 @@ export async function privateRead(path, uid) {
         }
     }
     catch (error) {
-        if (hasCode(error, "ENOENT"))
+        if (hasErrnoCode(error, "ENOENT"))
             return undefined;
         throw error;
     }
@@ -71,7 +71,7 @@ export async function privateWrite(path, text) {
     }
     finally {
         await unlink(temporary).catch((error) => {
-            if (!hasCode(error, "ENOENT"))
+            if (!hasErrnoCode(error, "ENOENT"))
                 throw error;
         });
     }