@beryl-so/cli 0.1.0

package/dist/commands/tests.js

@@ -0,0 +1,239 @@
+import fs from "node:fs";
+import { UsageError } from "../errors.js";
+import { arg, argList, flagBool, flagNum, flagStr, projectPath, readJsonFlag } from "./util.js";
+const testPath = (ws, p, id) => `${projectPath(ws, p)}/tests/${id}`;
+export const testCommands = [
+    {
+        name: "tests list",
+        summary: "List the project's tests with their latest result",
+        scope: "project",
+        flags: [{ name: "env", type: "string", description: "Filter by environment id" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.get(`${projectPath(workspaceId, projectId)}/tests`, {
+                    environment_id: flagStr(input, "env"),
+                }),
+            };
+        },
+    },
+    {
+        name: "tests get",
+        summary: "Show one test",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.get(testPath(workspaceId, projectId, arg(input, "test-id"))) };
+        },
+    },
+    {
+        name: "tests plan",
+        summary: "Print a test's current step plan (JSON)",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const base = testPath(workspaceId, projectId, arg(input, "test-id"));
+            const versions = (await ctx.client.get(`${base}/versions`, { limit: 1 }));
+            const version = (await ctx.client.get(`${base}/versions/${versions.current_version_no}`));
+            return { data: version.json_plan, human: JSON.stringify(version.json_plan, null, 2) };
+        },
+    },
+    {
+        name: "tests create",
+        summary: "Create a test case from a JSON action plan — for tests authored locally, e.g. by your coding agent",
+        description: "The plan is a JSON object whose steps are {action, selector, url, value, ...}: the first " +
+            "step must be a goto, and at least one step must be an expect. By default the plan is " +
+            "verified in a real browser before the test is accepted.",
+        scope: "project",
+        flags: [
+            { name: "title", type: "string", required: true, description: "Title for the new test" },
+            { name: "file", type: "string", required: true, description: "Plan JSON file, or - for stdin" },
+            {
+                name: "no-verify",
+                type: "boolean",
+                description: "Skip the compile-time browser/AI verification — trust the authored plan as-is",
+            },
+        ],
+        examples: ['beryl tests create --title "Checkout happy path" --file plan.json'],
+        async run(ctx, input) {
+            const title = flagStr(input, "title");
+            if (!title)
+                throw new UsageError("--title is required");
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.post(`${projectPath(workspaceId, projectId)}/tests`, {
+                    title,
+                    plan: readJsonFlag(input, "file"),
+                    verify: !flagBool(input, "no-verify"),
+                }),
+            };
+        },
+    },
+    {
+        name: "tests set-plan",
+        summary: "Replace a test's step plan from a JSON file (creates a new version)",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        flags: [
+            { name: "file", type: "string", required: true, description: "Plan JSON file, or - for stdin" },
+        ],
+        examples: ["beryl tests plan 4f… > plan.json  # edit, then:", "beryl tests set-plan 4f… --file plan.json"],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.patch(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/plan`, { json_plan: readJsonFlag(input, "file") }),
+            };
+        },
+    },
+    {
+        name: "tests recompile",
+        summary: "Validate + verify an edited plan against the live site before persisting",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        flags: [
+            { name: "file", type: "string", required: true, description: "Plan JSON file, or - for stdin" },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.post(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/plan/recompile`, { json_plan: readJsonFlag(input, "file") }),
+            };
+        },
+    },
+    {
+        name: "tests versions",
+        summary: "List a test's version history",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        flags: [
+            { name: "limit", type: "number", description: "Page size" },
+            { name: "cursor", type: "number", description: "Continue from a previous next_cursor" },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.get(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/versions`, { limit: flagNum(input, "limit"), cursor: flagNum(input, "cursor") }),
+            };
+        },
+    },
+    {
+        name: "tests version",
+        summary: "Show one specific version of a test (including its plan)",
+        scope: "project",
+        args: [
+            { name: "test-id", description: "Test id", required: true },
+            { name: "version-no", description: "Version number", required: true },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.get(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/versions/${arg(input, "version-no")}`),
+            };
+        },
+    },
+    {
+        name: "tests diff",
+        summary: "Diff two versions of a test's plan",
+        scope: "project",
+        args: [
+            { name: "test-id", description: "Test id", required: true },
+            { name: "from", description: "From version number", required: true },
+            { name: "to", description: "To version number", required: true },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.get(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/versions/${arg(input, "from")}/diff/${arg(input, "to")}`),
+            };
+        },
+    },
+    {
+        name: "tests restore",
+        summary: "Restore a test to an earlier version",
+        scope: "project",
+        args: [
+            { name: "test-id", description: "Test id", required: true },
+            { name: "version-no", description: "Version number to restore", required: true },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.post(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/restore`, { version_no: Number(arg(input, "version-no")) }),
+            };
+        },
+    },
+    {
+        name: "tests reset",
+        summary: "Discard user edits and return the test to its latest system-authored version",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.post(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/system-reset`),
+            };
+        },
+    },
+    {
+        name: "tests heal",
+        summary: "Turn self-healing on or off for a test",
+        scope: "project",
+        args: [
+            { name: "test-id", description: "Test id", required: true },
+            { name: "state", description: "on or off", required: true },
+        ],
+        async run(ctx, input) {
+            const state = arg(input, "state").toLowerCase();
+            if (state !== "on" && state !== "off")
+                throw new UsageError("<state> must be on or off");
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.patch(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/heal-eligibility`, { self_heal_enabled: state === "on" }),
+            };
+        },
+    },
+    {
+        name: "tests history",
+        summary: "Pass/fail history, streak, and stability for a test",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        flags: [
+            { name: "limit", type: "number", description: "How many runs of history" },
+            { name: "env", type: "string", description: "Filter by environment id" },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.get(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/history`, { limit: flagNum(input, "limit"), environment_id: flagStr(input, "env") }),
+            };
+        },
+    },
+    {
+        name: "tests script",
+        summary: "Print the rendered Playwright spec for a test",
+        scope: "project",
+        args: [{ name: "test-id", description: "Test id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const data = (await ctx.client.get(`${testPath(workspaceId, projectId, arg(input, "test-id"))}/script`));
+            const script = typeof data === "string" ? data : (data.script ?? data.content ?? data);
+            return { data, human: typeof script === "string" ? script : JSON.stringify(data, null, 2) };
+        },
+    },
+    {
+        name: "tests export",
+        summary: "Export tests as Playwright .spec.ts files in a ZIP",
+        scope: "project",
+        args: [{ name: "test-ids", description: "One or more test ids", required: true, variadic: true }],
+        flags: [{ name: "out", type: "string", description: "Output file (default beryl-tests.zip)" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const response = (await ctx.client.request("POST", `${projectPath(workspaceId, projectId)}/tests/export`, { body: { test_case_ids: argList(input, "test-ids") }, raw: true }));
+            const out = flagStr(input, "out") ?? "beryl-tests.zip";
+            fs.writeFileSync(out, Buffer.from(await response.arrayBuffer()));
+            return { data: { written: out }, human: `Wrote ${out}` };
+        },
+    },
+];

package/dist/commands/util.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import { UsageError } from "../errors.js";
+export const projectPath = (ws, p) => `/workspaces/${ws}/projects/${p}`;
+export function arg(input, name) {
+    const value = input.args[name];
+    if (typeof value !== "string" || !value)
+        throw new UsageError(`Missing <${name}>`);
+    return value;
+}
+export function argList(input, name) {
+    const value = input.args[name];
+    if (!Array.isArray(value) || value.length === 0)
+        throw new UsageError(`Missing <${name}>`);
+    return value;
+}
+export function flagStr(input, name) {
+    const value = input.flags[name];
+    return value === undefined ? undefined : String(value);
+}
+export function flagBool(input, name) {
+    return input.flags[name] === true;
+}
+export function flagNum(input, name) {
+    const value = input.flags[name];
+    if (value === undefined)
+        return undefined;
+    const n = Number(value);
+    if (Number.isNaN(n))
+        throw new UsageError(`--${name} must be a number`);
+    return n;
+}
+export function readJsonFlag(input, name) {
+    const file = flagStr(input, name);
+    if (!file)
+        throw new UsageError(`--${name} <file> is required`);
+    const text = file === "-" ? fs.readFileSync(0, "utf8") : fs.readFileSync(file, "utf8");
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        throw new UsageError(`--${name}: ${file} is not valid JSON (${err.message})`);
+    }
+}

package/dist/commands/watch.js

@@ -0,0 +1,113 @@
+import { CliError } from "../errors.js";
+import { dim, green, red, statusColor, yellow } from "../output.js";
+import { sseStream } from "../sse.js";
+import { projectPath } from "./util.js";
+function withTimeout(minutes) {
+    if (!minutes)
+        return undefined;
+    return AbortSignal.timeout(minutes * 60_000);
+}
+export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
+    const signal = withTimeout(timeoutMinutes);
+    let finalStatus = "unknown";
+    let counters = {};
+    const seen = new Set();
+    for await (const ev of sseStream(ctx.client, `${projectPath(ws, project)}/runs/${runId}/stream`, signal)) {
+        if (ctx.json) {
+            ctx.out(JSON.stringify(ev));
+        }
+        if (ev.counters)
+            counters = ev.counters;
+        const kind = ev.event;
+        if (!ctx.json) {
+            if (kind === "run_started") {
+                ctx.err(dim(`run ${runId} started`));
+            }
+            else if (kind === "test_completed") {
+                const key = `${ev.test_result_id}:${ev.status}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    const ok = ev.status === "passed";
+                    const mark = ok ? green("✓") : red("✗");
+                    const duration = ev.duration_ms ? dim(` ${Math.round(Number(ev.duration_ms) / 1000)}s`) : "";
+                    const error = ev.error_message ? red(` — ${String(ev.error_message).slice(0, 120)}`) : "";
+                    ctx.err(`${mark} ${statusColor(String(ev.status))} ${dim(String(ev.test_result_id))}${duration}${error}`);
+                }
+            }
+        }
+        if (kind === "run_completed" || kind === "run_cancelled") {
+            finalStatus = ev.status ?? kind;
+            break;
+        }
+        if (kind === "error") {
+            finalStatus = "error";
+            break;
+        }
+    }
+    if (signal?.aborted)
+        throw new CliError(`Timed out after ${timeoutMinutes} minutes`, 1);
+    const failed = (counters.failed ?? 0) + (counters.errored ?? 0);
+    const passed = counters.passed ?? 0;
+    const summary = failed > 0
+        ? red(`${failed} failed`) + `, ${passed} passed`
+        : green(`${passed} passed`) + (counters.cancelled ? yellow(`, ${counters.cancelled} cancelled`) : "");
+    if (!ctx.json)
+        ctx.err(`\n${statusColor(finalStatus)}: ${summary}`);
+    const exitCode = finalStatus === "completed" && failed === 0 ? 0 : 1;
+    return { data: { run_id: runId, status: finalStatus, ...counters }, exitCode };
+}
+export async function watchExploration(ctx, ws, project, explorationId, timeoutMinutes) {
+    const signal = withTimeout(timeoutMinutes);
+    let finalStatus = "unknown";
+    let handedOffRunId = null;
+    let error = null;
+    const seen = new Set();
+    for await (const ev of sseStream(ctx.client, `${projectPath(ws, project)}/explorations/${explorationId}/stream`, signal)) {
+        if (ctx.json)
+            ctx.out(JSON.stringify(ev));
+        const kind = ev.event;
+        if (kind === "exploration_step" && !ctx.json) {
+            const seq = Number(ev.seq);
+            if (!seen.has(seq)) {
+                seen.add(seq);
+                const mark = ev.ok === false ? red("✗") : green("·");
+                const tool = ev.tool ? `${ev.tool}` : "";
+                const text = (ev.summary ?? ev.rationale ?? "");
+                ctx.err(`${mark} ${dim(`#${seq}`)} ${tool} ${text.replace(/\s+/g, " ").slice(0, 140)}`);
+            }
+        }
+        else if (kind === "exploration_completed") {
+            finalStatus = ev.status ?? "completed";
+            handedOffRunId = ev.test_run_id ?? null;
+            if (ev.error)
+                error = String(ev.error);
+            break;
+        }
+        else if (kind === "error") {
+            finalStatus = "failed";
+            error = ev.error ?? "exploration failed";
+            break;
+        }
+    }
+    if (signal?.aborted)
+        throw new CliError(`Timed out after ${timeoutMinutes} minutes`, 1);
+    if (!ctx.json) {
+        ctx.err(`\nexploration ${statusColor(finalStatus)}${error ? red(` — ${error}`) : ""}`);
+        if (handedOffRunId)
+            ctx.err(dim(`handed off to run ${handedOffRunId}`));
+    }
+    return {
+        data: { exploration_id: explorationId, status: finalStatus, test_run_id: handedOffRunId, error },
+        exitCode: finalStatus === "failed" ? 1 : 0,
+    };
+}
+export async function pollCurrentExploration(ctx, ws, project, timeoutSeconds = 180) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
+        const detail = (await ctx.client.get(projectPath(ws, project)));
+        if (detail.current_exploration_id)
+            return detail.current_exploration_id;
+        await new Promise((r) => setTimeout(r, 3000));
+    }
+    throw new CliError("No exploration started within the wait window");
+}

