automate.ax 0.1.3

package/dist/cli/commands/debug.js

@@ -0,0 +1,52 @@
+import { green, red, yellow } from "ansis";
+import { defineCommand } from "citty";
+import { joinURL } from "ufo";
+import { commandNames } from "../command-names.js";
+import { renderDetailBlock } from "../lib/detail-block.js";
+import { env } from "../lib/env.js";
+import { createCommandRun, output, sessionIntro, useSession } from "../utils.js";
+import { log } from "@clack/prompts";
+import { dimmed } from "../lib/io.js";
+export const debugCommand = defineCommand({
+    meta: {
+        name: commandNames.debug,
+        description: "Print resolved app URL and API endpoints this CLI uses",
+    },
+    run: createCommandRun(null, debug),
+});
+/** Logs APP_ORIGIN and the RPC/auth base URLs derived from it. */
+export async function debug() {
+    const { APP_ORIGIN } = env;
+    const session = await useSession({ signInAnonymously: false });
+    const appOrigin = APP_ORIGIN;
+    const apiRpc = joinURL(APP_ORIGIN, "/api/rpc");
+    const apiRest = joinURL(APP_ORIGIN, "/api/v1");
+    const apiAuth = joinURL(APP_ORIGIN, "/api/auth");
+    output
+        .normal(() => {
+        sessionIntro(session);
+        log.message(renderDetailBlock({
+            [dimmed `App origin`]: appOrigin,
+            [dimmed `API RPC`]: apiRpc,
+            [dimmed `API REST`]: apiRest,
+            [dimmed `API Auth`]: apiAuth,
+            [dimmed `Auth Status`]: session
+                ? session.user.isAnonymous
+                    ? yellow `Anon`
+                    : green `Logged in`
+                : red `No Auth`,
+        }, { keyAlignment: "right" }));
+        log.message();
+    })
+        .json({
+        appOrigin,
+        apiRpc,
+        apiRest,
+        apiAuth,
+        authStatus: !session
+            ? "no_auth"
+            : session.user.isAnonymous
+                ? "anonymous"
+                : "logged_in",
+    });
+}

package/dist/cli/commands/deploy.d.ts

@@ -0,0 +1,24 @@
+import z from "zod";
+import { apiClient } from "../lib/api-client.js";
+import { configDirOptsSchema } from "../utils.js";
+export declare const deployCommand: import("citty").CommandDef<{
+    readonly dir: {
+        readonly type: "string";
+        readonly description: "Directory containing a config file";
+        readonly alias: ["d"];
+    };
+}>;
+/**
+ * Builds and deploys every automation found in a project's config directory.
+ *
+ * @param opts - Validated options selecting the project directory.
+ * @throws When the directory contains no automation source files.
+ */
+export declare function deploy(opts: z.infer<typeof configDirOptsSchema>): Promise<void>;
+/**
+ * Formats the current deployment status for the interactive spinner.
+ *
+ * @param deployment - Current deployment polling response.
+ */
+export declare function deploymentStatusMessage(deployment: Pick<Awaited<ReturnType<typeof apiClient.deployment.get>>, "status">): "Deploying" | "Planning automations" | "Creating runtime snapshots" | "Configuring event sources";
+//# sourceMappingURL=deploy.d.ts.map

package/dist/cli/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/deploy.ts"],"names":[],"mappings":"AAMA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,EAAE,SAAS,EAAE,6BAAyB;AAI7C,OAAO,EAEL,mBAAmB,EAOpB,oBAAgB;AAkBjB,eAAO,MAAM,aAAa;;;;;;EAaxB,CAAA;AAEF;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,iBAoErE;AA+CD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,IAAI,CACd,OAAO,CAAC,UAAU,CAAC,OAAO,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EACpD,QAAQ,CACT,qGASF"}

package/dist/cli/commands/deploy.js

