@noimosai/platform-cli 0.1.3 → 0.1.4

package/dist/schema/platformTeamSkills.js

@@ -0,0 +1,302 @@
+import { z } from "zod";
+import { Document, isScalar, parseDocument, visit } from "yaml";
+import { projectScopeSchema } from "./platformPublicExecution.js";
+import { PLATFORM_CUSTOM_TOOL_LIMITS, platformVersionAuthorSchema } from "./platformCustomTools.js";
+import { PLATFORM_TEAM_SKILL_SLUG } from "./platformTeamSkillSlug.js";
+export { PLATFORM_TEAM_SKILL_SLUG } from "./platformTeamSkillSlug.js";
+export const PLATFORM_TEAM_SKILL_LIMITS = {
+    perProject: 200,
+    versions: 50,
+    titleChars: 80,
+    nameChars: 40,
+    descriptionChars: 1024,
+    contentBytes: 32_768,
+    frontmatterChars: 8_192,
+    markdownBytes: 65_536,
+    files: 200,
+    fileBytes: 5 * 1024 * 1024,
+    packageBytes: 10 * 1024 * 1024,
+    requestBytes: 20 * 1024 * 1024,
+};
+export const PLATFORM_TEAM_STORAGE_BYTES = 100_000_000;
+export const platformSkillStorageSchema = z.object({ usedBytes: z.number().int().nonnegative().safe(), limitBytes: z.number().int().positive().safe() });
+export const platformSkillPathSchema = z.string().min(1).max(260).refine(path => !/[\\\u0000-\u001f\u007f:]/u.test(path.normalize("NFKC")) && !path.startsWith("/") && path.normalize("NFKC").split("/").every(part => part && !/[. ]$/.test(part)
+    && ![".git", "node_modules", "__proto__", "constructor", "prototype"].includes(part.toLowerCase()) && !/^\.env(?:\.|$)/i.test(part)
+    && !/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part)), "Invalid relative skill file path");
+export const platformSkillFilePathSchema = platformSkillPathSchema.refine(path => path.normalize("NFKC").toLowerCase() !== "skill.md", "SKILL.md is the main skill content");
+export const platformSkillFileSchema = z.object({
+    path: platformSkillFilePathSchema,
+    data: z.string().max(Math.ceil(PLATFORM_TEAM_SKILL_LIMITS.fileBytes / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+    executable: z.boolean().optional(),
+}).strict();
+export const skillFileBytes = (file) => file.data.length / 4 * 3 - (file.data.endsWith("==") ? 2 : file.data.endsWith("=") ? 1 : 0);
+export const platformSkillFilesSchema = z.array(platformSkillFileSchema).max(PLATFORM_TEAM_SKILL_LIMITS.files).superRefine((files, context) => {
+    const names = new Set();
+    let bytes = 0;
+    for (const [index, file] of files.entries()) {
+        const name = file.path.normalize("NFKC").toLowerCase(), size = skillFileBytes(file);
+        if (names.has(name) || files.some(other => other !== file && other.path.normalize("NFKC").toLowerCase().startsWith(`${name}/`)))
+            context.addIssue({ code: "custom", path: [index, "path"], message: "Skill file paths collide" });
+        names.add(name);
+        bytes += size;
+        if (size > PLATFORM_TEAM_SKILL_LIMITS.fileBytes)
+            context.addIssue({ code: "custom", path: [index, "data"], message: "Skill file is too large" });
+    }
+    if (bytes > PLATFORM_TEAM_SKILL_LIMITS.packageBytes)
+        context.addIssue({ code: "custom", message: "Skill package is too large" });
+});
+export function readSkillMarkdown(source) {
+    const text = source.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+    let content = text, frontmatter = "", name, description, hasMetadata = false;
+    if (text.startsWith("---\n")) {
+        const match = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(text);
+        if (!match)
+            throw new Error("The SKILL.md frontmatter has no closing ---.");
+        frontmatter = match[1];
+        content = text.slice(match[0].length);
+        if (frontmatter.length > 8192)
+            throw new Error("The SKILL.md frontmatter is too large.");
+        const document = parseDocument(frontmatter, { uniqueKeys: true });
+        if (document.errors.length)
+            throw new Error("The SKILL.md frontmatter is not valid YAML.");
+        const fields = z.object({ name: z.string().optional(), description: z.string().optional() }).passthrough().parse(document.toJS({ maxAliasCount: 50 }));
+        name = fields.name;
+        description = fields.description?.trim();
+        hasMetadata = Object.keys(fields).some(key => key !== "name" && key !== "description");
+    }
+    content = content.trim();
+    const heading = /^#\s+(.+?)\s*#*\s*(?:\n|$)/.exec(content);
+    if (heading)
+        content = content.slice(heading[0].length).trim();
+    return { name, description, title: heading?.[1], content, frontmatter, hasMetadata };
+}
+function validSkillFrontmatter(value) {
+    if (!value.trim())
+        return true;
+    try {
+        readSkillMarkdown(`---\n${value}\n---\n`);
+    }
+    catch {
+        return false;
+    }
+    let indirect = false;
+    visit(parseDocument(value), { Alias() { indirect = true; return visit.BREAK; },
+        Pair(_, pair) { if (isScalar(pair.key) && pair.key.value === "<<") {
+            indirect = true;
+            return visit.BREAK;
+        } } });
+    return !indirect;
+}
+function frontmatterObject(frontmatter) {
+    const document = parseDocument(frontmatter || "", { merge: true, uniqueKeys: true });
+    if (document.errors.length)
+        throw new Error("The SKILL.md frontmatter is not valid YAML.");
+    const value = document.toJS({ maxAliasCount: 50 });
+    if (value === null || value === undefined)
+        return {};
+    return z.record(z.string(), z.unknown()).parse(value);
+}
+export const SKILL_EXECUTING_FIELDS = ["hooks", "allowed-tools", "allowedTools", "mcpServers"];
+export const SKILL_EXECUTING_FILES = ["mcp.json"];
+export const skillExecutingFiles = (files) => (files ?? []).filter(file => SKILL_EXECUTING_FILES.includes(file.path.toLowerCase()));
+export function omitFrontmatterFields(frontmatter, fields) {
+    const value = frontmatterObject(frontmatter);
+    const removed = fields.filter(field => Object.hasOwn(value, field));
+    if (!removed.length)
+        return { frontmatter, removed };
+    for (const field of removed)
+        delete value[field];
+    return { frontmatter: Object.keys(value).length ? new Document(value).toString() : "", removed };
+}
+export function restoreFrontmatterFields(local, stored, fields) {
+    const target = parseDocument(local);
+    if (target.errors.length)
+        throw new Error("The SKILL.md frontmatter is not valid YAML.");
+    const source = frontmatterObject(stored), present = frontmatterObject(local);
+    const restored = fields.filter(field => Object.hasOwn(source, field) && !Object.hasOwn(present, field));
+    for (const field of restored)
+        target.set(field, source[field]);
+    return restored.length ? target.toString() : local;
+}
+export function frontmatterValue(frontmatter, field) {
+    const value = frontmatterObject(frontmatter);
+    return Object.hasOwn(value, field) ? value[field] : undefined;
+}
+export function renderSkillMarkdown(skill, name) {
+    const document = parseDocument(skill.frontmatter || "");
+    if (document.errors.length)
+        throw new Error("The SKILL.md frontmatter is not valid YAML.");
+    if (name)
+        document.set("name", name);
+    document.set("description", skill.description);
+    return `---\n${document.toString()}---\n# ${skill.title}\n\n${skill.content}\n`;
+}
+export const PLATFORM_TEAM_SKILL_KINDS = ["instructions", "skill", "agent", "rule", "hook", "folder", "mcp_server", "permission"];
+export const platformTeamSkillKindSchema = z.enum(PLATFORM_TEAM_SKILL_KINDS);
+export const platformTeamSkillListKindSchema = z.enum([...PLATFORM_TEAM_SKILL_KINDS, "all"]);
+export const teamSkillKindHoldsFiles = (kind) => kind === "skill" || kind === "hook" || kind === "folder";
+export const teamSkillKindNeedsAdmin = (kind) => kind === "hook" || kind === "mcp_server" || kind === "permission";
+export const AGENT_EXECUTING_FIELDS = ["hooks", "mcpServers", "permissionMode"];
+export const teamItemExecutingFields = (kind) => kind === "skill" ? SKILL_EXECUTING_FIELDS : kind === "agent" ? AGENT_EXECUTING_FIELDS : [];
+export function teamItemNeedsAdmin(kind, definition) {
+    if (teamSkillKindNeedsAdmin(kind))
+        return true;
+    if (kind === "skill" && skillExecutingFiles(definition.files).length)
+        return true;
+    const fields = teamItemExecutingFields(kind), frontmatter = definition.frontmatter;
+    if (!fields.length || !frontmatter?.trim())
+        return false;
+    try {
+        return omitFrontmatterFields(frontmatter, fields).removed.length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+export const TEAM_HOOK_DIR_PLACEHOLDER = "${RELVO_HOOK_DIR}";
+export const TEAM_AGENT_PLACEHOLDER = "${RELVO_AGENT}";
+function readJsonContent(content, key, what) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        throw new Error(`${what} is JSON.`);
+    }
+    const wrapped = z.object({ [key]: z.unknown() }).strict().safeParse(value);
+    return wrapped.success ? wrapped.data[key] : value;
+}
+const hookHandlerSchema = z.object({ type: z.string().min(1) }).passthrough();
+const hookGroupSchema = z.object({ matcher: z.string().optional(), hooks: z.array(hookHandlerSchema).min(1) }).passthrough();
+export const platformTeamHookConfigSchema = z.record(z.string().regex(/^[A-Z][A-Za-z]{1,40}$/, "Hook events are names such as PreToolUse"), z.array(hookGroupSchema).min(1));
+export function readTeamHookConfig(content) {
+    const what = "A hook's content is a JSON object of events, as under \"hooks\" in settings.json";
+    const parsed = platformTeamHookConfigSchema.safeParse(readJsonContent(content, "hooks", what));
+    if (!parsed.success)
+        throw new Error(`${what}: ${parsed.error.issues[0]?.message ?? "invalid"}.`);
+    return parsed.data;
+}
+const environmentName = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,99}$/);
+export const platformTeamMcpServerSchema = z.union([
+    z.object({ type: z.literal("stdio").optional(), command: z.string().trim().min(1).max(500), args: z.array(z.string().max(2000)).max(100).optional(),
+        env: z.record(environmentName, z.string().max(2000)).optional() }).strict(),
+    z.object({ type: z.literal("http"), url: z.url({ protocol: /^https?$/ }).max(2000), headers: z.record(z.string().regex(/^[A-Za-z0-9-]{1,100}$/), z.string().max(2000)).optional(),
+        bearerTokenEnvVar: environmentName.optional() }).strict(),
+]);
+export function readTeamMcpServer(content) {
+    const what = "An MCP server's content is one server as in .mcp.json: {\"command\", \"args\", \"env\"} or {\"type\": \"http\", \"url\"}";
+    const parsed = platformTeamMcpServerSchema.safeParse(readJsonContent(content, "mcpServer", what));
+    if (!parsed.success)
+        throw new Error(`${what}: ${parsed.error.issues[0]?.message ?? "invalid"}.`);
+    return parsed.data;
+}
+const permissionRules = z.array(z.string().trim().min(1).max(500)).max(200).optional();
+export const platformTeamPermissionsSchema = z.object({ allow: permissionRules, ask: permissionRules, deny: permissionRules }).strict()
+    .refine(rules => Boolean(rules.allow?.length || rules.ask?.length || rules.deny?.length), "Name at least one rule");
+export function readTeamPermissions(content) {
+    const what = "Permission rules are JSON as under \"permissions\" in settings.json: {\"allow\", \"ask\", \"deny\"}";
+    const parsed = platformTeamPermissionsSchema.safeParse(readJsonContent(content, "permissions", what));
+    if (!parsed.success)
+        throw new Error(`${what}: ${parsed.error.issues[0]?.message ?? "invalid"}.`);
+    return parsed.data;
+}
+export const TEAM_HOOK_PLUGIN_HARNESSES = ["pi", "opencode", "amp"];
+export const TEAM_HOOK_NATIVE_FOLDER = "native";
+export function teamHookPluginHarnesses(files) {
+    const named = new Set();
+    for (const file of files ?? []) {
+        const [folder, harness, ...rest] = file.path.split("/");
+        if (folder !== TEAM_HOOK_NATIVE_FOLDER)
+            continue;
+        if (!rest.length || !TEAM_HOOK_PLUGIN_HARNESSES.some(name => name === harness))
+            return null;
+        named.add(harness);
+    }
+    return TEAM_HOOK_PLUGIN_HARNESSES.filter(name => named.has(name));
+}
+export function teamSkillKindIssues(kind, definition) {
+    const fields = [];
+    if (definition.files?.length && !teamSkillKindHoldsFiles(kind))
+        fields.push("files");
+    const reader = kind === "hook" ? readTeamHookConfig : kind === "mcp_server" ? readTeamMcpServer : kind === "permission" ? readTeamPermissions : undefined;
+    if (reader) {
+        try {
+            reader(definition.content);
+        }
+        catch {
+            fields.push("content");
+        }
+    }
+    if (kind === "hook") {
+        const plugins = teamHookPluginHarnesses(definition.files);
+        if (plugins === null)
+            fields.push("files");
+        else if (!plugins.length && !fields.includes("content") && !Object.keys(readTeamHookConfig(definition.content)).length)
+            fields.push("content");
+    }
+    return fields;
+}
+export const TEAM_HARNESSES = ["claude", "codex", "pi", "dsh", "opencode", "gemini", "kimi", "qwen", "cursor", "copilot", "amp", "droid"];
+export const teamHarnessSchema = z.enum(TEAM_HARNESSES);
+export const TEAM_HARNESS_NAMES = { claude: "Claude Code", codex: "Codex", pi: "Pi", dsh: "deepseek-harness", opencode: "OpenCode",
+    gemini: "Gemini CLI", kimi: "Kimi Code", qwen: "Qwen Code", cursor: "Cursor", copilot: "GitHub Copilot CLI", amp: "Amp", droid: "Factory Droid" };
+export const platformTeamHarnessesSchema = z.array(z.enum(["all", ...TEAM_HARNESSES])).max(TEAM_HARNESSES.length + 1)
+    .describe("The coding agents to write this item for when members sync: all (the default), or names such as claude, codex, gemini. On update, [] keeps the current choice.");
+export const storedTeamHarnesses = (requested) => requested.includes("all") ? []
+    : TEAM_HARNESSES.filter(harness => requested.includes(harness));
+export const teamItemTargets = (harnesses, harness) => !harnesses?.length || harnesses.includes(harness);
+export const platformTeamSkillSlugSchema = z.string().regex(PLATFORM_TEAM_SKILL_SLUG).describe("Lowercase letters, digits and underscores, starting with a letter.");
+export const platformTeamItemNameSchema = z.string().trim().min(1).max(PLATFORM_TEAM_SKILL_LIMITS.nameChars).regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/)
+    .describe("The user-chosen name in coding agents and ZIP downloads. Lowercase letters, digits and single hyphens, starting with a letter.");
+const optionalItemName = z.union([platformTeamItemNameSchema, z.literal("")]).optional().transform(value => value || undefined);
+export const teamItemName = (item) => item.name ?? item.slug.replaceAll("_", "-");
+export const teamItemInstallName = (item) => `relvo-team-${teamItemName(item)}`;
+export const platformTeamSkillDefinitionSchema = z.object({
+    title: z.string().trim().min(1).max(PLATFORM_TEAM_SKILL_LIMITS.titleChars),
+    description: z.string().trim().min(1).max(PLATFORM_TEAM_SKILL_LIMITS.descriptionChars).describe("When an agent should follow this skill; agents choose skills by it."),
+    content: z.string().trim().min(1).max(PLATFORM_TEAM_SKILL_LIMITS.contentBytes).refine(value => new TextEncoder().encode(value).byteLength <= PLATFORM_TEAM_SKILL_LIMITS.contentBytes, "The content is too long")
+        .describe("Markdown: the steps, the tools to use (by name) and what to check. No secrets."),
+    files: platformSkillFilesSchema.optional(),
+    frontmatter: z.string().max(PLATFORM_TEAM_SKILL_LIMITS.frontmatterChars).refine(validSkillFrontmatter, "Invalid skill YAML metadata").optional(),
+}).strict();
+export const platformTeamSkillCreateSchema = platformTeamSkillDefinitionSchema.extend({ slug: platformTeamSkillSlugSchema, name: optionalItemName,
+    kind: platformTeamSkillKindSchema.optional().describe("skill (the default): steps an agent follows when a task fits; agent: a subagent's instructions, " +
+        "with description saying when to delegate to it; instructions: shared base instructions in AGENTS.md or CLAUDE.md; rule: additional, optionally path-scoped rules; folder: shared files, content saying what they are; " +
+        "hook, mcp_server, permission: JSON content, written only by team admins in the console. Only a skill, hook or folder holds files."),
+    harnesses: platformTeamHarnessesSchema.optional() }).strict();
+export const platformTeamSkillUpdateSchema = platformTeamSkillDefinitionSchema.extend({ expectedVersion: z.number().int().min(1), name: optionalItemName, harnesses: platformTeamHarnessesSchema.optional() }).strict();
+export const platformTeamSkillRestoreSchema = z.object({ version: z.number().int().min(1), expectedVersion: z.number().int().min(1) }).strict();
+export const platformTeamSkillSchema = z.object({ slug: platformTeamSkillSlugSchema, name: platformTeamItemNameSchema.optional(), kind: platformTeamSkillKindSchema.default("skill"),
+    adminOnly: z.boolean().default(false),
+    harnesses: z.array(teamHarnessSchema).default([]), title: z.string(), description: z.string(), content: z.string(),
+    files: platformSkillFilesSchema.optional(), frontmatter: z.string().optional(),
+    version: z.number().int().min(1), createdAt: z.string(), updatedAt: z.string() });
+export const platformTeamSkillSummarySchema = platformTeamSkillSchema.omit({ content: true, files: true, frontmatter: true });
+export const platformTeamSkillVersionSchema = z.object({ version: z.number().int().min(1), title: z.string(), createdAt: z.string() });
+export const platformSuggestionSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("custom_tool"), occurrences: z.number().int().min(2), lastSeenAt: z.string(),
+        executions: z.array(z.string()).min(1).max(3),
+        code: z.string().min(1).max(PLATFORM_CUSTOM_TOOL_LIMITS.codeChars) }),
+    z.object({ kind: z.literal("skill"), occurrences: z.number().int().min(2), lastSeenAt: z.string(), tools: z.array(z.string()).min(2).max(3) }),
+]);
+export const platformSuggestionsSchema = z.object({ suggestions: z.array(platformSuggestionSchema).max(20), since: z.string() });
+export const platformTeamSkillHistorySchema = platformTeamSkillVersionSchema.extend({ author: platformVersionAuthorSchema });
+export const platformTeamSkillVersionDetailSchema = platformTeamSkillSchema.pick({ title: true, description: true, content: true, files: true, frontmatter: true })
+    .extend({ version: z.number().int().min(1), createdAt: z.string(), author: platformVersionAuthorSchema });
+const skillInput = projectScopeSchema.extend({ slug: platformTeamSkillSlugSchema });
+const skillResult = z.object({ skill: platformTeamSkillSchema }).strict();
+export const platformTeamSkillContracts = {
+    listDeveloperTeamSkills: { input: projectScopeSchema.strict(), output: z.object({ skills: z.array(platformTeamSkillSummarySchema.extend({ canEdit: z.boolean(), canDelete: z.boolean() })),
+            canCreate: z.boolean(), canCreateAdminKinds: z.boolean().optional(),
+            storage: platformSkillStorageSchema.optional() }).strict() },
+    getDeveloperTeamSkill: { input: skillInput.strict(), output: skillResult },
+    getDeveloperTeamSkillAccess: { input: skillInput.strict(), output: z.object({ members: z.array(z.object({ memberId: z.string(), email: z.string(), name: z.string().nullable(),
+                image: z.string().nullish(), canRead: z.boolean(), canEdit: z.boolean(), canDelete: z.boolean() }).strict()) }).strict() },
+    createDeveloperTeamSkill: { input: projectScopeSchema.extend({ skill: platformTeamSkillCreateSchema }).strict(), output: skillResult },
+    updateDeveloperTeamSkill: { input: skillInput.extend({ skill: platformTeamSkillUpdateSchema }).strict(), output: skillResult },
+    restoreDeveloperTeamSkill: { input: skillInput.merge(platformTeamSkillRestoreSchema).strict(), output: skillResult },
+    deleteDeveloperTeamSkill: { input: skillInput.strict(), output: z.object({ success: z.literal(true) }).strict() },
+    listDeveloperTeamSkillVersions: { input: skillInput.strict(), output: z.object({ versions: z.array(platformTeamSkillHistorySchema) }).strict() },
+    getDeveloperTeamSkillVersion: { input: skillInput.extend({ version: z.number().int().min(1) }).strict(), output: z.object({ version: platformTeamSkillVersionDetailSchema }).strict() },
+    listDeveloperSuggestions: { input: projectScopeSchema.strict(), output: platformSuggestionsSchema },
+};

