@tonbo/cli 0.0.2 → 0.0.4

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,5 +1,11 @@
 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;
@@ -7,7 +13,7 @@ export declare class AuthClient {
     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

@@ -55,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));
@@ -72,7 +74,8 @@ export class AuthClient {
             scope: "openid profile email",
             state,
         }).toString();
-        const code = await this.listenForCode(state, () => this.browserOpener(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,
@@ -80,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() {
@@ -93,10 +99,19 @@ 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;
@@ -104,16 +119,24 @@ export class AuthClient {
                 const complete = (closeError) => {
                     if (closeError)
                         reject(closeError);
-                    else if ("code" in result)
+                    else if ("code" in result) {
+                        progress({ status: "completed", step: "callback-close" });
                         resolve(result.code);
+                    }
                     else
                         reject(result.error);
                 };
+                if ("code" in result)
+                    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(() => {
@@ -124,7 +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" ||
@@ -133,12 +157,26 @@ 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."),
+                }));
+            });
         });
     }
 }

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,12 +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: "Logged in to Tonbo." });
+    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/generated/contracts.d.ts

@@ -184,4 +184,5 @@ export declare const piSessionContract: {
     readonly durable_completion_timeout_seconds: 30;
     readonly session_directory: "/sessions";
     readonly path_template: "/sessions/{session_id}.jsonl";
+    readonly preflight_command: readonly ["/usr/local/bin/artifacts", "runtime", "session-preflight"];
 };

package/dist/src/generated/contracts.js

@@ -217,5 +217,10 @@ export const piSessionContract = {
     "format_version": 3,
     "durable_completion_timeout_seconds": 30,
     "session_directory": "/sessions",
-    "path_template": "/sessions/{session_id}.jsonl"
+    "path_template": "/sessions/{session_id}.jsonl",
+    "preflight_command": [
+        "/usr/local/bin/artifacts",
+        "runtime",
+        "session-preflight"
+    ]
 };

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.2",
+  "version": "0.0.4",
   "description": "Deploy one persistent Agent per Project from the command line.",
   "homepage": "https://tonbo.dev",
   "bugs": {