@memberjunction/server 6.2.0-edge.3 → 6.2.0-edge.4

package/src/__tests__/AdhocQueryResolver.sqlAuthorizer.test.ts

@@ -0,0 +1,104 @@
+// type-graphql decorators call `Reflect.getMetadata`, which only exists once this polyfill is
+// loaded. MUST precede any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+/**
+ * MJServer registers an ad-hoc SQL authorizer with the action engine so that Run Ad-hoc Query, which
+ * agents run as the calling user, applies the same checks as the ExecuteAdhocQuery resolver: the
+ * rendered SQL must be one read statement, every table it reads must be an entity base view the
+ * caller may read in full (no row-level filter, no denied field), and the timeout is limited by the
+ * server's request timeout.
+ *
+ * Every SQL statement below is harmless.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+vi.mock('type-graphql', () => {
+  const noopDecorator = () => () => undefined;
+  return {
+    Resolver: noopDecorator, Mutation: noopDecorator, Query: noopDecorator, Subscription: noopDecorator,
+    ObjectType: noopDecorator, InputType: noopDecorator, Field: noopDecorator, Arg: noopDecorator,
+    Args: noopDecorator, Ctx: noopDecorator, PubSub: noopDecorator, Root: noopDecorator,
+    Directive: noopDecorator, Authorized: noopDecorator, UseMiddleware: noopDecorator,
+    createUnionType: () => class {},
+    AuthorizationError: class AuthorizationError extends Error {},
+    Float: class {}, Int: class {}, ID: class {},
+  };
+});
+
+// The server config is read from mj.config at import; the authorizer takes its timeout as an argument.
+vi.mock('../config.js', () => ({ configInfo: { databaseSettings: { requestTimeout: 120_000 } } }));
+
+import type { DatabaseProviderBase, UserInfo } from '@memberjunction/core';
+import { CreateAdhocSQLAuthorizer } from '../resolvers/AdhocQueryResolver.js';
+import { ClampAdhocTimeoutSeconds } from '../resolvers/adhocTimeout.js';
+
+type EntityShape = { Name: string; SchemaName: string; BaseView: string; rowFilter?: string };
+
+/** A read-only provider with the entity metadata the table check reads. */
+function readOnlyProvider(entities: EntityShape[]): DatabaseProviderBase {
+  return {
+    PlatformKey: 'sqlserver',
+    Entities: entities.map((e) => ({
+      Name: e.Name,
+      SchemaName: e.SchemaName,
+      BaseView: e.BaseView,
+      GetUserPermisions: () => ({ CanRead: true }),
+      GetEffectiveRowFilterWhereClause: () => e.rowFilter ?? '',
+      GetDeniedReadFields: () => new Set<string>(),
+    })),
+  } as unknown as DatabaseProviderBase;
+}
+
+const USER = { ID: 'user-1', Email: 'user@example.com' } as unknown as UserInfo;
+const RUBRIC_EVALUATIONS: EntityShape = { Name: 'MJ: Rubric Evaluations', SchemaName: '__mj', BaseView: 'vwRubricEvaluations' };
+const REQUEST_TIMEOUT_MS = 120_000;
+
+describe('CreateAdhocSQLAuthorizer', () => {
+  const authorizer = CreateAdhocSQLAuthorizer(REQUEST_TIMEOUT_MS);
+
+  it('admits SQL that reads only entity views the user may read in full', () => {
+    const refusal = authorizer.Authorize('SELECT ID FROM [__mj].[vwRubricEvaluations]', readOnlyProvider([RUBRIC_EVALUATIONS]), USER);
+
+    expect(refusal).toBeNull();
+  });
+
+  it('refuses SQL that reads an entity the user may read only through a row filter', () => {
+    const filtered = { ...RUBRIC_EVALUATIONS, rowFilter: "EvaluatorUserID='user-1'" };
+
+    const refusal = authorizer.Authorize('SELECT * FROM __mj.vwRubricEvaluations', readOnlyProvider([filtered]), USER);
+
+    expect(refusal).toMatch(/row-level-security filtered/);
+  });
+
+  it('refuses SQL that reads a table that is not an entity view', () => {
+    const refusal = authorizer.Authorize('SELECT * FROM [__mj].[User]', readOnlyProvider([RUBRIC_EVALUATIONS]), USER);
+
+    expect(refusal).toMatch(/entity base view/);
+  });
+
+  it('refuses a stacked batch hidden behind a bracket identifier', () => {
+    const refusal = authorizer.Authorize("SELECT 1 AS [a'] ; SELECT 2 AS [b']", readOnlyProvider([RUBRIC_EVALUATIONS]), USER);
+
+    expect(refusal).toMatch(/single read query/);
+  });
+
+  it('limits the timeout the way ExecuteAdhocQuery does', () => {
+    for (const requested of [undefined, 5, 600]) {
+      expect(authorizer.ClampTimeoutSeconds(requested)).toBe(ClampAdhocTimeoutSeconds(requested, REQUEST_TIMEOUT_MS));
+    }
+    expect(authorizer.ClampTimeoutSeconds(600)).toBe(120);
+  });
+});
+
+describe('MJServer startup', () => {
+  // Startup needs a database, so this one assertion reads the source.
+  it('registers the read-only provider factory and this authorizer with the action engine', () => {
+    const src = readFileSync(resolve(__dirname, '../index.ts'), 'utf8');
+
+    expect(/ActionEngineServer\.Instance\.SetReadOnlyProviderFactory\(\s*\(\)\s*=>\s*CreateReadOnlyProvider\(dataSources\)\s*\)/.test(src)).toBe(true);
+    expect(/ActionEngineServer\.Instance\.SetAdhocSQLAuthorizer\(\s*CreateAdhocSQLAuthorizer\(configInfo\.databaseSettings\.requestTimeout\)\s*\)/.test(src)).toBe(true);
+  });
+});

