@getpaseo/cli 0.3.0 → 0.4.0-beta.1

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 "./hub-client/index.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

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 "./hub-client/index.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 "./hub-client/index.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/provider/diagnostic.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+export interface ProviderDiagnosticResult {
+    provider: string;
+    diagnostic: string;
+}
+export declare const providerDiagnosticSchema: OutputSchema<ProviderDiagnosticResult>;
+export interface ProviderDiagnosticOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runDiagnosticCommand(provider: string, options: ProviderDiagnosticOptions, _command: Command): Promise<SingleResult<ProviderDiagnosticResult>>;
+//# sourceMappingURL=diagnostic.d.ts.map

package/dist/commands/provider/diagnostic.js

@@ -0,0 +1,31 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const providerDiagnosticSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider" },
+        { header: "DIAGNOSTIC", field: "diagnostic" },
+    ],
+    renderHuman(result) {
+        if (result.type === "single")
+            return result.data.diagnostic;
+        return result.data.map((entry) => entry.diagnostic).join("\n\n");
+    },
+};
+export async function runDiagnosticCommand(provider, options, _command) {
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const result = await client.getProviderDiagnostic(provider.trim().toLowerCase());
+        return {
+            type: "single",
+            data: {
+                provider: result.provider,
+                diagnostic: result.diagnostic,
+            },
+            schema: providerDiagnosticSchema,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=diagnostic.js.map