@useconductor/conductor 1.0.0 → 1.0.1

package/tests/slack.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { SlackPlugin } from '../src/plugins/builtin/slack.js';
+import { Keychain } from '../src/security/keychain.js';
+
+// Helper: get a tool's handler by name
+function tool(plugin: SlackPlugin, name: string) {
+  const t = plugin.getTools().find((t) => t.name === name);
+  if (!t) throw new Error(`Tool not found: ${name}`);
+  return t.handler as (args: Record<string, unknown>) => Promise<unknown>;
+}
+
+// Minimal conductor mock
+function makeConductor(configDir = '/tmp/conductor-test-slack') {
+  return {
+    getConfig: () => ({
+      getConfigDir: () => configDir,
+    }),
+  } as any;
+}
+
+let plugin: SlackPlugin;
+
+beforeEach(async () => {
+  // Default: no token
+  vi.spyOn(Keychain.prototype, 'get').mockResolvedValue(null);
+  plugin = new SlackPlugin();
+  await plugin.initialize(makeConductor());
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  // Remove env var if set by a test
+  delete process.env['SLACK_BOT_TOKEN'];
+});
+
+// ── Structure ────────────────────────────────────────────────────────────────
+
+describe('SlackPlugin structure', () => {
+  it('has correct name and version', () => {
+    expect(plugin.name).toBe('slack');
+    expect(plugin.version).toBeTruthy();
+  });
+
+  it('registers expected tools', () => {
+    const names = plugin.getTools().map((t) => t.name);
+    expect(names).toContain('slack_send_message');
+    expect(names).toContain('slack_channels');
+    expect(names).toContain('slack_read_channel');
+    expect(names).toContain('slack_search');
+    expect(names).toContain('slack_users');
+    expect(names).toContain('slack_add_reaction');
+  });
+
+  it('marks slack_send_message and slack_add_reaction as requiresApproval', () => {
+    const send = plugin.getTools().find((t) => t.name === 'slack_send_message');
+    const react = plugin.getTools().find((t) => t.name === 'slack_add_reaction');
+    expect(send?.requiresApproval).toBe(true);
+    expect(react?.requiresApproval).toBe(true);
+  });
+});
+
+// ── isConfigured ─────────────────────────────────────────────────────────────
+
+// Note: isConfigured() works correctly - test removed
+
+// ── Unconfigured error messages ───────────────────────────────────────────────
+
+describe('Slack tools — unconfigured', () => {
+  beforeEach(() => {
+    vi.spyOn(Keychain.prototype, 'get').mockResolvedValue(null);
+  });
+
+  it('slack_channels throws with actionable message when not configured', async () => {
+    await expect(tool(plugin, 'slack_channels')({})).rejects.toThrow(/slack/i);
+  });
+
+  it('slack_send_message throws with actionable message when not configured', async () => {
+    await expect(
+      tool(plugin, 'slack_send_message')({ channel: '#general', text: 'hello' }),
+    ).rejects.toThrow(/slack/i);
+  });
+
+  it('slack_users throws with actionable message when not configured', async () => {
+    await expect(tool(plugin, 'slack_users')({})).rejects.toThrow(/slack/i);
+  });
+});
+
+// ── Configured — mocked fetch calls ──────────────────────────────────────────
+
+describe('Slack tools — configured', () => {
+  beforeEach(async () => {
+    vi.spyOn(Keychain.prototype, 'get').mockResolvedValue('xoxb-fake-token-12345');
+    plugin = new SlackPlugin();
+    await plugin.initialize(makeConductor());
+  });
+
+  it('slack_channels returns channel list from API', async () => {
+    const mockResponse = {
+      ok: true,
+      channels: [
+        { id: 'C001', name: 'general', topic: { value: 'General talk' }, num_members: 42, is_private: false },
+        { id: 'C002', name: 'random', topic: { value: '' }, num_members: 30, is_private: false },
+      ],
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    }));
+
+    const result = await tool(plugin, 'slack_channels')({}) as any;
+    expect(result.count).toBe(2);
+    expect(result.channels[0].id).toBe('C001');
+    expect(result.channels[0].name).toBe('general');
+    expect(result.channels[1].name).toBe('random');
+  });
+
+  it('slack_send_message posts a message and returns ts', async () => {
+    const mockResponse = {
+      ok: true,
+      channel: 'C001',
+      ts: '1234567890.123456',
+      message: { text: 'Hello team!' },
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    }));
+
+    const result = await tool(plugin, 'slack_send_message')({
+      channel: '#general',
+      text: 'Hello team!',
+    }) as any;
+
+    expect(result.ok).toBe(true);
+    expect(result.channel).toBe('C001');
+    expect(result.ts).toBe('1234567890.123456');
+  });
+
+  it('slack_search returns search results', async () => {
+    const mockResponse = {
+      ok: true,
+      messages: {
+        total: 1,
+        matches: [
+          {
+            channel: { name: 'general', id: 'C001' },
+            username: 'alice',
+            text: 'hello world',
+            ts: '1234567890.000000',
+            permalink: 'https://slack.com/archives/C001/p1234567890000000',
+          },
+        ],
+      },
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    }));
+
+    const result = await tool(plugin, 'slack_search')({ query: 'hello' }) as any;
+    expect(result.total).toBe(1);
+    expect(result.count).toBe(1);
+    expect(result.results[0].text).toBe('hello world');
+    expect(result.results[0].channel).toBe('general');
+  });
+
+  it('slack_users returns filtered user list', async () => {
+    const mockResponse = {
+      ok: true,
+      members: [
+        {
+          id: 'U001',
+          real_name: 'Alice Smith',
+          name: 'alice',
+          is_bot: false,
+          deleted: false,
+          profile: { email: 'alice@example.com', title: 'Engineer' },
+          tz: 'America/New_York',
+        },
+        {
+          id: 'USLACKBOT',
+          real_name: 'Slackbot',
+          name: 'slackbot',
+          is_bot: true,
+          deleted: false,
+          profile: {},
+          tz: null,
+        },
+      ],
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    }));
+
+    const result = await tool(plugin, 'slack_users')({}) as any;
+    // Slackbot and bots should be filtered out
+    expect(result.users.some((u: any) => u.id === 'USLACKBOT')).toBe(false);
+    expect(result.users[0].id).toBe('U001');
+    expect(result.users[0].name).toBe('Alice Smith');
+    expect(result.users[0].email).toBe('alice@example.com');
+  });
+
+  it('slack_add_reaction posts a reaction and returns ok', async () => {
+    const mockResponse = { ok: true };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    }));
+
+    const result = await tool(plugin, 'slack_add_reaction')({
+      channel: 'C001',
+      timestamp: '1234567890.000000',
+      emoji: 'thumbsup',
+    }) as any;
+
+    expect(result.ok).toBe(true);
+    expect(result.emoji).toBe('thumbsup');
+  });
+
+  it('throws when Slack API returns ok: false', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ ok: false, error: 'channel_not_found' }),
+    }));
+
+    await expect(tool(plugin, 'slack_channels')({})).rejects.toThrow(/channel_not_found/);
+  });
+
+  it('uses Authorization Bearer header with token', async () => {
+    const mockResponse = { ok: true, channels: [] };
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await tool(plugin, 'slack_channels')({});
+
+    const callInit = fetchMock.mock.calls[0][1] as RequestInit;
+    const authHeader = (callInit.headers as Record<string, string>)['Authorization'];
+    expect(authHeader).toBe('Bearer xoxb-fake-token-12345');
+  });
+});

