@devries-cameron20 / composio Mirror · read-only / commits / 9c88c6009
Fork 0

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Mirrored from https://github.com/Camo67/composio.git

Synced Nov 21, 08:30 UTC

refactor(cli): move `toolkits list`, `search` and `version` into the directory shape (#4988)

This PR: - moves `dev toolkits list`, `search` and `version` from `toolkits/commands/` to `toolkits/<name>/toolkits.<name>.{cmd,handler}.ts`, plus `toolkits.version.format.ts`; `toolkits/commands/` no longer exists. `list` and `search` keep rendering rows through the group's shared `toolkits/format.ts`, as `toolkits info` does - `toolkits list` still reads `--user-id` from `CommandSurface`; its user fallback (`--user-id`, then the directory's test user, then the global one) and its `--connected` rule are now the pure `resolveToolkitsListUser` and `applyConnectedFilter`, and the session lookup is an `Option` pipeline instead of `let` and `undefined` checks - `list` and `search` set exit code 1 through `NodeProcess` instead of writing `process.exitCode` directly; `version` reads its unvalidated response through a narrow `VersionedToolkit` param type instead of a cast - moves the four test files to `test/src/commands/toolkits/{list,search,version}/` and adds cases: `list --connected` with an active connection, with a rejected session, and with no user; catalog and search failures (stderr message, `[]` on stdout, exit 1); the `search --limit` clamp; handler tables for the user fallback, the `--connected` filter, and the version history (none, missing `meta`, more than 20) - part of the CLI command-layout series (legacy-shape cleanup before U10); no user-visible change, so no CHANGELOG entry ## Context Verified on the branch tip: | Check | Result | | --- | --- | | `pnpm --filter @composio/cli typecheck` | passes | | `pnpm --filter @composio/cli test` (skills, boundaries, command tests, Vitest, including `root-help-consistency.test.ts`) | 189 files, 2060 passed, 1 skipped; the one failure was the known `analytics.dispatch.test.ts` install_id flake, which passes on rerun | | `validate:command-tests` | 2 exemptions (unchanged) | | `lint:effect` | 0 diagnostics | | `oxlint`, prettier | clean | | root `pnpm typecheck` | passes | | Binary smoke | compared with an `origin/next` (c37b41dd8) binary, isolated `HOME`: stdout, stderr and exit code are identical for 28 runs. Logged out: root, `dev`, `dev toolkits` and every `toolkits` subcommand `--help`; `list`, `search`, `version` with and without flags (login hint, exit 1); missing and extra arguments, a bad `--limit`, an unknown flag; `--user-id`/`--project-name` on each. With a key and an unreachable API: `list` (plain, `--connected`, `--user-id`) and `search` print `[]` and exit 1, `version` exits 0, and the shared-flag rejections on `search`/`version` are unchanged |

