@camerontaylor/paseo-cli 0.8.0-fork.1

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

@@ -0,0 +1,126 @@
+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>;
+declare const triggerSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodBoolean;
+    format: z.ZodEnum<{
+        single_run: "single_run";
+        legacy_multistep: "legacy_multistep";
+    }>;
+    yaml: z.ZodString;
+}, z.core.$strict>;
+export declare const triggersResponseSchema: z.ZodObject<{
+    triggers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        enabled: z.ZodBoolean;
+        format: z.ZodEnum<{
+            single_run: "single_run";
+            legacy_multistep: "legacy_multistep";
+        }>;
+        yaml: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const triggerValidationResponseSchema: z.ZodObject<{
+    name: z.ZodString;
+    valid: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export declare const triggerInstallationResponseSchema: z.ZodObject<{
+    triggerId: z.ZodString;
+    name: z.ZodString;
+    revisionId: z.ZodString;
+    version: z.ZodNumber;
+    active: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export declare const configurationResourcesSchema: z.ZodObject<{
+    daemons: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strict>>;
+    github: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        accountLogin: z.ZodString;
+        accountType: z.ZodString;
+        repositories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    discord: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        guildName: z.ZodString;
+    }, z.core.$strict>>;
+    slack: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        teamName: z.ZodString;
+    }, z.core.$strict>>;
+    linear: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        organizationName: 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 HubTrigger = z.infer<typeof triggerSchema>;
+export type HubTriggerValidationResult = z.infer<typeof triggerValidationResponseSchema>;
+export type HubTriggerInstallationResult = z.infer<typeof triggerInstallationResponseSchema>;
+export type HubConfigurationResources = z.infer<typeof configurationResourcesSchema>;
+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,85 @@
+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();
+const triggerSchema = z
+    .object({
+    id: z.string().uuid(),
+    name: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
+    enabled: z.boolean(),
+    format: z.enum(["single_run", "legacy_multistep"]),
+    yaml: z.string(),
+})
+    .strict();
+export const triggersResponseSchema = z.object({ triggers: z.array(triggerSchema) }).strict();
+export const triggerValidationResponseSchema = z
+    .object({ name: z.string().regex(/^[a-z][a-z0-9_-]*$/u), valid: z.literal(true) })
+    .strict();
+export const triggerInstallationResponseSchema = z
+    .object({
+    triggerId: z.string().uuid(),
+    name: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
+    revisionId: z.string().uuid(),
+    version: z.number().int().positive(),
+    active: z.literal(true),
+})
+    .strict();
+export const configurationResourcesSchema = z
+    .object({
+    daemons: z.array(z.object({ id: z.string().uuid(), slug: z.string().min(1) }).strict()),
+    github: z.array(z
+        .object({
+        slug: z.string().min(1),
+        accountLogin: z.string().min(1),
+        accountType: z.string().min(1),
+        repositories: z.array(z.string().min(1)),
+    })
+        .strict()),
+    discord: z.array(z.object({ slug: z.string().min(1), guildName: z.string().min(1) }).strict()),
+    slack: z.array(z.object({ slug: z.string().min(1), teamName: z.string().min(1) }).strict()),
+    linear: z.array(z.object({ slug: z.string().min(1), organizationName: z.string().min(1) }).strict()),
+})
+    .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,85 @@
+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 details = formatFieldIssues(parsed.data.errors, parsed.data.issues);
+    const message = details !== undefined || parsed.data.detail === undefined
+        ? title
+        : `${title}: ${parsed.data.detail}`;
+    let code = "HUB_REQUEST_FAILED";
+    if (response.status === 422)
+        code = "HUB_VALIDATION_FAILED";
+    if (response.status === 404)
+        code = "HUB_NOT_FOUND";
+    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;
+    const [file, ...fieldPath] = path;
+    if (typeof file === "string" && file.startsWith(".paseo/") && fieldPath.length > 0) {
+        return `${file}: ${formatPathSegments(fieldPath)}`;
+    }
+    return formatPathSegments(path) || undefined;
+}
+function formatPathSegments(path) {
+    let formatted = "";
+    for (const segment of path) {
+        if (typeof segment === "number")
+            formatted += `[${segment}]`;
+        else
+            formatted += formatted.length === 0 ? segment : `.${segment}`;
+    }
+    return formatted;
+}
+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

@@ -0,0 +1,20 @@
+import { Command } from "commander";
+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 {
+    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(overrides?: Partial<HubCommandEnvironment>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/hub/index.js

@@ -0,0 +1,94 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.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";
+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 { addHubExportCommand } from "./export.js";
+import { processHubReporter } from "./reporter.js";
+import { hubStatusResult } from "./status-output.js";
+import { addHubResolutionHelp } from "./help.js";
+import { addHubInitCommand, continueHubGuidedSetup } from "./init.js";
+import { addHubPermissionsCommand } from "./permissions.js";
+function productionEnvironment() {
+    const env = process.env;
+    const hub = new HubHttpClient();
+    return {
+        env,
+        credentials: new PrivateHubCredentialStore(env),
+        hub,
+        login: createCliLoginFlow(hub),
+        daemon: productionHubDaemonConnection,
+        reporter: processHubReporter,
+        cwd: () => process.cwd(),
+        ...productionLogoutPrompt,
+    };
+}
+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,
+        isInteractive: environment.isInteractive,
+        continueGuidedSetup: (origin) => continueHubGuidedSetup(origin, environment),
+    });
+    addHubInitCommand(hub, environment);
+    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 withHubDaemon(environment.daemon, options.host, async (client) => hubStatusResult((await client.getHubStatus()).status));
+    }));
+    addHubDisconnectCommand(hub, {
+        daemon: environment.daemon,
+        reporter: environment.reporter,
+    });
+    addHubPermissionsCommand(hub, {
+        daemon: environment.daemon,
+        reporter: environment.reporter,
+    });
+    addHubProjectsCommand(hub, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        reporter: environment.reporter,
+    });
+    addHubExportCommand(hub, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        reporter: environment.reporter,
+        cwd: environment.cwd,
+    });
+    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;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/hub/init-plan.d.ts

