@gentbajko/slopify 1.3.1 → 1.4.0

package/dist/edge/docker.js

@@ -0,0 +1,109 @@
+import { mkdir, rmdir } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { z } from "zod";
+import { installHostPackage } from "../host-cli/install.js";
+import { ensureBridgeToken, hasCode, prepareHostPaths } from "../host-cli/paths.js";
+import { ensureHostService, privateRead, privateWrite } from "../host-cli/service.js";
+import { resolveHostCommand } from "../host-cli/status.js";
+import { hostCliProtocol, hostLlmIds } from "../kernel/ports/host-cli.js";
+export async function prepareDockerHostCli(options) {
+    if (options.disabled)
+        return {};
+    let installed = false;
+    for (const id of hostLlmIds) {
+        try {
+            await resolveHostCommand(id, options.env);
+            installed = true;
+        }
+        catch (error) {
+            if (!hasCode(error, "ENOENT"))
+                throw new Error("Host CLI detection failed. No container was changed.");
+        }
+    }
+    if (!installed)
+        return {};
+    if (process.platform !== "linux")
+        throw new Error("Managed host CLI setup requires Linux/systemd. Use --host-cli=off for API-only Docker.");
+    const uid = process.getuid?.();
+    if (uid === undefined || uid === 0)
+        throw new Error("Run the Docker launcher as your logged-in user, not root; or use --host-cli=off.");
+    const receiptPath = join(options.root, "consent.json");
+    const existing = await privateRead(receiptPath, uid);
+    const receipt = z.object({ version: z.literal(1), automaticStartup: z.literal(true) }).strict();
+    let approved = options.accepted;
+    if (existing !== undefined) {
+        try {
+            approved ||= receipt.safeParse(JSON.parse(existing)).success;
+        }
+        catch {
+            throw new Error("Invalid host helper consent receipt.");
+        }
+    }
+    if (!approved) {
+        if (!options.interactive)
+            throw new Error("Host CLI setup needs confirmation. Use --accept-host-cli to approve, or --host-cli=off for API-only Docker.");
+        approved = await options.prompt("Allow Slopify to run your host Claude Code, Codex and Gemini CLIs using their existing logins? This installs a private helper and enables automatic startup. User lingering keeps your user services running after logout and at boot. Credentials stay on the host. [y/N] ");
+        if (!approved)
+            throw new Error("Host CLI setup declined. The container is unchanged. Use --host-cli=off for API-only Docker.");
+    }
+    const inspect = () => options.runner.exec("docker", [
+        "image",
+        "inspect",
+        "--format",
+        '{{index .Config.Labels "io.slopify.host-cli-protocol"}}',
+        options.image,
+    ], options.signal);
+    let image = await inspect();
+    if (image.code !== 0 || image.stdout.trim() !== String(hostCliProtocol)) {
+        const pulled = await options.runner.exec("docker", ["pull", options.image], options.signal);
+        if (pulled.code !== 0)
+            throw new Error("Could not pull a compatible Docker image. No helper or container was changed.");
+        image = await inspect();
+        if (image.code !== 0 || image.stdout.trim() !== String(hostCliProtocol))
+            throw new Error("This Docker image does not support the host helper. Update the image before retrying.");
+    }
+    const supported = await options.runner.exec("systemctl", ["--user", "list-units", "--no-legend", "--no-pager", "slopify-cli-bridge.service"], options.signal);
+    if (supported.code !== 0)
+        throw new Error("The systemd user service is unavailable. Use a normal Slopify install or --host-cli=off for API-only Docker.");
+    const paths = await prepareHostPaths(options.root);
+    const lock = join(paths.root, "setup.lock");
+    const deadline = Date.now() + 30_000;
+    for (;;) {
+        try {
+            await mkdir(lock, { mode: 0o700 });
+            break;
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+            if (Date.now() >= deadline)
+                throw new Error("Another host helper setup holds setup.lock. Wait for it to finish; the container is unchanged.");
+            await delay(100, undefined, { signal: options.signal });
+        }
+    }
+    try {
+        await ensureBridgeToken(paths.tokenFile);
+        const installed = await installHostPackage({
+            root: paths.root,
+            version: options.version,
+            runner: options.runner,
+            signal: options.signal,
+        });
+        await ensureHostService({
+            root: paths.root,
+            entry: installed.entry,
+            node: process.execPath,
+            uid,
+            version: options.version,
+            runner: options.runner,
+            signal: options.signal,
+            env: options.env,
+        });
+        await privateWrite(receiptPath, JSON.stringify({ version: 1, automaticStartup: true }));
+        return { directory: paths.share };
+    }
+    finally {
+        await rmdir(lock);
+    }
+}

