6
} from '@composio/client/resources/auth-configs';
7
import {
8
APIConnectionError,
9
- NotFoundError,
9
make as makeComposioClient,
10
type ComposioError,
11
type RequestOptions,
16
TriggerInstanceUpsertParams,
17
} from '@composio/client/resources/trigger-instances';
18
import type { SessionRetrieveInfoResponse } from '@composio/client/resources/auth';
20
-import type { ToolRetrieveResponse } from '@composio/client/resources/tools';
19
import { TIMESTAMP } from '../models/account';
20
import * as BunFileSystem from '@effect/platform-bun/BunFileSystem';
21
import * as BunPath from '@effect/platform-bun/BunPath';
31
Path,
32
References,
33
Schedule,
36
- String,
34
} from 'effect';
35
import { CliConfig, type Command as CliCommand } from 'effect/cli';
36
import { ChildProcess, ChildProcessSpawner } from 'effect/process';
39
import * as MockConsole from './mock-console';
40
import * as MockTerminal from './mock-terminal';
41
import { TerminalUITest } from './terminal-ui-test';
45
-import type { Toolkits, ToolkitDetailed } from 'src/models/toolkits';
42
import { NodeProcess } from 'src/services/node-process';
43
import { cliDebugFlagsLayer } from 'src/services/runtime-flags';
44
import {
45
ComposioClientSingleton,
46
ComposioSessionRepository,
47
ComposioToolkitsRepository,
52
- type ToolkitProjectScope,
48
} from 'src/services/composio-clients';
54
-import {
55
- InvalidToolkitsError,
56
- InvalidToolkitVersionsError,
57
- type InvalidVersionDetail,
58
-} from 'src/services/toolkit-version-validation';
49
import { type OrganizationSummary, type OrgProject } from 'src/services/composio-account';
60
-import type { ToolkitVersionOverrides } from 'src/effects/toolkit-version-overrides';
50
import { JsPackageManagerDetector } from 'src/services/js-package-manager-detector';
62
-import type { Tool, Tools } from 'src/models/tools';
63
-import type { TriggerTypes, TriggerTypesAsEnums } from 'src/models/trigger-types';
51
import type { AuthConfigItem } from 'src/models/auth-configs';
52
import type { ConnectedAccountItem } from 'src/models/connected-accounts';
53
import type { TriggerInstanceItem } from 'src/models/triggers';
67
-import type { ToolkitVersionSpec } from 'src/effects/toolkit-version-overrides';
54
import { ComposioUserContextLive } from 'src/services/user-context';
55
import { ComposioCliUserConfig } from 'src/services/cli-user-config';
56
import { CliUserConfig } from 'src/models/cli-user-config';
87
} from 'src/services/setup-skill-installer';
88
import { FetchHttpClient, HttpClient } from 'effect/http';
89
import * as BunServices from '@effect/platform-bun/BunServices';
104
-
105
-/**
106
- * A 404 as the Effect client reports one, with the API error envelope when the
107
- * scenario has one.
108
- */
109
-const notFoundError = (
110
- message: string,
111
- envelope?: { readonly message: string; readonly suggested_fix: string }
112
-) =>
113
- new NotFoundError({
114
- message,
115
- method: 'GET',
116
- url: 'https://mock.invalid',
117
- status: 404,
118
- requestId: undefined,
119
- details: envelope ? { ...envelope, code: 404, slug: 'Not_Found', status: 404 } : undefined,
120
- body: envelope ? { error: envelope } : undefined,
121
- });
90
+import { notFoundError } from '../layers/not-found';
91
+import {
92
+ resolveToolkitsTestData,
93
+ toolkitCatalogMethods,
94
+ type ToolkitsTestData,
95
+} from '../layers/toolkits';
96
97
/**
98
* The credentials and scope one mock-client request carries: the parameters
153
/**
154
* Mock toolkit-related data to use in test.
155
*/
182
- toolkitsData?: {
183
- toolkits?: Toolkits;
184
- /**
185
- * Custom toolkits registered in the test project. Kept apart from
186
- * `toolkits`, the Composio-managed catalog, as the API keeps them apart.
187
- */
188
- projectToolkits?: Toolkits;
189
- /**
190
- * The project `projectToolkits` belong to. When set, a project-toolkit
191
- * lookup for any other scope, or for none, finds nothing, as the API
192
- * would answer for another project.
193
- */
194
- projectToolkitsScope?: ToolkitProjectScope;
195
- /**
196
- * Called with the scope of every project-toolkit lookup.
197
- */
198
- onGetProjectToolkits?: (scope: ToolkitProjectScope | undefined) => void;
199
- detailedToolkits?: ToolkitDetailed[];
200
- tools?: Tools;
201
- triggerTypesAsEnums?: TriggerTypesAsEnums;
202
- triggerTypes?: TriggerTypes;
203
- };
156
+ toolkitsData?: ToolkitsTestData;
157
158
/**
159
* Account, session-info, and consumer data served by the mock client's
322
323
type RequiredLayer = Layer.Layer<CliCommand.Environment, unknown, never>;
324
372
-const toClientTool = (tool: Tool): ToolRetrieveResponse => {
373
- // Derive toolkit slug from tool slug prefix (e.g. GMAIL_SEND_EMAIL -> gmail)
374
- const parts = tool.slug.split('_');
375
- const toolkitSlug = parts.length > 1 ? parts[0]!.toLowerCase() : '';
376
- return {
377
- ...tool,
378
- available_versions: [...tool.available_versions],
379
- tags: [...tool.tags],
380
- no_auth: false,
381
- version: 'latest',
382
- scopes: [],
383
- scope_requirements: null,
384
- is_deprecated: false,
385
- deprecated: {
386
- displayName: tool.name,
387
- version: 'latest',
388
- available_versions: [...tool.available_versions],
389
- is_deprecated: false,
390
- toolkit: { logo: '' },
391
- },
392
- toolkit: { name: toolkitSlug, slug: toolkitSlug, logo: '' },
393
- };
394
-};
395
-
325
/**
326
* Effect layer that injects all the services needed for tests, using mocks to avoid
327
* side-effects like unwanted HTTP requests to remote services.
328
*/
329
export const TestLayer = (input?: TestLiveInput) =>
330
Effect.gen(function* () {
402
- const defaultAppClientData = {
403
- toolkits: [] as Toolkits,
404
- projectToolkits: [] as Toolkits,
405
- detailedToolkits: [] as ToolkitDetailed[],
406
- tools: [] as Tools,
407
- triggerTypesAsEnums: [] as TriggerTypesAsEnums,
408
- triggerTypes: [] as TriggerTypes,
409
- } satisfies TestLiveInput['toolkitsData'];
331
const fixture = input?.fixture;
411
- const toolkitsData = {
412
- ...defaultAppClientData,
413
- ...(input?.toolkitsData ?? {}),
414
- detailedToolkits:
415
- input?.toolkitsData?.detailedToolkits ?? defaultAppClientData.detailedToolkits,
416
- };
332
+ const toolkitsData = resolveToolkitsTestData(input?.toolkitsData);
333
334
const defaultAuthConfigsData = {
335
items: [] as AuthConfigItem[],
371
const ComposioToolkitsRepositoryTest = Layer.succeed(
372
ComposioToolkitsRepository,
373
ComposioToolkitsRepository.of({
458
- getToolkits: () => Effect.succeed(toolkitsData.toolkits),
459
- getProjectToolkits: scope =>
460
- Effect.sync(() => {
461
- toolkitsData.onGetProjectToolkits?.(scope);
462
- const owner = toolkitsData.projectToolkitsScope;
463
- const inScope =
464
- owner === undefined ||
465
- (scope?.orgId === owner.orgId && scope.projectId === owner.projectId);
466
- return inScope ? toolkitsData.projectToolkits : [];
467
- }),
468
- getToolkitsBySlugs: (slugs: ReadonlyArray<string>) => {
469
- const normalizedSlugs = new Set(slugs.map(s => String.toLowerCase(s)));
470
- const found = toolkitsData.toolkits.filter(t =>
471
- normalizedSlugs.has(String.toLowerCase(t.slug))
472
- );
473
- if (found.length !== slugs.length) {
474
- const foundSlugs = new Set(found.map(t => String.toLowerCase(t.slug)));
475
- const notFound = slugs.filter(s => !foundSlugs.has(String.toLowerCase(s)));
476
- return Effect.fail(
477
- new InvalidToolkitsError({
478
- invalidToolkits: [...notFound],
479
- availableToolkits: toolkitsData.toolkits.map(t => t.slug),
480
- })
481
- );
482
- }
483
- return Effect.succeed(found);
484
- },
485
- getMetrics: () => Effect.succeed({ byteSize: 0, requests: 0 }),
486
- getToolsAsEnums: () => Effect.succeed(toolkitsData.tools.map(tool => tool.slug)),
487
- getTriggerTypesAsEnums: () => Effect.succeed(toolkitsData.triggerTypesAsEnums),
488
- getTriggerTypes: (toolkitSlugs?: ReadonlyArray<string>) => {
489
- let triggers = toolkitsData.triggerTypes;
490
- if (toolkitSlugs && toolkitSlugs.length > 0) {
491
- const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
492
- triggers = triggers.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
493
- }
494
- return Effect.succeed(triggers);
495
- },
496
- getTriggerTypeDetailed: (slug: string) => {
497
- const found = toolkitsData.triggerTypes.find(
498
- trigger => trigger.slug.toUpperCase() === slug.toUpperCase()
499
- );
500
- if (!found) {
501
- return Effect.fail(notFoundError(`Trigger type "${slug}" not found`));
502
- }
503
- return Effect.succeed(found);
504
- },
505
- getTools: (toolkitSlugs?: ReadonlyArray<string>) => {
506
- let tools = toolkitsData.tools;
507
- if (toolkitSlugs && toolkitSlugs.length > 0) {
508
- const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
509
- tools = tools.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
510
- }
511
- return Effect.succeed(tools);
512
- },
513
- validateToolkits: (toolkitSlugs: ReadonlyArray<string>) => {
514
- const normalizedInputSlugs = toolkitSlugs.map(slug => String.toLowerCase(slug));
515
- const availableSlugs = toolkitsData.toolkits.map(toolkit =>
516
- String.toLowerCase(toolkit.slug)
517
- );
518
- const invalidSlugs = normalizedInputSlugs.filter(slug => !availableSlugs.includes(slug));
519
-
520
- if (invalidSlugs.length > 0) {
521
- return Effect.fail(
522
- new InvalidToolkitsError({
523
- invalidToolkits: invalidSlugs,
524
- availableToolkits: availableSlugs,
525
- })
526
- );
527
- }
528
-
529
- return Effect.succeed(normalizedInputSlugs);
530
- },
531
- filterToolkitsBySlugs: (toolkits, toolkitSlugs) => {
532
- const normalizedSlugs = new Set(toolkitSlugs.map(slug => String.toLowerCase(slug)));
533
- return toolkits.filter(toolkit => normalizedSlugs.has(String.toLowerCase(toolkit.slug)));
534
- },
535
- getToolsByVersionSpecs: (specs: ReadonlyArray<ToolkitVersionSpec>) => {
536
- // Filter tools based on toolkit slugs from specs
537
- const toolkitSlugs = specs.map(s => s.toolkitSlug.toUpperCase());
538
- const prefixes = toolkitSlugs.map(s => `${s}_`);
539
- const tools = toolkitsData.tools.filter(t =>
540
- prefixes.some(p => t.slug.toUpperCase().startsWith(p))
541
- );
542
- return Effect.succeed(tools);
543
- },
544
- validateToolkitVersions: (
545
- overrides: ToolkitVersionOverrides,
546
- relevantToolkits?: ReadonlyArray<string>
547
- ) => {
548
- // Mock implementation that validates against test fixture
549
- const invalidVersions: InvalidVersionDetail[] = [];
550
- const warnings: string[] = [];
551
-
552
- for (const [toolkit, version] of overrides) {
553
- // Check if toolkit should be validated
554
- if (relevantToolkits && !relevantToolkits.map(s => s.toLowerCase()).includes(toolkit)) {
555
- warnings.push(`Version override for "${toolkit}" will be ignored`);
556
- continue;
557
- }
558
-
559
- // Check if toolkit exists in the fixture
560
- const toolkitExists = toolkitsData.toolkits.some(
561
- t => String.toLowerCase(t.slug) === toolkit
562
- );
563
-
564
- if (!toolkitExists) {
565
- return Effect.fail(
566
- new InvalidToolkitsError({
567
- invalidToolkits: [toolkit],
568
- availableToolkits: toolkitsData.toolkits.map(t => t.slug),
569
- })
570
- );
571
- }
572
-
573
- // Mock: only accept 'latest' or versions matching pattern YYYYMMDD_NN
574
- const validPattern = /^\d{8}_\d{2}$/;
575
- if (version !== 'latest' && !validPattern.test(version)) {
576
- invalidVersions.push({
577
- toolkit,
578
- requestedVersion: version,
579
- availableVersions: ['20250901_00', '20250815_00', '20250710_00'],
580
- });
581
- }
582
- }
583
-
584
- if (invalidVersions.length > 0) {
585
- return Effect.fail(new InvalidToolkitVersionsError({ invalidVersions }));
586
- }
587
-
588
- return Effect.succeed({
589
- validatedOverrides: overrides,
590
- warnings: warnings as ReadonlyArray<string>,
591
- });
592
- },
593
- searchToolkits: (params: {
594
- search?: string;
595
- category?: string;
596
- limit?: number;
597
- cursor?: string;
598
- }) => {
599
- let results = [...toolkitsData.toolkits];
600
-
601
- if (params.search) {
602
- const q = params.search.toLowerCase();
603
- results = results.filter(
604
- t =>
605
- t.name.toLowerCase().includes(q) ||
606
- t.slug.toLowerCase().includes(q) ||
607
- t.meta.description.toLowerCase().includes(q)
608
- );
609
- }
610
-
611
- const limit = params.limit ?? 30;
612
- const items = results.slice(0, limit);
613
- return Effect.succeed({
614
- items,
615
- total_items: results.length,
616
- total_pages: Math.ceil(results.length / limit),
617
- next_cursor: null,
618
- });
619
- },
620
- searchTools: (params: {
621
- search?: string;
622
- toolkit_slug?: string;
623
- tags?: string;
624
- limit?: number;
625
- cursor?: string;
626
- }) => {
627
- let results = [...toolkitsData.tools];
628
-
629
- if (params.toolkit_slug) {
630
- const slugs = params.toolkit_slug.split(',').map(s => s.trim().toUpperCase() + '_');
631
- results = results.filter(t => slugs.some(p => t.slug.toUpperCase().startsWith(p)));
632
- }
633
-
634
- if (params.search) {
635
- const q = params.search.toLowerCase();
636
- results = results.filter(
637
- t =>
638
- t.name.toLowerCase().includes(q) ||
639
- t.slug.toLowerCase().includes(q) ||
640
- t.description.toLowerCase().includes(q)
641
- );
642
- }
643
-
644
- if (params.tags) {
645
- const tagList = params.tags.split(',').map(t => t.trim().toLowerCase());
646
- results = results.filter(t =>
647
- tagList.some(tag => t.tags.map(tt => tt.toLowerCase()).includes(tag))
648
- );
649
- }
650
-
651
- const limit = params.limit ?? 30;
652
- const items = results.slice(0, limit).map(toClientTool);
653
- return Effect.succeed({
654
- items,
655
- total_items: results.length,
656
- total_pages: Math.ceil(results.length / limit),
657
- current_page: 1,
658
- next_cursor: null,
659
- });
660
- },
661
- getToolDetailed: (slug: string) => {
662
- const found = toolkitsData.tools.find(t => t.slug.toUpperCase() === slug.toUpperCase());
663
- if (!found) {
664
- return Effect.fail(notFoundError(`Tool "${slug}" not found`));
665
- }
666
- return Effect.succeed(toClientTool(found));
667
- },
668
- getToolkitDetailed: (slug: string) => {
669
- const found = toolkitsData.detailedToolkits.find(
670
- t => t.slug.toLowerCase() === slug.toLowerCase()
671
- );
672
- if (!found) {
673
- return Effect.fail(notFoundError(`Toolkit "${slug}" not found`));
674
- }
675
- return Effect.succeed(found);
676
- },
374
+ ...toolkitCatalogMethods(toolkitsData),
375
listAuthConfigs: (params: {
376
search?: string;
377
toolkit_slug?: string;