@getpaseo/cli 0.3.0-beta.4 → 0.3.1

package/dist/commands/hub/{device-authorization.d.ts → login-flow.d.ts}

@@ -1,5 +1,5 @@
-import { type CloudDeviceAuthorization } from "./cloud-device-authorization.js";
-export interface AuthorizationWaiter {
+import type { HubHttpClient } from "./client.js";
+export interface LoginWaiter {
     wait(milliseconds: number): Promise<void>;
     now(): number;
 }
@@ -17,21 +17,18 @@ export declare class SystemBrowser implements BrowserOpener {
     constructor(options?: SystemBrowserOptions);
     open(url: string): Promise<void>;
 }
-export interface AuthorizationReporter {
-    instructions(verificationUri: string, userCode: string): void;
-}
-interface DeviceAuthorizationWorkflowOptions {
-    cloud: CloudDeviceAuthorization;
-    waiter: AuthorizationWaiter;
+interface CliLoginFlowOptions {
+    hub: Pick<HubHttpClient, "startCliAuthorization" | "pollCliAuthorization">;
+    waiter: LoginWaiter;
     browser: BrowserOpener;
-    reporter: AuthorizationReporter;
-    openBrowser?: boolean;
+    instructions(verificationUri: string, userCode: string): void;
+    openBrowser: boolean;
 }
-export declare class DeviceAuthorizationWorkflow {
+export declare class CliLoginFlow {
     private readonly options;
-    constructor(options: DeviceAuthorizationWorkflowOptions);
-    authorize(hubUrl: string, displayName: string): Promise<string>;
+    constructor(options: CliLoginFlowOptions);
+    authorize(origin: string): Promise<string>;
 }
-export declare function createDeviceAuthorizationWorkflow(): DeviceAuthorizationWorkflow;
+export declare function createCliLoginFlow(hub: HubHttpClient): CliLoginFlow;
 export {};
-//# sourceMappingURL=device-authorization.d.ts.map
+//# sourceMappingURL=login-flow.d.ts.map

package/dist/commands/hub/login-flow.js

@@ -0,0 +1,78 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+export class SystemBrowser {
+    constructor(options = {}) {
+        this.hostPlatform = options.hostPlatform ?? platform();
+        this.launch = options.launch ?? launchDetached;
+    }
+    async open(url) {
+        if (this.hostPlatform === "win32") {
+            await this.launch("rundll32.exe", ["url.dll,FileProtocolHandler", url]);
+            return;
+        }
+        await this.launch(this.hostPlatform === "darwin" ? "open" : "xdg-open", [url]);
+    }
+}
+export class CliLoginFlow {
+    constructor(options) {
+        this.options = options;
+    }
+    async authorize(origin) {
+        const authorization = await this.options.hub.startCliAuthorization(origin);
+        this.options.instructions(authorization.verificationUri, authorization.userCode);
+        if (this.options.openBrowser) {
+            await this.options.browser.open(authorization.verificationUriComplete).catch(() => undefined);
+        }
+        let interval = authorization.interval;
+        const expiresAt = Date.parse(authorization.expiresAt);
+        while (true) {
+            const remaining = expiresAt - this.options.waiter.now();
+            if (remaining <= 0)
+                throw new Error("Hub CLI login expired");
+            await this.options.waiter.wait(Math.min(interval * 1000, remaining));
+            const pollLifetime = expiresAt - this.options.waiter.now();
+            if (pollLifetime <= 0)
+                throw new Error("Hub CLI login expired");
+            const outcome = await this.options.hub.pollCliAuthorization(origin, authorization.deviceCode, pollLifetime);
+            const credential = approvedCredential(outcome);
+            if (credential !== null)
+                return credential;
+            if (outcome.status === "denied")
+                throw new Error("Hub CLI login was denied");
+            if (outcome.status === "expired")
+                throw new Error("Hub CLI login expired");
+            if (outcome.status === "disclosed")
+                throw new Error("Hub CLI login was already completed");
+            if (outcome.status !== "retry_later")
+                interval = outcome.interval;
+        }
+    }
+}
+export function createCliLoginFlow(hub) {
+    return new CliLoginFlow({
+        hub,
+        waiter: {
+            wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+            now: Date.now,
+        },
+        browser: new SystemBrowser(),
+        instructions(verificationUri, userCode) {
+            process.stderr.write(`Open ${verificationUri} and enter code ${userCode}\n`);
+        },
+        openBrowser: process.stderr.isTTY === true,
+    });
+}
+function approvedCredential(outcome) {
+    return outcome.status === "authorized" ? outcome.credential : null;
+}
+async function launchDetached(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { detached: true, shell: false, stdio: "ignore" });
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+        child.once("error", reject);
+    });
+}
+//# sourceMappingURL=login-flow.js.map

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

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import type { HubCredentialStore } from "./credentials.js";
+import type { CliLoginFlow } from "./login-flow.js";
+import { type HubReporter } from "./reporter.js";
+interface HubLoginResult {
+    origin: string;
+    status: "logged_in";
+}
+interface HubLoginDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    flow: Pick<CliLoginFlow, "authorize">;
+    reporter: HubReporter;
+}
+export declare function runHubLogin(originInput: string | undefined, options: {
+    json?: boolean;
+}, dependencies: HubLoginDependencies): Promise<SingleResult<HubLoginResult>>;
+export declare function addHubLoginCommand(parent: Command, dependencies: HubLoginDependencies): void;
+export {};
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/hub/login.js

