@getpaseo/cli 0.3.1 → 0.4.0-beta.2

package/dist/cli.js

@@ -1,8 +1,6 @@
 import { Command, Option } from "commander";
 import { createAgentCommand } from "./commands/agent/index.js";
 import { createDaemonCommand } from "./commands/daemon/index.js";
-import { createChatCommand } from "./commands/chat/index.js";
-import { createLoopCommand } from "./commands/loop/index.js";
 import { createPermitCommand } from "./commands/permit/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
 import { createScheduleCommand } from "./commands/schedule/index.js";
@@ -107,13 +105,10 @@ export function createCli() {
     program.addCommand(createDaemonCommand());
     program.addCommand(createHubCommand());
     // Chat commands
-    program.addCommand(createChatCommand());
     // Terminal commands
     program.addCommand(createTerminalCommand());
     // Workspace script commands
     program.addCommand(createScriptCommand());
-    // Loop commands
-    program.addCommand(createLoopCommand());
     // Schedule commands
     program.addCommand(createScheduleCommand());
     program.addCommand(createHeartbeatCommand());

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

@@ -1,5 +1,5 @@
 import type { Command } from "commander";
-import type { HubHttpClient } from "./client.js";
+import type { HubHttpClient } from "./hub-client/index.js";
 import type { HubCredentialStore } from "./credentials.js";
 import type { HubDaemonConnection } from "./daemon-client.js";
 import { type HubReporter } from "./reporter.js";

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

@@ -0,0 +1,16 @@
+export interface HubBundleFile {
+    path: string;
+    content: string;
+}
+export interface HubDeployBundle {
+    projectSlug: string;
+    files: readonly HubBundleFile[];
+    workflowCount: number;
+}
+interface DiscoverHubBundleInput {
+    cwd: string;
+    project?: string;
+}
+export declare function discoverHubBundle(input: DiscoverHubBundleInput): Promise<HubDeployBundle>;
+export {};
+//# sourceMappingURL=deploy-bundle.d.ts.map

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

@@ -0,0 +1,248 @@
+import { lstat, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { HubCommandError } from "./error.js";
+const HUB_RESOURCE_PATH = ".paseo/hub.yml";
+const LEGACY_TOML_PATH = ".paseo/hub.toml";
+const WORKFLOW_DIRECTORY = ".paseo/workflows";
+const PARTIAL_DIRECTORY = `${WORKFLOW_DIRECTORY}/partials`;
+const PROJECT_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+export async function discoverHubBundle(input) {
+    const projectSlug = requireProjectSlug(input.project);
+    const root = path.resolve(input.cwd);
+    await rejectLegacyToml(root);
+    const resource = await readBundleFile(root, HUB_RESOURCE_PATH, {
+        missingCode: "HUB_RESOURCE_MISSING",
+        missingMessage: `${HUB_RESOURCE_PATH} does not exist. Run this command from the project root.`,
+    });
+    const workflowNames = await discoverWorkflowNames(root);
+    const workflows = await Promise.all(workflowNames.map((name) => readBundleFile(root, `${WORKFLOW_DIRECTORY}/${name}`)));
+    const partialPaths = collectPartialPaths(workflows);
+    const partials = await Promise.all(partialPaths.map((file) => readBundleFile(root, file)));
+    const files = [resource, ...workflows, ...partials].toSorted(compareBundleFiles);
+    assertUniqueBundlePaths(files);
+    return { projectSlug, files, workflowCount: workflows.length };
+}
+function requireProjectSlug(project) {
+    if (project === undefined) {
+        throw new HubCommandError("HUB_PROJECT_REQUIRED", "Project is required. Pass --project <slug>.");
+    }
+    if (!PROJECT_SLUG_PATTERN.test(project)) {
+        throw new HubCommandError("HUB_INVALID_PROJECT", "Project must be a bare slug such as my-project.");
+    }
+    return project;
+}
+async function rejectLegacyToml(root) {
+    try {
+        await lstat(path.join(root, LEGACY_TOML_PATH));
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return;
+        throw unreadablePath(LEGACY_TOML_PATH);
+    }
+    throw new HubCommandError("HUB_CONFIGURATION_EXTENSION_UNSUPPORTED", `${LEGACY_TOML_PATH} is not supported. Use ${HUB_RESOURCE_PATH}.`);
+}
+async function discoverWorkflowNames(root) {
+    const directory = path.join(root, WORKFLOW_DIRECTORY);
+    await requireSafeDirectory(root, directory, WORKFLOW_DIRECTORY, {
+        missingCode: "HUB_WORKFLOW_DIRECTORY_MISSING",
+        missingMessage: `${WORKFLOW_DIRECTORY} does not exist.`,
+    });
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        throw unreadablePath(WORKFLOW_DIRECTORY);
+    }
+    const names = [];
+    for (const entry of entries.toSorted((left, right) => compareText(left.name, right.name))) {
+        const bundlePath = `${WORKFLOW_DIRECTORY}/${entry.name}`;
+        if (entry.isSymbolicLink())
+            throw unsafePath(bundlePath);
+        if (entry.isDirectory()) {
+            if (entry.name === "partials")
+                continue;
+            throw new HubCommandError("HUB_WORKFLOW_PATH_UNSUPPORTED", `${bundlePath} is not a direct-child .yml workflow.`);
+        }
+        if (!entry.isFile())
+            throw regularFileRequired(bundlePath);
+        if (!entry.name.endsWith(".yml")) {
+            throw new HubCommandError("HUB_WORKFLOW_EXTENSION_UNSUPPORTED", `${bundlePath} must use the .yml extension.`);
+        }
+        names.push(entry.name);
+    }
+    if (names.length === 0) {
+        throw new HubCommandError("HUB_WORKFLOW_MISSING", `${WORKFLOW_DIRECTORY} must contain at least one direct-child .yml workflow.`);
+    }
+    return names;
+}
+function collectPartialPaths(workflows) {
+    const paths = new Set();
+    for (const workflow of workflows) {
+        let document;
+        try {
+            document = YAML.parse(workflow.content);
+        }
+        catch {
+            throw new HubCommandError("HUB_WORKFLOW_INVALID_YAML", `${workflow.path} is not valid YAML.`);
+        }
+        if (!isRecord(document) || !Array.isArray(document["steps"]))
+            continue;
+        for (const step of document["steps"]) {
+            if (!isRecord(step) || !Array.isArray(step["prompt"]))
+                continue;
+            for (const block of step["prompt"]) {
+                if (!isRecord(block) || !Object.hasOwn(block, "include"))
+                    continue;
+                const include = block["include"];
+                if (typeof include !== "string") {
+                    throw invalidPartialPath(workflow.path, String(include));
+                }
+                paths.add(resolvePartialPath(workflow.path, include));
+            }
+        }
+    }
+    return [...paths].sort(compareText);
+}
+function resolvePartialPath(workflowPath, include) {
+    const decoded = decodePartialPath(workflowPath, include);
+    if (/^(?:[a-zA-Z]:[\\/]|[\\/]{1,2})/u.test(decoded)) {
+        throw invalidPartialPath(workflowPath, include);
+    }
+    const segments = decoded.replaceAll("\\", "/").split("/");
+    if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..") ||
+        segments[0] !== "partials") {
+        throw invalidPartialPath(workflowPath, include);
+    }
+    return `${WORKFLOW_DIRECTORY}/${segments.join("/")}`;
+}
+function decodePartialPath(workflowPath, include) {
+    let decoded = include;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        let next;
+        try {
+            next = decodeURIComponent(decoded);
+        }
+        catch {
+            throw invalidPartialPath(workflowPath, include);
+        }
+        if (next === decoded)
+            break;
+        decoded = next;
+    }
+    if (decoded.includes("\0") || /%[0-9a-f]{2}/iu.test(decoded)) {
+        throw invalidPartialPath(workflowPath, include);
+    }
+    return decoded;
+}
+async function readBundleFile(root, bundlePath, missing = {
+    missingCode: "HUB_BUNDLE_FILE_MISSING",
+    missingMessage: `${bundlePath} does not exist.`,
+}) {
+    const absolutePath = path.join(root, ...bundlePath.split("/"));
+    await rejectSymlinkComponents(root, absolutePath, bundlePath);
+    let stats;
+    try {
+        stats = await lstat(absolutePath);
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT") {
+            throw new HubCommandError(missing.missingCode, missing.missingMessage);
+        }
+        throw unreadablePath(bundlePath);
+    }
+    if (stats.isSymbolicLink())
+        throw unsafePath(bundlePath);
+    if (!stats.isFile())
+        throw regularFileRequired(bundlePath);
+    if (!hasReadPermission(stats.mode))
+        throw unreadablePath(bundlePath);
+    try {
+        return { path: bundlePath, content: (await readFile(absolutePath)).toString("utf8") };
+    }
+    catch {
+        throw unreadablePath(bundlePath);
+    }
+}
+async function requireSafeDirectory(root, absolutePath, bundlePath, missing) {
+    await rejectSymlinkComponents(root, absolutePath, bundlePath);
+    let stats;
+    try {
+        stats = await lstat(absolutePath);
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT") {
+            throw new HubCommandError(missing.missingCode, missing.missingMessage);
+        }
+        throw unreadablePath(bundlePath);
+    }
+    if (stats.isSymbolicLink())
+        throw unsafePath(bundlePath);
+    if (!stats.isDirectory()) {
+        throw new HubCommandError("HUB_WORKFLOW_DIRECTORY_INVALID", `${bundlePath} must be a directory.`);
+    }
+}
+async function rejectSymlinkComponents(root, target, bundlePath) {
+    const relative = path.relative(root, target);
+    let current = root;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            if ((await lstat(current)).isSymbolicLink())
+                throw unsafePath(bundlePath);
+        }
+        catch (error) {
+            if (error instanceof HubCommandError)
+                throw error;
+            if (errorCode(error) === "ENOENT")
+                return;
+            throw unreadablePath(bundlePath);
+        }
+    }
+}
+function assertUniqueBundlePaths(files) {
+    const seen = new Set();
+    for (const file of files) {
+        if (seen.has(file.path)) {
+            throw new HubCommandError("HUB_BUNDLE_PATH_DUPLICATE", `${file.path} appears more than once in the discovered bundle.`);
+        }
+        seen.add(file.path);
+    }
+}
+function invalidPartialPath(workflowPath, include) {
+    return new HubCommandError("HUB_PARTIAL_PATH_INVALID", `${workflowPath} includes an unsafe path outside ${PARTIAL_DIRECTORY}: ${include}`);
+}
+function unsafePath(bundlePath) {
+    return new HubCommandError("HUB_BUNDLE_UNSAFE_PATH", `${bundlePath} must not use a symlink.`);
+}
+function unreadablePath(bundlePath) {
+    return new HubCommandError("HUB_BUNDLE_UNREADABLE", `Could not read ${bundlePath}. Check the file and permissions.`);
+}
+function regularFileRequired(bundlePath) {
+    return new HubCommandError("HUB_BUNDLE_NOT_FILE", `${bundlePath} must be a regular file.`);
+}
+function compareBundleFiles(left, right) {
+    return compareText(left.path, right.path);
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+function hasReadPermission(mode) {
+    return (mode & 0o444) !== 0;
+}
+function errorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const code = Reflect.get(error, "code");
+    return typeof code === "string" ? code : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=deploy-bundle.js.map

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

@@ -1,10 +1,9 @@
 import type { Command } from "commander";
 import { type SingleResult } from "../../output/index.js";
-import { HubHttpClient, type HubInstallResult, type HubValidationResult } from "./client.js";
+import { HubHttpClient, type HubInstallResult, type HubValidationResult } from "./hub-client/index.js";
 import { type HubCredentialStore } from "./credentials.js";
 import { type HubReporter } from "./reporter.js";
 export interface HubDeployOptions {
-    file?: string;
     project?: string;
     hub?: string;
     apiKey?: string;
@@ -27,9 +26,11 @@ export interface HubDeployCommandDependencies {
 }
 interface HubDeployResult extends HubInstallResult {
     origin: string;
+    workflows: number;
 }
 interface HubDryRunResult extends HubValidationResult {
     origin: string;
+    workflows: number;
 }
 export declare function runHubDeploy(options: HubDeployOptions, environment?: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult>>;
 export declare function addHubDeployCommand(hub: Command, dependencies: HubDeployCommandDependencies): void;

package/dist/commands/hub/deploy.js

@@ -1,9 +1,9 @@
 import { withOutput } from "../../output/index.js";
 import { addJsonOption } from "../../utils/command-options.js";
 import { resolveHubCredential, resolveHubOrigin } from "./authority.js";
-import { HubHttpClient } from "./client.js";
+import { HubHttpClient, } from "./hub-client/index.js";
 import { PrivateHubCredentialStore } from "./credentials.js";
-import { resolveHubDeployInput } from "./deploy-input.js";
+import { discoverHubBundle } from "./deploy-bundle.js";
 import { processHubReporter, reportHubProgress } from "./reporter.js";
 import { addHubResolutionHelp } from "./help.js";
 const resultSchema = {
@@ -13,6 +13,7 @@ const resultSchema = {
         { header: "VERSION", field: "version" },
         { header: "VERSION ID", field: "versionId" },
         { header: "ACTIVE", field: "active" },
+        { header: "WORKFLOWS", field: "workflows" },
         { header: "HUB", field: "origin" },
     ],
 };
@@ -21,6 +22,7 @@ const validationSchema = {
     columns: [
         { header: "PROJECT", field: "projectSlug" },
         { header: "VALID", field: "valid" },
+        { header: "WORKFLOWS", field: "workflows" },
         { header: "HUB", field: "origin" },
     ],
 };
@@ -37,9 +39,8 @@ export async function runHubDeploy(options, environment = {
         credentials,
     };
     const origin = resolveHubOrigin(resolution);
-    const deployInput = await resolveHubDeployInput({
+    const deployInput = await discoverHubBundle({
         cwd: environment.cwd,
-        ...(options.file === undefined ? {} : { file: options.file }),
         ...(options.project === undefined ? {} : { project: options.project }),
     });
     const action = options.dryRun === true ? "Validating" : "Deploying";
@@ -52,23 +53,29 @@ export async function runHubDeploy(options, environment = {
     };
     if (options.dryRun === true) {
         const validated = await (environment.hub ?? new HubHttpClient()).validateConfiguration(request);
-        return { type: "single", data: { ...validated, origin }, schema: validationSchema };
+        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, origin }, schema: resultSchema };
+    return {
+        type: "single",
+        data: { ...deployed, workflows: deployInput.workflowCount, origin },
+        schema: resultSchema,
+    };
 }
 export function addHubDeployCommand(hub, dependencies) {
     addJsonOption(addHubResolutionHelp(hub
         .command("deploy")
-        .description("Install and activate a Hub configuration")
-        .argument("[file]", "Hub configuration YAML", ".paseo/hub.yml")
+        .description("Discover, validate, and activate the canonical .paseo Hub bundle")
         .option("-p, --project <slug>", "Target 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 file = args[0];
         const options = args.at(-2);
-        return runHubDeploy({ ...options, file }, {
+        return runHubDeploy(options, {
             cwd: dependencies.cwd(),
             env: dependencies.env,
             credentials: dependencies.credentials,

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

@@ -0,0 +1,18 @@
+import type { HubBundleFile } from "../deploy-bundle.js";
+import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubProject, type HubValidationResult } from "./internal/contracts.js";
+export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubProject, 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[]>;
+    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,88 @@
+import { HubCommandError } from "../error.js";
+import { authorizationPollSchema, authorizationSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, 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;
+    }
+    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

package/dist/commands/hub/{client.d.ts → hub-client/internal/contracts.d.ts}

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import type { HubDeployPartial } from "./deploy-input.js";
-declare const authorizationSchema: z.ZodObject<{
+export declare const authorizationSchema: z.ZodObject<{
     deviceCode: z.ZodString;
     userCode: z.ZodString;
     verificationUri: z.ZodURL;
@@ -8,7 +7,7 @@ declare const authorizationSchema: z.ZodObject<{
     expiresAt: z.ZodString;
     interval: z.ZodNumber;
 }, z.core.$strict>;
-declare const authorizationPollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const authorizationPollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     status: z.ZodLiteral<"pending">;
     interval: z.ZodNumber;
 }, z.core.$strict>, z.ZodObject<{
@@ -36,36 +35,31 @@ declare const projectSchema: z.ZodObject<{
     slug: z.ZodString;
     name: z.ZodString;
 }, z.core.$strict>;
-declare const installResponseSchema: z.ZodObject<{
+export declare const projectsResponseSchema: z.ZodObject<{
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const installResponseSchema: z.ZodObject<{
     projectSlug: z.ZodString;
     version: z.ZodNumber;
     versionId: z.ZodString;
     active: z.ZodLiteral<true>;
 }, z.core.$strict>;
-declare const validationResponseSchema: z.ZodObject<{
+export declare const validationResponseSchema: z.ZodObject<{
     projectSlug: z.ZodString;
     valid: z.ZodLiteral<true>;
 }, z.core.$strict>;
+export declare const enrollmentTokenSchema: z.ZodObject<{
+    token: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strict>;
 export type CliAuthorization = z.infer<typeof authorizationSchema>;
 export type CliAuthorizationPoll = z.infer<typeof authorizationPollSchema>;
 export type HubProject = z.infer<typeof projectSchema>;
 export type HubInstallResult = z.infer<typeof installResponseSchema>;
 export type HubValidationResult = z.infer<typeof validationResponseSchema>;
-interface HubConfigurationInput {
-    origin: string;
-    apiKey: string;
-    projectSlug: string;
-    yaml: string;
-    partials?: readonly HubDeployPartial[];
-}
-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[]>;
-    installConfiguration(input: HubConfigurationInput): Promise<HubInstallResult>;
-    validateConfiguration(input: HubConfigurationInput): Promise<HubValidationResult>;
-    issueEnrollmentToken(origin: string, apiKey: string): Promise<string>;
-    private request;
-}
 export {};
-//# sourceMappingURL=client.d.ts.map
+//# sourceMappingURL=contracts.d.ts.map

package/dist/commands/hub/hub-client/internal/contracts.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+const activationUrlSchema = z.url({ protocol: /^https?$/u });
+export const authorizationSchema = z
+    .object({
+    deviceCode: z.string().min(32),
+    userCode: z.string().min(1),
+    verificationUri: activationUrlSchema,
+    verificationUriComplete: activationUrlSchema,
+    expiresAt: z.string().datetime(),
+    interval: z.number().int().min(1),
+})
+    .strict();
+export const authorizationPollSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("pending"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(1) }).strict(),
+    z
+        .object({
+        status: z.literal("authorized"),
+        interval: z.number().int().min(1),
+        credential: z.string().min(32),
+        organizationId: z.string().min(1),
+    })
+        .strict(),
+    z.object({ status: z.literal("denied"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("expired"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("disclosed"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("retry_later") }).strict(),
+]);
+const projectSchema = z
+    .object({ id: z.string().uuid(), slug: z.string().min(1), name: z.string().min(1) })
+    .strict();
+export const projectsResponseSchema = z.object({ projects: z.array(projectSchema) }).strict();
+export const installResponseSchema = z
+    .object({
+    projectSlug: z.string().min(1),
+    version: z.number().int().positive(),
+    versionId: z.string().uuid(),
+    active: z.literal(true),
+})
+    .strict();
+export const validationResponseSchema = z
+    .object({ projectSlug: z.string().min(1), valid: z.literal(true) })
+    .strict();
+export const enrollmentTokenSchema = z
+    .object({ token: z.string().min(32), expiresAt: z.string().datetime() })
+    .strict();
+//# sourceMappingURL=contracts.js.map

package/dist/commands/hub/hub-client/internal/problem.d.ts

@@ -0,0 +1,3 @@
+import { HubCommandError } from "../../error.js";
+export declare function hubRequestFailure(response: Response, failureMessage: string, apiKey: string | undefined): Promise<HubCommandError>;
+//# sourceMappingURL=problem.d.ts.map