agor-live 0.17.2 → 0.17.3

package/dist/daemon/services/config.d.ts

@@ -1,7 +1,7 @@
 import { AgorConfig } from '@agor/core/config';
 import { Database } from '@agor/core/db';
 import { Application } from '@agor/core/feathers';
-import { Params, TaskID } from '@agor/core/types';
+import { Params, TaskID, AgenticToolName } from '@agor/core/types';
 
 /**
  * Config Service
@@ -37,6 +37,12 @@ declare class ConfigService {
     resolveApiKey(data: {
         taskId: TaskID;
         keyName: string;
+        /**
+         * Restrict the per-user lookup to this tool's credential bucket. Executors
+         * always pass this; absent it, the resolver falls back to a cross-tool
+         * sweep (legacy behavior preserved for non-SDK callers).
+         */
+        tool?: AgenticToolName;
     }): Promise<{
         apiKey: string | null;
         source: 'user' | 'config' | 'env' | 'native';

package/dist/daemon/services/config.js

@@ -62,7 +62,7 @@ var ConfigService = class {
    * Called via: client.service('config').resolveApiKey({ taskId, keyName })
    */
   async resolveApiKey(data) {
-    const { taskId, keyName } = data;
+    const { taskId, keyName, tool } = data;
     let userId;
     try {
       const tasksService = this.app?.service("tasks");
@@ -75,7 +75,8 @@ var ConfigService = class {
     }
     const result = await resolveApiKey(keyName, {
       userId,
-      db: this.db
+      db: this.db,
+      tool
     });
     return {
       apiKey: result.apiKey ?? null,

package/dist/daemon/services/gateway.js

@@ -12,8 +12,8 @@ import {
   hasConnector,
   parseGitHubThreadId
 } from "@agor/core/gateway";
-import { resolveModelConfig } from "@agor/core/models";
-import { getDefaultPermissionMode, SessionStatus } from "@agor/core/types";
+import { resolveSessionDefaults } from "@agor/core/sessions";
+import { SessionStatus } from "@agor/core/types";
 function hasListeningConfig(channel) {
   const config = channel.config;
   switch (channel.channel_type) {
@@ -333,9 +333,23 @@ var GatewayService = class {
     let mcpAuthWarning;
     const agenticConfig = channel.agentic_config;
     const agenticTool = agenticConfig?.agent ?? "claude-code";
-    const userDefaults = user.default_agentic_config?.[agenticTool];
-    const permissionMode = agenticConfig?.permissionMode ?? userDefaults?.permissionMode ?? getDefaultPermissionMode(agenticTool);
-    const modelConfig = agenticConfig?.modelConfig ?? userDefaults?.modelConfig;
+    const {
+      permission_config: gatewayPermissionConfig,
+      model_config: gatewayModelConfig,
+      mcp_server_ids: gatewayMcpServerIds
+    } = resolveSessionDefaults({
+      agenticTool,
+      user,
+      overrides: {
+        permissionMode: agenticConfig?.permissionMode,
+        modelConfig: agenticConfig?.modelConfig,
+        codexSandboxMode: agenticConfig?.codexSandboxMode,
+        codexApprovalPolicy: agenticConfig?.codexApprovalPolicy,
+        codexNetworkAccess: agenticConfig?.codexNetworkAccess,
+        mcpServerIds: agenticConfig?.mcpServerIds
+      }
+    });
+    const permissionMode = gatewayPermissionConfig.mode;
     if (existingMapping) {
       sessionId = existingMapping.session_id;
       await this.threadMapRepo.updateLastMessage(existingMapping.id);
@@ -387,8 +401,8 @@ var GatewayService = class {
         unix_username: user.unix_username ?? null,
         status: SessionStatus.IDLE,
         agentic_tool: agenticTool,
-        permission_config: { mode: permissionMode },
-        model_config: resolveModelConfig(modelConfig),
+        permission_config: gatewayPermissionConfig,
+        model_config: gatewayModelConfig,
         tasks: [],
         // Denormalized gateway metadata (immutable snapshot at creation time)
         // Avoids N+1 lookups when rendering board cards
@@ -398,15 +412,14 @@ var GatewayService = class {
       });
       sessionId = session.session_id;
       created = true;
-      const mcpServerIds = agenticConfig?.mcpServerIds;
-      if (mcpServerIds && mcpServerIds.length > 0) {
+      if (gatewayMcpServerIds.length > 0) {
         await sessionsService.setMCPServers(
           session.session_id,
-          mcpServerIds,
+          gatewayMcpServerIds,
           "gateway"
         );
         const unauthedMcpNames = [];
-        for (const serverId of mcpServerIds) {
+        for (const serverId of gatewayMcpServerIds) {
           try {
             const server = await this.mcpServerRepo.findById(serverId);
             if (server?.auth?.type === "oauth") {
@@ -480,18 +493,18 @@ var GatewayService = class {
 
 ${promptText}`;
       }
-      const response = await promptService.create(
+      const task = await promptService.create(
         { prompt: promptText, permissionMode, messageSource: "gateway" },
         { route: { id: sessionId }, user }
       );
-      if (response.queued) {
+      if (task.status === "queued") {
         console.log(
-          `[gateway] Message queued for session ${sessionId.substring(0, 8)} at position ${response.queue_position}`
+          `[gateway] Message queued for session ${sessionId.substring(0, 8)} at position ${task.queue_position}`
         );
         this.sendDebugMessage(
           channel,
           data.thread_id,
-          `Session is busy, message queued at position ${response.queue_position}`
+          `Session is busy, message queued at position ${task.queue_position}`
         );
       } else {
         console.log(

package/dist/daemon/services/mcp-servers.d.ts

@@ -1,5 +1,5 @@
 import { Database } from '@agor/core/db';
-import { QueryParams, MCPServer, CreateMCPServerInput, UpdateMCPServerInput, Paginated } from '@agor/core/types';
+import { QueryParams, MCPServer, CreateMCPServerInput, UpdateMCPServerInput } from '@agor/core/types';
 import { DrizzleService } from '../adapters/drizzle.js';
 
 /**
@@ -28,7 +28,12 @@ declare class MCPServersService extends DrizzleService<MCPServer, CreateMCPServe
     /**
      * Override find to support filter params
      */
-    find(params?: MCPServerParams): Promise<MCPServer[] | Paginated<MCPServer>>;
+    find(params?: MCPServerParams): Promise<MCPServer[] | {
+        total: number;
+        limit: number;
+        skip: number;
+        data: MCPServer[];
+    }>;
     /**
      * Custom method: Find by scope
      */

package/dist/daemon/services/repos.js

@@ -343,7 +343,9 @@ function spawnExecutorLocal(payload, options) {
       ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY,
       ANTHROPIC_AUTH_TOKEN: env.ANTHROPIC_AUTH_TOKEN,
       ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL,
+      CLAUDE_CODE_OAUTH_TOKEN: env.CLAUDE_CODE_OAUTH_TOKEN,
       OPENAI_API_KEY: env.OPENAI_API_KEY,
+      OPENAI_BASE_URL: env.OPENAI_BASE_URL,
       GEMINI_API_KEY: env.GEMINI_API_KEY,
       GOOGLE_API_KEY: env.GOOGLE_API_KEY
     }).filter(([_, v]) => v !== void 0)

package/dist/daemon/services/sessions.d.ts

@@ -135,7 +135,7 @@ declare class SessionsService extends DrizzleService<Session, Partial<Session>,
     /**
      * Custom method: Trigger queue processing
      *
-     * Processes the next queued message for an idle session.
+     * Drains the next queued task for an idle session.
      * Used by callback system to trigger immediate queue processing.
      *
      * NOTE: The actual implementation is provided by index.ts via setQueueProcessor

package/dist/daemon/services/sessions.js

@@ -8,6 +8,7 @@ import {
 } from "@agor/core/db";
 import { Forbidden as Forbidden2 } from "@agor/core/feathers";
 import { resolveModelConfig } from "@agor/core/models";
+import { resolveSessionDefaults } from "@agor/core/sessions";
 import { ROLES as ROLES2, SessionStatus } from "@agor/core/types";
 
 // src/adapters/drizzle.ts
@@ -517,25 +518,16 @@ var SessionsService = class extends DrizzleService {
       if (userId && this.app) {
         try {
           const user = await this.app.service("users").get(userId, params);
-          const toolDefaults = user?.default_agentic_config?.[targetTool];
-          if (toolDefaults) {
-            permissionConfig = {
-              mode: toolDefaults.permissionMode,
-              ...targetTool === "codex" && toolDefaults.codexSandboxMode && toolDefaults.codexApprovalPolicy ? {
-                codex: {
-                  sandboxMode: toolDefaults.codexSandboxMode,
-                  approvalPolicy: toolDefaults.codexApprovalPolicy,
-                  networkAccess: toolDefaults.codexNetworkAccess
-                }
-              } : {}
-            };
-            modelConfig = resolveModelConfig(toolDefaults.modelConfig) ?? modelConfig;
-          }
+          const userResolved = resolveSessionDefaults({ agenticTool: targetTool, user });
+          permissionConfig = userResolved.permission_config;
+          modelConfig = userResolved.model_config ?? modelConfig;
         } catch (error) {
           console.warn(
-            "Could not fetch user preferences for spawned session, using parent settings:",
+            "Could not fetch user preferences for spawned session, using system defaults:",
             error
           );
+          const sysResolved = resolveSessionDefaults({ agenticTool: targetTool });
+          permissionConfig = sysResolved.permission_config;
         }
       }
     }
@@ -656,7 +648,7 @@ ${data.extraInstructions}`;
   /**
    * Custom method: Trigger queue processing
    *
-   * Processes the next queued message for an idle session.
+   * Drains the next queued task for an idle session.
    * Used by callback system to trigger immediate queue processing.
    *
    * NOTE: The actual implementation is provided by index.ts via setQueueProcessor

package/dist/daemon/services/tasks.js

@@ -465,7 +465,7 @@ var TasksService = class extends DrizzleService {
         promptText = typeof firstUser.content === "string" ? firstUser.content : Array.isArray(firstUser.content) ? firstUser.content.filter((b) => b.type === "text").map((b) => b.text || "").join("\n\n") : "";
       }
       if (!promptText) {
-        promptText = task.description || btwSession.title || "(no prompt)";
+        promptText = task.full_prompt?.substring(0, 120) || btwSession.title || "(no prompt)";
       }
       const assistantMessages = messageList.filter((msg) => msg.role === "assistant").sort((a, b) => (b.index || 0) - (a.index || 0));
       let responseText = "";
@@ -547,7 +547,7 @@ var TasksService = class extends DrizzleService {
         return;
       }
       const includeOriginalPrompt = childSession.callback_config?.include_original_prompt ?? targetSession.callback_config?.include_original_prompt ?? false;
-      const spawnPrompt = includeOriginalPrompt ? task.description || "(no prompt available)" : void 0;
+      const spawnPrompt = includeOriginalPrompt ? task.full_prompt?.substring(0, 120) || "(no prompt available)" : void 0;
       let lastAssistantMessage;
       const includeLastMessage = childSession.callback_config?.include_last_message ?? targetSession.callback_config?.include_last_message ?? true;
       if (includeLastMessage) {
@@ -596,7 +596,6 @@ var TasksService = class extends DrizzleService {
       };
       const customTemplate = targetSession.callback_config?.template;
       const callbackMessage = renderChildCompletionCallback(context, customTemplate);
-      const messageRepo = new MessagesRepository(this.db);
       if (!targetSession.created_by) {
         console.warn(
           `\u26A0\uFE0F  [TasksService] Cannot queue callback: target session ${targetSessionId.substring(0, 8)} has no creator (anonymous session)`
@@ -604,15 +603,22 @@ var TasksService = class extends DrizzleService {
         return;
       }
       const callbackCreator = childSession.callback_config?.callback_created_by ?? targetSession.created_by;
-      await messageRepo.createQueued(targetSessionId, callbackMessage, {
-        is_agor_callback: true,
-        source: "agor",
-        child_session_id: childSession.session_id,
-        child_task_id: task.task_id,
-        queued_by_user_id: callbackCreator
+      const callbackTask = await this.taskRepo.createPending({
+        session_id: targetSessionId,
+        full_prompt: callbackMessage,
+        created_by: callbackCreator,
+        status: TaskStatus.QUEUED,
+        metadata: {
+          is_agor_callback: true,
+          source: "agor",
+          child_session_id: childSession.session_id,
+          child_task_id: task.task_id,
+          queued_by_user_id: callbackCreator
+        }
       });
+      this.emit?.("queued", callbackTask);
       console.log(
-        `\u{1F514} Queued callback to ${targetSessionId.substring(0, 8)} from child ${childSession.session_id.substring(0, 8)}`
+        `\u{1F514} Queued callback task ${callbackTask.task_id.substring(0, 8)} on session ${targetSessionId.substring(0, 8)} from child ${childSession.session_id.substring(0, 8)}`
       );
     } catch (error) {
       console.error(

package/dist/daemon/services/terminals.js

@@ -114,7 +114,9 @@ function spawnExecutorLocal(payload, options) {
       ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY,
       ANTHROPIC_AUTH_TOKEN: env.ANTHROPIC_AUTH_TOKEN,
       ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL,
+      CLAUDE_CODE_OAUTH_TOKEN: env.CLAUDE_CODE_OAUTH_TOKEN,
       OPENAI_API_KEY: env.OPENAI_API_KEY,
+      OPENAI_BASE_URL: env.OPENAI_BASE_URL,
       GEMINI_API_KEY: env.GEMINI_API_KEY,
       GOOGLE_API_KEY: env.GOOGLE_API_KEY
     }).filter(([_, v]) => v !== void 0)

package/dist/daemon/services/users.d.ts

@@ -1,5 +1,5 @@
 import * as _agor_core_types from '@agor/core/types';
-import { Params, Paginated, User, UserID, UserRole, EnvVarScope } from '@agor/core/types';
+import { Params, Paginated, User, UserID, UserRole, AgenticToolsUpdate, EnvVarScope, AgenticToolName, AgenticToolsConfig } from '@agor/core/types';
 import { Database } from '@agor/core/db';
 
 /**
@@ -28,11 +28,12 @@ interface UpdateUserData {
     avatar?: string;
     preferences?: Record<string, unknown>;
     onboarding_completed?: boolean;
-    api_keys?: {
-        ANTHROPIC_API_KEY?: string | null;
-        OPENAI_API_KEY?: string | null;
-        GEMINI_API_KEY?: string | null;
-    };
+    /**
+     * Per-tool credential patch. Each tool's sub-object is a partial patch —
+     * `string` sets and encrypts, `null` clears, omitted fields are untouched.
+     * Field names are env var names exported into the SDK CLI environment.
+     */
+    agentic_tools?: AgenticToolsUpdate;
     env_vars?: Record<string, string | null>;
     env_var_scopes?: Record<string, EnvVarScope>;
     default_agentic_config?: _agor_core_types.DefaultAgenticConfig;
@@ -50,7 +51,7 @@ declare class UsersService {
     /**
      * Get user by ID
      */
-    get(id: UserID, _params?: Params): Promise<User>;
+    get(id: UserID, params?: Params): Promise<User>;
     /**
      * Create new user
      */
@@ -58,7 +59,7 @@ declare class UsersService {
     /**
      * Update user
      */
-    patch(id: UserID, data: UpdateUserData, _params?: Params): Promise<User>;
+    patch(id: UserID, data: UpdateUserData, params?: Params): Promise<User>;
     /**
      * Delete user
      */
@@ -72,10 +73,19 @@ declare class UsersService {
      */
     verifyPassword(user: User, password: string): Promise<boolean>;
     /**
-     * Get decrypted API key for a user
-     * Used by key resolution service
+     * Get a single decrypted credential field scoped to a specific agentic tool.
+     *
+     * Replaces the legacy flat-namespace `getApiKey(userId, 'ANTHROPIC_API_KEY')`
+     * call site with `(userId, 'claude-code', 'ANTHROPIC_API_KEY')` so an
+     * Anthropic key stored on the user can no longer leak into a Codex spawn.
+     */
+    getToolConfigField<T extends AgenticToolName>(userId: UserID, tool: T, field: keyof AgenticToolsConfig[T] & string): Promise<string | undefined>;
+    /**
+     * Get the full decrypted credential bag for one tool. Used when spawning an
+     * SDK so the executor environment receives only that tool's env vars.
+     * Returns `null` if the user has no stored config for the tool.
      */
-    getApiKey(userId: UserID, keyName: 'ANTHROPIC_API_KEY' | 'OPENAI_API_KEY' | 'GEMINI_API_KEY'): Promise<string | undefined>;
+    getToolConfig<T extends AgenticToolName>(userId: UserID, tool: T): Promise<AgenticToolsConfig[T] | null>;
     /**
      * Get decrypted environment variables for a user (ALL scopes).
      *
@@ -89,6 +99,12 @@ declare class UsersService {
      *
      * @param row - Database row
      * @param includePassword - Include password field (for authentication only)
+     * @param requesterId - Authenticated user making the request. When equal to
+     *   the row's `user_id`, the returned DTO includes `agentic_tools_public_values`
+     *   (decrypted plaintext for the whitelisted non-secret fields like
+     *   `OPENAI_BASE_URL` / `ANTHROPIC_BASE_URL`). For any other requester —
+     *   including admins viewing someone else's profile — public values are
+     *   omitted, since base URLs can leak internal hostnames.
      */
     private rowToUser;
 }

package/dist/daemon/services/users.js

@@ -20,7 +20,38 @@ import {
   users
 } from "@agor/core/db";
 import { isLikelyGitToken } from "@agor/core/git";
-import { normalizeRole, ROLES } from "@agor/core/types";
+import {
+  extractAgenticToolsPublicValues,
+  normalizeRole,
+  ROLES,
+  toAgenticToolsStatus
+} from "@agor/core/types";
+function applyAgenticToolsPatch(current, patch) {
+  const next = { ...current };
+  for (const [tool, fields] of Object.entries(patch)) {
+    if (!fields) continue;
+    const bucket = { ...next[tool] ?? {} };
+    for (const [field, value] of Object.entries(fields)) {
+      if (value === null || value === void 0) {
+        delete bucket[field];
+      } else {
+        try {
+          bucket[field] = encryptApiKey(value);
+          console.log(`\u{1F510} Encrypted user agentic_tools.${tool}.${field}`);
+        } catch (err) {
+          console.error(`Failed to encrypt agentic_tools.${tool}.${field}:`, err);
+          throw new Error(`Failed to encrypt agentic_tools.${tool}.${field}`);
+        }
+      }
+    }
+    if (Object.keys(bucket).length > 0) {
+      next[tool] = bucket;
+    } else {
+      delete next[tool];
+    }
+  }
+  return next;
+}
 var UsersService = class {
   constructor(db) {
     this.db = db;
@@ -31,6 +62,7 @@ var UsersService = class {
   async find(params) {
     const email = params?.query?.email;
     const includePassword = !!email;
+    const requesterId = params?.user?.user_id;
     let rows;
     if (email) {
       const row = await select(this.db).from(users).where(eq(users.email, email)).one();
@@ -38,7 +70,7 @@ var UsersService = class {
     } else {
       rows = await select(this.db).from(users).all();
     }
-    const results = rows.map((row) => this.rowToUser(row, includePassword));
+    const results = rows.map((row) => this.rowToUser(row, includePassword, requesterId));
     return {
       total: results.length,
       limit: results.length,
@@ -49,12 +81,13 @@ var UsersService = class {
   /**
    * Get user by ID
    */
-  async get(id, _params) {
+  async get(id, params) {
     const row = await select(this.db).from(users).where(eq(users.user_id, id)).one();
     if (!row) {
       throw new Error(`User not found: ${id}`);
     }
-    return this.rowToUser(row);
+    const requesterId = params?.user?.user_id;
+    return this.rowToUser(row, false, requesterId);
   }
   /**
    * Create new user
@@ -89,7 +122,7 @@ var UsersService = class {
   /**
    * Update user
    */
-  async patch(id, data, _params) {
+  async patch(id, data, params) {
     const now = /* @__PURE__ */ new Date();
     const updates = { updated_at: now };
     if (data.password) {
@@ -105,26 +138,11 @@ var UsersService = class {
     if (data.unix_username !== void 0) updates.unix_username = data.unix_username;
     if (data.onboarding_completed !== void 0)
       updates.onboarding_completed = data.onboarding_completed;
-    if (data.avatar || data.preferences || data.api_keys || data.env_vars || data.env_var_scopes || data.default_agentic_config) {
+    if (data.avatar || data.preferences || data.agentic_tools || data.env_vars || data.env_var_scopes || data.default_agentic_config) {
       const current = await this.get(id);
       const currentRow = await select(this.db).from(users).where(eq(users.user_id, id)).one();
       const currentData = currentRow?.data;
-      const encryptedKeys = currentData?.api_keys || {};
-      if (data.api_keys) {
-        for (const [key, value] of Object.entries(data.api_keys)) {
-          if (value === null || value === void 0) {
-            delete encryptedKeys[key];
-          } else {
-            try {
-              encryptedKeys[key] = encryptApiKey(value);
-              console.log(`\u{1F510} Encrypted user API key: ${key}`);
-            } catch (err) {
-              console.error(`Failed to encrypt ${key}:`, err);
-              throw new Error(`Failed to encrypt ${key}`);
-            }
-          }
-        }
-      }
+      const nextAgenticTools = data.agentic_tools ? applyAgenticToolsPatch(currentData?.agentic_tools ?? {}, data.agentic_tools) : currentData?.agentic_tools ?? {};
       const normalizedExisting = normalizeStoredEnvMap(currentData?.env_vars);
       const nextEnvVars = { ...normalizedExisting };
       if (data.env_vars) {
@@ -182,7 +200,7 @@ var UsersService = class {
       updates.data = {
         avatar: data.avatar ?? current.avatar,
         preferences: data.preferences ?? current.preferences,
-        api_keys: Object.keys(encryptedKeys).length > 0 ? encryptedKeys : void 0,
+        agentic_tools: Object.keys(nextAgenticTools).length > 0 ? nextAgenticTools : void 0,
         env_vars: Object.keys(nextEnvVars).length > 0 ? nextEnvVars : void 0,
         default_agentic_config: data.default_agentic_config ?? current.default_agentic_config
       };
@@ -191,7 +209,8 @@ var UsersService = class {
     if (!row) {
       throw new Error(`User not found: ${id}`);
     }
-    return this.rowToUser(row);
+    const requesterId = params?.user?.user_id;
+    return this.rowToUser(row, false, requesterId);
   }
   /**
    * Delete user
@@ -217,22 +236,47 @@ var UsersService = class {
     return compare(password, row.password);
   }
   /**
-   * Get decrypted API key for a user
-   * Used by key resolution service
+   * Get a single decrypted credential field scoped to a specific agentic tool.
+   *
+   * Replaces the legacy flat-namespace `getApiKey(userId, 'ANTHROPIC_API_KEY')`
+   * call site with `(userId, 'claude-code', 'ANTHROPIC_API_KEY')` so an
+   * Anthropic key stored on the user can no longer leak into a Codex spawn.
    */
-  async getApiKey(userId, keyName) {
+  async getToolConfigField(userId, tool, field) {
     const row = await select(this.db).from(users).where(eq(users.user_id, userId)).one();
     if (!row) return void 0;
     const data = row.data;
-    const encryptedKey = data.api_keys?.[keyName];
-    if (!encryptedKey) return void 0;
+    const encrypted = data.agentic_tools?.[tool]?.[field];
+    if (!encrypted) return void 0;
     try {
-      return decryptApiKey(encryptedKey);
+      return decryptApiKey(encrypted);
     } catch (err) {
-      console.error(`Failed to decrypt ${keyName} for user ${userId}:`, err);
+      console.error(`Failed to decrypt agentic_tools.${tool}.${field} for user ${userId}:`, err);
       return void 0;
     }
   }
+  /**
+   * Get the full decrypted credential bag for one tool. Used when spawning an
+   * SDK so the executor environment receives only that tool's env vars.
+   * Returns `null` if the user has no stored config for the tool.
+   */
+  async getToolConfig(userId, tool) {
+    const row = await select(this.db).from(users).where(eq(users.user_id, userId)).one();
+    if (!row) return null;
+    const data = row.data;
+    const fields = data.agentic_tools?.[tool];
+    if (!fields || Object.keys(fields).length === 0) return null;
+    const out = {};
+    for (const [field, encrypted] of Object.entries(fields)) {
+      if (!encrypted) continue;
+      try {
+        out[field] = decryptApiKey(encrypted);
+      } catch (err) {
+        console.error(`Failed to decrypt agentic_tools.${tool}.${field} for user ${userId}:`, err);
+      }
+    }
+    return Object.keys(out).length > 0 ? out : null;
+  }
   /**
    * Get decrypted environment variables for a user (ALL scopes).
    *
@@ -260,8 +304,14 @@ var UsersService = class {
    *
    * @param row - Database row
    * @param includePassword - Include password field (for authentication only)
+   * @param requesterId - Authenticated user making the request. When equal to
+   *   the row's `user_id`, the returned DTO includes `agentic_tools_public_values`
+   *   (decrypted plaintext for the whitelisted non-secret fields like
+   *   `OPENAI_BASE_URL` / `ANTHROPIC_BASE_URL`). For any other requester —
+   *   including admins viewing someone else's profile — public values are
+   *   omitted, since base URLs can leak internal hostnames.
    */
-  rowToUser(row, includePassword = false) {
+  rowToUser(row, includePassword = false, requesterId) {
     const data = row.data;
     const normalizedEnvVars = normalizeStoredEnvMap(data.env_vars);
     const envVarMetadata = Object.keys(normalizedEnvVars).length > 0 ? Object.fromEntries(
@@ -283,12 +333,12 @@ var UsersService = class {
       must_change_password: !!row.must_change_password,
       created_at: row.created_at,
       updated_at: row.updated_at ?? void 0,
-      // Return key status (boolean), NOT actual keys
-      api_keys: data.api_keys ? {
-        ANTHROPIC_API_KEY: !!data.api_keys.ANTHROPIC_API_KEY,
-        OPENAI_API_KEY: !!data.api_keys.OPENAI_API_KEY,
-        GEMINI_API_KEY: !!data.api_keys.GEMINI_API_KEY
-      } : void 0,
+      // Per-tool credential presence (boolean only — never expose decrypted values).
+      agentic_tools: toAgenticToolsStatus(data.agentic_tools),
+      // Self-only: return plaintext for whitelisted non-secret fields
+      // (base URLs) so the UI can render the saved value back. Field-level
+      // secrets are NEVER on the whitelist; see `AGENTIC_TOOLS_PUBLIC_FIELDS`.
+      agentic_tools_public_values: requesterId === row.user_id ? extractAgenticToolsPublicValues(data.agentic_tools, decryptApiKey) : void 0,
       // Return env var metadata (presence + scope), NOT actual values
       env_vars: envVarMetadata,
       // Return default agentic config
@@ -332,11 +382,7 @@ var UsersServiceWithAuth = class extends UsersService {
       must_change_password: !!row.must_change_password,
       created_at: row.created_at,
       updated_at: row.updated_at ?? void 0,
-      api_keys: data.api_keys ? {
-        ANTHROPIC_API_KEY: !!data.api_keys.ANTHROPIC_API_KEY,
-        OPENAI_API_KEY: !!data.api_keys.OPENAI_API_KEY,
-        GEMINI_API_KEY: !!data.api_keys.GEMINI_API_KEY
-      } : void 0,
+      agentic_tools: toAgenticToolsStatus(data.agentic_tools),
       env_vars: envVarMetadata
     };
   }

package/dist/daemon/services/worktree-owners.js

@@ -99,7 +99,9 @@ function spawnExecutorLocal(payload, options) {
       ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY,
       ANTHROPIC_AUTH_TOKEN: env.ANTHROPIC_AUTH_TOKEN,
       ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL,
+      CLAUDE_CODE_OAUTH_TOKEN: env.CLAUDE_CODE_OAUTH_TOKEN,
       OPENAI_API_KEY: env.OPENAI_API_KEY,
+      OPENAI_BASE_URL: env.OPENAI_BASE_URL,
       GEMINI_API_KEY: env.GEMINI_API_KEY,
       GOOGLE_API_KEY: env.GOOGLE_API_KEY
     }).filter(([_, v]) => v !== void 0)

package/dist/daemon/services/worktrees.js

@@ -363,7 +363,9 @@ function spawnExecutorLocal(payload, options) {
       ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY,
       ANTHROPIC_AUTH_TOKEN: env.ANTHROPIC_AUTH_TOKEN,
       ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL,
+      CLAUDE_CODE_OAUTH_TOKEN: env.CLAUDE_CODE_OAUTH_TOKEN,
       OPENAI_API_KEY: env.OPENAI_API_KEY,
+      OPENAI_BASE_URL: env.OPENAI_BASE_URL,
       GEMINI_API_KEY: env.GEMINI_API_KEY,
       GOOGLE_API_KEY: env.GOOGLE_API_KEY
     }).filter(([_, v]) => v !== void 0)

package/dist/daemon/setup/index.js

@@ -313,6 +313,9 @@ function createTokenBucket(capacity, refillPerSec, now = Date.now) {
     return false;
   };
 }
+function userRoomName(userId) {
+  return `user:${userId}`;
+}
 function parseTerminalChannel(channel) {
   if (typeof channel !== "string") return null;
   if (!channel.startsWith("user/") || !channel.endsWith("/terminal")) return null;
@@ -406,7 +409,7 @@ function createSocketIOConfig(app, options) {
         });
       }
       if (user?.user_id) {
-        socket.join(`user:${user.user_id}`);
+        socket.join(userRoomName(user.user_id));
         console.log(
           `\u{1F3E0} Socket ${socket.id} joined user room at connection: user:${user.user_id.substring(0, 8)}`
         );
@@ -601,7 +604,7 @@ function createSocketIOConfig(app, options) {
       if (!userId) return;
       for (const [, socket] of io.sockets.sockets) {
         if (socket.feathers === context.connection) {
-          socket.join(`user:${userId}`);
+          socket.join(userRoomName(userId));
           console.log(
             `\u{1F3E0} Socket ${socket.id} joined user room after login: user:${userId.substring(0, 8)}`
           );