recess-cli 1.9.2 → 2.1.0

package/dist/commands/shared.js

@@ -0,0 +1,100 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { flagNumber, flagString } from "../args.js";
+import { CliError } from "../errors.js";
+export function positional(parsed, index, label) {
+    const value = parsed.positionals[index];
+    if (!value) {
+        throw new CliError("invalid_arguments", `Missing ${label}.`);
+    }
+    return value;
+}
+export function assertChoice(value, choices, label) {
+    if (!choices.includes(value)) {
+        throw new CliError("invalid_arguments", `${label} must be one of: ${choices.join(", ")}.`);
+    }
+    return value;
+}
+export function flagIdList(parsed, name) {
+    const raw = flagString(parsed, name);
+    if (raw === undefined)
+        return [];
+    const ids = raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (ids.length === 0) {
+        throw new CliError("invalid_arguments", `--${name} requires a value.`);
+    }
+    return ids;
+}
+export function flagBooleanValue(parsed, name) {
+    const raw = flagString(parsed, name);
+    if (raw === undefined)
+        return undefined;
+    if (raw === "true")
+        return true;
+    if (raw === "false")
+        return false;
+    throw new CliError("invalid_arguments", `--${name} must be true or false.`);
+}
+export function flagInteger(parsed, name, options = {}) {
+    const value = flagNumber(parsed, name);
+    if (value === undefined) {
+        if (options.required) {
+            throw new CliError("invalid_arguments", `Missing required --${name}.`);
+        }
+        return undefined;
+    }
+    if (!Number.isInteger(value) ||
+        (options.min !== undefined && value < options.min) ||
+        (options.max !== undefined && value > options.max)) {
+        const bounds = options.min !== undefined && options.max !== undefined
+            ? ` from ${options.min} through ${options.max}`
+            : options.min !== undefined
+                ? ` of at least ${options.min}`
+                : options.max !== undefined
+                    ? ` no greater than ${options.max}`
+                    : "";
+        throw new CliError("invalid_arguments", `--${name} must be an integer${bounds}.`);
+    }
+    return value;
+}
+export function flagIsoInstant(parsed, name, options = {}) {
+    const raw = flagString(parsed, name, options);
+    if (raw === undefined)
+        return undefined;
+    if (!/^\d{4}-\d{2}-\d{2}T/.test(raw) || Number.isNaN(Date.parse(raw))) {
+        throw new CliError("invalid_arguments", `--${name} must be a full ISO-8601 datetime with a timezone.`);
+    }
+    return raw;
+}
+export async function readJsonValue(filePath, label) {
+    const absolutePath = path.resolve(filePath);
+    let raw;
+    try {
+        raw = await fs.readFile(absolutePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new CliError("invalid_arguments", `${label} does not exist: ${absolutePath}`);
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new CliError("invalid_arguments", `${label} is not valid JSON (${absolutePath}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { absolutePath, raw, parsed };
+}
+export async function readJsonFile(filePath, label) {
+    const { absolutePath, parsed } = await readJsonValue(filePath, label);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new CliError("invalid_arguments", `${label} must be a JSON object (${absolutePath}).`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=shared.js.map

package/dist/config.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { CliError } from "./errors.js";
 export const DEFAULT_OAUTH_CLIENT_ID = "c7e34138-18f9-45b1-a2fb-26a4e3a6d739";
 export function defaultConfigPath() {
     return (process.env.RECESS_CLI_CONFIG ??
@@ -16,32 +17,111 @@ export async function readStoredConfig(configPath = defaultConfigPath()) {
         throw error;
     }
 }
-export async function resolveConfig() {
+export async function resolveConfig(profileName) {
     const configPath = defaultConfigPath();
     const stored = await readStoredConfig(configPath);
+    const selectedProfileName = profileName ?? process.env.RECESS_CLI_PROFILE ?? stored.activeProfile;
+    const profile = selectedProfileName
+        ? stored.profiles?.[selectedProfileName]
+        : undefined;
+    if (selectedProfileName && !profile) {
+        throw new CliError("unknown_profile", `Unknown Recess CLI profile ${selectedProfileName}. Run \`recess --json profile list\`.`);
+    }
     const envCookie = process.env.RECESS_CLI_COOKIE;
-    const sessionCookie = envCookie ?? stored.sessionCookie;
+    const sessionCookie = envCookie ??
+        (selectedProfileName ? profile?.sessionCookie : stored.sessionCookie);
     return {
         configPath,
         apiOrigin: process.env.RECESS_CLI_API_ORIGIN ??
+            profile?.apiOrigin ??
             stored.apiOrigin ??
             "https://api.recess.gg",
         webOrigin: process.env.RECESS_CLI_WEB_ORIGIN ??
+            profile?.webOrigin ??
             stored.webOrigin ??
             "https://recess.gg",
         oauthClientId: process.env.RECESS_CLI_OAUTH_CLIENT_ID ??
+            profile?.oauthClientId ??
             stored.oauthClientId ??
             DEFAULT_OAUTH_CLIENT_ID,
         sessionCookie,
-        sessionExpiresAt: stored.sessionExpiresAt,
-        user: stored.user,
+        sessionExpiresAt: selectedProfileName
+            ? profile?.sessionExpiresAt
+            : stored.sessionExpiresAt,
+        user: selectedProfileName ? profile?.user : stored.user,
         authSource: envCookie ? "env" : sessionCookie ? "config" : "missing",
-        pendingDeviceCode: stored.pendingDeviceCode,
-        pendingUserCode: stored.pendingUserCode,
-        pendingApprovalUrl: stored.pendingApprovalUrl,
-        pendingExpiresAt: stored.pendingExpiresAt,
+        pendingDeviceCode: selectedProfileName
+            ? profile?.pendingDeviceCode
+            : stored.pendingDeviceCode,
+        pendingUserCode: selectedProfileName
+            ? profile?.pendingUserCode
+            : stored.pendingUserCode,
+        pendingApprovalUrl: selectedProfileName
+            ? profile?.pendingApprovalUrl
+            : stored.pendingApprovalUrl,
+        pendingExpiresAt: selectedProfileName
+            ? profile?.pendingExpiresAt
+            : stored.pendingExpiresAt,
+        profileName: selectedProfileName,
+    };
+}
+export function assertProfileName(name) {
+    const normalized = name.trim();
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(normalized)) {
+        throw new CliError("invalid_arguments", "Profile names must be 1-64 letters, numbers, underscores, or hyphens.");
+    }
+    return normalized;
+}
+export async function listProfiles() {
+    const stored = await readStoredConfig();
+    return {
+        activeProfile: stored.activeProfile ?? null,
+        profiles: Object.entries(stored.profiles ?? {})
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, config]) => ({
+            name,
+            config: {
+                apiOrigin: config.apiOrigin,
+                webOrigin: config.webOrigin,
+                oauthClientId: config.oauthClientId,
+            },
+        })),
     };
 }
