@rooaak/cli 0.1.0-beta.1

package/dist/src/lib/generated-command.js

@@ -0,0 +1,357 @@
+import { resolveBaseUrl } from "./base-url.js";
+import { ExitCode } from "./exit-codes.js";
+import { normalizeLocalUsageError, exitCodeForError, toJsonErrorEnvelope, toJsonOkEnvelope } from "./normalize-error.js";
+import { parseOptions } from "./options.js";
+import { createProfileStore } from "./profile-store.js";
+import { createRenderer } from "./renderer.js";
+import { createTransport } from "./transport.js";
+function jsonTypeFromFlag(flag) {
+    if (flag.valueType === "boolean")
+        return "boolean";
+    if (flag.valueType === "number")
+        return "number";
+    if (flag.valueType === "json")
+        return "json";
+    return "string";
+}
+function coerceFlagValue(flag, raw) {
+    if (flag.valueType === "boolean") {
+        if (typeof raw === "boolean")
+            return raw;
+        const v = raw.toLowerCase();
+        if (v === "true")
+            return true;
+        if (v === "false")
+            return false;
+        throw new Error(`Expected boolean for ${flag.name} (true|false)`);
+    }
+    if (flag.valueType === "number") {
+        if (typeof raw !== "string")
+            throw new Error(`Expected number for ${flag.name}`);
+        const n = Number(raw);
+        if (!Number.isFinite(n))
+            throw new Error(`Expected number for ${flag.name}`);
+        return n;
+    }
+    if (flag.valueType === "json") {
+        if (typeof raw !== "string")
+            throw new Error(`Expected JSON for ${flag.name}`);
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`Expected valid JSON for ${flag.name}`);
+        }
+    }
+    if (typeof raw !== "string")
+        throw new Error(`Expected string for ${flag.name}`);
+    return raw;
+}
+function getProfileOrUsageError(ctx) {
+    const r = createRenderer(ctx);
+    const store = createProfileStore({ configPath: ctx.profileConfigPath });
+    const cfgRes = store.readConfig();
+    if (cfgRes.kind === "missing") {
+        const err = {
+            code: "auth.not_logged_in",
+            message: "Not logged in. Run `rooaak auth login --api-key ...`.",
+            details: {},
+            meta: {},
+        };
+        if (ctx.flags.json)
+            r.json(toJsonErrorEnvelope(err));
+        else
+            r.error(err.message);
+        return { ok: false, exit: exitCodeForError(err) };
+    }
+    if (cfgRes.kind === "corrupt") {
+        const err = {
+            code: "config.corrupt",
+            message: cfgRes.message,
+            details: { path: cfgRes.path },
+            meta: {},
+        };
+        if (ctx.flags.json)
+            r.json(toJsonErrorEnvelope(err));
+        else
+            r.error(err.message);
+        return { ok: false, exit: exitCodeForError(err) };
+    }
+    const config = cfgRes.config;
+    const profileName = config.currentProfile;
+    const profile = config.profiles[profileName];
+    if (!profile?.apiKey) {
+        const err = {
+            code: "auth.not_logged_in",
+            message: "Not logged in. Run `rooaak auth login --api-key ...`.",
+            details: {},
+            meta: {},
+        };
+        if (ctx.flags.json)
+            r.json(toJsonErrorEnvelope(err));
+        else
+            r.error(err.message);
+        return { ok: false, exit: exitCodeForError(err) };
+    }
+    const baseUrl = resolveBaseUrl({
+        cliFlag: ctx.flags.baseUrl,
+        env: ctx.env.ROOAAK_BASE_URL,
+        profile: profile.baseUrl,
+    });
+    return { ok: true, apiKey: profile.apiKey, baseUrl, profileName };
+}
+export function renderGeneratedCommandHelp(ctx, spec) {
+    const r = createRenderer(ctx);
+    const usage = `rooaak ${spec.group} ${spec.action} [flags]`;
+    const flags = [...spec.flags].sort((a, b) => {
+        // Required first, then by source, then by name.
+        const req = Number(b.required) - Number(a.required);
+        if (req !== 0)
+            return req;
+        const order = { path: 0, query: 1, header: 2, body: 3 };
+        const src = order[a.source] - order[b.source];
+        if (src !== 0)
+            return src;
+        return a.name.localeCompare(b.name);
+    });
+    if (ctx.flags.json) {
+        r.json(toJsonOkEnvelope({
+            type: "help",
+            usage,
+            operationId: spec.operationId,
+            summary: spec.summary,
+            description: spec.description,
+            method: spec.method,
+            path: spec.pathTemplate,
+            flags: flags.map((f) => ({
+                name: f.name,
+                required: f.required,
+                type: jsonTypeFromFlag(f),
+                source: f.source,
+                description: f.description,
+            })),
+        }));
+        return ExitCode.Success;
+    }
+    const lines = [];
+    lines.push("Usage:");
+    lines.push(`  ${usage}`);
+    lines.push("");
+    lines.push("Endpoint:");
+    lines.push(`  ${spec.method} ${spec.pathTemplate}`);
+    if (spec.summary)
+        lines.push(`  ${spec.summary}`);
+    lines.push("");
+    lines.push("Flags:");
+    if (flags.length === 0) {
+        lines.push("  (none)");
+    }
+    else {
+        for (const f of flags) {
+            const req = f.required ? "required" : "optional";
+            const type = jsonTypeFromFlag(f);
+            const desc = f.description ? ` - ${f.description}` : "";
+            lines.push(`  ${f.name} <${type}> (${req}, ${f.source})${desc}`);
+        }
+    }
+    lines.push("");
+    ctx.stdout.write(lines.join("\n") + "\n");
+    return ExitCode.Success;
+}
+export async function runGeneratedCommand(ctx, spec, argv) {
+    const r = createRenderer(ctx);
+    const optionSpecs = spec.flags.map((f) => ({ name: f.name, takesValue: f.takesValue }));
+    const parsed = parseOptions(argv, optionSpecs);
+    if (parsed.unknownOption) {
+        const err = normalizeLocalUsageError(`Unknown option: ${parsed.unknownOption}`);
+        if (ctx.flags.json)
+            r.json(toJsonErrorEnvelope(err));
+        else
+            r.error(err.message);
+        return ExitCode.Usage;
+    }
+    if (parsed.missingValueOption) {
+        const err = normalizeLocalUsageError(`Missing value for: ${parsed.missingValueOption}`);
+        if (ctx.flags.json)
+            r.json(toJsonErrorEnvelope(err));
+        else
+            r.error(err.message);
+        return ExitCode.Usage;
+    }
+    if (parsed.positionals.length > 0) {
+        const err = normalizeLocalUsageError("Unexpected extra arguments", { argc: parsed.positionals.length });
+        if (ctx.flags.json)
+            r.json(toJsonErrorEnvelope(err));
+        else
+            r.error(err.message);
+        return ExitCode.Usage;
+    }
+    // Parse `--body` early so we can treat it as an escape hatch for required body fields.
+    let bodyOverridePresent = false;
+    let bodyOverride = undefined;
+    const bodyExplicit = parsed.values["--body"];
+    if (typeof bodyExplicit === "string") {
+        bodyOverridePresent = true;
+        try {
+            bodyOverride = JSON.parse(bodyExplicit);
+        }
+        catch {
+            const err = normalizeLocalUsageError("Invalid JSON for --body");
+            if (ctx.flags.json)
+                r.json(toJsonErrorEnvelope(err));
+            else
+                r.error(err.message);
+            return ExitCode.Usage;
+        }
+    }
+    for (const f of spec.flags) {
+        if (!f.required)
+            continue;
+        if (bodyOverridePresent && f.source === "body" && f.name !== "--body")
+            continue;
+        const v = parsed.values[f.name];
+        if (v === undefined || v === false || v === "") {
+            const err = normalizeLocalUsageError(`Missing required flag: ${f.name}`);
+            if (ctx.flags.json)
+                r.json(toJsonErrorEnvelope(err));
+            else
+                r.error(err.message);
+            return ExitCode.Usage;
+        }
+    }
+    const auth = getProfileOrUsageError(ctx);
+    if (!auth.ok)
+        return auth.exit;
+    const transport = createTransport({
+        baseUrl: auth.baseUrl,
+        apiKey: auth.apiKey,
+        fetchFn: ctx.fetchFn,
+    });
+    let path = spec.pathTemplate;
+    const query = new URLSearchParams();
+    const headers = {};
+    let body = undefined;
+    const bodyObj = {};
+    let sawBodyField = false;
+    // Always bind path/query/header flags regardless of whether `--body` is present.
+    // Only the body-building portion is conditional: `--body` overrides individual body flags.
+    for (const f of spec.flags) {
+        const raw = parsed.values[f.name];
+        if (raw === undefined)
+            continue;
+        if (f.source === "path") {
+            if (typeof raw !== "string") {
+                const err = normalizeLocalUsageError(`Invalid value for ${f.name}`);
+                if (ctx.flags.json)
+                    r.json(toJsonErrorEnvelope(err));
+                else
+                    r.error(err.message);
+                return ExitCode.Usage;
+            }
+            const token = `{${f.wireName}}`;
+            if (!path.includes(token)) {
+                const err = normalizeLocalUsageError(`Unable to bind path param for ${f.name}`);
+                if (ctx.flags.json)
+                    r.json(toJsonErrorEnvelope(err));
+                else
+                    r.error(err.message);
+                return ExitCode.Usage;
+            }
+            path = path.replaceAll(token, encodeURIComponent(raw));
+            continue;
+        }
+        if (f.source === "query") {
+            if (typeof raw !== "string" && typeof raw !== "boolean") {
+                const err = normalizeLocalUsageError(`Invalid value for ${f.name}`);
+                if (ctx.flags.json)
+                    r.json(toJsonErrorEnvelope(err));
+                else
+                    r.error(err.message);
+                return ExitCode.Usage;
+            }
+            try {
+                const v = coerceFlagValue(f, raw);
+                query.set(f.wireName, typeof v === "string" ? v : JSON.stringify(v));
+            }
+            catch (e) {
+                const err = normalizeLocalUsageError(e instanceof Error ? e.message : `Invalid value for ${f.name}`);
+                if (ctx.flags.json)
+                    r.json(toJsonErrorEnvelope(err));
+                else
+                    r.error(err.message);
+                return ExitCode.Usage;
+            }
+            continue;
+        }
+        if (f.source === "header") {
+            if (typeof raw !== "string" && typeof raw !== "boolean") {
+                const err = normalizeLocalUsageError(`Invalid value for ${f.name}`);
+                if (ctx.flags.json)
+                    r.json(toJsonErrorEnvelope(err));
+                else
+                    r.error(err.message);
+                return ExitCode.Usage;
+            }
+            try {
+                const v = coerceFlagValue(f, raw);
+                headers[f.wireName] = typeof v === "string" ? v : JSON.stringify(v);
+            }
+            catch (e) {
+                const err = normalizeLocalUsageError(e instanceof Error ? e.message : `Invalid value for ${f.name}`);
+                if (ctx.flags.json)
+                    r.json(toJsonErrorEnvelope(err));
+                else
+                    r.error(err.message);
+                return ExitCode.Usage;
+            }
+            continue;
+        }
+        if (f.source === "body") {
+            if (f.name === "--body")
+                continue;
+            if (bodyOverridePresent)
+                continue;
+            sawBodyField = true;
+            try {
+                bodyObj[f.wireName] = coerceFlagValue(f, raw);
+            }
+            catch (e) {
+                const err = normalizeLocalUsageError(e instanceof Error ? e.message : `Invalid value for ${f.name}`);
+                if (ctx.flags.json)
+                    r.json(toJsonErrorEnvelope(err));
+                else
+                    r.error(err.message);
+                return ExitCode.Usage;
+            }
+        }
+    }
+    if (bodyOverridePresent)
+        body = bodyOverride;
+    else if (sawBodyField)
+        body = bodyObj;
+    const qs = query.toString();
+    const fullPath = qs.length > 0 ? `${path}?${qs}` : path;
+    r.debug(`${spec.method} ${auth.baseUrl}${fullPath}`);
+    const httpRes = await transport.requestJson({
+        method: spec.method,
+        path: fullPath,
+        headers: Object.keys(headers).length > 0 ? headers : undefined,
+        body,
+    });
+    if (!httpRes.ok) {
+        const err = httpRes.error;
+        if (ctx.flags.json)
+            r.json(toJsonErrorEnvelope(err));
+        else
+            r.error(err.message);
+        return exitCodeForError(err);
+    }
+    const meta = { status: httpRes.status, requestId: httpRes.requestId };
+    if (ctx.flags.json) {
+        r.json(toJsonOkEnvelope(httpRes.data, meta));
+    }
+    else {
+        ctx.stdout.write(JSON.stringify(httpRes.data, null, 2) + "\n");
+    }
+    return ExitCode.Success;
+}