@@ -0,0 +1,33 @@
+import type { HubStatus } from "./daemon-client.js";
+import type { HubStarterAgentRuntime } from "./starter-agent-runtime.js";
+export type HubInitProvider = "github" | "slack" | "discord";
+export type HubInitConnectionResolution = {
+    kind: "connected";
+    daemonId: string;
+} | {
+    kind: "pending";
+    state: "connecting" | "reconnecting";
+} | {
+    kind: "connect";
+} | {
+    kind: "conflict";
+    origin: string;
+};
+export interface HubInitScaffoldInput {
+    cwd: string;
+    daemonSlug: string;
+    agent: HubStarterAgentRuntime & {
+        mode: string;
+    };
+    provider: HubInitProvider;
+    providerFilters: Readonly<Record<string, string>>;
+}
+export interface HubInitScaffold {
+    triggerPath: string;
+    trigger: string;
+    testAction: string;
+}
+export declare function hubLoginResumeCommand(step: "connect" | "init", origin: string): string;
+export declare function resolveHubInitConnection(status: HubStatus, origin: string): HubInitConnectionResolution;
+export declare function createHubInitScaffold(input: HubInitScaffoldInput): HubInitScaffold;
+//# sourceMappingURL=init-plan.d.ts.map

package/dist/commands/hub/init-plan.js