package/dist/edge/host-cli.js

@@ -0,0 +1,58 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { nodeRunCli } from "../adapters/llm/run-cli.js";
+import { hostEnvironmentSchema } from "../host-cli/environment.js";
+import { ensureBridgeToken, prepareHostPaths } from "../host-cli/paths.js";
+import { createHostRuntime } from "../host-cli/runtime.js";
+import { startHostServer } from "../host-cli/server.js";
+import { resolveHostCommand } from "../host-cli/status.js";
+import { readVersion } from "../kernel/version.js";
+import { nodeCliProbe } from "../slices/settings/cli-status.js";
+const { values } = parseArgs({ options: { "state-dir": { type: "string" } }, strict: true });
+if (!values["state-dir"])
+    throw new Error("A host helper state directory is required.");
+const paths = await prepareHostPaths(values["state-dir"]);
+const file = await open(join(paths.root, "host-environment.json"), constants.O_RDONLY | constants.O_NOFOLLOW);
+try {
+    const stat = await file.stat();
+    if (!stat.isFile() ||
+        stat.size > 64 * 1024 ||
+        (stat.mode & 0o077) !== 0 ||
+        (process.getuid && stat.uid !== process.getuid()))
+        throw new Error("Unsafe host environment file.");
+    const buffer = Buffer.alloc(64 * 1024 + 1);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+    if (bytesRead > 64 * 1024)
+        throw new Error("Host environment file is too large.");
+    const environment = hostEnvironmentSchema.parse(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")));
+    Object.assign(process.env, environment);
+}
+finally {
+    await file.close();
+}
+const server = await startHostServer({
+    directory: paths.share,
+    token: await ensureBridgeToken(paths.tokenFile),
+    version: readVersion(),
+    ports: createHostRuntime({
+        run: nodeRunCli,
+        probe: nodeCliProbe,
+        env: process.env,
+        now: Date.now,
+        resolve: (id) => resolveHostCommand(id, process.env),
+    }),
+});
+process.on("SIGHUP", server.pauseAdmissions);
+process.on("SIGUSR2", server.resumeAdmissions);
+const stop = () => {
+    void server.stop().then(() => {
+        process.exitCode = 0;
+    }, () => {
+        console.error("Host helper shutdown failed.");
+        process.exitCode = 1;
+    });
+};
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);

package/dist/edge/http/actions.js

@@ -56,7 +56,7 @@ export function actionRoutes(deps) {
         ...reruns,
         runner: deps.runner,
         emit: (projectId, event) => deps.hub.emit(projectId, event),
-        providers: () => providerStatuses({ db: deps.db, probe: deps.probe }),
+        providers: () => providerStatuses({ db: deps.db, probe: deps.probe, hostCliStatus: deps.hostCliStatus }),
         allowsCustomModels: deps.catalogue ? () => false : allowsCustomModel,
         modelsFor: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
     };

package/dist/edge/http/diagnostics.js