package/dist/schema/platformToolAccess.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { platformCustomToolNameSchema } from "./platformCustomTools.js";
+import { PLATFORM_TEAM_SECRET_NAME } from "./platformTeamSecretName.js";
+import { PLATFORM_TEAM_SKILL_SLUG } from "./platformTeamSkillSlug.js";
+import { platformToolNameSchema } from "./platformPublicExecution.js";
+const connectionId = z.string().regex(/^[A-Za-z0-9-]{1,64}$/), projectId = connectionId;
+export const platformConnectionGrantSchema = z.templateLiteral(["connection:", connectionId]);
+export const platformConnectionOperationGrantSchema = z.templateLiteral(["connection:", connectionId, "/", z.string().regex(/^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/)]);
+export const platformSkillGrantSchema = z.templateLiteral(["skill:", projectId, "/", z.string().regex(PLATFORM_TEAM_SKILL_SLUG)]);
+export const platformSecretGrantSchema = z.templateLiteral(["secret:", projectId, "/", z.string().regex(PLATFORM_TEAM_SECRET_NAME)]);
+export const memberToolAccessSchema = z.array(z.union([platformCustomToolNameSchema, platformConnectionGrantSchema, platformConnectionOperationGrantSchema,
+    platformSkillGrantSchema, platformSecretGrantSchema])).max(20_000).nullable();
+export const keyToolAccessSchema = memberToolAccessSchema;
+export const platformTeamAccessSchema = z.object({
+    members: z.array(z.object({ memberId: z.string(), email: z.string(), name: z.string().nullable(), role: z.string(), toolAccess: memberToolAccessSchema }).loose()),
+    invitations: z.array(z.object({ id: z.string(), email: z.string(), role: z.string(), expiresAt: z.string(), toolAccess: memberToolAccessSchema }).loose()),
+});
+export const platformMemberAccessUpdateSchema = z.object({ toolAccess: memberToolAccessSchema }).strict();
+export const platformTeamQuerySchema = z.object({
+    memberOffset: z.coerce.number().int().min(0).max(100_000).default(0),
+    invitationOffset: z.coerce.number().int().min(0).max(100_000).default(0),
+    limit: z.coerce.number().int().min(1).max(100).default(10),
+}).strict();
+const teamRole = z.enum(["OWNER", "ADMIN", "EDITOR", "BILLING", "MEMBER"]);
+const rosterMember = z.object({ memberId: z.string(), email: z.string(), name: z.string().nullable(), role: teamRole });
+const rosterInvitation = z.object({ id: z.string(), email: z.string(), role: teamRole, expiresAt: z.string() });
+export const platformTeamContextSchema = z.object({
+    team: z.object({ id: z.string(), name: z.string() }),
+    project: z.object({ id: z.string(), name: z.string(), role: z.enum(["ADMIN", "DEVELOPER", "VIEWER"]) }),
+    member: rosterMember,
+    scopes: z.array(z.string()),
+    canListMembers: z.boolean(),
+    members: z.object({ items: z.array(rosterMember), nextOffset: z.number().int().nonnegative().nullable() }).nullable(),
+    invitations: z.object({ items: z.array(rosterInvitation), nextOffset: z.number().int().nonnegative().nullable() }).nullable(),
+});
+export const memberTeamSkillAccessSchema = z.enum(["EDIT", "OWN", "READ"]);
+export const platformProjectRoleSchema = z.enum(["ADMIN", "DEVELOPER", "VIEWER"]);
+export const PLATFORM_REALTIME_VOICE_TOOL = "realtime_voice";
+export const projectPermissionPolicySchema = z.object({
+    tools: z.array(platformToolNameSchema).max(20_000).nullable(),
+    teamSkillAccess: memberTeamSkillAccessSchema,
+}).strict();
+export function projectPermissionPolicy(set) {
+    return set ? { tools: set.toolExecutionRestricted ? set.toolExecution : null, teamSkillAccess: set.teamSkillAccess } : null;
+}
+export function projectSkillAccess(member) {
+    const existing = member.role === "OWNER" || member.role === "ADMIN" ? "EDIT" : member.teamSkillAccess;
+    const cap = member.projectPolicy?.teamSkillAccess;
+    return !cap ? existing : existing === "READ" || cap === "READ" ? "READ" : existing === "OWN" || cap === "OWN" ? "OWN" : "EDIT";
+}
+export const projectPermissionSetDefinitionSchema = projectPermissionPolicySchema.extend({
+    name: z.string().trim().min(1).max(100), role: platformProjectRoleSchema,
+});
+export const projectPermissionSetSchema = projectPermissionSetDefinitionSchema.extend({
+    id: z.string(), version: z.number().int().positive(), archivedAt: z.string().nullable(),
+});
+export const projectPermissionSetRefSchema = projectPermissionSetSchema.pick({ id: true, name: true, version: true });
+export const projectAssignmentSchema = z.object({
+    projectId: z.string().min(1).max(128), role: platformProjectRoleSchema, permissionSetId: z.string().min(1).max(128).nullable().optional(),
+}).strict();
+export const projectAssignmentsSchema = z.array(projectAssignmentSchema).min(1).max(100)
+    .refine(assignments => new Set(assignments.map(assignment => assignment.projectId)).size === assignments.length);