package/dist/src/lib/normalize-error.d.ts

@@ -0,0 +1,45 @@
+import { ExitCode } from "./exit-codes.js";
+export type JsonErrorEnvelope = {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        details: Record<string, unknown>;
+    };
+    meta: {
+        status?: number;
+        requestId?: string;
+    };
+};
+export type JsonOkEnvelope<T> = {
+    ok: true;
+    data: T;
+    meta: {
+        status?: number;
+        requestId?: string;
+    };
+};
+export type JsonEnvelope<T> = JsonOkEnvelope<T> | JsonErrorEnvelope;
+export type NormalizedError = {
+    code: string;
+    message: string;
+    details: Record<string, unknown>;
+    meta: {
+        status?: number;
+        requestId?: string;
+    };
+};
+export declare function getRequestIdFromHeaders(headers: Headers): string | undefined;
+export declare function normalizeHttpError(input: {
+    status: number;
+    requestId?: string;
+    body: unknown;
+}): NormalizedError;
+export declare function normalizeLocalUsageError(message: string, details?: Record<string, unknown>): NormalizedError;
+export declare function exitCodeForError(err: NormalizedError): ExitCode;
+export declare function toJsonErrorEnvelope(err: NormalizedError): JsonErrorEnvelope;
+export declare function toJsonOkEnvelope<T>(data: T, meta?: {
+    status?: number;
+    requestId?: string;
+}): JsonOkEnvelope<T>;
+//# sourceMappingURL=normalize-error.d.ts.map

