@myagentroam/protocol 0.1.7 → 0.9.0

package/dist/index.js

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 export * from './enterprise.js';
+export * from './skill.js';
+export * from './mcp.js';
 export const healthStatusSchema = z.object({
     status: z.literal('ok')
 });
@@ -11,6 +13,15 @@ export const runnerAvailabilitySchema = z.object({
     available: z.boolean(),
     version: z.string().optional()
 });
+export const runtimeCommandSchema = z
+    .object({
+    id: z.enum(['npx', 'git', 'python', 'pip']),
+    command: z.string().trim().min(1).max(128),
+    available: z.boolean(),
+    version: z.string().trim().min(1).max(512).optional(),
+    path: z.string().trim().min(1).max(2048).optional()
+})
+    .strict();
 export const nodeUpgradeStatusSchema = z.object({
     state: z.enum(['IDLE', 'WAITING_FOR_RUNS', 'READY_TO_RESTART', 'FAILED']),
     targetVersion: z
@@ -32,6 +43,7 @@ export const nodeMetadataSchema = z
     codex: runnerAvailabilitySchema.optional(),
     claudeCode: runnerAvailabilitySchema.optional(),
     openCode: runnerAvailabilitySchema.optional(),
+    runtimeCommands: z.array(runtimeCommandSchema).max(16).optional(),
     supervisedUpgrade: z.boolean().optional(),
     upgrade: nodeUpgradeStatusSchema.optional()
 })
