@nowcrew/daemon 0.6.6 → 0.6.7

package/dist/remote/config.js

@@ -1,135 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { link, mkdir, open, readFile, rename, unlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { z } from "zod";
-const RemoteConfigFileSchema = z.object({
-    version: z.literal(1),
-    host: z.string().min(1),
-    port: z.number().int().min(1).max(65_535),
-    allowedOrigins: z.array(z.string().url()).max(16),
-}).strict();
-const RemoteOwnerLockSchema = z.object({
-    version: z.literal(1),
-    gatewayId: z.string().uuid(),
-    pid: z.number().int().positive(),
-    host: z.string().min(1),
-    port: z.number().int().min(1).max(65_535),
-    startedAt: z.string().datetime(),
-    identityKey: z.string().regex(/^[A-Za-z0-9_-]{43}$/).optional(),
-}).strict();
-export function remotePaths(root = process.env.NOWCREW_REMOTE_HOME ?? join(homedir(), ".nowcrew", "remote")) {
-    return {
-        root,
-        config: join(root, "config.json"),
-        token: join(root, "token"),
-        lock: join(root, "gateway.lock.json"),
-        codexSocket: join(root, "codex", "app-server.sock"),
-    };
-}
-async function readOptional(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-}
-async function writeOwnerOnly(path, contents) {
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    const tmp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-    const file = await open(tmp, "wx", 0o600);
-    try {
-        await file.writeFile(contents, "utf8");
-        await file.sync();
-    }
-    finally {
-        await file.close();
-    }
-    await rename(tmp, path);
-}
-export async function loadOrCreateRemoteConfig(overrides = {}) {
-    const paths = remotePaths(overrides.root);
-    await mkdir(paths.root, { recursive: true, mode: 0o700 });
-    const existingConfig = await readOptional(paths.config);
-    const parsed = existingConfig === null
-        ? { version: 1, host: "127.0.0.1", port: 4317, allowedOrigins: [] }
-        : RemoteConfigFileSchema.parse(JSON.parse(existingConfig));
-    const fileConfig = RemoteConfigFileSchema.parse({
-        ...parsed,
-        ...(overrides.host === undefined ? {} : { host: overrides.host }),
-        ...(overrides.port === undefined ? {} : { port: overrides.port }),
-    });
-    if (existingConfig === null || fileConfig.host !== parsed.host || fileConfig.port !== parsed.port) {
-        await writeOwnerOnly(paths.config, `${JSON.stringify(fileConfig, null, 2)}\n`);
-    }
-    const existingToken = (await readOptional(paths.token))?.trim();
-    const token = existingToken && /^[A-Za-z0-9_-]{43}$/.test(existingToken)
-        ? existingToken
-        : randomBytes(32).toString("base64url");
-    if (token !== existingToken)
-        await writeOwnerOnly(paths.token, `${token}\n`);
-    return { ...fileConfig, token, paths };
-}
-export async function updateRemoteBinding(config, input) {
-    const next = RemoteConfigFileSchema.parse({
-        version: 1,
-        host: input.host,
-        port: input.port,
-        allowedOrigins: input.allowedOrigins ?? config.allowedOrigins,
-    });
-    await writeOwnerOnly(config.paths.config, `${JSON.stringify(next, null, 2)}\n`);
-    return { ...next, token: config.token, paths: config.paths };
-}
-export async function acquireRemoteOwnerLock(path, value) {
-    const parsed = RemoteOwnerLockSchema.parse(value);
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    const tmp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-    const file = await open(tmp, "wx", 0o600);
-    try {
-        await file.writeFile(`${JSON.stringify(parsed, null, 2)}\n`, "utf8");
-        await file.sync();
-    }
-    finally {
-        await file.close();
-    }
-    try {
-        await link(tmp, path);
-        return true;
-    }
-    catch (error) {
-        if (error.code === "EEXIST")
-            return false;
-        throw error;
-    }
-    finally {
-        await unlink(tmp).catch((error) => {
-            if (error.code !== "ENOENT")
-                throw error;
-        });
-    }
-}
-export async function readRemoteOwnerLock(path) {
-    const contents = await readOptional(path);
-    return contents === null ? null : RemoteOwnerLockSchema.parse(JSON.parse(contents));
-}
-export async function releaseRemoteOwnerLock(path, gatewayId) {
-    const current = await readRemoteOwnerLock(path);
-    if (!current || current.gatewayId !== gatewayId)
-        return false;
-    try {
-        await unlink(path);
-        return true;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-}
-// Exported for tests that verify atomic replacement without duplicating filesystem logic.
-export async function writeRemoteConfigForTest(path, contents) {
-    await writeOwnerOnly(path, contents);
-}