@byokit/openclaw 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 0.5.1 (2026-10-02)
+
+- The README points to the shared account-route vocabulary (D18); `routes()` still returns today's table.
+- FIX: ChatGPT sign-in now interrupts abandoned wizard/paste waits on gateway disconnect and reconfirms a new, usable OAuth profile for the selected member through the reconnected engine. Recovery is bounded and fails closed for unknown, missing, pre-existing or unrelated credentials, cancellation and expiry. A synchronous cleanup error during reconnect no longer suppresses the terminal sign-in view.
+
 ## 0.5.0 (2026-10-01)
 
 - Dependency update: pins @byokit/relay 0.5.1.

package/README.md

@@ -243,6 +243,8 @@ The kit writes only under the `stateDir` the app passes. It spawns the engine wi
 (never `process.env`), reads no environment variables except `PATH` to find `npm`, and never bills an API behind the
 person's back (memory search is never a paid provider).
 
+Route data follows the shared account-route vocabulary (D18 in [`docs/runtime-kits.md`](../../docs/runtime-kits.md#21-account-routes-d18)): subscription routes are offered by default, and every other billing is used only when named. The full table of the pinned engine's auth choices is planned work; `routes()` returns today's table.
+
 ## Credential sealing and threat model
 
 The pinned engine has no supported hook for sealing OAuth profile writes. Its `auth-profiles` loader stores

package/dist/kit.d.ts

@@ -52,6 +52,7 @@ export declare class OpenClawKit {
     private readonly approvalsCtl;
     private listeners;
     private off;
+    private signInDisconnects;
     private starting?;
     private stopping;
     private failures;

package/dist/kit.js

@@ -427,6 +427,7 @@ export class OpenClawKit {
     approvalsCtl;
     listeners = new Set();
     off = [];
+    signInDisconnects = new Set();
     starting;
     stopping = false;
     failures = 0;
@@ -535,6 +536,8 @@ export class OpenClawKit {
         const engineFailed = _why === 'engine exited' && this.current.phase === 'failed' && this.current.why === 'exited';
         if (this.stopping || (this.current.phase !== 'ready' && !engineFailed))
             return;
+        for (const fn of this.signInDisconnects)
+            fn();
         void this.disconnect();
         if (this.o.spawnEngine === false) {
             this.setState({ phase: 'failed', why: 'handshake' });
@@ -590,7 +593,8 @@ export class OpenClawKit {
     // sign-in (5.7): every body here is the module's, with this kit's transport, members and ports.
     signInCtx() {
         return { request: (method, params, o) => this.request()(method, params, o),
-            ensure: (member) => this.ensureMember(member), callbackPort: this.o.callbackPort ?? 1455 };
+            ensure: (member) => this.ensureMember(member), callbackPort: this.o.callbackPort ?? 1455,
+            onDisconnect: (fn) => { this.signInDisconnects.add(fn); return () => { this.signInDisconnects.delete(fn); }; } };
     }
     routes() {
         return routeTable();

package/dist/signin.d.ts

@@ -5,6 +5,7 @@ export type SignInCtx = {
         agentId: string;
     }>;
     callbackPort: number;
+    onDisconnect?(fn: () => void): () => void;
 };
 /**
  * Drive the engine's provider-owned login. `on` sees every view the person watches; `done` resolves once, and

package/dist/signin.js

@@ -12,6 +12,7 @@ const START_MS = 60_000;
 const PULL_MS = 120_000;
 const STATUS_MS = 20_000;
 const CANCEL_MS = 10_000;
+const RECONFIRM_MS = 60_000;
 const TURNS = 200;
 const PASTE_MS = 15 * 60_000;
 const cut = (value) => (value instanceof Error ? value.message : String(value)).slice(0, 200);
@@ -25,6 +26,7 @@ export function signIn(ctx, member, o, on) {
     const via = o.via ?? 'browser';
     const owner = new AbortController();
     const { signal } = owner;
+    const driveOwner = new AbortController();
     const wantsCallback = via === 'browser' && o.authChoice === 'openai';
     let server;
     let sessionId = '';
@@ -33,6 +35,24 @@ export function signIn(ctx, member, o, on) {
     let settleStart;
     const startingSettled = new Promise((resolve) => { settleStart = resolve; });
     let over = false;
+    let recovering = false;
+    let offDisconnect;
+    let agentId;
+    let before;
+    // Only ChatGPT's OAuth routes are qualified for auth-reload recovery. No API-key fallback.
+    const reconfirm = o.authChoice === 'openai' || o.authChoice === 'openai-device-code';
+    // Pin models-auth-status: profiles carry {profileId, type, status, expiry: {at, remainingMs, label}}.
+    // Older summaries are not credential proof; a refreshed pre-existing id cannot stand in for this login.
+    const profiles = (status, usable = true) => {
+        const auth = status;
+        if (auth?.unavailable || !Array.isArray(auth?.providers) || auth.providers.some((row) => !row || typeof row !== 'object' || typeof row.provider !== 'string' || !Array.isArray(row.profiles)
+            || row.profiles.some((p) => !p || typeof p.profileId !== 'string' || typeof p.type !== 'string')))
+            return undefined;
+        return new Set(auth.providers.filter((row) => row.provider === 'openai').flatMap((row) => (row.profiles ?? []).filter((p) => p.type === 'oauth' && typeof p.profileId === 'string'
+            && (!usable || ((p.status === 'ok' || p.status === 'expiring') && Number.isFinite(p.expiry?.at)
+                && p.expiry.at > Date.now())))
+            .map((p) => p.profileId)));
+    };
     let approval = false;
     let sawDeviceCode = false;
     let codeExpired = false;
@@ -49,7 +69,10 @@ export function signIn(ctx, member, o, on) {
     let pasteIn;
     let returned;
     const done = new Promise((resolve) => { settle = resolve; });
-    const say = (v) => on({ state: 'waiting', via, ...v });
+    const say = (v) => {
+        if (!over && !recovering && !signal.aborted)
+            on({ state: 'waiting', via, ...v });
+    };
     const closeCallback = async () => {
         const held = server;
         server = undefined;
@@ -61,6 +84,7 @@ export function signIn(ctx, member, o, on) {
             return;
         over = true;
         stopApproval();
+        offDisconnect?.();
         o.signal?.removeEventListener('abort', cancel);
         owner.abort();
         returned = undefined;
@@ -76,7 +100,7 @@ export function signIn(ctx, member, o, on) {
             // and leaves the person locked out of signing in. Waiting for that settlement is what frees the admission.
             await startingSettled;
             if (sessionId)
-                await ctx.request('wizard.cancel', { sessionId }, { timeoutMs: CANCEL_MS }).catch(() => { });
+                await Promise.resolve().then(() => ctx.request('wizard.cancel', { sessionId }, { timeoutMs: CANCEL_MS })).catch(() => { });
         })();
         return releasing;
     };
@@ -130,12 +154,18 @@ export function signIn(ctx, member, o, on) {
         });
     };
     const drive = async () => {
+        const signal = AbortSignal.any([owner.signal, driveOwner.signal]);
         if (wantsCallback) {
             server = await holdCallback().catch(() => undefined);
             if (!server)
                 return { state: 'failed', via, why: 'busy' };
         }
-        const { agentId } = await ctx.ensure(member);
+        ({ agentId } = await ctx.ensure(member));
+        if (reconfirm && ctx.onDisconnect) {
+            before = profiles(await authStatus(ctx.request, agentId).catch(() => undefined), false);
+            if (signal.aborted)
+                return cancelled();
+        }
         // Native login is completed by the person in unmodified Claude Code. The pin does not expose this
         // choice via auth.start; activation verifies the CLI route and persists it only after a live test succeeds.
         if (o.authChoice === 'anthropic-cli' || o.authChoice === 'apiKey') {
@@ -292,10 +322,61 @@ export function signIn(ctx, member, o, on) {
             return expired();
         return error ? { state: 'failed', via, why: 'failed', error: cut(error) } : { state: 'done', via };
     };
+    const disconnected = new Promise((resolve) => {
+        if (reconfirm)
+            offDisconnect = ctx.onDisconnect?.(() => {
+                recovering = true;
+                resolve(undefined); // win the race before the old request's abort/close rejection propagates
+                driveOwner.abort();
+            });
+    });
+    const recover = async () => {
+        const failed = { state: 'failed', via, why: 'failed', error: 'Sign-in could not be confirmed after the gateway restarted. Try again.' };
+        if (!agentId || !before)
+            return failed;
+        const recovery = new AbortController();
+        const recoverySignal = AbortSignal.any([signal, recovery.signal]);
+        let timer;
+        let abort;
+        const end = new Promise((resolve) => {
+            abort = () => resolve(codeExpired ? expired() : cancelled());
+            signal.addEventListener('abort', abort, { once: true });
+            timer = setTimeout(() => resolve(failed), RECONFIRM_MS);
+            if (signal.aborted)
+                abort();
+        });
+        const readback = async () => {
+            while (!recoverySignal.aborted && !over) {
+                const status = await Promise.resolve().then(() => ctx.request('models.authStatus', { agentId, refresh: true }, { timeoutMs: STATUS_MS, signal: recoverySignal })).catch(() => undefined);
+                const after = profiles(status);
+                if (!recoverySignal.aborted && after && [...after].some((p) => !before.has(p)))
+                    return { state: 'done', via };
+                await new Promise((resolve) => {
+                    const stop = () => { clearTimeout(wait); recoverySignal.removeEventListener('abort', stop); resolve(); };
+                    const wait = setTimeout(stop, 1_000);
+                    recoverySignal.addEventListener('abort', stop, { once: true });
+                    if (recoverySignal.aborted)
+                        stop();
+                });
+            }
+            return codeExpired ? expired() : cancelled();
+        };
+        try {
+            return await Promise.race([readback(), end]);
+        }
+        finally {
+            recovery.abort();
+            clearTimeout(timer);
+            signal.removeEventListener('abort', abort);
+        }
+    };
     void (async () => {
         let view;
         try {
-            view = await drive();
+            const driven = await Promise.race([drive(), disconnected]);
+            view = driven ?? await recover();
+            if (signal.aborted)
+                view = codeExpired ? expired() : cancelled();
         }
         catch (error) {
             if (signal.aborted)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "The OpenClaw runtime kit: the pinned engine's full operator surface with plain-words helpers for members, sign-in, runs and approvals.",
   "license": "Apache-2.0",
   "type": "module",