@getpaseo/cli 0.3.0 → 0.4.0-beta.1

package/dist/commands/hub/deploy.js

@@ -1,8 +1,11 @@
 import { withOutput } from "../../output/index.js";
 import { addJsonOption } from "../../utils/command-options.js";
-import { installHubConfiguration } from "./client.js";
-import { resolveHubDeployInput } from "./deploy-input.js";
-import { HubDeployError } from "./error.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 { processHubReporter, reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
 const resultSchema = {
     idField: "versionId",
     columns: [
@@ -10,62 +13,75 @@ const resultSchema = {
         { header: "VERSION", field: "version" },
         { header: "VERSION ID", field: "versionId" },
         { header: "ACTIVE", field: "active" },
+        { header: "WORKFLOWS", field: "workflows" },
+        { header: "HUB", field: "origin" },
     ],
 };
-export async function runHubDeploy(options, environment = { cwd: process.cwd(), env: process.env }) {
-    const origin = options.hub ?? environment.env.PASEO_HUB_URL;
-    const apiKey = options.apiKey ?? environment.env.PASEO_HUB_API_KEY;
-    if (!origin) {
-        throw new HubDeployError("HUB_ORIGIN_REQUIRED", "Hub origin is required. Pass --hub <origin> or set PASEO_HUB_URL.");
-    }
-    if (!apiKey) {
-        throw new HubDeployError("HUB_API_KEY_REQUIRED", "Hub API key is required. Pass --api-key <secret> or set PASEO_HUB_API_KEY.");
-    }
-    const normalizedOrigin = parseHubOrigin(origin);
-    const deployInput = await resolveHubDeployInput({
+const validationSchema = {
+    idField: "projectSlug",
+    columns: [
+        { header: "PROJECT", field: "projectSlug" },
+        { header: "VALID", field: "valid" },
+        { header: "WORKFLOWS", field: "workflows" },
+        { header: "HUB", field: "origin" },
+    ],
+};
+export async function runHubDeploy(options, environment = {
+    cwd: process.cwd(),
+    env: process.env,
+    credentials: new PrivateHubCredentialStore(),
+    hub: new HubHttpClient(),
+}) {
+    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 deployInput = await discoverHubBundle({
         cwd: environment.cwd,
-        ...(options.file === undefined ? {} : { file: options.file }),
         ...(options.project === undefined ? {} : { project: options.project }),
     });
-    const deployed = await installHubConfiguration({
-        origin: normalizedOrigin,
-        apiKey,
+    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,
-    });
-    return { type: "single", data: deployed, schema: resultSchema };
+    };
+    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) {
-    addJsonOption(hub
+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")).action(withOutput(async (...args) => {
-        const file = args[0];
+        .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, file });
+        return runHubDeploy(options, {
+            cwd: dependencies.cwd(),
+            env: dependencies.env,
+            credentials: dependencies.credentials,
+            hub: dependencies.hub,
+            reporter: dependencies.reporter,
+        });
     }));
 }
-function parseHubOrigin(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        throw invalidHubOrigin();
-    }
-    if (!["http:", "https:"].includes(url.protocol) ||
-        url.username ||
-        url.password ||
-        url.pathname !== "/" ||
-        url.search ||
-        url.hash) {
-        throw invalidHubOrigin();
-    }
-    return url.origin;
-}
-function invalidHubOrigin() {
-    return new HubDeployError("HUB_INVALID_ORIGIN", "Hub URL must be an HTTP or HTTPS origin without credentials, path, query, or hash.");
-}
 //# 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, current.hubOrigin);
+    });
+}
+export function addHubDisconnectCommand(parent, dependencies) {
+    addJsonAndDaemonHostOptions(parent
+        .command("disconnect")
+        .option("--force", "Remove local authority even if the Hub is offline")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubDisconnect(options, dependencies);
+    }));
+}
+//# sourceMappingURL=disconnect.js.map

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

