@getpaseo/cli 0.3.0 → 0.3.1

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

@@ -0,0 +1,17 @@
+import type { HubCredentialStore } from "./credentials.js";
+export interface HubAuthorityOptions {
+    origin?: string;
+    apiKey?: string;
+}
+interface ResolveHubInput {
+    options: HubAuthorityOptions;
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+}
+export declare const DEFAULT_HUB_ORIGIN = "https://hub.paseo.sh";
+export declare function resolveHubOrigin(input: ResolveHubInput): string;
+export declare function resolveHubCredential(input: ResolveHubInput & {
+    origin: string;
+}): string;
+export {};
+//# sourceMappingURL=authority.d.ts.map

package/dist/commands/hub/authority.js

@@ -0,0 +1,18 @@
+import { HubCommandError } from "./error.js";
+import { normalizeHubOrigin } from "./origin.js";
+export const DEFAULT_HUB_ORIGIN = "https://hub.paseo.sh";
+export function resolveHubOrigin(input) {
+    const configuredOrigin = input.options.origin ?? input.env.PASEO_HUB_URL;
+    const selectedOrigin = configuredOrigin ?? input.credentials.active()?.origin ?? DEFAULT_HUB_ORIGIN;
+    return normalizeHubOrigin(selectedOrigin);
+}
+export function resolveHubCredential(input) {
+    const explicitCredential = input.options.apiKey ?? input.env.PASEO_HUB_API_KEY;
+    if (explicitCredential !== undefined)
+        return explicitCredential;
+    const stored = input.credentials.get(input.origin);
+    if (stored !== null)
+        return stored.credential;
+    throw new HubCommandError("HUB_API_KEY_REQUIRED", `No stored Hub login matches ${input.origin}. Run \`paseo hub login ${input.origin}\`, pass --api-key <secret>, or set PASEO_HUB_API_KEY.`);
+}
+//# sourceMappingURL=authority.js.map

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

@@ -1,19 +1,71 @@
 import { z } from "zod";
 import type { HubDeployPartial } from "./deploy-input.js";
+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.$strict>;
+declare const authorizationPollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"pending">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"slow_down">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"authorized">;
+    interval: z.ZodNumber;
+    credential: z.ZodString;
+    organizationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"denied">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"expired">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"disclosed">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"retry_later">;
+}, z.core.$strict>], "status">;
+declare const projectSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
 declare const installResponseSchema: z.ZodObject<{
     projectSlug: z.ZodString;
     version: z.ZodNumber;
     versionId: z.ZodString;
-    active: z.ZodBoolean;
+    active: z.ZodLiteral<true>;
 }, z.core.$strict>;
+declare const validationResponseSchema: z.ZodObject<{
+    projectSlug: z.ZodString;
+    valid: z.ZodLiteral<true>;
+}, 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>;
-interface InstallHubConfigurationInput {
+export type HubValidationResult = z.infer<typeof validationResponseSchema>;
+interface HubConfigurationInput {
     origin: string;
     apiKey: string;
     projectSlug: string;
     yaml: string;
     partials?: readonly HubDeployPartial[];
 }
-export declare function installHubConfiguration(input: InstallHubConfigurationInput): Promise<HubInstallResult>;
+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

package/dist/commands/hub/client.js

@@ -1,13 +1,50 @@
 import { z } from "zod";
-import { HubDeployError } from "./error.js";
+import { HubCommandError } from "./error.js";
+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(1),
+})
+    .strict();
+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();
+const projectsResponseSchema = z.object({ projects: z.array(projectSchema) }).strict();
 const installResponseSchema = z
     .object({
     projectSlug: z.string().min(1),
     version: z.number().int().positive(),
     versionId: z.string().uuid(),
-    active: z.boolean(),
+    active: z.literal(true),
 })
     .strict();