@@ -0,0 +1,292 @@
+import { confirm, log, password, select, text } from "@clack/prompts";
+import { defineCommand } from "citty";
+import os from "node:os";
+import path from "node:path";
+import { setTimeout } from "node:timers/promises";
+import open from "open";
+import z from "zod";
+import { commandNames } from "../command-names.js";
+import { apiClient } from "../lib/api-client.js";
+import { accent, dimmed } from "../lib/io.js";
+import { buildAutomations, findAutomationFiles } from "../lib/automation-build.js";
+import { loadProjectConfig } from "../lib/project-config.js";
+import { createCommandRun, configDirOptsSchema, output, pluralize, sessionIntro, safelyPrompt, useConfigDir, useSession, } from "../utils.js";
+import { clearSpinner, startSpinner } from "../lib/spinner.js";
+import { renderDetailBlock } from "../lib/detail-block.js";
+import { isJsonOutput } from "../lib/json-output.js";
+const CONNECT_NEW_ACCOUNT = "__connect_new_account__";
+const AUTHORIZATION_POLL_INTERVAL_MS = 2_000;
+export const deployCommand = defineCommand({
+    meta: {
+        name: commandNames.deploy,
+        description: "Deploy project code",
+    },
+    args: {
+        dir: {
+            type: "string",
+            description: "Directory containing a config file",
+            alias: ["d"],
+        },
+    },
+    run: createCommandRun(configDirOptsSchema, deploy),
+});
+/**
+ * Builds and deploys every automation found in a project's config directory.
+ *
+ * @param opts - Validated options selecting the project directory.
+ * @throws When the directory contains no automation source files.
+ */
+export async function deploy(opts) {
+    const session = await useSession();
+    output.normal(() => sessionIntro(session));
+    const configDir = await useConfigDir(opts);
+    const { projectId } = await loadProjectConfig(configDir.configPath);
+    const automationFiles = await findAutomationFiles(configDir.dir);
+    if (automationFiles.length === 0) {
+        throw new Error(`No automation files found in ${formatDisplayPath(configDir.dir)}. Expected at least one *.automation.ts file.`);
+    }
+    startSpinner("Building automations");
+    const build = await buildAutomations(configDir.dir, automationFiles);
+    clearSpinner();
+    startSpinner("Deploying");
+    const { id: deploymentId } = await apiClient.deployment.create({
+        projectId,
+        automations: build.automations,
+    });
+    let deployment = await pollForDeployment(projectId, deploymentId);
+    clearSpinner();
+    while (deployment.status === "awaiting_authorization") {
+        const authorization = await apiClient.authorization.get({
+            deploymentId,
+        });
+        if (isJsonOutput()) {
+            output.json({
+                ...configDir,
+                authorization,
+                automationFiles,
+                build,
+                deployment,
+            });
+            return;
+        }
+        await configureAuthorization(deploymentId, authorization);
+        deployment = await pollForDeployment(projectId, deploymentId);
+        clearSpinner();
+    }
+    output.normal(() => log.info(renderDetailBlock({
+        [dimmed `Directory`]: formatDisplayPath(configDir.dir),
+        [dimmed `Project`]: `${accent(deployment.project.name)}\n${dimmed(deployment.project.id)}`,
+        [dimmed `Automations`]: formatAutomationDetails(build.automations),
+    }, { keyAlignment: "right", lineSpacing: 1 })));
+    output
+        .normal(() => log.success(`Successfully deployed ${accent(String(build.automations.length))} ${pluralize(build.automations.length, "automation")}`))
+        .json({ ...configDir, automationFiles, build, deployment });
+}
+/**
+ * Polls deployment status until it reaches a terminal state.
+ *
+ * @param projectId - Project that owns the deployment.
+ * @param deploymentId - Deployment to poll.
+ */
+async function pollForDeployment(projectId, deploymentId) {
+    let previousMessage = "Deploying";
+    const interruptMessage = `Stopped waiting. Deployment ${deploymentId} will continue in the background.`;
+    startSpinner(previousMessage, interruptMessage);
+    while (true) {
+        const deployment = await apiClient.deployment.get({
+            deploymentId,
+            projectId,
+        });
+        if (deployment.status === "active" || deployment.status === "inactive") {
+            return deployment;
+        }
+        if (deployment.status === "awaiting_authorization")
+            return deployment;
+        if (deployment.status === "failed") {
+            throw new Error(deployment.job?.error ??
+                `Deployment failed after ${deployment.job?.attempts ?? 0} attempts.`);
+        }
+        if (deployment.status === "superseded") {
+            throw new Error("Deployment was superseded by a newer deployment.");
+        }
+        const message = deploymentStatusMessage(deployment);
+        if (message !== previousMessage) {
+            startSpinner(message, interruptMessage);
+            previousMessage = message;
+        }
+        await setTimeout(2_000);
+    }
+}
+/**
+ * Formats the current deployment status for the interactive spinner.
+ *
+ * @param deployment - Current deployment polling response.
+ */
+export function deploymentStatusMessage(deployment) {
+    return deployment.status === "planning"
+        ? "Planning automations"
+        : deployment.status === "snapshotting"
+            ? "Creating runtime snapshots"
+            : deployment.status === "configuring"
+                ? "Configuring event sources"
+                : "Deploying";
+}
+/**
+ * Interactively assigns existing eligible accounts to unmet bindings.
+ *
+ * @param deploymentId - Deployment whose requirements should be assigned.
+ * @param authorization - Current accounts and deployment requirements.
+ */
+async function configureAuthorization(deploymentId, authorization) {
+    let current = authorization;
+    while (true) {
+        const requirement = current.requirements.find(({ satisfied }) => !satisfied);
+        if (!requirement)
+            return;
+        const service = current.services.find((candidate) => candidate.id === requirement.serviceId);
+        if (!service) {
+            throw new Error(`Integration service ${requirement.serviceId} is unavailable.`);
+        }
+        const accounts = current.accounts.filter((account) => requirement.eligibleAccountIds.includes(account.id));
+        if (accounts.length > 0) {
+            const selectedAccountId = await safelyPrompt(() => select({
+                message: `Choose an account for ${service.name}/${requirement.binding}`,
+                options: [
+                    ...accounts.map((account) => ({
+                        label: account.label,
+                        value: account.id,
+                    })),
+                    {
+                        label: `Connect new ${service.name} account`,
+                        value: CONNECT_NEW_ACCOUNT,
+                    },
+                ],
+            }), "Account");
+            if (selectedAccountId !== CONNECT_NEW_ACCOUNT) {
+                await apiClient.authorization.selectAccount({
+                    accountId: selectedAccountId,
+                    binding: requirement.binding,
+                    deploymentId,
+                });
+                current = await apiClient.authorization.get({ deploymentId });
+                continue;
+            }
+        }
+        current = await connectAccount(deploymentId, requirement, service);
+    }
+}
+/**
+ * Connects and selects a new account using a server-provided manifest.
+ *
+ * @param deploymentId - Deployment awaiting the account.
+ * @param requirement - Binding that needs an account.
+ * @param service - API-provided service presentation.
+ */
+async function connectAccount(deploymentId, requirement, service) {
+    if (service.connection.type === "form") {
+        const data = {};
+        for (const field of service.connection.fields) {
+            const message = field.description
+                ? `${field.label} — ${field.description}`
+                : field.label;
+            if (field.input === "boolean") {
+                data[field.name] = await safelyPrompt(() => confirm({
+                    initialValue: field.default,
+                    message,
+                }), field.label);
+                continue;
+            }
+            const options = {
+                message,
+                placeholder: field.placeholder,
+                validate: (value) => {
+                    if (field.required && !value)
+                        return `${field.label} is required.`;
+                    if (field.input === "number" &&
+                        value &&
+                        !Number.isFinite(Number(value))) {
+                        return `${field.label} must be a number.`;
+                    }
+                },
+            };
+            const value = await safelyPrompt(() => field.input === "password"
+                ? password(options)
+                : text({
+                    ...options,
+                    initialValue: field.default?.toString(),
+                }), field.label);
+            if (!value && !field.required)
+                continue;
+            data[field.name] =
+                field.input === "number" ? z.coerce.number().parse(value) : value;
+        }
+        startSpinner(`Connecting ${service.name}`);
+        await apiClient.authorization.submitCredentials({
+            binding: requirement.binding,
+            data,
+            deploymentId,
+            serviceId: requirement.serviceId,
+        });
+        clearSpinner();
+        return apiClient.authorization.get({ deploymentId });
+    }
+    const { url } = await apiClient.authorization.beginConnection({
+        binding: requirement.binding,
+        deploymentId,
+        serviceId: requirement.serviceId,
+    });
+    log.info(`Authorize ${service.name} in your browser:\n${url}`);
+    await open(url, { wait: false }).catch(() => null);
+    startSpinner(`Waiting for ${service.name} authorization`, `Stopped waiting. Deployment ${deploymentId} remains pending authorization.`);
+    while (true) {
+        const authorization = await apiClient.authorization.get({ deploymentId });
+        if (authorization.requirements.find((candidate) => candidate.binding === requirement.binding &&
+            candidate.serviceId === requirement.serviceId)?.satisfied) {
+            clearSpinner();
+            return authorization;
+        }
+        await setTimeout(AUTHORIZATION_POLL_INTERVAL_MS);
+    }
+}
+/**
+ * Formats an absolute path relative to the current directory or home when
+ * possible.
+ *
+ * @param target - Filesystem path to display.
+ */
+function formatDisplayPath(target) {
+    const absoluteTarget = path.resolve(target);
+    const cwdRelative = path.relative(process.cwd(), absoluteTarget);
+    if (cwdRelative.length > 0 && isRelativeWithin(cwdRelative)) {
+        return `.${path.sep}${cwdRelative}`;
+    }
+    const homeRelative = path.relative(os.homedir(), absoluteTarget);
+    if (homeRelative.length === 0)
+        return "~";
+    if (isRelativeWithin(homeRelative)) {
+        return `~${path.sep}${homeRelative}`;
+    }
+    return absoluteTarget;
+}
+/**
+ * Formats deployed automation identities for a CLI detail block.
+ *
+ * @param automations - Built automations to list.
+ */
+function formatAutomationDetails(automations) {
+    if (automations.length === 0)
+        return dimmed `None`;
+    return automations
+        .map((automation) => dimmed(automation.identityKey))
+        .join("\n");
+}
+/**
+ * Checks whether a relative path remains within its base directory.
+ *
+ * @param relative - Relative path to inspect.
+ */
+function isRelativeWithin(relative) {
+    return (relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}

package/dist/cli/commands/login.d.ts

@@ -0,0 +1,20 @@
+import z from "zod";
+/** Arguments accepted by the login command. */
+declare const loginOptsSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodEmail>;
+}, z.core.$strip>;
+export declare const loginCommand: import("citty").CommandDef<{
+    readonly email: {
+        readonly type: "string";
+        readonly description: "Prefill the browser login email";
+        readonly alias: ["e"];
+    };
+}>;
+/**
+ * Runs the login flow for the given CLI options.
+ *
+ * @param opts - Validated login options, including an optional email hint.
+ */
+export declare function login(opts: z.infer<typeof loginOptsSchema>): Promise<void>;
+export {};
+//# sourceMappingURL=login.d.ts.map