package/dist/commands/workspaces.js

@@ -0,0 +1,220 @@
+import { saveGlobalConfig } from "../config.js";
+import { green } from "../output.js";
+import { arg, flagBool, flagStr } from "./util.js";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const workspaceCommands = [
+    {
+        name: "workspaces list",
+        summary: "List workspaces you belong to",
+        async run(ctx) {
+            const rows = (await ctx.client.get("/workspaces/"));
+            return { data: rows };
+        },
+    },
+    {
+        name: "workspaces get",
+        summary: "Show one workspace",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return { data: await ctx.client.get(`/workspaces/${ws}`) };
+        },
+    },
+    {
+        name: "workspaces create",
+        summary: "Create a workspace",
+        args: [{ name: "name", description: "Workspace name", required: true }],
+        flags: [
+            { name: "domain", type: "string", description: "Company domain to associate" },
+            {
+                name: "visible-to-org",
+                type: "boolean",
+                description: "Let anyone on your email domain discover and join it",
+            },
+        ],
+        async run(ctx, input) {
+            const created = await ctx.client.post("/workspaces/", {
+                name: arg(input, "name"),
+                domain: flagStr(input, "domain") ?? null,
+                visible_to_org: flagBool(input, "visible-to-org"),
+            });
+            return { data: created };
+        },
+    },
+    {
+        name: "workspaces update",
+        summary: "Rename a workspace or change its visibility",
+        scope: "workspace",
+        flags: [
+            { name: "name", type: "string", description: "New name" },
+            { name: "visible-to-org", type: "boolean", description: "Toggle org discoverability" },
+            { name: "autofix", type: "boolean", description: "Toggle autofix" },
+        ],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            const body = {};
+            if (flagStr(input, "name") !== undefined)
+                body.name = flagStr(input, "name");
+            if (input.flags["visible-to-org"] !== undefined)
+                body.visible_to_org = input.flags["visible-to-org"];
+            if (input.flags.autofix !== undefined)
+                body.autofix_enabled = input.flags.autofix;
+            return { data: await ctx.client.patch(`/workspaces/${ws}`, body) };
+        },
+    },
+    {
+        name: "workspaces delete",
+        summary: "Delete a workspace and everything in it",
+        scope: "workspace",
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            await ctx.confirm(`Delete workspace ${ws} and ALL its projects?`, flagBool(input, "force"));
+            await ctx.client.del(`/workspaces/${ws}`);
+            return { human: "Deleted." };
+        },
+    },
+    {
+        name: "workspaces use",
+        summary: "Set the default workspace for future commands",
+        args: [{ name: "workspace", description: "Workspace id or name", required: true }],
+        async run(ctx, input) {
+            const value = arg(input, "workspace");
+            const id = UUID_RE.test(value)
+                ? value
+                : await ctx.requireWorkspace({ args: {}, flags: { workspace: value } });
+            const detail = (await ctx.client.get(`/workspaces/${id}`));
+            saveGlobalConfig({ workspace: id, project: undefined });
+            return {
+                data: { workspace: id },
+                human: `${green("Default workspace set")}: ${detail.name} (${id})`,
+            };
+        },
+    },
+    {
+        name: "workspaces history",
+        summary: "Show the workspace's action history (who did what, when)",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return { data: await ctx.client.get(`/workspaces/${ws}/action-history`) };
+        },
+    },
+    {
+        name: "workspaces leave",
+        summary: "Leave a workspace you are a member of",
+        scope: "workspace",
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            await ctx.confirm(`Leave workspace ${ws}?`, flagBool(input, "force"));
+            await ctx.client.post(`/workspaces/${ws}/leave`);
+            return { human: "Left the workspace." };
+        },
+    },
+    {
+        name: "members list",
+        summary: "List workspace members",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return { data: await ctx.client.get(`/workspaces/${ws}/members`) };
+        },
+    },
+    {
+        name: "members set-role",
+        summary: "Change a member's role",
+        scope: "workspace",
+        args: [
+            { name: "user-id", description: "Member's user id", required: true },
+            { name: "role", description: "OWNER or USER", required: true },
+        ],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            const role = arg(input, "role").toUpperCase();
+            return {
+                data: await ctx.client.patch(`/workspaces/${ws}/members/${arg(input, "user-id")}`, { role }),
+            };
+        },
+    },
+    {
+        name: "members remove",
+        summary: "Remove a member from the workspace",
+        scope: "workspace",
+        args: [{ name: "user-id", description: "Member's user id", required: true }],
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            const userId = arg(input, "user-id");
+            await ctx.confirm(`Remove ${userId} from workspace ${ws}?`, flagBool(input, "force"));
+            await ctx.client.del(`/workspaces/${ws}/members/${userId}`);
+            return { human: "Removed." };
+        },
+    },
+    {
+        name: "invites send",
+        summary: "Invite someone to the workspace by email",
+        scope: "workspace",
+        args: [{ name: "email", description: "Invitee email", required: true }],
+        flags: [
+            { name: "role", type: "string", enum: ["OWNER", "USER"], description: "Role (default USER)" },
+        ],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return {
+                data: await ctx.client.post(`/workspaces/${ws}/invitations`, {
+                    email: arg(input, "email"),
+                    role: (flagStr(input, "role") ?? "USER").toUpperCase(),
+                }),
+            };
+        },
+    },
+    {
+        name: "invites list",
+        summary: "List the workspace's outstanding invitations",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return { data: await ctx.client.get(`/workspaces/${ws}/invitations`) };
+        },
+    },
+    {
+        name: "invites revoke",
+        summary: "Revoke a pending invitation",
+        scope: "workspace",
+        args: [{ name: "invitation-id", description: "Invitation id", required: true }],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            await ctx.client.del(`/workspaces/${ws}/invitations/${arg(input, "invitation-id")}`);
+            return { human: "Revoked." };
+        },
+    },
+    {
+        name: "invites mine",
+        summary: "List invitations sent to you",
+        async run(ctx) {
+            return { data: await ctx.client.get("/invitations") };
+        },
+    },
+    {
+        name: "invites accept",
+        summary: "Accept an invitation (by id, or by the token from the invite email)",
+        args: [{ name: "invitation", description: "Invitation id or emailed token", required: true }],
+        async run(ctx, input) {
+            const value = arg(input, "invitation");
+            const path = UUID_RE.test(value)
+                ? `/invitations/${value}/accept`
+                : `/invitations/token/${value}/accept`;
+            return { data: await ctx.client.post(path) };
+        },
+    },
+    {
+        name: "invites decline",
+        summary: "Decline an invitation",
+        args: [{ name: "invitation-id", description: "Invitation id", required: true }],
+        async run(ctx, input) {
+            await ctx.client.post(`/invitations/${arg(input, "invitation-id")}/decline`);
+            return { human: "Declined." };
+        },
+    },
+];