package/dist/src/lib/normalize-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-error.d.ts","sourceRoot":"","sources":["../../../src/lib/normalize-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAElE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAClC,CAAC;IACF,IAAI,EAAE;QACJ,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,CAAC,CAAC;IACR,IAAI,EAAE;QACJ,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC;AAEpE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,EAAE;QACJ,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAMF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAO5E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,eAAe,CAqElB;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACpC,eAAe,CAOjB;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,eAAe,GAAG,QAAQ,CAY/D;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,GAAG,iBAAiB,CAa3E;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CAS9G"}

package/dist/src/lib/normalize-error.js

@@ -0,0 +1,128 @@
+import { exitCodeForHttpStatus, ExitCode } from "./exit-codes.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function getRequestIdFromHeaders(headers) {
+    return (headers.get("x-request-id") ||
+        headers.get("x-correlation-id") ||
+        headers.get("x-correlation-id".toLowerCase()) ||
+        undefined);
+}
+export function normalizeHttpError(input) {
+    const status = input.status;
+    const serverCode = isPlainObject(input.body) &&
+        isPlainObject(input.body.error) &&
+        typeof input.body.error.code === "string"
+        ? input.body.error.code
+        : undefined;
+    const serverMessage = isPlainObject(input.body) &&
+        isPlainObject(input.body.error) &&
+        typeof input.body.error.message === "string"
+        ? input.body.error.message
+        : undefined;
+    const serverDetails = isPlainObject(input.body) &&
+        isPlainObject(input.body.error) &&
+        isPlainObject(input.body.error.details)
+        ? input.body.error.details
+        : {};
+    let code = "server.error";
+    let message = serverMessage || `Request failed (${status})`;
+    if (status === 401) {
+        if (serverMessage?.toLowerCase().includes("invalid api key")) {
+            code = "auth.invalid_api_key";
+            message = "Invalid API key";
+        }
+        else if (serverMessage?.toLowerCase().includes("missing api key")) {
+            code = "auth.missing_api_key";
+            message = "Missing API key";
+        }
+        else {
+            code = "auth.unauthorized";
+            message = "Unauthorized";
+        }
+    }
+    else if (status === 403) {
+        code = "permission.forbidden";
+        message = serverMessage || "Forbidden";
+    }
+    else if (status === 404) {
+        code = "not_found";
+        message = serverMessage || "Not found";
+    }
+    else if (status === 409) {
+        code = "conflict";
+        message = serverMessage || "Conflict";
+    }
+    else if (status === 400) {
+        code = "request.bad_request";
+        message = serverMessage || "Bad request";
+    }
+    else if (status === 422) {
+        code = "request.validation_error";
+        message = serverMessage || "Validation error";
+    }
+    else if (status >= 500) {
+        code = "server.error";
+        message = "Server error";
+    }
+    const details = {
+        ...(serverCode ? { serverCode } : {}),
+        ...(Object.keys(serverDetails).length > 0 ? { serverDetails } : {}),
+    };
+    return {
+        code,
+        message,
+        details,
+        meta: { status, requestId: input.requestId },
+    };
+}
+export function normalizeLocalUsageError(message, details = {}) {
+    return {
+        code: "usage.validation_error",
+        message,
+        details,
+        meta: {},
+    };
+}
+export function exitCodeForError(err) {
+    const status = err.meta.status;
+    if (typeof status === "number")
+        return exitCodeForHttpStatus(status);
+    if (err.code.startsWith("usage."))
+        return ExitCode.Usage;
+    if (err.code.startsWith("auth."))
+        return ExitCode.Auth;
+    if (err.code.startsWith("permission."))
+        return ExitCode.Permission;
+    if (err.code.startsWith("not_found"))
+        return ExitCode.NotFound;
+    if (err.code.startsWith("conflict"))
+        return ExitCode.Conflict;
+    if (err.code.startsWith("config."))
+        return ExitCode.Usage;
+    return ExitCode.Transient;
+}
+export function toJsonErrorEnvelope(err) {
+    return {
+        ok: false,
+        error: {
+            code: err.code,
+            message: err.message,
+            details: err.details,
+        },
+        meta: {
+            status: err.meta.status,
+            requestId: err.meta.requestId,
+        },
+    };
+}
+export function toJsonOkEnvelope(data, meta) {
+    return {
+        ok: true,
+        data,
+        meta: {
+            status: meta?.status,
+            requestId: meta?.requestId,
+        },
+    };
+}

