@getpaseo/cli 0.3.0-beta.4 → 0.3.1

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

@@ -1,7 +1,7 @@
 import { lstat, readFile } from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
-import { HubDeployError } from "./error.js";
+import { HubCommandError } from "./error.js";
 const DEFAULT_CONFIGURATION_PATH = ".paseo/hub.yml";
 const PROMPT_PARTIAL_ROOT = ".paseo/partials";
 const PROMPT_PARTIAL_ROOT_PREFIX = `${PROMPT_PARTIAL_ROOT}/`;
@@ -19,10 +19,10 @@ export async function resolveHubDeployInput(input) {
     const configuration = parseConfiguration(yaml);
     const projectSlug = input.project ?? projectFromConfiguration(configuration);
     if (projectSlug === undefined) {
-        throw new HubDeployError("HUB_PROJECT_REQUIRED", "Project is required. Pass --project <slug> or add top-level project to the YAML.");
+        throw new HubCommandError("HUB_PROJECT_REQUIRED", "Project is required. Pass --project <slug> or add top-level project to the YAML.");
     }
     if (!PROJECT_SLUG_PATTERN.test(projectSlug)) {
-        throw new HubDeployError("HUB_INVALID_PROJECT", "Project must be a bare slug such as my-project.");
+        throw new HubCommandError("HUB_INVALID_PROJECT", "Project must be a bare slug such as my-project.");
     }
     const partials = await resolvePromptPartials(projectRoot, configuration);
     return {
@@ -47,7 +47,7 @@ function resolveConfigurationPath(cwd, file) {
     return resolved;
 }
 async function readConfiguration(projectRoot, configurationPath, displayPath) {
-    const unsafePath = () => new HubDeployError("HUB_CONFIGURATION_UNSAFE_PATH", `Hub configuration at ${displayPath} must not use a symlink.`);
+    const unsafePath = () => new HubCommandError("HUB_CONFIGURATION_UNSAFE_PATH", `Hub configuration at ${displayPath} must not use a symlink.`);
     await rejectSymlinkComponents(projectRoot, configurationPath, unsafePath);
     let stats;
     try {
@@ -60,10 +60,10 @@ async function readConfiguration(projectRoot, configurationPath, displayPath) {
         throw unsafePath();
     }
     if (!stats.isFile()) {
-        throw new HubDeployError("HUB_CONFIGURATION_NOT_FILE", `Hub configuration at ${displayPath} must be a regular file.`);
+        throw new HubCommandError("HUB_CONFIGURATION_NOT_FILE", `Hub configuration at ${displayPath} must be a regular file.`);
     }
     if (!hasReadPermission(stats.mode)) {
-        throw new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check file permissions.`);
+        throw new HubCommandError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check file permissions.`);
     }
     let bytes;
     try {
@@ -74,7 +74,7 @@ async function readConfiguration(projectRoot, configurationPath, displayPath) {
     }
     const yaml = bytes.toString("utf8");
     if (yaml.length > MAX_CONFIGURATION_LENGTH) {
-        throw new HubDeployError("HUB_CONFIGURATION_TOO_LARGE", `Hub configuration at ${displayPath} exceeds the ${MAX_CONFIGURATION_LENGTH}-character limit.`);
+        throw new HubCommandError("HUB_CONFIGURATION_TOO_LARGE", `Hub configuration at ${displayPath} exceeds the ${MAX_CONFIGURATION_LENGTH}-character limit.`);
     }
     return yaml;
 }
@@ -84,10 +84,10 @@ function parseConfiguration(yaml) {
         configuration = YAML.parse(yaml);
     }
     catch {
-        throw new HubDeployError("HUB_INVALID_CONFIGURATION", "Hub configuration is not valid YAML.");
+        throw new HubCommandError("HUB_INVALID_CONFIGURATION", "Hub configuration is not valid YAML.");
     }
     if (!isRecord(configuration)) {
-        throw new HubDeployError("HUB_INVALID_CONFIGURATION", "Hub configuration must be a YAML mapping.");
+        throw new HubCommandError("HUB_INVALID_CONFIGURATION", "Hub configuration must be a YAML mapping.");
     }
     return configuration;
 }
@@ -96,14 +96,14 @@ function projectFromConfiguration(configuration) {
     if (project === undefined)
         return undefined;
     if (typeof project !== "string") {
-        throw new HubDeployError("HUB_INVALID_PROJECT", "Top-level project must be a bare project slug.");
+        throw new HubCommandError("HUB_INVALID_PROJECT", "Top-level project must be a bare project slug.");
     }
     return project;
 }
 async function resolvePromptPartials(projectRoot, configuration) {
     const references = collectPromptPartialReferences(configuration);
     if (references.length > MAX_PROMPT_PARTIAL_COUNT) {
-        throw new HubDeployError("HUB_PARTIAL_LIMIT_EXCEEDED", `Hub configuration references ${references.length} partials; the limit is ${MAX_PROMPT_PARTIAL_COUNT}.`);
+        throw new HubCommandError("HUB_PARTIAL_LIMIT_EXCEEDED", `Hub configuration references ${references.length} partials; the limit is ${MAX_PROMPT_PARTIAL_COUNT}.`);
     }
     const partials = [];
     let bundleBytes = 0;
@@ -112,11 +112,11 @@ async function resolvePromptPartials(projectRoot, configuration) {
         const content = await readPartial(projectRoot, partialPath, reference.path);
         const contentBytes = Buffer.byteLength(content, "utf8");
         if (contentBytes > MAX_PROMPT_PARTIAL_CONTENT_BYTES) {
-            throw new HubDeployError("HUB_PARTIAL_TOO_LARGE", `Referenced Hub partial ${reference.path} exceeds the ${MAX_PROMPT_PARTIAL_CONTENT_BYTES}-byte limit.`);
+            throw new HubCommandError("HUB_PARTIAL_TOO_LARGE", `Referenced Hub partial ${reference.path} exceeds the ${MAX_PROMPT_PARTIAL_CONTENT_BYTES}-byte limit.`);
         }
         bundleBytes += contentBytes;
         if (bundleBytes > MAX_PROMPT_PARTIAL_BUNDLE_BYTES) {
-            throw new HubDeployError("HUB_PARTIAL_BUNDLE_TOO_LARGE", `Referenced Hub partials exceed the ${MAX_PROMPT_PARTIAL_BUNDLE_BYTES}-byte combined limit.`);
+            throw new HubCommandError("HUB_PARTIAL_BUNDLE_TOO_LARGE", `Referenced Hub partials exceed the ${MAX_PROMPT_PARTIAL_BUNDLE_BYTES}-byte combined limit.`);
         }
         partials.push({ path: reference.path, content });
     }
@@ -139,11 +139,11 @@ function collectPromptPartialReferences(configuration) {
                     continue;
                 const include = block["include"];
                 if (typeof include !== "string") {
-                    throw new HubDeployError("HUB_PARTIAL_PATH_INVALID", "Hub partial include path must be a string.");
+                    throw new HubCommandError("HUB_PARTIAL_PATH_INVALID", "Hub partial include path must be a string.");
                 }
                 const normalizedPath = normalizePromptPartialPath(include);
                 if (seen.has(normalizedPath)) {
-                    throw new HubDeployError("HUB_PARTIAL_DUPLICATE", `Hub partial ${normalizedPath} is referenced more than once. Remove the duplicate include.`);
+                    throw new HubCommandError("HUB_PARTIAL_DUPLICATE", `Hub partial ${normalizedPath} is referenced more than once. Remove the duplicate include.`);
                 }
                 seen.add(normalizedPath);
                 references.push({ path: normalizedPath });
@@ -168,7 +168,7 @@ function normalizePromptPartialPath(value) {
         throw invalidPromptPartialPath(value);
     }
     if (canonical.length > MAX_PROMPT_PARTIAL_PATH_LENGTH) {
-        throw new HubDeployError("HUB_PARTIAL_PATH_TOO_LONG", `Hub partial path ${value} exceeds the ${MAX_PROMPT_PARTIAL_PATH_LENGTH}-character limit.`);
+        throw new HubCommandError("HUB_PARTIAL_PATH_TOO_LONG", `Hub partial path ${value} exceeds the ${MAX_PROMPT_PARTIAL_PATH_LENGTH}-character limit.`);
     }
     return canonical.slice(PROMPT_PARTIAL_ROOT_PREFIX.length);
 }
@@ -192,31 +192,31 @@ function decodePromptPartialPath(value) {
     return decoded;
 }
 async function readPartial(projectRoot, partialPath, displayPath) {
-    await rejectSymlinkComponents(projectRoot, partialPath, () => new HubDeployError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not use a symlink.`));
+    await rejectSymlinkComponents(projectRoot, partialPath, () => new HubCommandError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not use a symlink.`));
     let stats;
     try {
         stats = await lstat(partialPath);
     }
     catch (error) {
         if (errorCode(error) === "ENOENT") {
-            throw new HubDeployError("HUB_PARTIAL_MISSING", `Referenced Hub partial ${displayPath} does not exist.`);
+            throw new HubCommandError("HUB_PARTIAL_MISSING", `Referenced Hub partial ${displayPath} does not exist.`);
         }
-        throw new HubDeployError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
+        throw new HubCommandError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
     }
     if (stats.isSymbolicLink()) {
-        throw new HubDeployError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not be a symlink.`);
+        throw new HubCommandError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not be a symlink.`);
     }
     if (!stats.isFile()) {
-        throw new HubDeployError("HUB_PARTIAL_NOT_FILE", `Referenced Hub partial ${displayPath} must be a regular file.`);
+        throw new HubCommandError("HUB_PARTIAL_NOT_FILE", `Referenced Hub partial ${displayPath} must be a regular file.`);
     }
     if (!hasReadPermission(stats.mode)) {
-        throw new HubDeployError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
+        throw new HubCommandError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
     }
     try {
         return (await readFile(partialPath)).toString("utf8");
     }
     catch {
-        throw new HubDeployError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
+        throw new HubCommandError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
     }
 }
 async function rejectSymlinkComponents(root, target, error) {
@@ -229,7 +229,7 @@ async function rejectSymlinkComponents(root, target, error) {
                 throw error();
         }
         catch (failure) {
-            if (failure instanceof HubDeployError)
+            if (failure instanceof HubCommandError)
                 throw failure;
             if (errorCode(failure) === "ENOENT")
                 return;
@@ -239,15 +239,15 @@ async function rejectSymlinkComponents(root, target, error) {
 }
 function configurationReadError(displayPath, error) {
     if (errorCode(error) === "ENOENT") {
-        return new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Pass an existing YAML file.`);
+        return new HubCommandError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Pass an existing YAML file.`);
     }
-    return new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check the file and permissions.`);
+    return new HubCommandError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check the file and permissions.`);
 }
 function invalidConfigurationPath() {
-    return new HubDeployError("HUB_CONFIGURATION_PATH_INVALID", "Hub configuration path must stay within the current project root; parent-directory paths are not allowed.");
+    return new HubCommandError("HUB_CONFIGURATION_PATH_INVALID", "Hub configuration path must stay within the current project root; parent-directory paths are not allowed.");
 }
 function invalidPromptPartialPath(value) {
-    return new HubDeployError("HUB_PARTIAL_PATH_INVALID", `Hub partial path must be a safe relative path under .paseo/partials/: ${value}`);
+    return new HubCommandError("HUB_PARTIAL_PATH_INVALID", `Hub partial path must be a safe relative path under .paseo/partials/: ${value}`);
 }
 function hasReadPermission(mode) {
     return (mode & 0o444) !== 0;

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

@@ -1,17 +1,37 @@
 import type { Command } from "commander";
 import { type SingleResult } from "../../output/index.js";
-import { type HubInstallResult } from "./client.js";
+import { HubHttpClient, type HubInstallResult, type HubValidationResult } from "./client.js";
+import { type HubCredentialStore } from "./credentials.js";
+import { type HubReporter } from "./reporter.js";
 export interface HubDeployOptions {
     file?: string;
     project?: string;
     hub?: string;
     apiKey?: string;
+    dryRun?: boolean;
+    json?: boolean;
 }
 interface HubDeployEnvironment {
     cwd: string;
     env: Readonly<Record<string, string | undefined>>;
+    credentials?: HubCredentialStore;
+    hub?: Pick<HubHttpClient, "installConfiguration" | "validateConfiguration">;
+    reporter?: HubReporter;
 }
-export declare function runHubDeploy(options: HubDeployOptions, environment?: HubDeployEnvironment): Promise<SingleResult<HubInstallResult>>;
-export declare function addHubDeployCommand(hub: Command): void;
+export interface HubDeployCommandDependencies {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: Pick<HubHttpClient, "installConfiguration" | "validateConfiguration">;
+    reporter: HubReporter;
+    cwd(): string;
+}
+interface HubDeployResult extends HubInstallResult {
+    origin: string;
+}
+interface HubDryRunResult extends HubValidationResult {
+    origin: string;
+}
+export declare function runHubDeploy(options: HubDeployOptions, environment?: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult>>;
+export declare function addHubDeployCommand(hub: Command, dependencies: HubDeployCommandDependencies): void;
 export {};
 //# sourceMappingURL=deploy.d.ts.map

package/dist/commands/hub/deploy.js

@@ -1,8 +1,11 @@
 import { withOutput } from "../../output/index.js";
 import { addJsonOption } from "../../utils/command-options.js";
-import { installHubConfiguration } from "./client.js";
+import { resolveHubCredential, resolveHubOrigin } from "./authority.js";
+import { HubHttpClient } from "./client.js";
+import { PrivateHubCredentialStore } from "./credentials.js";
 import { resolveHubDeployInput } from "./deploy-input.js";
-import { HubDeployError } from "./error.js";
+import { processHubReporter, reportHubProgress } from "./reporter.js";
+import { addHubResolutionHelp } from "./help.js";
 const resultSchema = {
     idField: "versionId",
     columns: [
@@ -10,62 +13,68 @@ const resultSchema = {
         { header: "VERSION", field: "version" },
         { header: "VERSION ID", field: "versionId" },
         { header: "ACTIVE", field: "active" },
+        { 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 validationSchema = {
+    idField: "projectSlug",
+    columns: [
+        { header: "PROJECT", field: "projectSlug" },
+        { header: "VALID", field: "valid" },
+        { 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 resolveHubDeployInput({
         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, origin }, schema: validationSchema };
+    }
+    const deployed = await (environment.hub ?? new HubHttpClient()).installConfiguration(request);
+    return { type: "single", data: { ...deployed, 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")
         .option("-p, --project <slug>", "Target project slug")
         .option("--hub <origin>", "Paseo Hub origin")
-        .option("--api-key <secret>", "Organization API key")).action(withOutput(async (...args) => {
+        .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, file }, {
+            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/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 "./client.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

package/dist/commands/hub/index.js

@@ -1,87 +1,77 @@
 import { Command } from "commander";
-import { hostname } from "node:os";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
-import { connectToDaemon } from "../../utils/client.js";
-import { createDeviceAuthorizationWorkflow } from "./device-authorization.js";
+import { HubHttpClient } from "./client.js";
+import { addHubConnectCommand } from "./connect.js";
+import { PrivateHubCredentialStore } from "./credentials.js";
+import { productionHubDaemonConnection, withHubDaemon, } from "./daemon-client.js";
 import { addHubDeployCommand } from "./deploy.js";
-const productionEnvironment = {
-    connect: (host) => connectToDaemon({ host }),
-    authorize: (url, displayName) => createDeviceAuthorizationWorkflow().authorize(url, displayName),
-    displayName: hostname,
-};
-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" },
-    ],
-};
-function result(status, warning) {
+import { addHubDisconnectCommand } from "./disconnect.js";
+import { createCliLoginFlow } from "./login-flow.js";
+import { addHubLoginCommand } from "./login.js";
+import { addHubLogoutCommand, productionLogoutPrompt } from "./logout.js";
+import { addHubProjectsCommand } from "./projects.js";
+import { processHubReporter } from "./reporter.js";
+import { hubStatusResult } from "./status-output.js";
+import { addHubResolutionHelp } from "./help.js";
+function productionEnvironment() {
+    const env = process.env;
+    const hub = new HubHttpClient();
     return {
-        type: "list",
-        data: [
-            {
-                state: status.state,
-                daemonId: status.daemonId,
-                hub: status.hubOrigin,
-                scopes: status.scopes.join(", "),
-                connectedAt: status.connectedAt,
-                error: status.lastError,
-                warning,
-            },
-        ],
-        schema,
+        env,
+        credentials: new PrivateHubCredentialStore(env),
+        hub,
+        login: createCliLoginFlow(hub),
+        daemon: productionHubDaemonConnection,
+        reporter: processHubReporter,
+        cwd: () => process.cwd(),
+        ...productionLogoutPrompt,
     };
 }
-async function withClient(environment, host, action) {
-    const client = await environment.connect(host);
-    try {
-        return await action(client);
-    }
-    finally {
-        await client.close().catch(() => undefined);
-    }
-}
-export function createHubCommand(environment = productionEnvironment) {
-    const hub = new Command("hub").description("Manage Paseo Hub");
-    addJsonAndDaemonHostOptions(hub.command("connect").argument("<url>").option("--token <token>")).action(withOutput(async (...args) => {
-        const url = args[0];
-        const options = args.at(-2);
-        return withClient(environment, options.host, async (client) => {
-            if (options.token !== undefined) {
-                return result((await client.connectHub(url, options.token)).status);
-            }
-            const existing = (await client.getHubStatus()).status;
-            if (existing.state !== "not_connected" && existing.state !== "revoked") {
-                throw new Error("This daemon already has a Hub relationship");
-            }
-            const token = await environment.authorize(url, suggestedDisplayName(environment.displayName()));
-            return result((await client.connectHub(url, token)).status);
-        });
-    }));
+export function createHubCommand(overrides = {}) {
+    const environment = { ...productionEnvironment(), ...overrides };
+    const hub = addHubResolutionHelp(new Command("hub").description("Manage Paseo Hub"));
+    addHubLoginCommand(hub, {
+        env: environment.env,
+        credentials: environment.credentials,
+        flow: environment.login,
+        reporter: environment.reporter,
+    });
+    addHubConnectCommand(hub, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        daemon: environment.daemon,
+        reporter: environment.reporter,
+    });
     addJsonAndDaemonHostOptions(hub.command("status")).action(withOutput(async (...args) => {
         const options = args.at(-2);
-        return withClient(environment, options.host, async (client) => result((await client.getHubStatus()).status));
+        return withHubDaemon(environment.daemon, options.host, async (client) => hubStatusResult((await client.getHubStatus()).status));
     }));
-    addJsonAndDaemonHostOptions(hub
-        .command("disconnect")
-        .option("--force", "Remove local authority even if the Hub is offline")).action(withOutput(async (...args) => {
-        const options = args.at(-2);
-        return withClient(environment, options.host, async (client) => {
-            const response = await client.disconnectHub(options.force ?? false);
-            return result(response.status, response.warning);
-        });
-    }));
-    addHubDeployCommand(hub);
+    addHubDisconnectCommand(hub, {
+        daemon: environment.daemon,
+        reporter: environment.reporter,
+    });
+    addHubProjectsCommand(hub, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        reporter: environment.reporter,
+    });
+    addHubDeployCommand(hub, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        reporter: environment.reporter,
+        cwd: environment.cwd,
+    });
+    addHubLogoutCommand(hub, {
+        credentials: environment.credentials,
+        daemon: environment.daemon,
+        isInteractive: environment.isInteractive,
+        confirmDisconnect: environment.confirmDisconnect,
+        reporter: environment.reporter,
+    });
     return hub;
 }
-function suggestedDisplayName(value) {
-    return value.trim().slice(0, 100) || "Paseo daemon";
-}
 //# sourceMappingURL=index.js.map