firedrill-run 3.0.0 → 3.0.1

package/README.md

@@ -9,19 +9,17 @@ Use the CLI yourself, or let a coding agent operate it for you. Local execution
 is not an operating-system sandbox. Approved commands run with your own user
 permissions.
 
-**Release candidate:** the proposed public package is `firedrill-run@3.0.0`.
-It is not published or approved for public activation yet. The existing
-unversioned package resolves to the older product. Do not use `@latest` to
-install this candidate. Once the owner approves and publishes this release,
-the intended commands are:
+## Get started
+
+Use this version explicitly while the unversioned package still points to the
+previous platform:
 
 ```sh
-npx --yes firedrill-run@3.0.0 init
-npx --yes firedrill-run@3.0.0 --help
+npx firedrill-run@3.0.1 init
+npx firedrill-run@3.0.1 --help
 ```
 
-Until then, use only an explicitly supplied private candidate tarball.
-`firedrill --help` of that exact installed candidate is authoritative.
+For automation, `firedrill --help` and `--json` describe the installed version.
 
 ## Requirements
 

package/dist/assembly.json

@@ -1,7 +1,7 @@
 {
   "schema": "firedrill.cli-assembly.v1",
   "package": "firedrill-run",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "entry": "cli/src/main.js",
   "helpers": [
     "cli/runtime/source_snapshot.py",

package/dist/cli/src/auth.js

@@ -130,6 +130,15 @@ export async function login(options) {
             throw new CliError('authorization_exchange_uncertain', 'The original token exchange was interrupted and cannot be safely repeated. Review Account access in the browser. Clear the local attempt with logout --local-only before starting another.', 2);
         if (!pending) {
             const grant = await jsonRequest(new URL(config.device_authorization_endpoint), { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ client_id: config.client_id }), signal: options.signal });
+            if (grant.status === 429) {
+                // No grant exists yet. Report a definitive refusal without creating a
+                // second grant or replaying an unknown device-authorization POST.
+                const wait = grant.retryAfterMs;
+                const advice = wait !== undefined && Number.isFinite(wait) && wait <= 3_600_000
+                    ? ` Wait at least ${Math.max(1, Math.ceil(wait / 1000))} seconds before starting sign-in again.`
+                    : ' Wait before starting sign-in again; do not repeatedly restart it.';
+                throw new CliError('device_authorization_rate_limited', 'Browser sign-in is temporarily busy.' + advice, 2);
+            }
             if (grant.status !== 200)
                 throw new CliError('device_authorization_failed', 'Browser sign-in could not be started.');
             const value = grant.body;
@@ -166,6 +175,7 @@ export async function login(options) {
                 : 'Run the same command to resume if interrupted.'}\n`);
         if (launchBrowser)
             await openBrowser(pending.verification_url);
+        let rateRefusals = 0;
         while (Date.now() < pending.expires_at * 1000) {
             await sleep(Math.min(Math.max(0, pending.next_poll_at - Date.now()), Math.max(0, pending.expires_at * 1000 - Date.now())), undefined, { signal: options.signal });
             options.signal.throwIfAborted();
@@ -183,7 +193,38 @@ export async function login(options) {
                 return finishAuthorization(saved);
             }
             const error = result.body && typeof result.body === 'object' ? result.body.error : undefined;
+            if (result.status === 429) {
+                // A complete, parsed HTTP refusal is distinct from transport/parse
+                // failure or a response that may contain exchanged credentials. Those
+                // uncertain cases keep the polling marker and are never replayed.
+                const body = result.body;
+                if (!body || typeof body !== 'object' || Array.isArray(body)
+                    || ['access_token', 'refresh_token', 'id_token', 'user'].some(key => key in body))
+                    throw new CliError('authorization_exchange_uncertain', 'The authorization response was not confirmed. Review Account access before clearing the original local attempt. No exchange was retried.', 2);
+                rateRefusals += 1;
+                const interval = error === 'slow_down' ? Math.min(3600, pending.interval + 5) : pending.interval;
+                const backoff = Math.min(60_000, 5_000 * 2 ** Math.min(rateRefusals - 1, 4));
+                const minimumWait = Math.max(interval * 1000, result.retryAfterMs ?? backoff);
+                // Never retry earlier than Retry-After or extend the original grant.
+                // An advertised wait beyond that lifetime reaches expiry, not a retry.
+                const deadline = pending.expires_at * 1000;
+                const nextPollAt = Math.min(deadline, Date.now() + minimumWait + Math.floor(Math.random() * 1000));
+                pending = { ...pending, state: 'waiting', interval, next_poll_at: nextPollAt };
+                await savePendingDevice(pending, options.signal);
+                const waitSeconds = Math.max(1, Math.ceil((nextPollAt - Date.now()) / 1000));
+                if (options.json)
+                    process.stdout.write(JSON.stringify({ type: 'authorization_waiting', authorization_id: pending.id,
+                        reason: 'rate_limited', retry_in_seconds: nextPollAt < deadline ? waitSeconds : null,
+                        expires_in: Math.max(0, Math.ceil((deadline - Date.now()) / 1000)),
+                        same_authorization: true, new_device_grant: false }) + '\n');
+                else
+                    process.stderr.write(nextPollAt < deadline
+                        ? `Sign-in is temporarily busy. Waiting ${waitSeconds} seconds before checking the same authorization again.\n`
+                        : 'Sign-in is temporarily busy. Its required wait reaches the original authorization expiry; no new authorization will be started automatically.\n');
+                continue;
+            }
             if (error === 'authorization_pending' || error === 'slow_down') {
+                rateRefusals = 0;
                 // RFC 8628: slow_down permanently adds 5 seconds to the polling interval.
                 const interval = error === 'slow_down' ? Math.min(3600, pending.interval + 5) : pending.interval;
                 pending = { ...pending, state: 'waiting', interval, next_poll_at: Date.now() + interval * 1000 };

package/dist/cli/src/main.js

@@ -745,12 +745,17 @@ export async function main() {
         if (args[0] === 'init') {
             if (Object.keys(parsed.values).some(key => !['json', 'help', 'workspace', 'no-browser', 'open'].includes(key)))
                 throw new CliError('arguments_invalid', 'Use firedrill init with optional --session-only or --persistent, --workspace <id>, --no-browser, --open and --json.', 2);
-            await initCommand(args.slice(1), { json, signal: controller.signal, workspace: parsed.values.workspace,
+            const initialization = await initCommand(args.slice(1), { json, signal: controller.signal, workspace: parsed.values.workspace,
                 openBrowser: !parsed.values['no-browser'], explicitOpen, mode: credentialMode.mode }, emit);
             if (companion) {
                 // Session-only credentials live only in this process: keep serving until
                 // a signal or logout (companion shutdown) stops it.
-                emit('companion_running', { endpoint_ready: true, mode: 'session' }, 'Session-only companion running. Keep this terminal open; other firedrill commands use it. Stop it with Ctrl-C or firedrill logout.');
+                emit('companion_running', { endpoint_ready: true, mode: 'session', initialization_state: initialization.state,
+                    initialization_complete: initialization.state === 'ready',
+                    command_phase_complete: true,
+                    workspace_id: initialization.state === 'ready' ? initialization.workspace_id : null,
+                    process_lifetime: 'until_logout_or_signal',
+                    next_command: initialization.state === 'workspace_pending' ? 'firedrill workspace list --session-only --json' : null }, 'Session-only companion running. Keep this terminal open; other firedrill commands use it. Stop it with Ctrl-C or firedrill logout.');
                 if (!controller.signal.aborted)
                     await once(controller.signal, 'abort');
                 emit('companion_stopping', { reason: signalled ? 'signal' : 'shutdown' }, 'Stopping the companion. In-memory credentials are erased on close.');

package/dist/cli/src/simple/init.js

@@ -1,5 +1,5 @@
 import { api, login } from '../auth.js';
-import { CliError } from '../http.js';
+import { APP_ORIGIN, CliError } from '../http.js';
 import { terminalText } from '../prompts.js';
 import { selectedWorkspace } from '../world-access.js';
 import { machineReport, machineText } from './status.js';
@@ -40,7 +40,41 @@ export async function initCommand(args, options, emit) {
             throw error;
         session = await login({ json: options.json, open: options.openBrowser, explicitOpen: options.explicitOpen, signal: options.signal });
     }
-    const scope = await selectedWorkspace({ workspace: options.workspace, interactive, signal: options.signal, openBrowser });
+    let scope;
+    try {
+        scope = await selectedWorkspace({ workspace: options.workspace, interactive, signal: options.signal, openBrowser });
+    }
+    catch (error) {
+        // Device authorization already succeeded. A durable workspace discovery or
+        // explicit setup step must not erase the only copy of that signed-in session.
+        // Only session-only init owns a companion lifetime; persistent commands and
+        // authorization/transport/cancellation failures retain their normal errors.
+        if (mode !== 'session' || options.signal.aborted || !(error instanceof CliError)
+            || !['workspace_discovery_pending', 'workspace_setup_required'].includes(error.code))
+            throw error;
+        const reason = error.code === 'workspace_discovery_pending' ? 'workspace_discovery_pending' : 'workspace_setup_required';
+        emit('init_pending', {
+            state: 'workspace_pending', reason, authenticated: true, initialization_complete: false,
+            account: { id: session.user.id, email: session.user.email }, workspace_id: null, credential_mode: 'session',
+            companion_required: true, process_lifetime: 'until_logout_or_signal',
+            next_command: 'firedrill workspace list --session-only --json',
+            select_command_template: 'firedrill workspace use <workspace-id> --session-only --json',
+            status_command: 'firedrill status --session-only --json',
+            ...(reason === 'workspace_setup_required' ? { browser_url: new URL('/onboarding', APP_ORIGIN).href,
+                action_required: 'create_or_select_workspace_with_person_approval' } : {}),
+            uploaded: false, model_called: false,
+        }, [
+            `Signed in as ${terminalText(session.user.email)}.`,
+            reason === 'workspace_discovery_pending' ? 'Workspace access is still being checked.' : 'A workspace still needs to be created or selected.',
+            'Initialization is not complete. Keep this terminal open to retain the session-only sign-in.',
+            'In another terminal, run firedrill workspace list --session-only, then firedrill workspace use <workspace-id> --session-only.',
+            'Use only a workspace returned for this account. Normal organization authorization and person approvals still apply.',
+            ...(reason === 'workspace_setup_required' ? [`Workspace setup: ${new URL('/onboarding', APP_ORIGIN).href}`] : []),
+            'After selecting it, firedrill status --session-only shows the current account, workspace and machine.',
+            'Do not start another init while this companion is running. Stop with Ctrl-C or firedrill logout.',
+        ].join('\n'));
+        return { state: 'workspace_pending', reason };
+    }
     const machine = await machineReport(options.signal);
     emit('init', {
         account: { id: session.user.id, email: session.user.email }, workspace_id: scope.workspace, credential_mode: mode, machine,
@@ -58,4 +92,5 @@ export async function initCommand(args, options, emit) {
         ...NEXT.map((step, index) => `  ${index + 1}. ${step.command}\n     ${step.note}`),
         'Nothing was uploaded and no model was called.',
     ].join('\n'));
+    return { state: 'ready', workspace_id: scope.workspace };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firedrill-run",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Local AI agent simulations with cloud-hosted worlds and tools",
   "type": "module",
   "bin": {