@@ -7,7 +7,11 @@ import { providerStatuses } from "../../slices/settings/readiness.js";
  */
 export function diagnosticsRoutes(deps) {
     return new Hono().get("/", async (c) => {
-        const providers = await providerStatuses({ db: deps.db, probe: deps.probe });
+        const providers = await providerStatuses({
+            db: deps.db,
+            probe: deps.probe,
+            hostCliStatus: deps.hostCliStatus,
+        });
         const projectCount = deps.db.prepare("SELECT count(*) AS count FROM projects").get();
         const schema = deps.db.prepare("SELECT max(version) AS version FROM schema_migrations").get();
         c.header("Cache-Control", "no-store");

package/dist/edge/http/host-cli.js

@@ -0,0 +1,247 @@
+import { timingSafeEqual } from "node:crypto";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { stream } from "hono/streaming";
+import { z } from "zod";
+import { sniffImage } from "../../adapters/image/bytes.js";
+import { redact } from "../../kernel/log.js";
+import { bridgeLimits, hostCliIds, hostCliProtocol, hostFrameSchema, hostImageSchema, hostLlmIds, hostLlmSchema, hostModelsSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
+import { isProviderError, providerError } from "../../kernel/ports/model.js";
+export function hostGate() {
+    let accepting = true;
+    let stopped = false;
+    const generation = new Set();
+    const metadata = new Set();
+    return {
+        get active() {
+            return generation.size;
+        },
+        get accepting() {
+            return accepting;
+        },
+        acquire: (kind) => {
+            const set = kind === "generation" ? generation : metadata;
+            if (!accepting || set.size >= bridgeLimits[kind])
+                return undefined;
+            const controller = new AbortController();
+            set.add(controller);
+            return {
+                signal: controller.signal,
+                abort: () => controller.abort(),
+                release: () => {
+                    set.delete(controller);
+                },
+            };
+        },
+        pause: () => {
+            accepting = false;
+        },
+        resume: () => {
+            if (!stopped)
+                accepting = true;
+        },
+        stop: () => {
+            stopped = true;
+            accepting = false;
+            for (const controller of [...generation, ...metadata])
+                controller.abort();
+        },
+    };
+}
+const unavailable = "Host CLI operation did not finish reliably; its result may be uncertain. Review the affected rebuild before retrying.";
+function fault(error, token) {
+    return {
+        type: "error",
+        kind: isProviderError(error) ? error.fault.kind : "unavailable",
+        message: redact(isProviderError(error)
+            ? error.message
+            : "Host helper operation failed. Check the host CLI and rerun the Docker launcher.")
+            .replaceAll(token, "[redacted]")
+            .slice(0, 4096),
+    };
+}
+export function hostCliRoutes(options) {
+    const app = new Hono();
+    const { gate, ports, token } = options;
+    app.use("*", async (c, next) => {
+        const supplied = Buffer.from(c.req.header("authorization") ?? "");
+        const expected = Buffer.from(`Bearer ${token}`);
+        if (supplied.length !== expected.length || !timingSafeEqual(supplied, expected))
+            return c.json({ type: "error", kind: "unavailable", message: "Host helper authorization failed." }, 401);
+        c.header("Cache-Control", "no-store");
+        await next();
+    });
+    app.get("/v1/health", (c) => c.json({
+        protocol: hostCliProtocol,
+        version: options.version,
+        active: gate.active,
+        accepting: gate.accepting,
+    }));
+    app.use("/v1/*", async (c, next) => {
+        const kind = c.req.method === "POST" ? "generation" : "metadata";
+        const job = gate.acquire(kind);
+        if (!job)
+            return c.json({
+                type: "error",
+                kind: "unavailable",
+                message: "The host helper is busy or restarting. Review the rebuild after it is ready.",
+            }, 503);
+        const outgoing = c.env?.outgoing;
+        let responseEnded = !outgoing;
+        let handlerEnded = false;
+        let streaming = false;
+        const releaseIfFinished = () => {
+            if (responseEnded && handlerEnded && !streaming)
+                job.release();
+        };
+        c.set("job", {
+            ...job,
+            holdStream: () => {
+                streaming = true;
+            },
+            release: () => {
+                streaming = false;
+                releaseIfFinished();
+            },
+        });
+        const finish = () => {
+            responseEnded = true;
+            releaseIfFinished();
+        };
+        const close = () => {
+            if (!outgoing?.writableFinished)
+                job.abort();
+            finish();
+        };
+        outgoing?.once("close", close);
+        outgoing?.once("finish", finish);
+        const abort = () => job.abort();
+        c.req.raw.signal.addEventListener("abort", abort, { once: true });
+        try {
+            await next();
+        }
+        finally {
+            c.req.raw.signal.removeEventListener("abort", abort);
+            handlerEnded = true;
+            releaseIfFinished();
+        }
+    });
+    app.use("/v1/*", bodyLimit({
+        maxSize: bridgeLimits.request,
+        onError: (c) => c.json({ type: "error", kind: "unavailable", message: "Host request is too large." }, 413),
+    }));
+    app.get("/v1/status/:provider", async (c) => {
+        const id = z.enum(hostCliIds).safeParse(c.req.param("provider"));
+        if (!id.success)
+            return c.notFound();
+        const status = hostStatusSchema.parse(await ports.status(id.data));
+        const text = JSON.stringify(status);
+        if (Buffer.byteLength(text) > bridgeLimits.status)
+            throw providerError({ kind: "unavailable", message: "Host status exceeded its limit." });
+        return c.json(status);
+    });
+    app.get("/v1/models/:provider", async (c) => {
+        const id = z.enum(hostCliIds).safeParse(c.req.param("provider"));
+        if (!id.success)
+            return c.notFound();
+        const result = hostModelsSchema.parse({
+            models: await (id.data === "codex-image" ? ports.image : ports.llm(id.data)).models(),
+        });
+        if (Buffer.byteLength(JSON.stringify(result)) > bridgeLimits.models)
+            throw providerError({ kind: "unavailable", message: "Host models exceeded their limit." });
+        return c.json(result);
+    });
+    app.post("/v1/llm/:provider", async (c) => {
+        const id = z.enum(hostLlmIds).safeParse(c.req.param("provider"));
+        if (!id.success)
+            return c.notFound();
+        const body = hostLlmSchema.safeParse(await json(c.req.raw));
+        if (!body.success)
+            return invalid(c);
+        const job = c.get("job");
+        job.holdStream();
+        const controller = new AbortController();
+        const signal = AbortSignal.any([job.signal, controller.signal]);
+        let timer = setTimeout(() => controller.abort(), 120_000);
+        let total = 0;
+        let done = false;
+        c.header("Content-Type", "application/x-ndjson");
+        return stream(c, async (output) => {
+            output.onAbort(() => controller.abort());
+            const abort = () => output.abort();
+            signal.addEventListener("abort", abort, { once: true });
+            try {
+                for await (const event of ports.llm(id.data).complete({ ...body.data, signal })) {
+                    signal.throwIfAborted();
+                    clearTimeout(timer);
+                    timer = setTimeout(() => controller.abort(), 120_000);
+                    const parsed = hostFrameSchema.parse(event);
+                    if (done || parsed.type === "error")
+                        throw new Error("Invalid provider stream.");
+                    const frame = `${JSON.stringify(parsed)}\n`;
+                    total += Buffer.byteLength(frame);
+                    if (Buffer.byteLength(frame) > bridgeLimits.frame || total > bridgeLimits.stream)
+                        throw new Error("Host stream exceeded its limit.");
+                    await output.write(frame);
+                    signal.throwIfAborted();
+                    done = parsed.type === "done";
+                }
+                if (!done)
+                    throw providerError({ kind: "unavailable", message: unavailable });
+            }
+            catch (error) {
+                if (!output.aborted)
+                    await output.write(`${JSON.stringify(fault(signal.aborted ? providerError({ kind: "unavailable", message: unavailable }) : error, token))}\n`);
+            }
+            finally {
+                clearTimeout(timer);
+                signal.removeEventListener("abort", abort);
+                controller.abort();
+                job.release();
+            }
+        }, async () => {
+            controller.abort();
+            job.release();
+        });
+    });
+    app.post("/v1/image", async (c) => {
+        const body = hostImageSchema.safeParse(await json(c.req.raw));
+        if (!body.success)
+            return invalid(c);
+        const job = c.get("job");
+        const controller = new AbortController();
+        const signal = AbortSignal.any([job.signal, controller.signal]);
+        const timer = setTimeout(() => controller.abort(), 300_000);
+        try {
+            const result = await ports.image.generate({ ...body.data, signal });
+            if (signal.aborted)
+                throw providerError({ kind: "unavailable", message: unavailable });
+            if (result.bytes.byteLength > bridgeLimits.image || sniffImage(result.bytes) !== result.mime)
+                throw new Error("Invalid host image.");
+            c.header("Content-Type", result.mime);
+            c.header("Content-Length", String(result.bytes.byteLength));
+            return c.body(new Uint8Array(result.bytes));
+        }
+        catch (error) {
+            throw signal.aborted ? providerError({ kind: "unavailable", message: unavailable }) : error;
+        }
+        finally {
+            clearTimeout(timer);
+            controller.abort();
+        }
+    });
+    app.onError((error, c) => c.json(fault(error, token), 503));
+    app.notFound((c) => c.json({ type: "error", kind: "unavailable", message: "Unknown host helper operation or protocol." }, 404));
+    return app;
+}
+async function json(request) {
+    try {
+        return await request.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+function invalid(c) {
+    return c.json({ type: "error", kind: "unavailable", message: "Invalid host provider request." }, 400);
+}

package/dist/edge/http/providers.js

@@ -17,7 +17,11 @@ const keyBody = z.object({ key: z.string().min(1).max(4096) });
 // generated from; see stagingRoutes.
 export function providerRoutes(deps) {
     const keys = { db: deps.db, clock: deps.clock };
-    const readiness = { db: deps.db, probe: deps.probe };
+    const readiness = {
+        db: deps.db,
+        probe: deps.probe,
+        hostCliStatus: deps.hostCliStatus,
+    };
     const catalog = createModelCatalog({
         load: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
         fallback: deps.fallbackModelsFor ?? (() => []),

package/dist/host-cli/environment.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+const path = z
+    .string()
+    .max(16384)
+    .refine((value) => !/[\p{Cc}]/u.test(value));
+export const hostEnvironmentSchema = z
+    .object({
+    HOME: path,
+    PATH: path,
+    CODEX_HOME: path.optional(),
+    CLAUDE_CONFIG_DIR: path.optional(),
+    XDG_CONFIG_HOME: path.optional(),
+    XDG_DATA_HOME: path.optional(),
+    XDG_CACHE_HOME: path.optional(),
+    SSL_CERT_FILE: path.optional(),
+    NODE_EXTRA_CA_CERTS: path.optional(),
+})
+    .strict();
+export function hostEnvironment(env) {
+    const selected = {};
+    for (const key of Object.keys(hostEnvironmentSchema.shape))
+        if (env[key] !== undefined)
+            selected[key] = env[key];
+    return hostEnvironmentSchema.parse(selected);
+}

package/dist/host-cli/install.js

@@ -0,0 +1,61 @@
+import { execFile } from "node:child_process";
+import { access, lstat, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+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) => {
+            if (error && typeof error.code !== "number")
+                return reject(new Error("Host setup command could not finish. Check Docker, Node and the systemd user service."));
+            resolve({ code: typeof error?.code === "number" ? error.code : 0, stdout });
+        });
+    }),
+};
+async function entryAt(directory, version) {
+    const path = join(directory, "node_modules", "@gentbajko", "slopify");
+    z.object({ name: z.literal(updatePackage), version: z.literal(version) }).parse(JSON.parse(await readFile(join(path, "package.json"), "utf8")));
+    const entry = join(path, "dist/edge/host-cli.js");
+    if (!(await lstat(entry)).isFile())
+        throw new Error("Host helper entry is not a regular file.");
+    await access(entry);
+    return entry;
+}
+export async function installHostPackage(options) {
+    const { root, version, runner, signal } = options;
+    if (!isStableVersion(version))
+        throw new Error("Invalid host helper version.");
+    const versions = join(root, "versions");
+    const directory = join(versions, version);
+    try {
+        return { entry: await entryAt(directory, version) };
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw new Error("Existing host helper install is invalid. No service was changed.");
+    }
+    await mkdir(versions, { recursive: true, mode: 0o700 });
+    const staging = await mkdtemp(join(versions, `.install-${version}-`));
+    try {
+        await writeFile(join(staging, ".npmrc"), "registry=https://registry.npmjs.org/\n@gentbajko:registry=https://registry.npmjs.org/\n", { mode: 0o600 });
+        await writeFile(join(staging, ".global-npmrc"), "", { mode: 0o600 });
+        const npm = await npmCommand();
+        const args = installArgs(staging, version);
+        const result = await runner.exec(npm.file, [
+            ...npm.args,
+            ...args.slice(0, -1),
+            "--ignore-scripts",
+            options.packageSource ?? `${updatePackage}@${version}`,
+        ], signal);
+        if (result.code !== 0)
+            throw new Error("npm could not install the host helper. The existing container was not changed.");
+        await entryAt(staging, version);
+        await rename(staging, directory);
+        return { entry: await entryAt(directory, version) };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}

package/dist/host-cli/paths.js

@@ -0,0 +1,68 @@
+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";
+export async function prepareHostPaths(root) {
+    if (!isAbsolute(root) || /[\p{Cc}]/u.test(root))
+        throw new Error("Unsafe host helper directory.");
+    const normalized = resolve(root);
+    const share = join(normalized, "share");
+    const socket = join(share, "cli.sock");
+    if (Buffer.byteLength(socket) > 100)
+        throw new Error("Use a shorter XDG_DATA_HOME for the host helper socket (at most 100 bytes).");
+    await mkdir(normalized, { recursive: true, mode: 0o700 });
+    await ownedDirectory(normalized, true);
+    await chmod(normalized, 0o700);
+    await mkdir(share, { recursive: true, mode: 0o755 });
+    await ownedDirectory(share);
+    await chmod(share, 0o755);
+    return { root: normalized, share, socket, tokenFile: join(share, "token") };
+}
+async function ownedDirectory(path, privateRoot = false) {
+    const entry = await lstat(path);
+    if (!entry.isDirectory() ||
+        entry.isSymbolicLink() ||
+        (privateRoot && (entry.mode & 0o077) !== 0) ||
+        (process.getuid && entry.uid !== process.getuid()))
+        throw new Error("Unsafe host helper directory.");
+}
+export async function readBridgeToken(path) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const entry = await file.stat();
+        if (!entry.isFile() || entry.size !== 64 || (entry.mode & 0o022) !== 0)
+            throw new Error("Invalid host helper token file.");
+        const buffer = Buffer.alloc(65);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+        const value = buffer.subarray(0, bytesRead).toString("utf8");
+        if (!/^[a-f0-9]{64}$/.test(value))
+            throw new Error("Invalid host helper token file.");
+        return value;
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function ensureBridgeToken(path) {
+    try {
+        const file = await open(path, "wx", 0o644);
+        try {
+            await file.writeFile(randomBytes(32).toString("hex"));
+            await file.chmod(0o644);
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch (error) {
+        if (!hasCode(error, "EEXIST"))
+            throw error;
+    }
+    const entry = await lstat(path);
+    if (entry.isSymbolicLink() || (process.getuid && entry.uid !== process.getuid()))
+        throw new Error("Unsafe host helper token file.");
+    return readBridgeToken(path);
+}
+export function hasCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}