+const validationResponseSchema = z
+    .object({ projectSlug: z.string().min(1), valid: z.literal(true) })
+    .strict();
+const enrollmentTokenSchema = z
+    .object({ token: z.string().min(32), expiresAt: z.string().datetime() })
+    .strict();
 const issuePathSchema = z.union([z.string(), z.array(z.union([z.string(), z.number()]))]);
 const fieldIssueSchema = z.object({
     field: z.string().optional(),
@@ -25,60 +62,145 @@ const problemSchema = z.object({
         .optional(),
     issues: z.array(fieldIssueSchema).optional(),
 });
-export async function installHubConfiguration(input) {
-    let response;
-    try {
-        response = await fetch(`${input.origin}/api/v1/configurations/install`, {
+export class HubHttpClient {
+    async startCliAuthorization(origin) {
+        return this.request({
+            origin,
+            path: "/api/v1/cli-authorizations",
             method: "POST",
-            headers: {
-                authorization: `Bearer ${input.apiKey}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({
-                projectSlug: input.projectSlug,
-                yaml: input.yaml,
-                ...(input.partials === undefined || input.partials.length === 0
-                    ? {}
-                    : { partials: input.partials }),
-            }),
+            body: {},
+            successStatus: 201,
+            schema: authorizationSchema,
+            failureMessage: "Hub CLI login could not be started",
         });
     }
-    catch {
-        throw new HubDeployError("HUB_NETWORK_ERROR", `Could not reach Paseo Hub at ${input.origin}. Check the Hub URL and network connection.`);
+    async pollCliAuthorization(origin, deviceCode, timeoutMilliseconds) {
+        try {
+            return await this.request({
+                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;
+        }
     }
-    if (response.status !== 201) {
-        throw await deploymentFailure(response, input.apiKey);
+    async listProjects(origin, apiKey) {
+        const response = await this.request({
+            origin,
+            path: "/api/v1/projects",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: projectsResponseSchema,
+            failureMessage: "Hub project listing failed",
+        });
+        return response.projects;
     }
-    try {
-        return installResponseSchema.parse(await response.json());
+    installConfiguration(input) {
+        return this.request({
+            origin: input.origin,
+            path: "/api/v1/configurations/install",
+            method: "POST",
+            apiKey: input.apiKey,
+            body: configurationBody(input),
+            successStatus: 201,
+            schema: installResponseSchema,
+            failureMessage: "Hub deployment failed",
+        });
     }
-    catch {
-        throw new HubDeployError("HUB_INVALID_RESPONSE", "Hub returned a malformed deployment response.");
+    validateConfiguration(input) {
+        return this.request({
+            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 this.request({
+            origin,
+            path: "/api/v1/daemons/enrollment-tokens",
+            method: "POST",
+            apiKey,
+            successStatus: 201,
+            schema: enrollmentTokenSchema,
+            failureMessage: "Hub daemon enrollment authorization failed",
+        });
+        return response.token;
+    }
+    async request(input) {
+        const signal = AbortSignal.timeout(input.timeoutMilliseconds ?? 15000);
+        let response;
+        try {
+            response = await fetch(`${input.origin}${input.path}`, {
+                method: input.method,
+                headers: {
+                    ...(input.apiKey === undefined ? {} : { authorization: `Bearer ${input.apiKey}` }),
+                    ...(input.body === undefined ? {} : { "content-type": "application/json" }),
+                },
+                ...(input.body === undefined ? {} : { body: JSON.stringify(input.body) }),
+                signal,
+            });
+        }
+        catch {
+            throw new HubCommandError("HUB_NETWORK_ERROR", `Could not reach Paseo Hub at ${input.origin}. Check the Hub URL and network connection.`);
+        }
+        if (response.status !== input.successStatus) {
+            throw await requestFailure(response, input.failureMessage, input.apiKey);
+        }
+        try {
+            return input.schema.parse(await response.json());
+        }
+        catch {
+            throw new HubCommandError("HUB_INVALID_RESPONSE", "Hub returned a malformed response.");
+        }
     }
 }
-async function deploymentFailure(response, apiKey) {
+function configurationBody(input) {
+    return {
+        projectSlug: input.projectSlug,
+        yaml: input.yaml,
+        ...(input.partials === undefined || input.partials.length === 0
+            ? {}
+            : { partials: input.partials }),
+    };
+}
+async function requestFailure(response, failureMessage, apiKey) {
     const contentType = response.headers.get("content-type") ?? "";
     if (!contentType.toLowerCase().includes("application/problem+json")) {
-        return new HubDeployError("HUB_REQUEST_FAILED", `Hub deployment failed with HTTP ${response.status}.`);
+        return new HubCommandError("HUB_REQUEST_FAILED", `${failureMessage} with HTTP ${response.status}.`);
     }
     let body;
     try {
         body = await response.json();
     }
     catch {
-        return new HubDeployError("HUB_INVALID_RESPONSE", `Hub returned malformed problem details for HTTP ${response.status}.`);
+        return new HubCommandError("HUB_INVALID_RESPONSE", `Hub returned malformed problem details for HTTP ${response.status}.`);
     }
     const parsed = problemSchema.safeParse(body);
     if (!parsed.success ||
         (parsed.data.status !== undefined && parsed.data.status !== response.status)) {
-        return new HubDeployError("HUB_INVALID_RESPONSE", `Hub returned nonconforming problem details for HTTP ${response.status}.`);
+        return new HubCommandError("HUB_INVALID_RESPONSE", `Hub returned nonconforming problem details for HTTP ${response.status}.`);
     }
-    const title = parsed.data.title ?? `Hub deployment failed with HTTP ${response.status}`;
-    const detail = parsed.data.detail;
-    const message = detail === undefined ? title : `${title}: ${detail}`;
+    const title = parsed.data.title ?? `${failureMessage} with HTTP ${response.status}`;
+    const message = parsed.data.detail === undefined ? title : `${title}: ${parsed.data.detail}`;
     const details = formatFieldIssues(parsed.data.errors, parsed.data.issues);
     const code = response.status === 422 ? "HUB_VALIDATION_FAILED" : "HUB_REQUEST_FAILED";
-    return new HubDeployError(code, redactSecret(message, apiKey), details === undefined ? undefined : redactSecret(details, apiKey));
+    return new HubCommandError(code, redactSecret(message, apiKey), details === undefined ? undefined : redactSecret(details, apiKey));
 }
 function formatFieldIssues(errors, issues) {
     const fieldIssues = Array.isArray(errors) ? errors : issues;
@@ -99,16 +221,14 @@ function formatIssuePath(path) {
         return path;
     let formatted = "";
     for (const segment of path) {
-        if (typeof segment === "number") {
+        if (typeof segment === "number")
             formatted += `[${segment}]`;
-        }
-        else {
+        else
             formatted += formatted.length === 0 ? segment : `.${segment}`;
-        }
     }
     return formatted || undefined;
 }
 function redactSecret(value, secret) {
-    return value.split(secret).join("[redacted]");
+    return secret === undefined ? value : value.split(secret).join("[redacted]");
 }
 //# sourceMappingURL=client.js.map

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

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import type { HubHttpClient } from "./client.js";
+import type { HubCredentialStore } from "./credentials.js";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import { type HubReporter } from "./reporter.js";
+interface HubConnectOptions {
+    apiKey?: string;
+    host?: string;
+    json?: boolean;
+}
+interface HubConnectDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: Pick<HubHttpClient, "issueEnrollmentToken">;
+    daemon: HubDaemonConnection;
+    reporter: HubReporter;
+}
+export declare function runHubConnect(originInput: string | undefined, options: HubConnectOptions, dependencies: HubConnectDependencies): Promise<import("../../output/types.js").ListResult<import("./status-output.js").HubRow>>;
+export declare function addHubConnectCommand(parent: Command, dependencies: HubConnectDependencies): void;
+export {};
+//# sourceMappingURL=connect.d.ts.map

package/dist/commands/hub/connect.js

@@ -0,0 +1,34 @@
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { resolveHubCredential, resolveHubOrigin } from "./authority.js";
+import { withHubDaemon } from "./daemon-client.js";
+import { hubStatusResult } from "./status-output.js";
+import { reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
+export async function runHubConnect(originInput, options, dependencies) {
+    const resolution = {
+        options: { origin: originInput, apiKey: options.apiKey },
+        env: dependencies.env,
+        credentials: dependencies.credentials,
+    };
+    const origin = resolveHubOrigin(resolution);
+    reportHubProgress(dependencies.reporter, options, `Connecting this daemon to ${origin}`);
+    const credential = resolveHubCredential({ ...resolution, origin });
+    const token = await dependencies.hub.issueEnrollmentToken(origin, credential);
+    return withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
+        const response = await daemon.connectHub(origin, token);
+        return hubStatusResult(response.status);
+    });
+}
+export function addHubConnectCommand(parent, dependencies) {
+    addJsonAndDaemonHostOptions(addHubResolutionHelp(parent
+        .command("connect")
+        .description("Enroll this daemon with a Paseo Hub")
+        .argument("[origin]", "Paseo Hub origin")
+        .option("--api-key <secret>", "Organization API key"))).action(withOutput(async (...args) => {
+        const origin = args[0];
+        const options = args.at(-2);
+        return runHubConnect(origin, options, dependencies);
+    }));
+}
+//# sourceMappingURL=connect.js.map

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

@@ -0,0 +1,21 @@
+export interface StoredHubCredential {
+    origin: string;
+    credential: string;
+}
+export interface HubCredentialStore {
+    active(): StoredHubCredential | null;
+    get(origin: string): StoredHubCredential | null;
+    save(credential: StoredHubCredential): void;
+    logoutActive(): StoredHubCredential | null;
+}
+export declare class PrivateHubCredentialStore implements HubCredentialStore {
+    private readonly filePath;
+    constructor(env?: Readonly<Record<string, string | undefined>>);
+    active(): StoredHubCredential | null;
+    get(origin: string): StoredHubCredential | null;
+    save(credential: StoredHubCredential): void;
+    logoutActive(): StoredHubCredential | null;
+    private read;
+    private write;
+}
+//# sourceMappingURL=credentials.d.ts.map

package/dist/commands/hub/credentials.js

@@ -0,0 +1,143 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { HubCommandError } from "./error.js";
+import { normalizeHubOrigin } from "./origin.js";
+const PRIVATE_DIRECTORY_MODE = 0o700;
+const PRIVATE_FILE_MODE = 0o600;
+const credentialRecordSchema = z
+    .object({ origin: z.string(), credential: z.string().min(1) })
+    .strict();
+const credentialFileSchema = z
+    .object({
+    version: z.literal(1),
+    activeOrigin: z.string().nullable(),
+    credentials: z.array(credentialRecordSchema),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const origins = new Set();
+    for (const record of value.credentials) {
+        let normalized;
+        try {
+            normalized = normalizeHubOrigin(record.origin);
+        }
+        catch {
+            context.addIssue({ code: "custom", message: "Credential origin is invalid" });
+            continue;
+        }
+        if (normalized !== record.origin || origins.has(record.origin)) {
+            context.addIssue({
+                code: "custom",
+                message: "Credential origins must be unique and normalized",
+            });
+        }
+        origins.add(record.origin);
+    }
+    if (value.activeOrigin !== null && !origins.has(value.activeOrigin)) {
+        context.addIssue({ code: "custom", message: "Active credential is missing" });
+    }
+});
+export class PrivateHubCredentialStore {
+    constructor(env = process.env) {
+        this.filePath = path.join(resolvePaseoHome(env), "hub-credentials.json");
+    }
+    active() {
+        const data = this.read();
+        if (data.activeOrigin === null)
+            return null;
+        return data.credentials.find((record) => record.origin === data.activeOrigin) ?? null;
+    }
+    get(origin) {
+        const normalizedOrigin = normalizeHubOrigin(origin);
+        return this.read().credentials.find((record) => record.origin === normalizedOrigin) ?? null;
+    }
+    save(credential) {
+        const origin = normalizeHubOrigin(credential.origin);
+        const current = this.read();
+        const remaining = current.credentials.filter((record) => record.origin !== origin);
+        this.write({
+            version: 1,
+            activeOrigin: origin,
+            credentials: [...remaining, { origin, credential: credential.credential }],
+        });
+    }
+    logoutActive() {
+        const current = this.read();
+        if (current.activeOrigin === null)
+            return null;
+        const removed = current.credentials.find((record) => record.origin === current.activeOrigin);
+        if (removed === undefined)
+            throw invalidCredentialFile();
+        this.write({
+            version: 1,
+            activeOrigin: null,
+            credentials: current.credentials.filter((record) => record.origin !== current.activeOrigin),
+        });
+        return removed;
+    }
+    read() {
+        let contents;
+        try {
+            contents = readFileSync(this.filePath, "utf8");
+        }
+        catch (error) {
+            if (isMissingFile(error))
+                return { version: 1, activeOrigin: null, credentials: [] };
+            throw credentialStorageError();
+        }
+        chmodPrivate(this.filePath, PRIVATE_FILE_MODE);
+        try {
+            return credentialFileSchema.parse(JSON.parse(contents));
+        }
+        catch {
+            throw invalidCredentialFile();
+        }
+    }
+    write(value) {
+        const parsed = credentialFileSchema.parse(value);
+        const directory = path.dirname(this.filePath);
+        mkdirSync(directory, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+        chmodPrivate(directory, PRIVATE_DIRECTORY_MODE);
+        const temporaryPath = path.join(directory, `.${path.basename(this.filePath)}.${process.pid}.${randomUUID()}.tmp`);
+        try {
+            writeFileSync(temporaryPath, `${JSON.stringify(parsed, null, 2)}\n`, {
+                encoding: "utf8",
+                mode: PRIVATE_FILE_MODE,
+            });
+            renameSync(temporaryPath, this.filePath);
+            chmodPrivate(this.filePath, PRIVATE_FILE_MODE);
+        }
+        catch {
+            rmSync(temporaryPath, { force: true });
+            throw credentialStorageError();
+        }
+    }
+}
+function resolvePaseoHome(env) {
+    const configured = env.PASEO_HOME ?? "~/.paseo";
+    const expanded = configured === "~" ? homedir() : configured.replace(/^~\//u, `${homedir()}/`);
+    return path.resolve(expanded);
+}
+function chmodPrivate(target, mode) {
+    if (process.platform === "win32")
+        return;
+    try {
+        chmodSync(target, mode);
+    }
+    catch {
+        throw credentialStorageError();
+    }
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function invalidCredentialFile() {
+    return new HubCommandError("HUB_CREDENTIALS_INVALID", "Stored Hub login is invalid. Run `paseo hub login <origin>` to replace it.");
+}
+function credentialStorageError() {
+    return new HubCommandError("HUB_CREDENTIALS_UNAVAILABLE", "Could not access the private Hub credential store under PASEO_HOME.");
+}
+//# sourceMappingURL=credentials.js.map

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

@@ -0,0 +1,27 @@
+export interface HubStatus {
+    state: string;
+    daemonId: string | null;
+    hubOrigin: string | null;
+    scopes: string[];
+    connectedAt: string | null;
+    lastError: string | null;
+}
+export interface HubDaemonClient {
+    connectHub(url: string, token: string): Promise<{
+        status: HubStatus;
+    }>;
+    getHubStatus(): Promise<{
+        status: HubStatus;
+    }>;
+    disconnectHub(force: boolean): Promise<{
+        status: HubStatus;
+        warning?: string;
+    }>;
+    close(): Promise<void>;
+}
+export interface HubDaemonConnection {
+    connect(host: string | undefined): Promise<HubDaemonClient>;
+}
+export declare const productionHubDaemonConnection: HubDaemonConnection;
+export declare function withHubDaemon<T>(connection: HubDaemonConnection, host: string | undefined, action: (client: HubDaemonClient) => Promise<T>): Promise<T>;
+//# sourceMappingURL=daemon-client.d.ts.map

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

@@ -0,0 +1,14 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const productionHubDaemonConnection = {
+    connect: (host) => connectToDaemon({ host }),
+};
+export async function withHubDaemon(connection, host, action) {
+    const client = await connection.connect(host);
+    try {
+        return await action(client);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=daemon-client.js.map