package/dist/schema/platformTriggers.js

@@ -0,0 +1,153 @@
+import { z } from "zod";
+import { projectScopeSchema, platformJsonObjectSchema, platformMicrosSchema, PLATFORM_SEARCH_MAX_LENGTH } from "./platformPublicExecution.js";
+import { platformMonitorDestinationInputSchema, platformMonitorDestinationSchema, platformMonitorRecipientSchema, PLATFORM_MONITOR_DESTINATION_LIMITS } from "./platformMonitors.js";
+import { platformWorkflowSlugSchema } from "./platformWorkflows.js";
+import { PLATFORM_FREE_TOOL_OVERAGE_MICROS } from "./platformBillingConstants.js";
+export const PLATFORM_TRIGGER_LIMITS = {
+    perProject: 50,
+    perTeam: 100,
+    nameChars: 80,
+    budgetChars: 16,
+    eventsPage: 100,
+    eventDataBytes: 65_536,
+    ingressBodyBytes: 1_048_576,
+    retentionDays: 30,
+    keptEvents: 10_000,
+    eventsPerBatch: 100,
+    typesPage: 100,
+};
+export const PLATFORM_TRIGGER_INTERVALS = { "1m": 60, "5m": 300, "15m": 900, "1h": 3_600 };
+export const platformTriggerIntervalSchema = z.enum(["1m", "5m", "15m", "1h"]);
+export const PLATFORM_TRIGGER_DEFAULT_MAXIMUM_CHARGE_MICROS_PER_POLL = PLATFORM_FREE_TOOL_OVERAGE_MICROS;
+export const PLATFORM_TRIGGER_ID = /^trg_[A-Za-z0-9_-]{1,100}$/;
+export const platformTriggerIdSchema = z.string().regex(PLATFORM_TRIGGER_ID);
+export const PLATFORM_TRIGGER_TYPE = /^[a-z0-9][a-z0-9_]{0,63}\.[A-Za-z0-9][A-Za-z0-9_.:]{0,79}$/;
+export const platformTriggerTypeIdSchema = z.string().regex(PLATFORM_TRIGGER_TYPE);
+const toolName = z.string().regex(/^[a-z][a-z0-9_]{1,127}$/);
+const connectionId = z.string().min(1).max(128);
+const pointer = z.string().max(200).regex(/^(\/[^/]*)*$/);
+export const platformTriggerDestinationKindSchema = z.enum(["webhook", "slack", "discord", "email", "workflow"]);
+const workflowDestination = z.object({
+    kind: z.literal("workflow"),
+    label: z.string().trim().max(PLATFORM_MONITOR_DESTINATION_LIMITS.labelChars).default(""),
+    workflow: platformWorkflowSlugSchema,
+    input: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,63}$/).default("event").describe("The workflow input that receives the event object."),
+    maximumChargeMicros: platformMicrosSchema,
+}).strict();
+export const platformTriggerDestinationInputSchema = z.union([platformMonitorDestinationInputSchema, workflowDestination]);
+export const platformTriggerDestinationSchema = platformMonitorDestinationSchema.extend({
+    kind: platformTriggerDestinationKindSchema,
+    workflow: z.object({ slug: platformWorkflowSlugSchema, input: z.string(), maximumChargeMicros: platformMicrosSchema }).nullable().default(null),
+});
+const common = {
+    name: z.string().trim().max(PLATFORM_TRIGGER_LIMITS.nameChars).default("").describe("Empty names the trigger after its type or operation."),
+    connectionId: connectionId.describe("The connection of the app, from /tools/connections."),
+    destinations: z.array(platformTriggerDestinationInputSchema).max(PLATFORM_MONITOR_DESTINATION_LIMITS.perMonitor).default([]),
+};
+export const platformTriggerCreateSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("poll"),
+        tool: toolName.describe("A read operation of the connected app, for example github__issues_list_for_repo."),
+        arguments: platformJsonObjectSchema.default({}).describe("The operation's arguments without connectionId."),
+        interval: platformTriggerIntervalSchema.default("5m"),
+        itemsPath: pointer.optional().describe("Where the list of items is in the response body. Omit to use the largest list."),
+        maximumChargeMicrosPerPoll: platformMicrosSchema.default(PLATFORM_TRIGGER_DEFAULT_MAXIMUM_CHARGE_MICROS_PER_POLL),
+        ...common,
+    }).strict(),
+    z.object({
+        kind: z.literal("webhook"),
+        type: platformTriggerTypeIdSchema.describe("A trigger type from /trigger-types, for example github.push."),
+        config: platformJsonObjectSchema.default({}).describe("The type's settings, valid against its configSchema."),
+        ...common,
+    }).strict(),
+]);
+export const platformTriggerUpdateSchema = z.object({
+    enabled: z.boolean().optional(),
+    name: z.string().trim().max(PLATFORM_TRIGGER_LIMITS.nameChars).optional().describe("Empty or omitted keeps the name."),
+}).strict();
+export const platformTriggerStatusSchema = z.enum(["active", "disabled", "failed"]);
+export const platformTriggerSchema = z.object({
+    id: platformTriggerIdSchema,
+    name: z.string(),
+    kind: z.enum(["poll", "webhook"]),
+    app: z.string(),
+    connectionId: z.string(),
+    status: platformTriggerStatusSchema,
+    statusReason: z.string().nullable(),
+    tool: z.string().nullable(),
+    arguments: platformJsonObjectSchema.nullable(),
+    interval: platformTriggerIntervalSchema.nullable(),
+    itemsPath: z.string().nullable(),
+    maximumChargeMicrosPerPoll: platformMicrosSchema.nullable(),
+    type: z.string().nullable(),
+    config: platformJsonObjectSchema.nullable(),
+    apiKeyId: z.string(),
+    lastCheckedAt: z.string().nullable(),
+    lastEventAt: z.string().nullable(),
+    nextCheckAt: z.string().nullable(),
+    lastError: z.string().nullable(),
+    createdAt: z.string(),
+    destinations: z.array(platformTriggerDestinationSchema),
+});
+export const platformTriggerEventSchema = z.object({
+    id: z.string().regex(/^\d{1,20}$/),
+    triggerId: platformTriggerIdSchema,
+    type: z.string(),
+    key: z.string(),
+    title: z.string(),
+    url: z.string(),
+    data: platformJsonObjectSchema,
+    receivedAt: z.string(),
+});
+export const platformTriggerEventsQuerySchema = z.object({
+    after: z.string().regex(/^\d{1,20}$/).optional(),
+    limit: z.coerce.number().int().min(1).max(PLATFORM_TRIGGER_LIMITS.eventsPage).default(50),
+}).strict();
+export const platformTriggerEventsSchema = z.object({ events: z.array(platformTriggerEventSchema), nextAfter: z.string().nullable() });
+export const platformTriggerTypeSchema = z.object({
+    type: platformTriggerTypeIdSchema,
+    app: z.string(),
+    name: z.string(),
+    description: z.string(),
+    configSchema: platformJsonObjectSchema,
+    setup: z.enum(["automatic", "app"]),
+    available: z.boolean(),
+    unavailableReason: z.string().nullable(),
+});
+export const platformTriggerOperationSchema = z.object({ tool: toolName, app: z.string(), description: z.string(), inputSchema: platformJsonObjectSchema });
+export const platformTriggerTypesQuerySchema = z.object({
+    app: z.string().regex(/^[a-z0-9][a-z0-9_]{0,63}$/),
+    connectionId: z.string().max(128).optional(),
+    query: z.string().trim().max(PLATFORM_SEARCH_MAX_LENGTH).default(""),
+    offset: z.coerce.number().int().min(0).max(100_000).default(0),
+    limit: z.coerce.number().int().min(1).max(PLATFORM_TRIGGER_LIMITS.typesPage).default(50),
+}).strict();
+export const platformTriggerTypesSchema = z.object({
+    types: z.array(platformTriggerTypeSchema),
+    operations: z.array(platformTriggerOperationSchema),
+    total: z.number().int().min(0),
+});
+export const platformTriggerDeliverySchema = z.object({
+    version: z.literal(1),
+    type: z.literal("trigger.event"),
+    deliveryId: z.string(),
+    trigger: z.object({ id: platformTriggerIdSchema, name: z.string(), kind: z.enum(["poll", "webhook"]), app: z.string(), source: z.string(), connectionId: z.string() }).strict(),
+    event: platformTriggerEventSchema.omit({ triggerId: true }),
+}).strict();
+const projectTrigger = projectScopeSchema.extend({ triggerId: platformTriggerIdSchema });
+export const platformTriggerContracts = {
+    listDeveloperTriggers: { input: projectScopeSchema.strict(), output: z.object({ triggers: z.array(platformTriggerSchema) }).strict() },
+    createDeveloperTrigger: { input: projectScopeSchema.extend({ apiKeyId: z.string().min(1).max(128), trigger: platformTriggerCreateSchema }).strict(),
+        output: z.object({ trigger: platformTriggerSchema }).strict() },
+    updateDeveloperTrigger: { input: projectTrigger.merge(platformTriggerUpdateSchema).strict(), output: z.object({ trigger: platformTriggerSchema }).strict() },
+    deleteDeveloperTrigger: { input: projectTrigger.strict(), output: z.object({ success: z.literal(true) }).strict() },
+    listDeveloperTriggerEvents: {
+        input: projectScopeSchema.extend({ triggerId: platformTriggerIdSchema.optional(), after: platformTriggerEventsQuerySchema.shape.after,
+            limit: z.number().int().min(1).max(PLATFORM_TRIGGER_LIMITS.eventsPage).default(50) }).strict(),
+        output: platformTriggerEventsSchema,
+    },
+    listDeveloperTriggerTypes: { input: projectScopeSchema.merge(platformTriggerTypesQuerySchema).strict(), output: platformTriggerTypesSchema },
+    addDeveloperTriggerDestination: { input: projectTrigger.extend({ destination: platformTriggerDestinationInputSchema }).strict(), output: z.object({ trigger: platformTriggerSchema }).strict() },
+    removeDeveloperTriggerDestination: { input: projectTrigger.extend({ destinationId: platformTriggerDestinationSchema.shape.id }).strict(), output: z.object({ trigger: platformTriggerSchema }).strict() },
+    listDeveloperTriggerRecipients: { input: projectScopeSchema.strict(), output: z.object({ recipients: z.array(platformMonitorRecipientSchema) }).strict() },
+};

