clementine-agent 1.10.0 → 1.10.2

package/dist/cli/dashboard.js

@@ -4478,7 +4478,19 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                 });
                 return;
             }
-            res.status(500).json({ error: String(err) });
+            // Composio errors carry useful detail in `.error`, `.message`, and
+            // `.status`; serializing with String() drops everything except the name.
+            // Pull whatever's there and log server-side so we have a paper trail.
+            const e = err;
+            const detail = e?.error
+                ? (typeof e.error === 'string' ? e.error : (e.error.message ?? JSON.stringify(e.error)))
+                : (e?.message ?? String(err));
+            console.error(`[composio] authorize ${slug} failed:`, detail, e?.stack ?? '');
+            res.status(500).json({
+                error: detail,
+                toolkit: slug,
+                statusCode: e?.status,
+            });
         }
     });
     app.post('/api/composio/toolkits/:slug/disconnect', async (req, res) => {
@@ -25839,7 +25851,12 @@ async function connectComposio(slug) {
       window.open(d.setupUrl, '_blank');
       return;
     }
-    if (!res.ok) { toast('Connect failed: ' + (d.error || res.status), 'error'); return; }
+    if (!res.ok) {
+      var reason = d.error || ('HTTP ' + res.status);
+      toast('Connect failed: ' + reason, 'error');
+      console.error('[composio] connect failed', { slug: slug, status: res.status, body: d });
+      return;
+    }
     if (d.redirectUrl) {
       window.open(d.redirectUrl, '_blank');
       toast('Opened ' + slug + ' authorization in a new tab. Refresh after approving.', 'info');

package/dist/config.d.ts

@@ -11,6 +11,12 @@ export declare const PKG_DIR: string;
 /** Data home — user data, vault, .env, logs, sessions. */
 export declare const BASE_DIR: string;
 import { shellEscape as _shellEscape } from './config/env-parser.js';
+/**
+ * Look up a config value: local .env first, then process.env fallback.
+ * Keychain refs in either source are resolved lazily; failed resolution
+ * falls through to the fallback rather than returning the literal stub.
+ */
+export declare function getEnv(key: string, fallback?: string): string;
 /** Merged view of process.env overlaid with .env. Use for classifyIntegrations / summarizeIntegrationStatus. */
 export declare function envSnapshot(): Record<string, string | undefined>;
 /** Test-only: clear the keychain ref cache so re-resolution can be tested. */

package/dist/config.js

@@ -84,7 +84,7 @@ function maybeResolveRef(value) {
  * Keychain refs in either source are resolved lazily; failed resolution
  * falls through to the fallback rather than returning the literal stub.
  */
-function getEnv(key, fallback = '') {
+export function getEnv(key, fallback = '') {
     const fromLocal = maybeResolveRef(env[key]);
     if (fromLocal !== undefined && fromLocal !== '')
         return fromLocal;

package/dist/integrations/composio/client.d.ts

@@ -32,6 +32,7 @@ export declare function isComposioEnabled(): boolean;
  * the dashboard PUT /api/settings/COMPOSIO_API_KEY handler.
  */
 export declare function resetComposioClient(): void;
+export declare function getPreferredUserId(): Promise<string>;
 export declare function clementineUserId(): string;
 export declare function displayNameFor(slug: string): string;
 export interface ConnectedToolkit {

package/dist/integrations/composio/client.js

@@ -15,7 +15,18 @@
 import { Composio } from '@composio/core';
 import { ClaudeAgentSDKProvider } from '@composio/claude-agent-sdk';
 import pino from 'pino';
+import { getEnv } from '../../config.js';
 const logger = pino({ name: 'clementine.composio' });
+// `process.env` is intentionally NOT populated from .env (config.ts keeps
+// secrets out of the SDK subprocess). Reading process.env.COMPOSIO_API_KEY
+// directly works during the dashboard's hot-reload (PUT handler mutates
+// process.env), but is empty after a fresh daemon restart even if the key
+// is in .env. Use this helper everywhere we read Composio env vars: it
+// prefers process.env (hot-reload from dashboard) and falls back to the
+// .env file via getEnv (survives restarts).
+function readComposioEnv(key) {
+    return process.env[key] || getEnv(key, '');
+}
 // Curated set surfaced in the dashboard. Composio exposes 1000+ — rendering
 // them all is noisy. Users can still connect anything by editing this list.
 export const CURATED_TOOLKITS = [
@@ -40,6 +51,9 @@ export const CURATED_TOOLKITS = [
     { slug: 'stripe', displayName: 'Stripe', authMode: 'managed' },
     { slug: 'supabase', displayName: 'Supabase', authMode: 'managed' },
     { slug: 'linkedin', displayName: 'LinkedIn', authMode: 'managed' },
+    { slug: 'outlook', displayName: 'Outlook', authMode: 'managed' },
+    { slug: 'onedrive', displayName: 'OneDrive', authMode: 'managed' },
+    { slug: 'zoom', displayName: 'Zoom', authMode: 'managed' },
     { slug: 'twitter', displayName: 'Twitter / X', authMode: 'byo' },
 ];
 const DISPLAY_NAME_BY_SLUG = new Map(CURATED_TOOLKITS.map(t => [t.slug, t.displayName]));
@@ -47,7 +61,7 @@ let singleton = null;
 export function getComposio() {
     if (singleton)
         return singleton;
-    const apiKey = process.env.COMPOSIO_API_KEY;
+    const apiKey = readComposioEnv('COMPOSIO_API_KEY');
     if (!apiKey)
         return null;
     singleton = new Composio({
@@ -57,7 +71,7 @@ export function getComposio() {
     return singleton;
 }
 export function isComposioEnabled() {
-    return Boolean(process.env.COMPOSIO_API_KEY);
+    return Boolean(readComposioEnv('COMPOSIO_API_KEY'));
 }
 /**
  * Discard the cached client + identity cache so the next call to getComposio()
@@ -68,11 +82,54 @@ export function resetComposioClient() {
     singleton = null;
     identityCache.clear();
     toolkitMetaCache = null;
+    detectedPreferredUserId = null;
+}
+// Public: same logic as the internal detector, exposed for the MCP bridge so
+// agent sessions land on the right user_id.
+export async function getPreferredUserId() {
+    const composio = getComposio();
+    if (!composio)
+        return clementineUserId();
+    return detectPreferredUserId(composio);
 }
-// Single-tenant by default. All connections are keyed under COMPOSIO_USER_ID;
-// override if the same Composio account is shared with another tool.
+// Default user_id for *new* connections. We list connections without filtering
+// so existing accounts (set up in Composio's web UI under the platform default
+// "default" user_id, or any other label) still surface — but new authorize()
+// calls have to pass *some* user_id, and we want it to match whatever the
+// user already has if possible. detectPreferredUserId() picks the user_id
+// with the most existing connections, falling back to this constant.
+const DEFAULT_NEW_CONNECTION_USER_ID = 'default';
 export function clementineUserId() {
-    return process.env.COMPOSIO_USER_ID ?? 'clementine-default';
+    return readComposioEnv('COMPOSIO_USER_ID') || DEFAULT_NEW_CONNECTION_USER_ID;
+}
+// Cached after first detection — avoids extra API calls per authorize.
+let detectedPreferredUserId = null;
+async function detectPreferredUserId(composio) {
+    const explicit = readComposioEnv('COMPOSIO_USER_ID');
+    if (explicit)
+        return explicit;
+    if (detectedPreferredUserId)
+        return detectedPreferredUserId;
+    try {
+        const resp = await composio.connectedAccounts.list({ limit: 100 });
+        const counts = new Map();
+        for (const it of resp.items) {
+            const uid = it.userId ?? it.user_id;
+            if (typeof uid === 'string' && uid.length > 0) {
+                counts.set(uid, (counts.get(uid) ?? 0) + 1);
+            }
+        }
+        if (counts.size > 0) {
+            const top = [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+            detectedPreferredUserId = top;
+            return top;
+        }
+    }
+    catch (err) {
+        logger.debug({ err }, 'detectPreferredUserId failed — using default');
+    }
+    detectedPreferredUserId = DEFAULT_NEW_CONNECTION_USER_ID;
+    return DEFAULT_NEW_CONNECTION_USER_ID;
 }
 export function displayNameFor(slug) {
     return DISPLAY_NAME_BY_SLUG.get(slug) ?? humanize(slug);
@@ -226,7 +283,11 @@ export async function listConnectedToolkits() {
     if (!composio)
         return [];
     try {
-        const resp = await composio.connectedAccounts.list({ userIds: [clementineUserId()] });
+        // No userIds filter: a Composio API key is account-scoped, and a personal
+        // agent should see every connection on the account regardless of which
+        // user_id label it was created under. This is the fix for "I connected X
+        // in Composio but it doesn't show up in Clementine."
+        const resp = await composio.connectedAccounts.list({ limit: 100 });
         const enriched = await Promise.all(resp.items.map(async (it) => {
             const seed = extractAccountIdentity(it.state, it.data);
             const identity = it.status === 'ACTIVE'
@@ -359,7 +420,11 @@ export async function authorizeToolkit(slug, opts) {
     // 2. Initiate the connection. allowMultiple if there's already an active
     //    connection so we add another account instead of replacing.
     const existing = (await listConnectedToolkits()).filter(c => c.slug === slug && c.status === 'ACTIVE');
-    const conn = await composio.connectedAccounts.initiate(clementineUserId(), authConfigId, {
+    // Reuse whichever user_id already owns connections in this account, so a
+    // freshly authorized Gmail lands next to the existing Outlook (etc.) under
+    // the same user_id. Falls back to env override or "default".
+    const userId = await detectPreferredUserId(composio);
+    const conn = await composio.connectedAccounts.initiate(userId, authConfigId, {
         ...(existing.length > 0 ? { allowMultiple: true } : {}),
         ...(opts?.callbackUrl ? { callbackUrl: opts.callbackUrl } : {}),
         ...(opts?.alias ? { alias: opts.alias } : {}),

package/dist/integrations/composio/mcp-bridge.js

@@ -17,7 +17,7 @@
  */
 import { createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { clementineUserId, getComposio, listConnectedToolkits, } from './client.js';
+import { getComposio, getPreferredUserId, listConnectedToolkits, } from './client.js';
 const logger = pino({ name: 'clementine.composio.mcp' });
 /**
  * Build SDK MCP server configs for the given toolkit slugs (or all active
@@ -57,7 +57,8 @@ async function buildOne(composio, slug, connected) {
     // auto-create one and 400s for BYO toolkits (Twitter etc.) that don't have
     // a managed OAuth app available.
     const authConfig = (await composio.authConfigs.list({ toolkit: slug })).items[0];
-    const session = await composio.create(clementineUserId(), {
+    const userId = await getPreferredUserId();
+    const session = await composio.create(userId, {
         toolkits: [slug],
         manageConnections: false,
         ...(authConfig ? { authConfigs: { [slug]: authConfig.id } } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",