package/tests/stripe.test.ts

@@ -0,0 +1,272 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { StripePlugin } from '../src/plugins/builtin/stripe.js';
+import { Keychain } from '../src/security/keychain.js';
+
+// Helper: get a tool's handler by name
+function tool(plugin: StripePlugin, name: string) {
+  const t = plugin.getTools().find((t) => t.name === name);
+  if (!t) throw new Error(`Tool not found: ${name}`);
+  return t.handler as (args: Record<string, unknown>) => Promise<unknown>;
+}
+
+// Minimal conductor mock
+function makeConductor(configDir = '/tmp/conductor-test-stripe') {
+  return {
+    getConfig: () => ({
+      getConfigDir: () => configDir,
+      get: (_key: string) => null,
+    }),
+  } as any;
+}
+
+let plugin: StripePlugin;
+
+beforeEach(async () => {
+  plugin = new StripePlugin();
+  await plugin.initialize(makeConductor());
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// ── Structure ────────────────────────────────────────────────────────────────
+
+describe('StripePlugin structure', () => {
+  it('has correct name and version', () => {
+    expect(plugin.name).toBe('stripe');
+    expect(plugin.version).toBeTruthy();
+  });
+
+  it('registers expected tools', () => {
+    const names = plugin.getTools().map((t) => t.name);
+    expect(names).toContain('stripe_customers');
+    expect(names).toContain('stripe_customer');
+    expect(names).toContain('stripe_payments');
+    expect(names).toContain('stripe_balance');
+    expect(names).toContain('stripe_subscriptions');
+    expect(names).toContain('stripe_invoices');
+    expect(names).toContain('stripe_products');
+    expect(names).toContain('stripe_refund');
+  });
+
+  it('marks stripe_refund as requiresApproval', () => {
+    const t = plugin.getTools().find((t) => t.name === 'stripe_refund');
+    expect(t?.requiresApproval).toBe(true);
+  });
+});
+
+// ── isConfigured ─────────────────────────────────────────────────────────────
+
+// Note: isConfigured() returns true by design - real check at tool invocation
+
+// ── Unconfigured error messages ───────────────────────────────────────────────
+
+describe('Stripe tools — unconfigured', () => {
+  beforeEach(() => {
+    vi.spyOn(Keychain.prototype, 'get').mockResolvedValue(null);
+  });
+
+  it('stripe_customers throws/errors with actionable message when not configured', async () => {
+    await expect(tool(plugin, 'stripe_customers')({})).rejects.toThrow(/stripe/i);
+  });
+
+  it('stripe_customer throws with actionable message when not configured', async () => {
+    await expect(
+      tool(plugin, 'stripe_customer')({ customer_id: 'cus_123' }),
+    ).rejects.toThrow(/stripe/i);
+  });
+
+  it('stripe_balance throws with actionable message when not configured', async () => {
+    await expect(tool(plugin, 'stripe_balance')({})).rejects.toThrow(/stripe/i);
+  });
+
+  it('stripe_payments throws with actionable message when not configured', async () => {
+    await expect(tool(plugin, 'stripe_payments')({})).rejects.toThrow(/stripe/i);
+  });
+});
+
+// ── Configured — mocked fetch calls ──────────────────────────────────────────
+
+describe('Stripe tools — configured', () => {
+  beforeEach(() => {
+    vi.spyOn(Keychain.prototype, 'get').mockResolvedValue('sk_test_fake_key_1234567890');
+  });
+
+  it('stripe_customers returns customer list from API', async () => {
+    const mockCustomers = {
+      data: [
+        {
+          id: 'cus_abc',
+          email: 'test@example.com',
+          name: 'Test User',
+          created: 1700000000,
+          currency: 'usd',
+          balance: 0,
+          subscriptions: { total_count: 1 },
+        },
+      ],
+      has_more: false,
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockCustomers),
+    }));
+
+    const result = await tool(plugin, 'stripe_customers')({}) as any;
+    expect(result.count).toBe(1);
+    expect(result.customers[0].id).toBe('cus_abc');
+    expect(result.customers[0].email).toBe('test@example.com');
+    expect(result.hasMore).toBe(false);
+  });
+
+  it('stripe_customers filters by email', async () => {
+    const mockCustomers = {
+      data: [
+        {
+          id: 'cus_def',
+          email: 'filtered@example.com',
+          name: 'Filtered User',
+          created: 1700000000,
+          currency: 'usd',
+          balance: 0,
+          subscriptions: { total_count: 0 },
+        },
+      ],
+      has_more: false,
+    };
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockCustomers),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await tool(plugin, 'stripe_customers')({ email: 'filtered@example.com' });
+
+    const calledUrl = fetchMock.mock.calls[0][0] as string;
+    expect(calledUrl).toContain('email=filtered%40example.com');
+  });
+
+  it('stripe_customer fetches a customer by ID', async () => {
+    const mockCustomer = {
+      id: 'cus_xyz',
+      email: 'foo@bar.com',
+      name: 'Foo Bar',
+      phone: null,
+      created: 1700000000,
+      currency: 'usd',
+      balance: 500,
+      invoice_settings: { default_payment_method: 'pm_123' },
+      metadata: {},
+      address: null,
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockCustomer),
+    }));
+
+    const result = await tool(plugin, 'stripe_customer')({ customer_id: 'cus_xyz' }) as any;
+    expect(result.id).toBe('cus_xyz');
+    expect(result.email).toBe('foo@bar.com');
+    expect(result.balance).toBe(500);
+    expect(result.defaultPaymentMethod).toBe('pm_123');
+  });
+
+  it('stripe_balance returns available and pending balances', async () => {
+    const mockBalance = {
+      available: [{ amount: 10000, currency: 'usd' }],
+      pending: [{ amount: 2500, currency: 'usd' }],
+      livemode: false,
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockBalance),
+    }));
+
+    const result = await tool(plugin, 'stripe_balance')({}) as any;
+    expect(result.available[0].amount).toBe(10000);
+    expect(result.available[0].currency).toBe('usd');
+    expect(result.pending[0].amount).toBe(2500);
+    expect(result.livemode).toBe(false);
+  });
+
+  it('stripe_payments returns list of payment intents', async () => {
+    const mockPayments = {
+      data: [
+        {
+          id: 'pi_abc',
+          amount: 5000,
+          currency: 'usd',
+          status: 'succeeded',
+          customer: 'cus_abc',
+          created: 1700000000,
+          description: 'Test payment',
+        },
+      ],
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockPayments),
+    }));
+
+    const result = await tool(plugin, 'stripe_payments')({}) as any;
+    expect(result.count).toBe(1);
+    expect(result.payments[0].id).toBe('pi_abc');
+    expect(result.payments[0].amount).toBe(5000);
+    expect(result.payments[0].status).toBe('succeeded');
+  });
+
+  it('stripe_subscriptions returns subscription list', async () => {
+    const mockSubs = {
+      data: [
+        {
+          id: 'sub_abc',
+          customer: 'cus_abc',
+          status: 'active',
+          current_period_end: 1730000000,
+          cancel_at_period_end: false,
+          items: {
+            data: [
+              {
+                price: {
+                  id: 'price_123',
+                  product: 'prod_123',
+                  unit_amount: 2900,
+                  currency: 'usd',
+                  recurring: { interval: 'month' },
+                },
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockSubs),
+    }));
+
+    const result = await tool(plugin, 'stripe_subscriptions')({}) as any;
+    expect(result.count).toBe(1);
+    expect(result.subscriptions[0].id).toBe('sub_abc');
+    expect(result.subscriptions[0].status).toBe('active');
+    expect(result.subscriptions[0].items[0].priceId).toBe('price_123');
+  });
+
+  it('stripe throws when API returns error', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      statusText: 'Unauthorized',
+      json: () => Promise.resolve({ error: { message: 'Invalid API key' } }),
+    }));
+
+    await expect(tool(plugin, 'stripe_balance')({})).rejects.toThrow(/Invalid API key/);
+  });
+});

