@reshotdev/screenshot 0.0.1-beta.2 → 0.0.1-beta.20

package/LICENSE

@@ -175,7 +175,7 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
 END OF TERMS AND CONDITIONS
 
-Copyright 2026 Mindy, Inc.
+Copyright 2026 The Plain Works Co., Ltd.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

package/README.md

@@ -1,6 +1,6 @@
 # @reshotdev/screenshot
 
-Product screenshots in documentation go stale within days of a deploy. Manually recapturing them across themes, viewports, and locales is tedious and error-prone. This CLI automates screenshot and video capture in CI/CD, comparing against baselines to detect visual drift before it reaches production docs.
+Product screenshots in documentation go stale within days of a UI change. Manually recapturing them across themes, viewports, and locales is tedious and error-prone. This CLI runs screenshot and video capture against a localhost build, comparing each run against the previous capture so teams can review diffs before docs change.
 
 [![npm](https://img.shields.io/npm/v/@reshotdev/screenshot)](https://www.npmjs.com/package/@reshotdev/screenshot)
 [![CI](https://github.com/reshotdev/screenshot/actions/workflows/ci.yml/badge.svg)](https://github.com/reshotdev/screenshot/actions/workflows/ci.yml)
@@ -21,20 +21,62 @@ Requires Node.js >= 18. Playwright browsers are installed automatically on first
 # 1. Interactive setup wizard
 reshot setup
 
-# 2. Capture screenshots from your config
+# 2. Start your app with a production-like local server
+npm run build
+npm run start
+
+# 3. Capture screenshots from your config
 reshot run
 
-# 3. Review captures in the web UI
+# 4. Review captures in the web UI
 reshot studio
+
+# 5. Publish when you want hosted assets — pass --auto-approve on first run
+reshot publish --auto-approve
 ```
 
+For launch-grade reliability, do not treat `next dev` as the supported capture
+runtime. Use a production-like local server and see the
+[Supported Environments guide](https://reshot.dev/docs/cli/getting-started/supported-environments).
+
+> **First-time setup tip:** pass `--auto-approve` to your first `reshot
+> publish` so newly-captured visuals skip the review queue and become
+> immediately available via `reshot pull`. Without it, every new visual
+> lands in PENDING and is only visible in the studio.
+
+> **OAuth / magic-link / Supabase apps:** skip `auth.loginSteps` and use
+> `playwright codegen $YOUR_APP --save-storage=.reshot/auth-state.json`
+> once, then set `"storageStatePath": ".reshot/auth-state.json"` in your
+> config. See [Authentication](#authentication) below for details.
+
+## Certified Targets
+
+> **Most integrations should omit `target` entirely.** Certified targets
+> are an opt-in contract for production-grade flows once basic capture is
+> working — start without them and add `target` later if you need the
+> stronger guarantees.
+
+This release adds a **Certified Targets** contract for apps that need stronger guarantees than ad hoc capture. Certified targets declare their readiness selectors, localhost runtime, required routes, and expected published assets in `reshot.config.json`, then pass the full doctor/capture/publish/delivery pipeline before release.
+
 ## Configuration
 
-Create `docsync.config.json` in your project root:
+Create `reshot.config.json` in your project root:
 
 ```json
 {
   "baseUrl": "http://localhost:3000",
+  "target": {
+    "key": "docs-app",
+    "displayName": "Docs App",
+    "tier": "certified",
+    "owner": "Docs Team",
+    "baseUrl": "http://localhost:3000",
+    "captureSafe": false,
+    "supportedLocalCommand": "npm run build && npm run start",
+    "defaultAuthMode": "fixture",
+    "requiredEnv": ["PROJECT_ID"],
+    "certificationScenarioKeys": ["dashboard"]
+  },
   "assetDir": ".reshot/output",
   "concurrency": 2,
   "viewport": { "width": 1280, "height": 720 },
@@ -55,6 +97,15 @@ Create `docsync.config.json` in your project root:
       "name": "Dashboard",
       "url": "/dashboard",
       "requiresAuth": true,
+      "captureClass": "fixture-auth",
+      "ready": {
+        "selector": "[data-loaded='true']",
+        "expression": "window.__APP_READY__ === true"
+      },
+      "requiredRoutes": ["/dashboard"],
+      "requiredSelectors": ["[data-testid='dashboard-content']"],
+      "expectedArtifacts": ["overview", "analytics"],
+      "publishPolicy": "required",
       "readySelector": "[data-loaded='true']",
       "steps": [
         { "action": "screenshot", "key": "overview", "description": "Dashboard overview" },
@@ -76,14 +127,27 @@ Create `docsync.config.json` in your project root:
 | `reshot record [title]` | Interactive recording via Chrome DevTools | `--browser`, `--url`, `--port` |
 | `reshot sync` | Upload traces/docs to Reshot platform | `--trace-dir`, `--dry-run` |
 | `reshot studio` | Launch web management UI | `--port`, `--no-open` |
-| `reshot validate` | Check config and bindings | `--strict`, `--fix` |
 | `reshot status` | View project status and sync history | `--jobs`, `--drifts`, `--json` |
 | `reshot publish` | Upload assets with versioning | `--tag`, `--message`, `--dry-run` |
 | `reshot pull` | Generate asset map for builds | `--format json\|ts\|csv`, `--output`, `--status` |
+| `reshot doctor target` | Audit target routes, readiness, and auth contract | `--scenarios`, `--json` |
+| `reshot verify publish` | Validate publish, pull/export, and hosted delivery | `--scenarios`, `--tag`, `--json` |
+| `reshot certify` | Run the full certified-target pipeline | `--scenarios`, `--tag`, `--json` |
 | `reshot drifts` | Manage visual drift notifications | `approve`, `reject`, `ignore`, `approve-all` |
 | `reshot import-tests` | Import Playwright tests as scenarios | `--dry-run`, `--no-interactive` |
-| `reshot ci setup` | Generate CI/CD workflow files | — |
-| `reshot ci run` | Capture + publish in one step (CI) | `--tag`, `--no-publish`, `--dry-run` |
+
+## Certification Workflow
+
+Use these commands when a target app needs release-grade verification:
+
+```bash
+reshot doctor target
+reshot run --scenarios dashboard
+reshot verify publish --tag v1.0.0
+reshot certify --tag v1.0.0
+```
+
+Certification reports are written to `.reshot/reports/certification.json`.
 
 ## Step Types
 
@@ -221,23 +285,44 @@ During recording:
 - Press **C** to start/stop a video clip
 - Press **Q** to quit and save
 
-The recorded scenario is appended to `docsync.config.json` automatically.
+The recorded scenario is appended to `reshot.config.json` automatically.
 
 ## Authentication
 
-### Storage State (from Playwright)
+### Storage State (recommended)
+
+For OAuth, magic-link, Supabase Auth, Clerk, Auth.js, and any other modern
+auth flow that can't be scripted with form fields, capture a Playwright
+storage state once and let reshot reuse it for every scenario:
 
 ```bash
 npx playwright codegen http://localhost:3000 --save-storage=.reshot/auth-state.json
 ```
 
+Then point your config at it:
+
 ```json
 {
   "storageStatePath": ".reshot/auth-state.json"
 }
 ```
 
-### Login Steps
+`reshot record` does the same thing interactively and writes to
+`~/.reshot/session-state.json` by default.
+
+### Test backdoors
+
+If your app has a dev/test backdoor that bypasses auth at the server layer
+(for example a `/api/devtools` fixture endpoint, a header-based
+impersonation hook, or a localhost-only cookie), you can point reshot at it
+via `baseUrl` and skip storage state entirely. This is often the cleanest
+option for first-party apps that already maintain such an endpoint for
+testing.
+
+### Login Steps (password forms only)
+
+If your app still uses a traditional username/password form, you can
+script the login directly:
 
 ```json
 {
@@ -254,6 +339,8 @@ npx playwright codegen http://localhost:3000 --save-storage=.reshot/auth-state.j
 ```
 
 Environment variables (`${EMAIL}`, `${PASSWORD}`) are interpolated at runtime.
+`loginSteps` cannot drive OAuth, magic-link, or any redirect-based flow —
+use **Storage State** above for those.
 
 ## Output Formats
 
@@ -285,63 +372,67 @@ Set `"format": "summary-video"` in scenario output config to record the full bro
 
 Crops the screenshot to the bounding box of the selected element.
 
-## CI/CD Integration
-
-### GitHub Actions
-
-```yaml
-name: Visual Capture
-on:
-  push:
-    branches: [main]
-
-jobs:
-  capture:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npm start &  # start your app
-      - run: npx @reshotdev/screenshot ci run --tag ${{ github.sha }} --message "Deploy ${{ github.sha }}"
-        env:
-          RESHOT_TOKEN: ${{ secrets.RESHOT_TOKEN }}
+## Automation in Scripts
+
+Use headless mode with environment variables to integrate into build scripts or local workflows:
+
+```bash
+# In your Makefile or build script
+export RESHOT_API_KEY=$(cat .reshot/api-key)
+reshot run --scenarios dashboard --no-headless false
+reshot publish --tag v1.2.0
 ```
 
-Or use the setup wizard:
+Set `RESHOT_API_KEY` and `RESHOT_PROJECT_ID` to run without interactive auth:
 
 ```bash
-reshot ci setup
+RESHOT_API_KEY=your-key RESHOT_PROJECT_ID=your-project reshot run
 ```
 
-This generates a `.github/workflows/reshot.yml` tailored to your project.
+For headless execution, ensure:
+- Your app is running on localhost (e.g., `npm run build && npm run start`)
+- `headless: true` is set in `reshot.config.json`
+- API credentials are available as environment variables
 
 ## Asset Map for Builds
 
 Generate a manifest of captured assets for use in documentation sites or marketing pages:
 
 ```bash
-reshot pull --format json --output assets.json --status approved
+reshot pull --format json --output assets.json
 ```
 
+The output is keyed by scenario, visual, and context (variant). `meta` mirrors
+the API response; `assets` is a 3-level nested object — `scenarioKey →
+visualKey → context`:
+
 ```json
 {
-  "assets": [
-    {
-      "key": "dashboard-overview",
-      "variant": "theme-light",
-      "url": "https://cdn.reshot.dev/abc123/dashboard-overview.png",
-      "format": "png",
-      "width": 1280,
-      "height": 720,
-      "version": "v1.2.0"
+  "meta": {
+    "projectId": "...",
+    "exportedAt": "2026-04-30T12:00:00.000Z",
+    "totalVisuals": 12
+  },
+  "assets": {
+    "dashboard": {
+      "overview": {
+        "themeLight": {
+          "type": "image/png",
+          "alt": "Dashboard overview, light theme",
+          "steps": [
+            { "src": "https://cdn.reshot.dev/abc123/overview.png", "step": "overview" }
+          ]
+        },
+        "themeDark": { "...": "..." }
+      }
     }
-  ]
+  }
 }
 ```
 
-Also supports `--format ts` (TypeScript with full metadata) and `--format csv`.
+By default `pull` returns visuals in all states (approved + pending). Pass
+`--status approved` to filter to released visuals only. Also supports
+`--format ts` (TypeScript with full metadata) and `--format csv`.
 
 ## Drift Management
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@reshotdev/screenshot",
-  "version": "0.0.1-beta.2",
-  "description": "CI/CD screenshot and video capture CLI",
+  "version": "0.0.1-beta.20",
+  "description": "Screenshot and video capture CLI",
   "author": "Reshot <hello@reshot.dev>",
   "license": "MIT",
   "homepage": "https://reshot.dev",
@@ -13,12 +13,20 @@
   "publishConfig": {
     "access": "public"
   },
-  "keywords": ["screenshots", "ci-cd", "documentation", "visual-testing", "automation", "playwright"],
+  "keywords": [
+    "screenshots",
+    "cli",
+    "documentation",
+    "visual-testing",
+    "automation",
+    "playwright"
+  ],
   "bin": {
-    "reshot": "./src/index.js"
+    "reshot": "src/index.js"
   },
   "files": [
     "src/",
+    "vendor/compose/dist/",
     "web/manager/dist/",
     "web/cropper/",
     "web/subtitle-editor/",
@@ -28,24 +36,13 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "scripts": {
-    "test": "node scripts/test.js",
-    "test:unit": "node --test tests/unit/*.test.js",
-    "test:integration": "node --test tests/integration/*.test.js",
-    "test:all": "node --test tests/unit/*.test.js tests/integration/*.test.js",
-    "test:dry-run": "node src/index.js --help && node src/index.js --version",
-    "prepublishOnly": "cd web/manager && npm install && npm run build",
-    "ui:build": "cd web/manager && npm install && npm run build",
-    "ui:dev": "cd web/manager && npm install && npm run dev",
-    "lint": "echo 'No linting configured yet'",
-    "pack:check": "npm pack --dry-run"
-  },
   "dependencies": {
     "axios": "^1.6.2",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",
+    "esbuild": "^0.27.2",
     "express": "^4.18.2",
     "form-data": "^4.0.0",
     "fs-extra": "^11.2.0",
@@ -55,10 +52,24 @@
     "ora": "^7.0.1",
     "pixelmatch": "^5.3.0",
     "playwright": "^1.40.0",
+    "playwright-core": "^1.57.0",
     "pngjs": "^7.0.0",
     "sharp": "^0.33.2",
     "socket.io": "^4.7.2",
     "uuid": "^9.0.1",
     "@aws-sdk/client-s3": "^3.650.0"
+  },
+  "scripts": {
+    "test": "node scripts/test.js",
+    "test:unit": "node --test tests/unit/*.test.js",
+    "test:integration": "node --test tests/integration/*.test.js",
+    "test:all": "node --test tests/unit/*.test.js tests/integration/*.test.js",
+    "test:dry-run": "node src/index.js --help && node src/index.js --version",
+    "test:source": "node src/index.js",
+    "ui:build": "cd web/manager && npm install && npm run build",
+    "ui:dev": "cd web/manager && npm install && npm run dev",
+    "lint": "echo 'No linting configured yet'",
+    "build": "pnpm run ui:build",
+    "pack:check": "npm pack --dry-run"
   }
 }

package/src/commands/auth.js

@@ -14,6 +14,7 @@ const pkg = require("../../package.json");
 
 const DEFAULT_CALLBACK_PORT = 3721;
 const POLL_INTERVAL_MS = 2000;
+const DEFAULT_AUTH_TIMEOUT_MS = 15 * 60 * 1000;
 
 const unwrapResponse = (payload) => {
   if (!payload) {
@@ -95,15 +96,27 @@ function startLocalStatusServer(requestedPort, options = {}) {
   });
 }
 
-async function waitForCompletion(apiBaseUrl, authToken, expiresAtIso) {
+async function waitForCompletion(
+  apiBaseUrl,
+  authToken,
+  expiresAtIso,
+  options = {},
+) {
+  const httpClient = options.httpClient || axios;
+  const spinnerFactory = options.spinnerFactory || ora;
   const expiresAt = expiresAtIso
     ? Date.parse(expiresAtIso)
     : Date.now() + 5 * 60 * 1000;
-  const statusSpinner = ora("Waiting for browser authentication…").start();
+  const timeoutMs = Math.max(
+    1,
+    Number(options.timeoutMs || DEFAULT_AUTH_TIMEOUT_MS),
+  );
+  const deadline = Math.min(expiresAt, Date.now() + timeoutMs);
+  const statusSpinner = spinnerFactory("Waiting for browser authentication…").start();
 
   try {
-    while (Date.now() < expiresAt) {
-      const statusResponse = await axios.get(`${apiBaseUrl}/auth/cli/status`, {
+    while (Date.now() < deadline) {
+      const statusResponse = await httpClient.get(`${apiBaseUrl}/auth/cli/status`, {
         params: { token: authToken },
       });
       const payload = unwrapResponse(statusResponse.data);
@@ -127,39 +140,114 @@ async function waitForCompletion(apiBaseUrl, authToken, expiresAtIso) {
       await wait(POLL_INTERVAL_MS);
     }
 
-    throw new Error("Authentication timed out before completion.");
+    throw new Error(
+      "Authentication timed out before completion. Re-run `reshot auth` and use the printed auth URL if the browser handoff stalls.",
+    );
   } catch (error) {
     statusSpinner.fail("Browser authentication failed");
     throw error;
   }
 }
 
-async function verifyApiKey(apiBaseUrl, apiKey) {
-  await axios.get(`${apiBaseUrl}/auth/cli/verify`, {
+async function verifyApiKey(apiBaseUrl, apiKey, httpClient = axios) {
+  const response = await httpClient.get(`${apiBaseUrl}/auth/cli/verify`, {
     headers: {
       Authorization: `Bearer ${apiKey}`,
     },
   });
+  return response?.data || null;
 }
 
-async function authCommand() {
-  const apiBaseUrl = getApiBaseUrl();
+async function authCommand(options = {}) {
+  // Support non-interactive auth via environment variables
+  const envApiKey = options.apiKey || process.env.RESHOT_API_KEY;
+  const envProjectId = options.projectId || process.env.RESHOT_PROJECT_ID;
+  const httpClient = options.httpClient || axios;
+  const openFn = options.openFn || open;
+  const writeSettingsFn = options.writeSettingsFn || writeSettings;
+  const startLocalStatusServerFn =
+    options.startLocalStatusServerFn || startLocalStatusServer;
+  const waitForCompletionFn = options.waitForCompletionFn || waitForCompletion;
+  const verifyApiKeyFn = options.verifyApiKeyFn || verifyApiKey;
+  const spinnerFactory = options.spinnerFactory || ora;
+  const timeoutMs = Number(options.timeoutMs || DEFAULT_AUTH_TIMEOUT_MS);
+  if (envApiKey && envProjectId) {
+    const platformUrl = process.env.RESHOT_PLATFORM_URL || "https://reshot.dev";
+    // Best-effort resolve the project name so settings + the setup report
+    // don't record `projectName: null` on this non-interactive path.
+    let projectName = null;
+    try {
+      const apiBaseUrl = options.apiBaseUrl || getApiBaseUrl();
+      const verified = await verifyApiKeyFn(apiBaseUrl, envApiKey, httpClient);
+      // /auth/cli/verify wraps its payload in an { data: … } envelope.
+      const payload = verified?.data || verified;
+      projectName = payload?.project?.name || null;
+    } catch {
+      // Verification is best-effort here; keep going without the name.
+    }
+    writeSettingsFn({
+      projectId: envProjectId,
+      projectName,
+      apiKey: envApiKey,
+      platformUrl,
+      linkedAt: new Date().toISOString(),
+      cliVersion: pkg.version,
+    });
+    console.log(chalk.green("✔ Authenticated via environment variables"));
+    console.log(
+      chalk.gray(`  Project: ${projectName || envProjectId}`),
+    );
+    console.log(chalk.gray(`  Platform: ${platformUrl}`));
+    return {
+      mode: "cloud-connected",
+      projectId: envProjectId,
+      projectName,
+      platformUrl,
+    };
+  }
+
+  // The browser approval flow requires an interactive session (a human approves
+  // in the browser while the CLI polls). With no TTY and no env credentials we
+  // would otherwise open a browser nobody sees and poll for up to 15 minutes —
+  // i.e. hang. Detect that and exit promptly with actionable guidance.
+  const stdinIsInteractive =
+    typeof options.isInteractive === "boolean"
+      ? options.isInteractive
+      : Boolean(process.stdin && process.stdin.isTTY);
+  if (!stdinIsInteractive) {
+    console.error(
+      chalk.red("✖ `reshot auth` needs an interactive terminal."),
+    );
+    console.error(
+      chalk.gray(
+        "  Run it in an interactive shell to approve in the browser, or set",
+      ),
+    );
+    console.error(
+      chalk.gray(
+        "  RESHOT_API_KEY and RESHOT_PROJECT_ID for non-interactive (CI) auth.",
+      ),
+    );
+    const err = new Error("Interactive terminal required for browser auth");
+    err.code = "ENOTTY";
+    throw err;
+  }
+
+  const apiBaseUrl = options.apiBaseUrl || getApiBaseUrl();
   const explicitPortEnv =
-    process.env.RESHOT_CLI_CALLBACK_PORT ||
-    process.env.DOCSYNC_CLI_CALLBACK_PORT ||
-    "";
+    process.env.RESHOT_CLI_CALLBACK_PORT || "";
   const basePort = parseInt(explicitPortEnv || `${DEFAULT_CALLBACK_PORT}`, 10);
   const hasExplicitPort = Boolean(explicitPortEnv);
 
   let localServer;
   let callbackPort;
-  const spinner = ora("Requesting authentication session…").start();
+  const spinner = spinnerFactory("Requesting authentication session…").start();
 
   try {
     if (hasExplicitPort) {
       // Respect an explicitly configured port and fail fast with a clear error
       // if it is not available.
-      const { server, port } = await startLocalStatusServer(basePort, {
+      const { server, port } = await startLocalStatusServerFn(basePort, {
         explicit: true,
       });
       localServer = server;
@@ -169,12 +257,12 @@ async function authCommand() {
       // but automatically fall back to any available port so users never have
       // to think about port conflicts.
       try {
-        const { server, port } = await startLocalStatusServer(basePort);
+        const { server, port } = await startLocalStatusServerFn(basePort);
         localServer = server;
         callbackPort = port;
       } catch (error) {
         if (error && error.code === "EADDRINUSE") {
-          const { server, port } = await startLocalStatusServer(0);
+          const { server, port } = await startLocalStatusServerFn(0);
           localServer = server;
           callbackPort = port;
           console.log(
@@ -188,12 +276,15 @@ async function authCommand() {
       }
     }
 
-    const initiateResponse = await axios.post(
+    const initiatePayload = {
+      callbackPort,
+      clientVersion: pkg.version,
+      ...(options.projectId ? { projectId: options.projectId } : {}),
+    };
+
+    const initiateResponse = await httpClient.post(
       `${apiBaseUrl}/auth/cli/initiate`,
-      {
-        callbackPort,
-        clientVersion: pkg.version,
-      },
+      initiatePayload,
       { headers: { "Content-Type": "application/json" } }
     );
 
@@ -207,21 +298,47 @@ async function authCommand() {
     spinner.succeed("Authentication session created");
     console.log(chalk.gray(`Token expires at ${expiresAt || "unknown time"}`));
     console.log(chalk.gray(`Settings will be stored in ${SETTINGS_PATH}`));
-
-    await open(authUrl, { wait: false });
+    console.log(chalk.gray("Auth URL:"));
+    console.log(chalk.cyan(authUrl));
     console.log(
-      chalk.blue(
-        "A browser window has been opened. Complete the flow to continue."
-      )
+      chalk.gray(
+        "If the browser did not open, copy the URL above into a browser and complete the approval flow there.",
+      ),
     );
 
-    const status = await waitForCompletion(apiBaseUrl, authToken, expiresAt);
-    await verifyApiKey(apiBaseUrl, status.project.apiKey);
+    let browserOpened = false;
+    try {
+      await openFn(authUrl, { wait: false });
+      browserOpened = true;
+      console.log(
+        chalk.blue(
+          "A browser window has been opened. Approve the session there to continue.",
+        )
+      );
+    } catch (error) {
+      console.log(
+        chalk.yellow(
+          `Could not open a browser automatically: ${error.message}`,
+        ),
+      );
+      console.log(
+        chalk.gray(
+          "Continue by opening the auth URL manually. The CLI will keep waiting for approval.",
+        ),
+      );
+    }
+
+    const status = await waitForCompletionFn(apiBaseUrl, authToken, expiresAt, {
+      httpClient,
+      spinnerFactory,
+      timeoutMs,
+    });
+    await verifyApiKeyFn(apiBaseUrl, status.project.apiKey, httpClient);
 
     // Derive platformUrl from apiBaseUrl (remove /api suffix)
-    const platformUrl = apiBaseUrl.replace(/\/api\/?$/, '') || 'http://localhost:3000';
+    const platformUrl = apiBaseUrl.replace(/\/api\/?$/, '') || 'https://reshot.dev';
 
-    writeSettings({
+    writeSettingsFn({
       projectId: status.project.id,
       projectName: status.project.name,
       apiKey: status.project.apiKey,
@@ -249,6 +366,15 @@ async function authCommand() {
       )
     );
     console.log(chalk.gray(`Settings saved to ${SETTINGS_PATH}`));
+    console.log(chalk.gray("Mode: cloud-connected"));
+    return {
+      mode: "cloud-connected",
+      browserOpened,
+      authUrl,
+      projectId: status.project.id,
+      projectName: status.project.name,
+      platformUrl,
+    };
   } finally {
     if (localServer) {
       localServer.close();
@@ -257,3 +383,6 @@ async function authCommand() {
 }
 
 module.exports = authCommand;
+module.exports.waitForCompletion = waitForCompletion;
+module.exports.verifyApiKey = verifyApiKey;
+module.exports.startLocalStatusServer = startLocalStatusServer;