@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/hub/login.js

@@ -0,0 +1,40 @@
+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 });
+    reportHubProgress(dependencies.reporter, options, "Logged in");
+    if (!options.json &&
+        dependencies.isInteractive?.() &&
+        dependencies.continueGuidedSetup !== undefined) {
+        await dependencies.continueGuidedSetup(origin);
+    }
+    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,32 @@
+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;
+    warning?: string;
+}
+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,71 @@
+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" },
+        { header: "WARNING", field: "warning" },
+    ],
+};
+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}`);
+    const disconnect = await withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
+        return daemon.disconnectHub(options.force ?? false);
+    });
+    dependencies.credentials.logoutActive();
+    return logoutResult({
+        origin: active.origin,
+        status: "logged_out",
+        daemonDisconnected: disconnect.status.state === "not_connected",
+        ...(disconnect.warning ? { warning: disconnect.warning } : {}),
+    });
+}
+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 without notifying the Hub")).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/permissions.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import { type ListResult } from "../../output/index.js";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import { type HubReporter } from "./reporter.js";
+interface HubPermissionsOptions {
+    host?: string;
+    json?: boolean;
+}
+interface HubPermissionsDependencies {
+    daemon: HubDaemonConnection;
+    reporter: HubReporter;
+}
+interface PermissionRow {
+    permission: string;
+    description: string;
+}
+export declare function runHubPermissionsList(options: HubPermissionsOptions, dependencies: HubPermissionsDependencies): Promise<ListResult<PermissionRow>>;
+export declare function runHubPermissionChange(operation: "grant" | "revoke", permission: string, options: HubPermissionsOptions, dependencies: HubPermissionsDependencies): Promise<ListResult<import("./status-output.js").HubRow>>;
+export declare function addHubPermissionsCommand(parent: Command, dependencies: HubPermissionsDependencies): void;
+export {};
+//# sourceMappingURL=permissions.d.ts.map

package/dist/commands/hub/permissions.js

@@ -0,0 +1,61 @@
+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";
+const schema = {
+    idField: "permission",
+    columns: [
+        { header: "PERMISSION", field: "permission" },
+        { header: "DESCRIPTION", field: "description" },
+    ],
+};
+export function runHubPermissionsList(options, dependencies) {
+    return withHubDaemon(dependencies.daemon, options.host, async (client) => {
+        const status = (await client.getHubStatus()).status;
+        requireConnectedHub(status);
+        return {
+            type: "list",
+            data: status.permissions.map((permission) => ({
+                permission,
+                description: describePermission(permission),
+            })),
+            schema,
+        };
+    });
+}
+export function runHubPermissionChange(operation, permission, options, dependencies) {
+    return withHubDaemon(dependencies.daemon, options.host, async (client) => {
+        const current = (await client.getHubStatus()).status;
+        requireConnectedHub(current);
+        const response = await client.updateHubPermissions(operation === "grant" ? { grant: [permission] } : { revoke: [permission] });
+        reportHubProgress(dependencies.reporter, options, `${operation === "grant" ? "Granted" : "Revoked"} ${permission} ${operation === "grant" ? "to" : "from"} ${response.status.hubOrigin}`);
+        return hubStatusResult(response.status);
+    });
+}
+export function addHubPermissionsCommand(parent, dependencies) {
+    const permissions = parent
+        .command("permissions")
+        .description("Manage this Hub's daemon permissions");
+    addJsonAndDaemonHostOptions(permissions.command("list")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return runHubPermissionsList(options, dependencies);
+    }));
+    for (const operation of ["grant", "revoke"]) {
+        addJsonAndDaemonHostOptions(permissions.command(operation).argument("<permission>", "Daemon permission")).action(withOutput(async (...args) => {
+            const permission = args[0];
+            const options = args.at(-2);
+            return runHubPermissionChange(operation, permission, options, dependencies);
+        }));
+    }
+}
+function requireConnectedHub(status) {
+    if (status.hubOrigin === null ||
+        (status.state !== "connected" && status.state !== "reconnecting")) {
+        throw new Error("This daemon is not connected to a Hub");
+    }
+}
+function describePermission(permission) {
+    return permission === "hub.execute" ? "Run agents for Hub automations" : permission;
+}
+//# sourceMappingURL=permissions.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/starter-agent-runtime.d.ts

@@ -0,0 +1,37 @@
+import type { ProviderSnapshotEntry } from "@camerontaylor/paseo-protocol/agent-types";
+export interface HubStarterAgentRuntime {
+    provider: string;
+    model: string;
+    mode?: string;
+}
+export interface HubStarterAgentProvider {
+    id: string;
+    label: string;
+    models: readonly HubStarterAgentModel[];
+    modes: readonly HubStarterAgentMode[];
+}
+export interface HubStarterAgentModel {
+    id: string;
+    label: string;
+    suggested: boolean;
+}
+export interface HubStarterAgentMode {
+    id: string;
+    label: string;
+    suggested: boolean;
+}
+export type HubStarterAgentProviderSnapshotState = {
+    kind: "ready";
+    providers: readonly HubStarterAgentProvider[];
+} | {
+    kind: "loading";
+} | {
+    kind: "unavailable";
+};
+export declare function availableStarterAgentProviders(entries: readonly ProviderSnapshotEntry[]): HubStarterAgentProvider[];
+export declare function starterAgentProviderSnapshotState(entries: readonly ProviderSnapshotEntry[]): HubStarterAgentProviderSnapshotState;
+export declare function suggestedStarterAgentChoice<T extends {
+    suggested: boolean;
+}>(choices: readonly T[]): T | undefined;
+export declare function selectedStarterAgentRuntime(provider: HubStarterAgentProvider, modelId: string, modeId?: string): HubStarterAgentRuntime | undefined;
+//# sourceMappingURL=starter-agent-runtime.d.ts.map

package/dist/commands/hub/starter-agent-runtime.js

@@ -0,0 +1,49 @@
+export function availableStarterAgentProviders(entries) {
+    return entries.flatMap((entry) => {
+        if (entry.status !== "ready" || !entry.enabled)
+            return [];
+        const models = (entry.models ?? [])
+            .filter((model) => model.isSelectable !== false)
+            .map((model) => ({ id: model.id, label: model.label, suggested: model.isDefault === true }));
+        if (models.length === 0)
+            return [];
+        const modes = (entry.modes ?? []).map((mode) => ({
+            id: mode.id,
+            label: mode.label,
+            suggested: mode.id === entry.defaultModeId,
+        }));
+        return [
+            {
+                id: entry.provider,
+                label: entry.label ?? entry.provider,
+                models,
+                modes,
+            },
+        ];
+    });
+}
+export function starterAgentProviderSnapshotState(entries) {
+    const providers = availableStarterAgentProviders(entries);
+    if (providers.length > 0)
+        return { kind: "ready", providers };
+    if (entries.length === 0)
+        return { kind: "loading" };
+    if (entries.some((entry) => entry.enabled && entry.status === "loading")) {
+        return { kind: "loading" };
+    }
+    return { kind: "unavailable" };
+}
+export function suggestedStarterAgentChoice(choices) {
+    return choices.find((choice) => choice.suggested);
+}
+export function selectedStarterAgentRuntime(provider, modelId, modeId) {
+    if (!provider.models.some((model) => model.id === modelId))
+        return undefined;
+    if (provider.modes.length === 0) {
+        return modeId === undefined ? { provider: provider.id, model: modelId } : undefined;
+    }
+    if (modeId === undefined || !provider.modes.some((mode) => mode.id === modeId))
+        return undefined;
+    return { provider: provider.id, model: modelId, mode: modeId };
+}
+//# sourceMappingURL=starter-agent-runtime.js.map

package/dist/commands/hub/starter-trigger.d.ts

@@ -0,0 +1,10 @@
+import type { HubConfigurationResources } from "./hub-client/index.js";
+import type { HubInitProvider } from "./init-plan.js";
+export interface HubStarterTriggerConnection {
+    id: string;
+    label: string;
+    provider: HubInitProvider;
+    filters: Readonly<Record<string, string>>;
+}
+export declare function availableStarterTriggerConnections(resources: HubConfigurationResources, githubRepository?: string): HubStarterTriggerConnection[];
+//# sourceMappingURL=starter-trigger.d.ts.map

package/dist/commands/hub/starter-trigger.js

@@ -0,0 +1,30 @@
+export function availableStarterTriggerConnections(resources, githubRepository) {
+    return [
+        ...resources.github.flatMap((connection) => githubRepository !== undefined && connection.repositories.includes(githubRepository)
+            ? [
+                {
+                    id: `github:${githubRepository}`,
+                    label: `GitHub — ${githubRepository}`,
+                    provider: "github",
+                    filters: {
+                        connection: connection.slug,
+                        repo: githubRepository,
+                    },
+                },
+            ]
+            : []),
+        ...resources.slack.map(({ slug, teamName }) => ({
+            id: `slack:${slug}`,
+            label: `Slack — ${teamName}`,
+            provider: "slack",
+            filters: { connection: slug },
+        })),
+        ...resources.discord.map(({ slug, guildName }) => ({
+            id: `discord:${slug}`,
+            label: `Discord — ${guildName}`,
+            provider: "discord",
+            filters: { connection: slug },
+        })),
+    ];
+}
+//# sourceMappingURL=starter-trigger.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;
+    permissions: 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: "PERMISSIONS", field: "permissions" },
+        { 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,
+                permissions: status.permissions.join(", "),
+                connectedAt: status.connectedAt,
+                error: status.lastError,
+                warning,
+            },
+        ],
+        schema,
+    };
+}
+//# sourceMappingURL=status-output.js.map

package/dist/commands/onboard.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+import { type DaemonStartOptions } from "./daemon/local-daemon.js";
+interface OnboardOptions extends DaemonStartOptions {
+    timeout?: string;
+    voice?: "ask" | "enable" | "disable";
+}
+export declare function onboardCommand(): Command;
+export declare function runOnboard(options: OnboardOptions): Promise<void>;
+export {};
+//# sourceMappingURL=onboard.d.ts.map