package/dist/src/lib/options.d.ts

@@ -0,0 +1,12 @@
+export type OptionSpec = {
+    name: string;
+    takesValue: boolean;
+};
+export type ParsedOptions = {
+    positionals: string[];
+    values: Record<string, string | boolean>;
+    unknownOption?: string;
+    missingValueOption?: string;
+};
+export declare function parseOptions(argv: string[], specs: OptionSpec[]): ParsedOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/src/lib/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/lib/options.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,aAAa,CAwD/E"}

package/dist/src/lib/options.js

@@ -0,0 +1,49 @@
+export function parseOptions(argv, specs) {
+    const specMap = new Map();
+    for (const spec of specs)
+        specMap.set(spec.name, spec);
+    const values = {};
+    const positionals = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--") {
+            positionals.push(...argv.slice(i + 1));
+            break;
+        }
+        if (!arg.startsWith("-")) {
+            positionals.push(...argv.slice(i));
+            break;
+        }
+        if (arg.startsWith("--")) {
+            const [name, inline] = arg.split("=", 2);
+            const spec = specMap.get(name);
+            if (!spec)
+                return { positionals: [], values, unknownOption: name };
+            if (!spec.takesValue) {
+                values[name] = true;
+                continue;
+            }
+            if (inline !== undefined) {
+                if (inline.length === 0)
+                    return { positionals: [], values, missingValueOption: name };
+                values[name] = inline;
+                continue;
+            }
+            const value = argv[i + 1];
+            if (!value || value === "--") {
+                return { positionals: [], values, missingValueOption: name };
+            }
+            // Only treat the next token as "missing" when it is a known option. This allows legitimate values
+            // that start with `-` (e.g. negative numbers, free-form strings like "-hello", or "--not-an-option").
+            const [nextName] = value.split("=", 2);
+            if (nextName.startsWith("--") && specMap.has(nextName)) {
+                return { positionals: [], values, missingValueOption: name };
+            }
+            values[name] = value;
+            i++;
+            continue;
+        }
+        return { positionals: [], values, unknownOption: arg };
+    }
+    return { positionals, values };
+}