@@ -236,7 +248,9 @@ export const runnerProfileSchema = z.object({
     models: z.array(z.object({
         id: z.string().min(1).max(128),
         label: z.string().min(1).max(128),
-        supportedEfforts: z.array(z.string().min(1).max(64)).max(32)
+        supportedEfforts: z.array(z.string().min(1).max(64)).max(32),
+        isDefault: z.boolean().optional(),
+        defaultEffort: z.string().min(1).max(64).optional()
     })),
     accessOptions: z.array(z.object({
         id: z.string().min(1).max(128),
@@ -754,7 +768,21 @@ export const workbenchNodeOperationSchema = z.enum([
     'terminal.close',
     'terminal.attach.authorize',
     'node.upgrade.request',
-    'node.upgrade.cancel'
+    'node.upgrade.cancel',
+    'node.skills.inspect',
+    'node.skills.install',
+    'node.skills.remove',
+    'workspace.skills.inspect',
+    'workspace.skills.install',
+    'workspace.skills.remove',
+    'workspace.skills.git-exclude-repair',
+    'skill.install.job.get',
+    'node.mcps.inspect',
+    'node.mcps.install',
+    'node.mcps.remove',
+    'workspace.mcps.inspect',
+    'workspace.mcps.install',
+    'workspace.mcps.remove'
 ]);
 /**
  * A small, explicit envelope keeps WebSocket messages independently parseable
@@ -806,6 +834,19 @@ export const nodeErrorSchema = z.object({
         'TERMINAL_ATTACH_CONFLICT',
         'TERMINAL_REPLAY_GAP',
         'TERMINAL_DATA_CHANNEL_UNAVAILABLE',
+        'SKILL_TARGET_OFFLINE',
+        'SKILL_TARGET_LIMIT_EXCEEDED',
+        'SKILL_NAME_CONFLICT',
+        'SKILL_PATH_UNSAFE',
+        'SKILL_CONTENT_INVALID',
+        'SKILL_INSTALL_PARTIAL',
+        'SKILL_INSTALL_FAILED',
+        'SKILL_INSTALL_VERSION_UNKNOWN',
+        'SKILL_INSTALL_RECOVERY_REQUIRED',
+        'SKILL_INSTALL_INVALID_LINK',
+        'NODE_SKILL_LINK_UNAVAILABLE',
+        'WORKSPACE_SKILL_GIT_EXCLUDE_FAILED',
+        'WORKSPACE_SKILL_TRACKED_CONFIRM_REQUIRED',
         'INTERNAL_ERROR'
     ])
 });

package/dist/mcp.d.ts

@@ -0,0 +1,438 @@
+import { z } from 'zod';
+export declare const mcpSourceInputSchema: z.ZodEffects<z.ZodObject<{
+    scope: z.ZodEnum<["ENTERPRISE", "ORGANIZATION", "PERSONAL"]>;
+    organizationId: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodString;
+    locator: z.ZodEffects<z.ZodString, string, string>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    locator: string;
+    organizationId?: number | undefined;
+    enabled?: boolean | undefined;
+}, {
+    name: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    locator: string;
+    organizationId?: number | undefined;
+    enabled?: boolean | undefined;
+}>, {
+    name: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    locator: string;
+    organizationId?: number | undefined;
+    enabled?: boolean | undefined;
+}, {
+    name: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    locator: string;
+    organizationId?: number | undefined;
+    enabled?: boolean | undefined;
+}>;
+export type McpSourceInput = z.infer<typeof mcpSourceInputSchema>;
+export declare const mcpRuntimeDescriptorSchema: z.ZodDiscriminatedUnion<"transport", [z.ZodObject<{
+    transport: z.ZodLiteral<"STDIO">;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    environment: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        secretName: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        secretName: string;
+    }, {
+        secretName: string;
+    }>>>>;
+}, "strict", z.ZodTypeAny, {
+    transport: "STDIO";
+    command: string;
+    args: string[];
+    environment?: Record<string, {
+        secretName: string;
+    }> | undefined;
+}, {
+    transport: "STDIO";
+    command: string;
+    args?: string[] | undefined;
+    environment?: Record<string, {
+        secretName: string;
+    }> | undefined;
+}>, z.ZodObject<{
+    transport: z.ZodLiteral<"HTTP">;
+    url: z.ZodEffects<z.ZodString, string, string>;
+    headers: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        secretName: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        secretName: string;
+    }, {
+        secretName: string;
+    }>>>>;
+}, "strict", z.ZodTypeAny, {
+    transport: "HTTP";
+    url: string;
+    headers?: Record<string, {
+        secretName: string;
+    }> | undefined;
+}, {
+    transport: "HTTP";
+    url: string;
+    headers?: Record<string, {
+        secretName: string;
+    }> | undefined;
+}>]>;
+export type McpRuntimeDescriptor = z.infer<typeof mcpRuntimeDescriptorSchema>;
+export declare const mcpCatalogEntrySchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    scope: z.ZodEnum<["ENTERPRISE", "ORGANIZATION", "PERSONAL"]>;
+    ownerOrganizationId: z.ZodOptional<z.ZodNumber>;
+    ownerUserId: z.ZodOptional<z.ZodNumber>;
+    serverName: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodEffects<z.ZodString, string, string>;
+    featured: z.ZodBoolean;
+    tags: z.ZodArray<z.ZodString, "many">;
+    runtime: z.ZodDiscriminatedUnion<"transport", [z.ZodObject<{
+        transport: z.ZodLiteral<"STDIO">;
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        environment: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            secretName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            secretName: string;
+        }, {
+            secretName: string;
+        }>>>>;
+    }, "strict", z.ZodTypeAny, {
+        transport: "STDIO";
+        command: string;
+        args: string[];
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    }, {
+        transport: "STDIO";
+        command: string;
+        args?: string[] | undefined;
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    }>, z.ZodObject<{
+        transport: z.ZodLiteral<"HTTP">;
+        url: z.ZodEffects<z.ZodString, string, string>;
+        headers: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            secretName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            secretName: string;
+        }, {
+            secretName: string;
+        }>>>>;
+    }, "strict", z.ZodTypeAny, {
+        transport: "HTTP";
+        url: string;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    }, {
+        transport: "HTTP";
+        url: string;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    }>]>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    displayName: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    sourceId: string;
+    featured: boolean;
+    tags: string[];
+    description: string;
+    serverName: string;
+    version: string;
+    runtime: {
+        transport: "STDIO";
+        command: string;
+        args: string[];
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    } | {
+        transport: "HTTP";
+        url: string;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    };
+    ownerUserId?: number | undefined;
+    ownerOrganizationId?: number | undefined;
+}, {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    displayName: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    sourceId: string;
+    featured: boolean;
+    tags: string[];
+    description: string;
+    serverName: string;
+    version: string;
+    runtime: {
+        transport: "STDIO";
+        command: string;
+        args?: string[] | undefined;
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    } | {
+        transport: "HTTP";
+        url: string;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    };
+    ownerUserId?: number | undefined;
+    ownerOrganizationId?: number | undefined;
+}>, {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    displayName: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    sourceId: string;
+    featured: boolean;
+    tags: string[];
+    description: string;
+    serverName: string;
+    version: string;
+    runtime: {
+        transport: "STDIO";
+        command: string;
+        args: string[];
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    } | {
+        transport: "HTTP";
+        url: string;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    };
+    ownerUserId?: number | undefined;
+    ownerOrganizationId?: number | undefined;
+}, {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    displayName: string;
+    scope: "PERSONAL" | "ENTERPRISE" | "ORGANIZATION";
+    sourceId: string;
+    featured: boolean;
+    tags: string[];
+    description: string;
+    serverName: string;
+    version: string;
+    runtime: {
+        transport: "STDIO";
+        command: string;
+        args?: string[] | undefined;
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    } | {
+        transport: "HTTP";
+        url: string;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+    };
+    ownerUserId?: number | undefined;
+    ownerOrganizationId?: number | undefined;
+}>;
+export type McpCatalogEntry = z.infer<typeof mcpCatalogEntrySchema>;
+export declare const mcpInstallationConfigurationSchema: z.ZodObject<{
+    arguments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    environment: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        secretName: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        secretName: string;
+    }, {
+        secretName: string;
+    }>>>>;
+    headers: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        secretName: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        secretName: string;
+    }, {
+        secretName: string;
+    }>>>>;
+}, "strict", z.ZodTypeAny, {
+    environment?: Record<string, {
+        secretName: string;
+    }> | undefined;
+    headers?: Record<string, {
+        secretName: string;
+    }> | undefined;
+    arguments?: string[] | undefined;
+}, {
+    environment?: Record<string, {
+        secretName: string;
+    }> | undefined;
+    headers?: Record<string, {
+        secretName: string;
+    }> | undefined;
+    arguments?: string[] | undefined;
+}>;
+export type McpInstallationConfiguration = z.infer<typeof mcpInstallationConfigurationSchema>;
+export declare const mcpInstallationInputSchema: z.ZodObject<{
+    catalogEntryId: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    configuration: z.ZodDefault<z.ZodObject<{
+        arguments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        environment: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            secretName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            secretName: string;
+        }, {
+            secretName: string;
+        }>>>>;
+        headers: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            secretName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            secretName: string;
+        }, {
+            secretName: string;
+        }>>>>;
+    }, "strict", z.ZodTypeAny, {
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        arguments?: string[] | undefined;
+    }, {
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        arguments?: string[] | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    enabled: boolean;
+    catalogEntryId: string;
+    configuration: {
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        arguments?: string[] | undefined;
+    };
+}, {
+    catalogEntryId: string;
+    enabled?: boolean | undefined;
+    configuration?: {
+        environment?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        headers?: Record<string, {
+            secretName: string;
+        }> | undefined;
+        arguments?: string[] | undefined;
+    } | undefined;
+}>;
+export type McpInstallationInput = z.infer<typeof mcpInstallationInputSchema>;
+export declare const installedMcpSchema: z.ZodObject<{
+    catalogEntryId: z.ZodString;
+    serverName: z.ZodString;
+    displayName: z.ZodString;
+    version: z.ZodString;
+    origin: z.ZodEnum<["NODE", "WORKSPACE"]>;
+    enabled: z.ZodBoolean;
+    status: z.ZodEnum<["CURRENT", "UPDATE_AVAILABLE", "INVALID", "UNAVAILABLE"]>;
+    installedAt: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    status: "CURRENT" | "UPDATE_AVAILABLE" | "INVALID" | "UNAVAILABLE";
+    displayName: string;
+    enabled: boolean;
+    installedAt: number;
+    serverName: string;
+    version: string;
+    catalogEntryId: string;
+    origin: "NODE" | "WORKSPACE";
+}, {
+    status: "CURRENT" | "UPDATE_AVAILABLE" | "INVALID" | "UNAVAILABLE";
+    displayName: string;
+    enabled: boolean;
+    installedAt: number;
+    serverName: string;
+    version: string;
+    catalogEntryId: string;
+    origin: "NODE" | "WORKSPACE";
+}>;
+export declare const mcpTargetInspectionSchema: z.ZodObject<{
+    targetKind: z.ZodEnum<["NODE", "WORKSPACE"]>;
+    installations: z.ZodArray<z.ZodObject<{
+        catalogEntryId: z.ZodString;
+        serverName: z.ZodString;
+        displayName: z.ZodString;
+        version: z.ZodString;
+        origin: z.ZodEnum<["NODE", "WORKSPACE"]>;
+        enabled: z.ZodBoolean;
+        status: z.ZodEnum<["CURRENT", "UPDATE_AVAILABLE", "INVALID", "UNAVAILABLE"]>;
+        installedAt: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        status: "CURRENT" | "UPDATE_AVAILABLE" | "INVALID" | "UNAVAILABLE";
+        displayName: string;
+        enabled: boolean;
+        installedAt: number;
+        serverName: string;
+        version: string;
+        catalogEntryId: string;
+        origin: "NODE" | "WORKSPACE";
+    }, {
+        status: "CURRENT" | "UPDATE_AVAILABLE" | "INVALID" | "UNAVAILABLE";
+        displayName: string;
+        enabled: boolean;
+        installedAt: number;
+        serverName: string;
+        version: string;
+        catalogEntryId: string;
+        origin: "NODE" | "WORKSPACE";
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    targetKind: "NODE" | "WORKSPACE";
+    installations: {
+        status: "CURRENT" | "UPDATE_AVAILABLE" | "INVALID" | "UNAVAILABLE";
+        displayName: string;
+        enabled: boolean;
+        installedAt: number;
+        serverName: string;
+        version: string;
+        catalogEntryId: string;
+        origin: "NODE" | "WORKSPACE";
+    }[];
+}, {
+    targetKind: "NODE" | "WORKSPACE";
+    installations: {
+        status: "CURRENT" | "UPDATE_AVAILABLE" | "INVALID" | "UNAVAILABLE";
+        displayName: string;
+        enabled: boolean;
+        installedAt: number;
+        serverName: string;
+        version: string;
+        catalogEntryId: string;
+        origin: "NODE" | "WORKSPACE";
+    }[];
+}>;
+export type McpTargetInspection = z.infer<typeof mcpTargetInspectionSchema>;

package/dist/mcp.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { skillScopeSchema } from './skill.js';
+const httpsUrlSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(2048)
+    .refine((value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && url.username === '' && url.password === '';
+    }
+    catch {
+        return false;
+    }
+}, 'URL must use HTTPS without userinfo');
+const mcpNameSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(255)
+    .regex(/^[A-Za-z0-9._/-]+$/u);
+const environmentNameSchema = z.string().regex(/^[A-Z_][A-Z0-9_]*$/u);
+const secretReferenceSchema = z.object({ secretName: environmentNameSchema }).strict();
+const referenceMapSchema = z.record(environmentNameSchema, secretReferenceSchema).default({});
+const headerReferenceMapSchema = z
+    .record(z
+    .string()
+    .trim()
+    .min(1)
+    .max(128)
+    .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), secretReferenceSchema)
+    .default({});
+export const mcpSourceInputSchema = z
+    .object({
+    scope: skillScopeSchema,
+    organizationId: z.number().int().positive().optional(),
+    name: z.string().trim().min(1).max(128),
+    locator: httpsUrlSchema,
+    enabled: z.boolean().optional()
+})
+    .strict()
+    .superRefine((source, context) => {
+    if ((source.scope === 'ORGANIZATION') !== (source.organizationId !== undefined))
+        context.addIssue({ code: 'custom', message: 'organizationId must match scope' });
+});
+export const mcpRuntimeDescriptorSchema = z.discriminatedUnion('transport', [
+    z
+        .object({
+        transport: z.literal('STDIO'),
+        command: z
+            .string()
+            .trim()
+            .min(1)
+            .max(512)
+            .regex(/^[^\r\n\0]+$/u),
+        args: z
+            .array(z
+            .string()
+            .max(2048)
+            .regex(/^[^\0]*$/u))
+            .max(64)
+            .default([]),
+        environment: referenceMapSchema.optional()
+    })
+        .strict(),
+    z
+        .object({
+        transport: z.literal('HTTP'),
+        url: httpsUrlSchema,
+        headers: headerReferenceMapSchema.optional()
+    })
+        .strict()
+]);
+export const mcpCatalogEntrySchema = z
+    .object({
+    id: z.string().min(1).max(128),
+    sourceId: z.string().min(1).max(128),
+    scope: skillScopeSchema,
+    ownerOrganizationId: z.number().int().positive().optional(),
+    ownerUserId: z.number().int().positive().optional(),
+    serverName: mcpNameSchema,
+    displayName: z.string().trim().min(1).max(128),
+    description: z.string().max(4096),
+    version: z
+        .string()
+        .trim()
+        .min(1)
+        .max(255)
+        .refine((value) => value !== 'latest'),
+    featured: z.boolean(),
+    tags: z.array(z.string().trim().min(1).max(32)).max(10),
+    runtime: mcpRuntimeDescriptorSchema,
+    createdAt: z.number().int().nonnegative(),
+    updatedAt: z.number().int().nonnegative()
+})
+    .strict()
+    .superRefine((entry, context) => {
+    if ((entry.scope === 'ORGANIZATION') !== (entry.ownerOrganizationId !== undefined))
+        context.addIssue({ code: 'custom', message: 'organization owner must match scope' });
+    if ((entry.scope === 'PERSONAL') !== (entry.ownerUserId !== undefined))
+        context.addIssue({ code: 'custom', message: 'user owner must match scope' });
+});
+export const mcpInstallationConfigurationSchema = z
+    .object({
+    arguments: z
+        .array(z
+        .string()
+        .max(2048)
+        .regex(/^[^\0]*$/u))
+        .max(32)
+        .optional(),
+    environment: referenceMapSchema.optional(),
+    headers: headerReferenceMapSchema.optional()
+})
+    .strict();
+export const mcpInstallationInputSchema = z
+    .object({
+    catalogEntryId: z.string().min(1).max(128),
+    enabled: z.boolean().default(true),
+    configuration: mcpInstallationConfigurationSchema.default({})
+})
+    .strict();
+export const installedMcpSchema = z
+    .object({
+    catalogEntryId: z.string().min(1).max(128),
+    serverName: mcpNameSchema,
+    displayName: z.string().trim().min(1).max(128),
+    version: z.string().trim().min(1).max(255),
+    origin: z.enum(['NODE', 'WORKSPACE']),
+    enabled: z.boolean(),
+    status: z.enum(['CURRENT', 'UPDATE_AVAILABLE', 'INVALID', 'UNAVAILABLE']),
+    installedAt: z.number().int().nonnegative()
+})
+    .strict();
+export const mcpTargetInspectionSchema = z
+    .object({
+    targetKind: z.enum(['NODE', 'WORKSPACE']),
+    installations: z.array(installedMcpSchema).max(500)
+})
+    .strict();