@@ -1,4 +1,4 @@
-export declare class HubDeployError extends Error {
+export declare class HubCommandError extends Error {
     readonly code: string;
     readonly details?: string | undefined;
     constructor(code: string, message: string, details?: string | undefined);

package/dist/commands/hub/error.js

@@ -1,9 +1,9 @@
-export class HubDeployError extends Error {
+export class HubCommandError extends Error {
     constructor(code, message, details) {
         super(message);
         this.code = code;
         this.details = details;
-        this.name = "HubDeployError";
+        this.name = "HubCommandError";
     }
 }
 //# sourceMappingURL=error.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,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/hub-client/internal/contracts.d.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export 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>;
+export 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>;
+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>;
+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>;
+export {};
+//# 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

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

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { HubCommandError } from "../../error.js";
+const issuePathSchema = z.union([z.string(), z.array(z.union([z.string(), z.number()]))]);
+const fieldIssueSchema = z.object({
+    field: z.string().optional(),
+    path: issuePathSchema.optional(),
+    message: z.string(),
+});
+const problemSchema = z.object({
+    type: z.string().optional(),
+    title: z.string().optional(),
+    status: z.number().int().optional(),
+    detail: z.string().optional(),
+    instance: z.string().optional(),
+    errors: z
+        .union([z.array(fieldIssueSchema), z.record(z.string(), z.array(z.string()))])
+        .optional(),
+    issues: z.array(fieldIssueSchema).optional(),
+});
+export async function hubRequestFailure(response, failureMessage, apiKey) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().includes("application/problem+json")) {
+        return new HubCommandError("HUB_REQUEST_FAILED", `${failureMessage} with HTTP ${response.status}.`);
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        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 HubCommandError("HUB_INVALID_RESPONSE", `Hub returned nonconforming problem details for HTTP ${response.status}.`);
+    }
+    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 HubCommandError(code, redactSecret(message, apiKey), details === undefined ? undefined : redactSecret(details, apiKey));
+}
+function formatFieldIssues(errors, issues) {
+    const fieldIssues = Array.isArray(errors) ? errors : issues;
+    if (fieldIssues !== undefined) {
+        const lines = fieldIssues.map((issue) => {
+            const field = issue.field ?? formatIssuePath(issue.path);
+            return field === undefined ? issue.message : `${field}: ${issue.message}`;
+        });
+        return lines.length === 0 ? undefined : lines.join("\n");
+    }
+    if (errors === undefined)
+        return undefined;
+    const lines = Object.entries(errors).flatMap(([field, messages]) => messages.map((message) => `${field}: ${message}`));
+    return lines.length === 0 ? undefined : lines.join("\n");
+}
+function formatIssuePath(path) {
+    if (path === undefined || typeof path === "string")
+        return path;
+    let formatted = "";
+    for (const segment of path) {
+        if (typeof segment === "number")
+            formatted += `[${segment}]`;
+        else
+            formatted += formatted.length === 0 ? segment : `.${segment}`;
+    }
+    return formatted || undefined;
+}
+function redactSecret(value, secret) {
+    return secret === undefined ? value : value.split(secret).join("[redacted]");
+}
+//# sourceMappingURL=problem.js.map

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

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+interface HubRequest<T> {
+    origin: string;
+    path: string;
+    method: "GET" | "POST";
+    apiKey?: string;
+    body?: unknown;
+    successStatus: number;
+    schema: z.ZodType<T>;
+    timeoutMilliseconds?: number;
+    failureMessage: string;
+}
+export declare function requestHub<T>(input: HubRequest<T>): Promise<T>;
+export {};
+//# sourceMappingURL=transport.d.ts.map

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

@@ -0,0 +1,30 @@
+import { HubCommandError } from "../../error.js";
+import { hubRequestFailure } from "./problem.js";
+export async function requestHub(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 hubRequestFailure(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.");
+    }
+}
+//# sourceMappingURL=transport.js.map

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

@@ -1,30 +1,20 @@
 import { Command } from "commander";
-interface HubCommandClient {
-    connectHub(url: string, token: string): Promise<{
-        status: HubStatus;
-    }>;
-    getHubStatus(): Promise<{
-        status: HubStatus;
-    }>;
-    disconnectHub(force: boolean): Promise<{
-        status: HubStatus;
-        warning?: string;
-    }>;
-    close(): Promise<void>;
-}
-interface HubStatus {
-    state: string;
-    daemonId: string | null;
-    hubOrigin: string | null;
-    scopes: string[];
-    connectedAt: string | null;
-    lastError: string | null;
-}
+import { HubHttpClient } from "./hub-client/index.js";
+import { type HubCredentialStore } from "./credentials.js";
+import { type HubDaemonConnection } from "./daemon-client.js";
+import { type CliLoginFlow } from "./login-flow.js";
+import { type HubReporter } from "./reporter.js";
 interface HubCommandEnvironment {
-    connect(host: string | undefined): Promise<HubCommandClient>;
-    authorize(url: string, displayName: string): Promise<string>;
-    displayName(): string;
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: HubHttpClient;
+    login: Pick<CliLoginFlow, "authorize">;
+    daemon: HubDaemonConnection;
+    isInteractive(): boolean;
+    confirmDisconnect(origin: string): Promise<boolean>;
+    reporter: HubReporter;
+    cwd(): string;
 }
-export declare function createHubCommand(environment?: HubCommandEnvironment): Command;
+export declare function createHubCommand(overrides?: Partial<HubCommandEnvironment>): Command;
 export {};
 //# sourceMappingURL=index.d.ts.map