+export async function saveProfile(name, profile) {
+    const normalized = assertProfileName(name);
+    const stored = await readStoredConfig();
+    await writeStoredConfig({
+        ...stored,
+        profiles: {
+            ...stored.profiles,
+            [normalized]: {
+                ...stored.profiles?.[normalized],
+                ...profile,
+            },
+        },
+    });
+}
+export async function useProfile(name) {
+    const normalized = assertProfileName(name);
+    const stored = await readStoredConfig();
+    if (!stored.profiles?.[normalized]) {
+        throw new CliError("unknown_profile", `Unknown Recess CLI profile ${normalized}. Run \`recess --json profile list\`.`);
+    }
+    await writeStoredConfig({ ...stored, activeProfile: normalized });
+}
+export async function deleteProfile(name) {
+    const normalized = assertProfileName(name);
+    const stored = await readStoredConfig();
+    if (!stored.profiles?.[normalized]) {
+        throw new CliError("unknown_profile", `Unknown Recess CLI profile ${normalized}.`);
+    }
+    const profiles = { ...stored.profiles };
+    delete profiles[normalized];
+    if (stored.activeProfile === normalized)
+        delete stored.activeProfile;
+    await writeStoredConfig({ ...stored, profiles });
+}
 export async function writeStoredConfig(config, configPath = defaultConfigPath()) {
     const directory = path.dirname(configPath);
     await fs.mkdir(directory, { recursive: true, mode: 0o700 });
@@ -52,28 +132,45 @@ export async function writeStoredConfig(config, configPath = defaultConfigPath()
     await fs.rename(temporary, configPath);
     await fs.chmod(configPath, 0o600);
 }
-export async function updateStoredConfig(update) {
+export async function updateStoredConfig(update, profileName) {
     const configPath = defaultConfigPath();
     const current = await readStoredConfig(configPath);
-    const next = { ...current, ...update };
+    const next = profileName
+        ? {
+            ...current,
+            profiles: {
+                ...current.profiles,
+                [assertProfileName(profileName)]: {
+                    ...current.profiles?.[profileName],
+                    ...update,
+                },
+            },
+        }
+        : { ...current, ...update };
     await writeStoredConfig(next, configPath);
     return next;
 }
-export async function clearStoredSession() {
+export async function clearStoredSession(profileName) {
     const configPath = defaultConfigPath();
     const current = await readStoredConfig(configPath);
-    delete current.sessionCookie;
-    delete current.sessionExpiresAt;
-    delete current.user;
+    const target = profileName ? current.profiles?.[profileName] : current;
+    if (!target)
+        return;
+    delete target.sessionCookie;
+    delete target.sessionExpiresAt;
+    delete target.user;
     await writeStoredConfig(current, configPath);
 }
-export async function clearPendingDeviceAuth() {
+export async function clearPendingDeviceAuth(profileName) {
     const configPath = defaultConfigPath();
     const current = await readStoredConfig(configPath);
-    delete current.pendingDeviceCode;
-    delete current.pendingUserCode;
-    delete current.pendingApprovalUrl;
-    delete current.pendingExpiresAt;
+    const target = profileName ? current.profiles?.[profileName] : current;
+    if (!target)
+        return;
+    delete target.pendingDeviceCode;
+    delete target.pendingUserCode;
+    delete target.pendingApprovalUrl;
+    delete target.pendingExpiresAt;
     await writeStoredConfig(current, configPath);
 }
 //# sourceMappingURL=config.js.map

package/dist/delivery.js

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CliError } from "./errors.js";
+export async function deliverJson(destination, envelope) {
+    if (!destination || destination === "stdout")
+        return { delivered: false };
+    if (!destination.startsWith("file:")) {
+        throw new CliError("invalid_delivery", "--deliver must be one of: stdout, file:<path>. Webhook delivery is deliberately unavailable for authenticated Recess data.");
+    }
+    const requestedPath = destination.slice("file:".length);
+    if (!requestedPath) {
+        throw new CliError("invalid_delivery", "file: delivery requires a path.");
+    }
+    const absolutePath = path.resolve(requestedPath);
+    const bytes = Buffer.from(`${JSON.stringify(envelope)}\n`, "utf8");
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true, mode: 0o700 });
+    const temporary = `${absolutePath}.${process.pid}.tmp`;
+    await fs.writeFile(temporary, bytes, { mode: 0o600 });
+    await fs.rename(temporary, absolutePath);
+    return {
+        delivered: true,
+        deliveredTo: `file:${absolutePath}`,
+        bytes: bytes.byteLength,
+    };
+}
+//# sourceMappingURL=delivery.js.map

package/dist/feedback.js

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CliError } from "./errors.js";
+function feedbackPath() {
+    return (process.env.RECESS_CLI_FEEDBACK_PATH ??
+        path.join(os.homedir(), ".recess-cli", "feedback.jsonl"));
+}
+async function readFeedback() {
+    try {
+        return (await fs.readFile(feedbackPath(), "utf8"))
+            .split("\n")
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function listFeedback(limit = 20) {
+    const entries = (await readFeedback()).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+    return {
+        entries: entries.slice(0, limit),
+        truncated: entries.length > limit,
+    };
+}
+export async function submitFeedback(entry) {
+    const existing = (await readFeedback()).find((item) => item.id === entry.id);
+    if (existing)
+        return existing;
+    const endpoint = process.env.RECESS_CLI_FEEDBACK_ENDPOINT;
+    let upstreamStatus;
+    if (endpoint) {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "idempotency-key": entry.id,
+            },
+            body: JSON.stringify(entry),
+            signal: AbortSignal.timeout(10_000),
+        });
+        upstreamStatus = response.status;
+        if (!response.ok) {
+            throw new CliError("feedback_delivery_failed", `Feedback endpoint returned HTTP ${response.status}. Retry the unchanged command with the same operation key.`);
+        }
+    }
+    const saved = { ...entry, ...(upstreamStatus ? { upstreamStatus } : {}) };
+    const file = feedbackPath();
+    await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await fs.appendFile(file, `${JSON.stringify(saved)}\n`, { mode: 0o600 });
+    await fs.chmod(file, 0o600);
+    return saved;
+}
+//# sourceMappingURL=feedback.js.map