@tonbo/cli 0.0.1 → 0.0.3

package/dist/src/app.js

@@ -5,6 +5,8 @@ import { AuthClient } from "./auth.js";
 import { deployCommand, runCommand, loginCommand, projectCreateCommand, projectUseCommand, sshCommand, sshKeyAddCommand, sshKeyRemoveCommand, secretListCommand, secretRemoveCommand, secretSetCommand, } from "./commands.js";
 import { FileConfigStore } from "./config.js";
 import { FileCredentialStore } from "./credentials.js";
+import { silentProgress, TerminalProgress } from "./progress.js";
+import { readDefaultSshPublicKeys } from "./ssh-key.js";
 const packageVersion = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
 export function createDependencies(json = false) {
     const accountOrigin = process.env.TONBO_ACCOUNT_ORIGIN || "https://tonbo.dev";
@@ -14,12 +16,14 @@ export function createDependencies(json = false) {
         auth: new AuthClient(new FileCredentialStore(), fetch, accountOrigin),
         config: new FileConfigStore(),
         cwd: () => process.cwd(),
+        defaultSshPublicKeys: readDefaultSshPublicKeys,
         output: (value) => {
             if (json)
                 console.log(JSON.stringify(value));
             else
                 console.log(value.message ?? value);
         },
+        progress: json ? silentProgress : new TerminalProgress(process.stderr),
         secretValue: async (name, fromEnvironment) => {
             const environmentName = fromEnvironment ?? name;
             const value = process.env[environmentName];

package/dist/src/auth.d.ts

@@ -1,12 +1,19 @@
 import type { CredentialStore } from "./credentials.js";
 import type { OAuthTokenSet } from "./types.js";
+export type LoginStep = "account-config" | "callback-server" | "browser" | "browser-authorization" | "callback-close" | "token-exchange" | "credential-store";
+export interface LoginProgressEvent {
+    status: "completed" | "started";
+    step: LoginStep;
+}
+export type LoginProgress = (event: LoginProgressEvent) => void;
 export declare class AuthClient {
     private readonly credentials;
     private readonly fetcher;
     private readonly accountOrigin;
-    constructor(credentials: CredentialStore, fetcher: typeof fetch, accountOrigin?: string);
+    private readonly browserOpener;
+    constructor(credentials: CredentialStore, fetcher: typeof fetch, accountOrigin?: string, browserOpener?: (url: string) => Promise<void>);
     accessToken(): Promise<string>;
-    login(): Promise<OAuthTokenSet>;
+    login(progress?: LoginProgress): Promise<OAuthTokenSet>;
     private config;
     private exchange;
     private listenForCode;

package/dist/src/auth.js

@@ -21,10 +21,12 @@ export class AuthClient {
     credentials;
     fetcher;
     accountOrigin;
-    constructor(credentials, fetcher, accountOrigin = "https://tonbo.dev") {
+    browserOpener;
+    constructor(credentials, fetcher, accountOrigin = "https://tonbo.dev", browserOpener = openBrowser) {
         this.credentials = credentials;
         this.fetcher = fetcher;
         this.accountOrigin = accountOrigin;
+        this.browserOpener = browserOpener;
     }
     async accessToken() {
         const injected = process.env.TONBO_ACCESS_TOKEN?.trim();
@@ -53,8 +55,10 @@ export class AuthClient {
         await this.credentials.save(refreshed);
         return refreshed.access_token;
     }
-    async login() {
+    async login(progress = () => { }) {
+        progress({ status: "started", step: "account-config" });
         const config = await this.config();
+        progress({ status: "completed", step: "account-config" });
         if (config.redirect_uri !== LOOPBACK_REDIRECT)
             throw new Error(`Unsupported OAuth redirect URI: ${config.redirect_uri}`);
         const verifier = base64url(randomBytes(48));
@@ -70,7 +74,8 @@ export class AuthClient {
             scope: "openid profile email",
             state,
         }).toString();
-        const code = await this.listenForCode(state, () => openBrowser(authorization.toString()));
+        const code = await this.listenForCode(state, () => this.browserOpener(authorization.toString()), progress);
+        progress({ status: "started", step: "token-exchange" });
         const tokens = withAbsoluteExpiry(await this.exchange(config.token_endpoint, new URLSearchParams({
             client_id: config.client_id,
             code,
@@ -78,7 +83,10 @@ export class AuthClient {
             grant_type: "authorization_code",
             redirect_uri: config.redirect_uri,
         })));
+        progress({ status: "completed", step: "token-exchange" });
+        progress({ status: "started", step: "credential-store" });
         await this.credentials.save(tokens);
+        progress({ status: "completed", step: "credential-store" });
         return tokens;
     }
     config() {
@@ -91,19 +99,45 @@ export class AuthClient {
             body,
         });
     }
-    listenForCode(expectedState, ready) {
+    listenForCode(expectedState, ready, progress) {
         return new Promise((resolve, reject) => {
             let settled = false;
-            const finish = (result) => {
+            const sockets = new Set();
+            let authorizationStarted = false;
+            const startAuthorization = () => {
+                if (authorizationStarted)
+                    return;
+                authorizationStarted = true;
+                progress({ status: "completed", step: "browser" });
+                progress({ status: "started", step: "browser-authorization" });
+            };
+            const finish = (result, completedResponseSocket) => {
                 if (settled)
                     return;
                 settled = true;
                 clearTimeout(timeout);
-                server.close();
+                const complete = (closeError) => {
+                    if (closeError)
+                        reject(closeError);
+                    else if ("code" in result) {
+                        progress({ status: "completed", step: "callback-close" });
+                        resolve(result.code);
+                    }
+                    else
+                        reject(result.error);
+                };
                 if ("code" in result)
-                    resolve(result.code);
-                else
-                    reject(result.error);
+                    progress({ status: "started", step: "callback-close" });
+                if (!server.listening) {
+                    complete();
+                    return;
+                }
+                server.close(complete);
+                for (const socket of sockets) {
+                    if (socket !== completedResponseSocket)
+                        socket.destroy();
+                }
+                server.closeIdleConnections();
             };
             const timeout = setTimeout(() => {
                 finish({ error: new Error("Timed out waiting for browser login.") });
@@ -113,8 +147,8 @@ export class AuthClient {
                 const code = url.searchParams.get("code");
                 const oauthError = url.searchParams.get("error_description") ?? url.searchParams.get("error");
                 if (oauthError) {
-                    respond(response, "denied");
-                    finish({ error: new Error(oauthError) });
+                    const responseSocket = response.socket;
+                    respond(response, "denied", () => finish({ error: new Error(oauthError) }, responseSocket));
                     return;
                 }
                 if (url.pathname !== "/callback" ||
@@ -123,19 +157,34 @@ export class AuthClient {
                     respond(response, "invalid");
                     return;
                 }
-                respond(response, "complete");
-                finish({ code });
+                startAuthorization();
+                progress({ status: "completed", step: "browser-authorization" });
+                const responseSocket = response.socket;
+                respond(response, "complete", () => finish({ code }, responseSocket));
+            });
+            server.on("connection", (socket) => {
+                sockets.add(socket);
+                socket.once("close", () => sockets.delete(socket));
             });
             server.once("error", (error) => finish({ error }));
-            server.listen(17655, "localhost", () => void ready().catch((error) => finish({
-                error: error instanceof Error ? error : new Error("Could not open the login browser."),
-            })));
+            progress({ status: "started", step: "callback-server" });
+            server.listen(17655, "localhost", () => {
+                progress({ status: "completed", step: "callback-server" });
+                progress({ status: "started", step: "browser" });
+                void ready()
+                    .then(startAuthorization)
+                    .catch((error) => finish({
+                    error: error instanceof Error ? error : new Error("Could not open the login browser."),
+                }));
+            });
         });
     }
 }
-function respond(response, outcome) {
+function respond(response, outcome, finished) {
     const page = callbackResponse(outcome);
-    response.writeHead(page.status, page.headers);
+    if (finished)
+        response.once("finish", finished);
+    response.writeHead(page.status, { ...page.headers, connection: "close" });
     response.end(page.body);
 }
 async function openBrowser(url) {

package/dist/src/commands.d.ts

@@ -2,12 +2,16 @@ import type { AuthClient } from "./auth.js";
 import type { TonboApi } from "./api.js";
 import type { ConfigStore } from "./config.js";
 import type { ProjectSummary } from "./types.js";
+import { readDefaultSshPublicKeys } from "./ssh-key.js";
+import type { ProgressReporter } from "./progress.js";
 export interface CommandDependencies {
     api: TonboApi;
     auth: AuthClient;
     config: ConfigStore;
     cwd: () => string;
+    defaultSshPublicKeys: typeof readDefaultSshPublicKeys;
     output: (value: unknown) => void;
+    progress: ProgressReporter;
     executable?: () => string;
     secretValue: (name: string, fromEnvironment?: string) => Promise<string>;
 }

package/dist/src/commands.js

@@ -1,6 +1,6 @@
 import { buildRevision, loadDeclaration } from "./declaration.js";
 import { buildSourceBundle, findDeclarationRoot } from "./source.js";
-import { readDefaultSshPublicKeys, readSshPublicKey } from "./ssh-key.js";
+import { readSshPublicKey } from "./ssh-key.js";
 import { launchProjectSsh } from "./ssh.js";
 export async function resolveProject(deps, selector) {
     const oauthToken = await deps.auth.accessToken();
@@ -37,16 +37,55 @@ export function selectProject(projects, selector) {
     return matches[0];
 }
 export async function loginCommand(deps) {
-    await deps.auth.login();
-    const oauthToken = await deps.auth.accessToken();
-    const keys = await readDefaultSshPublicKeys();
-    for (const key of keys)
-        await deps.api.registerSshKey(oauthToken, key);
-    deps.output({
-        message: keys.length
-            ? `Logged in to Tonbo and registered ${keys.length} SSH key${keys.length === 1 ? "" : "s"}.`
-            : "Logged in to Tonbo. No default SSH public key was found; run `tonbo ssh-key add <path.pub>` before using native SSH.",
-    });
+    try {
+        const tokens = await deps.auth.login((event) => reportLoginProgress(deps.progress, event));
+        deps.progress.start("Preparing SSH access");
+        const keys = await deps.defaultSshPublicKeys();
+        await Promise.all(keys.map((key) => deps.api.registerSshKey(tokens.access_token, key)));
+        deps.progress.succeed("SSH access ready");
+        deps.output({ message: "Logged in to Tonbo." });
+    }
+    catch (error) {
+        deps.progress.fail();
+        throw error;
+    }
+}
+const LOGIN_PROGRESS_MESSAGES = {
+    "account-config": {
+        started: "Connecting to Tonbo",
+        completed: "Connected to Tonbo",
+    },
+    "callback-server": {
+        started: "Starting local browser callback",
+        completed: "Local browser callback ready",
+    },
+    browser: {
+        started: "Opening browser",
+        completed: "Browser opened",
+    },
+    "browser-authorization": {
+        started: "Waiting for browser authorization",
+        completed: "Browser authorization received",
+    },
+    "callback-close": {
+        started: "Closing local browser callback",
+        completed: "Local browser callback closed",
+    },
+    "token-exchange": {
+        started: "Exchanging authorization code",
+        completed: "Authorization code exchanged",
+    },
+    "credential-store": {
+        started: "Saving login session",
+        completed: "Login session saved",
+    },
+};
+function reportLoginProgress(progress, event) {
+    const messages = LOGIN_PROGRESS_MESSAGES[event.step];
+    if (event.status === "started")
+        progress.start(messages.started);
+    else
+        progress.succeed(messages.completed);
 }
 export async function sshKeyAddCommand(deps, path) {
     const key = await readSshPublicKey(path);

package/dist/src/progress.d.ts

@@ -0,0 +1,25 @@
+export interface ProgressReporter {
+    start(message: string): void;
+    succeed(message?: string): void;
+    fail(message?: string): void;
+}
+interface ProgressStream {
+    isTTY?: boolean;
+    write(value: string): unknown;
+}
+export declare class TerminalProgress implements ProgressReporter {
+    private readonly stream;
+    private readonly intervalMs;
+    private activeMessage;
+    private frame;
+    private lastWidth;
+    private timer;
+    constructor(stream: ProgressStream, intervalMs?: number);
+    start(message: string): void;
+    succeed(message?: string | undefined): void;
+    fail(message?: string | undefined): void;
+    private finish;
+    private render;
+}
+export declare const silentProgress: ProgressReporter;
+export {};

package/dist/src/progress.js

@@ -0,0 +1,60 @@
+const FRAMES = ["|", "/", "-", "\\"];
+export class TerminalProgress {
+    stream;
+    intervalMs;
+    activeMessage;
+    frame = 0;
+    lastWidth = 0;
+    timer;
+    constructor(stream, intervalMs = 80) {
+        this.stream = stream;
+        this.intervalMs = intervalMs;
+    }
+    start(message) {
+        if (this.activeMessage)
+            this.succeed();
+        this.activeMessage = message;
+        this.frame = 0;
+        if (!this.stream.isTTY) {
+            this.stream.write(`[..] ${message}\n`);
+            return;
+        }
+        this.render(`[${FRAMES[this.frame]}] ${message}`);
+        this.timer = setInterval(() => {
+            this.frame = (this.frame + 1) % FRAMES.length;
+            this.render(`[${FRAMES[this.frame]}] ${this.activeMessage}`);
+        }, this.intervalMs);
+        this.timer.unref();
+    }
+    succeed(message = this.activeMessage) {
+        this.finish("ok", message);
+    }
+    fail(message = this.activeMessage) {
+        this.finish("!!", message);
+    }
+    finish(marker, message) {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        this.activeMessage = undefined;
+        if (!message)
+            return;
+        const line = `[${marker}] ${message}`;
+        if (this.stream.isTTY) {
+            this.render(line);
+            this.stream.write("\n");
+            this.lastWidth = 0;
+            return;
+        }
+        this.stream.write(`${line}\n`);
+    }
+    render(value) {
+        this.stream.write(`\r${value.padEnd(this.lastWidth)}`);
+        this.lastWidth = value.length;
+    }
+}
+export const silentProgress = {
+    start: () => { },
+    succeed: () => { },
+    fail: () => { },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonbo/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Deploy one persistent Agent per Project from the command line.",
   "homepage": "https://tonbo.dev",
   "bugs": {