@otto-code/cli 0.8.10 → 0.8.13

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

@@ -0,0 +1,136 @@
+import path from "node:path";
+import YAML from "yaml";
+export function planHubInitOpening(input) {
+    return {
+        replaceExisting: input.ottoDirectoryExists,
+        steps: [...(input.loggedIn ? [] : ["login"]), "connect", "project", "scaffold"],
+    };
+}
+export function createHubInitBundle(projectSlug, scaffold) {
+    return {
+        projectSlug,
+        workflowCount: 1,
+        files: [
+            { path: ".otto/hub.yml", content: scaffold.hub },
+            { path: scaffold.workflowPath, content: scaffold.workflow },
+        ],
+    };
+}
+export function resolveHubInitProjects(projects) {
+    if (projects.length === 0)
+        return { kind: "none" };
+    if (projects.length === 1)
+        return { kind: "selected", project: projects[0] };
+    return { kind: "choose", projects };
+}
+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 environmentName = input.daemonSlug;
+    const hub = YAML.stringify({
+        environments: {
+            [environmentName]: {
+                kind: "daemon",
+                daemon: input.daemonSlug,
+                cwd: path.resolve(input.cwd),
+            },
+        },
+        agents: {
+            codex: {
+                provider: "codex",
+                mode: "full-access",
+            },
+        },
+    }, { lineWidth: 0 });
+    const provider = providerScaffold(input.provider, input.providerFilters, environmentName);
+    return {
+        hub,
+        workflowPath: `.otto/workflows/${input.provider}-help.yml`,
+        workflow: YAML.stringify(provider.workflow, { lineWidth: 0 }),
+        testAction: provider.testAction,
+    };
+}
+function providerScaffold(provider, filters, environment) {
+    if (provider === "github") {
+        const repo = requireFilter(filters, "repo");
+        const user = requireFilter(filters, "user");
+        return {
+            workflow: workflow({
+                name: "github-help",
+                on: "github.issue_comment",
+                filters: { repo, contains: "@otto", from_users: [user] },
+                environment,
+            }),
+            testAction: `Comment \`@otto have a look\` on ${repo}.`,
+        };
+    }
+    const user = requireFilter(filters, "user");
+    if (provider === "slack") {
+        const workspace = requireFilter(filters, "workspace");
+        return {
+            workflow: workflow({
+                name: "slack-help",
+                on: "slack.mention",
+                filters: { workspace, from_users: [user] },
+                environment,
+                reply: "slack.reply",
+            }),
+            testAction: "Mention `@Otto have a look` in Slack.",
+        };
+    }
+    const guild = requireFilter(filters, "guild");
+    return {
+        workflow: workflow({
+            name: "discord-help",
+            on: "discord.mention",
+            filters: { guild, from_users: [user] },
+            environment,
+            reply: "discord.reply",
+        }),
+        testAction: "Mention `@Otto have a look` in Discord.",
+    };
+}
+function workflow(input) {
+    const replyInstruction = input.reply === undefined ? "" : "Answer with hub.reply, then ";
+    return {
+        name: input.name,
+        on: input.on,
+        max_runtime: "2h",
+        filters: input.filters,
+        steps: [
+            {
+                id: "work",
+                environment: input.environment,
+                max_runtime: "90m",
+                idle_timeout: "10m",
+                agent: "codex",
+                prompt: [
+                    {
+                        text: `${replyInstruction}complete this request and call hub.finish_execution when done.\n\n<user-prompt>\n\${{ otto.prompt }}\n</user-prompt>\n`,
+                    },
+                ],
+                ...(input.reply === undefined
+                    ? {}
+                    : { allow_outputs: [{ type: 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,20 @@
+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";
+interface HubInitEnvironment {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: HubHttpClient;
+    login: Pick<CliLoginFlow, "authorize">;
+    daemon: HubDaemonConnection;
+    reporter: HubReporter;
+    cwd(): string;
+}
+export declare function addHubInitCommand(parent: Command, environment: HubInitEnvironment): void;
+export declare function runHubInit(environment: HubInitEnvironment): Promise<void>;
+export declare function githubRepositoryFromRemote(remote: string): string | undefined;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/hub/init.js

@@ -0,0 +1,415 @@
+import { cancel, confirm, intro, isCancel, log, note, outro, select, spinner, text, } from "@clack/prompts";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { DEFAULT_HUB_ORIGIN, resolveHubCredential } from "./authority.js";
+import { withHubDaemon } from "./daemon-client.js";
+import { HubCommandError } from "./error.js";
+import { createHubInitBundle, createHubInitScaffold, planHubInitOpening, resolveHubInitConnection, resolveHubInitProjects, } from "./init-plan.js";
+import { runHubLogin } from "./login.js";
+import { runHubConnect } from "./connect.js";
+import { runHubDeployBundle } from "./deploy.js";
+import { runHubProjects } from "./projects.js";
+import { normalizeHubOrigin } from "./origin.js";
+const execFileAsync = promisify(execFile);
+const DAEMON_READY_TIMEOUT_MS = 60000;
+const DAEMON_READY_POLL_MS = 250;
+class HubInitCancelledError extends Error {
+}
+function initErrorMessage(error) {
+    if (error instanceof HubCommandError && error.details) {
+        return `${error.message}\n${error.details}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+export function addHubInitCommand(parent, environment) {
+    parent
+        .command("init")
+        .description("Create and optionally deploy a safe starter Hub bundle")
+        .action(async () => {
+        try {
+            await runHubInit(environment);
+        }
+        catch (error) {
+            if (error instanceof HubInitCancelledError) {
+                cancel(error.message);
+                return;
+            }
+            cancel(initErrorMessage(error));
+            process.exitCode = 1;
+        }
+    });
+}
+export async function runHubInit(environment) {
+    requireInteractiveTerminal();
+    intro("Set up Otto Hub");
+    const cwd = environment.cwd();
+    const activeLogin = environment.credentials.active();
+    const opening = planHubInitOpening({
+        loggedIn: activeLogin !== null,
+        ottoDirectoryExists: await pathExists(path.join(cwd, ".otto")),
+    });
+    if (opening.replaceExisting &&
+        !(await requiredConfirm("Replace the existing .otto/ Hub bundle?", false))) {
+        throw new HubInitCancelledError("Existing .otto/ bundle left unchanged.");
+    }
+    const origin = await ensureLogin(activeLogin?.origin, environment);
+    const daemonId = await ensureDaemonConnection(origin, environment);
+    const project = await chooseProject(origin, environment);
+    const resources = await loadConfigurationResources(origin, environment);
+    const daemon = resources.daemons.find(({ id }) => id === daemonId);
+    if (daemon === undefined) {
+        throw new HubCommandError("HUB_DAEMON_RESOURCE_MISSING", "The connected daemon is not available in this Hub organization. Reconnect it and try again.");
+    }
+    log.success(`Connected as ${daemon.slug}`);
+    const provider = await chooseProvider();
+    const providerFilters = await collectProviderFilters(provider, resources, cwd);
+    const scaffold = createHubInitScaffold({
+        cwd,
+        daemonSlug: daemon.slug,
+        provider,
+        providerFilters,
+    });
+    const bundle = createHubInitBundle(project.slug, scaffold);
+    await withSpinner("Validating bundle", async () => {
+        await runHubDeployBundle({ project: project.slug, hub: origin, dryRun: true }, bundle, {
+            cwd,
+            env: environment.env,
+            credentials: environment.credentials,
+            hub: environment.hub,
+            reporter: { progress() { } },
+        });
+    });
+    log.success("Dry run passed");
+    await writeScaffold(cwd, scaffold, opening.replaceExisting);
+    log.success(`Created .otto/hub.yml and ${scaffold.workflowPath}`);
+    const deploy = await requiredConfirm("Deploy now?", true);
+    if (deploy) {
+        await withSpinner("Deploying bundle", async () => {
+            await runHubDeployBundle({ project: project.slug, hub: origin }, bundle, {
+                cwd,
+                env: environment.env,
+                credentials: environment.credentials,
+                hub: environment.hub,
+                reporter: { progress() { } },
+            });
+        });
+        log.success("Deployed");
+    }
+    else {
+        log.message(`Skipped deployment. Run: otto hub deploy -p ${project.slug}`);
+    }
+    const activityUrl = new URL(`/projects/${project.slug}/activity`, origin).toString();
+    note(`${scaffold.testAction}\nWatch it at ${activityUrl}`, "Test your workflow");
+    outro(deploy ? "Hub is ready" : "Hub bundle is ready");
+}
+async function ensureLogin(activeOrigin, environment) {
+    const endpoint = await requiredSelect({
+        message: "Hub endpoint",
+        initialValue: activeOrigin === undefined || activeOrigin === DEFAULT_HUB_ORIGIN ? "hosted" : "custom",
+        options: [
+            { value: "hosted", label: "hub.otto-code.me" },
+            { value: "custom", label: "Custom endpoint…" },
+        ],
+    });
+    const origin = endpoint === "hosted"
+        ? DEFAULT_HUB_ORIGIN
+        : await requiredText({
+            message: "Custom Hub URL",
+            initialValue: activeOrigin === undefined || activeOrigin === DEFAULT_HUB_ORIGIN
+                ? environment.env.OTTO_HUB_URL
+                : activeOrigin,
+            validate(value) {
+                try {
+                    normalizeHubOrigin(value ?? "");
+                }
+                catch {
+                    return "Enter a valid Hub URL";
+                }
+                return undefined;
+            },
+        });
+    const normalizedOrigin = normalizeHubOrigin(origin);
+    if (environment.credentials.get(normalizedOrigin) !== null) {
+        log.success(`Logged in to ${normalizedOrigin}`);
+        return normalizedOrigin;
+    }
+    await runHubLogin(normalizedOrigin, {}, {
+        env: environment.env,
+        credentials: environment.credentials,
+        flow: environment.login,
+        reporter: environment.reporter,
+    });
+    log.success(`Logged in to ${normalizedOrigin}`);
+    return normalizedOrigin;
+}
+async function ensureDaemonConnection(origin, environment) {
+    const status = await withHubDaemon(environment.daemon, undefined, async (daemon) => daemon.getHubStatus().then((response) => response.status));
+    const connection = resolveHubInitConnection(status, origin);
+    if (connection.kind === "connected") {
+        return connection.daemonId;
+    }
+    if (connection.kind === "pending") {
+        return waitForDaemonReady(origin, environment.daemon);
+    }
+    if (connection.kind === "conflict") {
+        throw new HubCommandError("HUB_DAEMON_ALREADY_CONNECTED", `This daemon is connected to ${connection.origin}. Disconnect it before running Hub init for ${origin}.`);
+    }
+    if (!(await requiredConfirm(`Connect this daemon to ${origin}?`, true))) {
+        throw new HubInitCancelledError("A connected daemon is required to create the bundle.");
+    }
+    await runHubConnect(origin, {}, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        daemon: environment.daemon,
+        reporter: environment.reporter,
+    });
+    return waitForDaemonReady(origin, environment.daemon);
+}
+async function waitForDaemonReady(origin, connection) {
+    return withSpinner("Waiting for the daemon to connect", async (reporter) => withHubDaemon(connection, undefined, async (daemon) => {
+        const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+        while (true) {
+            const status = (await daemon.getHubStatus()).status;
+            const resolution = resolveHubInitConnection(status, origin);
+            if (resolution.kind === "connected")
+                return resolution.daemonId;
+            if (resolution.kind === "conflict") {
+                throw new HubCommandError("HUB_DAEMON_ALREADY_CONNECTED", `This daemon connected to ${resolution.origin} while Hub init was waiting for ${origin}.`);
+            }
+            if (resolution.kind === "connect") {
+                throw new HubCommandError("HUB_DAEMON_CONNECTION_LOST", "The daemon lost its Hub relationship while Hub init was waiting for it.");
+            }
+            if (Date.now() >= deadline) {
+                throw new HubCommandError("HUB_DAEMON_CONNECTION_TIMEOUT", "The daemon did not connect within 60 seconds. Check `otto hub status`, then run Hub init again.");
+            }
+            reporter.progress(`Daemon is ${resolution.state}`);
+            await delay(DAEMON_READY_POLL_MS);
+        }
+    }));
+}
+async function chooseProject(origin, environment) {
+    const result = await runHubProjects({ hub: origin }, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        reporter: { progress() { } },
+    });
+    const resolution = resolveHubInitProjects(result.data.projects);
+    if (resolution.kind === "none") {
+        throw new HubInitCancelledError(`No Hub projects exist yet. Create one at ${new URL("/projects/new", origin).toString()}, then run otto hub init again.`);
+    }
+    if (resolution.kind === "selected") {
+        return resolution.project;
+    }
+    const slug = await requiredSelect({
+        message: "Project",
+        options: resolution.projects.map((project) => ({
+            value: project.slug,
+            label: project.name,
+            hint: project.slug,
+        })),
+    });
+    const project = resolution.projects.find((candidate) => candidate.slug === slug);
+    if (project === undefined) {
+        throw new HubCommandError("HUB_PROJECT_SELECTION_INVALID", "The selected Hub project is unavailable.");
+    }
+    return project;
+}
+async function chooseProvider() {
+    return requiredSelect({
+        message: "Trigger provider",
+        options: [
+            { value: "github", label: "GitHub", hint: "issue or pull request comment" },
+            { value: "slack", label: "Slack", hint: "channel mention" },
+            { value: "discord", label: "Discord", hint: "channel mention" },
+        ],
+    });
+}
+async function collectProviderFilters(provider, resources, cwd) {
+    if (provider === "github") {
+        const [login, originRemote] = await Promise.all([
+            readGhValue(["api", "user", "--jq", ".login"]),
+            readCommandValue("git", ["remote", "get-url", "origin"], cwd),
+        ]);
+        const repo = originRemote === undefined ? undefined : githubRepositoryFromRemote(originRemote);
+        if (repo === undefined) {
+            throw new HubCommandError("HUB_GITHUB_REPOSITORY_UNDETECTED", "Could not detect a GitHub repository from the origin remote.");
+        }
+        if (!resources.github.some(({ repositories }) => repositories.includes(repo))) {
+            const connected = resources.github.flatMap(({ repositories }) => repositories);
+            throw new HubCommandError("HUB_GITHUB_REPOSITORY_NOT_CONNECTED", `${repo} is not connected to this Hub organization. Connected repositories: ${connected.join(", ") || "none"}.`);
+        }
+        return {
+            user: await requiredText({
+                message: "Your GitHub username (only this user can trigger the bot)",
+                initialValue: login,
+            }),
+            repo,
+        };
+    }
+    if (provider === "slack") {
+        return {
+            workspace: await chooseConnection("Slack workspace", resources.slack.map(({ slug, teamName }) => ({ slug, label: teamName }))),
+            user: await requiredText({
+                message: "Your Slack username (only this user can trigger the bot)",
+            }),
+        };
+    }
+    return {
+        guild: await chooseConnection("Discord server", resources.discord.map(({ slug, guildName }) => ({ slug, label: guildName }))),
+        user: await requiredText({
+            message: "Your Discord username (only this user can trigger the bot)",
+        }),
+    };
+}
+async function loadConfigurationResources(origin, environment) {
+    try {
+        return await withSpinner("Loading Hub connections", () => environment.hub.listConfigurationResources(origin, resolveHubCredential({
+            options: { origin },
+            env: environment.env,
+            credentials: environment.credentials,
+            origin,
+        })));
+    }
+    catch (error) {
+        if (error instanceof HubCommandError && error.code === "HUB_NOT_FOUND") {
+            throw new HubCommandError("HUB_UPDATE_REQUIRED", "This Hub does not support guided setup. Update the Hub and try again.");
+        }
+        throw error;
+    }
+}
+async function chooseConnection(message, connections) {
+    if (connections.length === 0) {
+        throw new HubCommandError("HUB_PROVIDER_CONNECTION_REQUIRED", `No ${message.toLowerCase()} is connected in this Hub organization. Connect one and try again.`);
+    }
+    if (connections.length === 1)
+        return connections[0].slug;
+    return requiredSelect({
+        message,
+        options: connections.map(({ slug, label }) => ({ value: slug, label })),
+    });
+}
+async function writeScaffold(cwd, scaffold, replaceExisting) {
+    const root = path.join(cwd, ".otto");
+    const staging = path.join(cwd, `.otto-init-${randomUUID()}`);
+    const backup = path.join(cwd, `.otto-backup-${randomUUID()}`);
+    let movedExisting = false;
+    try {
+        await mkdir(path.join(staging, "workflows"), { recursive: true });
+        await writeFile(path.join(staging, "hub.yml"), scaffold.hub, { flag: "wx" });
+        await writeFile(path.join(staging, "workflows", path.basename(scaffold.workflowPath)), scaffold.workflow, {
+            flag: "wx",
+        });
+        if (replaceExisting) {
+            await rename(root, backup);
+            movedExisting = true;
+        }
+        await rename(staging, root);
+        if (movedExisting)
+            await rm(backup, { recursive: true, force: true });
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true });
+        if (movedExisting) {
+            await rename(backup, root).catch(() => undefined);
+        }
+        throw error;
+    }
+}
+async function pathExists(target) {
+    try {
+        await lstat(target);
+        return true;
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function errorCode(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function readGhValue(args) {
+    return readCommandValue("gh", args);
+}
+async function readCommandValue(command, args, cwd) {
+    try {
+        const { stdout } = await execFileAsync(command, [...args], { encoding: "utf8", cwd });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function githubRepositoryFromRemote(remote) {
+    const trimmed = remote.trim().replace(/\.git$/u, "");
+    const ssh = /^(?:ssh:\/\/)?git@github\.com[:/]([^/]+\/[^/]+)$/u.exec(trimmed);
+    if (ssh?.[1] !== undefined)
+        return ssh[1];
+    try {
+        const url = new URL(trimmed);
+        if (url.hostname !== "github.com")
+            return undefined;
+        const repository = url.pathname.replace(/^\//u, "");
+        return /^[^/]+\/[^/]+$/u.test(repository) ? repository : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function withSpinner(message, action) {
+    const progress = spinner();
+    progress.start(message);
+    try {
+        const result = await action({ progress: (nextMessage) => progress.message(nextMessage) });
+        progress.stop(message);
+        return result;
+    }
+    catch (error) {
+        progress.error(message);
+        throw error;
+    }
+}
+async function requiredText(options) {
+    const answer = await text({
+        ...options,
+        validate(value) {
+            const input = value ?? "";
+            const customError = options.validate?.(input);
+            if (customError !== undefined)
+                return customError;
+            return input.trim().length === 0 ? "A value is required" : undefined;
+        },
+    });
+    if (isCancel(answer))
+        throw new HubInitCancelledError("Hub init cancelled.");
+    return answer.trim();
+}
+async function requiredConfirm(message, initialValue) {
+    const answer = await confirm({ message, initialValue });
+    if (isCancel(answer))
+        throw new HubInitCancelledError("Hub init cancelled.");
+    return answer;
+}
+async function requiredSelect(options) {
+    const answer = await select(options);
+    if (isCancel(answer))
+        throw new HubInitCancelledError("Hub init cancelled.");
+    return answer;
+}
+function requireInteractiveTerminal() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new HubCommandError("HUB_INIT_INTERACTIVE_REQUIRED", "otto hub init requires a TTY.");
+    }
+}
+//# sourceMappingURL=init.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