@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/hub/deploy-triggers.js

@@ -0,0 +1,116 @@
+import { lstat, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { HubCommandError } from "./error.js";
+const TRIGGER_DIRECTORY = ".paseo/triggers";
+export async function discoverHubTriggers(cwd) {
+    const root = path.resolve(cwd);
+    const directory = path.join(root, TRIGGER_DIRECTORY);
+    const paseoDirectory = await readStats(path.join(root, ".paseo"), {
+        code: "HUB_TRIGGER_DIRECTORY_MISSING",
+        message: `${TRIGGER_DIRECTORY} does not exist. Run this command from the project root.`,
+    });
+    if (paseoDirectory.isSymbolicLink())
+        throw unsafeTriggerPath(TRIGGER_DIRECTORY);
+    const directoryStats = await readTriggerDirectoryStats(root, directory);
+    if (directoryStats.isSymbolicLink())
+        throw unsafeTriggerPath(TRIGGER_DIRECTORY);
+    if (!directoryStats.isDirectory()) {
+        throw new HubCommandError("HUB_TRIGGER_DIRECTORY_INVALID", `${TRIGGER_DIRECTORY} must be a directory.`);
+    }
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (!isExpectedReadError(error))
+            throw error;
+        throw unreadableTriggerPath(TRIGGER_DIRECTORY);
+    }
+    const triggers = [];
+    for (const entry of entries.toSorted((left, right) => left.name.localeCompare(right.name))) {
+        const triggerPath = `${TRIGGER_DIRECTORY}/${entry.name}`;
+        if (entry.isSymbolicLink())
+            throw unsafeTriggerPath(triggerPath);
+        if (!entry.isFile() || !entry.name.endsWith(".yml")) {
+            throw new HubCommandError("HUB_TRIGGER_PATH_UNSUPPORTED", `${triggerPath} must be a direct-child .yml trigger.`);
+        }
+        try {
+            triggers.push({
+                path: triggerPath,
+                yaml: await readFile(path.join(root, triggerPath), "utf8"),
+            });
+        }
+        catch (error) {
+            if (!isExpectedReadError(error))
+                throw error;
+            throw unreadableTriggerPath(triggerPath);
+        }
+    }
+    if (triggers.length === 0) {
+        throw new HubCommandError("HUB_TRIGGER_MISSING", `${TRIGGER_DIRECTORY} must contain at least one direct-child .yml trigger.`);
+    }
+    return triggers;
+}
+async function readTriggerDirectoryStats(root, directory) {
+    try {
+        return await lstat(directory);
+    }
+    catch (error) {
+        if (errorCode(error) !== "ENOENT") {
+            if (!isExpectedReadError(error))
+                throw error;
+            throw unreadableTriggerPath(TRIGGER_DIRECTORY);
+        }
+        if (await legacyBundleExists(root)) {
+            throw new HubCommandError("HUB_PROJECT_REQUIRED", "This directory contains a legacy .paseo/hub.yml bundle. Pass --project <slug> to deploy it.");
+        }
+        throw new HubCommandError("HUB_TRIGGER_DIRECTORY_MISSING", `${TRIGGER_DIRECTORY} does not exist. Run this command from the project root.`);
+    }
+}
+async function legacyBundleExists(root) {
+    try {
+        await lstat(path.join(root, ".paseo/hub.yml"));
+        return true;
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return false;
+        if (!isExpectedReadError(error))
+            throw error;
+        throw unreadableTriggerPath(".paseo/hub.yml");
+    }
+}
+async function readStats(target, missing) {
+    try {
+        return await lstat(target);
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            throw new HubCommandError(missing.code, missing.message);
+        if (!isExpectedReadError(error))
+            throw error;
+        throw unreadableTriggerPath(TRIGGER_DIRECTORY);
+    }
+}
+function unsafeTriggerPath(triggerPath) {
+    return new HubCommandError("HUB_TRIGGER_UNSAFE_PATH", `${triggerPath} must not use a symlink.`);
+}
+function unreadableTriggerPath(triggerPath) {
+    return new HubCommandError("HUB_TRIGGER_UNREADABLE", `Could not read ${triggerPath}. Check the file and permissions.`);
+}
+function errorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const code = Reflect.get(error, "code");
+    return typeof code === "string" ? code : undefined;
+}
+function isExpectedReadError(error) {
+    const code = errorCode(error);
+    return (code === "EACCES" ||
+        code === "EPERM" ||
+        code === "ENOENT" ||
+        code === "ENOTDIR" ||
+        code === "ELOOP" ||
+        code === "EISDIR");
+}
+//# sourceMappingURL=deploy-triggers.js.map

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