package/src/__tests__/BridgeHostInstance.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { hostname } from 'os';
+import type { IMetadataProvider, RunViewParams, UserInfo } from '@memberjunction/core';
+import type { IRealtimeSession, RealtimeInputFrame } from '@memberjunction/ai';
+import type { MJAIAgentSessionBridgeEntity, MJAIBridgeProviderEntity } from '@memberjunction/core-entities';
+import { AIBridgeEngine, LOOPBACK_BRIDGE_DRIVER_CLASS } from '@memberjunction/ai-bridge-server';
+import { BindBridgeEngineHostInstance, StartBridgeOrphanReconciliation } from '../agentSessions/BridgeHostInstance.js';
+import { GetBootID, GetCurrentHostInstance, HostInstanceIdentity, SetHostInstancePort } from '../agentSessions/HostInstance.js';
+
+/** The port this test process "serves" on, set the way `Serve` sets it, before anything reads the identity. */
+const OUR_PORT = 4000;
+/** The port of a second MJAPI on the same host. */
+const OTHER_PORT = 4100;
+SetHostInstancePort(OUR_PORT);
+
+const user = { ID: 'system-user', Email: 'system@example.com' } as unknown as UserInfo;
+
+/** A bridge row as the engine reads and writes it. */
+interface BridgeRow {
+    ID: string;
+    Status: MJAIAgentSessionBridgeEntity['Status'];
+    HostInstanceID: string | null;
+    AgentSessionID: string;
+    CloseReason?: MJAIAgentSessionBridgeEntity['CloseReason'];
+}
+
+/** A `LIKE` pattern as a regular expression: `%` any run of characters, `_` any one character. */
+function likePattern(pattern: string): RegExp {
+    const body = [...pattern]
+        .map((c) => (c === '%' ? '.*' : c === '_' ? '.' : c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')))
+        .join('');
+    return new RegExp(`^${body}$`);
+}
+
+/**
+ * A provider over a bridge table, answering the engine the way the database would: the orphan reconcile's read
+ * returns the open rows whose `HostInstanceID` matches the filter's `LIKE` pattern and isn't the id it excludes, and a
+ * row the engine loads and saves is written back. `row(id)` reads a row's current state.
+ */
+function bridgeTable(rows: BridgeRow[]): {
+    provider: IMetadataProvider;
+    row: (id: string) => BridgeRow;
+    runView: ReturnType<typeof vi.fn>;
+} {
+    const table = new Map(rows.map((r) => [r.ID, { ...r }]));
+    const runView = vi.fn(async (params: RunViewParams) => {
+        if (params.EntityName !== 'MJ: AI Agent Session Bridges') {
+            return { Success: true, Results: [] };
+        }
+        const filter = typeof params.ExtraFilter === 'string' ? params.ExtraFilter : '';
+        const like = likePattern(/HostInstanceID LIKE '(.*?)'/.exec(filter)?.[1] ?? '');
+        const excluded = /HostInstanceID <> '(.*?)'/.exec(filter)?.[1];
+        const results = [...table.values()]
+            .filter((r) => r.Status === 'Connecting' || r.Status === 'Connected')
+            .filter((r) => r.HostInstanceID != null && like.test(r.HostInstanceID) && r.HostInstanceID !== excluded)
+            .map((r) => ({ ...r }));
+        return { Success: true, Results: results };
+    });
+    const provider = {
+        RunView: runView,
+        GetEntityObject: vi.fn(async () => {
+            const entity: BridgeRow & { LatestResult: { CompleteMessage: string }; Load: (id: string) => Promise<boolean>; Save: () => Promise<boolean> } = {
+                ID: '',
+                Status: 'Pending',
+                HostInstanceID: null,
+                AgentSessionID: '',
+                CloseReason: null,
+                LatestResult: { CompleteMessage: '' },
+                Load: async (id: string) => {
+                    const stored = table.get(id);
+                    if (!stored) {
+                        return false;
+                    }
+                    Object.assign(entity, stored);
+                    return true;
+                },
+                Save: async () => {
+                    const stored = table.get(entity.ID);
+                    if (stored) {
+                        stored.Status = entity.Status;
+                        stored.CloseReason = entity.CloseReason;
+                    }
+                    return true;
+                },
+            };
+            return entity;
+        }),
+    } as unknown as IMetadataProvider;
+    return { provider, row: (id: string) => table.get(id) as BridgeRow, runView };
+}
+
+/** A realtime model session that says nothing: a bridge only needs one to connect. */
+class SilentSession implements IRealtimeSession {
+    public SendInput(_frame: RealtimeInputFrame): void {}
+    public async RegisterTools(): Promise<void> {}
+    public OnOutput(): void {}
+    public OnTranscript(): void {}
+    public OnToolCall(): void {}
+    public async SendToolResult(): Promise<void> {}
+    public OnInterruption(): void {}
+    public OnError(): void {}
+    public OnUsage(): void {}
+    public async Close(): Promise<void> {}
+}
+
+/** The loopback bridge provider: a bridge with no platform behind it. */
+const loopbackProvider = {
+    ID: 'provider-loopback',
+    Name: 'Loopback',
+    DriverClass: LOOPBACK_BRIDGE_DRIVER_CLASS,
+    SupportedFeaturesObject: { AudioIn: true, AudioOut: true },
+} as unknown as MJAIBridgeProviderEntity;
+
+afterEach(() => {
+    AIBridgeEngine.Instance.StopOrphanReconciliation();
+    BindBridgeEngineHostInstance();
+});
+
+describe('BindBridgeEngineHostInstance', () => {
+    it("makes the engine stamp this MJAPI instance's identity (hostname:port:pid:bootId) on the bridges it creates", async () => {
+        BindBridgeEngineHostInstance();
+        const row = {
+            ID: 'bridge-new',
+            Status: 'Pending',
+            HostInstanceID: null as string | null,
+            NewRecord: vi.fn(),
+            Save: vi.fn(async () => true),
+            Load: vi.fn(async () => true),
+            LatestResult: { CompleteMessage: '' },
+        };
+        const provider = {
+            GetEntityObject: vi.fn(async () => row),
+            RunView: vi.fn(async () => ({ Success: true, Results: [] })),
+        } as unknown as IMetadataProvider;
+
+        const active = await AIBridgeEngine.Instance.StartBridgeSession({
+            AgentSessionID: 'session-1',
+            Provider: loopbackProvider,
+            RealtimeSession: new SilentSession(),
+            Address: 'loopback://room',
+            ContextUser: user,
+            MetadataProvider: provider,
+        });
+        try {
+            expect(row.HostInstanceID).toBe(GetCurrentHostInstance().GetHostInstanceID());
+            expect(row.HostInstanceID).toBe(`${hostname()}:${OUR_PORT}:${process.pid}:${GetBootID()}`);
+        } finally {
+            await AIBridgeEngine.Instance.StopBridgeSession(active.SessionBridgeID, 'Explicit', user, provider);
+        }
+    });
+});
+
+describe("the bridge engine's orphan reconcile with this MJAPI's identity (#5310)", () => {
+    const ours = GetCurrentHostInstance();
+    const theirs = new HostInstanceIdentity(ours.HostName, String(OTHER_PORT), 40404, 'boot-theirs');
+
+    /** Both MJAPIs' live bridges, and one each left by an earlier boot. */
+    function sharedTable(): BridgeRow[] {
+        return [
+            { ID: 'ours-live', Status: 'Connected', HostInstanceID: ours.GetHostInstanceID(), AgentSessionID: 'session-ours-live' },
+            { ID: 'ours-stale', Status: 'Connected', HostInstanceID: `${ours.GetInstancePrefix()}31337:boot-ours-before`, AgentSessionID: 'session-ours-stale' },
+            { ID: 'theirs-live', Status: 'Connected', HostInstanceID: theirs.GetHostInstanceID(), AgentSessionID: 'session-theirs-live' },
+            { ID: 'theirs-stale', Status: 'Connecting', HostInstanceID: `${theirs.GetInstancePrefix()}27182:boot-theirs-before`, AgentSessionID: 'session-theirs-stale' },
+        ];
+    }
+
+    it('closes the bridges an earlier boot of this instance left, and nothing else (one MJAPI, as before)', async () => {
+        BindBridgeEngineHostInstance();
+        const { provider, row } = bridgeTable([
+            { ID: 'before-restart', Status: 'Connected', HostInstanceID: `${ours.GetInstancePrefix()}31337:boot-before`, AgentSessionID: 'session-1' },
+            // The OS gave the restarted process the same pid; the boot id still differs.
+            { ID: 'before-restart-same-pid', Status: 'Connecting', HostInstanceID: `${ours.GetInstancePrefix()}${ours.ProcessID}:boot-before`, AgentSessionID: 'session-2' },
+            { ID: 'this-boot', Status: 'Connected', HostInstanceID: ours.GetHostInstanceID(), AgentSessionID: 'session-3' },
+            { ID: 'other-host', Status: 'Connected', HostInstanceID: `other-host:${OUR_PORT}:31337:boot-other`, AgentSessionID: 'session-4' },
+            // Stamped before MJServer gave the engine its identity; no instance owns it.
+            { ID: 'fallback-stamped', Status: 'Connected', HostInstanceID: `unknown-host:31337:boot-old`, AgentSessionID: 'session-5' },
+        ]);
+
+        const closed = await AIBridgeEngine.Instance.ReconcileOrphans(user, provider);
+
+        expect(closed).toBe(2);
+        expect(row('before-restart')).toMatchObject({ Status: 'Disconnected', CloseReason: 'Janitor' });
+        expect(row('before-restart-same-pid')).toMatchObject({ Status: 'Disconnected', CloseReason: 'Janitor' });
+        expect(row('this-boot').Status).toBe('Connected');
+        expect(row('other-host').Status).toBe('Connected');
+        expect(row('fallback-stamped').Status).toBe('Connected');
+    });
+
+    it("closes its own stale bridges and leaves the other MJAPI's live bridges open", async () => {
+        BindBridgeEngineHostInstance();
+        const { provider, row } = bridgeTable(sharedTable());
+
+        const closed = await AIBridgeEngine.Instance.ReconcileOrphans(user, provider);
+
+        expect(closed).toBe(1);
+        expect(row('ours-stale')).toMatchObject({ Status: 'Disconnected', CloseReason: 'Janitor' });
+        expect(row('ours-live').Status).toBe('Connected');
+        expect(row('theirs-live').Status).toBe('Connected');
+        expect(row('theirs-stale').Status).toBe('Connecting');
+    });
+
+    it("the other MJAPI's reconcile closes its stale bridges and leaves this one's live bridges open", async () => {
+        // What the other MJAPI's own BindBridgeEngineHostInstance gives its engine.
+        AIBridgeEngine.Instance.SetHostInstanceIdentity(theirs);
+        const { provider, row } = bridgeTable(sharedTable());
+
+        const closed = await AIBridgeEngine.Instance.ReconcileOrphans(user, provider);
+
+        expect(closed).toBe(1);
+        expect(row('theirs-stale')).toMatchObject({ Status: 'Disconnected', CloseReason: 'Janitor' });
+        expect(row('theirs-live').Status).toBe('Connected');
+        expect(row('ours-live').Status).toBe('Connected');
+        expect(row('ours-stale').Status).toBe('Connected');
+    });
+});
+
+describe('StartBridgeOrphanReconciliation', () => {
+    it("reconciles at once, with this instance's identity, as the given user", async () => {
+        BindBridgeEngineHostInstance();
+        const ours = GetCurrentHostInstance();
+        const { provider, row, runView } = bridgeTable([
+            { ID: 'ours-stale', Status: 'Connected', HostInstanceID: `${ours.GetInstancePrefix()}31337:boot-before`, AgentSessionID: 'session-1' },
+            { ID: 'theirs-live', Status: 'Connected', HostInstanceID: `${ours.HostName}:${OTHER_PORT}:40404:boot-theirs`, AgentSessionID: 'session-2' },
+        ]);
+
+        StartBridgeOrphanReconciliation(provider, user);
+
+        await vi.waitFor(() => expect(row('ours-stale').Status).toBe('Disconnected'));
+        expect(row('theirs-live').Status).toBe('Connected');
+        expect(runView.mock.calls[0][1]).toBe(user);
+    });
+});

package/src/__tests__/ClientToolRequestResolver.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ClientToolResponse } from '@memberjunction/ai-core-plus';
+
+/**
+ * RespondToClientToolRequest is the seam between a browser's tool answer and the waiting agent run:
+ * the resolver checks the media with the real ParseClientToolMedia and hands the answer to
+ * ClientToolRequestManager.ReceiveResponse, which this suite replaces to see what the run receives.
+ */
+const h = vi.hoisted(() => ({
+    receiveResponse: vi.fn((_response: ClientToolResponse): boolean => true),
+    logError: vi.fn(),
+}));
+
+// The resolver's GraphQL decorators read TypeScript type metadata that the test transform does not
+// emit, so they become no-ops; the suite calls the resolver method directly.
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    const decorators = [
+        'Resolver', 'Query', 'Mutation', 'Subscription', 'Arg', 'Args', 'ArgsType', 'Ctx', 'Root', 'Info', 'Field',
+        'FieldResolver', 'ObjectType', 'InputType', 'InterfaceType', 'Authorized', 'UseMiddleware', 'Extensions',
+        'Directive', 'PubSub',
+    ];
+    return {
+        ...Object.fromEntries(decorators.map((name) => [name, noopDecorator])),
+        Float: class {},
+        Int: class {},
+        ID: class {},
+        PubSubEngine: class {},
+        AuthorizationError: class AuthorizationError extends Error {},
+        registerEnumType: () => undefined,
+        createUnionType: () => class {},
+    };
+});
+
+// Replace the agent package so the resolver test does not load the @memberjunction/ai-agents graph.
+vi.mock('@memberjunction/ai-agents', () => ({
+    ClientToolRequestManager: { Instance: { ReceiveResponse: h.receiveResponse } },
+    CLIENT_TOOL_REQUEST_TOPIC: 'CLIENT_TOOL_REQUEST',
+}));
+
+// Keep the resolver's error log out of the test output, and observable.
+vi.mock('@memberjunction/core', async (importOriginal) => {
+    const actual = await importOriginal<Record<string, unknown>>();
+    return { ...actual, LogError: h.logError, LogStatus: vi.fn() };
+});
+
+import { ClientToolRequestResolver } from '../resolvers/ClientToolRequestResolver.js';
+
+/** Base64 content of 3 bytes ("ABC"). */
+const SMALL_BASE64 = 'QUJD';
+/** Base64 content that decodes to 2,000,004 bytes, over the 2,000,000-byte limit. */
+const OVERSIZED_BASE64 = 'A'.repeat(2_666_672);
+
+/** Sends one answer through the mutation, as the browser does. */
+function respond(media: string | undefined, result: string | undefined = '{"ok":true}'): Promise<boolean> {
+    return new ClientToolRequestResolver().RespondToClientToolRequest('req-1', true, result, undefined, media);
+}
+
+/** The response the waiting run received. */
+function received(): ClientToolResponse {
+    expect(h.receiveResponse).toHaveBeenCalledTimes(1);
+    return h.receiveResponse.mock.calls[0][0];
+}
+
+beforeEach(() => {
+    h.receiveResponse.mockReset();
+    h.receiveResponse.mockReturnValue(true);
+    h.logError.mockReset();
+});
+
+describe('ClientToolRequestResolver.RespondToClientToolRequest', () => {
+    it('hands valid media to the waiting run with the result', async () => {
+        const media = JSON.stringify([{ MimeType: 'image/jpeg', Base64: SMALL_BASE64, Width: 1280, Height: 720 }]);
+
+        await expect(respond(media)).resolves.toBe(true);
+
+        expect(received()).toEqual({
+            RequestID: 'req-1',
+            Success: true,
+            Result: { ok: true },
+            ErrorMessage: undefined,
+            Media: [{ MimeType: 'image/jpeg', Base64: SMALL_BASE64, Width: 1280, Height: 720 }],
+        });
+    });
+
+    it('hands no Media to the run when the answer carries none', async () => {
+        await respond(undefined);
+
+        expect(received()).toEqual({ RequestID: 'req-1', Success: true, Result: { ok: true }, ErrorMessage: undefined, Media: undefined });
+    });
+
+    it.each([
+        ['a MIME type that is not allowed', JSON.stringify([{ MimeType: 'image/gif', Base64: SMALL_BASE64 }]), 'media MIME type "image/gif" is not allowed'],
+        ['an item over the size limit', JSON.stringify([{ MimeType: 'image/png', Base64: OVERSIZED_BASE64 }]), 'media item is 2000004 bytes; the limit is 2000000'],
+        [
+            'more than 4 items',
+            JSON.stringify(Array.from({ length: 5 }, () => ({ MimeType: 'image/jpeg', Base64: SMALL_BASE64 }))),
+            'media holds 5 items; the limit is 4',
+        ],
+    ])('gives the run a failed result for %s, without the result or the media', async (_case, media, reason) => {
+        await respond(media);
+
+        expect(received()).toEqual({ RequestID: 'req-1', Success: false, ErrorMessage: `Client tool media rejected: ${reason}` });
+    });
+
+    it('gives the run a failed result and returns false when the result is not valid JSON', async () => {
+        await expect(respond(undefined, '{not json')).resolves.toBe(false);
+
+        expect(received()).toEqual({
+            RequestID: 'req-1',
+            Success: false,
+            ErrorMessage: expect.stringMatching(/^Client tool response rejected: /),
+        });
+        expect(h.logError).toHaveBeenCalledWith(expect.stringContaining('RespondToClientToolRequest error:'));
+    });
+});