package/dist/config.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const DEFAULT_API_URL = "https://api.beryl.so";
+export const LOCAL_CONFIG_FILENAME = ".beryl.json";
+export function globalConfigPath(env = process.env) {
+    const base = env.BERYL_CONFIG_DIR ??
+        (env.XDG_CONFIG_HOME ? path.join(env.XDG_CONFIG_HOME, "beryl") : undefined) ??
+        path.join(os.homedir(), ".config", "beryl");
+    return path.join(base, "config.json");
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function findLocalConfig(cwd) {
+    let dir = path.resolve(cwd);
+    for (;;) {
+        const candidate = path.join(dir, LOCAL_CONFIG_FILENAME);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+export function loadConfig(env = process.env, cwd = process.cwd()) {
+    const globalPath = globalConfigPath(env);
+    const global = readJson(globalPath) ?? {};
+    const localPath = findLocalConfig(cwd);
+    const local = localPath ? (readJson(localPath) ?? {}) : {};
+    return {
+        apiUrl: env.BERYL_API_URL ?? local.api_url ?? global.api_url ?? DEFAULT_API_URL,
+        token: env.BERYL_API_KEY ?? env.BERYL_TOKEN ?? local.token ?? global.token,
+        workspace: env.BERYL_WORKSPACE ?? local.workspace ?? global.workspace,
+        project: env.BERYL_PROJECT ?? local.project ?? global.project,
+        globalConfigPath: globalPath,
+        localConfigPath: localPath,
+    };
+}
+export function saveGlobalConfig(patch, env = process.env) {
+    const file = globalConfigPath(env);
+    const current = readJson(file) ?? {};
+    const next = { ...current, ...patch };
+    for (const key of Object.keys(next)) {
+        if (next[key] === undefined)
+            delete next[key];
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+    try {
+        fs.chmodSync(file, 0o600);
+    }
+    catch {
+        // best effort on non-POSIX filesystems
+    }
+    return file;
+}