package/dist/src/lib/package-version.d.ts

@@ -0,0 +1,2 @@
+export declare function getPackageVersion(): string;
+//# sourceMappingURL=package-version.d.ts.map

package/dist/src/lib/package-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../../../src/lib/package-version.ts"],"names":[],"mappings":"AAMA,wBAAgB,iBAAiB,IAAI,MAAM,CAiB1C"}

package/dist/src/lib/package-version.js

@@ -0,0 +1,22 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+let cached = null;
+export function getPackageVersion() {
+    if (cached)
+        return cached;
+    try {
+        // Compiled output lives at `dist/**`; package.json is one directory up from `dist`.
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const pkgJsonPath = path.resolve(__dirname, "..", "..", "..", "package.json");
+        const raw = fs.readFileSync(pkgJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        cached = typeof parsed.version === "string" ? parsed.version : "0.0.0";
+        return cached;
+    }
+    catch {
+        cached = "0.0.0";
+        return cached;
+    }
+}

package/dist/src/lib/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function getDefaultConfigDir(appName: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/src/lib/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/lib/paths.ts"],"names":[],"mappings":"AAOA,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAmB3D"}

package/dist/src/lib/paths.js

@@ -0,0 +1,21 @@
+import os from "node:os";
+import path from "node:path";
+function assertNever(x) {
+    throw new Error(`Unexpected platform: ${String(x)}`);
+}
+export function getDefaultConfigDir(appName) {
+    const platform = process.platform;
+    const home = os.homedir();
+    if (platform === "darwin") {
+        return path.join(home, "Library", "Application Support", appName);
+    }
+    if (platform === "win32") {
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        return path.join(appData, appName);
+    }
+    if (platform === "linux") {
+        const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+        return path.join(xdgConfigHome, appName);
+    }
+    assertNever(platform);
+}

package/dist/src/lib/profile-name.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidProfileName(name: string): boolean;
+//# sourceMappingURL=profile-name.d.ts.map

package/dist/src/lib/profile-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-name.d.ts","sourceRoot":"","sources":["../../../src/lib/profile-name.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGxD"}

package/dist/src/lib/profile-name.js

@@ -0,0 +1,4 @@
+export function isValidProfileName(name) {
+    // Keep it simple and file-name safe.
+    return /^[a-zA-Z0-9._-]+$/.test(name);
+}