@slates/client 1.0.0-rc.2 → 1.0.0-rc.20

package/src/client.test.ts

@@ -4,6 +4,7 @@ import {
   SlateAuth,
   SlateConfig,
   type SlateLogEntry,
+  SlatePublicTool,
   SlateSpecification,
   SlateTool,
   SlateTrigger
@@ -30,9 +31,17 @@ let createDemoSlate = () => {
     z.object({
       prefix: z.string()
     })
-  ).getDefaultConfig(() => ({
-    prefix: 'Hello'
-  }));
+  )
+    .getDefaultConfig(() => ({
+      prefix: 'Hello'
+    }))
+    .docs([
+      {
+        type: 'docs.config.general',
+        name: 'Demo config docs',
+        url: 'https://example.com/docs/config'
+      }
+    ]);
 
   let demoAuth = SlateAuth.create<{ token: string }>()
     .output(
@@ -47,6 +56,13 @@ let createDemoSlate = () => {
       inputSchema: z.object({
         token: z.string()
       }),
+      docs: [
+        {
+          type: 'docs.auth.token',
+          name: 'Demo token auth docs',
+          url: 'https://example.com/docs/auth/token'
+        }
+      ],
       getDefaultInput: async () => ({
         token: 'default-token'
       }),
@@ -58,7 +74,8 @@ let createDemoSlate = () => {
       getOutput: async (ctx: { input: { token: string } }) => ({
         output: {
           token: ctx.input.token
-        }
+        },
+        scopes: [`scope:${ctx.input.token}`]
       }),
       getProfile: async (ctx: { output: { token: string } }) => ({
         profile: {
@@ -71,13 +88,26 @@ let createDemoSlate = () => {
     key: 'demo-slate',
     name: 'Demo Slate',
     description: 'A tiny test slate',
+    docs: [
+      {
+        name: 'Demo provider docs',
+        url: 'https://example.com/docs/provider'
+      }
+    ],
     config: demoConfig,
     auth: demoAuth
   });
 
   let echoTool = SlateTool.create(spec, {
     key: 'echo',
-    name: 'Echo'
+    name: 'Echo',
+    docs: [
+      {
+        type: 'docs.action.general',
+        name: 'Echo tool docs',
+        url: 'https://example.com/docs/actions/echo'
+      }
+    ]
   })
     .input(
       z.object({
@@ -97,6 +127,7 @@ let createDemoSlate = () => {
         }
       ]
     })
+    .authMethods(['token_auth'])
     .handleInvocation(async ctx => ({
       output: {
         greeting: `${ctx.config.prefix} ${ctx.input.name}`,
@@ -170,6 +201,59 @@ let createTraceSlate = (baseUrl: string) => {
   });
 };
 
+let createTraceErrorSlate = (baseUrl: string) => {
+  let config = SlateConfig.create(z.object({}));
+  let auth = SlateAuth.create<{}>().output(z.object({}));
+
+  let spec = SlateSpecification.create({
+    key: 'trace-error-slate',
+    name: 'Trace Error Slate',
+    description: 'A slate that traces failed HTTP requests',
+    config,
+    auth
+  });
+
+  let traceTool = SlateTool.create(spec, {
+    key: 'trace_http_error',
+    name: 'Trace HTTP Error'
+  })
+    .input(z.object({}))
+    .output(
+      z.object({
+        ok: z.boolean()
+      })
+    )
+    .handleInvocation(async () => {
+      await axios.post(
+        `${baseUrl}/trace-error?client_secret=request-secret`,
+        new URLSearchParams({
+          grant_type: 'authorization_code',
+          client_secret: 'client-secret'
+        }).toString(),
+        {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: 'Bearer client-token'
+          }
+        }
+      );
+
+      return {
+        output: {
+          ok: true
+        },
+        message: 'should not reach'
+      };
+    })
+    .build();
+
+  return Slate.create({
+    spec,
+    tools: [traceTool],
+    triggers: []
+  });
+};
+
 let createTriggerTraceSlate = () => {
   let config = SlateConfig.create(z.object({}));
   let auth = SlateAuth.create<{}>().output(z.object({}));
@@ -229,7 +313,14 @@ let createTriggerTraceSlate = () => {
     )
     .webhook({
       handleRequest: async () => ({
-        inputs: [{ id: 'webhook-1' }, { id: 'webhook-2' }]
+        inputs: [{ id: 'webhook-1' }, { id: 'webhook-2' }],
+        response: {
+          status: 202,
+          headers: {
+            'x-trigger-result': 'accepted'
+          },
+          body: 'accepted'
+        }
       }),
       handleEvent: async ctx => ({
         id: ctx.input.id,
@@ -249,6 +340,180 @@ let createTriggerTraceSlate = () => {
   });
 };
 
+type OAuthConfig = {
+  loginHost: string;
+};
+
+type OAuthOutput = {
+  token: string;
+  refreshToken?: string;
+};
+
+type SeenOAuthConfig = Partial<
+  Record<'authorizationUrl' | 'callback' | 'refresh' | 'profile', OAuthConfig>
+>;
+
+let getRequiredOAuthConfig = (ctx: { config?: Record<string, unknown> }): OAuthConfig => {
+  expect(ctx.config).toBeDefined();
+  return ctx.config as OAuthConfig;
+};
+
+let createOauthConfigSlate = (seenConfig: SeenOAuthConfig) => {
+  let config = SlateConfig.create(
+    z.object({
+      loginHost: z.string()
+    })
+  );
+
+  let auth = SlateAuth.create<{ token: string; refreshToken?: string }>()
+    .output(
+      z.object({
+        token: z.string(),
+        refreshToken: z.string().optional()
+      })
+    )
+    .addOauth({
+      type: 'auth.oauth',
+      key: 'oauth',
+      name: 'OAuth',
+      scopes: [],
+      inputSchema: z.object({}),
+      getAuthorizationUrl: async ctx => {
+        let config = getRequiredOAuthConfig(ctx);
+        seenConfig.authorizationUrl = config;
+        return {
+          url: `https://${config.loginHost}/authorize`,
+          callbackState: {
+            loginHost: config.loginHost
+          }
+        };
+      },
+      handleCallback: async ctx => {
+        let config = getRequiredOAuthConfig(ctx);
+        seenConfig.callback = config;
+        return {
+          output: {
+            token: `token:${config.loginHost}`,
+            refreshToken: 'refresh-token'
+          }
+        };
+      },
+      handleTokenRefresh: async (ctx: {
+        output: OAuthOutput;
+        config?: Record<string, unknown>;
+      }) => {
+        let config = getRequiredOAuthConfig(ctx);
+        seenConfig.refresh = config;
+        return {
+          output: {
+            ...ctx.output,
+            token: `refreshed:${config.loginHost}`
+          }
+        };
+      },
+      getProfile: async (ctx: { config?: Record<string, unknown> }) => {
+        let config = getRequiredOAuthConfig(ctx);
+        seenConfig.profile = config;
+        return {
+          profile: {
+            loginHost: config.loginHost
+          }
+        };
+      }
+    });
+
+  let spec = SlateSpecification.create({
+    key: 'oauth-config-slate',
+    name: 'OAuth Config Slate',
+    description: 'A slate that reads config in OAuth callbacks',
+    config,
+    auth
+  });
+
+  return Slate.create({
+    spec,
+    tools: [],
+    triggers: []
+  });
+};
+
+type TokenConfig = {
+  prefix: string;
+};
+
+type SeenTokenConfig = Partial<Record<'output' | 'profile', TokenConfig>>;
+
+let getRequiredTokenConfig = (ctx: { config?: Record<string, unknown> }): TokenConfig => {
+  expect(ctx.config).toBeDefined();
+  return ctx.config as TokenConfig;
+};
+
+type TokenAuthOutputContext = {
+  input: { token: string };
+  config?: Record<string, unknown>;
+};
+
+type TokenAuthProfileContext = {
+  output: { token: string };
+  config?: Record<string, unknown>;
+};
+
+let createTokenConfigSlate = (seenConfig: SeenTokenConfig) => {
+  let config = SlateConfig.create(
+    z.object({
+      prefix: z.string()
+    })
+  );
+
+  let auth = SlateAuth.create<{ token: string }>()
+    .output(
+      z.object({
+        token: z.string()
+      })
+    )
+    .addTokenAuth({
+      type: 'auth.token',
+      key: 'token_auth',
+      name: 'Token Auth',
+      inputSchema: z.object({
+        token: z.string()
+      }),
+      getOutput: async (ctx: TokenAuthOutputContext) => {
+        let currentConfig = getRequiredTokenConfig(ctx);
+        seenConfig.output = currentConfig;
+        return {
+          output: {
+            token: `${currentConfig.prefix}:${ctx.input.token}`
+          }
+        };
+      },
+      getProfile: async (ctx: TokenAuthProfileContext) => {
+        let currentConfig = getRequiredTokenConfig(ctx);
+        seenConfig.profile = currentConfig;
+        return {
+          profile: {
+            prefix: currentConfig.prefix,
+            token: ctx.output.token
+          }
+        };
+      }
+    });
+
+  let spec = SlateSpecification.create({
+    key: 'token-config-slate',
+    name: 'Token Config Slate',
+    description: 'A slate that reads config in token auth hooks',
+    config,
+    auth
+  });
+
+  return Slate.create({
+    spec,
+    tools: [],
+    triggers: []
+  });
+};
+
 describe('@slates/client local transport', () => {
   it('discovers auth/config and invokes tools with session state', async () => {
     let slate = createDemoSlate();
@@ -258,10 +523,23 @@ describe('@slates/client local transport', () => {
 
     let provider = await client.identify();
     expect(provider.provider.id).toBe('demo-slate');
+    expect(provider.docs).toEqual([
+      {
+        name: 'Demo provider docs',
+        url: 'https://example.com/docs/provider'
+      }
+    ]);
 
     let actions = await client.listTools();
     expect(actions).toHaveLength(1);
     expect(actions[0]!.id).toBe('echo');
+    expect(actions[0]!.docs).toEqual([
+      {
+        type: 'docs.action.general',
+        name: 'Echo tool docs',
+        url: 'https://example.com/docs/actions/echo'
+      }
+    ]);
     expect(actions[0]!.scopes).toEqual({
       AND: [
         {
@@ -269,9 +547,18 @@ describe('@slates/client local transport', () => {
         }
       ]
     });
+    expect(actions[0]!.authMethods).toEqual(['token_auth']);
+    expect(actions[0]!.isPublic).toBe(false);
 
     let configSchema = await client.getConfigSchema();
     expect(configSchema.schema.properties.prefix.type).toBe('string');
+    expect(configSchema.docs).toEqual([
+      {
+        type: 'docs.config.general',
+        name: 'Demo config docs',
+        url: 'https://example.com/docs/config'
+      }
+    ]);
 
     let defaultConfig = await client.getDefaultConfig();
     expect(defaultConfig.config).toEqual({ prefix: 'Hello' });
@@ -279,6 +566,13 @@ describe('@slates/client local transport', () => {
     let authMethods = await client.listAuthMethods();
     expect(authMethods.authenticationMethods).toHaveLength(1);
     expect(authMethods.authenticationMethods[0]!.type).toBe('auth.token');
+    expect(authMethods.authenticationMethods[0]!.docs).toEqual([
+      {
+        type: 'docs.auth.token',
+        name: 'Demo token auth docs',
+        url: 'https://example.com/docs/auth/token'
+      }
+    ]);
 
     let defaultInput = await client.getDefaultAuthInput('token_auth');
     expect(defaultInput.input).toEqual({ token: 'default-token' });
@@ -295,6 +589,7 @@ describe('@slates/client local transport', () => {
       input: changedInput.input ?? { token: '' }
     });
     expect(authOutput.output).toEqual({ token: 'trimmed-token' });
+    expect(authOutput.scopes).toEqual(['scope:trimmed-token']);
 
     client.setConfig({ prefix: 'Hi' });
     client.setAuth({
@@ -409,7 +704,7 @@ describe('@slates/client local transport', () => {
       state: null
     });
 
-    await client.request('slates/action.trigger.webhook_handle', {
+    let webhookResult = await client.request('slates/action.trigger.webhook_handle', {
       actionId: 'webhook_trigger',
       url: 'https://example.com/webhook',
       method: 'POST',
@@ -419,6 +714,16 @@ describe('@slates/client local transport', () => {
       body: null,
       state: null
     });
+    expect(webhookResult.response).toEqual({
+      status: 202,
+      headers: {
+        'x-trigger-result': 'accepted'
+      },
+      body: {
+        encoding: 'base64',
+        content: Buffer.from('accepted').toString('base64')
+      }
+    });
 
     await waitForLogs();
 
@@ -442,6 +747,7 @@ describe('@slates/client local transport', () => {
             component: 'action',
             functionName: 'handleRequest',
             inputCount: 2,
+            hasResponse: true,
             actionId: 'webhook_trigger'
           })
         })
@@ -449,6 +755,123 @@ describe('@slates/client local transport', () => {
     );
   });
 
+  it('passes current profile config into OAuth callbacks', async () => {
+    let seenConfig: SeenOAuthConfig = {};
+    let client = createSlatesClient({
+      transport: createLocalSlateTransport({
+        slate: createOauthConfigSlate(seenConfig)
+      }),
+      state: {
+        config: {
+          loginHost: 'sandbox.example.com'
+        }
+      }
+    });
+
+    let authorizationUrl = await client.getAuthorizationUrl({
+      authenticationMethodId: 'oauth',
+      redirectUri: 'http://localhost:3000/callback',
+      state: 'state-1',
+      input: {},
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      scopes: []
+    });
+
+    expect(authorizationUrl.authorizationUrl).toBe('https://sandbox.example.com/authorize');
+    expect(authorizationUrl.callbackState).toEqual({
+      loginHost: 'sandbox.example.com'
+    });
+
+    let callback = await client.handleAuthorizationCallback({
+      authenticationMethodId: 'oauth',
+      code: 'code-1',
+      state: 'state-1',
+      redirectUri: 'http://localhost:3000/callback',
+      input: {},
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      scopes: [],
+      callbackState: authorizationUrl.callbackState
+    });
+
+    expect(callback.output).toEqual({
+      token: 'token:sandbox.example.com',
+      refreshToken: 'refresh-token'
+    });
+
+    let refreshed = await client.refreshToken({
+      authenticationMethodId: 'oauth',
+      output: callback.output,
+      input: {},
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      scopes: []
+    });
+
+    expect(refreshed.output.token).toBe('refreshed:sandbox.example.com');
+
+    let profile = await client.getAuthProfile({
+      authenticationMethodId: 'oauth',
+      output: refreshed.output,
+      input: {},
+      scopes: []
+    });
+
+    expect(profile.profile).toEqual({
+      loginHost: 'sandbox.example.com'
+    });
+    expect(seenConfig).toEqual({
+      authorizationUrl: { loginHost: 'sandbox.example.com' },
+      callback: { loginHost: 'sandbox.example.com' },
+      refresh: { loginHost: 'sandbox.example.com' },
+      profile: { loginHost: 'sandbox.example.com' }
+    });
+  });
+
+  it('passes current profile config into token auth callbacks', async () => {
+    let seenConfig: SeenTokenConfig = {};
+    let client = createSlatesClient({
+      transport: createLocalSlateTransport({
+        slate: createTokenConfigSlate(seenConfig)
+      }),
+      state: {
+        config: {
+          prefix: 'configured'
+        }
+      }
+    });
+
+    let authOutput = await client.getAuthOutput({
+      authenticationMethodId: 'token_auth',
+      input: {
+        token: 'secret-token'
+      }
+    });
+
+    expect(authOutput.output).toEqual({
+      token: 'configured:secret-token'
+    });
+
+    let profile = await client.getAuthProfile({
+      authenticationMethodId: 'token_auth',
+      output: authOutput.output,
+      input: {
+        token: 'secret-token'
+      },
+      scopes: []
+    });
+
+    expect(profile.profile).toEqual({
+      prefix: 'configured',
+      token: 'configured:secret-token'
+    });
+    expect(seenConfig).toEqual({
+      output: { prefix: 'configured' },
+      profile: { prefix: 'configured' }
+    });
+  });
+
   it('throws structured protocol errors for provider responses', async () => {
     let client = createSlatesClient({
       transport: {
@@ -546,7 +969,7 @@ describe('@slates/client local transport', () => {
       expect(trace?.request.url).not.toContain('request-secret');
       expect(trace?.request.headers).toMatchObject({
         accept: 'application/json, text/plain, */*',
-        'user-agent': 'slates.dev@1.0.0/trace-slate',
+        'user-agent': 'slates.dev/1.0.0 trace-slate',
         'x-slates-provider': 'trace-slate'
       });
       expect(trace?.request.headers).not.toHaveProperty('authorization');
@@ -566,4 +989,166 @@ describe('@slates/client local transport', () => {
       });
     }
   });
+
+  it('returns sanitized request traces on provider errors', async () => {
+    let server = createServer((_req, res) => {
+      res.statusCode = 400;
+      res.setHeader('Content-Type', 'application/json');
+      res.end(
+        JSON.stringify({
+          error: 'invalid_grant',
+          client_secret: 'server-secret'
+        })
+      );
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(0, '127.0.0.1', () => resolve());
+    });
+
+    try {
+      let { port } = server.address() as AddressInfo;
+      let client = createSlatesClient({
+        transport: createLocalSlateTransport({
+          slate: createTraceErrorSlate(`http://127.0.0.1:${port}`)
+        }),
+        state: {
+          config: {}
+        }
+      });
+
+      let error = await client
+        .invokeTool('trace_http_error', {})
+        .then(() => null)
+        .catch(err => err as SlateProtocolError);
+
+      expect(error).toBeInstanceOf(SlateProtocolError);
+      expect(error?.data.code).toBe('upstream.invalid_request');
+      expect(error?.data.requestTraces).toHaveLength(1);
+
+      let trace = error?.data.requestTraces?.[0] as Record<string, any> | undefined;
+      expect(trace?.request.method).toBe('POST');
+      expect(trace?.request.url).not.toContain('request-secret');
+      expect(trace?.request.headers).not.toHaveProperty('authorization');
+      expect(trace?.request.body?.text).toContain('client_secret=[redacted]');
+      expect(trace?.response?.status).toBe(400);
+      expect(trace?.response?.body?.text).toContain('"client_secret":"[redacted]"');
+      expect(trace?.response?.body?.text).not.toContain('server-secret');
+    } finally {
+      await new Promise<void>((resolve, reject) => {
+        server.close(error => (error ? reject(error) : resolve()));
+      });
+    }
+  });
+
+  it('lists, gets, and invokes public tools without config or auth', async () => {
+    let config = SlateConfig.create(
+      z.object({
+        prefix: z.string()
+      })
+    );
+    let auth = SlateAuth.create<{ token: string }>()
+      .output(
+        z.object({
+          token: z.string()
+        })
+      )
+      .addTokenAuth({
+        type: 'auth.token',
+        key: 'token_auth',
+        name: 'Token Auth',
+        inputSchema: z.object({
+          token: z.string()
+        }),
+        getOutput: async ctx => ({
+          output: {
+            token: ctx.input.token
+          }
+        })
+      });
+
+    let spec = SlateSpecification.create({
+      key: 'public-tool-slate',
+      name: 'Public Tool Slate',
+      config,
+      auth
+    });
+
+    let echoTool = SlateTool.create(spec, {
+      key: 'echo',
+      name: 'Echo'
+    })
+      .input(
+        z.object({
+          name: z.string()
+        })
+      )
+      .output(
+        z.object({
+          greeting: z.string()
+        })
+      )
+      .handleInvocation(async ctx => ({
+        output: {
+          greeting: `${ctx.config.prefix} ${ctx.input.name}`
+        },
+        message: 'done'
+      }))
+      .build();
+
+    let setupTool = SlatePublicTool.create(spec, {
+      key: 'setup',
+      name: 'Setup'
+    })
+      .input(z.object({}))
+      .output(
+        z.object({
+          docsUrl: z.string()
+        })
+      )
+      .handleInvocation(async ctx => {
+        expect(ctx).not.toHaveProperty('config');
+        expect(ctx).not.toHaveProperty('auth');
+
+        return {
+          output: {
+            docsUrl: 'https://example.com/setup'
+          },
+          message: 'ok'
+        };
+      })
+      .build();
+
+    let client = createSlatesClient({
+      transport: createLocalSlateTransport({
+        slate: Slate.create({
+          spec,
+          tools: [echoTool, setupTool],
+          triggers: []
+        })
+      })
+    });
+
+    let tools = await client.listTools();
+    expect(tools.map(tool => ({ id: tool.id, isPublic: tool.isPublic }))).toEqual([
+      { id: 'echo', isPublic: false },
+      { id: 'setup', isPublic: true }
+    ]);
+
+    let setup = await client.getTool('setup');
+    expect(setup.isPublic).toBe(true);
+
+    let echo = await client.getTool('echo');
+    expect(echo.isPublic).toBe(false);
+
+    let result = await client.invokeTool('setup', {});
+    expect(result.output).toEqual({
+      docsUrl: 'https://example.com/setup'
+    });
+
+    await expect(client.invokeTool('echo', { name: 'Ada' })).rejects.toMatchObject({
+      message: 'Session context has not been initialized'
+    });
+  });
 });