@@ -0,0 +1,94 @@
+import path from "node:path";
+import YAML from "yaml";
+export function hubLoginResumeCommand(step, origin) {
+    return step === "connect" ? `paseo hub connect ${origin}` : "paseo hub init";
+}
+export function resolveHubInitConnection(status, origin) {
+    if (status.state === "connected" && status.hubOrigin === origin && status.daemonId !== null) {
+        return { kind: "connected", daemonId: status.daemonId };
+    }
+    if ((status.state === "connecting" || status.state === "reconnecting") &&
+        status.hubOrigin === origin) {
+        return { kind: "pending", state: status.state };
+    }
+    if (status.hubOrigin !== null && status.state !== "not_connected" && status.state !== "revoked") {
+        return { kind: "conflict", origin: status.hubOrigin };
+    }
+    return { kind: "connect" };
+}
+export function createHubInitScaffold(input) {
+    const provider = providerScaffold(input.provider, input.providerFilters);
+    return {
+        triggerPath: `.paseo/triggers/${input.provider}-help.yml`,
+        trigger: YAML.stringify(triggerDocument({
+            ...provider,
+            target: { daemon: input.daemonSlug, cwd: path.resolve(input.cwd) },
+            agent: {
+                provider: input.agent.provider,
+                model: input.agent.model,
+                mode: input.agent.mode,
+            },
+        }), { lineWidth: 0 }),
+        testAction: provider.testAction,
+    };
+}
+function providerScaffold(provider, filters) {
+    const connection = requireFilter(filters, "connection");
+    if (provider === "github") {
+        const repo = requireFilter(filters, "repo");
+        const user = requireFilter(filters, "user");
+        return {
+            name: "github-help",
+            event: "github.issue_comment",
+            connection,
+            filters: { repo, contains: "@paseo", from_users: [user] },
+            testAction: `Comment \`@paseo have a look\` on ${repo}.`,
+        };
+    }
+    const user = requireFilter(filters, "user");
+    if (provider === "slack") {
+        return {
+            name: "slack-help",
+            event: "slack.mention",
+            connection,
+            filters: { from_users: [user] },
+            reply: "slack.reply",
+            testAction: "Mention `@Paseo have a look` in Slack.",
+        };
+    }
+    return {
+        name: "discord-help",
+        event: "discord.mention",
+        connection,
+        filters: { from_users: [user] },
+        reply: "discord.reply",
+        testAction: "Mention `@Paseo have a look` in Discord.",
+    };
+}
+function triggerDocument(input) {
+    const replyInstruction = input.reply === undefined ? "" : "Answer with hub.reply, then ";
+    return {
+        name: input.name,
+        enabled: true,
+        on: { [input.event]: { connection: input.connection, filters: input.filters } },
+        max_runtime: "2h",
+        run: {
+            target: input.target,
+            agent: input.agent,
+            continuation: { mode: "conversation" },
+            max_runtime: "90m",
+            idle_timeout: "10m",
+            prompt: `${replyInstruction}complete this request and call hub.finish_execution when done.\n\n<user-prompt>\n\${{ paseo.prompt }}\n</user-prompt>\n`,
+            ...(input.reply === undefined
+                ? {}
+                : { outputs: { [input.reply]: { max: 1, required: true } } }),
+        },
+    };
+}
+function requireFilter(filters, name) {
+    const value = filters[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required for this provider`);
+    return value;
+}
+//# sourceMappingURL=init-plan.js.map

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

@@ -0,0 +1,35 @@
+import { select, text } from "@clack/prompts";
+import type { Command } from "commander";
+import type { HubCredentialStore } from "./credentials.js";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import type { HubHttpClient } from "./hub-client/index.js";
+import type { CliLoginFlow } from "./login-flow.js";
+import type { HubReporter } from "./reporter.js";
+export interface HubGuidedSetupEnvironment {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: HubHttpClient;
+    login: Pick<CliLoginFlow, "authorize">;
+    daemon: HubDaemonConnection;
+    reporter: HubReporter;
+    cwd(): string;
+    isInteractive?(): boolean;
+    prompts?: {
+        confirm(message: string, initialValue: boolean): Promise<boolean>;
+        select(options: Parameters<typeof select<string>>[0]): Promise<string>;
+        text(options: Parameters<typeof text>[0]): Promise<string>;
+        message(value: string): void;
+    };
+}
+interface HubGuidedSetupState {
+    origin?: string;
+    daemonId?: string;
+    deploy?: boolean;
+}
+export declare function addHubInitCommand(parent: Command, environment: HubGuidedSetupEnvironment): void;
+export declare function runHubInit(environment: HubGuidedSetupEnvironment): Promise<void>;
+export declare function runHubGuidedSetup(environment: HubGuidedSetupEnvironment, state?: HubGuidedSetupState): Promise<void>;
+export declare function continueHubGuidedSetup(origin: string, environment: HubGuidedSetupEnvironment): Promise<void>;
+export declare function githubRepositoryFromRemote(remote: string): string | undefined;
+export {};
+//# sourceMappingURL=init.d.ts.map