@@ -0,0 +1,50 @@
+import type { Command } from "commander";
+import { type ListResult, type SingleResult } from "../../output/index.js";
+import { HubHttpClient, type HubInstallResult, type HubTriggerInstallationResult, type HubTriggerValidationResult, type HubValidationResult } from "./hub-client/index.js";
+import { type HubCredentialStore } from "./credentials.js";
+import { type HubDeployBundle } from "./deploy-bundle.js";
+import { type HubDeployTrigger } from "./deploy-triggers.js";
+import { type HubReporter } from "./reporter.js";
+export interface HubDeployOptions {
+    project?: string;
+    hub?: string;
+    apiKey?: string;
+    dryRun?: boolean;
+    json?: boolean;
+}
+export interface HubDeployEnvironment {
+    cwd: string;
+    env: Readonly<Record<string, string | undefined>>;
+    credentials?: HubCredentialStore;
+    hub?: Pick<HubHttpClient, "installConfiguration" | "validateConfiguration" | "installTrigger" | "validateTrigger">;
+    reporter?: HubReporter;
+}
+export interface HubDeployCommandDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: Pick<HubHttpClient, "installConfiguration" | "validateConfiguration" | "installTrigger" | "validateTrigger">;
+    reporter: HubReporter;
+    cwd(): string;
+}
+interface HubDeployResult extends HubInstallResult {
+    origin: string;
+    workflows: number;
+}
+interface HubDryRunResult extends HubValidationResult {
+    origin: string;
+    workflows: number;
+}
+interface HubTriggerDeployResult extends HubTriggerInstallationResult {
+    origin: string;
+    path: string;
+}
+interface HubTriggerDryRunResult extends HubTriggerValidationResult {
+    origin: string;
+    path: string;
+}
+export declare function runHubDeploy(options: HubDeployOptions, environment?: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult> | ListResult<HubTriggerDeployResult> | ListResult<HubTriggerDryRunResult>>;
+export declare function runHubDeployTriggers(options: HubDeployOptions, triggers: readonly HubDeployTrigger[], environment: HubDeployEnvironment): Promise<ListResult<HubTriggerDeployResult> | ListResult<HubTriggerDryRunResult>>;
+export declare function runHubDeployBundle(options: HubDeployOptions, deployInput: HubDeployBundle, environment: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult>>;
+export declare function addHubDeployCommand(hub: Command, dependencies: HubDeployCommandDependencies): void;
+export {};
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/hub/deploy.js

@@ -0,0 +1,159 @@
+import { withOutput, } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+import { resolveHubCredential, resolveHubOrigin } from "./authority.js";
+import { HubHttpClient, } from "./hub-client/index.js";
+import { PrivateHubCredentialStore } from "./credentials.js";
+import { discoverHubBundle } from "./deploy-bundle.js";
+import { discoverHubTriggers } from "./deploy-triggers.js";
+import { HubCommandError } from "./error.js";
+import { processHubReporter, reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
+const resultSchema = {
+    idField: "versionId",
+    columns: [
+        { header: "PROJECT", field: "projectSlug" },
+        { header: "VERSION", field: "version" },
+        { header: "VERSION ID", field: "versionId" },
+        { header: "ACTIVE", field: "active" },
+        { header: "WORKFLOWS", field: "workflows" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+const validationSchema = {
+    idField: "projectSlug",
+    columns: [
+        { header: "PROJECT", field: "projectSlug" },
+        { header: "VALID", field: "valid" },
+        { header: "WORKFLOWS", field: "workflows" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+const triggerResultSchema = {
+    idField: "triggerId",
+    columns: [
+        { header: "TRIGGER", field: "name" },
+        { header: "VERSION", field: "version" },
+        { header: "REVISION ID", field: "revisionId" },
+        { header: "ACTIVE", field: "active" },
+        { header: "PATH", field: "path" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+const triggerValidationSchema = {
+    idField: "name",
+    columns: [
+        { header: "TRIGGER", field: "name" },
+        { header: "VALID", field: "valid" },
+        { header: "PATH", field: "path" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+export async function runHubDeploy(options, environment = {
+    cwd: process.cwd(),
+    env: process.env,
+    credentials: new PrivateHubCredentialStore(),
+    hub: new HubHttpClient(),
+}) {
+    if (options.project === undefined) {
+        return runHubDeployTriggers(options, await discoverHubTriggers(environment.cwd), environment);
+    }
+    const deployInput = await discoverHubBundle({
+        cwd: environment.cwd,
+        project: options.project,
+    });
+    return runHubDeployBundle(options, deployInput, environment);
+}
+export async function runHubDeployTriggers(options, triggers, environment) {
+    const credentials = environment.credentials ?? new PrivateHubCredentialStore(environment.env);
+    const resolution = {
+        options: { origin: options.hub, apiKey: options.apiKey },
+        env: environment.env,
+        credentials,
+    };
+    const origin = resolveHubOrigin(resolution);
+    const credential = resolveHubCredential({ ...resolution, origin });
+    const action = options.dryRun === true ? "Validating" : "Deploying";
+    reportHubProgress(environment.reporter ?? processHubReporter, options, `${action} ${String(triggers.length)} trigger${triggers.length === 1 ? "" : "s"} ${options.dryRun === true ? "against" : "to"} ${origin}`);
+    const hub = environment.hub ?? new HubHttpClient();
+    if (options.dryRun === true) {
+        const data = await Promise.all(triggers.map(async (trigger) => ({
+            ...(await hub.validateTrigger(origin, credential, trigger.yaml)),
+            origin,
+            path: trigger.path,
+        })));
+        return { type: "list", data, schema: triggerValidationSchema };
+    }
+    await Promise.all(triggers.map((trigger) => hub.validateTrigger(origin, credential, trigger.yaml)));
+    const data = [];
+    for (const trigger of triggers) {
+        try {
+            data.push({
+                ...(await hub.installTrigger(origin, credential, trigger.yaml)),
+                origin,
+                path: trigger.path,
+            });
+        }
+        catch (error) {
+            if (data.length === 0)
+                throw error;
+            throw new HubCommandError("HUB_TRIGGER_DEPLOY_PARTIAL", `Could not deploy ${trigger.path} after ${String(data.length)} trigger${data.length === 1 ? "" : "s"} had been installed.`, `${errorMessage(error)}\nInstalled before the failure:\n${data.map(({ path: installedPath }) => `- ${installedPath}`).join("\n")}`);
+        }
+    }
+    return { type: "list", data, schema: triggerResultSchema };
+}
+function errorMessage(error) {
+    if (error instanceof HubCommandError) {
+        return error.details === undefined ? error.message : `${error.message}\n${error.details}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+export async function runHubDeployBundle(options, deployInput, environment) {
+    const credentials = environment.credentials ?? new PrivateHubCredentialStore(environment.env);
+    const resolution = {
+        options: { origin: options.hub, apiKey: options.apiKey },
+        env: environment.env,
+        credentials,
+    };
+    const origin = resolveHubOrigin(resolution);
+    const action = options.dryRun === true ? "Validating" : "Deploying";
+    reportHubProgress(environment.reporter ?? processHubReporter, options, `${action} ${deployInput.projectSlug} ${options.dryRun === true ? "against" : "to"} ${origin}`);
+    const credential = resolveHubCredential({ ...resolution, origin });
+    const request = {
+        origin,
+        apiKey: credential,
+        ...deployInput,
+    };
+    if (options.dryRun === true) {
+        const validated = await (environment.hub ?? new HubHttpClient()).validateConfiguration(request);
+        return {
+            type: "single",
+            data: { ...validated, workflows: deployInput.workflowCount, origin },
+            schema: validationSchema,
+        };
+    }
+    const deployed = await (environment.hub ?? new HubHttpClient()).installConfiguration(request);
+    return {
+        type: "single",
+        data: { ...deployed, workflows: deployInput.workflowCount, origin },
+        schema: resultSchema,
+    };
+}
+export function addHubDeployCommand(hub, dependencies) {
+    addJsonOption(addHubResolutionHelp(hub
+        .command("deploy")
+        .description("Deploy .paseo organization triggers or a legacy project bundle")
+        .option("-p, --project <slug>", "Deploy a legacy bundle to this project slug")
+        .option("--hub <origin>", "Paseo Hub origin")
+        .option("--api-key <secret>", "Organization API key")
+        .option("--dry-run", "Validate without installing or activating"))).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubDeploy(options, {
+            cwd: dependencies.cwd(),
+            env: dependencies.env,
+            credentials: dependencies.credentials,
+            hub: dependencies.hub,
+            reporter: dependencies.reporter,
+        });
+    }));
+}
+//# sourceMappingURL=deploy.js.map

package/dist/commands/hub/disconnect.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from "commander";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import { type HubReporter } from "./reporter.js";
+interface HubDisconnectOptions {
+    force?: boolean;
+    host?: string;
+    json?: boolean;
+}
+interface HubDisconnectDependencies {
+    daemon: HubDaemonConnection;
+    reporter: HubReporter;
+}
+export declare function runHubDisconnect(options: HubDisconnectOptions, dependencies: HubDisconnectDependencies): Promise<import("../../output/types.js").ListResult<import("./status-output.js").HubRow>>;
+export declare function addHubDisconnectCommand(parent: Command, dependencies: HubDisconnectDependencies): void;
+export {};
+//# sourceMappingURL=disconnect.d.ts.map

package/dist/commands/hub/disconnect.js

@@ -0,0 +1,24 @@
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { withHubDaemon } from "./daemon-client.js";
+import { reportHubProgress } from "./reporter.js";
+import { hubStatusResult } from "./status-output.js";
+export function runHubDisconnect(options, dependencies) {
+    return withHubDaemon(dependencies.daemon, options.host, async (client) => {
+        const current = (await client.getHubStatus()).status;
+        if (current.hubOrigin !== null) {
+            reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${current.hubOrigin}`);
+        }
+        const response = await client.disconnectHub(options.force ?? false);
+        return hubStatusResult(response.status, response.warning);
+    });
+}
+export function addHubDisconnectCommand(parent, dependencies) {
+    addJsonAndDaemonHostOptions(parent
+        .command("disconnect")
+        .option("--force", "Remove local authority without notifying the Hub")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubDisconnect(options, dependencies);
+    }));
+}
+//# sourceMappingURL=disconnect.js.map

package/dist/commands/hub/error.d.ts

@@ -0,0 +1,6 @@
+export declare class HubCommandError extends Error {
+    readonly code: string;
+    readonly details?: string | undefined;
+    constructor(code: string, message: string, details?: string | undefined);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/commands/hub/error.js

@@ -0,0 +1,9 @@
+export class HubCommandError extends Error {
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "HubCommandError";
+    }
+}
+//# sourceMappingURL=error.js.map

package/dist/commands/hub/export.d.ts

@@ -0,0 +1,28 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import type { HubCredentialStore } from "./credentials.js";
+import type { HubHttpClient } from "./hub-client/index.js";
+import { type HubReporter } from "./reporter.js";
+interface HubExportResult {
+    origin: string;
+    directory: string;
+    exported: number;
+    unchanged: number;
+}
+export interface HubExportOptions {
+    hub?: string;
+    apiKey?: string;
+    force?: boolean;
+    json?: boolean;
+}
+interface HubExportDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: Pick<HubHttpClient, "listTriggers">;
+    reporter: HubReporter;
+    cwd(): string;
+}
+export declare function runHubExport(directoryInput: string | undefined, options: HubExportOptions, dependencies: HubExportDependencies): Promise<SingleResult<HubExportResult>>;
+export declare function addHubExportCommand(parent: Command, dependencies: HubExportDependencies): void;
+export {};
+//# sourceMappingURL=export.d.ts.map

package/dist/commands/hub/export.js

@@ -0,0 +1,80 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { withOutput } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+import { resolveHubCredential, resolveHubOrigin } from "./authority.js";
+import { HubCommandError } from "./error.js";
+import { addHubResolutionHelp } from "./help.js";
+import { reportHubProgress } from "./reporter.js";
+const schema = {
+    idField: "directory",
+    columns: [
+        { header: "DIRECTORY", field: "directory" },
+        { header: "EXPORTED", field: "exported" },
+        { header: "UNCHANGED", field: "unchanged" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+export async function runHubExport(directoryInput, options, dependencies) {
+    const resolution = {
+        options: { origin: options.hub, apiKey: options.apiKey },
+        env: dependencies.env,
+        credentials: dependencies.credentials,
+    };
+    const origin = resolveHubOrigin(resolution);
+    const credential = resolveHubCredential({ ...resolution, origin });
+    const directory = path.resolve(dependencies.cwd(), directoryInput ?? ".paseo/triggers");
+    reportHubProgress(dependencies.reporter, options, `Exporting triggers from ${origin}`);
+    const triggers = await dependencies.hub.listTriggers(origin, credential);
+    await mkdir(directory, { recursive: true });
+    const files = await Promise.all(triggers.map(async (trigger) => {
+        const destination = path.join(directory, `${trigger.name}.yml`);
+        return { destination, trigger, existing: await readOptionalFile(destination) };
+    }));
+    const conflict = files.find(({ existing, trigger }) => existing !== undefined && existing !== trigger.yaml && options.force !== true);
+    if (conflict !== undefined) {
+        throw new HubCommandError("HUB_EXPORT_CONFLICT", `${conflict.destination} already exists with different contents. Pass --force to replace it.`);
+    }
+    for (const file of files) {
+        if (file.existing === file.trigger.yaml)
+            continue;
+        await writeFile(file.destination, file.trigger.yaml, file.existing === undefined ? { flag: "wx" } : undefined);
+    }
+    return {
+        type: "single",
+        data: {
+            origin,
+            directory,
+            exported: files.filter(({ existing, trigger }) => existing !== trigger.yaml).length,
+            unchanged: files.filter(({ existing, trigger }) => existing === trigger.yaml).length,
+        },
+        schema,
+    };
+}
+export function addHubExportCommand(parent, dependencies) {
+    addJsonOption(addHubResolutionHelp(parent
+        .command("export")
+        .description("Export active Hub triggers as one YAML file per trigger")
+        .argument("[directory]", "Destination directory", ".paseo/triggers")
+        .option("--hub <origin>", "Paseo Hub origin")
+        .option("--api-key <secret>", "Organization API key")
+        .option("--force", "Replace trigger files with different contents"))).action(withOutput(async (...args) => {
+        const directory = args[0];
+        const options = args.at(-2);
+        return runHubExport(directory, options, dependencies);
+    }));
+}
+async function readOptionalFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return undefined;
+        throw error;
+    }
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+//# sourceMappingURL=export.js.map

package/dist/commands/hub/help.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function addHubResolutionHelp(command: Command): Command;
+//# sourceMappingURL=help.d.ts.map

package/dist/commands/hub/help.js

@@ -0,0 +1,5 @@
+const resolutionHelp = "\nHub origin precedence: command origin/--hub, PASEO_HUB_URL, active stored login, then https://hub.paseo.sh.\nCredential precedence: --api-key, PASEO_HUB_API_KEY, then a stored login for the exact resolved origin.\n";
+export function addHubResolutionHelp(command) {
+    return command.addHelpText("after", resolutionHelp);
+}
+//# sourceMappingURL=help.js.map

package/dist/commands/hub/hub-client/index.d.ts

@@ -0,0 +1,22 @@
+import type { HubBundleFile } from "../deploy-bundle.js";
+import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubConfigurationResources, type HubProject, type HubTrigger, type HubTriggerInstallationResult, type HubTriggerValidationResult, type HubValidationResult } from "./internal/contracts.js";
+export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubConfigurationResources, HubProject, HubTrigger, HubTriggerInstallationResult, HubTriggerValidationResult, HubValidationResult, } from "./internal/contracts.js";
+interface HubConfigurationInput {
+    origin: string;
+    apiKey: string;
+    projectSlug: string;
+    files: readonly HubBundleFile[];
+}
+export declare class HubHttpClient {
+    startCliAuthorization(origin: string): Promise<CliAuthorization>;
+    pollCliAuthorization(origin: string, deviceCode: string, timeoutMilliseconds: number): Promise<CliAuthorizationPoll>;
+    listProjects(origin: string, apiKey: string): Promise<HubProject[]>;
+    listTriggers(origin: string, apiKey: string): Promise<HubTrigger[]>;
+    validateTrigger(origin: string, apiKey: string, yaml: string): Promise<HubTriggerValidationResult>;
+    installTrigger(origin: string, apiKey: string, yaml: string): Promise<HubTriggerInstallationResult>;
+    listConfigurationResources(origin: string, apiKey: string): Promise<HubConfigurationResources>;
+    installConfiguration(input: HubConfigurationInput): Promise<HubInstallResult>;
+    validateConfiguration(input: HubConfigurationInput): Promise<HubValidationResult>;
+    issueEnrollmentToken(origin: string, apiKey: string): Promise<string>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/hub/hub-client/index.js

@@ -0,0 +1,135 @@
+import { HubCommandError } from "../error.js";
+import { authorizationPollSchema, authorizationSchema, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, triggersResponseSchema, triggerInstallationResponseSchema, triggerValidationResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
+import { requestHub } from "./internal/transport.js";
+export class HubHttpClient {
+    startCliAuthorization(origin) {
+        return requestHub({
+            origin,
+            path: "/api/v1/cli-authorizations",
+            method: "POST",
+            body: {},
+            successStatus: 201,
+            schema: authorizationSchema,
+            failureMessage: "Hub CLI login could not be started",
+        });
+    }
+    async pollCliAuthorization(origin, deviceCode, timeoutMilliseconds) {
+        try {
+            return await requestHub({
+                origin,
+                path: "/api/v1/cli-authorizations/poll",
+                method: "POST",
+                body: { deviceCode },
+                successStatus: 200,
+                schema: authorizationPollSchema,
+                timeoutMilliseconds,
+                failureMessage: "Hub CLI login polling failed",
+            });
+        }
+        catch (error) {
+            if (error instanceof HubCommandError && error.code === "HUB_NETWORK_ERROR") {
+                return { status: "retry_later" };
+            }
+            throw error;
+        }
+    }
+    async listProjects(origin, apiKey) {
+        const response = await requestHub({
+            origin,
+            path: "/api/v1/projects",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: projectsResponseSchema,
+            failureMessage: "Hub project listing failed",
+        });
+        return response.projects;
+    }
+    async listTriggers(origin, apiKey) {
+        const response = await requestHub({
+            origin,
+            path: "/api/v1/triggers",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: triggersResponseSchema,
+            failureMessage: "Hub trigger export failed",
+        });
+        return response.triggers;
+    }
+    validateTrigger(origin, apiKey, yaml) {
+        return requestHub({
+            origin,
+            path: "/api/v1/triggers/validate",
+            method: "POST",
+            apiKey,
+            body: { yaml },
+            successStatus: 200,
+            schema: triggerValidationResponseSchema,
+            failureMessage: "Hub trigger validation failed",
+        });
+    }
+    installTrigger(origin, apiKey, yaml) {
+        return requestHub({
+            origin,
+            path: "/api/v1/triggers/install",
+            method: "POST",
+            apiKey,
+            body: { yaml },
+            successStatus: 201,
+            schema: triggerInstallationResponseSchema,
+            failureMessage: "Hub trigger deployment failed",
+        });
+    }
+    listConfigurationResources(origin, apiKey) {
+        return requestHub({
+            origin,
+            path: "/api/v1/configuration-resources",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: configurationResourcesSchema,
+            failureMessage: "Hub configuration resource listing failed",
+        });
+    }
+    installConfiguration(input) {
+        return requestHub({
+            origin: input.origin,
+            path: "/api/v1/configurations/install",
+            method: "POST",
+            apiKey: input.apiKey,
+            body: configurationBody(input),
+            successStatus: 201,
+            schema: installResponseSchema,
+            failureMessage: "Hub deployment failed",
+        });
+    }
+    validateConfiguration(input) {
+        return requestHub({
+            origin: input.origin,
+            path: "/api/v1/configurations/validate",
+            method: "POST",
+            apiKey: input.apiKey,
+            body: configurationBody(input),
+            successStatus: 200,
+            schema: validationResponseSchema,
+            failureMessage: "Hub configuration validation failed",
+        });
+    }
+    async issueEnrollmentToken(origin, apiKey) {
+        const response = await requestHub({
+            origin,
+            path: "/api/v1/daemons/enrollment-tokens",
+            method: "POST",
+            apiKey,
+            successStatus: 201,
+            schema: enrollmentTokenSchema,
+            failureMessage: "Hub daemon enrollment authorization failed",
+        });
+        return response.token;
+    }
+}
+function configurationBody(input) {
+    return { projectSlug: input.projectSlug, files: input.files };
+}
+//# sourceMappingURL=index.js.map