@byokit/openclaw 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 0.19.0 (2026-10-19)
+
+- FEAT: connect Composio through the pinned engine's native MCP OAuth flow, with browser URL handoff and native sign-out.
+
+## 0.18.3 (2026-10-19)
+
+- A signed-in Claude Code login is an account in the kit's account list, and its Claude CLI route's models are listed under it.
+
+## 0.18.2 (2026-10-19)
+
+- A signed-in ChatGPT login lists the Codex CLI route's models in the account model list, marked available.
+
+## 0.18.1 (2026-10-18)
+
+- Dependency update: pins @byokit/accounts 0.28.1.
+- FIX: (from @byokit/accounts 0.28.1) Installed Codex readiness retries a transient account check once and distinguishes timeouts, startup, pipe, exit, protocol and unreadable-reply failures from a confirmed signed-out account, with safe typed probe metadata and no provider messages or stderr.
+
 ## 0.18.0 (2026-10-18)
 
 - Reattach a paired device to a live-kit run by its existing idempotency key: sequenced replay then live events, a bounded journal with typed truncation, and grant-member isolation. Device disconnect does not interrupt the run; engine-restart reconstruction is not included.

package/README.md

@@ -390,6 +390,8 @@ apps can offer them when the app or person opts in, labelled API key (billed per
 `local`) so the app can label what is billed. Proxy routes, compatibility aliases, local runtimes stay off. Native Claude Code sign-in is offered by default. The kit re-checks the installed Claude login at each setup detection and, once it is signed in, restarts the engine onto it. A plan key (OpenCode Go: `kit.addAccount(member, { authChoice: 'opencode-go' }, on)`) asks for `Plan key`; `paste` it and the engine live-tests it before `done`. A paired device starts the same sign-in with either `via` and pastes the key over the sealed link, which keeps it on the host. A run reaches the pinned engine's static Go models (default `opencode-go/deepseek-v4-pro`); the kit keeps OpenCode Go's `x-opencode-session` header on every request, the setup probe included. A live-only Go model such as Muse needs no app config: the kit registers the plan's live catalog with each model's API, so `run({ model: 'opencode-go/muse-spark-1.3-contributor' })` runs on the account (or with `auth: 'apiKey'` on a Go key); an app that sets `config.models.providers['opencode-go'].models` keeps its own list. A choice the pinned Gateway cannot set up has readiness `no_upstream_flow` and is never offered. Pass the accounts the app offers in `KitOptions.offered` (the provider, auth choice or alias each route carries, e.g. `'openrouter'`); the kit allow-lists the plugin of every route those name, so an opted-in sign-in is not blocked. An app can still name a plugin directly in `config.plugins.allow`, and pass the route's `choice` explicitly to `kit.signIn()`.
 Offered provider plugins are allowed by default alongside the app's plugin ids. A route whose provider plugin ships outside the engine (Z.AI's GLM Coding Plan, for one) has readiness `needs_plugin` until the app calls `await kit.installPlugin(route.needs.plugin)`: it installs that plugin into the kit's own engine at exactly the engine's version and pinned npm integrity, keeps it allowed across restarts, and rejects `PluginInstallError` (`code` `version` or `integrity`) with nothing installed on a mismatch. Discovery never installs.
 
+Composio uses its hosted MCP endpoint with the pinned OpenClaw engine's native OAuth client; BYOKit does not maintain a Composio app/tool list or install a separate plugin. `beginComposioSignIn()` configures `https://connect.composio.dev/mcp` for Streamable HTTP OAuth and returns `{ url }`; open it in the browser, then call `completeComposioSignIn()` to wait for OpenClaw's callback and token exchange. OpenClaw stores the OAuth credentials in its engine-owned SQLite state; when the app supplies `authSeal`, the kit seals that state at rest with other engine data. `signOutComposio()` invokes native MCP logout. Composio usage is billed under the person's own Composio plan.
+
 ## API at a glance
 
 Entries:

package/dist/accounts.d.ts