package/dist/cli/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/login.ts"],"names":[],"mappings":"AAMA,OAAO,CAAC,MAAM,KAAK,CAAA;AAiBnB,+CAA+C;AAC/C,QAAA,MAAM,eAAe;;iBAEnB,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;EAavB,CAAA;AAEF;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,iBAKhE"}

package/dist/cli/commands/login.js

@@ -0,0 +1,145 @@
+import { log } from "@clack/prompts";
+import { defineCommand } from "citty";
+import { setTimeout } from "node:timers/promises";
+import open from "open";
+import { pick } from "remeda";
+import { joinURL, withQuery } from "ufo";
+import z from "zod";
+import { commandNames } from "../command-names.js";
+import { apiClient } from "../lib/api-client.js";
+import { authClient } from "../lib/auth-client.js";
+import { env } from "../lib/env.js";
+import { clearSavedTokenSync, createCommandRun, output, sessionIntro, saveTokenSync, useSession, } from "../utils.js";
+import { accent } from "../lib/io.js";
+import { clearSpinner, startSpinner } from "../lib/spinner.js";
+import { blue } from "ansis";
+/** Arguments accepted by the login command. */
+const loginOptsSchema = z.object({
+    email: z.email().optional(),
+});
+export const loginCommand = defineCommand({
+    meta: {
+        name: commandNames.login,
+        description: "Authenticate with Automate.ax",
+    },
+    args: {
+        email: {
+            type: "string",
+            description: "Prefill the browser login email",
+            alias: ["e"],
+        },
+    },
+    run: createCommandRun(loginOptsSchema, login),
+});
+/**
+ * Runs the login flow for the given CLI options.
+ *
+ * @param opts - Validated login options, including an optional email hint.
+ */
+export async function login(opts) {
+    const session = await useSession({ signInAnonymously: false });
+    output.normal(() => sessionIntro(session, { skipAnonWarning: true }));
+    await loginWithDeviceAuth(opts.email, !!session?.user.isAnonymous);
+}
+const DEVICE_CLIENT_ID = "automate-cli";
+/**
+ * Opens the browser to a server-hosted login page, then polls until that page
+ * approves the device code.
+ *
+ * If the CLI currently holds an anonymous session, app-owned rows are migrated
+ * to the newly authenticated user before the old session is discarded.
+ *
+ * @param email - Optional email address to prefill in the browser.
+ * @param hasAnonymousSession - Whether to link the current anonymous account.
+ * @throws When device authorization or the resulting login session fails.
+ */
+async function loginWithDeviceAuth(email, hasAnonymousSession) {
+    startSpinner("Preparing login");
+    const { device_code, user_code } = await authClient.device.code({
+        client_id: DEVICE_CLIENT_ID,
+    });
+    const authPageUrl = withQuery(joinURL(env.APP_ORIGIN, "/login"), {
+        user_code,
+        email: email?.toLowerCase(),
+    });
+    clearSpinner();
+    output.normal(() => log.message(blue.underline.link(authPageUrl, "Open in browser"), {
+        symbol: blue `↗`,
+    }));
+    await open(authPageUrl);
+    startSpinner("Waiting for authorization");
+    const accessToken = await pollForDeviceToken(device_code);
+    clearSpinner();
+    if (hasAnonymousSession) {
+        startSpinner("Linking account");
+        await apiClient.session.linkDeviceSession({ newAccessToken: accessToken });
+        clearSpinner();
+    }
+    saveTokenSync(accessToken);
+    const session = await authClient.getSession();
+    if (!session) {
+        clearSavedTokenSync();
+        throw new Error("Failed to login");
+    }
+    output
+        .normal(() => log.success(`Logged in as ${accent(session.user.email)}`))
+        .json({
+        loggedIn: true,
+        success: true,
+        user: pick(session.user, [
+            "id",
+            "name",
+            "email",
+            "emailVerified",
+            "image",
+            "createdAt",
+            "updatedAt",
+        ]),
+    });
+}
+/**
+ * Polls the device token endpoint until the user authorizes or the code
+ * expires.
+ *
+ * @param deviceCode - OAuth device code whose authorization is pending.
+ * @throws When authorization is denied, expires, or otherwise fails.
+ */
+async function pollForDeviceToken(deviceCode) {
+    let interval = 2000;
+    while (true) {
+        await setTimeout(interval);
+        try {
+            const { access_token } = await authClient.device.token({
+                device_code: deviceCode,
+                client_id: DEVICE_CLIENT_ID,
+                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                fetchOptions: {
+                    headers: {
+                        "user-agent": `Automate.ax CLI`,
+                    },
+                },
+            });
+            return access_token;
+        }
+        catch (err) {
+            switch (z.object({ error: z.object({ error: z.string() }) }).safeParse(err).data
+                ?.error.error) {
+                case "authorization_pending":
+                    continue;
+                case "slow_down":
+                    interval *= 1.5;
+                    continue;
+                case "access_denied":
+                    throw new Error("Authorization was denied by the user", {
+                        cause: err,
+                    });
+                case "expired_token":
+                    throw new Error("Device code expired. Please try again", {
+                        cause: err,
+                    });
+                default:
+                    throw err;
+            }
+        }
+    }
+}

