@bevel-software/platform-core-backend 0.34.0 → 0.36.1

package/src/modules/tool-manuals/__tests__/tool-manuals.managed-sign-in.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from 'vitest';
+import { normalizeToolManual } from '../tool-manuals.service.js';
+
+/**
+ * A sign-in that goes through a managed connector: the `oauth` block names
+ * the connector instead of a client id, and — for a workspace connection —
+ * may sit on an `admin`-scoped variable, the one case an OAuth block may.
+ */
+function manual(variable: Record<string, unknown>): string {
+  return JSON.stringify({
+    id: 'microsoft365',
+    type: 'inline',
+    variables: [variable],
+    tools: [
+      {
+        name: 'list_mail',
+        description: 'List mail.',
+        inputs: { type: 'object', properties: {} },
+        outputs: { type: 'object', properties: {} },
+        tool_call_template: {
+          call_template_type: 'http',
+          http_method: 'GET',
+          url: 'https://graph.microsoft.com/v1.0/me/messages',
+          headers: { Authorization: 'Bearer ${ACCESS_TOKEN}' },
+        },
+      },
+    ],
+  });
+}
+
+const ENDPOINTS = {
+  authorizationUrl: 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize',
+  tokenUrl: 'https://login.microsoftonline.com/common/oauth2/v2.0/token',
+};
+
+describe('a managed sign-in in a .tool', () => {
+  test('parses without a clientId when `managed` names the connector and scope set', () => {
+    const d = normalizeToolManual('m', 'Plugins/x/m.tool', manual({
+      name: 'ACCESS_TOKEN',
+      scope: 'user',
+      oauth: { ...ENDPOINTS, scopes: ['Mail.Read'], managed: { connectorId: 'microsoft365', scopeSet: 'read' } },
+    }));
+    expect(d.variables?.[0].oauth).toEqual({
+      ...ENDPOINTS,
+      scopes: ['Mail.Read'],
+      managed: { connectorId: 'microsoft365', scopeSet: 'read' },
+    });
+    expect(d.variables?.[0].oauth?.clientId).toBeUndefined();
+  });
+
+  test('still requires a clientId on an ordinary sign-in', () => {
+    expect(() =>
+      normalizeToolManual('m', 'Plugins/x/m.tool', manual({ name: 'ACCESS_TOKEN', scope: 'user', oauth: { ...ENDPOINTS } })),
+    ).toThrow(/clientId/);
+  });
+
+  test('refuses a malformed `managed` reference without repeating it', () => {
+    expect(() =>
+      normalizeToolManual('m', 'Plugins/x/m.tool', manual({
+        name: 'ACCESS_TOKEN',
+        scope: 'user',
+        oauth: { ...ENDPOINTS, managed: { connectorId: 'Micro Soft!', scopeSet: 'read' } },
+      })),
+    ).toThrow(/`variables\[0\]\.oauth\.managed` must be/);
+  });
+
+  test('refuses a sign-in that names both `managed` and a `clientId`: one client, not two flows', () => {
+    expect(() =>
+      normalizeToolManual('m', 'Plugins/x/m.tool', manual({
+        name: 'ACCESS_TOKEN',
+        scope: 'user',
+        oauth: { ...ENDPOINTS, clientId: 'own', managed: { connectorId: 'microsoft365', scopeSet: 'read' } },
+      })),
+    ).toThrow(/names both `managed` and a `clientId`/);
+  });
+
+  test('a workspace connection: `oauth` on an `admin` variable is allowed only when managed', () => {
+    const shared = normalizeToolManual('m', 'Plugins/x/m.tool', manual({
+      name: 'ACCESS_TOKEN',
+      scope: 'admin',
+      oauth: { ...ENDPOINTS, managed: { connectorId: 'hubspot', scopeSet: 'read' } },
+    }));
+    expect(shared.variables?.[0]).toMatchObject({ scope: 'admin', oauth: { managed: { connectorId: 'hubspot' } } });
+
+    expect(() =>
+      normalizeToolManual('m', 'Plugins/x/m.tool', manual({ name: 'ACCESS_TOKEN', scope: 'admin', oauth: { ...ENDPOINTS, clientId: 'c' } })),
+    ).toThrow(/scope` must be `user`/);
+  });
+});

package/src/modules/tool-manuals/__tests__/tool-manuals.mcp-oauth.test.ts

@@ -1,17 +1,19 @@
 import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
-import { NodeFs } from '../../kb-fs/node-fs.js';
-import { KbPluginSource } from '../../plugins/discovery/kb-plugin-source.js';
+// The real disk, and the service wired over it, come from the composition-root
+// fixtures, as production wires them: this suite constructs no implementation
+// from its file, its own module's included.
+import { realDisk } from '../../../__tests__/real-disk.js';
+import { realToolManualService, type McpAuthDiscoveryPort } from '../../../__tests__/tool-manuals.js';
 
 /** The one disk, as production wires it: the service and its discovery read the same one. */
-const disk = new NodeFs();
+const disk = realDisk();
 import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DEFAULT_BRANCH } from '@bevel-software/platform-shared';
-import { ToolManualService, type McpAuthDiscoveryPort } from '../tool-manuals.service.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
-import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import type { IAccessControl } from '../../access/access-control.interface.js';
+import type { WorkspaceService } from '../../workspace/index.js';
+import type { IAccessControl } from '../../access/index.js';
 import { testKbContext } from '../../../__tests__/kb-context.js';
 
 const KB_DIR = 'knowledge-base';
@@ -63,9 +65,10 @@ describe('ToolManualService — MCP OAuth auto-discovery decoration', () => {
   });
 
   function svcWith(discovery: McpAuthDiscoveryPort) {
-    const svc = new ToolManualService(workspaceService, allowAll, testKbContext({ kbDirName: KB_DIR }), disk, new KbPluginSource(disk, testKbContext({ kbDirName: KB_DIR })));
-    svc.setMcpAuthDiscovery(discovery);
-    return svc;
+    return realToolManualService(
+      { workspaceService, accessControl: allowAll, kb: testKbContext({ kbDirName: KB_DIR }), disk },
+      discovery,
+    );
   }
 
   test('a bare mcp tool whose server demands OAuth gains the synthetic sign-in var + header', async () => {
@@ -94,8 +97,10 @@ describe('ToolManualService — MCP OAuth auto-discovery decoration', () => {
 
     // The served call template carries the header the variable loader will fill.
     const templates = await svc.toManualCallTemplates('user@example.com');
-    const notionTemplate = templates.find((t) => t.name === 'notion') as any;
-    expect(notionTemplate.config.mcpServers.notion.headers).toEqual({
+    const notionTemplate = templates.find((t) => t.name === 'notion') as
+      | { config: { mcpServers: Record<string, { headers: Record<string, string> }> } }
+      | undefined;
+    expect(notionTemplate?.config.mcpServers.notion?.headers).toEqual({
       Authorization: 'Bearer ${MCP_OAUTH}',
     });
   });
@@ -298,4 +303,185 @@ describe('ToolManualService — MCP OAuth auto-discovery decoration', () => {
     // The declaration is carried verbatim, opt-out included.
     expect(hubspot.variables?.[0].oauth).toMatchObject({ clientId: 'owner-app', pkce: false });
   });
+
+  describe('liveDeclaration — what a sign-in start reads', () => {
+    const HUBSPOT_ENDPOINTS = {
+      authorizationUrl: 'https://auth.hubspot.example/authorize',
+      tokenUrl: 'https://auth.hubspot.example/token',
+    };
+
+    test('reads the file as it is now, not the catalog the last scan cached', async () => {
+      await writeDeclaredServer({ clientId: 'client-A', ...HUBSPOT_ENDPOINTS });
+      const svc = svcWith({ statusFor: vi.fn(async () => ({ status: 'open' as const })) });
+      // The catalog is scanned and cached under client A…
+      const cached = (await svc.listAccessible('user@example.com')).find((m) => m.name === 'hubspot')!;
+      expect(cached.variables?.[0].oauth?.clientId).toBe('client-A');
+
+      // …the file is edited, and nothing invalidates the catalog.
+      await writeDeclaredServer({ clientId: 'client-B', ...HUBSPOT_ENDPOINTS, scopes: ['crm.read'] });
+      const stale = (await svc.listAccessible('user@example.com')).find((m) => m.name === 'hubspot')!;
+      expect(stale.variables?.[0].oauth?.clientId).toBe('client-A');
+
+      const live = await svc.liveDeclaration('user@example.com', 'hubspot', 'HUBSPOT_TOKEN');
+      expect(live?.manual.name).toBe('hubspot');
+      expect(live?.variable?.oauth).toEqual({ clientId: 'client-B', ...HUBSPOT_ENDPOINTS, scopes: ['crm.read'] });
+    });
+
+    test('a .tool file is read afresh the same way', async () => {
+      const toolsDir = join(root, wsId, KB_DIR, 'Plugins');
+      const write = (clientId: string) =>
+        writeFile(
+          join(toolsDir, 'crm.tool'),
+          JSON.stringify({
+            name: 'crm',
+            type: 'http',
+            url: 'https://api.crm.example/openapi.json',
+            variables: [{ name: 'SIGNIN', scope: 'user', oauth: { clientId, ...HUBSPOT_ENDPOINTS } }],
+          }),
+        );
+      await write('client-A');
+      const svc = svcWith({ statusFor: vi.fn(async () => ({ status: 'open' as const })) });
+      await svc.listAccessible('user@example.com');
+      await write('client-B');
+      const live = await svc.liveDeclaration('user@example.com', 'crm', 'SIGNIN');
+      expect(live?.variable?.oauth?.clientId).toBe('client-B');
+    });
+
+    test('completes a client-id-only declaration from the server metadata, or carries the discovery reason', async () => {
+      await writeDeclaredServer({ clientId: 'owner-app' });
+      const statusFor = vi.fn(async () => ({ status: 'open' as const }));
+      const providerForDeclaredClient = vi.fn(async () => ({
+        status: 'oauth' as const,
+        provider: { ...HUBSPOT_ENDPOINTS, clientId: 'owner-app', pkce: true, resource: 'https://mcp.hubspot.example/mcp' },
+      }));
+      const live = await svcWith({ statusFor, providerForDeclaredClient }).liveDeclaration(
+        'user@example.com',
+        'hubspot',
+        'HUBSPOT_TOKEN',
+      );
+      expect(live?.variable?.oauth).toEqual({
+        clientId: 'owner-app',
+        ...HUBSPOT_ENDPOINTS,
+        resource: 'https://mcp.hubspot.example/mcp',
+      });
+      // Never a zero-config probe or registration for a declared sign-in.
+      expect(statusFor).not.toHaveBeenCalled();
+
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const stuck = await svcWith({
+        statusFor,
+        providerForDeclaredClient: async () => ({ status: 'unsupported' as const, reason: 'no authorization-server metadata' }),
+      }).liveDeclaration('user@example.com', 'hubspot', 'HUBSPOT_TOKEN');
+      expect(stuck?.variable?.oauth).toEqual({ clientId: 'owner-app' });
+      expect(stuck?.manual.setup).toEqual({ kind: 'oauth-manual', reason: 'no authorization-server metadata' });
+      warn.mockRestore();
+    });
+
+    test('a .tool whose sign-in endpoint fails validation answers the parser’s reason, even while the catalog holds the valid version', async () => {
+      const toolsDir = join(root, wsId, KB_DIR, 'Plugins');
+      const write = (tokenUrl: string) =>
+        writeFile(
+          join(toolsDir, 'crm.tool'),
+          JSON.stringify({
+            name: 'crm',
+            type: 'http',
+            url: 'https://api.crm.example/openapi.json',
+            variables: [{ name: 'SIGNIN', scope: 'user', oauth: { clientId: 'c', authorizationUrl: HUBSPOT_ENDPOINTS.authorizationUrl, tokenUrl } }],
+          }),
+        );
+      await write(HUBSPOT_ENDPOINTS.tokenUrl);
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const svc = svcWith({ statusFor: vi.fn(async () => ({ status: 'open' as const })) });
+      expect((await svc.listAccessible('user@example.com')).some((m) => m.name === 'crm')).toBe(true);
+
+      await write('http://127.0.0.1/token');
+      await expect(svc.liveDeclaration('user@example.com', 'crm', 'SIGNIN')).resolves.toEqual({
+        refused: '`variables[0].oauth.tokenUrl` must use https',
+      });
+      await write('https://10.0.0.5/token');
+      await expect(svc.liveDeclaration('user@example.com', 'crm', 'SIGNIN')).resolves.toEqual({
+        refused: '`variables[0].oauth.tokenUrl` host is not allowed',
+      });
+      warn.mockRestore();
+    });
+
+    test('a plugin.json sign-in whose endpoint fails validation answers the reason too, not only a log line', async () => {
+      await writeDeclaredServer({ clientId: 'owner-app', ...HUBSPOT_ENDPOINTS, tokenUrl: 'http://127.0.0.1/token' });
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const svc = svcWith({ statusFor: vi.fn(async () => ({ status: 'open' as const })) });
+      const live = await svc.liveDeclaration('user@example.com', 'hubspot', 'HUBSPOT_TOKEN');
+      expect(live?.refused).toContain('`variables[0].oauth.tokenUrl` must use https');
+      // Located by position, never by the name the entry declared (the .tool parser's rule).
+      expect(live?.refused).not.toContain('HUBSPOT_TOKEN');
+      // The catalog's public listing is unchanged by this: the server is still left out.
+      const catalog = await svc.listAccessibleCatalog('user@example.com');
+      expect(catalog.tools.some((m) => m.name === 'hubspot')).toBe(false);
+      warn.mockRestore();
+    });
+
+    test('a refusal is read-gated like the manual it would have been', async () => {
+      await writeDeclaredServer({ clientId: 'owner-app', ...HUBSPOT_ENDPOINTS, tokenUrl: 'http://127.0.0.1/token' });
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const denyAll = {
+        canRead: async () => false,
+        canReadBatch: async (_w: string, _e: string, paths: string[]) => new Map(paths.map((p) => [p, false])),
+      } as unknown as IAccessControl;
+      const locked = realToolManualService({
+        workspaceService,
+        accessControl: denyAll,
+        kb: testKbContext({ kbDirName: KB_DIR }),
+        disk,
+      });
+      await expect(locked.liveDeclaration('user@example.com', 'hubspot', 'HUBSPOT_TOKEN')).resolves.toBeNull();
+      warn.mockRestore();
+    });
+
+    test('a workspace that cannot be opened is an error for a sign-in start, where the catalog answers empty', async () => {
+      await writeDeclaredServer({ clientId: 'owner-app', ...HUBSPOT_ENDPOINTS });
+      const down = {
+        getOrCreateForBranch: async () => {
+          throw new Error('workspace unavailable');
+        },
+      } as unknown as WorkspaceService;
+      const allowAll = {
+        canRead: async () => true,
+        canReadBatch: async (_w: string, _e: string, paths: string[]) => new Map(paths.map((p) => [p, true])),
+      } as unknown as IAccessControl;
+      const svc = realToolManualService({
+        workspaceService: down,
+        accessControl: allowAll,
+        kb: testKbContext({ kbDirName: KB_DIR }),
+        disk,
+      });
+      // The catalog degrades to "nothing released" and tries again next scan…
+      await expect(svc.listAccessible('user@example.com')).resolves.toEqual([]);
+      // …but a sign-in start must not read that as "no sign-in declared".
+      await expect(svc.liveDeclaration('user@example.com', 'hubspot', 'HUBSPOT_TOKEN')).rejects.toThrow(
+        'workspace unavailable',
+      );
+    });
+
+    test('answers no variable when the file declares none of that name, and null for an unreadable manual', async () => {
+      await writeDeclaredServer({ clientId: 'owner-app', ...HUBSPOT_ENDPOINTS });
+      const statusFor = vi.fn(async () => ({ status: 'oauth' as const, provider: OAUTH_PROVIDER }));
+      const svc = svcWith({ statusFor });
+      // The zero-config variable is synthesised by the catalog, not declared in any file.
+      const bare = await svc.liveDeclaration('user@example.com', 'notion', 'MCP_OAUTH');
+      expect(bare?.manual.name).toBe('notion');
+      expect(bare?.variable).toBeUndefined();
+      expect(statusFor).not.toHaveBeenCalled();
+
+      const denyAll = {
+        canRead: async () => false,
+        canReadBatch: async (_w: string, _e: string, paths: string[]) => new Map(paths.map((p) => [p, false])),
+      } as unknown as IAccessControl;
+      const locked = realToolManualService({
+        workspaceService,
+        accessControl: denyAll,
+        kb: testKbContext({ kbDirName: KB_DIR }),
+        disk,
+      });
+      await expect(locked.liveDeclaration('user@example.com', 'hubspot', 'HUBSPOT_TOKEN')).resolves.toBeNull();
+    });
+  });
 });

package/src/modules/tool-manuals/__tests__/tool-manuals.restart.test.ts

@@ -207,7 +207,7 @@ describe('external tools and their sign-ins across a restart', () => {
       createToolContextResolver({
         authService: { getUserById: async (id: string) => (id === USER.id ? { ...USER, name: 'User' } : null) } as never,
         workspaceService: { getWorkspacePath: async () => root } as never,
-        workflowService: {} as never,
+        versionControlService: {} as never,
         events: {} as never,
         kbDirName: KB_DIR,
         creatorAccess: { planForCreate: async () => null, grantInExtractedFile: async () => null, noteAccessFileWritten: () => {} },

package/src/modules/tool-manuals/__tests__/tool-manuals.tools.test.ts

@@ -1,11 +1,13 @@
 import type { Server as HttpServer } from 'node:http';
 import express from 'express';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { ToolRegistry } from '../../tool-registry/tool-registry.js';
-import { InternalTokenService } from '../../tool-auth/internal-token.service.js';
-import { createToolAuthMiddleware } from '../../tool-auth/tool-auth.middleware.js';
-import { createToolContextResolver } from '../../tool-helpers/tool-context.js';
-import { createToolHandlerFactory } from '../../tool-helpers/tool-handler.js';
+import { ToolRegistry } from '../../tool-registry/index.js';
+import {
+  InternalTokenService,
+  createToolAuthMiddleware,
+  createToolContextResolver,
+  createToolHandlerFactory,
+} from '../../../__tests__/tool-wiring.js';
 import { registerToolManualsTools } from '../tool-manuals.tools.js';
 import type { IToolManualService } from '../tool-manuals.contract.js';
 import { testKbContext } from '../../../__tests__/kb-context.js';
@@ -115,7 +117,7 @@ async function start(hiddenTools?: HiddenToolSource): Promise<string> {
       getUserById: async (id: string) => (id === ALICE.id ? ALICE : id === BOB.id ? BOB : null),
     } as never,
     workspaceService: { getWorkspacePath: async () => '/tmp/ws' } as never,
-    workflowService: {} as never,
+    versionControlService: {} as never,
     events: {} as never,
     kbDirName: 'knowledge-base',
     creatorAccess: { planForCreate: async () => null, grantInExtractedFile: async () => null, noteAccessFileWritten: () => {} },
@@ -337,3 +339,127 @@ describe('list_tool_setup — a declaration that lives on a draft says so', () =
     expect(toolManualService.listDeclaredOnlyOnBranch).not.toHaveBeenCalled();
   });
 });
+
+describe('list_tool_setup — a tool that needs the caller’s own value says so', () => {
+  const TICKETS = {
+    slug: 'ticketdesk',
+    name: 'ticketdesk',
+    path: 'Plugins/Support/ticketdesk.tool',
+    type: 'http' as const,
+    variables: [{ name: 'TICKETDESK_TOKEN', scope: 'user' as const, label: null }],
+  };
+
+  it('tells a caller without their own value where to set it, and to reconnect', async () => {
+    const base = await start();
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [TICKETS], invalid: [] } as never);
+    // Bob has configured nothing (see `statusFor`).
+    const body = (await (await callSetup(base, 'bevel_bob')).json()) as { note?: string };
+    expect(body.note).toContain('`ticketdesk` needs your own value or sign-in');
+    expect(body.note).toContain('Connect page, never in the chat');
+    expect(body.note).toContain('reconnect your assistant');
+  });
+
+  it('says nothing to a caller who has set theirs', async () => {
+    const base = await start();
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [TICKETS], invalid: [] } as never);
+    const body = (await (await callSetup(base, 'bevel_alice')).json()) as { note?: string };
+    expect(body.note).toBeUndefined();
+  });
+
+  const SIGN_IN = {
+    ...TICKETS,
+    variables: [{ name: 'TICKETDESK_OAUTH', scope: 'user' as const, label: null, oauth: { scopes: ['tickets'] } }],
+  };
+
+  /** The owner's side of a sign-in: a provider row of the OAuth kind. */
+  const ownerSignedUp = { adminConfigured: true, adminKind: 'oauth' as const };
+
+  /** A managed connector enabled as ONE workspace connection: the sign-in sits on an `admin` variable. */
+  const SHARED_SIGN_IN = {
+    ...TICKETS,
+    variables: [
+      {
+        name: 'ACCESS_TOKEN',
+        scope: 'admin' as const,
+        label: 'Ticketdesk sign-in',
+        oauth: { scopes: ['tickets'], managed: { connectorId: 'ticketdesk', scopeSet: 'read' } },
+      },
+    ],
+  };
+
+  it('a workspace connection is authorized only while the owner’s token covers the declared scopes, and names its connector', async () => {
+    const base = await start();
+    const authorizedOf = async (status: Record<string, unknown>) => {
+      vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [SHARED_SIGN_IN], invalid: [] } as never);
+      statusFor.mockImplementationOnce(async (_userId: string, keys: string[]) =>
+        keys.map((key) => ({ key, adminConfigured: true, adminKind: 'oauth' as const, userConfigured: false, ...status })),
+      );
+      const body = (await (await callSetup(base, 'bevel_bob')).json()) as {
+        tools: { variables: { authorized: boolean | null; managed?: unknown }[] }[];
+      };
+      return body.tools[0].variables[0];
+    };
+    // Connected by an owner, but before the tool asked for `tickets`.
+    expect((await authorizedOf({ adminAuthorized: true, adminGrantedScopes: 'profile' })).authorized).toBe(false);
+    // Connected with a covering token: everyone's, Bob's included.
+    const connected = await authorizedOf({ adminAuthorized: true, adminGrantedScopes: 'profile tickets' });
+    expect(connected.authorized).toBe(true);
+    expect(connected.managed).toEqual({ connectorId: 'ticketdesk', scopeSet: 'read' });
+    // Nobody has connected it yet.
+    expect((await authorizedOf({ adminAuthorized: false })).authorized).toBe(false);
+  });
+
+  it('tells a caller to sign in once the owner has set the sign-in up', async () => {
+    const base = await start();
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [SIGN_IN], invalid: [] } as never);
+    statusFor.mockImplementationOnce(async (_userId: string, keys: string[]) =>
+      keys.map((key) => ({ key, ...ownerSignedUp, userConfigured: false })),
+    );
+    const body = (await (await callSetup(base, 'bevel_bob')).json()) as { note?: string };
+    expect(body.note).toContain('`ticketdesk` needs your own value or sign-in');
+  });
+
+  it('names a tool the proxy hides for a stale credential: the wrong kind, or a sign-in short of a scope', async () => {
+    const base = await start();
+    // A row left from when the variable was a plain key.
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [SIGN_IN], invalid: [] } as never);
+    statusFor.mockImplementationOnce(async (_userId: string, keys: string[]) =>
+      keys.map((key) => ({ key, ...ownerSignedUp, userConfigured: true, userKind: 'static' as const })),
+    );
+    expect(((await (await callSetup(base, 'bevel_bob')).json()) as { note?: string }).note).toContain('`ticketdesk` needs your own value or sign-in');
+    // Signed in, but before the tool asked for `tickets`.
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [SIGN_IN], invalid: [] } as never);
+    statusFor.mockImplementationOnce(async (_userId: string, keys: string[]) =>
+      keys.map((key) => ({ key, ...ownerSignedUp, userConfigured: true, userKind: 'oauth' as const, userAuthorized: true, grantedScopes: 'profile' })),
+    );
+    expect(((await (await callSetup(base, 'bevel_bob')).json()) as { note?: string }).note).toContain('`ticketdesk` needs your own value or sign-in');
+    // Signed in with the scope: nothing to say.
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [SIGN_IN], invalid: [] } as never);
+    statusFor.mockImplementationOnce(async (_userId: string, keys: string[]) =>
+      keys.map((key) => ({ key, ...ownerSignedUp, userConfigured: true, userKind: 'oauth' as const, userAuthorized: true, grantedScopes: 'tickets' })),
+    );
+    expect(((await (await callSetup(base, 'bevel_bob')).json()) as { note?: string }).note).toBeUndefined();
+  });
+
+  it('does not send a caller to sign in before the owner has set the sign-in up', async () => {
+    const base = await start();
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [SIGN_IN], invalid: [] } as never);
+    statusFor.mockImplementationOnce(async (_userId: string, keys: string[]) =>
+      keys.map((key) => ({ key, adminConfigured: false, userConfigured: false })),
+    );
+    const body = (await (await callSetup(base, 'bevel_bob')).json()) as { note?: string };
+    expect(body.note).toBeUndefined();
+  });
+
+  it('does not send a caller to sign in on a shared key left from when the variable was static', async () => {
+    const base = await start();
+    // The owner turned a plain key into a sign-in; the old shared row is still
+    // there, so `adminConfigured` is true, but it is no provider to sign in to.
+    vi.mocked(toolManualService.listAccessibleCatalog).mockResolvedValueOnce({ tools: [SIGN_IN], invalid: [] } as never);
+    statusFor.mockImplementationOnce(async (_userId: string, keys: string[]) =>
+      keys.map((key) => ({ key, adminConfigured: true, adminKind: 'static' as const, userConfigured: false })),
+    );
+    const body = (await (await callSetup(base, 'bevel_bob')).json()) as { note?: string };
+    expect(body.note).toBeUndefined();
+  });
+});