@@ -2,6 +2,7 @@ import { createLocks } from './locks.ts';
 import { type RouteView } from './routes.ts';
 import type { Account, AccountId, AccountPick, Defaults, GatewayTransport, Member, ModelInfo, MoveResult, Room, RunSelection, SignInOptions, SignInView } from './types.ts';
 export declare const modelsOf: (provider: string, answer: unknown) => ModelInfo[];
+export declare const modelsOfAccount: (row: Pick<Account, 'provider' | 'state'>, answer: unknown) => ModelInfo[];
 type IndexEntry = {
     agent: string;
     name: string;

package/dist/accounts.js

@@ -16,7 +16,7 @@ import { KEY_PREFIX, MEMBER_ID, NEW_MEMBER_ID, keyAgentId, untilListed, untilUnl
 import { routes, routeFor } from './routes.js';
 import { words } from './words.js';
 const record = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-// `models.list { agentId, view: 'default' }` rows of the account's provider, mapped to `provider/model`. The pin
+// `models.list { agentId, view: 'all' }` rows of the account's provider, mapped to `provider/model`. The pin
 // reports no per-plan availability, so `why: 'plan'` only comes from a run ending `plan`, never from here.
 export const modelsOf = (provider, answer) => {
     const rows = record(answer) && Array.isArray(answer.models) ? answer.models : [];
@@ -48,6 +48,16 @@ export const modelsOf = (provider, answer) => {
     }
     return out;
 };
+// The account's models: its provider's rows, plus the Codex CLI route's rows when the account is ready. The pin reports
+// those as missing-auth (no auth reaches the Codex route from the ChatGPT login), so the kit, which holds the login, is the
+// signal for them.
+export const modelsOfAccount = (row, answer) => {
+    const own = modelsOf(row.provider, answer);
+    if (row.provider !== 'openai' || row.state !== 'ready')
+        return own;
+    const codex = modelsOf('openai-codex', answer).map(({ why: _why, ...m }) => ({ ...m, available: true }));
+    return [...own, ...codex];
+};
 const ACCOUNT_AGENT = /^[a-z][a-z0-9-]{0,31}--[0-9a-f]{6}$/;
 const usable = (status) => status === 'ok' || status === 'expiring' || status === 'static';
 const IDENTITY = 'IDENTITY.md';
@@ -512,7 +522,14 @@ export function createAccounts(ctx) {
         }
         return { rows, dirty };
     };
-    const gather = (agentId) => Promise.all([rosterOf(), profilesOf(agentId)]);
+    // A detected Claude Code login has no profile in the kit: it stays in Claude Code. The engine's detection says whether
+    // it is there, and a detected one is the member's signed-in claude-cli profile for this read.
+    const claudeDetected = (agentId) => ctx.request('openclaw.setup.detect', { agentId }, { timeoutMs: 20_000 })
+        .then((r) => r.candidates?.some((c) => c.kind === 'claude-cli' && c.credentials === true) === true, () => false);
+    const gather = async (agentId) => {
+        const [roster, profiles, claude] = await Promise.all([rosterOf(), profilesOf(agentId), claudeDetected(agentId)]);
+        return [roster, claude && !profiles.some((p) => p.provider === 'claude-cli') ? [...profiles, { provider: 'claude-cli', status: 'ok' }] : profiles];
+    };
     const buildRows = async (member, agentId) => {
         const file = read(member);
         const [roster, profiles] = await gather(agentId);
@@ -638,7 +655,7 @@ export function createAccounts(ctx) {
         return readModels(row, entry);
     }
     // The shared hold covers the read, so no kit read of the agent is in flight while it is removed.
-    const readModels = (row, entry) => ctx.locks.shared(entry.agent, async () => modelsOf(row.provider, await ctx.request('models.list', { agentId: entry.agent, view: 'default' })));
+    const readModels = (row, entry) => ctx.locks.shared(entry.agent, async () => modelsOfAccount(row, await ctx.request('models.list', { agentId: entry.agent, view: 'all' })));
     async function room(member, id, demand) {
         check(member);
         await ctx.ensure(member);
@@ -812,8 +829,8 @@ export function createAccounts(ctx) {
                 return failed('start_failed', words('move.taken', { name: row.name }));
             // The session's model when the target lists it, else the target's first available; the read takes no shared
             // hold (this move holds the target exclusively). With no answer the fork keeps the parent's own selection.
-            const models = await ctx.request('models.list', { agentId: entry.agent, view: 'default' })
-                .then((answer) => modelsOf(row.provider, answer), () => []);
+            const models = await ctx.request('models.list', { agentId: entry.agent, view: 'all' })
+                .then((answer) => modelsOfAccount(row, answer), () => []);
             const current = typeof session.model !== 'string' ? undefined
                 : (typeof session.modelProvider === 'string' && !session.model.includes('/') ? `${session.modelProvider}/${session.model}` : session.model).toLowerCase();
             const model = models.find((m) => m.id.toLowerCase() === current)?.id ?? models.find((m) => m.available)?.id;

package/dist/bridge.js

@@ -3,6 +3,7 @@ import { randomBytes } from 'node:crypto';
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createServer } from 'node:net';
 import { rm } from 'node:fs/promises';
+import { provider } from '@byokit/accounts';
 import { words } from './words.js';
 /** Newline-framed JSON, one request per connection; anything larger is not a gate request. */
 const FRAME_CAP = 1_000_000;
@@ -38,6 +39,8 @@ export function writePlugin(dir, o) {
         name: 'BYOKit bridge',
         activation: { onStartup: true },
         cliBackends: ['openai-codex'],
+        // The Codex CLI route lists the ChatGPT catalogue's models; the engine lists a plugin route's rows only from here.
+        modelCatalog: { providers: { 'openai-codex': { models: [provider('chatgpt').models.strong, provider('chatgpt').models.fast].map((id) => ({ id, name: id })) } }, discovery: { 'openai-codex': 'static' } },
         contracts: { tools: o.tools.map((t) => t.name), ...(o.browser ? { agentToolResultMiddleware: ['openclaw', 'codex'] } : {}) },
         configSchema: { type: 'object', additionalProperties: false },
     };

package/dist/engine.d.ts

@@ -62,6 +62,14 @@ export declare class Engine {
         output: string;
     }>;
     private get path();
+    private runOwned;
+    private composioMcpLogin?;
+    private composioMcpContext;
+    beginComposioMcpLogin(): Promise<{
+        url: string;
+    }>;
+    completeComposioMcpLogin(): Promise<void>;
+    signOutComposio(): Promise<void>;
     private get claudeFolder();
     doctorContext(): {
         entry: string;

package/dist/engine.js

@@ -341,6 +341,115 @@ export class Engine {
         });
     }
     get path() { return ['/usr/bin', '/bin', ...this.o.enginePath ?? []].join(':'); }
+    async runOwned(binary, args, env, timeoutMs, input) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(binary, args, { cwd: this.root, env, stdio: ['pipe', 'pipe', 'pipe'] });
+            let output = '', timedOut = false;
+            this.started.add(child);
+            const keep = (chunk) => { output = (output + chunk.toString()).slice(-65_536); };
+            child.stdout.on('data', keep);
+            child.stderr.on('data', keep);
+            const timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timeoutMs);
+            child.once('error', error => { clearTimeout(timer); this.started.forget(child); reject(error); });
+            child.once('close', code => { clearTimeout(timer); this.started.forget(child); resolve({ code: timedOut ? null : code, output }); });
+            child.stdin.end(input);
+        });
+    }
+    composioMcpLogin;
+    composioMcpContext() {
+        const { entry, env: inherited } = this.doctorContext();
+        const home = join(this.root, 'home');
+        return { entry, env: { ...inherited, HOME: home, XDG_CONFIG_HOME: join(home, '.config'),
+                XDG_DATA_HOME: join(home, '.local/share'), XDG_STATE_HOME: join(home, '.local/state') } };
+    }
+    beginComposioMcpLogin() {
+        if (this.composioMcpLogin)
+            throw new Error('Composio MCP sign-in is already pending.');
+        const { entry, env } = this.composioMcpContext();
+        const child = spawn(process.execPath, [entry, 'mcp', 'login', 'composio'], {
+            cwd: join(this.root, 'home'), env, stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.started.add(child);
+        let output = '', urlFound = false;
+        let resolveUrl, rejectUrl;
+        let resolveDone;
+        const url = new Promise((resolve, reject) => { resolveUrl = resolve; rejectUrl = reject; });
+        const done = new Promise(resolve => { resolveDone = resolve; });
+        const timer = setTimeout(() => { child.kill('SIGKILL'); rejectUrl(new Error('OpenClaw MCP login did not return an authorization URL.')); }, 30_000);
+        const capture = (chunk) => {
+            output = (output + chunk.toString()).slice(-65_536);
+            const raw = output.match(/https:\/\/[^\s"'<>]+/)?.[0];
+            if (!raw || urlFound)
+                return;
+            try {
+                const parsed = new URL(raw);
+                if (parsed.protocol !== 'https:' || !['connect.composio.dev', 'login.composio.dev'].includes(parsed.hostname)
+                    || parsed.username || parsed.password)
+                    throw new Error('OpenClaw returned an unsafe Composio OAuth URL.');
+                urlFound = true;
+                clearTimeout(timer);
+                resolveUrl(parsed.href);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                rejectUrl(error);
+                child.kill('SIGKILL');
+            }
+        };
+        child.stdout.on('data', capture);
+        child.stderr.on('data', capture);
+        child.once('error', error => {
+            clearTimeout(timer);
+            rejectUrl(error);
+            this.started.forget(child);
+            if (this.composioMcpLogin?.done === done && !urlFound)
+                this.composioMcpLogin = undefined;
+            resolveDone({ code: null, output });
+        });
+        child.once('close', code => {
+            clearTimeout(timer);
+            this.started.forget(child);
+            if (!urlFound) {
+                rejectUrl(new Error(`OpenClaw MCP login exited before authorization URL (exit ${code}).`));
+                if (this.composioMcpLogin?.done === done)
+                    this.composioMcpLogin = undefined;
+            }
+            resolveDone({ code, output });
+        });
+        this.composioMcpLogin = { url, done, child };
+        return url.then(value => ({ url: value }));
+    }
+    async completeComposioMcpLogin() {
+        const pending = this.composioMcpLogin;
+        if (!pending)
+            throw new Error('No Composio MCP sign-in is pending.');
+        try {
+            await pending.url;
+            let timer;
+            const timedOut = new Promise(resolve => { timer = setTimeout(() => resolve(null), 10 * 60_000); timer.unref(); });
+            const result = await Promise.race([pending.done, timedOut]);
+            clearTimeout(timer);
+            if (!result) {
+                pending.child.kill('SIGKILL');
+                await pending.done;
+                throw new Error('Composio MCP sign-in timed out.');
+            }
+            if (result.code !== 0)
+                throw new Error(`Composio MCP sign-in did not complete (OpenClaw exit ${result.code}).`);
+        }
+        finally {
+            if (this.composioMcpLogin?.done === pending.done)
+                this.composioMcpLogin = undefined;
+        }
+    }
+    async signOutComposio() {
+        if (this.composioMcpLogin)
+            throw new Error('Cannot sign out while Composio MCP sign-in is pending.');
+        const { entry, env } = this.composioMcpContext();
+        const result = await this.runOwned(process.execPath, [entry, 'mcp', 'logout', 'composio'], env, 30_000);
+        if (result.code !== 0)
+            throw new Error(`Composio MCP sign-out failed (OpenClaw exit ${result.code}).`);
+    }
     // The engine's own Claude folder: the fallback login writes it and, only with claudeFallback, the gateway reads it.
     get claudeFolder() { return join(this.root, 'home', '.claude'); }
     doctorContext() {
@@ -350,7 +459,8 @@ export class Engine {
                 OPENCLAW_STATE_DIR: join(this.root, 'state'), OPENCLAW_CONFIG_PATH: join(this.root, 'openclaw.json'),
                 // Upstream eagerly imports/refreshes Codex OAuth. Only the CLI may see the person's login.
                 CODEX_HOME: join(home, '.codex'),
-                XDG_CACHE_HOME: join(home, '.cache'), ...this.claudeFallback ? { CLAUDE_CONFIG_DIR: this.claudeFolder } : {},
+                XDG_CACHE_HOME: join(home, '.cache'),
+                ...this.claudeFallback ? { CLAUDE_CONFIG_DIR: this.claudeFolder } : {},
                 TMPDIR: join(this.root, 'tmp'), npm_config_cache: join(this.root, 'npm-cache'), npm_config_userconfig: join(this.root, 'npmrc'),
                 OPENCLAW_NO_RESPAWN: '1', OPENCLAW_SKIP_CHANNELS: '1', OPENCLAW_DISABLE_BONJOUR: '1',
                 OPENCLAW_EXEC_SHELL_SNAPSHOT: '0', OPENCLAW_LOAD_SHELL_ENV: '0', OPENCLAW_GATEWAY_TOKEN: this.token,
@@ -679,6 +789,7 @@ export class Engine {
         await this.starting?.catch(() => { });
         const child = this.child;
         await this.started.terminate(delay);
+        this.composioMcpLogin = undefined;
         if (child && child.exitCode === null && child.signalCode === null)
             throw new Error('engine did not stop; credential store still in use');
         this.child = undefined;

package/dist/kit.d.ts

@@ -131,6 +131,14 @@ export declare class OpenClawKit {
     }>;
     private signInCtx;
     routes(): RouteView[];
+    /** Start Composio's hosted MCP OAuth flow through the pinned engine; return the URL for the app to open. */
+    beginComposioSignIn(): Promise<{
+        url: string;
+    }>;
+    /** Wait for OpenClaw's native MCP OAuth callback and token exchange to finish. */
+    completeComposioSignIn(): Promise<void>;
+    /** Clear the engine-owned native MCP OAuth credential for Composio. */
+    signOutComposio(): Promise<void>;
     /** B7 (5.7): install one external provider plugin a `needs_plugin` route names into this kit's own engine, at its
      * pin; resolves once the restarted gateway lists it enabled at that version. Discovery never installs. Serialized:
      * concurrent installs would race the allow-list update and double-spawn the installer into one engine tree. */

package/dist/kit.js

@@ -1089,6 +1089,17 @@ export class OpenClawKit {
     routes() {
         return routeTable({ plugins: installedPlugins(this.engine.root) });
     }
+    /** Start Composio's hosted MCP OAuth flow through the pinned engine; return the URL for the app to open. */
+    async beginComposioSignIn() {
+        await this.patchConfig({ mcp: { servers: { composio: {
+                        url: 'https://connect.composio.dev/mcp', transport: 'streamable-http', auth: 'oauth', enabled: true,
+                    } } } });
+        return this.engine.beginComposioMcpLogin();
+    }
+    /** Wait for OpenClaw's native MCP OAuth callback and token exchange to finish. */
+    completeComposioSignIn() { return this.engine.completeComposioMcpLogin(); }
+    /** Clear the engine-owned native MCP OAuth credential for Composio. */
+    signOutComposio() { return this.engine.signOutComposio(); }
     /** B7 (5.7): install one external provider plugin a `needs_plugin` route names into this kit's own engine, at its
      * pin; resolves once the restarted gateway lists it enabled at that version. Discovery never installs. Serialized:
      * concurrent installs would race the allow-list update and double-spawn the installer into one engine tree. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "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",
@@ -60,7 +60,7 @@
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"
   },
   "dependencies": {
-    "@byokit/accounts": "0.28.0",
+    "@byokit/accounts": "0.28.1",
     "@byokit/pair": "0.10.4",
     "@byokit/relay": "0.8.2",
     "@byokit/discover": "0.8.4",