@otto-code/cli 0.8.12 → 0.8.13

package/dist/commands/hub/hub-client/index.js

@@ -0,0 +1,99 @@
+import { HubCommandError } from "../error.js";
+import { authorizationPollSchema, authorizationSchema, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
+import { requestHub } from "./internal/transport.js";
+export class HubHttpClient {
+    startCliAuthorization(origin) {
+        return requestHub({
+            origin,
+            path: "/api/v1/cli-authorizations",
+            method: "POST",
+            body: {},
+            successStatus: 201,
+            schema: authorizationSchema,
+            failureMessage: "Hub CLI login could not be started",
+        });
+    }
+    async pollCliAuthorization(origin, deviceCode, timeoutMilliseconds) {
+        try {
+            return await requestHub({
+                origin,
+                path: "/api/v1/cli-authorizations/poll",
+                method: "POST",
+                body: { deviceCode },
+                successStatus: 200,
+                schema: authorizationPollSchema,
+                timeoutMilliseconds,
+                failureMessage: "Hub CLI login polling failed",
+            });
+        }
+        catch (error) {
+            if (error instanceof HubCommandError && error.code === "HUB_NETWORK_ERROR") {
+                return { status: "retry_later" };
+            }
+            throw error;
+        }
+    }
+    async listProjects(origin, apiKey) {
+        const response = await requestHub({
+            origin,
+            path: "/api/v1/projects",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: projectsResponseSchema,
+            failureMessage: "Hub project listing failed",
+        });
+        return response.projects;
+    }
+    listConfigurationResources(origin, apiKey) {
+        return requestHub({
+            origin,
+            path: "/api/v1/configuration-resources",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: configurationResourcesSchema,
+            failureMessage: "Hub configuration resource listing failed",
+        });
+    }
+    installConfiguration(input) {
+        return requestHub({
+            origin: input.origin,
+            path: "/api/v1/configurations/install",
+            method: "POST",
+            apiKey: input.apiKey,
+            body: configurationBody(input),
+            successStatus: 201,
+            schema: installResponseSchema,
+            failureMessage: "Hub deployment failed",
+        });
+    }
+    validateConfiguration(input) {
+        return requestHub({
+            origin: input.origin,
+            path: "/api/v1/configurations/validate",
+            method: "POST",
+            apiKey: input.apiKey,
+            body: configurationBody(input),
+            successStatus: 200,
+            schema: validationResponseSchema,
+            failureMessage: "Hub configuration validation failed",
+        });
+    }
+    async issueEnrollmentToken(origin, apiKey) {
+        const response = await requestHub({
+            origin,
+            path: "/api/v1/daemons/enrollment-tokens",
+            method: "POST",
+            apiKey,
+            successStatus: 201,
+            schema: enrollmentTokenSchema,
+            failureMessage: "Hub daemon enrollment authorization failed",
+        });
+        return response.token;
+    }
+}
+function configurationBody(input) {
+    return { projectSlug: input.projectSlug, files: input.files };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,86 @@
+import { z } from "zod";
+export declare const authorizationSchema: z.ZodObject<{
+    deviceCode: z.ZodString;
+    userCode: z.ZodString;
+    verificationUri: z.ZodURL;
+    verificationUriComplete: z.ZodURL;
+    expiresAt: z.ZodString;
+    interval: z.ZodNumber;
+}, z.core.$strict>;
+export declare const authorizationPollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"pending">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"slow_down">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"authorized">;
+    interval: z.ZodNumber;
+    credential: z.ZodString;
+    organizationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"denied">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"expired">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"disclosed">;
+    interval: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"retry_later">;
+}, z.core.$strict>], "status">;
+declare const projectSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export declare const projectsResponseSchema: z.ZodObject<{
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const 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>>;
+}, 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 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,62 @@
+import { z } from "zod";
+const activationUrlSchema = z.url({ protocol: /^https?$/u });
+export const authorizationSchema = z
+    .object({
+    deviceCode: z.string().min(32),
+    userCode: z.string().min(1),
+    verificationUri: activationUrlSchema,
+    verificationUriComplete: activationUrlSchema,
+    expiresAt: z.string().datetime(),
+    interval: z.number().int().min(1),
+})
+    .strict();
+export const authorizationPollSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("pending"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(1) }).strict(),
+    z
+        .object({
+        status: z.literal("authorized"),
+        interval: z.number().int().min(1),
+        credential: z.string().min(32),
+        organizationId: z.string().min(1),
+    })
+        .strict(),
+    z.object({ status: z.literal("denied"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("expired"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("disclosed"), interval: z.number().int().min(1) }).strict(),
+    z.object({ status: z.literal("retry_later") }).strict(),
+]);
+const projectSchema = z
+    .object({ id: z.string().uuid(), slug: z.string().min(1), name: z.string().min(1) })
+    .strict();
+export const projectsResponseSchema = z.object({ projects: z.array(projectSchema) }).strict();
+export const 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()),
+})
+    .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(".otto/") && 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

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

package/dist/commands/hub/index.js

@@ -1,85 +1,79 @@
 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";
-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 { 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 { processHubReporter } from "./reporter.js";
+import { hubStatusResult } from "./status-output.js";
+import { addHubResolutionHelp } from "./help.js";
+import { addHubInitCommand } from "./init.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 this daemon's Otto Hub relationship");
-    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 Otto Hub"));
+    addHubLoginCommand(hub, {
+        env: environment.env,
+        credentials: environment.credentials,
+        flow: environment.login,
+        reporter: environment.reporter,
+    });
+    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 withClient(environment, options.host, async (client) => result((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);
-        });
+        return withHubDaemon(environment.daemon, options.host, async (client) => hubStatusResult((await client.getHubStatus()).status));
     }));
+    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) || "Otto daemon";
-}
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,50 @@
+import type { HubDeployBundle } from "./deploy-bundle.js";
+import type { HubProject } from "./hub-client/index.js";
+import type { HubStatus } from "./daemon-client.js";
+export type HubInitProvider = "github" | "slack" | "discord";
+export type HubInitProjectResolution = {
+    kind: "none";
+} | {
+    kind: "selected";
+    project: HubProject;
+} | {
+    kind: "choose";
+    projects: readonly HubProject[];
+};
+export type HubInitConnectionResolution = {
+    kind: "connected";
+    daemonId: string;
+} | {
+    kind: "pending";
+    state: "connecting" | "reconnecting";
+} | {
+    kind: "connect";
+} | {
+    kind: "conflict";
+    origin: string;
+};
+export interface HubInitOpeningPlan {
+    replaceExisting: boolean;
+    steps: readonly ("login" | "connect" | "project" | "scaffold")[];
+}
+export interface HubInitScaffoldInput {
+    cwd: string;
+    daemonSlug: string;
+    provider: HubInitProvider;
+    providerFilters: Readonly<Record<string, string>>;
+}
+export interface HubInitScaffold {
+    hub: string;
+    workflowPath: string;
+    workflow: string;
+    testAction: string;
+}
+export declare function planHubInitOpening(input: {
+    loggedIn: boolean;
+    ottoDirectoryExists: boolean;
+}): HubInitOpeningPlan;
+export declare function createHubInitBundle(projectSlug: string, scaffold: HubInitScaffold): HubDeployBundle;
+export declare function resolveHubInitProjects(projects: readonly HubProject[]): HubInitProjectResolution;
+export declare function resolveHubInitConnection(status: HubStatus, origin: string): HubInitConnectionResolution;
+export declare function createHubInitScaffold(input: HubInitScaffoldInput): HubInitScaffold;
+//# sourceMappingURL=init-plan.d.ts.map