package/dist/cli/commands/logout.d.ts

@@ -0,0 +1,4 @@
+export declare const logoutCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+/** Signs out and clears the saved CLI session token. */
+export declare function logout(): Promise<void>;
+//# sourceMappingURL=logout.d.ts.map

package/dist/cli/commands/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/logout.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,aAAa,qDAMxB,CAAA;AAEF,wDAAwD;AACxD,wBAAsB,MAAM,kBA0B3B"}

package/dist/cli/commands/logout.js

@@ -0,0 +1,32 @@
+import { log } from "@clack/prompts";
+import { defineCommand } from "citty";
+import { commandExamples, commandNames } from "../command-names.js";
+import { authClient } from "../lib/auth-client.js";
+import { accent } from "../lib/io.js";
+import { clearSpinner, startSpinner } from "../lib/spinner.js";
+import { clearSavedTokenSync, createCommandRun, output, sessionIntro, useSession, } from "../utils.js";
+export const logoutCommand = defineCommand({
+    meta: {
+        name: commandNames.logout,
+        description: "Logout from Automate.ax",
+    },
+    run: createCommandRun(null, logout),
+});
+/** Signs out and clears the saved CLI session token. */
+export async function logout() {
+    const session = await useSession({ signInAnonymously: false });
+    output.normal(() => sessionIntro(session, { skipAnonWarning: true }));
+    if (!session || session.user.isAnonymous) {
+        output
+            .normal(() => log.warn(`Not currently signed in. Run ${accent(commandExamples.login)} to sign in.`))
+            .json({ loggedIn: false, success: false, user: null });
+        return;
+    }
+    startSpinner("Signing out");
+    await authClient.signOut();
+    clearSavedTokenSync();
+    clearSpinner();
+    output
+        .normal(() => log.success(`Signed out. Sign back in with ${accent(commandExamples.login)}`))
+        .json({ loggedIn: false, success: true, user: null });
+}