Alberto Schiabel committed Oct 20, 2026 at 18:34 UTC 9c88c60096eef3bf80e118397b20c023378d97aa
17 files changed +831 -366
ts/packages/cli/src/commands/toolkits/commands/toolkits.list.cmd.ts deleted
-207
@@ -1,207 +0,0 @@
1 -import process from 'node:process';
2 -import { Command, Flag } from 'effect/cli';
3 -import { Effect, Option } from 'effect';
4 -import { TerminalUI } from 'src/services/terminal-ui';
5 -import { resolveToolRouterSession } from 'src/effects/create-tool-router-session';
6 -import { ComposioClientSingleton, ComposioToolkitsRepository } from 'src/services/composio-clients';
7 -import { idempotent } from 'src/services/composio-request';
8 -import { ProjectContext } from 'src/services/project-context';
9 -import { ComposioUserContext } from 'src/services/user-context';
10 -import { CommandSurface, directoryTestUserId, namedProject } from 'src/commands/surface';
11 -import { clampLimit } from 'src/ui/clamp-limit';
12 -import { extractMessage } from 'src/utils/api-error-extraction';
13 -import { mergeToolkitData, formatToolkitsJson, formatToolkitsTable } from '../format';
14 -
15 -const query = Flag.String('query').pipe(
16 - Flag.withDescription('Text search by name, slug, or description'),
17 - Flag.optional
18 -);
19 -
20 -const limit = Flag.Int('limit').pipe(
21 - Flag.withDefault(30),
22 - Flag.withDescription('Number of results per page (1-1000)')
23 -);
24 -
25 -const connected = Flag.Boolean('connected').pipe(
26 - Flag.withDescription('Filter to connected toolkits only'),
27 - Flag.optional
28 -);
29 -
30 -/**
31 - * List available toolkits with connection status.
32 - *
33 - * Always fetches catalog data (tools_count, triggers_count, latest_version).
34 - * When a user ID is available (explicit --user-id, project, or global config),
35 - * also fetches session data to enrich with connection status.
36 - *
37 - * @example
38 - * ```bash
39 - * composio dev toolkits list
40 - * composio dev toolkits list --query "email"
41 - * composio dev toolkits list --connected
42 - * composio dev toolkits list --user-id "alice"
43 - * ```
44 - */
45 -export const toolkitsCmd$List = Command.make(
46 - 'list',
47 - { query, limit, connected },
48 - ({ query, limit, connected }) =>
49 - Effect.gen(function* () {
50 - const { userId } = yield* CommandSurface;
51 - const ui = yield* TerminalUI;
52 - const repo = yield* ComposioToolkitsRepository;
53 - const clientSingleton = yield* ComposioClientSingleton;
54 - const projectContext = yield* ProjectContext;
55 - const userContext = yield* ComposioUserContext;
56 -
57 - const clampedLimit = clampLimit(limit);
58 - // Resolved outside the session lookup, whose failures only drop the connection status.
59 - const project = yield* namedProject;
60 - const resolvedProjectContext = yield* projectContext.resolve;
61 - const testUserId = directoryTestUserId(
62 - resolvedProjectContext,
63 - Option.map(project, named => named.projectId)
64 - );
65 - const globalTestUserId = userContext.data.testUserId;
66 - const resolvedUserId = Option.match(userId, {
67 - onSome: value => Option.some(value),
68 - onNone: () => Option.orElse(testUserId, () => globalTestUserId),
69 - });
70 - const usingProjectTestUserId = Option.isNone(userId) && Option.isSome(testUserId);
71 - const usingGlobalTestUserId =
72 - Option.isNone(userId) && Option.isNone(testUserId) && Option.isSome(globalTestUserId);
73 -
74 - if (usingProjectTestUserId && Option.isSome(testUserId)) {
75 - yield* ui.log.warn(`Using test user id "${testUserId.value}"`);
76 - yield* ui.log.message('To show status for a specific user, use `--user-id`.');
77 - } else if (usingGlobalTestUserId && Option.isSome(globalTestUserId)) {
78 - yield* ui.log.warn(`Using global test user id "${globalTestUserId.value}"`);
79 - yield* ui.log.message('To show status for a specific user, use `--user-id`.');
80 - }
81 -
82 - if (Option.isSome(connected) && Option.isNone(resolvedUserId)) {
83 - yield* ui.log.warn(
84 - '`--connected` requires a user id. Use `--user-id` or run `composio dev init`.'
85 - );
86 - }
87 -
88 - // Fetch catalog data (always) and session context (when user ID available) in parallel.
89 - // The session toolkits call depends on the session ID, so it runs after session creation.
90 - const catalogEffect = repo.searchToolkits({
91 - search: Option.getOrUndefined(query),
92 - limit: clampedLimit,
93 - });
94 -
95 - // Resolve session context in parallel with catalog fetch (saves one round trip).
96 - const sessionContextEffect = Option.isSome(resolvedUserId)
97 - ? Effect.gen(function* () {
98 - const client = Option.isSome(project)
99 - ? project.value.client
100 - : yield* clientSingleton.get();
101 - const { sessionId } = yield* resolveToolRouterSession(client, resolvedUserId.value);
102 - return { client, sessionId };
103 - }).pipe(
104 - Effect.catch(error =>
105 - Effect.logDebug('Failed to create session:', error).pipe(Effect.as(undefined))
106 - )
107 - )
108 - : Effect.succeed(undefined as undefined);
109 -
110 - const [catalogResult, sessionContext] = yield* ui.withSpinner(
111 - 'Fetching toolkits...',
112 - Effect.all([catalogEffect, sessionContextEffect], { concurrency: 'unbounded' })
113 - );
114 -
115 - if (catalogResult.items.length === 0) {
116 - yield* ui.log.warn('No toolkits found. Try broadening your search.');
117 - yield* ui.output('[]');
118 - return;
119 - }
120 -
121 - // When session context is available, fetch session toolkits for connection status.
122 - let sessionItems:
123 - | ReadonlyArray<
124 - import('@composio/client/resources/tool-router').SessionToolkitsResponse.Item
125 - >
126 - | undefined;
127 - let sessionFailed = false;
128 - if (sessionContext) {
129 - const { client, sessionId } = sessionContext;
130 - // The session items only add connection status to the catalog rows,
131 - // and a failed read is already a silent fallback.
132 - sessionItems = yield* client.toolRouter.session
133 - .toolkits(
134 - sessionId,
135 - {
136 - search: Option.getOrUndefined(query),
137 - limit: clampedLimit,
138 - is_connected: Option.getOrUndefined(connected),
139 - },
140 - idempotent
141 - )
142 - .pipe(
143 - Effect.map(r => r.items),
144 - Effect.catch(error =>
145 - Effect.logDebug('Failed to fetch session toolkits:', error).pipe(
146 - Effect.as(
147 - [] as ReadonlyArray<
148 - import('@composio/client/resources/tool-router').SessionToolkitsResponse.Item
149 - >
150 - )
151 - )
152 - )
153 - );
154 - if (sessionItems.length === 0) {
155 - sessionFailed = true;
156 - sessionItems = undefined;
157 - }
158 - } else if (Option.isSome(resolvedUserId)) {
159 - // Session creation itself failed (caught in parallel fetch above).
160 - sessionFailed = true;
161 - }
162 -
163 - let unified = mergeToolkitData(catalogResult.items, sessionItems);
164 -
165 - // Apply --connected filter client-side: only keep toolkits with an active connection.
166 - const isConnectedFilter = Option.getOrUndefined(connected);
167 - if (isConnectedFilter && sessionItems) {
168 - unified = unified.filter(t => t.connected?.status === 'ACTIVE');
169 - } else if (isConnectedFilter && sessionFailed) {
170 - yield* ui.log.warn('`--connected` filter could not be applied — session data unavailable.');
171 - }
172 -
173 - if (unified.length === 0) {
174 - yield* ui.log.warn('No connected toolkits found. Try without --connected.');
175 - yield* ui.output('[]');
176 - return;
177 - }
178 -
179 - const showing = unified.length;
180 - const total = catalogResult.total_items;
181 - yield* ui.log.info(
182 - `Listing ${showing} of ${total} toolkits\n\n${formatToolkitsTable(unified)}`
183 - );
184 -
185 - const firstSlug = unified[0]?.slug;
186 - if (firstSlug) {
187 - yield* ui.log.step(
188 - `To view details of a toolkit:\n> composio dev toolkits info "${firstSlug}"`
189 - );
190 - }
191 - yield* ui.output(formatToolkitsJson(unified));
192 - }).pipe(
193 - Effect.catch(error =>
194 - Effect.gen(function* () {
195 - const ui = yield* TerminalUI;
196 - yield* ui.log.error(
197 - extractMessage(error) ?? 'An error occurred while fetching toolkits.'
198 - );
199 - yield* ui.output('[]');
200 - process.exitCode = 1;
201 - })
202 - )
203 - )
204 -).pipe(
205 - Command.withDescription('List available toolkits with connection status.'),
206 - Command.withExamples([{ command: 'composio dev toolkits list' }])
207 -);
ts/packages/cli/src/commands/toolkits/commands/toolkits.search.cmd.ts deleted
-73
@@ -1,73 +0,0 @@
1 -import process from 'node:process';
2 -import { Argument, Command, Flag } from 'effect/cli';
3 -import { Effect } from 'effect';
4 -import { ComposioToolkitsRepository } from 'src/services/composio-clients';
5 -import { TerminalUI } from 'src/services/terminal-ui';
6 -import { clampLimit } from 'src/ui/clamp-limit';
7 -import { extractMessage } from 'src/utils/api-error-extraction';
8 -import { mergeToolkitData, formatToolkitsTable, formatToolkitsJson } from '../format';
9 -
10 -const query = Argument.String('query').pipe(
11 - Argument.withDescription('Search query (e.g. "send emails")')
12 -);
13 -
14 -const limit = Flag.Int('limit').pipe(
15 - Flag.withDefault(10),
16 - Flag.withDescription('Number of results per page (1-1000)')
17 -);
18 -
19 -// TODO(tool-router-migration): migrate to Tool Router when the session toolkits endpoint
20 -// supports text search. Currently SessionToolsParams has no search capability.
21 -
22 -/**
23 - * Search toolkits by use case.
24 - *
25 - * @example
26 - * ```bash
27 - * composio dev toolkits search "send emails"
28 - * composio dev toolkits search "messaging" --limit 5
29 - * ```
30 - */
31 -export const toolkitsCmd$Search = Command.make('search', { query, limit }, ({ query, limit }) =>
32 - Effect.gen(function* () {
33 - const ui = yield* TerminalUI;
34 - const repo = yield* ComposioToolkitsRepository;
35 -
36 - const clampedLimit = clampLimit(limit);
37 -
38 - const result = yield* ui.withSpinner(
39 - `Searching toolkits for "${query}"...`,
40 - repo.searchToolkits({ search: query, limit: clampedLimit })
41 - );
42 -
43 - if (result.items.length === 0) {
44 - yield* ui.log.warn(`No toolkits found matching "${query}". Try broadening your search.`);
45 - yield* ui.output('[]');
46 - return;
47 - }
48 -
49 - const showing = result.items.length;
50 - const total = result.total_items;
51 -
52 - const unified = mergeToolkitData(result.items);
53 -
54 - yield* ui.log.info(`Found ${showing} of ${total} toolkits\n\n${formatToolkitsTable(unified)}`);
55 -
56 - // Next step hint
57 - const firstSlug = unified[0]?.slug;
58 - if (firstSlug) {
59 - yield* ui.log.step(`To view details:\n> composio dev toolkits info "${firstSlug}"`);
60 - }
61 -
62 - yield* ui.output(formatToolkitsJson(unified));
63 - }).pipe(
64 - Effect.catch(error =>
65 - Effect.gen(function* () {
66 - const ui = yield* TerminalUI;
67 - yield* ui.log.error(extractMessage(error) ?? 'An error occurred while searching toolkits.');
68 - yield* ui.output('[]');
69 - process.exitCode = 1;
70 - })
71 - )
72 - )
73 -).pipe(Command.withDescription('Search toolkits by use case.'));
ts/packages/cli/src/commands/toolkits/commands/toolkits.version.cmd.ts deleted
-81
@@ -1,81 +0,0 @@
1 -import { Argument, Command } from 'effect/cli';
2 -import { Effect, Option } from 'effect';
3 -import { ComposioClientSingleton } from 'src/services/composio-clients';
4 -import { TerminalUI } from 'src/services/terminal-ui';
5 -import { extractMessage } from 'src/utils/api-error-extraction';
6 -import { idempotent } from 'src/services/composio-request';
7 -
8 -const slug = Argument.String('slug').pipe(Argument.withDescription('Toolkit slug (e.g. "gmail")'));
9 -
10 -/**
11 - * Show toolkit version information.
12 - *
13 - * Fetches toolkit data via `client.toolkits.retrieve(slug)` and prints:
14 - * - latest available version
15 - * - last 20 available versions
16 - */
17 -export const toolkitsCmd$Version = Command.make('version', { slug }, ({ slug }) =>
18 - Effect.gen(function* () {
19 - const ui = yield* TerminalUI;
20 - const clientSingleton = yield* ComposioClientSingleton;
21 - const client = yield* clientSingleton.get();
22 -
23 - const toolkitOpt = yield* ui
24 - .withSpinner(
25 - `Fetching versions for toolkit "${slug}"...`,
26 - // Only the name, slug and version list are read, so a toolkit that
27 - // lacks other catalog fields still prints its versions.
28 - client.toolkits.retrieve(slug, undefined, idempotent)
29 - )
30 - .pipe(
31 - Effect.asSome,
32 - Effect.catch(error =>
33 - Effect.gen(function* () {
34 - const message =
35 - extractMessage(error) ?? `Failed to fetch version info for toolkit "${slug}".`;
36 - yield* ui.log.error(message);
37 - yield* Effect.logDebug('Toolkit version error:', error);
38 - yield* ui.log.step('Browse available toolkits:\n> composio dev toolkits list');
39 - return Option.none();
40 - })
41 - )
42 - );
43 -
44 - if (Option.isNone(toolkitOpt)) return;
45 -
46 - const toolkit = toolkitOpt.value as {
47 - slug: string;
48 - name: string;
49 - meta?: { available_versions?: ReadonlyArray<string> };
50 - };
51 - const availableVersions = toolkit.meta?.available_versions ?? [];
52 - const latestVersion = availableVersions.at(-1) ?? null;
53 - const recentVersions = availableVersions.slice(-20);
54 -
55 - const recentVersionLines =
56 - recentVersions.length > 0
57 - ? recentVersions.map(version => `- ${version}`).join('\n')
58 - : '- none';
59 -
60 - yield* ui.log.message(
61 - [
62 - `Toolkit: ${toolkit.name} (${toolkit.slug})`,
63 - `Latest Version: ${latestVersion ?? 'none'}`,
64 - `Last ${Math.min(20, recentVersions.length)} Available Versions:`,
65 - recentVersionLines,
66 - ].join('\n')
67 - );
68 -
69 - yield* ui.output(
70 - JSON.stringify(
71 - {
72 - slug: toolkit.slug,
73 - latest_version: latestVersion,
74 - available_versions_last_20: recentVersions,
75 - },
76 - null,
77 - 2
78 - )
79 - );
80 - })
81 -).pipe(Command.withDescription('Show latest and recent versions for a toolkit.'));
ts/packages/cli/src/commands/toolkits/list/toolkits.list.cmd.ts new
+37
@@ -0,0 +1,37 @@
1 +import { Command, Flag } from 'effect/cli';
2 +import { runToolkitsList } from './toolkits.list.handler';
3 +
4 +const query = Flag.String('query').pipe(
5 + Flag.withDescription('Text search by name, slug, or description'),
6 + Flag.optional
7 +);
8 +
9 +const limit = Flag.Int('limit').pipe(
10 + Flag.withDefault(30),
11 + Flag.withDescription('Number of results per page (1-1000)')
12 +);
13 +
14 +const connected = Flag.Boolean('connected').pipe(
15 + Flag.withDescription('Filter to connected toolkits only'),
16 + Flag.optional
17 +);
18 +
19 +/**
20 + * List available toolkits with connection status.
21 + *
22 + * @example
23 + * ```bash
24 + * composio dev toolkits list
25 + * composio dev toolkits list --query "email"
26 + * composio dev toolkits list --connected
27 + * composio dev toolkits list --user-id "alice"
28 + * ```
29 + */
30 +export const toolkitsCmd$List = Command.make(
31 + 'list',
32 + { query, limit, connected },
33 + runToolkitsList
34 +).pipe(
35 + Command.withDescription('List available toolkits with connection status.'),
36 + Command.withExamples([{ command: 'composio dev toolkits list' }])
37 +);
ts/packages/cli/src/commands/toolkits/list/toolkits.list.handler.ts new
+211
@@ -0,0 +1,211 @@
1 +import type { SessionToolkitsResponse } from '@composio/client/resources/tool-router';
2 +import { Array as Arr, Effect, Option } from 'effect';
3 +import { CommandSurface, directoryTestUserId, namedProject } from 'src/commands/surface';
4 +import { resolveToolRouterSession } from 'src/effects/create-tool-router-session';
5 +import { ComposioClientSingleton, ComposioToolkitsRepository } from 'src/services/composio-clients';
6 +import { idempotent } from 'src/services/composio-request';
7 +import { ProjectContext } from 'src/services/project-context';
8 +import { NodeProcess } from 'src/services/node-process';
9 +import { TerminalUI } from 'src/services/terminal-ui';
10 +import { ComposioUserContext } from 'src/services/user-context';
11 +import { clampLimit } from 'src/ui/clamp-limit';
12 +import { extractMessage } from 'src/utils/api-error-extraction';
13 +import {
14 + formatToolkitsJson,
15 + formatToolkitsTable,
16 + mergeToolkitData,
17 + type UnifiedToolkit,
18 +} from '../format';
19 +
20 +export type ToolkitsListParams = {
21 + readonly query: Option.Option<string>;
22 + readonly limit: number;
23 + readonly connected: Option.Option<boolean>;
24 +};
25 +
26 +type SessionToolkitItem = SessionToolkitsResponse.Item;
27 +
28 +/** The user whose connection status the list shows, and the notice printed when it is a fallback. */
29 +export type ToolkitsListUser = {
30 + readonly id: string;
31 + readonly fallbackNotice: Option.Option<string>;
32 +};
33 +
34 +/**
35 + * The `dev` group's `--user-id`, then the directory's test user id, then the global one.
36 + */
37 +export const resolveToolkitsListUser = (candidates: {
38 + readonly flag: Option.Option<string>;
39 + readonly projectTestUserId: Option.Option<string>;
40 + readonly globalTestUserId: Option.Option<string>;
41 +}): Option.Option<ToolkitsListUser> =>
42 + Option.firstSomeOf([
43 + Option.map(candidates.flag, id => ({ id, fallbackNotice: Option.none<string>() })),
44 + Option.map(candidates.projectTestUserId, id => ({
45 + id,
46 + fallbackNotice: Option.some(`Using test user id "${id}"`),
47 + })),
48 + Option.map(candidates.globalTestUserId, id => ({
49 + id,
50 + fallbackNotice: Option.some(`Using global test user id "${id}"`),
51 + })),
52 + ]);
53 +
54 +/**
55 + * Applies `--connected` to the merged rows. The filter needs the session's connection data; when a
56 + * user was resolved but the session returned nothing, the rows are kept and the filter is reported
57 + * as skipped.
58 + */
59 +export const applyConnectedFilter = (
60 + rows: ReadonlyArray<UnifiedToolkit>,
61 + params: {
62 + readonly connectedOnly: boolean;
63 + readonly sessionLoaded: boolean;
64 + readonly userResolved: boolean;
65 + }
66 +): { readonly rows: ReadonlyArray<UnifiedToolkit>; readonly filterSkipped: boolean } => {
67 + if (params.connectedOnly && params.sessionLoaded) {
68 + return { rows: rows.filter(row => row.connected?.status === 'ACTIVE'), filterSkipped: false };
69 + }
70 + return { rows, filterSkipped: params.connectedOnly && params.userResolved };
71 +};
72 +
73 +/**
74 + * Lists the toolkit catalog. When a user is known, the rows also carry that user's connection
75 + * status, read from a tool router session; a failed session read only drops the status.
76 + */
77 +export const runToolkitsList = ({ query, limit, connected }: ToolkitsListParams) =>
78 + Effect.gen(function* () {
79 + const { userId } = yield* CommandSurface;
80 + const ui = yield* TerminalUI;
81 + const repo = yield* ComposioToolkitsRepository;
82 + const clientSingleton = yield* ComposioClientSingleton;
83 + const projectContext = yield* ProjectContext;
84 + const userContext = yield* ComposioUserContext;
85 +
86 + const clampedLimit = clampLimit(limit);
87 + // Resolved outside the session lookup, whose failures only drop the connection status.
88 + const project = yield* namedProject;
89 + const resolvedProjectContext = yield* projectContext.resolve;
90 + const user = resolveToolkitsListUser({
91 + flag: userId,
92 + projectTestUserId: directoryTestUserId(
93 + resolvedProjectContext,
94 + Option.map(project, named => named.projectId)
95 + ),
96 + globalTestUserId: userContext.data.testUserId,
97 + });
98 +
99 + const fallbackNotice = Option.flatMap(user, resolved => resolved.fallbackNotice);
100 + if (Option.isSome(fallbackNotice)) {
101 + yield* ui.log.warn(fallbackNotice.value);
102 + yield* ui.log.message('To show status for a specific user, use `--user-id`.');
103 + }
104 +
105 + if (Option.isSome(connected) && Option.isNone(user)) {
106 + yield* ui.log.warn(
107 + '`--connected` requires a user id. Use `--user-id` or run `composio dev init`.'
108 + );
109 + }
110 +
111 + const catalogEffect = repo.searchToolkits({
112 + search: Option.getOrUndefined(query),
113 + limit: clampedLimit,
114 + });
115 +
116 + // The session is created alongside the catalog fetch (saves one round trip); its toolkits
117 + // call needs the session id, so it runs after.
118 + const sessionContextEffect = Option.match(user, {
119 + onNone: () => Effect.succeedNone,
120 + onSome: resolved =>
121 + Effect.gen(function* () {
122 + const client = yield* Option.match(project, {
123 + onSome: named => Effect.succeed(named.client),
124 + onNone: () => clientSingleton.get(),
125 + });
126 + const { sessionId } = yield* resolveToolRouterSession(client, resolved.id);
127 + return Option.some({ client, sessionId });
128 + }).pipe(
129 + Effect.catch(error =>
130 + Effect.logDebug('Failed to create session:', error).pipe(Effect.as(Option.none()))
131 + )
132 + ),
133 + });
134 +
135 + const [catalogResult, sessionContext] = yield* ui.withSpinner(
136 + 'Fetching toolkits...',
137 + Effect.all([catalogEffect, sessionContextEffect], { concurrency: 'unbounded' })
138 + );
139 +
140 + if (catalogResult.items.length === 0) {
141 + yield* ui.log.warn('No toolkits found. Try broadening your search.');
142 + yield* ui.output('[]');
143 + return;
144 + }
145 +
146 + // The session items only add connection status to the catalog rows, and a failed or empty
147 + // read is a silent fallback.
148 + const sessionItems = yield* Option.match(sessionContext, {
149 + onNone: () => Effect.succeedNone,
150 + onSome: ({ client, sessionId }) =>
151 + client.toolRouter.session
152 + .toolkits(
153 + sessionId,
154 + {
155 + search: Option.getOrUndefined(query),
156 + limit: clampedLimit,
157 + is_connected: Option.getOrUndefined(connected),
158 + },
159 + idempotent
160 + )
161 + .pipe(
162 + Effect.map(response => response.items),
163 + Effect.catch(error =>
164 + Effect.logDebug('Failed to fetch session toolkits:', error).pipe(
165 + Effect.as<ReadonlyArray<SessionToolkitItem>>([])
166 + )
167 + ),
168 + Effect.map(Option.liftPredicate(Arr.isReadonlyArrayNonEmpty))
169 + ),
170 + });
171 +
172 + const { rows, filterSkipped } = applyConnectedFilter(
173 + mergeToolkitData(catalogResult.items, Option.getOrUndefined(sessionItems)),
174 + {
175 + connectedOnly: Option.getOrElse(connected, () => false),
176 + sessionLoaded: Option.isSome(sessionItems),
177 + userResolved: Option.isSome(user),
178 + }
179 + );
180 + if (filterSkipped) {
181 + yield* ui.log.warn('`--connected` filter could not be applied — session data unavailable.');
182 + }
183 +
184 + if (rows.length === 0) {
185 + yield* ui.log.warn('No connected toolkits found. Try without --connected.');
186 + yield* ui.output('[]');
187 + return;
188 + }
189 +
190 + yield* ui.log.info(
191 + `Listing ${rows.length} of ${catalogResult.total_items} toolkits\n\n${formatToolkitsTable(rows)}`
192 + );
193 +
194 + const firstSlug = rows[0]?.slug;
195 + if (firstSlug) {
196 + yield* ui.log.step(
197 + `To view details of a toolkit:\n> composio dev toolkits info "${firstSlug}"`
198 + );
199 + }
200 + yield* ui.output(formatToolkitsJson(rows));
201 + }).pipe(
202 + Effect.catch(error =>
203 + Effect.gen(function* () {
204 + const ui = yield* TerminalUI;
205 + const proc = yield* NodeProcess;
206 + yield* ui.log.error(extractMessage(error) ?? 'An error occurred while fetching toolkits.');
207 + yield* ui.output('[]');
208 + yield* proc.setExitCode(1);
209 + })
210 + )
211 + );
ts/packages/cli/src/commands/toolkits/search/toolkits.search.cmd.ts new
+24
@@ -0,0 +1,24 @@
1 +import { Argument, Command, Flag } from 'effect/cli';
2 +import { runToolkitsSearch } from './toolkits.search.handler';
3 +
4 +const query = Argument.String('query').pipe(
5 + Argument.withDescription('Search query (e.g. "send emails")')
6 +);
7 +
8 +const limit = Flag.Int('limit').pipe(
9 + Flag.withDefault(10),
10 + Flag.withDescription('Number of results per page (1-1000)')
11 +);
12 +
13 +/**
14 + * Search toolkits by use case.
15 + *
16 + * @example
17 + * ```bash
18 + * composio dev toolkits search "send emails"
19 + * composio dev toolkits search "messaging" --limit 5
20 + * ```
21 + */
22 +export const toolkitsCmd$Search = Command.make('search', { query, limit }, runToolkitsSearch).pipe(
23 + Command.withDescription('Search toolkits by use case.')
24 +);
ts/packages/cli/src/commands/toolkits/search/toolkits.search.handler.ts new
+59
@@ -0,0 +1,59 @@
1 +import { Effect } from 'effect';
2 +import { ComposioToolkitsRepository } from 'src/services/composio-clients';
3 +import { NodeProcess } from 'src/services/node-process';
4 +import { TerminalUI } from 'src/services/terminal-ui';
5 +import { clampLimit } from 'src/ui/clamp-limit';
6 +import { extractMessage } from 'src/utils/api-error-extraction';
7 +import { formatToolkitsJson, formatToolkitsTable, mergeToolkitData } from '../format';
8 +
9 +export type ToolkitsSearchParams = {
10 + readonly query: string;
11 + readonly limit: number;
12 +};
13 +
14 +// TODO(tool-router-migration): migrate to Tool Router when the session toolkits endpoint
15 +// supports text search. Currently SessionToolsParams has no search capability.
16 +
17 +/**
18 + * Searches the toolkit catalog by use case. A failed search prints the error, writes `[]` to
19 + * stdout, and exits 1.
20 + */
21 +export const runToolkitsSearch = ({ query, limit }: ToolkitsSearchParams) =>
22 + Effect.gen(function* () {
23 + const ui = yield* TerminalUI;
24 + const repo = yield* ComposioToolkitsRepository;
25 +
26 + const result = yield* ui.withSpinner(
27 + `Searching toolkits for "${query}"...`,
28 + repo.searchToolkits({ search: query, limit: clampLimit(limit) })
29 + );
30 +
31 + if (result.items.length === 0) {
32 + yield* ui.log.warn(`No toolkits found matching "${query}". Try broadening your search.`);
33 + yield* ui.output('[]');
34 + return;
35 + }
36 +
37 + const rows = mergeToolkitData(result.items);
38 +
39 + yield* ui.log.info(
40 + `Found ${result.items.length} of ${result.total_items} toolkits\n\n${formatToolkitsTable(rows)}`
41 + );
42 +
43 + const firstSlug = rows[0]?.slug;
44 + if (firstSlug) {
45 + yield* ui.log.step(`To view details:\n> composio dev toolkits info "${firstSlug}"`);
46 + }
47 +
48 + yield* ui.output(formatToolkitsJson(rows));
49 + }).pipe(
50 + Effect.catch(error =>
51 + Effect.gen(function* () {
52 + const ui = yield* TerminalUI;
53 + const proc = yield* NodeProcess;
54 + yield* ui.log.error(extractMessage(error) ?? 'An error occurred while searching toolkits.');
55 + yield* ui.output('[]');
56 + yield* proc.setExitCode(1);
57 + })
58 + )
59 + );
ts/packages/cli/src/commands/toolkits/toolkits.cmd.ts
+3 -3
@@ -1,10 +1,10 @@
1 import { requireLogin } from 'src/effects/require-auth';
2 import { Command } from 'effect/cli';
3 import { rejectsSharedFlags } from 'src/commands/surface';
4 -import { toolkitsCmd$List } from './commands/toolkits.list.cmd';
4 +import { toolkitsCmd$List } from './list/toolkits.list.cmd';
5 import { toolkitsCmd$Info } from './info/toolkits.info.cmd';
6 -import { toolkitsCmd$Search } from './commands/toolkits.search.cmd';
7 -import { toolkitsCmd$Version } from './commands/toolkits.version.cmd';
6 +import { toolkitsCmd$Search } from './search/toolkits.search.cmd';
7 +import { toolkitsCmd$Version } from './version/toolkits.version.cmd';
8
9 /**
10 * CLI entry point for toolkit discovery commands.
ts/packages/cli/src/commands/toolkits/version/toolkits.version.cmd.ts new
+17
@@ -0,0 +1,17 @@
1 +import { Argument, Command } from 'effect/cli';
2 +import { runToolkitsVersion } from './toolkits.version.handler';
3 +
4 +const slug = Argument.String('slug').pipe(Argument.withDescription('Toolkit slug (e.g. "gmail")'));
5 +
6 +/**
7 + * Show toolkit version information: the latest available version and the last
8 + * 20 available versions.
9 + *
10 + * @example
11 + * ```bash
12 + * composio dev toolkits version "gmail"
13 + * ```
14 + */
15 +export const toolkitsCmd$Version = Command.make('version', { slug }, runToolkitsVersion).pipe(
16 + Command.withDescription('Show latest and recent versions for a toolkit.')
17 +);
ts/packages/cli/src/commands/toolkits/version/toolkits.version.format.ts new
+32
@@ -0,0 +1,32 @@
1 +/** The version history `toolkits version` prints. */
2 +export type ToolkitVersions = {
3 + readonly slug: string;
4 + readonly name: string;
5 + readonly latestVersion: string | null;
6 + readonly recentVersions: ReadonlyArray<string>;
7 +};
8 +
9 +// --- stderr -----------------------------------------------------------------------------------
10 +
11 +export const formatToolkitVersions = (versions: ToolkitVersions): string =>
12 + [
13 + `Toolkit: ${versions.name} (${versions.slug})`,
14 + `Latest Version: ${versions.latestVersion ?? 'none'}`,
15 + `Last ${versions.recentVersions.length} Available Versions:`,
16 + versions.recentVersions.length > 0
17 + ? versions.recentVersions.map(version => `- ${version}`).join('\n')
18 + : '- none',
19 + ].join('\n');
20 +
21 +// --- stdout -----------------------------------------------------------------------------------
22 +
23 +export const formatToolkitVersionsJson = (versions: ToolkitVersions): string =>
24 + JSON.stringify(
25 + {
26 + slug: versions.slug,
27 + latest_version: versions.latestVersion,
28 + available_versions_last_20: versions.recentVersions,
29 + },
30 + null,
31 + 2
32 + );
ts/packages/cli/src/commands/toolkits/version/toolkits.version.handler.ts new
+73
@@ -0,0 +1,73 @@
1 +import { Array as Arr, Effect, Option } from 'effect';
2 +import { ComposioClientSingleton } from 'src/services/composio-clients';
3 +import { idempotent } from 'src/services/composio-request';
4 +import { TerminalUI } from 'src/services/terminal-ui';
5 +import { extractMessage } from 'src/utils/api-error-extraction';
6 +import {
7 + formatToolkitVersions,
8 + formatToolkitVersionsJson,
9 + type ToolkitVersions,
10 +} from './toolkits.version.format';
11 +
12 +export type ToolkitsVersionParams = {
13 + readonly slug: string;
14 +};
15 +
16 +/** How many of the most recent versions the command prints. */
17 +export const RECENT_VERSIONS_LIMIT = 20;
18 +
19 +/**
20 + * The fields `toolkits version` reads. The response is not validated, so a toolkit that lacks
21 + * other catalog fields, or its version list, still prints.
22 + */
23 +export type VersionedToolkit = {
24 + readonly slug: string;
25 + readonly name: string;
26 + readonly meta?: { readonly available_versions?: ReadonlyArray<string> };
27 +};
28 +
29 +/** The latest version is the last one the API lists. */
30 +export const toolkitVersionsOf = (toolkit: VersionedToolkit): ToolkitVersions => {
31 + const availableVersions = toolkit.meta?.available_versions ?? [];
32 + return {
33 + slug: toolkit.slug,
34 + name: toolkit.name,
35 + latestVersion: Option.getOrNull(Arr.last(availableVersions)),
36 + recentVersions: availableVersions.slice(-RECENT_VERSIONS_LIMIT),
37 + };
38 +};
39 +
40 +/**
41 + * Shows a toolkit's latest version and its last 20 available versions. A failed lookup prints the
42 + * error and a browse hint and exits 0.
43 + */
44 +export const runToolkitsVersion = ({ slug }: ToolkitsVersionParams) =>
45 + Effect.gen(function* () {
46 + const ui = yield* TerminalUI;
47 + const clientSingleton = yield* ComposioClientSingleton;
48 + const client = yield* clientSingleton.get();
49 +
50 + const toolkitOpt = yield* ui
51 + .withSpinner(
52 + `Fetching versions for toolkit "${slug}"...`,
53 + client.toolkits.retrieve(slug, undefined, idempotent)
54 + )
55 + .pipe(
56 + Effect.map(toolkit => Option.some(toolkitVersionsOf(toolkit))),
57 + Effect.catch(error =>
58 + Effect.gen(function* () {
59 + yield* ui.log.error(
60 + extractMessage(error) ?? `Failed to fetch version info for toolkit "${slug}".`
61 + );
62 + yield* Effect.logDebug('Toolkit version error:', error);
63 + yield* ui.log.step('Browse available toolkits:\n> composio dev toolkits list');
64 + return Option.none<ToolkitVersions>();
65 + })
66 + )
67 + );
68 +
69 + if (Option.isNone(toolkitOpt)) return;
70 +
71 + yield* ui.log.message(formatToolkitVersions(toolkitOpt.value));
72 + yield* ui.output(formatToolkitVersionsJson(toolkitOpt.value));
73 + });
ts/packages/cli/test/src/commands/toolkits/list/toolkits.list.cmd.test.ts renamed
+161 -1
@@ -1,9 +1,13 @@
1 import { describe, expect, layer } from '@effect/vitest';
2 -import { ConfigProvider, DateTime, Effect } from 'effect';
2 +import { ConfigProvider, DateTime, Effect, Layer } from 'effect';
3 import { cli, TestLive, MockConsole } from 'test/__utils__';
4 import type { TestLiveInput } from 'test/__utils__/services/test-layer';
5 import type { Toolkits } from 'src/models/toolkits';
6 +import { ComposioToolkitsRepository } from 'src/services/composio-clients';
7 +import { notFoundError } from 'test/__utils__/layers/not-found';
8 +import { recordingNodeProcess } from 'test/__utils__/services/node-process-test';
9 import { routeRequests, stubClientResources } from 'test/__utils__/services/stub-composio-client';
10 +import { makeToolkitsRepositoryStub } from 'test/__utils__/services/toolkits-repository-stub';
11
12 const testToolkits: Toolkits = [
13 {
@@ -67,6 +71,45 @@ const testConfigProvider = ConfigProvider.fromEnv({
71 env: { COMPOSIO_USER_API_KEY: 'test_api_key' },
72 });
73
74 +const SESSION_TOOLKITS_PATH = '/api/v3.1/tool_router/session/trs_stub_session/toolkits';
75 +
76 +/** A tool router whose session toolkits call answers with `respondToolkits`. */
77 +const stubSessionToolkits = (respondToolkits: () => Response) =>
78 + stubClientResources(
79 + ['toolRouter'],
80 + routeRequests([{ method: 'GET', path: SESSION_TOOLKITS_PATH, respond: respondToolkits }], () =>
81 + Response.json({
82 + session_id: 'trs_stub_session',
83 + config: { user_id: 'global-default' },
84 + mcp: { type: 'http', url: 'https://mcp.stub.invalid' },
85 + tool_router_tools: [],
86 + })
87 + )
88 + );
89 +
90 +const sessionToolkit = (slug: string, name: string, status: string | null) => ({
91 + slug,
92 + name,
93 + meta: { description: '', logo: '' },
94 + is_no_auth: false,
95 + enabled: true,
96 + composio_managed_auth_schemes: ['OAUTH2'],
97 + connected_account:
98 + status === null
99 + ? null
100 + : {
101 + id: `ca_${slug}`,
102 + status,
103 + auth_config: { id: `ac_${slug}`, auth_scheme: 'OAUTH2', is_composio_managed: true },
104 + },
105 +});
106 +
107 +const forbidden = () =>
108 + Response.json(
109 + { error: { message: 'Not allowed', code: 1403, slug: 'Forbidden', status: 403 } },
110 + { status: 403 }
111 + );
112 +
113 describe('CLI: composio dev toolkits list', () => {
114 layer(TestLive({ baseConfigProvider: testConfigProvider, toolkitsData }))(
115 '[Given] no flags [Then] lists all toolkits with unified table',
@@ -216,6 +259,123 @@ describe('CLI: composio dev toolkits list', () => {
259 );
260 });
261
262 + layer(
263 + TestLive({
264 + baseConfigProvider: testConfigProvider,
265 + toolkitsData,
266 + fixture: 'global-test-user-id',
267 + })
268 + )('[Given] --connected and a session with one active connection', it => {
269 + it.effect('[Then] only the connected toolkit is listed', () =>
270 + Effect.gen(function* () {
271 + const stub = stubSessionToolkits(() =>
272 + Response.json({
273 + items: [
274 + sessionToolkit('gmail', 'Gmail', 'ACTIVE'),
275 + sessionToolkit('slack', 'Slack', 'EXPIRED'),
276 + sessionToolkit('github', 'GitHub', null),
277 + ],
278 + next_cursor: null,
279 + total_pages: 1,
280 + current_page: 1,
281 + total_items: 3,
282 + })
283 + );
284 + yield* cli(['dev', 'toolkits', 'list', '--connected']).pipe(Effect.provide(stub.layer));
285 + const stderr = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stderr' });
286 + const stdout = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stdout' });
287 +
288 + expect(stderr.join('\n')).toContain('Listing 1 of 3 toolkits');
289 + expect(stdout).toHaveLength(1);
290 + expect(JSON.parse(String(stdout[0]))).toEqual([
291 + expect.objectContaining({
292 + slug: 'gmail',
293 + connected: {
294 + status: 'ACTIVE',
295 + id: 'ca_gmail',
296 + auth_scheme: 'OAUTH2',
297 + is_composio_managed: true,
298 + },
299 + }),
300 + ]);
301 + expect(stub.requests.at(-1)?.path).toBe(
302 + `${SESSION_TOOLKITS_PATH}?limit=30&is_connected=true`
303 + );
304 + })
305 + );
306 + });
307 +
308 + layer(
309 + TestLive({
310 + baseConfigProvider: testConfigProvider,
311 + toolkitsData,
312 + fixture: 'global-test-user-id',
313 + })
314 + )('[Given] --connected and the API rejects the session toolkits', it => {
315 + it.effect('[Then] the filter is reported as skipped and every toolkit is listed', () =>
316 + Effect.gen(function* () {
317 + const stub = stubSessionToolkits(forbidden);
318 + yield* cli(['dev', 'toolkits', 'list', '--connected']).pipe(Effect.provide(stub.layer));
319 + const stderr = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stderr' });
320 + const stdout = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stdout' });
321 +
322 + expect(stderr).toContain(
323 + '`--connected` filter could not be applied — session data unavailable.'
324 + );
325 + expect(
326 + (JSON.parse(String(stdout.at(-1))) as Array<{ slug: string }>).map(row => row.slug)
327 + ).toEqual(['gmail', 'slack', 'github']);
328 + })
329 + );
330 + });
331 +
332 + layer(TestLive({ baseConfigProvider: testConfigProvider, toolkitsData }))(
333 + '[Given] --connected and no user id anywhere',
334 + it => {
335 + it.effect('[Then] warns that the filter needs a user id and lists the catalog', () =>
336 + Effect.gen(function* () {
337 + yield* cli(['dev', 'toolkits', 'list', '--connected']);
338 + const stderr = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stderr' });
339 + const stdout = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stdout' });
340 +
341 + expect(stderr[0]).toBe(
342 + '`--connected` requires a user id. Use `--user-id` or run `composio dev init`.'
343 + );
344 + expect(stderr.join('\n')).toContain('Listing 3 of 3 toolkits');
345 + expect(
346 + (JSON.parse(String(stdout.at(-1))) as Array<{ slug: string }>).map(row => row.slug)
347 + ).toEqual(['gmail', 'slack', 'github']);
348 + })
349 + );
350 + }
351 + );
352 +
353 + layer(TestLive({ baseConfigProvider: testConfigProvider, toolkitsData }))(
354 + '[Given] the catalog request fails',
355 + it => {
356 + it.effect('[Then] prints the error, writes `[]` to stdout and exits 1', () =>
357 + Effect.gen(function* () {
358 + const proc = recordingNodeProcess();
359 + const repository = Layer.succeed(
360 + ComposioToolkitsRepository,
361 + makeToolkitsRepositoryStub({
362 + searchToolkits: () => Effect.fail(notFoundError('Catalog unavailable')),
363 + })
364 + );
365 + yield* cli(['dev', 'toolkits', 'list']).pipe(
366 + Effect.provide(Layer.merge(repository, proc.layer))
367 + );
368 + const stderr = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stderr' });
369 + const stdout = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stdout' });
370 +
371 + expect(stderr).toContain('Catalog unavailable');
372 + expect(stdout).toEqual(['[]']);
373 + expect(proc.exitCode()).toBe(1);
374 + })
375 + );
376 + }
377 + );
378 +
379 layer(TestLive())('[Given] no API key', it => {
380 it.effect('warns user to login', () =>
381 Effect.gen(function* () {
ts/packages/cli/test/src/commands/toolkits/list/toolkits.list.handler.test.ts new
+104
@@ -0,0 +1,104 @@
1 +import { describe, expect, it } from 'vitest';
2 +import { Option } from 'effect';
3 +import type { UnifiedToolkit } from 'src/commands/toolkits/format';
4 +import {
5 + applyConnectedFilter,
6 + resolveToolkitsListUser,
7 +} from 'src/commands/toolkits/list/toolkits.list.handler';
8 +
9 +describe('toolkits list handler: resolveToolkitsListUser', () => {
10 + // `--user-id` wins, then the directory's test user, then the global one; only a fallback is announced.
11 + it.each([
12 + {
13 + name: '--user-id and both test users',
14 + flag: Option.some('alice'),
15 + projectTestUserId: Option.some('project-user'),
16 + globalTestUserId: Option.some('global-user'),
17 + expected: Option.some({ id: 'alice', fallbackNotice: Option.none() }),
18 + },
19 + {
20 + name: 'the directory and the global test user',
21 + flag: Option.none(),
22 + projectTestUserId: Option.some('project-user'),
23 + globalTestUserId: Option.some('global-user'),
24 + expected: Option.some({
25 + id: 'project-user',
26 + fallbackNotice: Option.some('Using test user id "project-user"'),
27 + }),
28 + },
29 + {
30 + name: 'only the global test user',
31 + flag: Option.none(),
32 + projectTestUserId: Option.none(),
33 + globalTestUserId: Option.some('global-user'),
34 + expected: Option.some({
35 + id: 'global-user',
36 + fallbackNotice: Option.some('Using global test user id "global-user"'),
37 + }),
38 + },
39 + {
40 + name: 'no user anywhere',
41 + flag: Option.none(),
42 + projectTestUserId: Option.none(),
43 + globalTestUserId: Option.none(),
44 + expected: Option.none(),
45 + },
46 + ])(
47 + '[Given] $name [Then] resolves the expected user',
48 + ({ name: _name, expected, ...candidates }) => {
49 + expect(resolveToolkitsListUser(candidates)).toEqual(expected);
50 + }
51 + );
52 +});
53 +
54 +const row = (slug: string, status: string | null): UnifiedToolkit => ({
55 + name: slug,
56 + slug,
57 + description: '',
58 + latest_version: null,
59 + tools_count: 0,
60 + triggers_count: 0,
61 + is_no_auth: false,
62 + enabled: status === null ? null : true,
63 + connected:
64 + status === null
65 + ? null
66 + : { status, id: `ca_${slug}`, auth_scheme: 'OAUTH2', is_composio_managed: true },
67 +});
68 +
69 +const rows = [row('gmail', 'ACTIVE'), row('slack', 'EXPIRED'), row('github', null)];
70 +
71 +describe('toolkits list handler: applyConnectedFilter', () => {
72 + it.each([
73 + {
74 + name: '--connected with session data',
75 + params: { connectedOnly: true, sessionLoaded: true, userResolved: true },
76 + slugs: ['gmail'],
77 + filterSkipped: false,
78 + },
79 + {
80 + name: '--connected, a user, and no session data',
81 + params: { connectedOnly: true, sessionLoaded: false, userResolved: true },
82 + slugs: ['gmail', 'slack', 'github'],
83 + filterSkipped: true,
84 + },
85 + {
86 + // Already warned about: `--connected` needs a user id.
87 + name: '--connected and no user',
88 + params: { connectedOnly: true, sessionLoaded: false, userResolved: false },
89 + slugs: ['gmail', 'slack', 'github'],
90 + filterSkipped: false,
91 + },
92 + {
93 + name: 'no --connected',
94 + params: { connectedOnly: false, sessionLoaded: true, userResolved: true },
95 + slugs: ['gmail', 'slack', 'github'],
96 + filterSkipped: false,
97 + },
98 + ])('[Given] $name [Then] keeps $slugs', ({ params, slugs, filterSkipped }) => {
99 + const result = applyConnectedFilter(rows, params);
100 +
101 + expect(result.rows.map(r => r.slug)).toEqual(slugs);
102 + expect(result.filterSkipped).toBe(filterSkipped);
103 + });
104 +});
ts/packages/cli/test/src/commands/toolkits/search/toolkits.search.cmd.test.ts renamed
+53 -1
@@ -1,8 +1,12 @@
1 import { describe, expect, layer } from '@effect/vitest';
2 -import { ConfigProvider, DateTime, Effect } from 'effect';
2 +import { ConfigProvider, DateTime, Effect, Layer } from 'effect';
3 import { cli, TestLive, MockConsole } from 'test/__utils__';
4 import type { TestLiveInput } from 'test/__utils__/services/test-layer';
5 import type { Toolkits } from 'src/models/toolkits';
6 +import { ComposioToolkitsRepository } from 'src/services/composio-clients';
7 +import { notFoundError } from 'test/__utils__/layers/not-found';
8 +import { recordingNodeProcess } from 'test/__utils__/services/node-process-test';
9 +import { makeToolkitsRepositoryStub } from 'test/__utils__/services/toolkits-repository-stub';
10
11 const testToolkits: Toolkits = [
12 {
@@ -115,6 +119,54 @@ describe('CLI: composio dev toolkits search', () => {
119 }
120 );
121
122 + layer(TestLive({ baseConfigProvider: testConfigProvider, toolkitsData }))(
123 + '[Given] query "email" and --limit 0 [Then] the limit is clamped to 1',
124 + it => {
125 + it.effect('requests one toolkit and writes the rows as JSON to stdout', () =>
126 + Effect.gen(function* () {
127 + yield* cli(['dev', 'toolkits', 'search', 'email', '--limit', '0']);
128 + const stderr = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stderr' });
129 + const stdout = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stdout' });
130 +
131 + expect(stderr.join('\n')).toContain('Found 1 of 2 toolkits');
132 + expect(stderr.join('\n')).toContain(
133 + 'To view details:\n> composio dev toolkits info "gmail"'
134 + );
135 + expect(stdout).toHaveLength(1);
136 + expect(JSON.parse(String(stdout[0]))).toEqual([
137 + expect.objectContaining({ slug: 'gmail', latest_version: '20250909', connected: null }),
138 + ]);
139 + })
140 + );
141 + }
142 + );
143 +
144 + layer(TestLive({ baseConfigProvider: testConfigProvider, toolkitsData }))(
145 + '[Given] the search request fails',
146 + it => {
147 + it.effect('[Then] prints the error, writes `[]` to stdout and exits 1', () =>
148 + Effect.gen(function* () {
149 + const proc = recordingNodeProcess();
150 + const repository = Layer.succeed(
151 + ComposioToolkitsRepository,
152 + makeToolkitsRepositoryStub({
153 + searchToolkits: () => Effect.fail(notFoundError('Search unavailable')),
154 + })
155 + );
156 + yield* cli(['dev', 'toolkits', 'search', 'email']).pipe(
157 + Effect.provide(Layer.merge(repository, proc.layer))
158 + );
159 + const stderr = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stderr' });
160 + const stdout = yield* MockConsole.getLines({ stripAnsi: true, stream: 'stdout' });
161 +
162 + expect(stderr).toContain('Search unavailable');
163 + expect(stdout).toEqual(['[]']);
164 + expect(proc.exitCode()).toBe(1);
165 + })
166 + );
167 + }
168 + );
169 +
170 layer(TestLive())('[Given] no API key', it => {
171 it.effect('warns user to login', () =>
172 Effect.gen(function* () {
ts/packages/cli/test/src/commands/toolkits/version/toolkits.version.client.cmd.test.ts renamed
ts/packages/cli/test/src/commands/toolkits/version/toolkits.version.cmd.test.ts renamed
ts/packages/cli/test/src/commands/toolkits/version/toolkits.version.handler.test.ts new
+57
@@ -0,0 +1,57 @@
1 +import { describe, expect, it } from 'vitest';
2 +import {
3 + formatToolkitVersions,
4 + formatToolkitVersionsJson,
5 +} from 'src/commands/toolkits/version/toolkits.version.format';
6 +import { toolkitVersionsOf } from 'src/commands/toolkits/version/toolkits.version.handler';
7 +
8 +const history = (count: number) =>
9 + Array.from({ length: count }, (_, index) => `20260101_${String(index + 1).padStart(2, '0')}`);
10 +
11 +describe('toolkits version handler: toolkitVersionsOf', () => {
12 + // The latest version is the last listed one; at most the last 20 are kept.
13 + it.each([
14 + {
15 + name: '25 versions',
16 + meta: { available_versions: history(25) },
17 + latestVersion: '20260101_25',
18 + recentVersions: history(25).slice(-20),
19 + },
20 + {
21 + name: 'two versions',
22 + meta: { available_versions: ['20260101_00', '20260201_00'] },
23 + latestVersion: '20260201_00',
24 + recentVersions: ['20260101_00', '20260201_00'],
25 + },
26 + {
27 + name: 'an empty version list',
28 + meta: { available_versions: [] },
29 + latestVersion: null,
30 + recentVersions: [],
31 + },
32 + { name: 'no version list', meta: {}, latestVersion: null, recentVersions: [] },
33 + { name: 'no meta', meta: undefined, latestVersion: null, recentVersions: [] },
34 + ])('[Given] $name [Then] latest is $latestVersion', ({ meta, latestVersion, recentVersions }) => {
35 + expect(toolkitVersionsOf({ slug: 'gmail', name: 'Gmail', meta })).toEqual({
36 + slug: 'gmail',
37 + name: 'Gmail',
38 + latestVersion,
39 + recentVersions,
40 + });
41 + });
42 +});
43 +
44 +describe('toolkits version format', () => {
45 + it('[Given] no versions [Then] both renderers say so', () => {
46 + const versions = toolkitVersionsOf({ slug: 'gmail', name: 'Gmail' });
47 +
48 + expect(formatToolkitVersions(versions)).toBe(
49 + 'Toolkit: Gmail (gmail)\nLatest Version: none\nLast 0 Available Versions:\n- none'
50 + );
51 + expect(JSON.parse(formatToolkitVersionsJson(versions))).toEqual({
52 + slug: 'gmail',
53 + latest_version: null,
54 + available_versions_last_20: [],
55 + });
56 + });
57 +});