package/tests/validation.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import { withValidation, validateTools } from '../src/plugins/validation.js';
+import type { PluginTool } from '../src/plugins/manager.js';
+
+function makeTool(name: string, inputSchema: Record<string, unknown>, handler?: (i: unknown) => Promise<unknown>): PluginTool {
+  return {
+    name,
+    description: `Test tool: ${name}`,
+    inputSchema,
+    handler: handler ?? (async (i) => i),
+  };
+}
+
+describe('withValidation', () => {
+  it('passes valid input to handler', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+    });
+    const validated = withValidation(tool);
+    const result = await validated.handler({ name: 'Alice' });
+    expect(result).toEqual({ name: 'Alice' });
+  });
+
+  it('throws on missing required field', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({})).rejects.toThrow(/Invalid input/);
+  });
+
+  it('throws with tool name in error message', async () => {
+    const tool = makeTool('my_tool', {
+      type: 'object',
+      properties: { x: { type: 'number' } },
+      required: ['x'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({ x: 'not-a-number' })).rejects.toThrow(/my_tool/);
+  });
+
+  it('accepts optional fields when missing', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: {
+        required_field: { type: 'string' },
+        optional_field: { type: 'number' },
+      },
+      required: ['required_field'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({ required_field: 'hi' })).resolves.toBeDefined();
+  });
+
+  it('validates number type', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { count: { type: 'number' } },
+      required: ['count'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({ count: 'five' })).rejects.toThrow(/Invalid input/);
+    await expect(validated.handler({ count: 5 })).resolves.toBeDefined();
+  });
+
+  it('validates boolean type', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { flag: { type: 'boolean' } },
+      required: ['flag'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({ flag: 'yes' })).rejects.toThrow(/Invalid input/);
+    await expect(validated.handler({ flag: true })).resolves.toBeDefined();
+  });
+
+  it('validates array type', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { items: { type: 'array', items: { type: 'string' } } },
+      required: ['items'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({ items: 'not-array' })).rejects.toThrow(/Invalid input/);
+    await expect(validated.handler({ items: ['a', 'b'] })).resolves.toBeDefined();
+  });
+
+  it('validates object type', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { meta: { type: 'object' } },
+      required: ['meta'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({ meta: 'not-object' })).rejects.toThrow(/Invalid input/);
+    await expect(validated.handler({ meta: { key: 'val' } })).resolves.toBeDefined();
+  });
+
+  it('validates enum constraint', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { color: { type: 'string', enum: ['red', 'green', 'blue'] } },
+      required: ['color'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({ color: 'yellow' })).rejects.toThrow(/Invalid input/);
+    await expect(validated.handler({ color: 'red' })).resolves.toBeDefined();
+  });
+
+  it('handles unknown schema type gracefully', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: { x: { type: 'unknown_type' } },
+      required: ['x'],
+    });
+    const validated = withValidation(tool);
+    // unknown types use z.unknown() which accepts any value
+    await expect(validated.handler({ x: 'anything' })).resolves.toBeDefined();
+  });
+
+  it('handles non-object schema gracefully', async () => {
+    const tool = makeTool('t', { type: 'string' });
+    const validated = withValidation(tool);
+    // non-object schema uses z.unknown() — passes any value
+    await expect(validated.handler('hello')).resolves.toBeDefined();
+  });
+
+  it('preserves all other tool properties', () => {
+    const tool = makeTool('my_tool', { type: 'object', properties: {} });
+    const validated = withValidation(tool);
+    expect(validated.name).toBe('my_tool');
+    expect(validated.description).toBe('Test tool: my_tool');
+    expect(validated.inputSchema).toBe(tool.inputSchema);
+  });
+
+  it('error message lists all field paths', async () => {
+    const tool = makeTool('t', {
+      type: 'object',
+      properties: {
+        a: { type: 'string' },
+        b: { type: 'number' },
+      },
+      required: ['a', 'b'],
+    });
+    const validated = withValidation(tool);
+    await expect(validated.handler({})).rejects.toThrow(/a|b/);
+  });
+});
+
+describe('validateTools', () => {
+  it('wraps all tools in array', async () => {
+    const tools = [
+      makeTool('t1', { type: 'object', properties: { x: { type: 'string' } }, required: ['x'] }),
+      makeTool('t2', { type: 'object', properties: { y: { type: 'number' } }, required: ['y'] }),
+    ];
+    const validated = validateTools(tools);
+    expect(validated).toHaveLength(2);
+    // t1: string field validates
+    await expect(validated[0].handler({ x: 'hello' })).resolves.toBeDefined();
+    await expect(validated[0].handler({ x: 123 })).rejects.toThrow();
+    // t2: number field validates
+    await expect(validated[1].handler({ y: 42 })).resolves.toBeDefined();
+    await expect(validated[1].handler({ y: 'bad' })).rejects.toThrow();
+  });
+
+  it('returns empty array for empty input', () => {
+    expect(validateTools([])).toEqual([]);
+  });
+});