package/dist/schema/platformWorkflows.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { platformExecutionIdSchema, platformJsonObjectSchema, platformMicrosSchema, platformProviderChoiceSchema, platformToolNameSchema } from "./platformPublicExecution.js";
+import { platformCustomToolInputSchemaSchema } from "./platformCustomTools.js";
+export const PLATFORM_WORKFLOW_LIMITS = {
+    perProject: 50,
+    steps: 20,
+    versions: 50,
+    activeRunsPerProject: 10,
+    titleChars: 80,
+    descriptionChars: 1_000,
+    stepsBytes: 32_768,
+    inputBytes: 16_384,
+};
+export const PLATFORM_WORKFLOW_SLUG = /^[a-z][a-z0-9_]{1,39}$/;
+export const platformWorkflowSlugSchema = z.string().regex(PLATFORM_WORKFLOW_SLUG).describe("Lowercase letters, digits and underscores, starting with a letter.");
+export const platformWorkflowStepIdSchema = z.string().regex(/^[a-z][a-z0-9_]{0,39}$/);
+export const platformWorkflowRunIdSchema = z.string().regex(/^wfr_[A-Za-z0-9_-]{1,100}$/);
+const pointerSchema = z.string().max(500).regex(/^(?:\/(?:[^~/]|~[01])*)*$/, "A JSON Pointer such as /data/companies/0/name");
+const referenceSchema = z.union([z.object({ $input: z.string(), path: z.string().optional() }).strict(), z.object({ $step: z.string(), path: z.string().optional() }).strict()]);
+export function platformWorkflowReference(value) {
+    const parsed = referenceSchema.safeParse(value);
+    if (!parsed.success)
+        return undefined;
+    const path = parsed.data.path ?? "";
+    return "$input" in parsed.data ? { kind: "input", name: parsed.data.$input, path } : { kind: "step", step: parsed.data.$step, path };
+}
+export function platformWorkflowReferences(value) {
+    const reference = platformWorkflowReference(value);
+    if (reference)
+        return [reference];
+    if (Array.isArray(value))
+        return value.flatMap(platformWorkflowReferences);
+    if (value !== null && typeof value === "object")
+        return Object.values(value).flatMap(platformWorkflowReferences);
+    return [];
+}
+export const platformWorkflowStepSchema = z.object({
+    id: platformWorkflowStepIdSchema.describe("Names the step for later steps' references: lowercase letters, digits and underscores."),
+    tool: platformToolNameSchema.describe("A tool of the project's catalog."),
+    arguments: platformJsonObjectSchema.describe("The tool's arguments. Write {\"$input\":\"name\"} for a run input or {\"$step\":\"id\",\"path\":\"/data/0/url\"} for a value of an earlier step's output."),
+    provider: platformProviderChoiceSchema,
+}).strict();
+const byteLength = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+const inputNames = (inputSchema) => {
+    const properties = inputSchema.properties;
+    return new Set(properties !== null && typeof properties === "object" && !Array.isArray(properties) ? Object.keys(properties) : []);
+};
+const definitionShape = {
+    title: z.string().trim().min(1).max(PLATFORM_WORKFLOW_LIMITS.titleChars),
+    description: z.string().trim().min(1).max(PLATFORM_WORKFLOW_LIMITS.descriptionChars).describe("What the workflow does and returns; agents choose workflows by it."),
+    inputSchema: platformCustomToolInputSchemaSchema.describe("JSON Schema of the run inputs, e.g. {\"type\":\"object\",\"properties\":{\"domain\":{\"type\":\"string\"}},\"required\":[\"domain\"]}."),
+    steps: z.array(platformWorkflowStepSchema).min(1).max(PLATFORM_WORKFLOW_LIMITS.steps).describe("Tool calls in the order they run; each starts after the previous one succeeded."),
+};
+function checkDefinition(definition, context) {
+    if (byteLength(definition.steps) > PLATFORM_WORKFLOW_LIMITS.stepsBytes)
+        context.addIssue({ code: "custom", path: ["steps"], message: "The steps are too large" });
+    const inputs = inputNames(definition.inputSchema), earlier = new Set();
+    definition.steps.forEach((step, index) => {
+        if (earlier.has(step.id))
+            context.addIssue({ code: "custom", path: ["steps", index, "id"], message: "Each step id is used once" });
+        for (const reference of platformWorkflowReferences(step.arguments)) {
+            if (!pointerSchema.safeParse(reference.path).success)
+                context.addIssue({ code: "custom", path: ["steps", index, "arguments"], message: `Invalid path ${reference.path}` });
+            else if (reference.kind === "input" && !inputs.has(reference.name))
+                context.addIssue({ code: "custom", path: ["steps", index, "arguments"], message: `No input named ${reference.name}` });
+            else if (reference.kind === "step" && !earlier.has(reference.step))
+                context.addIssue({ code: "custom", path: ["steps", index, "arguments"], message: `No earlier step named ${reference.step}` });
+        }
+        earlier.add(step.id);
+    });
+}
+export const platformWorkflowDefinitionSchema = z.object(definitionShape).strict().superRefine(checkDefinition);
+export const platformWorkflowCreateSchema = z.object({ ...definitionShape, slug: platformWorkflowSlugSchema }).strict().superRefine(checkDefinition);
+export const platformWorkflowUpdateSchema = z.object({ ...definitionShape, expectedVersion: z.number().int().min(1) }).strict().superRefine(checkDefinition);
+export const platformWorkflowSchema = z.object({ slug: platformWorkflowSlugSchema, title: z.string(), description: z.string(), inputSchema: platformJsonObjectSchema,
+    steps: z.array(platformWorkflowStepSchema), version: z.number().int().min(1), createdAt: z.string(), updatedAt: z.string() });
+export const platformWorkflowSummarySchema = platformWorkflowSchema.omit({ inputSchema: true, steps: true });
+export const platformWorkflowVersionSchema = z.object({ version: z.number().int().min(1), title: z.string(), createdAt: z.string() });
+export const platformWorkflowRunCreateSchema = z.object({
+    inputs: platformJsonObjectSchema.default({}).refine(value => byteLength(value) <= PLATFORM_WORKFLOW_LIMITS.inputBytes, "The inputs are too large")
+        .describe("Values for the workflow's input schema."),
+    maximumChargeMicros: platformMicrosSchema.describe("The most the whole run may charge, in micros of USD. A step whose price no longer fits stops the run before it is bought."),
+    version: z.number().int().min(1).optional().describe("Run an earlier kept version; omit for the current one."),
+}).strict();
+export const platformWorkflowRunStatusSchema = z.enum(["running", "succeeded", "failed", "needs_review", "cancelled"]);
+export const platformWorkflowRunStepSchema = z.object({
+    id: platformWorkflowStepIdSchema, tool: platformToolNameSchema,
+    status: z.enum(["pending", "queued", "running", "waiting", "succeeded", "failed", "cancelled", "needs_review"]),
+    executionId: platformExecutionIdSchema.nullable(), chargedMicros: platformMicrosSchema, errorCode: z.string().nullable(),
+}).strict();
+export const platformWorkflowRunSchema = z.object({
+    id: platformWorkflowRunIdSchema, workflow: platformWorkflowSlugSchema, version: z.number().int().min(1), status: platformWorkflowRunStatusSchema,
+    cancelRequested: z.boolean(), errorCode: z.string().nullable(), inputs: platformJsonObjectSchema,
+    maximumChargeMicros: platformMicrosSchema, chargedMicros: platformMicrosSchema, steps: z.array(platformWorkflowRunStepSchema),
+    resultExecutionId: platformExecutionIdSchema.nullable(),
+    createdAt: z.string(), updatedAt: z.string(), completedAt: z.string().nullable(),
+}).strict();
+export const platformWorkflowRunSummarySchema = platformWorkflowRunSchema.omit({ inputs: true, steps: true });
+export const platformWorkflowRunListQuerySchema = z.object({ before: platformWorkflowRunIdSchema.optional(), limit: z.coerce.number().int().min(1).max(50).default(20) }).strict();
+export const platformWorkflowRunListSchema = z.object({ runs: z.array(platformWorkflowRunSummarySchema), nextBefore: platformWorkflowRunIdSchema.nullable() }).strict();

package/dist/schema/scheduleTimeZone.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export function isScheduleTimeZone(value) {
+    if (!/^[A-Za-z][A-Za-z0-9_+-]*(\/[A-Za-z0-9_+-]+)*$/.test(value))
+        return false;
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: value });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const ScheduleTimeZone = z.string().max(64)
+    .refine(isScheduleTimeZone, "Invalid time zone (must be an IANA tz-database name).")
+    .transform(value => new Intl.DateTimeFormat("en-US", { timeZone: value }).resolvedOptions().timeZone);