package/dist/cli/commands/me.d.ts

@@ -0,0 +1,4 @@
+export declare const meCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+/** Prints auth status and identity with the CLI header. */
+export declare function me(): Promise<void>;
+//# sourceMappingURL=me.d.ts.map

package/dist/cli/commands/me.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"me.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/me.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,SAAS,qDAMpB,CAAA;AAEF,2DAA2D;AAC3D,wBAAsB,EAAE,kBAyCvB"}

package/dist/cli/commands/me.js

@@ -0,0 +1,48 @@
+import { intro, log } from "@clack/prompts";
+import { green, red } from "ansis";
+import { defineCommand } from "citty";
+import { pick } from "remeda";
+import { commandNames } from "../command-names.js";
+import { renderDetailBlock } from "../lib/detail-block.js";
+import { dimmed } from "../lib/io.js";
+import { CLI_PREFIX, createCommandRun, output, useSession } from "../utils.js";
+export const meCommand = defineCommand({
+    meta: {
+        name: commandNames.me,
+        description: "Check which account is currently logged in",
+    },
+    run: createCommandRun(null, me),
+});
+/** Prints auth status and identity with the CLI header. */
+export async function me() {
+    const session = await useSession({
+        signInAnonymously: false,
+    });
+    output
+        .normal(() => {
+        intro(CLI_PREFIX);
+        log.message(renderDetailBlock(!session || session.user.isAnonymous
+            ? { [dimmed `Status`]: red `Not logged in` }
+            : {
+                [dimmed `Status`]: green `Logged in`,
+                [dimmed `Name`]: session.user.name,
+                [dimmed `Email`]: session.user.email,
+                [dimmed `ID`]: dimmed(session.user.id),
+            }, { keyAlignment: "right" }));
+        log.message();
+    })
+        .json(!session || session.user.isAnonymous
+        ? { loggedIn: false, user: null }
+        : {
+            loggedIn: true,
+            user: pick(session.user, [
+                "id",
+                "name",
+                "email",
+                "emailVerified",
+                "image",
+                "createdAt",
+                "updatedAt",
+            ]),
+        });
+}

package/dist/cli/commands/org-api-key-create.d.ts

@@ -0,0 +1,26 @@
+import z from "zod";
+/** Validates options before an API key secret can be issued. */
+declare const createApiKeyOptsSchema: z.ZodObject<{
+    org: z.ZodOptional<z.ZodString>;
+    name: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const orgApiKeyCreateCommand: import("citty").CommandDef<{
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Name for the API key";
+        readonly alias: ["n"];
+    };
+    readonly org: {
+        type: "string";
+        description: string;
+        alias: string[];
+    };
+}>;
+/**
+ * Creates an organization API key and prints its one-time secret.
+ *
+ * @param opts - Organization selector and API key name.
+ */
+export declare function createOrganizationApiKey(opts: z.infer<typeof createApiKeyOptsSchema>): Promise<void>;
+export {};
+//# sourceMappingURL=org-api-key-create.d.ts.map

package/dist/cli/commands/org-api-key-create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-api-key-create.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/org-api-key-create.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAA;AAkBnB,gEAAgE;AAChE,QAAA,MAAM,sBAAsB;;;iBAE1B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;EAcjC,CAAA;AAEF;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,iBA6B7C"}