1
import { isAPIError } from '@composio/client/effect';
2
-import { Data, Effect, Option } from 'effect';
2
+import { Data, Effect, Option, Predicate, Result } from 'effect';
3
import { ExpectedFailure } from 'src/effects/expected-failure';
4
import { extractMessage } from 'src/utils/api-error-extraction';
5
import { ProjectContext } from './project-context';
9
findDeveloperProjectByName,
10
DeveloperProjectNotFoundError,
11
AmbiguousDeveloperProjectNameError,
12
+ getSessionInfoByUserApiKey,
13
} from './composio-account';
14
15
export type ProjectMode = 'consumer' | 'developer';
17
export type CliProjectType = 'CONSUMER' | 'DEVELOPER';
18
19
export type CliProjectResolutionSource =
19
- 'consumer-default' | 'developer-project-name' | 'developer-local-config' | 'developer-explicit';
20
+ | 'consumer-default'
21
+ | 'developer-project-name'
22
+ | 'developer-local-config'
23
+ | 'developer-explicit'
24
+ | 'developer-default';
25
26
export interface ResolvedCommandProject {
27
readonly orgId: string;
80
: new ProjectResolutionError({ reason: 'request_failed', message: apiMessage, cause: error });
81
};
82
83
+/** Why the working directory's developer project cannot serve a command. */
84
+type DirectoryProjectRefusal = { readonly reason: 'missing_developer_project' };
85
+
86
+const refusalError = (_refusal: DirectoryProjectRefusal): ProjectResolutionError =>
87
+ new ProjectResolutionError({
88
+ reason: 'missing_developer_project',
89
+ message: 'No developer project configured for this directory. Run `composio dev init`.',
90
+ });
91
+
92
+/** The developer project configured for the working directory. */
93
+const localDeveloperProject = (params: {
94
+ projectContext: ProjectContext['Service'];
95
+ apiKey: string;
96
+ storedOrgId: Option.Option<string>;
97
+}) =>
98
+ Effect.gen(function* () {
99
+ const localProject = yield* params.projectContext.resolve;
100
+ if (Option.isNone(localProject)) {
101
+ return Result.fail<DirectoryProjectRefusal>({ reason: 'missing_developer_project' });
102
+ }
103
+ const { orgId, projectId, projectName } = localProject.value;
104
+ return Result.succeed({
105
+ orgId,
106
+ projectId,
107
+ projectName: Option.getOrUndefined(projectName),
108
+ projectType: 'DEVELOPER',
109
+ source: 'developer-local-config',
110
+ } satisfies ResolvedCommandProject);
111
+ });
112
+
113
+/** The directory's developer project; fails with `ProjectResolutionError` when it cannot be used. */
114
+const resolveLocalDeveloperProject = (params: Parameters<typeof localDeveloperProject>[0]) =>
115
+ localDeveloperProject(params).pipe(
116
+ Effect.flatMap(result => Effect.fromResult(Result.mapError(result, refusalError)))
117
+ );
118
+
119
+/** What is wrong with the directory's developer project, as the start of a sentence. */
120
+const refusalSummary = (_refusal: DirectoryProjectRefusal): string =>
121
+ 'No developer project is set up for this directory';
122
+
123
+/** The command that lets the directory's developer project serve the next run. */
124
+const refusalRemedy = (_refusal: DirectoryProjectRefusal): string =>
125
+ 'Run `composio dev init` to choose one, or pass --project-name.';
126
+
127
+/** The stderr notice naming the default developer project a command uses instead. */
128
+const defaultProjectNotice = (
129
+ refusal: DirectoryProjectRefusal,
130
+ project: ResolvedCommandProject,
131
+ storedOrgId: Option.Option<string>
132
+): string => {
133
+ const which = Option.isSome(storedOrgId)
134
+ ? 'the newest developer project in the org you are logged in to'
135
+ : 'the newest developer project in the org you joined most recently';
136
+ return `${refusalSummary(refusal)}; using "${project.projectName}" (${project.projectId}), ${which}, instead. ${refusalRemedy(refusal)}`;
137
+};
138
+
139
+/**
140
+ * The developer project the backend acts on for a user-key request that names none: the newest
141
+ * developer project of the stored org (sent as `x-org-id`, so `composio orgs switch` holds), or
142
+ * without one, of the org the user joined most recently. Read once from session info, so every
143
+ * request of the command names this one project even if another becomes the newest meanwhile.
144
+ * Session info without a project, or a 404, means there is no such project. Other request
145
+ * failures keep their cause and message instead of recommending project setup.
146
+ */
147
+const defaultDeveloperProject = (params: {
148
+ apiKey: string;
149
+ storedOrgId: Option.Option<string>;
150
+ refusal: DirectoryProjectRefusal;
151
+}) =>
152
+ getSessionInfoByUserApiKey({
153
+ userApiKey: params.apiKey,
154
+ orgId: Option.getOrUndefined(params.storedOrgId),
155
+ }).pipe(
156
+ Effect.map(
157
+ info =>
158
+ ({
159
+ orgId: info.project.org.id,
160
+ projectId: info.project.nano_id,
161
+ projectName: info.project.name,
162
+ projectType: 'DEVELOPER',
163
+ source: 'developer-default',
164
+ }) satisfies ResolvedCommandProject
165
+ ),
166
+ Effect.mapError(error =>
167
+ (isAPIError(error) && error.status === 404) ||
168
+ Predicate.isTagged(error, 'services/HttpDecodingError')
169
+ ? new ProjectResolutionError({
170
+ reason: 'missing_developer_project',
171
+ message: `${refusalSummary(params.refusal)}, and no developer project was found in your org to use instead. Run \`composio dev init\` to set one up.`,
172
+ cause: error,
173
+ })
174
+ : error
175
+ )
176
+ );
177
+
178
export const resolveCommandProject = (params: { mode: ProjectMode; projectName?: string }) =>
179
Effect.gen(function* () {
180
const ctx = yield* ComposioUserContext;
181
const projectContext = yield* ProjectContext;
182
const apiKey = Option.getOrUndefined(ctx.data.apiKey);
83
- const currentOrgId = yield* Option.match(ctx.data.orgId, {
84
- onNone: () => Effect.fail(missingOrg()),
85
- onSome: value => Effect.succeed(value),
86
- });
87
-
183
if (!apiKey) {
184
return yield* Effect.fail(missingOrg());
185
}
186
92
- if (params.mode === 'consumer') {
93
- if (params.projectName) {
94
- const developerProject = yield* findDeveloperProjectByName({
95
- apiKey,
96
- orgId: currentOrgId,
97
- name: params.projectName,
98
- });
99
-
100
- return {
101
- orgId: currentOrgId,
102
- projectId: developerProject.id,
103
- projectName: developerProject.name,
104
- projectType: 'DEVELOPER',
105
- source: 'developer-project-name',
106
- } satisfies ResolvedCommandProject;
107
- }
108
-
109
- const consumerProject = yield* resolveConsumerProject({
187
+ // The directory's own project needs no stored org: a key from `COMPOSIO_USER_API_KEY`
188
+ // carries none, and the project file names its org.
189
+ if (params.mode === 'developer' && !params.projectName) {
190
+ return yield* resolveLocalDeveloperProject({
191
+ projectContext,
192
apiKey,
111
- orgId: currentOrgId,
193
+ storedOrgId: ctx.data.orgId,
194
});
113
-
114
- return {
115
- orgId: consumerProject.org_id,
116
- projectId: consumerProject.project_nano_id,
117
- projectName: consumerProject.project_name,
118
- projectType: 'CONSUMER',
119
- consumerUserId: consumerProject.consumer_user_id,
120
- source: 'consumer-default',
121
- } satisfies ResolvedCommandProject;
195
}
196
197
+ const currentOrgId = yield* Option.match(ctx.data.orgId, {
198
+ onNone: () => Effect.fail(missingOrg()),
199
+ onSome: value => Effect.succeed(value),
200
+ });
201
+
202
if (params.projectName) {
203
const developerProject = yield* findDeveloperProjectByName({
204
apiKey,
211
projectId: developerProject.id,
212
projectName: developerProject.name,
213
projectType: 'DEVELOPER',
136
- source: 'developer-explicit',
214
+ source: params.mode === 'consumer' ? 'developer-project-name' : 'developer-explicit',
215
} satisfies ResolvedCommandProject;
216
}
217
140
- const localProject = yield* projectContext.resolve;
141
- if (Option.isNone(localProject)) {
142
- return yield* Effect.fail(
143
- new ProjectResolutionError({
144
- reason: 'missing_developer_project',
145
- message: 'No developer project configured for this directory. Run `composio dev init`.',
146
- })
147
- );
148
- }
218
+ const consumerProject = yield* resolveConsumerProject({
219
+ apiKey,
220
+ orgId: currentOrgId,
221
+ });
222
223
return {
151
- orgId: localProject.value.orgId,
152
- projectId: localProject.value.projectId,
153
- projectName: Option.getOrUndefined(localProject.value.projectName),
154
- projectType: 'DEVELOPER',
155
- source: 'developer-local-config',
224
+ orgId: consumerProject.org_id,
225
+ projectId: consumerProject.project_nano_id,
226
+ projectName: consumerProject.project_name,
227
+ projectType: 'CONSUMER',
228
+ consumerUserId: consumerProject.consumer_user_id,
229
+ source: 'consumer-default',
230
} satisfies ResolvedCommandProject;
231
}).pipe(Effect.mapError(normalizeLookupError));
232
+
233
+/**
234
+ * The developer project for a dev command that acted on the backend's default project before
235
+ * it named one, so a directory without a usable project of its own keeps working: `--project-name`'s
236
+ * (whose failures stay failures), else the directory's, else the backend's default developer
237
+ * project (`defaultDeveloperProject`). `notice` says, for stderr, why the default stands in and
238
+ * which project it is; it is none when the command uses the project it was given. The default
239
+ * never stands in for a `--project-name` that cannot be resolved.
240
+ */
241
+export const resolveDeveloperProjectOrDefault = (params: { projectName?: string }) =>
242
+ Effect.gen(function* () {
243
+ if (params.projectName) {
244
+ const project = yield* resolveCommandProject({
245
+ mode: 'developer',
246
+ projectName: params.projectName,
247
+ });
248
+ return { project, notice: Option.none<string>() };
249
+ }
250
+ const ctx = yield* ComposioUserContext;
251
+ const projectContext = yield* ProjectContext;
252
+ const apiKey = Option.getOrUndefined(ctx.data.apiKey);
253
+ if (!apiKey) {
254
+ return yield* Effect.fail(missingOrg());
255
+ }
256
+ const storedOrgId = ctx.data.orgId;
257
+ const local = yield* localDeveloperProject({ projectContext, apiKey, storedOrgId });
258
+ return yield* Result.match(local, {
259
+ onSuccess: project => Effect.succeed({ project, notice: Option.none<string>() }),
260
+ onFailure: refusal =>
261
+ Effect.map(defaultDeveloperProject({ apiKey, storedOrgId, refusal }), project => ({
262
+ project,
263
+ notice: Option.some(defaultProjectNotice(refusal, project, storedOrgId)),
264
+ })),
265
+ });
266
+ }).pipe(Effect.mapError(normalizeLookupError));