@@ -0,0 +1,34 @@
+import { withOutput } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+import { resolveHubOrigin } from "./authority.js";
+import { reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
+const schema = {
+    idField: "origin",
+    columns: [
+        { header: "HUB", field: "origin" },
+        { header: "STATUS", field: "status" },
+    ],
+};
+export async function runHubLogin(originInput, options, dependencies) {
+    const origin = resolveHubOrigin({
+        options: { origin: originInput },
+        env: dependencies.env,
+        credentials: dependencies.credentials,
+    });
+    reportHubProgress(dependencies.reporter, options, `Logging in to ${origin}`);
+    const credential = await dependencies.flow.authorize(origin);
+    dependencies.credentials.save({ origin, credential });
+    return { type: "single", data: { origin, status: "logged_in" }, schema };
+}
+export function addHubLoginCommand(parent, dependencies) {
+    addJsonOption(addHubResolutionHelp(parent
+        .command("login")
+        .description("Log in to a Paseo Hub for CLI access")
+        .argument("[origin]", "Paseo Hub origin"))).action(withOutput(async (...args) => {
+        const origin = args[0];
+        const options = args.at(-2);
+        return runHubLogin(origin, options, dependencies);
+    }));
+}
+//# sourceMappingURL=login.js.map

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

@@ -0,0 +1,31 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import type { HubCredentialStore } from "./credentials.js";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import { type HubReporter } from "./reporter.js";
+interface HubLogoutResult {
+    origin: string | null;
+    status: "logged_out" | "not_logged_in";
+    daemonDisconnected: boolean;
+}
+interface HubLogoutOptions {
+    disconnectDaemon?: boolean;
+    force?: boolean;
+    host?: string;
+    json?: boolean;
+}
+interface HubLogoutDependencies {
+    credentials: HubCredentialStore;
+    daemon: HubDaemonConnection;
+    isInteractive(): boolean;
+    confirmDisconnect(origin: string): Promise<boolean>;
+    reporter: HubReporter;
+}
+export declare function runHubLogout(options: HubLogoutOptions, dependencies: HubLogoutDependencies): Promise<SingleResult<HubLogoutResult>>;
+export declare function addHubLogoutCommand(parent: Command, dependencies: HubLogoutDependencies): void;
+export declare const productionLogoutPrompt: {
+    isInteractive: () => boolean;
+    confirmDisconnect(origin: string): Promise<boolean>;
+};
+export {};
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/hub/logout.js

@@ -0,0 +1,65 @@
+import { confirm, isCancel } from "@clack/prompts";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { withHubDaemon } from "./daemon-client.js";
+import { reportHubProgress } from "./reporter.js";
+const schema = {
+    idField: "status",
+    columns: [
+        { header: "HUB", field: "origin" },
+        { header: "STATUS", field: "status" },
+        { header: "DAEMON DISCONNECTED", field: "daemonDisconnected" },
+    ],
+};
+export async function runHubLogout(options, dependencies) {
+    const active = dependencies.credentials.active();
+    if (active === null) {
+        return logoutResult({ origin: null, status: "not_logged_in", daemonDisconnected: false });
+    }
+    reportHubProgress(dependencies.reporter, options, `Logging out of ${active.origin}`);
+    const mayPrompt = options.json !== true && dependencies.isInteractive();
+    let daemonStatus = null;
+    const shouldInspectDaemon = options.disconnectDaemon === true || mayPrompt;
+    if (shouldInspectDaemon) {
+        daemonStatus = await withHubDaemon(dependencies.daemon, options.host, async (daemon) => daemon.getHubStatus().then((response) => response.status));
+    }
+    const sameHub = daemonStatus?.hubOrigin === active.origin;
+    let shouldDisconnect = options.disconnectDaemon === true && sameHub;
+    if (options.disconnectDaemon !== true && mayPrompt && sameHub) {
+        shouldDisconnect = await dependencies.confirmDisconnect(active.origin);
+    }
+    if (!shouldDisconnect) {
+        dependencies.credentials.logoutActive();
+        return logoutResult({ origin: active.origin, status: "logged_out", daemonDisconnected: false });
+    }
+    reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${active.origin}`);
+    await withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
+        await daemon.disconnectHub(options.force ?? false);
+    });
+    dependencies.credentials.logoutActive();
+    return logoutResult({ origin: active.origin, status: "logged_out", daemonDisconnected: true });
+}
+export function addHubLogoutCommand(parent, dependencies) {
+    addJsonAndDaemonHostOptions(parent
+        .command("logout")
+        .description("Remove the active stored Hub CLI login")
+        .option("--disconnect-daemon", "Also disconnect a daemon related to the same Hub")
+        .option("--force", "Remove daemon authority even if Hub is offline")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubLogout(options, dependencies);
+    }));
+}
+export const productionLogoutPrompt = {
+    isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    async confirmDisconnect(origin) {
+        const answer = await confirm({
+            message: `Disconnect this daemon from ${origin}?`,
+            initialValue: false,
+        });
+        return !isCancel(answer) && answer;
+    },
+};
+function logoutResult(data) {
+    return { type: "single", data, schema };
+}
+//# sourceMappingURL=logout.js.map

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

@@ -0,0 +1,2 @@
+export declare function normalizeHubOrigin(value: string): string;
+//# sourceMappingURL=origin.d.ts.map

package/dist/commands/hub/origin.js

@@ -0,0 +1,27 @@
+import { HubCommandError } from "./error.js";
+export function normalizeHubOrigin(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw invalidHubOrigin();
+    }
+    if (!["http:", "https:"].includes(url.protocol) ||
+        (url.protocol === "http:" && !isLoopbackHostname(url.hostname)) ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash) {
+        throw invalidHubOrigin();
+    }
+    return url.origin;
+}
+function isLoopbackHostname(hostname) {
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function invalidHubOrigin() {
+    return new HubCommandError("HUB_INVALID_ORIGIN", "Hub URL must be an HTTPS origin without credentials, path, query, or hash. HTTP is allowed only for localhost, 127.0.0.1, or [::1].");
+}
+//# sourceMappingURL=origin.js.map

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

@@ -0,0 +1,24 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import type { HubHttpClient, HubProject } from "./client.js";
+import type { HubCredentialStore } from "./credentials.js";
+import { type HubReporter } from "./reporter.js";
+interface HubProjectsResult {
+    origin: string;
+    projects: HubProject[];
+}
+export interface HubProjectsOptions {
+    hub?: string;
+    apiKey?: string;
+    json?: boolean;
+}
+interface HubProjectsDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: Pick<HubHttpClient, "listProjects">;
+    reporter: HubReporter;
+}
+export declare function runHubProjects(options: HubProjectsOptions, dependencies: HubProjectsDependencies): Promise<SingleResult<HubProjectsResult>>;
+export declare function addHubProjectsCommand(parent: Command, dependencies: HubProjectsDependencies): void;
+export {};
+//# sourceMappingURL=projects.d.ts.map

package/dist/commands/hub/projects.js

@@ -0,0 +1,49 @@
+import { render, withOutput } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+import { resolveHubCredential, resolveHubOrigin } from "./authority.js";
+import { reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
+const projectSchema = {
+    idField: "id",
+    columns: [
+        { header: "SLUG", field: "slug" },
+        { header: "NAME", field: "name" },
+        { header: "ID", field: "id" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+const schema = {
+    idField: "origin",
+    columns: [
+        { header: "HUB", field: "origin" },
+        { header: "PROJECTS", field: (result) => result.projects.length },
+    ],
+    renderHuman(result, options) {
+        const results = result.type === "single" ? [result.data] : result.data;
+        const data = results.flatMap((entry) => entry.projects.map((project) => ({ ...project, origin: entry.origin })));
+        return render({ type: "list", data, schema: projectSchema }, options);
+    },
+};
+export async function runHubProjects(options, dependencies) {
+    const resolution = {
+        options: { origin: options.hub, apiKey: options.apiKey },
+        env: dependencies.env,
+        credentials: dependencies.credentials,
+    };
+    const origin = resolveHubOrigin(resolution);
+    reportHubProgress(dependencies.reporter, options, `Listing projects from ${origin}`);
+    const credential = resolveHubCredential({ ...resolution, origin });
+    const projects = await dependencies.hub.listProjects(origin, credential);
+    return { type: "single", data: { origin, projects }, schema };
+}
+export function addHubProjectsCommand(parent, dependencies) {
+    addJsonOption(addHubResolutionHelp(parent
+        .command("projects")
+        .description("List projects for the authenticated Hub organization")
+        .option("--hub <origin>", "Paseo Hub origin")
+        .option("--api-key <secret>", "Organization API key"))).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubProjects(options, dependencies);
+    }));
+}
+//# sourceMappingURL=projects.js.map

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

@@ -0,0 +1,10 @@
+export interface HubReporter {
+    progress(message: string): void;
+}
+export declare const processHubReporter: HubReporter;
+interface HubReportOptions {
+    json?: boolean;
+}
+export declare function reportHubProgress(reporter: HubReporter, options: HubReportOptions, message: string): void;
+export {};
+//# sourceMappingURL=reporter.d.ts.map

package/dist/commands/hub/reporter.js

@@ -0,0 +1,11 @@
+export const processHubReporter = {
+    progress(message) {
+        process.stderr.write(`${message}\n`);
+    },
+};
+export function reportHubProgress(reporter, options, message) {
+    if (options.json === true)
+        return;
+    reporter.progress(message);
+}
+//# sourceMappingURL=reporter.js.map

package/dist/commands/hub/status-output.d.ts

@@ -0,0 +1,13 @@
+import type { ListResult } from "../../output/index.js";
+import type { HubStatus } from "./daemon-client.js";
+export interface HubRow {
+    state: string;
+    daemonId: string | null;
+    hub: string | null;
+    scopes: string;
+    connectedAt: string | null;
+    error: string | null;
+    warning?: string;
+}
+export declare function hubStatusResult(status: HubStatus, warning?: string, reportedHubOrigin?: string | null): ListResult<HubRow>;
+//# sourceMappingURL=status-output.d.ts.map

package/dist/commands/hub/status-output.js

@@ -0,0 +1,30 @@
+const schema = {
+    idField: "state",
+    columns: [
+        { header: "STATE", field: "state" },
+        { header: "HUB", field: "hub" },
+        { header: "DAEMON", field: "daemonId" },
+        { header: "SCOPES", field: "scopes" },
+        { header: "CONNECTED", field: "connectedAt" },
+        { header: "ERROR", field: "error" },
+        { header: "WARNING", field: "warning" },
+    ],
+};
+export function hubStatusResult(status, warning, reportedHubOrigin = status.hubOrigin) {
+    return {
+        type: "list",
+        data: [
+            {
+                state: status.state,
+                daemonId: status.daemonId,
+                hub: reportedHubOrigin,
+                scopes: status.scopes.join(", "),
+                connectedAt: status.connectedAt,
+                error: status.lastError,
+                warning,
+            },
+        ],
+        schema,
+    };
+}
+//# sourceMappingURL=status-output.js.map

package/dist/commands/schedule/types.d.ts

@@ -22,10 +22,7 @@ export type ScheduleTarget = {
         model?: string;
         thinkingOptionId?: string;
         title?: string | null;
-        approvalPolicy?: string;
-        sandboxMode?: string;
-        networkAccess?: boolean;
-        webSearch?: boolean;
+        providerOptions?: Record<string, unknown>;
     };
 };
 export interface ScheduleRunRecord {

package/dist/output/types.d.ts

@@ -58,7 +58,7 @@ export interface ListResult<T> {
     schema: OutputSchema<T>;
 }
 /** Union type for all command results */
-export type AnyCommandResult<T> = SingleResult<T> | ListResult<T>;
+export type AnyCommandResult<T> = T extends unknown ? SingleResult<T> | ListResult<T> : never;
 /** Base interface for command results (deprecated, use SingleResult or ListResult) */
 export type CommandResult<T> = SingleResult<T> | ListResult<T>;
 /** Structured error for command failures */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.3.0-beta.4",
+  "version": "0.3.1",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.3.0-beta.4",
-    "@getpaseo/protocol": "0.3.0-beta.4",
-    "@getpaseo/server": "0.3.0-beta.4",
+    "@getpaseo/client": "0.3.1",
+    "@getpaseo/protocol": "0.3.1",
+    "@getpaseo/server": "0.3.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",

package/dist/commands/hub/cloud-device-authorization.d.ts

@@ -1,45 +0,0 @@
-import { z } from "zod";
-declare const authorizationSchema: z.ZodObject<{
-    deviceCode: z.ZodString;
-    userCode: z.ZodString;
-    verificationUri: z.ZodURL;
-    verificationUriComplete: z.ZodURL;
-    expiresAt: z.ZodString;
-    interval: z.ZodNumber;
-}, z.core.$strip>;
-declare const pollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    status: z.ZodLiteral<"pending">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"slow_down">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"approved">;
-    interval: z.ZodNumber;
-    enrollmentToken: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"denied">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"expired">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"enrolled">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"retry_later">;
-}, z.core.$strip>], "status">;
-export type DeviceAuthorization = z.infer<typeof authorizationSchema>;
-export type DeviceAuthorizationPoll = z.infer<typeof pollSchema>;
-export interface CloudDeviceAuthorization {
-    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
-    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
-}
-export declare class CloudDeviceAuthorizationClient implements CloudDeviceAuthorization {
-    private readonly startTimeoutMilliseconds;
-    constructor(startTimeoutMilliseconds?: number);
-    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
-    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
-}
-export {};
-//# sourceMappingURL=cloud-device-authorization.d.ts.map

package/dist/commands/hub/cloud-device-authorization.js

@@ -1,92 +0,0 @@
-import { z } from "zod";
-const START_TIMEOUT_MS = 15000;
-const activationUrlSchema = z.url({ protocol: /^https?$/u });
-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(5),
-});
-const pollSchema = z.discriminatedUnion("status", [
-    z.object({ status: z.literal("pending"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(5) }),
-    z.object({
-        status: z.literal("approved"),
-        interval: z.number().int().min(5),
-        enrollmentToken: z.string().min(32),
-    }),
-    z.object({ status: z.literal("denied"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("expired"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("enrolled"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("retry_later") }),
-]);
-export class CloudDeviceAuthorizationClient {
-    constructor(startTimeoutMilliseconds = START_TIMEOUT_MS) {
-        this.startTimeoutMilliseconds = startTimeoutMilliseconds;
-    }
-    async start(hubUrl, displayName) {
-        const signal = AbortSignal.timeout(this.startTimeoutMilliseconds);
-        try {
-            const response = await fetch(endpoint(hubUrl, "/api/device-authorizations/"), {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ displayName }),
-                signal,
-            });
-            if (!response.ok)
-                throw new Error(`Cloud registration failed (${response.status})`);
-            return authorizationSchema.parse(await response.json());
-        }
-        catch (error) {
-            if (signal.aborted) {
-                throw new Error("Cloud registration start timed out", { cause: error });
-            }
-            throw error;
-        }
-    }
-    async poll(hubUrl, deviceCode, timeoutMilliseconds) {
-        const signal = AbortSignal.timeout(timeoutMilliseconds);
-        let response;
-        try {
-            response = await fetch(endpoint(hubUrl, "/api/device-authorizations/poll"), {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ deviceCode }),
-                signal,
-            });
-        }
-        catch {
-            return { status: "retry_later" };
-        }
-        if ([408, 425, 429].includes(response.status) || response.status >= 500) {
-            return { status: "retry_later" };
-        }
-        if (!response.ok)
-            throw new Error(`Cloud registration poll failed (${response.status})`);
-        let body;
-        try {
-            body = await response.json();
-        }
-        catch (error) {
-            if (signal.aborted || error instanceof TypeError)
-                return { status: "retry_later" };
-            throw error;
-        }
-        return pollSchema.parse(body);
-    }
-}
-function endpoint(hubUrl, pathname) {
-    const url = new URL(hubUrl);
-    if (!["http:", "https:"].includes(url.protocol) ||
-        url.username ||
-        url.password ||
-        url.search ||
-        url.hash) {
-        throw new Error("Hub URL must be an HTTP or HTTPS origin without credentials or a query");
-    }
-    url.pathname = `${url.pathname.replace(/\/$/u, "")}${pathname}`;
-    return url.toString();
-}
-//# sourceMappingURL=cloud-device-authorization.js.map