@elnora-ai/cli 2.2.1 → 2.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cli.js +409 -305
- package/package.json +2 -2
package/dist/cli.js
CHANGED
|
@@ -30,7 +30,7 @@ var VERSION, PRODUCTION_BASE_URL, BASE_URL, AI_SERVER_URL, PRODUCTION_MCP_URL, M
|
|
|
30
30
|
var init_config = __esm({
|
|
31
31
|
"src/lib/config.ts"() {
|
|
32
32
|
"use strict";
|
|
33
|
-
VERSION = true ? "2.
|
|
33
|
+
VERSION = true ? "2.3.0" : process.env.npm_package_version ?? "0.0.0-dev";
|
|
34
34
|
PRODUCTION_BASE_URL = "https://platform.elnora.ai/api/v1";
|
|
35
35
|
BASE_URL = process.env.ELNORA_API_URL ?? PRODUCTION_BASE_URL;
|
|
36
36
|
AI_SERVER_URL = process.env.ELNORA_AI_SERVER_URL ?? "https://platform.elnora.ai/ai-server";
|
|
@@ -66,10 +66,14 @@ var init_config = __esm({
|
|
|
66
66
|
file_working_copy: "/files/{id}/working-copy",
|
|
67
67
|
file_commit: "/files/{id}/commit",
|
|
68
68
|
file_upload_batch: "/files/upload/batch",
|
|
69
|
-
// Folders
|
|
69
|
+
// Folders (closure-table Knowledge Base — the `folder`/`folder_move` paths are shared with the
|
|
70
|
+
// legacy controller; the KB read/mutation verbs are distinguished by HTTP method at the call site)
|
|
70
71
|
folder: "/folders/{id}",
|
|
71
72
|
folder_move: "/folders/{id}/move",
|
|
72
73
|
folders_files: "/folders/files",
|
|
74
|
+
folder_roots: "/folders/roots",
|
|
75
|
+
folder_children: "/folders/{id}/children",
|
|
76
|
+
folder_files: "/folders/{id}/files",
|
|
73
77
|
// Organizations
|
|
74
78
|
organizations: "/organizations",
|
|
75
79
|
organization: "/organizations/{id}",
|
|
@@ -4149,19 +4153,42 @@ function registerFlagCommands() {
|
|
|
4149
4153
|
return [flagsList, flagsGet, flagsSet];
|
|
4150
4154
|
}
|
|
4151
4155
|
|
|
4152
|
-
// src/commands/folders/
|
|
4156
|
+
// src/commands/folders/children.ts
|
|
4153
4157
|
import { z as z46 } from "zod";
|
|
4154
4158
|
var inputSchema44 = z46.object({
|
|
4155
|
-
|
|
4156
|
-
|
|
4157
|
-
|
|
4159
|
+
folderId: z46.string().uuid().describe("Folder ID")
|
|
4160
|
+
});
|
|
4161
|
+
var foldersChildren = {
|
|
4162
|
+
name: "folders.children",
|
|
4163
|
+
group: "folders",
|
|
4164
|
+
description: "List the child folders of a Knowledge Base folder",
|
|
4165
|
+
inputSchema: inputSchema44,
|
|
4166
|
+
outputSchema: z46.any(),
|
|
4167
|
+
annotations: { readOnlyHint: true },
|
|
4168
|
+
async execute(input, ctx) {
|
|
4169
|
+
return ctx.client.get("folder_children", {
|
|
4170
|
+
pathParams: { id: input.folderId }
|
|
4171
|
+
});
|
|
4172
|
+
},
|
|
4173
|
+
formatOutput(output, format) {
|
|
4174
|
+
if (format === "compact") return output.id ?? JSON.stringify(output);
|
|
4175
|
+
return JSON.stringify(output, null, 2);
|
|
4176
|
+
}
|
|
4177
|
+
};
|
|
4178
|
+
|
|
4179
|
+
// src/commands/folders/create.ts
|
|
4180
|
+
import { z as z47 } from "zod";
|
|
4181
|
+
var inputSchema45 = z47.object({
|
|
4182
|
+
projectId: z47.string().uuid().describe("Project ID"),
|
|
4183
|
+
name: z47.string().min(1).describe("Folder name"),
|
|
4184
|
+
parentId: z47.string().uuid().optional().describe("Parent folder ID")
|
|
4158
4185
|
});
|
|
4159
4186
|
var foldersCreate = {
|
|
4160
4187
|
name: "folders.create",
|
|
4161
4188
|
group: "folders",
|
|
4162
4189
|
description: "Create a new folder in a project",
|
|
4163
|
-
inputSchema:
|
|
4164
|
-
outputSchema:
|
|
4190
|
+
inputSchema: inputSchema45,
|
|
4191
|
+
outputSchema: z47.any(),
|
|
4165
4192
|
async execute(input, ctx) {
|
|
4166
4193
|
const body = { name: input.name };
|
|
4167
4194
|
if (input.parentId) body.parentId = input.parentId;
|
|
@@ -4176,16 +4203,16 @@ var foldersCreate = {
|
|
|
4176
4203
|
};
|
|
4177
4204
|
|
|
4178
4205
|
// src/commands/folders/delete.ts
|
|
4179
|
-
import { z as
|
|
4180
|
-
var
|
|
4181
|
-
folderId:
|
|
4206
|
+
import { z as z48 } from "zod";
|
|
4207
|
+
var inputSchema46 = z48.object({
|
|
4208
|
+
folderId: z48.string().uuid().describe("Folder ID to delete")
|
|
4182
4209
|
});
|
|
4183
4210
|
var foldersDelete = {
|
|
4184
4211
|
name: "folders.delete",
|
|
4185
4212
|
group: "folders",
|
|
4186
4213
|
description: "Delete a folder",
|
|
4187
|
-
inputSchema:
|
|
4188
|
-
outputSchema:
|
|
4214
|
+
inputSchema: inputSchema46,
|
|
4215
|
+
outputSchema: z48.any(),
|
|
4189
4216
|
annotations: { destructiveHint: true },
|
|
4190
4217
|
async execute(input, ctx) {
|
|
4191
4218
|
await ctx.client.del("folder", {
|
|
@@ -4199,17 +4226,65 @@ var foldersDelete = {
|
|
|
4199
4226
|
}
|
|
4200
4227
|
};
|
|
4201
4228
|
|
|
4229
|
+
// src/commands/folders/files.ts
|
|
4230
|
+
import { z as z49 } from "zod";
|
|
4231
|
+
var inputSchema47 = z49.object({
|
|
4232
|
+
folderId: z49.string().uuid().describe("Folder ID"),
|
|
4233
|
+
...paginationInput
|
|
4234
|
+
});
|
|
4235
|
+
var foldersFiles = {
|
|
4236
|
+
name: "folders.files",
|
|
4237
|
+
group: "folders",
|
|
4238
|
+
description: "List files placed directly in a Knowledge Base folder",
|
|
4239
|
+
inputSchema: inputSchema47,
|
|
4240
|
+
outputSchema: z49.any(),
|
|
4241
|
+
annotations: { readOnlyHint: true },
|
|
4242
|
+
async execute(input, ctx) {
|
|
4243
|
+
return ctx.client.get("folder_files", {
|
|
4244
|
+
pathParams: { id: input.folderId },
|
|
4245
|
+
queryParams: { page: input.page, pageSize: input.pageSize }
|
|
4246
|
+
});
|
|
4247
|
+
},
|
|
4248
|
+
formatOutput(output, format) {
|
|
4249
|
+
if (format === "compact") return output.id ?? JSON.stringify(output);
|
|
4250
|
+
return JSON.stringify(output, null, 2);
|
|
4251
|
+
}
|
|
4252
|
+
};
|
|
4253
|
+
|
|
4254
|
+
// src/commands/folders/get.ts
|
|
4255
|
+
import { z as z50 } from "zod";
|
|
4256
|
+
var inputSchema48 = z50.object({
|
|
4257
|
+
folderId: z50.string().uuid().describe("Folder ID")
|
|
4258
|
+
});
|
|
4259
|
+
var foldersGet = {
|
|
4260
|
+
name: "folders.get",
|
|
4261
|
+
group: "folders",
|
|
4262
|
+
description: "Get a Knowledge Base folder's details and breadcrumb path",
|
|
4263
|
+
inputSchema: inputSchema48,
|
|
4264
|
+
outputSchema: z50.any(),
|
|
4265
|
+
annotations: { readOnlyHint: true },
|
|
4266
|
+
async execute(input, ctx) {
|
|
4267
|
+
return ctx.client.get("folder", {
|
|
4268
|
+
pathParams: { id: input.folderId }
|
|
4269
|
+
});
|
|
4270
|
+
},
|
|
4271
|
+
formatOutput(output, format) {
|
|
4272
|
+
if (format === "compact") return output.id ?? JSON.stringify(output);
|
|
4273
|
+
return JSON.stringify(output, null, 2);
|
|
4274
|
+
}
|
|
4275
|
+
};
|
|
4276
|
+
|
|
4202
4277
|
// src/commands/folders/list.ts
|
|
4203
|
-
import { z as
|
|
4204
|
-
var
|
|
4205
|
-
projectId:
|
|
4278
|
+
import { z as z51 } from "zod";
|
|
4279
|
+
var inputSchema49 = z51.object({
|
|
4280
|
+
projectId: z51.string().uuid().describe("Project ID")
|
|
4206
4281
|
});
|
|
4207
4282
|
var foldersList = {
|
|
4208
4283
|
name: "folders.list",
|
|
4209
4284
|
group: "folders",
|
|
4210
4285
|
description: "List folders in a project",
|
|
4211
|
-
inputSchema:
|
|
4212
|
-
outputSchema:
|
|
4286
|
+
inputSchema: inputSchema49,
|
|
4287
|
+
outputSchema: z51.any(),
|
|
4213
4288
|
annotations: { readOnlyHint: true },
|
|
4214
4289
|
async execute(input, ctx) {
|
|
4215
4290
|
return ctx.client.get("project_folders", {
|
|
@@ -4224,18 +4299,18 @@ var foldersList = {
|
|
|
4224
4299
|
|
|
4225
4300
|
// src/commands/folders/move.ts
|
|
4226
4301
|
init_errors();
|
|
4227
|
-
import { z as
|
|
4302
|
+
import { z as z52 } from "zod";
|
|
4228
4303
|
var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
4229
|
-
var
|
|
4230
|
-
folderId:
|
|
4231
|
-
parentId:
|
|
4304
|
+
var inputSchema50 = z52.object({
|
|
4305
|
+
folderId: z52.string().uuid().describe("Folder ID to move"),
|
|
4306
|
+
parentId: z52.string().min(1).describe("Target parent folder ID, or 'root' to move to project root")
|
|
4232
4307
|
});
|
|
4233
4308
|
var foldersMove = {
|
|
4234
4309
|
name: "folders.move",
|
|
4235
4310
|
group: "folders",
|
|
4236
4311
|
description: "Move a folder to a new parent (or to root)",
|
|
4237
|
-
inputSchema:
|
|
4238
|
-
outputSchema:
|
|
4312
|
+
inputSchema: inputSchema50,
|
|
4313
|
+
outputSchema: z52.any(),
|
|
4239
4314
|
async execute(input, ctx) {
|
|
4240
4315
|
let parentValue;
|
|
4241
4316
|
if (input.parentId === "root") {
|
|
@@ -4263,17 +4338,17 @@ var foldersMove = {
|
|
|
4263
4338
|
};
|
|
4264
4339
|
|
|
4265
4340
|
// src/commands/folders/rename.ts
|
|
4266
|
-
import { z as
|
|
4267
|
-
var
|
|
4268
|
-
folderId:
|
|
4269
|
-
name:
|
|
4341
|
+
import { z as z53 } from "zod";
|
|
4342
|
+
var inputSchema51 = z53.object({
|
|
4343
|
+
folderId: z53.string().uuid().describe("Folder ID"),
|
|
4344
|
+
name: z53.string().min(1).describe("New folder name")
|
|
4270
4345
|
});
|
|
4271
4346
|
var foldersRename = {
|
|
4272
4347
|
name: "folders.rename",
|
|
4273
4348
|
group: "folders",
|
|
4274
4349
|
description: "Rename a folder",
|
|
4275
|
-
inputSchema:
|
|
4276
|
-
outputSchema:
|
|
4350
|
+
inputSchema: inputSchema51,
|
|
4351
|
+
outputSchema: z53.any(),
|
|
4277
4352
|
annotations: { idempotentHint: true },
|
|
4278
4353
|
async execute(input, ctx) {
|
|
4279
4354
|
return ctx.client.put(
|
|
@@ -4290,17 +4365,46 @@ var foldersRename = {
|
|
|
4290
4365
|
}
|
|
4291
4366
|
};
|
|
4292
4367
|
|
|
4368
|
+
// src/commands/folders/roots.ts
|
|
4369
|
+
import { z as z54 } from "zod";
|
|
4370
|
+
var inputSchema52 = z54.object({});
|
|
4371
|
+
var foldersRoots = {
|
|
4372
|
+
name: "folders.roots",
|
|
4373
|
+
group: "folders",
|
|
4374
|
+
description: "List the top-level Knowledge Base folders you can access",
|
|
4375
|
+
inputSchema: inputSchema52,
|
|
4376
|
+
outputSchema: z54.any(),
|
|
4377
|
+
annotations: { readOnlyHint: true },
|
|
4378
|
+
async execute(_input, ctx) {
|
|
4379
|
+
return ctx.client.get("folder_roots");
|
|
4380
|
+
},
|
|
4381
|
+
formatOutput(output, format) {
|
|
4382
|
+
if (format === "compact") return output.id ?? JSON.stringify(output);
|
|
4383
|
+
return JSON.stringify(output, null, 2);
|
|
4384
|
+
}
|
|
4385
|
+
};
|
|
4386
|
+
|
|
4293
4387
|
// src/commands/folders/index.ts
|
|
4294
4388
|
function registerFolderCommands() {
|
|
4295
|
-
return [
|
|
4389
|
+
return [
|
|
4390
|
+
foldersRoots,
|
|
4391
|
+
foldersChildren,
|
|
4392
|
+
foldersGet,
|
|
4393
|
+
foldersFiles,
|
|
4394
|
+
foldersList,
|
|
4395
|
+
foldersCreate,
|
|
4396
|
+
foldersRename,
|
|
4397
|
+
foldersMove,
|
|
4398
|
+
foldersDelete
|
|
4399
|
+
];
|
|
4296
4400
|
}
|
|
4297
4401
|
|
|
4298
4402
|
// src/commands/health.ts
|
|
4299
|
-
import { z as
|
|
4300
|
-
var healthInput =
|
|
4301
|
-
var healthOutput =
|
|
4302
|
-
status:
|
|
4303
|
-
timestamp:
|
|
4403
|
+
import { z as z55 } from "zod";
|
|
4404
|
+
var healthInput = z55.object({});
|
|
4405
|
+
var healthOutput = z55.object({
|
|
4406
|
+
status: z55.string(),
|
|
4407
|
+
timestamp: z55.string()
|
|
4304
4408
|
});
|
|
4305
4409
|
var healthCheck = {
|
|
4306
4410
|
name: "health.check",
|
|
@@ -4330,18 +4434,18 @@ var healthCheck = {
|
|
|
4330
4434
|
};
|
|
4331
4435
|
|
|
4332
4436
|
// src/commands/library/create-folder.ts
|
|
4333
|
-
import { z as
|
|
4334
|
-
var
|
|
4335
|
-
orgId:
|
|
4336
|
-
name:
|
|
4337
|
-
parent:
|
|
4437
|
+
import { z as z56 } from "zod";
|
|
4438
|
+
var inputSchema53 = z56.object({
|
|
4439
|
+
orgId: z56.string().uuid().describe("Organization ID"),
|
|
4440
|
+
name: z56.string().min(1).describe("Folder name"),
|
|
4441
|
+
parent: z56.string().uuid().optional().describe("Parent folder ID")
|
|
4338
4442
|
});
|
|
4339
4443
|
var libraryCreateFolder = {
|
|
4340
4444
|
name: "library.createFolder",
|
|
4341
4445
|
group: "library",
|
|
4342
4446
|
description: "Create a folder in the organization library",
|
|
4343
|
-
inputSchema:
|
|
4344
|
-
outputSchema:
|
|
4447
|
+
inputSchema: inputSchema53,
|
|
4448
|
+
outputSchema: z56.any(),
|
|
4345
4449
|
async execute(input, ctx) {
|
|
4346
4450
|
const body = { name: input.name };
|
|
4347
4451
|
if (input.parent) body.parentId = input.parent;
|
|
@@ -4356,17 +4460,17 @@ var libraryCreateFolder = {
|
|
|
4356
4460
|
};
|
|
4357
4461
|
|
|
4358
4462
|
// src/commands/library/delete-folder.ts
|
|
4359
|
-
import { z as
|
|
4360
|
-
var
|
|
4361
|
-
orgId:
|
|
4362
|
-
folderId:
|
|
4463
|
+
import { z as z57 } from "zod";
|
|
4464
|
+
var inputSchema54 = z57.object({
|
|
4465
|
+
orgId: z57.string().uuid().describe("Organization ID"),
|
|
4466
|
+
folderId: z57.string().uuid().describe("Folder ID to delete")
|
|
4363
4467
|
});
|
|
4364
4468
|
var libraryDeleteFolder = {
|
|
4365
4469
|
name: "library.deleteFolder",
|
|
4366
4470
|
group: "library",
|
|
4367
4471
|
description: "Delete a folder from the organization library",
|
|
4368
|
-
inputSchema:
|
|
4369
|
-
outputSchema:
|
|
4472
|
+
inputSchema: inputSchema54,
|
|
4473
|
+
outputSchema: z57.any(),
|
|
4370
4474
|
annotations: { destructiveHint: true },
|
|
4371
4475
|
async execute(input, ctx) {
|
|
4372
4476
|
await ctx.client.del("library_folder", {
|
|
@@ -4381,17 +4485,17 @@ var libraryDeleteFolder = {
|
|
|
4381
4485
|
};
|
|
4382
4486
|
|
|
4383
4487
|
// src/commands/library/files.ts
|
|
4384
|
-
import { z as
|
|
4385
|
-
var
|
|
4386
|
-
orgId:
|
|
4488
|
+
import { z as z58 } from "zod";
|
|
4489
|
+
var inputSchema55 = z58.object({
|
|
4490
|
+
orgId: z58.string().uuid().describe("Organization ID"),
|
|
4387
4491
|
...paginationInput
|
|
4388
4492
|
});
|
|
4389
4493
|
var libraryFiles = {
|
|
4390
4494
|
name: "library.files",
|
|
4391
4495
|
group: "library",
|
|
4392
4496
|
description: "List files in the organization library",
|
|
4393
|
-
inputSchema:
|
|
4394
|
-
outputSchema:
|
|
4497
|
+
inputSchema: inputSchema55,
|
|
4498
|
+
outputSchema: z58.any(),
|
|
4395
4499
|
annotations: { readOnlyHint: true },
|
|
4396
4500
|
async execute(input, ctx) {
|
|
4397
4501
|
return ctx.client.get("library_files", {
|
|
@@ -4406,16 +4510,16 @@ var libraryFiles = {
|
|
|
4406
4510
|
};
|
|
4407
4511
|
|
|
4408
4512
|
// src/commands/library/folders.ts
|
|
4409
|
-
import { z as
|
|
4410
|
-
var
|
|
4411
|
-
orgId:
|
|
4513
|
+
import { z as z59 } from "zod";
|
|
4514
|
+
var inputSchema56 = z59.object({
|
|
4515
|
+
orgId: z59.string().uuid().describe("Organization ID")
|
|
4412
4516
|
});
|
|
4413
4517
|
var libraryFolders = {
|
|
4414
4518
|
name: "library.folders",
|
|
4415
4519
|
group: "library",
|
|
4416
4520
|
description: "List folders in the organization library",
|
|
4417
|
-
inputSchema:
|
|
4418
|
-
outputSchema:
|
|
4521
|
+
inputSchema: inputSchema56,
|
|
4522
|
+
outputSchema: z59.any(),
|
|
4419
4523
|
annotations: { readOnlyHint: true },
|
|
4420
4524
|
async execute(input, ctx) {
|
|
4421
4525
|
return ctx.client.get("library_folders", {
|
|
@@ -4429,18 +4533,18 @@ var libraryFolders = {
|
|
|
4429
4533
|
};
|
|
4430
4534
|
|
|
4431
4535
|
// src/commands/library/rename-folder.ts
|
|
4432
|
-
import { z as
|
|
4433
|
-
var
|
|
4434
|
-
orgId:
|
|
4435
|
-
folderId:
|
|
4436
|
-
name:
|
|
4536
|
+
import { z as z60 } from "zod";
|
|
4537
|
+
var inputSchema57 = z60.object({
|
|
4538
|
+
orgId: z60.string().uuid().describe("Organization ID"),
|
|
4539
|
+
folderId: z60.string().uuid().describe("Folder ID to rename"),
|
|
4540
|
+
name: z60.string().min(1).describe("New folder name")
|
|
4437
4541
|
});
|
|
4438
4542
|
var libraryRenameFolder = {
|
|
4439
4543
|
name: "library.renameFolder",
|
|
4440
4544
|
group: "library",
|
|
4441
4545
|
description: "Rename a folder in the organization library",
|
|
4442
|
-
inputSchema:
|
|
4443
|
-
outputSchema:
|
|
4546
|
+
inputSchema: inputSchema57,
|
|
4547
|
+
outputSchema: z60.any(),
|
|
4444
4548
|
async execute(input, ctx) {
|
|
4445
4549
|
return ctx.client.put(
|
|
4446
4550
|
"library_folder",
|
|
@@ -4462,16 +4566,16 @@ function registerLibraryCommands() {
|
|
|
4462
4566
|
}
|
|
4463
4567
|
|
|
4464
4568
|
// src/commands/orgs/accept-invite.ts
|
|
4465
|
-
import { z as
|
|
4466
|
-
var
|
|
4467
|
-
token:
|
|
4569
|
+
import { z as z61 } from "zod";
|
|
4570
|
+
var inputSchema58 = z61.object({
|
|
4571
|
+
token: z61.string().min(1).describe("Invitation token")
|
|
4468
4572
|
});
|
|
4469
4573
|
var orgsAcceptInvite = {
|
|
4470
4574
|
name: "orgs.acceptInvite",
|
|
4471
4575
|
group: "orgs",
|
|
4472
4576
|
description: "Accept an organization invitation by token",
|
|
4473
|
-
inputSchema:
|
|
4474
|
-
outputSchema:
|
|
4577
|
+
inputSchema: inputSchema58,
|
|
4578
|
+
outputSchema: z61.any(),
|
|
4475
4579
|
async execute(input, ctx) {
|
|
4476
4580
|
return ctx.client.post("invitation_accept", void 0, {
|
|
4477
4581
|
pathParams: { token: input.token }
|
|
@@ -4484,16 +4588,16 @@ var orgsAcceptInvite = {
|
|
|
4484
4588
|
};
|
|
4485
4589
|
|
|
4486
4590
|
// src/commands/orgs/billing.ts
|
|
4487
|
-
import { z as
|
|
4488
|
-
var
|
|
4489
|
-
orgId:
|
|
4591
|
+
import { z as z62 } from "zod";
|
|
4592
|
+
var inputSchema59 = z62.object({
|
|
4593
|
+
orgId: z62.string().uuid().describe("Organization ID")
|
|
4490
4594
|
});
|
|
4491
4595
|
var orgsBilling = {
|
|
4492
4596
|
name: "orgs.billing",
|
|
4493
4597
|
group: "orgs",
|
|
4494
4598
|
description: "Get billing status for an organization",
|
|
4495
|
-
inputSchema:
|
|
4496
|
-
outputSchema:
|
|
4599
|
+
inputSchema: inputSchema59,
|
|
4600
|
+
outputSchema: z62.any(),
|
|
4497
4601
|
annotations: { readOnlyHint: true },
|
|
4498
4602
|
async execute(input, ctx) {
|
|
4499
4603
|
return ctx.client.get("organization_billing", {
|
|
@@ -4507,17 +4611,17 @@ var orgsBilling = {
|
|
|
4507
4611
|
};
|
|
4508
4612
|
|
|
4509
4613
|
// src/commands/orgs/cancel-invite.ts
|
|
4510
|
-
import { z as
|
|
4511
|
-
var
|
|
4512
|
-
orgId:
|
|
4513
|
-
invitationId:
|
|
4614
|
+
import { z as z63 } from "zod";
|
|
4615
|
+
var inputSchema60 = z63.object({
|
|
4616
|
+
orgId: z63.string().uuid().describe("Organization ID"),
|
|
4617
|
+
invitationId: z63.string().uuid().describe("Invitation ID to cancel")
|
|
4514
4618
|
});
|
|
4515
4619
|
var orgsCancelInvite = {
|
|
4516
4620
|
name: "orgs.cancelInvite",
|
|
4517
4621
|
group: "orgs",
|
|
4518
4622
|
description: "Cancel a pending organization invitation",
|
|
4519
|
-
inputSchema:
|
|
4520
|
-
outputSchema:
|
|
4623
|
+
inputSchema: inputSchema60,
|
|
4624
|
+
outputSchema: z63.any(),
|
|
4521
4625
|
annotations: { destructiveHint: true },
|
|
4522
4626
|
async execute(input, ctx) {
|
|
4523
4627
|
await ctx.client.del("org_invitation", {
|
|
@@ -4532,17 +4636,17 @@ var orgsCancelInvite = {
|
|
|
4532
4636
|
};
|
|
4533
4637
|
|
|
4534
4638
|
// src/commands/orgs/create.ts
|
|
4535
|
-
import { z as
|
|
4536
|
-
var
|
|
4537
|
-
name:
|
|
4538
|
-
description:
|
|
4639
|
+
import { z as z64 } from "zod";
|
|
4640
|
+
var inputSchema61 = z64.object({
|
|
4641
|
+
name: z64.string().min(1).describe("Organization name"),
|
|
4642
|
+
description: z64.string().optional().describe("Organization description")
|
|
4539
4643
|
});
|
|
4540
4644
|
var orgsCreate = {
|
|
4541
4645
|
name: "orgs.create",
|
|
4542
4646
|
group: "orgs",
|
|
4543
4647
|
description: "Create a new organization",
|
|
4544
|
-
inputSchema:
|
|
4545
|
-
outputSchema:
|
|
4648
|
+
inputSchema: inputSchema61,
|
|
4649
|
+
outputSchema: z64.any(),
|
|
4546
4650
|
async execute(input, ctx) {
|
|
4547
4651
|
return ctx.client.post("organizations", input);
|
|
4548
4652
|
},
|
|
@@ -4553,17 +4657,17 @@ var orgsCreate = {
|
|
|
4553
4657
|
};
|
|
4554
4658
|
|
|
4555
4659
|
// src/commands/orgs/delete.ts
|
|
4556
|
-
import { z as
|
|
4557
|
-
var
|
|
4558
|
-
orgId:
|
|
4559
|
-
yes:
|
|
4660
|
+
import { z as z65 } from "zod";
|
|
4661
|
+
var inputSchema62 = z65.object({
|
|
4662
|
+
orgId: z65.string().uuid().describe("Organization ID to delete"),
|
|
4663
|
+
yes: z65.boolean().optional().default(false).describe("Skip confirmation prompt")
|
|
4560
4664
|
});
|
|
4561
4665
|
var orgsDelete = {
|
|
4562
4666
|
name: "orgs.delete",
|
|
4563
4667
|
group: "orgs",
|
|
4564
4668
|
description: "Delete an organization",
|
|
4565
|
-
inputSchema:
|
|
4566
|
-
outputSchema:
|
|
4669
|
+
inputSchema: inputSchema62,
|
|
4670
|
+
outputSchema: z65.any(),
|
|
4567
4671
|
annotations: { destructiveHint: true },
|
|
4568
4672
|
async execute(input, ctx) {
|
|
4569
4673
|
if (!input.yes) {
|
|
@@ -4584,17 +4688,17 @@ var orgsDelete = {
|
|
|
4584
4688
|
};
|
|
4585
4689
|
|
|
4586
4690
|
// src/commands/orgs/files.ts
|
|
4587
|
-
import { z as
|
|
4588
|
-
var
|
|
4589
|
-
orgId:
|
|
4691
|
+
import { z as z66 } from "zod";
|
|
4692
|
+
var inputSchema63 = z66.object({
|
|
4693
|
+
orgId: z66.string().uuid().describe("Organization ID"),
|
|
4590
4694
|
...paginationInput
|
|
4591
4695
|
});
|
|
4592
4696
|
var orgsFiles = {
|
|
4593
4697
|
name: "orgs.files",
|
|
4594
4698
|
group: "orgs",
|
|
4595
4699
|
description: "List files belonging to an organization",
|
|
4596
|
-
inputSchema:
|
|
4597
|
-
outputSchema:
|
|
4700
|
+
inputSchema: inputSchema63,
|
|
4701
|
+
outputSchema: z66.any(),
|
|
4598
4702
|
annotations: { readOnlyHint: true },
|
|
4599
4703
|
async execute(input, ctx) {
|
|
4600
4704
|
return ctx.client.get("org_files", {
|
|
@@ -4609,16 +4713,16 @@ var orgsFiles = {
|
|
|
4609
4713
|
};
|
|
4610
4714
|
|
|
4611
4715
|
// src/commands/orgs/get.ts
|
|
4612
|
-
import { z as
|
|
4613
|
-
var
|
|
4614
|
-
orgId:
|
|
4716
|
+
import { z as z67 } from "zod";
|
|
4717
|
+
var inputSchema64 = z67.object({
|
|
4718
|
+
orgId: z67.string().uuid().describe("Organization ID")
|
|
4615
4719
|
});
|
|
4616
4720
|
var orgsGet = {
|
|
4617
4721
|
name: "orgs.get",
|
|
4618
4722
|
group: "orgs",
|
|
4619
4723
|
description: "Get details of a specific organization",
|
|
4620
|
-
inputSchema:
|
|
4621
|
-
outputSchema:
|
|
4724
|
+
inputSchema: inputSchema64,
|
|
4725
|
+
outputSchema: z67.any(),
|
|
4622
4726
|
async execute(input, ctx) {
|
|
4623
4727
|
return ctx.client.get("organization", {
|
|
4624
4728
|
pathParams: { id: input.orgId }
|
|
@@ -4631,16 +4735,16 @@ var orgsGet = {
|
|
|
4631
4735
|
};
|
|
4632
4736
|
|
|
4633
4737
|
// src/commands/orgs/invitation-info.ts
|
|
4634
|
-
import { z as
|
|
4635
|
-
var
|
|
4636
|
-
token:
|
|
4738
|
+
import { z as z68 } from "zod";
|
|
4739
|
+
var inputSchema65 = z68.object({
|
|
4740
|
+
token: z68.string().min(1).describe("Invitation token")
|
|
4637
4741
|
});
|
|
4638
4742
|
var orgsInvitationInfo = {
|
|
4639
4743
|
name: "orgs.invitationInfo",
|
|
4640
4744
|
group: "orgs",
|
|
4641
4745
|
description: "Get information about an invitation by token",
|
|
4642
|
-
inputSchema:
|
|
4643
|
-
outputSchema:
|
|
4746
|
+
inputSchema: inputSchema65,
|
|
4747
|
+
outputSchema: z68.any(),
|
|
4644
4748
|
annotations: { readOnlyHint: true },
|
|
4645
4749
|
async execute(input, ctx) {
|
|
4646
4750
|
return ctx.client.get("invitation_info", {
|
|
@@ -4654,16 +4758,16 @@ var orgsInvitationInfo = {
|
|
|
4654
4758
|
};
|
|
4655
4759
|
|
|
4656
4760
|
// src/commands/orgs/invitations.ts
|
|
4657
|
-
import { z as
|
|
4658
|
-
var
|
|
4659
|
-
orgId:
|
|
4761
|
+
import { z as z69 } from "zod";
|
|
4762
|
+
var inputSchema66 = z69.object({
|
|
4763
|
+
orgId: z69.string().uuid().describe("Organization ID")
|
|
4660
4764
|
});
|
|
4661
4765
|
var orgsInvitations = {
|
|
4662
4766
|
name: "orgs.invitations",
|
|
4663
4767
|
group: "orgs",
|
|
4664
4768
|
description: "List pending invitations for an organization",
|
|
4665
|
-
inputSchema:
|
|
4666
|
-
outputSchema:
|
|
4769
|
+
inputSchema: inputSchema66,
|
|
4770
|
+
outputSchema: z69.any(),
|
|
4667
4771
|
annotations: { readOnlyHint: true },
|
|
4668
4772
|
async execute(input, ctx) {
|
|
4669
4773
|
return ctx.client.get("org_invitations", {
|
|
@@ -4677,18 +4781,18 @@ var orgsInvitations = {
|
|
|
4677
4781
|
};
|
|
4678
4782
|
|
|
4679
4783
|
// src/commands/orgs/invite.ts
|
|
4680
|
-
import { z as
|
|
4681
|
-
var
|
|
4682
|
-
orgId:
|
|
4683
|
-
email:
|
|
4684
|
-
role:
|
|
4784
|
+
import { z as z70 } from "zod";
|
|
4785
|
+
var inputSchema67 = z70.object({
|
|
4786
|
+
orgId: z70.string().uuid().describe("Organization ID"),
|
|
4787
|
+
email: z70.string().email().describe("Email address to invite"),
|
|
4788
|
+
role: z70.string().optional().default("Member").describe("Role to assign (default: Member)")
|
|
4685
4789
|
});
|
|
4686
4790
|
var orgsInvite = {
|
|
4687
4791
|
name: "orgs.invite",
|
|
4688
4792
|
group: "orgs",
|
|
4689
4793
|
description: "Invite a user to an organization by email",
|
|
4690
|
-
inputSchema:
|
|
4691
|
-
outputSchema:
|
|
4794
|
+
inputSchema: inputSchema67,
|
|
4795
|
+
outputSchema: z70.any(),
|
|
4692
4796
|
annotations: { idempotentHint: true },
|
|
4693
4797
|
async execute(input, ctx) {
|
|
4694
4798
|
const existing = await ctx.client.get("org_invitations", {
|
|
@@ -4716,14 +4820,14 @@ var orgsInvite = {
|
|
|
4716
4820
|
};
|
|
4717
4821
|
|
|
4718
4822
|
// src/commands/orgs/list.ts
|
|
4719
|
-
import { z as
|
|
4720
|
-
var
|
|
4823
|
+
import { z as z71 } from "zod";
|
|
4824
|
+
var inputSchema68 = z71.object({});
|
|
4721
4825
|
var orgsList = {
|
|
4722
4826
|
name: "orgs.list",
|
|
4723
4827
|
group: "orgs",
|
|
4724
4828
|
description: "List all organizations the current user belongs to",
|
|
4725
|
-
inputSchema:
|
|
4726
|
-
outputSchema:
|
|
4829
|
+
inputSchema: inputSchema68,
|
|
4830
|
+
outputSchema: z71.any(),
|
|
4727
4831
|
annotations: { readOnlyHint: true },
|
|
4728
4832
|
async execute(_input, ctx) {
|
|
4729
4833
|
return ctx.client.get("organizations");
|
|
@@ -4735,14 +4839,14 @@ var orgsList = {
|
|
|
4735
4839
|
};
|
|
4736
4840
|
|
|
4737
4841
|
// src/commands/orgs/list-all.ts
|
|
4738
|
-
import { z as
|
|
4739
|
-
var
|
|
4842
|
+
import { z as z72 } from "zod";
|
|
4843
|
+
var inputSchema69 = z72.object({});
|
|
4740
4844
|
var orgsListAll = {
|
|
4741
4845
|
name: "orgs.listAll",
|
|
4742
4846
|
group: "orgs",
|
|
4743
4847
|
description: "List all organizations (admin)",
|
|
4744
|
-
inputSchema:
|
|
4745
|
-
outputSchema:
|
|
4848
|
+
inputSchema: inputSchema69,
|
|
4849
|
+
outputSchema: z72.any(),
|
|
4746
4850
|
annotations: { readOnlyHint: true, internal: true },
|
|
4747
4851
|
async execute(_input, ctx) {
|
|
4748
4852
|
return ctx.client.get("organizations_all");
|
|
@@ -4754,16 +4858,16 @@ var orgsListAll = {
|
|
|
4754
4858
|
};
|
|
4755
4859
|
|
|
4756
4860
|
// src/commands/orgs/members.ts
|
|
4757
|
-
import { z as
|
|
4758
|
-
var
|
|
4759
|
-
orgId:
|
|
4861
|
+
import { z as z73 } from "zod";
|
|
4862
|
+
var inputSchema70 = z73.object({
|
|
4863
|
+
orgId: z73.string().uuid().describe("Organization ID")
|
|
4760
4864
|
});
|
|
4761
4865
|
var orgsMembers = {
|
|
4762
4866
|
name: "orgs.members",
|
|
4763
4867
|
group: "orgs",
|
|
4764
4868
|
description: "List members of an organization",
|
|
4765
|
-
inputSchema:
|
|
4766
|
-
outputSchema:
|
|
4869
|
+
inputSchema: inputSchema70,
|
|
4870
|
+
outputSchema: z73.any(),
|
|
4767
4871
|
annotations: { readOnlyHint: true },
|
|
4768
4872
|
async execute(input, ctx) {
|
|
4769
4873
|
return ctx.client.get("organization_members", {
|
|
@@ -4777,17 +4881,17 @@ var orgsMembers = {
|
|
|
4777
4881
|
};
|
|
4778
4882
|
|
|
4779
4883
|
// src/commands/orgs/remove-member.ts
|
|
4780
|
-
import { z as
|
|
4781
|
-
var
|
|
4782
|
-
orgId:
|
|
4783
|
-
membershipId:
|
|
4884
|
+
import { z as z74 } from "zod";
|
|
4885
|
+
var inputSchema71 = z74.object({
|
|
4886
|
+
orgId: z74.string().uuid().describe("Organization ID"),
|
|
4887
|
+
membershipId: z74.string().uuid().describe("Membership ID of the member to remove")
|
|
4784
4888
|
});
|
|
4785
4889
|
var orgsRemoveMember = {
|
|
4786
4890
|
name: "orgs.removeMember",
|
|
4787
4891
|
group: "orgs",
|
|
4788
4892
|
description: "Remove a member from an organization",
|
|
4789
|
-
inputSchema:
|
|
4790
|
-
outputSchema:
|
|
4893
|
+
inputSchema: inputSchema71,
|
|
4894
|
+
outputSchema: z74.any(),
|
|
4791
4895
|
annotations: { destructiveHint: true },
|
|
4792
4896
|
async execute(input, ctx) {
|
|
4793
4897
|
await ctx.client.del("organization_member", {
|
|
@@ -4802,17 +4906,17 @@ var orgsRemoveMember = {
|
|
|
4802
4906
|
};
|
|
4803
4907
|
|
|
4804
4908
|
// src/commands/orgs/resend-invite.ts
|
|
4805
|
-
import { z as
|
|
4806
|
-
var
|
|
4807
|
-
orgId:
|
|
4808
|
-
invitationId:
|
|
4909
|
+
import { z as z75 } from "zod";
|
|
4910
|
+
var inputSchema72 = z75.object({
|
|
4911
|
+
orgId: z75.string().uuid().describe("Organization ID"),
|
|
4912
|
+
invitationId: z75.string().uuid().describe("Invitation ID to resend")
|
|
4809
4913
|
});
|
|
4810
4914
|
var orgsResendInvite = {
|
|
4811
4915
|
name: "orgs.resendInvite",
|
|
4812
4916
|
group: "orgs",
|
|
4813
4917
|
description: "Resend an organization invitation email. Regenerates the token and extends the expiry by 7 days. Works on both pending and expired invitations, preserves the invitation ID.",
|
|
4814
|
-
inputSchema:
|
|
4815
|
-
outputSchema:
|
|
4918
|
+
inputSchema: inputSchema72,
|
|
4919
|
+
outputSchema: z75.any(),
|
|
4816
4920
|
annotations: { idempotentHint: true },
|
|
4817
4921
|
async execute(input, ctx) {
|
|
4818
4922
|
return ctx.client.post(
|
|
@@ -4828,16 +4932,16 @@ var orgsResendInvite = {
|
|
|
4828
4932
|
};
|
|
4829
4933
|
|
|
4830
4934
|
// src/commands/orgs/set-default.ts
|
|
4831
|
-
import { z as
|
|
4832
|
-
var
|
|
4833
|
-
orgId:
|
|
4935
|
+
import { z as z76 } from "zod";
|
|
4936
|
+
var inputSchema73 = z76.object({
|
|
4937
|
+
orgId: z76.string().uuid().describe("Organization ID to set as default")
|
|
4834
4938
|
});
|
|
4835
4939
|
var orgsSetDefault = {
|
|
4836
4940
|
name: "orgs.setDefault",
|
|
4837
4941
|
group: "orgs",
|
|
4838
4942
|
description: "Set an organization as the default",
|
|
4839
|
-
inputSchema:
|
|
4840
|
-
outputSchema:
|
|
4943
|
+
inputSchema: inputSchema73,
|
|
4944
|
+
outputSchema: z76.any(),
|
|
4841
4945
|
annotations: { idempotentHint: true },
|
|
4842
4946
|
async execute(input, ctx) {
|
|
4843
4947
|
return ctx.client.put("organization_set_default", void 0, {
|
|
@@ -4851,17 +4955,17 @@ var orgsSetDefault = {
|
|
|
4851
4955
|
};
|
|
4852
4956
|
|
|
4853
4957
|
// src/commands/orgs/set-stripe.ts
|
|
4854
|
-
import { z as
|
|
4855
|
-
var
|
|
4856
|
-
orgId:
|
|
4857
|
-
stripeCustomerId:
|
|
4958
|
+
import { z as z77 } from "zod";
|
|
4959
|
+
var inputSchema74 = z77.object({
|
|
4960
|
+
orgId: z77.string().uuid().describe("Organization ID"),
|
|
4961
|
+
stripeCustomerId: z77.string().min(1).describe("Stripe customer ID (e.g. cus_xxx)")
|
|
4858
4962
|
});
|
|
4859
4963
|
var orgsSetStripe = {
|
|
4860
4964
|
name: "orgs.setStripe",
|
|
4861
4965
|
group: "orgs",
|
|
4862
4966
|
description: "Set the Stripe customer ID for an organization",
|
|
4863
|
-
inputSchema:
|
|
4864
|
-
outputSchema:
|
|
4967
|
+
inputSchema: inputSchema74,
|
|
4968
|
+
outputSchema: z77.any(),
|
|
4865
4969
|
annotations: { idempotentHint: true },
|
|
4866
4970
|
async execute(input, ctx) {
|
|
4867
4971
|
return ctx.client.put(
|
|
@@ -4878,18 +4982,18 @@ var orgsSetStripe = {
|
|
|
4878
4982
|
|
|
4879
4983
|
// src/commands/orgs/update.ts
|
|
4880
4984
|
init_errors();
|
|
4881
|
-
import { z as
|
|
4882
|
-
var
|
|
4883
|
-
orgId:
|
|
4884
|
-
name:
|
|
4885
|
-
description:
|
|
4985
|
+
import { z as z78 } from "zod";
|
|
4986
|
+
var inputSchema75 = z78.object({
|
|
4987
|
+
orgId: z78.string().uuid().describe("Organization ID"),
|
|
4988
|
+
name: z78.string().min(1).optional().describe("New organization name"),
|
|
4989
|
+
description: z78.string().optional().describe("New organization description")
|
|
4886
4990
|
});
|
|
4887
4991
|
var orgsUpdate = {
|
|
4888
4992
|
name: "orgs.update",
|
|
4889
4993
|
group: "orgs",
|
|
4890
4994
|
description: "Update an existing organization",
|
|
4891
|
-
inputSchema:
|
|
4892
|
-
outputSchema:
|
|
4995
|
+
inputSchema: inputSchema75,
|
|
4996
|
+
outputSchema: z78.any(),
|
|
4893
4997
|
annotations: { idempotentHint: true },
|
|
4894
4998
|
async execute(input, ctx) {
|
|
4895
4999
|
const { orgId, ...fields } = input;
|
|
@@ -4910,18 +5014,18 @@ var orgsUpdate = {
|
|
|
4910
5014
|
};
|
|
4911
5015
|
|
|
4912
5016
|
// src/commands/orgs/update-role.ts
|
|
4913
|
-
import { z as
|
|
4914
|
-
var
|
|
4915
|
-
orgId:
|
|
4916
|
-
membershipId:
|
|
4917
|
-
role:
|
|
5017
|
+
import { z as z79 } from "zod";
|
|
5018
|
+
var inputSchema76 = z79.object({
|
|
5019
|
+
orgId: z79.string().uuid().describe("Organization ID"),
|
|
5020
|
+
membershipId: z79.string().uuid().describe("Membership ID of the member"),
|
|
5021
|
+
role: z79.string().min(1).describe("New role to assign")
|
|
4918
5022
|
});
|
|
4919
5023
|
var orgsUpdateRole = {
|
|
4920
5024
|
name: "orgs.updateRole",
|
|
4921
5025
|
group: "orgs",
|
|
4922
5026
|
description: "Update an organization member's role",
|
|
4923
|
-
inputSchema:
|
|
4924
|
-
outputSchema:
|
|
5027
|
+
inputSchema: inputSchema76,
|
|
5028
|
+
outputSchema: z79.any(),
|
|
4925
5029
|
annotations: { idempotentHint: true },
|
|
4926
5030
|
async execute(input, ctx) {
|
|
4927
5031
|
return ctx.client.put(
|
|
@@ -4962,18 +5066,18 @@ function registerOrgCommands() {
|
|
|
4962
5066
|
}
|
|
4963
5067
|
|
|
4964
5068
|
// src/commands/projects/add-member.ts
|
|
4965
|
-
import { z as
|
|
4966
|
-
var
|
|
4967
|
-
projectId:
|
|
4968
|
-
userId:
|
|
4969
|
-
role:
|
|
5069
|
+
import { z as z80 } from "zod";
|
|
5070
|
+
var inputSchema77 = z80.object({
|
|
5071
|
+
projectId: z80.string().uuid().describe("Project ID"),
|
|
5072
|
+
userId: z80.string().uuid().describe("User ID to add"),
|
|
5073
|
+
role: z80.string().default("Member").describe("Role to assign (default: Member)")
|
|
4970
5074
|
});
|
|
4971
5075
|
var projectsAddMember = {
|
|
4972
5076
|
name: "projects.addMember",
|
|
4973
5077
|
group: "projects",
|
|
4974
5078
|
description: "Add a member to a project",
|
|
4975
|
-
inputSchema:
|
|
4976
|
-
outputSchema:
|
|
5079
|
+
inputSchema: inputSchema77,
|
|
5080
|
+
outputSchema: z80.any(),
|
|
4977
5081
|
async execute(input, ctx) {
|
|
4978
5082
|
return ctx.client.post(
|
|
4979
5083
|
"project_members",
|
|
@@ -4988,16 +5092,16 @@ var projectsAddMember = {
|
|
|
4988
5092
|
};
|
|
4989
5093
|
|
|
4990
5094
|
// src/commands/projects/archive.ts
|
|
4991
|
-
import { z as
|
|
4992
|
-
var
|
|
4993
|
-
projectId:
|
|
5095
|
+
import { z as z81 } from "zod";
|
|
5096
|
+
var inputSchema78 = z81.object({
|
|
5097
|
+
projectId: z81.string().uuid().describe("Project ID to archive")
|
|
4994
5098
|
});
|
|
4995
5099
|
var projectsArchive = {
|
|
4996
5100
|
name: "projects.archive",
|
|
4997
5101
|
group: "projects",
|
|
4998
5102
|
description: "Archive (delete) a project",
|
|
4999
|
-
inputSchema:
|
|
5000
|
-
outputSchema:
|
|
5103
|
+
inputSchema: inputSchema78,
|
|
5104
|
+
outputSchema: z81.any(),
|
|
5001
5105
|
annotations: { destructiveHint: true },
|
|
5002
5106
|
async execute(input, ctx) {
|
|
5003
5107
|
await ctx.client.del("project", {
|
|
@@ -5012,18 +5116,18 @@ var projectsArchive = {
|
|
|
5012
5116
|
};
|
|
5013
5117
|
|
|
5014
5118
|
// src/commands/projects/create.ts
|
|
5015
|
-
import { z as
|
|
5016
|
-
var
|
|
5017
|
-
name:
|
|
5018
|
-
description:
|
|
5019
|
-
icon:
|
|
5119
|
+
import { z as z82 } from "zod";
|
|
5120
|
+
var inputSchema79 = z82.object({
|
|
5121
|
+
name: z82.string().min(1).describe("Project name"),
|
|
5122
|
+
description: z82.string().optional().describe("Project description"),
|
|
5123
|
+
icon: z82.string().optional().describe("Project icon")
|
|
5020
5124
|
});
|
|
5021
5125
|
var projectsCreate = {
|
|
5022
5126
|
name: "projects.create",
|
|
5023
5127
|
group: "projects",
|
|
5024
5128
|
description: "Create a new project",
|
|
5025
|
-
inputSchema:
|
|
5026
|
-
outputSchema:
|
|
5129
|
+
inputSchema: inputSchema79,
|
|
5130
|
+
outputSchema: z82.any(),
|
|
5027
5131
|
async execute(input, ctx) {
|
|
5028
5132
|
return ctx.client.post("projects", input);
|
|
5029
5133
|
},
|
|
@@ -5034,16 +5138,16 @@ var projectsCreate = {
|
|
|
5034
5138
|
};
|
|
5035
5139
|
|
|
5036
5140
|
// src/commands/projects/get.ts
|
|
5037
|
-
import { z as
|
|
5038
|
-
var
|
|
5039
|
-
projectId:
|
|
5141
|
+
import { z as z83 } from "zod";
|
|
5142
|
+
var inputSchema80 = z83.object({
|
|
5143
|
+
projectId: z83.string().uuid().describe("Project ID")
|
|
5040
5144
|
});
|
|
5041
5145
|
var projectsGet = {
|
|
5042
5146
|
name: "projects.get",
|
|
5043
5147
|
group: "projects",
|
|
5044
5148
|
description: "Get details of a specific project",
|
|
5045
|
-
inputSchema:
|
|
5046
|
-
outputSchema:
|
|
5149
|
+
inputSchema: inputSchema80,
|
|
5150
|
+
outputSchema: z83.any(),
|
|
5047
5151
|
annotations: { readOnlyHint: true },
|
|
5048
5152
|
async execute(input, ctx) {
|
|
5049
5153
|
return ctx.client.get("project", {
|
|
@@ -5057,16 +5161,16 @@ var projectsGet = {
|
|
|
5057
5161
|
};
|
|
5058
5162
|
|
|
5059
5163
|
// src/commands/projects/leave.ts
|
|
5060
|
-
import { z as
|
|
5061
|
-
var
|
|
5062
|
-
projectId:
|
|
5164
|
+
import { z as z84 } from "zod";
|
|
5165
|
+
var inputSchema81 = z84.object({
|
|
5166
|
+
projectId: z84.string().uuid().describe("Project ID to leave")
|
|
5063
5167
|
});
|
|
5064
5168
|
var projectsLeave = {
|
|
5065
5169
|
name: "projects.leave",
|
|
5066
5170
|
group: "projects",
|
|
5067
5171
|
description: "Leave a project",
|
|
5068
|
-
inputSchema:
|
|
5069
|
-
outputSchema:
|
|
5172
|
+
inputSchema: inputSchema81,
|
|
5173
|
+
outputSchema: z84.any(),
|
|
5070
5174
|
annotations: { destructiveHint: true },
|
|
5071
5175
|
async execute(input, ctx) {
|
|
5072
5176
|
return ctx.client.post("project_leave", void 0, {
|
|
@@ -5080,16 +5184,16 @@ var projectsLeave = {
|
|
|
5080
5184
|
};
|
|
5081
5185
|
|
|
5082
5186
|
// src/commands/projects/list.ts
|
|
5083
|
-
import { z as
|
|
5084
|
-
var
|
|
5187
|
+
import { z as z85 } from "zod";
|
|
5188
|
+
var inputSchema82 = z85.object({
|
|
5085
5189
|
...paginationInput
|
|
5086
5190
|
});
|
|
5087
5191
|
var projectsList = {
|
|
5088
5192
|
name: "projects.list",
|
|
5089
5193
|
group: "projects",
|
|
5090
5194
|
description: "List all projects accessible to the current user",
|
|
5091
|
-
inputSchema:
|
|
5092
|
-
outputSchema:
|
|
5195
|
+
inputSchema: inputSchema82,
|
|
5196
|
+
outputSchema: z85.any(),
|
|
5093
5197
|
annotations: { readOnlyHint: true },
|
|
5094
5198
|
async execute(input, ctx) {
|
|
5095
5199
|
return ctx.client.get("projects", {
|
|
@@ -5103,16 +5207,16 @@ var projectsList = {
|
|
|
5103
5207
|
};
|
|
5104
5208
|
|
|
5105
5209
|
// src/commands/projects/members.ts
|
|
5106
|
-
import { z as
|
|
5107
|
-
var
|
|
5108
|
-
projectId:
|
|
5210
|
+
import { z as z86 } from "zod";
|
|
5211
|
+
var inputSchema83 = z86.object({
|
|
5212
|
+
projectId: z86.string().uuid().describe("Project ID")
|
|
5109
5213
|
});
|
|
5110
5214
|
var projectsMembers = {
|
|
5111
5215
|
name: "projects.members",
|
|
5112
5216
|
group: "projects",
|
|
5113
5217
|
description: "List members of a project",
|
|
5114
|
-
inputSchema:
|
|
5115
|
-
outputSchema:
|
|
5218
|
+
inputSchema: inputSchema83,
|
|
5219
|
+
outputSchema: z86.any(),
|
|
5116
5220
|
annotations: { readOnlyHint: true },
|
|
5117
5221
|
async execute(input, ctx) {
|
|
5118
5222
|
return ctx.client.get("project_members", {
|
|
@@ -5126,17 +5230,17 @@ var projectsMembers = {
|
|
|
5126
5230
|
};
|
|
5127
5231
|
|
|
5128
5232
|
// src/commands/projects/remove-member.ts
|
|
5129
|
-
import { z as
|
|
5130
|
-
var
|
|
5131
|
-
projectId:
|
|
5132
|
-
userId:
|
|
5233
|
+
import { z as z87 } from "zod";
|
|
5234
|
+
var inputSchema84 = z87.object({
|
|
5235
|
+
projectId: z87.string().uuid().describe("Project ID"),
|
|
5236
|
+
userId: z87.string().uuid().describe("User ID to remove")
|
|
5133
5237
|
});
|
|
5134
5238
|
var projectsRemoveMember = {
|
|
5135
5239
|
name: "projects.removeMember",
|
|
5136
5240
|
group: "projects",
|
|
5137
5241
|
description: "Remove a member from a project",
|
|
5138
|
-
inputSchema:
|
|
5139
|
-
outputSchema:
|
|
5242
|
+
inputSchema: inputSchema84,
|
|
5243
|
+
outputSchema: z87.any(),
|
|
5140
5244
|
annotations: { destructiveHint: true },
|
|
5141
5245
|
async execute(input, ctx) {
|
|
5142
5246
|
await ctx.client.del("project_member", {
|
|
@@ -5152,19 +5256,19 @@ var projectsRemoveMember = {
|
|
|
5152
5256
|
|
|
5153
5257
|
// src/commands/projects/update.ts
|
|
5154
5258
|
init_errors();
|
|
5155
|
-
import { z as
|
|
5156
|
-
var
|
|
5157
|
-
projectId:
|
|
5158
|
-
name:
|
|
5159
|
-
description:
|
|
5160
|
-
icon:
|
|
5259
|
+
import { z as z88 } from "zod";
|
|
5260
|
+
var inputSchema85 = z88.object({
|
|
5261
|
+
projectId: z88.string().uuid().describe("Project ID"),
|
|
5262
|
+
name: z88.string().min(1).optional().describe("New project name"),
|
|
5263
|
+
description: z88.string().optional().describe("New project description"),
|
|
5264
|
+
icon: z88.string().optional().describe("New project icon")
|
|
5161
5265
|
});
|
|
5162
5266
|
var projectsUpdate = {
|
|
5163
5267
|
name: "projects.update",
|
|
5164
5268
|
group: "projects",
|
|
5165
5269
|
description: "Update an existing project",
|
|
5166
|
-
inputSchema:
|
|
5167
|
-
outputSchema:
|
|
5270
|
+
inputSchema: inputSchema85,
|
|
5271
|
+
outputSchema: z88.any(),
|
|
5168
5272
|
annotations: { idempotentHint: true },
|
|
5169
5273
|
async execute(input, ctx) {
|
|
5170
5274
|
const { projectId, ...fields } = input;
|
|
@@ -5185,18 +5289,18 @@ var projectsUpdate = {
|
|
|
5185
5289
|
};
|
|
5186
5290
|
|
|
5187
5291
|
// src/commands/projects/update-role.ts
|
|
5188
|
-
import { z as
|
|
5189
|
-
var
|
|
5190
|
-
projectId:
|
|
5191
|
-
userId:
|
|
5192
|
-
role:
|
|
5292
|
+
import { z as z89 } from "zod";
|
|
5293
|
+
var inputSchema86 = z89.object({
|
|
5294
|
+
projectId: z89.string().uuid().describe("Project ID"),
|
|
5295
|
+
userId: z89.string().uuid().describe("User ID of the member"),
|
|
5296
|
+
role: z89.string().min(1).describe("New role to assign")
|
|
5193
5297
|
});
|
|
5194
5298
|
var projectsUpdateRole = {
|
|
5195
5299
|
name: "projects.updateRole",
|
|
5196
5300
|
group: "projects",
|
|
5197
5301
|
description: "Update a project member's role",
|
|
5198
|
-
inputSchema:
|
|
5199
|
-
outputSchema:
|
|
5302
|
+
inputSchema: inputSchema86,
|
|
5303
|
+
outputSchema: z89.any(),
|
|
5200
5304
|
annotations: { idempotentHint: true },
|
|
5201
5305
|
async execute(input, ctx) {
|
|
5202
5306
|
return ctx.client.put(
|
|
@@ -5228,19 +5332,19 @@ function registerProjectCommands() {
|
|
|
5228
5332
|
}
|
|
5229
5333
|
|
|
5230
5334
|
// src/commands/protocols/generate.ts
|
|
5231
|
-
import { z as
|
|
5232
|
-
var
|
|
5233
|
-
description:
|
|
5234
|
-
title:
|
|
5235
|
-
project:
|
|
5335
|
+
import { z as z90 } from "zod";
|
|
5336
|
+
var inputSchema87 = z90.object({
|
|
5337
|
+
description: z90.string().min(10).max(5e3).describe("Protocol description"),
|
|
5338
|
+
title: z90.string().max(200).optional().describe("Task title (defaults to first 100 chars of description)"),
|
|
5339
|
+
project: z90.string().uuid().optional().describe("Project UUID to associate with")
|
|
5236
5340
|
});
|
|
5237
5341
|
var protocolsGenerate = {
|
|
5238
5342
|
name: "protocols.generate",
|
|
5239
5343
|
group: "protocols",
|
|
5240
5344
|
description: "Generate a bioprotocol \u2014 creates a task and sends the description in one call. Returns the task and the queued user message, NOT the AI response; the agent processes asynchronously. To get the generated protocol, poll elnora_tasks_messages with the returned task id every 5-10s until the last message has role 'assistant' with metadata.status 'completed'. Timeout after 5 min.",
|
|
5241
5345
|
stdinField: "description",
|
|
5242
|
-
inputSchema:
|
|
5243
|
-
outputSchema:
|
|
5346
|
+
inputSchema: inputSchema87,
|
|
5347
|
+
outputSchema: z90.any(),
|
|
5244
5348
|
annotations: { mcpScopes: ["tasks:write", "messages:write"] },
|
|
5245
5349
|
async execute(input, ctx) {
|
|
5246
5350
|
const body = { title: input.title || input.description.slice(0, 100) };
|
|
@@ -5274,9 +5378,9 @@ function registerProtocolCommands() {
|
|
|
5274
5378
|
}
|
|
5275
5379
|
|
|
5276
5380
|
// src/commands/search/all.ts
|
|
5277
|
-
import { z as
|
|
5278
|
-
var
|
|
5279
|
-
query:
|
|
5381
|
+
import { z as z91 } from "zod";
|
|
5382
|
+
var inputSchema88 = z91.object({
|
|
5383
|
+
query: z91.string().min(1).describe("Search query"),
|
|
5280
5384
|
...paginationInput
|
|
5281
5385
|
});
|
|
5282
5386
|
var searchAll = {
|
|
@@ -5284,8 +5388,8 @@ var searchAll = {
|
|
|
5284
5388
|
group: "search",
|
|
5285
5389
|
description: "Search across all entities",
|
|
5286
5390
|
stdinField: "query",
|
|
5287
|
-
inputSchema:
|
|
5288
|
-
outputSchema:
|
|
5391
|
+
inputSchema: inputSchema88,
|
|
5392
|
+
outputSchema: z91.any(),
|
|
5289
5393
|
annotations: { readOnlyHint: true },
|
|
5290
5394
|
async execute(input, ctx) {
|
|
5291
5395
|
return ctx.client.get("search_all", {
|
|
@@ -5299,10 +5403,10 @@ var searchAll = {
|
|
|
5299
5403
|
};
|
|
5300
5404
|
|
|
5301
5405
|
// src/commands/search/file-content.ts
|
|
5302
|
-
import { z as
|
|
5303
|
-
var
|
|
5304
|
-
query:
|
|
5305
|
-
projectId:
|
|
5406
|
+
import { z as z92 } from "zod";
|
|
5407
|
+
var inputSchema89 = z92.object({
|
|
5408
|
+
query: z92.string().min(1).describe("Search query"),
|
|
5409
|
+
projectId: z92.string().uuid().optional().describe("Filter by project ID"),
|
|
5306
5410
|
...paginationInput
|
|
5307
5411
|
});
|
|
5308
5412
|
var searchFileContent = {
|
|
@@ -5310,8 +5414,8 @@ var searchFileContent = {
|
|
|
5310
5414
|
group: "search",
|
|
5311
5415
|
description: "Search within file contents",
|
|
5312
5416
|
stdinField: "query",
|
|
5313
|
-
inputSchema:
|
|
5314
|
-
outputSchema:
|
|
5417
|
+
inputSchema: inputSchema89,
|
|
5418
|
+
outputSchema: z92.any(),
|
|
5315
5419
|
annotations: { readOnlyHint: true },
|
|
5316
5420
|
async execute(input, ctx) {
|
|
5317
5421
|
const queryParams = {
|
|
@@ -5329,9 +5433,9 @@ var searchFileContent = {
|
|
|
5329
5433
|
};
|
|
5330
5434
|
|
|
5331
5435
|
// src/commands/search/files.ts
|
|
5332
|
-
import { z as
|
|
5333
|
-
var
|
|
5334
|
-
query:
|
|
5436
|
+
import { z as z93 } from "zod";
|
|
5437
|
+
var inputSchema90 = z93.object({
|
|
5438
|
+
query: z93.string().min(1).describe("Search query"),
|
|
5335
5439
|
...paginationInput
|
|
5336
5440
|
});
|
|
5337
5441
|
var searchFiles = {
|
|
@@ -5339,8 +5443,8 @@ var searchFiles = {
|
|
|
5339
5443
|
group: "search",
|
|
5340
5444
|
description: "Search files by query",
|
|
5341
5445
|
stdinField: "query",
|
|
5342
|
-
inputSchema:
|
|
5343
|
-
outputSchema:
|
|
5446
|
+
inputSchema: inputSchema90,
|
|
5447
|
+
outputSchema: z93.any(),
|
|
5344
5448
|
annotations: { readOnlyHint: true },
|
|
5345
5449
|
async execute(input, ctx) {
|
|
5346
5450
|
return ctx.client.get("search_files", {
|
|
@@ -5354,9 +5458,9 @@ var searchFiles = {
|
|
|
5354
5458
|
};
|
|
5355
5459
|
|
|
5356
5460
|
// src/commands/search/tasks.ts
|
|
5357
|
-
import { z as
|
|
5358
|
-
var
|
|
5359
|
-
query:
|
|
5461
|
+
import { z as z94 } from "zod";
|
|
5462
|
+
var inputSchema91 = z94.object({
|
|
5463
|
+
query: z94.string().min(1).describe("Search query"),
|
|
5360
5464
|
...paginationInput
|
|
5361
5465
|
});
|
|
5362
5466
|
var searchTasks = {
|
|
@@ -5364,8 +5468,8 @@ var searchTasks = {
|
|
|
5364
5468
|
group: "search",
|
|
5365
5469
|
description: "Search tasks by query",
|
|
5366
5470
|
stdinField: "query",
|
|
5367
|
-
inputSchema:
|
|
5368
|
-
outputSchema:
|
|
5471
|
+
inputSchema: inputSchema91,
|
|
5472
|
+
outputSchema: z94.any(),
|
|
5369
5473
|
annotations: { readOnlyHint: true },
|
|
5370
5474
|
async execute(input, ctx) {
|
|
5371
5475
|
return ctx.client.get("search_tasks", {
|
|
@@ -5384,16 +5488,16 @@ function registerSearchCommands() {
|
|
|
5384
5488
|
}
|
|
5385
5489
|
|
|
5386
5490
|
// src/commands/tasks/archive.ts
|
|
5387
|
-
import { z as
|
|
5388
|
-
var
|
|
5389
|
-
taskId:
|
|
5491
|
+
import { z as z95 } from "zod";
|
|
5492
|
+
var inputSchema92 = z95.object({
|
|
5493
|
+
taskId: z95.string().uuid().describe("Task ID to archive")
|
|
5390
5494
|
});
|
|
5391
5495
|
var tasksArchive = {
|
|
5392
5496
|
name: "tasks.archive",
|
|
5393
5497
|
group: "tasks",
|
|
5394
5498
|
description: "Archive (delete) a task",
|
|
5395
|
-
inputSchema:
|
|
5396
|
-
outputSchema:
|
|
5499
|
+
inputSchema: inputSchema92,
|
|
5500
|
+
outputSchema: z95.any(),
|
|
5397
5501
|
annotations: { destructiveHint: true },
|
|
5398
5502
|
async execute(input, ctx) {
|
|
5399
5503
|
await ctx.client.del("task", {
|
|
@@ -5408,7 +5512,7 @@ var tasksArchive = {
|
|
|
5408
5512
|
};
|
|
5409
5513
|
|
|
5410
5514
|
// src/commands/tasks/create.ts
|
|
5411
|
-
import { z as
|
|
5515
|
+
import { z as z96 } from "zod";
|
|
5412
5516
|
|
|
5413
5517
|
// src/lib/poll.ts
|
|
5414
5518
|
init_errors();
|
|
@@ -5614,20 +5718,20 @@ ${this.useColor ? pc5.yellow("Stream timed out.") : "Stream timed out."}
|
|
|
5614
5718
|
};
|
|
5615
5719
|
|
|
5616
5720
|
// src/commands/tasks/create.ts
|
|
5617
|
-
var
|
|
5618
|
-
project:
|
|
5619
|
-
title:
|
|
5620
|
-
message:
|
|
5621
|
-
wait:
|
|
5622
|
-
stream:
|
|
5721
|
+
var inputSchema93 = z96.object({
|
|
5722
|
+
project: z96.string().uuid().optional().describe("Project ID (optional; defaults to your workspace)"),
|
|
5723
|
+
title: z96.string().optional().describe("Task title"),
|
|
5724
|
+
message: z96.string().optional().describe("Initial message"),
|
|
5725
|
+
wait: z96.boolean().default(false).describe("Wait for agent response (polling)"),
|
|
5726
|
+
stream: z96.boolean().default(false).describe("Stream agent response in real-time (SSE)")
|
|
5623
5727
|
});
|
|
5624
5728
|
var tasksCreate = {
|
|
5625
5729
|
name: "tasks.create",
|
|
5626
5730
|
group: "tasks",
|
|
5627
5731
|
description: "Create a new task in a project. If a message is provided it is queued, but the AI response is NOT returned \u2014 the agent processes asynchronously. Poll elnora_tasks_messages every 5-10s until the last message has role 'assistant' with metadata.status 'completed'. Timeout after 5 min.",
|
|
5628
5732
|
stdinField: "message",
|
|
5629
|
-
inputSchema:
|
|
5630
|
-
outputSchema:
|
|
5733
|
+
inputSchema: inputSchema93,
|
|
5734
|
+
outputSchema: z96.any(),
|
|
5631
5735
|
async execute(input, ctx) {
|
|
5632
5736
|
const result = await ctx.client.post("tasks", {
|
|
5633
5737
|
// projectId is optional (ELN-880 Phase C): when omitted the backend creates the
|
|
@@ -5679,16 +5783,16 @@ var tasksCreate = {
|
|
|
5679
5783
|
};
|
|
5680
5784
|
|
|
5681
5785
|
// src/commands/tasks/get.ts
|
|
5682
|
-
import { z as
|
|
5683
|
-
var
|
|
5684
|
-
taskId:
|
|
5786
|
+
import { z as z97 } from "zod";
|
|
5787
|
+
var inputSchema94 = z97.object({
|
|
5788
|
+
taskId: z97.string().uuid().describe("Task ID")
|
|
5685
5789
|
});
|
|
5686
5790
|
var tasksGet = {
|
|
5687
5791
|
name: "tasks.get",
|
|
5688
5792
|
group: "tasks",
|
|
5689
5793
|
description: "Get details of a specific task",
|
|
5690
|
-
inputSchema:
|
|
5691
|
-
outputSchema:
|
|
5794
|
+
inputSchema: inputSchema94,
|
|
5795
|
+
outputSchema: z97.any(),
|
|
5692
5796
|
annotations: { readOnlyHint: true },
|
|
5693
5797
|
async execute(input, ctx) {
|
|
5694
5798
|
return ctx.client.get("task", {
|
|
@@ -5702,17 +5806,17 @@ var tasksGet = {
|
|
|
5702
5806
|
};
|
|
5703
5807
|
|
|
5704
5808
|
// src/commands/tasks/list.ts
|
|
5705
|
-
import { z as
|
|
5706
|
-
var
|
|
5707
|
-
project:
|
|
5809
|
+
import { z as z98 } from "zod";
|
|
5810
|
+
var inputSchema95 = z98.object({
|
|
5811
|
+
project: z98.string().uuid().optional().describe("Project ID to filter by"),
|
|
5708
5812
|
...paginationInput
|
|
5709
5813
|
});
|
|
5710
5814
|
var tasksList = {
|
|
5711
5815
|
name: "tasks.list",
|
|
5712
5816
|
group: "tasks",
|
|
5713
5817
|
description: "List tasks, optionally filtered by project",
|
|
5714
|
-
inputSchema:
|
|
5715
|
-
outputSchema:
|
|
5818
|
+
inputSchema: inputSchema95,
|
|
5819
|
+
outputSchema: z98.any(),
|
|
5716
5820
|
annotations: { readOnlyHint: true },
|
|
5717
5821
|
async execute(input, ctx) {
|
|
5718
5822
|
if (input.project) {
|
|
@@ -5732,18 +5836,18 @@ var tasksList = {
|
|
|
5732
5836
|
};
|
|
5733
5837
|
|
|
5734
5838
|
// src/commands/tasks/messages.ts
|
|
5735
|
-
import { z as
|
|
5736
|
-
var
|
|
5737
|
-
taskId:
|
|
5738
|
-
cursor:
|
|
5739
|
-
limit:
|
|
5839
|
+
import { z as z99 } from "zod";
|
|
5840
|
+
var inputSchema96 = z99.object({
|
|
5841
|
+
taskId: z99.string().uuid().describe("Task ID"),
|
|
5842
|
+
cursor: z99.string().optional().describe("Pagination cursor"),
|
|
5843
|
+
limit: z99.number().int().min(1).max(100).default(50).describe("Results per page")
|
|
5740
5844
|
});
|
|
5741
5845
|
var tasksMessages = {
|
|
5742
5846
|
name: "tasks.messages",
|
|
5743
5847
|
group: "tasks",
|
|
5744
5848
|
description: "List messages for a task",
|
|
5745
|
-
inputSchema:
|
|
5746
|
-
outputSchema:
|
|
5849
|
+
inputSchema: inputSchema96,
|
|
5850
|
+
outputSchema: z99.any(),
|
|
5747
5851
|
annotations: { readOnlyHint: true },
|
|
5748
5852
|
async execute(input, ctx) {
|
|
5749
5853
|
const queryParams = { limit: input.limit };
|
|
@@ -5762,23 +5866,23 @@ var tasksMessages = {
|
|
|
5762
5866
|
};
|
|
5763
5867
|
|
|
5764
5868
|
// src/commands/tasks/send.ts
|
|
5765
|
-
import { z as
|
|
5869
|
+
import { z as z100 } from "zod";
|
|
5766
5870
|
init_profiles();
|
|
5767
5871
|
var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
5768
|
-
var
|
|
5769
|
-
taskId:
|
|
5770
|
-
message:
|
|
5771
|
-
fileRefs:
|
|
5772
|
-
wait:
|
|
5773
|
-
stream:
|
|
5872
|
+
var inputSchema97 = z100.object({
|
|
5873
|
+
taskId: z100.string().uuid().describe("Task ID"),
|
|
5874
|
+
message: z100.string().min(1).describe("Message content"),
|
|
5875
|
+
fileRefs: z100.string().optional().describe("Comma-separated file reference UUIDs"),
|
|
5876
|
+
wait: z100.boolean().default(false).describe("Wait for agent response (polling)"),
|
|
5877
|
+
stream: z100.boolean().default(false).describe("Stream agent response in real-time (SSE)")
|
|
5774
5878
|
});
|
|
5775
5879
|
var tasksSend = {
|
|
5776
5880
|
name: "tasks.send",
|
|
5777
5881
|
group: "tasks",
|
|
5778
5882
|
description: "Send a message to a task. Returns the created user message immediately \u2014 the agent processes asynchronously. To get the AI response, poll elnora_tasks_messages until the last message has role 'assistant' with metadata.status 'completed'. Poll every 5-10s, timeout after 5 min.",
|
|
5779
5883
|
stdinField: "message",
|
|
5780
|
-
inputSchema:
|
|
5781
|
-
outputSchema:
|
|
5884
|
+
inputSchema: inputSchema97,
|
|
5885
|
+
outputSchema: z100.any(),
|
|
5782
5886
|
async execute(input, ctx) {
|
|
5783
5887
|
let referencedFileIds;
|
|
5784
5888
|
if (input.fileRefs) {
|
|
@@ -5835,18 +5939,18 @@ var tasksSend = {
|
|
|
5835
5939
|
|
|
5836
5940
|
// src/commands/tasks/update.ts
|
|
5837
5941
|
init_errors();
|
|
5838
|
-
import { z as
|
|
5839
|
-
var
|
|
5840
|
-
taskId:
|
|
5841
|
-
title:
|
|
5842
|
-
status:
|
|
5942
|
+
import { z as z101 } from "zod";
|
|
5943
|
+
var inputSchema98 = z101.object({
|
|
5944
|
+
taskId: z101.string().uuid().describe("Task ID"),
|
|
5945
|
+
title: z101.string().min(1).optional().describe("New task title"),
|
|
5946
|
+
status: z101.string().optional().describe("New task status")
|
|
5843
5947
|
});
|
|
5844
5948
|
var tasksUpdate = {
|
|
5845
5949
|
name: "tasks.update",
|
|
5846
5950
|
group: "tasks",
|
|
5847
5951
|
description: "Update an existing task",
|
|
5848
|
-
inputSchema:
|
|
5849
|
-
outputSchema:
|
|
5952
|
+
inputSchema: inputSchema98,
|
|
5953
|
+
outputSchema: z101.any(),
|
|
5850
5954
|
annotations: { idempotentHint: true },
|
|
5851
5955
|
async execute(input, ctx) {
|
|
5852
5956
|
const { taskId, ...fields } = input;
|