@alpic-ai/api 0.0.0-staging.79eb8bf → 0.0.0-staging.7a9191a

package/dist/index.mjs

@@ -1,6 +1,408 @@
-import { oc } from "@orpc/contract";
 import { z } from "zod";
+import { oc } from "@orpc/contract";
+import ms from "ms";
+const platformSchema = z.enum(["chatgpt", "claudeai"]);
+const PLATFORM_LABELS = {
+	chatgpt: "ChatGPT",
+	claudeai: "Claude.ai"
+};
+const auditStatusSchema = z.enum([
+	"pending",
+	"partial",
+	"completed",
+	"failed"
+]);
+const checkSeveritySchema = z.enum([
+	"error",
+	"warning",
+	"info"
+]);
+const checkCategorySchema = z.enum([
+	"connectivity",
+	"tool-metadata",
+	"resource-metadata",
+	"performance",
+	"e2e"
+]);
+const checkScopeSchema = z.enum(["server", "view"]);
+const checkDetailSchema = z.object({
+	label: z.string(),
+	value: z.string().optional()
+});
+const checkResultSchema = z.object({
+	checkId: z.string(),
+	checkName: z.string(),
+	description: z.string(),
+	status: z.enum([
+		"pass",
+		"fail",
+		"skip",
+		"pending"
+	]),
+	message: z.string(),
+	skipReason: z.string().optional(),
+	severity: checkSeveritySchema,
+	category: checkCategorySchema,
+	scope: checkScopeSchema,
+	platforms: z.array(platformSchema).readonly().optional(),
+	durationMs: z.number(),
+	details: z.array(checkDetailSchema).optional(),
+	hint: z.object({ text: z.string() }).optional()
+});
+const auditReportSchema = z.object({
+	schemaVersion: z.string(),
+	auditId: z.string(),
+	targetUrl: z.string(),
+	startedAt: z.string(),
+	completedAt: z.string(),
+	durationMs: z.number(),
+	results: z.array(checkResultSchema),
+	requiresAuth: z.boolean(),
+	hasViewSupport: z.boolean(),
+	viewPlatforms: z.array(platformSchema).readonly().optional(),
+	isReadyForPlatform: z.record(platformSchema, z.boolean()),
+	widgetScreenshotKeys: z.object({
+		chatgpt: z.string().optional(),
+		claudeai: z.string().optional()
+	})
+});
+const widgetScreenshotSchema = z.object({ url: z.string() });
+const auditReportWithScreenshotsSchema = auditReportSchema.extend({ widgetScreenshots: z.object({
+	chatgpt: widgetScreenshotSchema.optional(),
+	claudeai: widgetScreenshotSchema.optional()
+}) });
+z.enum([
+	"ongoing",
+	"deployed",
+	"failed",
+	"canceled"
+]);
+z.object({
+	timestamp: z.coerce.date().optional(),
+	content: z.string().optional()
+});
+z.object({
+	id: z.string(),
+	createdAt: z.coerce.date(),
+	environmentId: z.string(),
+	content: z.string(),
+	source: z.enum(["model", "user"])
+});
+z.object({
+	content: z.string(),
+	source: z.enum(["model", "user"])
+});
+const toolDefinitionSchema = z.object({
+	name: z.string(),
+	title: z.string().optional().describe("Human-friendly name for the tool, used in the UI. If not provided, `name` will be used."),
+	description: z.string().optional(),
+	annotations: z.object({
+		readOnlyHint: z.boolean().optional(),
+		destructiveHint: z.boolean().optional(),
+		openWorldHint: z.boolean().optional(),
+		idempotentHint: z.boolean().optional()
+	}).optional()
+});
+const positiveTestCaseSchema = z.object({
+	scenario: z.string(),
+	userPrompt: z.string(),
+	toolTriggered: z.string().optional(),
+	expectedOutput: z.string().optional()
+}).partial().describe("Each case: Scenario, User prompt, Tool triggered, Expected output.");
+/** Accepts either a valid email or URL. */
+const supportChannelSchema = z.string().refine((value) => z.email().safeParse(value).success || z.url().safeParse(value).success, { error: "Must be a valid email or URL" });
+const chatgptCategorySchema = z.enum([
+	"BUSINESS",
+	"COLLABORATION",
+	"DESIGN",
+	"DEVELOPER_TOOLS",
+	"EDUCATION",
+	"ENTERTAINMENT",
+	"FINANCE",
+	"FOOD",
+	"LIFESTYLE",
+	"NEWS",
+	"PRODUCTIVITY",
+	"SHOPPING",
+	"TRAVEL"
+]);
+const chatgptAuthenticationSchema = z.enum(["No auth needed", "OAuth 2.0"]);
+const chatgptAllowedCountriesSchema = z.enum(["Allow all", "Restrict to specific countries"]);
+const negativeTestCaseSchema = z.object({
+	scenario: z.string(),
+	userPrompt: z.string()
+}).partial().describe("Each case: Scenario + User prompt (the app should NOT trigger).");
+const chatgptToolJustificationSchema = z.object({
+	toolName: z.string(),
+	readOnlyJustification: z.string(),
+	openWorldJustification: z.string(),
+	destructiveJustification: z.string()
+}).describe("Per-tool justification of each MCP annotation value (one sentence per hint).");
+const chatgptTranslationSchema = z.object({
+	locale: z.string(),
+	tagline: z.string().optional(),
+	description: z.string().optional()
+}).describe("Locale-scoped override for tagline + description. English (US) is the default.");
+/**
+* Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section.
+* When adding/removing/reordering fields, keep this in sync with the sheet.
+*/
+const chatgptSubmissionFormDataSchema = z.object({
+	logoLight: z.string().describe("Logo icon for light mode. Square PNG, no borders or rounded corners (clients apply circular cropping)."),
+	logoDark: z.string().describe("Logo icon for dark mode. Square PNG. Same specs as the light icon."),
+	appName: z.string().describe("The name users will see in ChatGPT and in the Apps Directory."),
+	tagline: z.string().max(30).describe("Plain-language phrase focused on function and user value. 30 chars max."),
+	description: z.string().describe("Clear, engaging description highlighting what the app does and why people will love it. Appears publicly on the directory page."),
+	category: chatgptCategorySchema.describe("Category from the OpenAI taxonomy."),
+	developerName: z.string().describe("Developer name shown publicly on the app's directory page."),
+	companyUrl: z.url().describe("Your company's main website URL."),
+	supportChannel: supportChannelSchema.describe("Customer support URL or email address."),
+	privacyPolicyUrl: z.url().describe("URL to your privacy policy."),
+	termsOfServiceUrl: z.url().describe("URL to the app's terms of service."),
+	demoRecordingUrl: z.url().describe("URL to a video demonstrating the app, recorded via OpenAI Developer Mode. Cover all main use cases on web, iOS, and Android."),
+	appCommerceAndPurchasing: z.boolean().describe("Checkbox: 'My app links or directs users out of ChatGPT to make purchases.' Defaults to false. Verify the app does not offer digital goods."),
+	serverUrl: z.url().describe("URL of the MCP server."),
+	authentication: chatgptAuthenticationSchema.describe("OAuth 2.0 or No auth. OAuth configuration is auto-discovered from the MCP server's metadata."),
+	tools: z.array(toolDefinitionSchema).describe("List of tools exposed by the MCP server (auto-populated from the production server's manifest)."),
+	toolJustifications: z.array(chatgptToolJustificationSchema).describe("Per-tool justification of `readOnlyHint`, `openWorldHint`, and `destructiveHint` annotation values."),
+	testCases: z.array(positiveTestCaseSchema).describe("At least 5 positive test cases. Each: Scenario, User prompt, Tool triggered, Expected output. Coverage over all major use cases."),
+	negativeTestCases: z.array(negativeTestCaseSchema).describe("3 negative test cases — prompts where the app should NOT trigger but the model might think it's relevant."),
+	screenshots: z.array(z.url()).describe("URLs of in-app screenshots. Widget apps must show the widget UI; non-widget apps show the model response. Min 1, max 4. First three are public."),
+	translations: z.array(chatgptTranslationSchema).describe("Per-locale translation of tagline + description. English (US) is the default."),
+	allowedCountries: chatgptAllowedCountriesSchema.describe("'Allow all' or restrict to a specific list. See OpenAI's supported countries list."),
+	releaseNotes: z.string().describe("Publicly displayed on the app details page.")
+});
+chatgptSubmissionFormDataSchema.pick({
+	appName: true,
+	developerName: true,
+	serverUrl: true,
+	tools: true,
+	authentication: true
+});
+chatgptSubmissionFormDataSchema.pick({
+	tagline: true,
+	description: true,
+	category: true,
+	testCases: true,
+	negativeTestCases: true,
+	toolJustifications: true
+});
+const claudeCategorySchema = z.enum([
+	"Business & Productivity",
+	"Communication",
+	"Data & Analytics",
+	"Development tools",
+	"Financial Services",
+	"Consumer Health",
+	"Health & Life Sciences",
+	"Media & Entertainment",
+	"Commerce & Shopping"
+]);
+z.enum([
+	"No auth needed",
+	"OAuth 2.0",
+	"Custom URL"
+]);
+const claudeMcpUrlTypeSchema = z.enum(["Universal URL", "Custom MCP URLs"]);
+z.enum(["Static OAuth Client", "Dynamic OAuth Client (DCR / CIMD)"]);
+const claudeReadWriteCapabilitiesSchema = z.enum([
+	"Read only",
+	"Write only",
+	"Read + write"
+]);
+const claudeTransportSchema = z.enum(["Streamable HTTP", "SSE"]);
+const claudeThirdPartySchema = z.enum([
+	"Web access (open web fetch / scraping / arbitrary URLs)",
+	"Third-party AI model integration",
+	"Third-party data retrieval (via workflow / aggregator)",
+	"Third-party data modification (via workflow / aggregator)",
+	"N/A"
+]);
+const claudeDataHandlingSchema = z.enum([
+	"Server only accesses data explicitly requested by user",
+	"No data is stored beyond session requirements",
+	"Data transmission is encrypted (HTTPS / TLS)",
+	"GDPR compliant (if applicable)"
+]);
+const claudeSponsoredContentSchema = z.enum([
+	"No, there is no sponsored content or advertisements",
+	"Yes, there are banner ads or other paid visual elements",
+	"Yes, returned content or ranking is impacted by sponsorship or ad placement"
+]);
+/**
+* Field order mirrors the Claude (Anthropic) submission spreadsheet, grouped by section.
+* When adding/removing/reordering fields, keep this in sync with the sheet.
+*/
+const claudeSubmissionFormDataSchema = z.object({
+	companyName: z.string().describe("Enter your company's legal name or the name under which your product is publicly known. This is used for internal tracking and may appear in directory listings."),
+	companyUrl: z.url().describe("Your company's main website URL, e.g. https://mycompany.com. Must be a valid URL with https://. This should be the root domain of the company behind this MCP server."),
+	primaryContactName: z.string().describe("Full name of the person Anthropic should contact about this submission. This person will receive review feedback, approval notices, and any follow-up questions."),
+	primaryContactEmail: z.email().describe("Business email for the primary contact. Must be a valid email address. Anthropic uses this to communicate about your submission status, required changes, and post-listing issues. Avoid using personal email addresses."),
+	primaryContactRole: z.string().optional().describe("The job title or role of the primary contact (e.g. 'CTO', 'Developer Relations Lead', 'Founder'). Optional but helps Anthropic route questions to the right person."),
+	anthropicPointOfContact: z.string().optional().describe("If you have a direct contact at Anthropic (e.g. from a partnership or sales conversation), enter their name here. This is optional but can greatly help expedite the review process. Leave blank if you don't have one."),
+	appName: z.string().describe(`The public display name for your connector as it will appear in the Connectors Directory.
+
+Rules:
+(1) Do NOT include the words 'MCP' or 'Server' — these are auto-rejected.
+(2) Use your brand/product name, e.g. 'Notion', 'Linear', 'Slack'.
+(3) You must own or have the right to use this brand name. For example, don't call it 'Google Drive Helper' if you're not Google.`),
+	mcpUrlType: claudeMcpUrlTypeSchema.describe(`Choose how your server URL works:
+• 'Universal URL': one single URL that all users connect to (most common). Example: https://mcp.myapp.com
+• 'Custom MCP URLs': each user gets their own unique URL (e.g. based on their workspace or instance). 
+If you choose this, you'll need to provide both a signup URL and a regex pattern that matches valid server URLs for your service.`),
+	serverUrl: z.url().describe(`If 'Universal URL': enter the full https:// URL where your MCP server is hosted and reachable. Example: https://mcp.myapp.com/
+If 'Custom MCP URLs': provide (1) the signup/onboarding URL where users create an account, and (2) a regex pattern that matches all valid server URLs for your service (e.g. https://[a-z0-9-]+\\.myapp\\.com/mcp). The server must be publicly accessible without VPN or whitelisting required.`),
+	tagline: z.string().max(55).describe(`A very short, punchy description shown below your server name in the directory listing. Max 55 characters including spaces.
+Think of it as a subtitle or elevator pitch fragment. Example: 'Manage tasks and projects in Linear' or 'Search and read your Notion workspace'. Avoid generic phrases like 'The best MCP server for...'`),
+	description: z.string().describe(`A 50–100 word description of what your MCP server does. This appears in the connector's detail page inside Claude. Write it from a user perspective: what can users do with this connector? What are the key features/tools? Avoid marketing fluff. Be specific. Example: 'Connect Claude to your Linear workspace. Create and update issues, search projects, manage teams, and track engineering cycles, all from within Claude.' Anthropic reviewers check this for accuracy against your actual tools.`),
+	testCases: z.array(positiveTestCaseSchema).describe(`Provide at least 3 concrete use cases, each with an example prompt a user could type to Claude. These are critical: Anthropic reviewers literally test your server using these prompts. Good examples are specific and demonstrate real value. 
+Best format: [Use case]: [exact prompt]"
+Example for a task manager:
+1. Create a task: 'Create a task called Review Q3 report, due Friday, assigned to Alice'
+2. Search tasks: 'Show me all open bugs in the Mobile project'
+3. Update status: 'Mark the Deploy v2.1 task as done'"`),
+	connectionRequirements: z.string().describe(`Describe any prerequisites a user must have before they can connect your server. Be exhaustive. Examples of things to mention:
+• Account type required (free vs paid plan)
+• Admin permissions or specific roles needed
+• Geographic restrictions (e.g. 'US only' or 'Not available in EU')
+• If users need to provide their own server URL or instance domain
+• Any setup steps needed before connecting (e.g. 'Enable API access in your account settings')
+If there are genuinely no special requirements, write exactly: 'No special requirements.'`),
+	readWriteCapabilities: claudeReadWriteCapabilitiesSchema.describe(`Select the option that best describes what your server can do:
 
+'Read Only': your tools only fetch/retrieve data (GET operations). Claude cannot modify anything via your server.
+'Write Only': your tools only create/update/delete data (rare).
+'Read + Write': your tools can both retrieve AND modify data (most common for full-featured connectors).
+
+Note: Anthropic rejects catch-all tools that accept both safe (GET) and unsafe (POST, PUT, DELETE) HTTP methods via a parameter e.g. a single api_request(method, endpoint) tool. Each tool should have a fixed, specific purpose. `),
+	isMcpApp: z.boolean().describe(`Select 'Yes' if your MCP server renders interactive UI elements (aka widgets or views) inside the Claude conversation.
+Select 'No' if your server only returns text/data responses.
+If 'Yes', you will also be required to provide screenshots of your UI (see Promotional Images section). MCP Apps are displayed with a special badge in the directory.`),
+	thirdPartyConnectionsAndWebAccess: z.array(claudeThirdPartySchema).describe(`Multi-select all that apply to your server's behavior:
+• 'Web access' — your server fetches arbitrary URLs, scrapes websites, or makes open-ended HTTP requests to the web (not just your own API).
+• 'Third-party AI model integration' — your server calls another AI model (e.g. OpenAI, Gemini, Cohere) as part of its processing.
+• 'Third-party data retrieval' — your server retrieves data via a workflow or aggregator platform (e.g. Zapier, Make, n8n) rather than calling your own API directly.
+• 'Third-party data modification' — your server modifies data via such a platform.
+• 'N/A' — your server only calls your own first-party API and does nothing else. Select this only if none of the above apply.`),
+	dataHandling: z.array(claudeDataHandlingSchema).describe(`Multi-select all data handling practices that accurately apply to your server. You must select at least 3. Key points:
+• 'Server only accesses data explicitly requested by user' — your server doesn't silently read unrelated user data.
+• 'No data is stored beyond session requirements' — you don't log or retain conversation data after the session.
+• 'Data transmission is encrypted (HTTPS/TLS)' — all data in transit is encrypted. This should always apply for remote servers.
+• 'GDPR compliant' — if you operate in the EU or serve EU users, check this only if you are genuinely compliant. Don't check it without having proper data processing agreements and procedures in place.
+Note: These are attestations — you are legally agreeing to these practices by submitting the form.`),
+	personalDataHealthAccess: z.boolean().describe(`Select 'Yes' ONLY if your connector gives users access to their own personal health information — such as medical records, lab results, diagnoses, prescriptions, wearable health metrics (heart rate, sleep data, etc.), or mental health data.
+Select 'No' for the vast majority of business/productivity/dev tools. When in doubt, select 'No'. This field triggers additional compliance review if 'Yes'.`),
+	categories: z.array(claudeCategorySchema).describe(`Select the category or categories that best describe your connector. This determines where it appears in the directory's browse experience. Choose the most specific fit:
+• Business & Productivity — project management, CRM, HR, office tools
+• Communication — email, chat, messaging, notifications
+• Data & Analytics — dashboards, reporting, databases, BI tools
+• Development tools — code repositories, CI/CD, issue trackers, monitoring
+• Financial Services — accounting, invoicing, fintech (note: financial transaction execution is not permitted)
+• Consumer Health — fitness, wellness, personal health tracking
+• Health & Life Sciences — clinical, pharma, medical professional tools
+• Media & Entertainment — content, publishing, streaming
+• Commerce & Shopping — e-commerce, inventory, orders
+Multiple categories are allowed if genuinely applicable.`),
+	sponsoredContentsOrAdvertisement: claudeSponsoredContentSchema.describe(`Be honest here — advertising is not permitted in the Connectors Directory per Anthropic's policy. Select the option that accurately describes your server:
+• 'No, there is no sponsored content or advertisements' — the results your server returns are not influenced by paid placement or sponsorship. This is what almost all connectors should select.
+• 'Yes, there are banner ads or other paid visual elements' — your UI includes visual ads. NOTE: this will likely lead to rejection, as Anthropic prohibits advertising in Claude.
+• 'Yes, the returned content or ranking of returned content is impacted by sponsorship or ad placement' — paid results affect what you return. NOTE: this also likely leads to rejection.
+If your server returns organic results from a platform that has ads in its own UI (but your API results are not affected by ads), select 'No'.`),
+	transportSupport: z.array(claudeTransportSchema).describe(`Select all transport protocols your server supports:
+• 'Streamable HTTP' — the modern, recommended transport. Anthropic strongly recommends implementing this. This is the future-proof option and should be your default.
+• 'SSE (Server-Sent Events)' — the older transport. SSE may be deprecated by Anthropic later in 2025/2026. If you currently only support SSE, you should plan to migrate to Streamable HTTP.
+If you support both, select both. If you're building from scratch, implement Streamable HTTP only.`),
+	serverDocumentationLink: z.url().describe(`A public URL pointing to documentation that helps users understand and use your connector. This is displayed in the Directory listing and must be publicly accessible without login. Minimum requirements for the docs page:
+• What the connector does and its key capabilities
+• How to connect/set it up (step by step)
+• What each tool does (or at least the main ones)
+• How to troubleshoot common issues
+• A support contact or channel
+Acceptable formats: a dedicated docs page, a help center article, a README on GitHub, or a blog post — as long as it's comprehensive. Note: Anthropic requires public documentation to be live by your publish date.`),
+	privacyPolicyUrl: z.url().describe(`URL to your privacy policy. This is mandatory and displayed in the directory listing. Missing or incomplete privacy policies result in immediate rejection. Your privacy policy must cover:
+• What data you collect (and how)
+• How you use the collected data
+• Where and how long you store it
+• Whether you share data with third parties (and who)
+• How users can contact you about data concerns
+The policy must be publicly accessible. If you don't have one yet, create one before submitting — there are free generators online, but make sure it accurately reflects your actual practices. If you're GDPR-compliant, your policy should reflect that.`),
+	supportChannel: supportChannelSchema.describe(`A URL or email address where users can get help with your connector. This is displayed in the Directory listing. Acceptable options:
+• Email address (e.g. support@myapp.com)
+• Link to a GitHub Issues page
+• Link to a help center or support article
+• Link to a Discord/Slack community
+• Link to your documentation's troubleshooting section
+Also uses this to notify you of security or compliance issues, so make sure it's actively monitored.`),
+	testingCredentials: z.string().describe(`Provide login credentials for a test account that Anthropic reviewers can use to verify your server works end-to-end. Critical requirements:
+• The account must have sample/demo data loaded — reviewers need to actually test your tools with real data.
+• No 2FA — reviewers can't receive SMS codes. Disable 2FA on this account.
+• If your service uses Google OAuth or another OAuth that requires email verification, use mcp-review@anthropic.com as the account email — Anthropic has access to this inbox.
+• Credentials must remain valid for at least 30 days from submission.
+• If your service requires API keys instead of a password, provide those.
+Format suggestion: Username/email: xxx | Password: xxx | Any other notes`),
+	tools: z.array(toolDefinitionSchema).describe(`A comma-separated list of all tools your MCP server exposes. Use the format: tool_name (Human-Readable Name). The tool_name is the internal identifier (snake_case, max 64 characters). The Human-Readable Name is what users see.
+Example: list_issues (List Issues), create_issue (Create Issue), update_issue (Update Issue), delete_issue (Delete Issue), search_issues (Search Issues)
+Reviewers test every single tool you list here — don't list tools that don't work. Also: do not have a single catch-all tool like api_request(method, endpoint) — Anthropic rejects these. Each action should be its own purpose-built tool.`),
+	toolTitlesAnnotationsConfirmed: z.boolean().describe(`This is a compliance confirmation — check both boxes only if you have actually implemented these in your server code:
+• 'I've specified user-friendly titles for all tools' — every tool has a 'title' annotation (a human-readable label, different from the tool name).
+• 'I've specified accurate tool annotations for all tools' — every tool has the correct annotation: readOnlyHint: true for read operations (search, get, list, fetch), OR destructiveHint: true for write operations (create, update, delete, send).
+This is the #1 reason submissions get rejected (30% of all rejections). Do not check these boxes without actually having implemented the annotations. See MCP spec for how to add them.`),
+	logoLight: z.string().describe(`Your connector's logo as displayed in the directory. Requirements:
+• Format: SVG only
+• Aspect ratio: square (1:1)
+• Should work on both light and dark backgrounds (or you can provide separate light/dark versions)
+• Provide via URL (Google Drive link is fine) or upload directly
+Tip: use a simple, recognizable icon — not a full wordmark. The logo appears at small sizes in the directory grid.`),
+	screenshots: z.array(z.url()).describe(`Screenshots or promotional images of your connector in action within Claude. Strongly recommended for all connectors, and required for MCP Apps (interactive UI). Guidelines:
+• 3–5 images is ideal
+• Minimum 1000px width, PNG format preferred
+• Crop to just the relevant part of the Claude interface (the tool response area)
+• Show your connector doing something impressive and useful — real data, real results
+• If you're an MCP App, include screenshots of your interactive UI elements
+• Videos are also welcome
+These images appear in your directory listing and are a key factor in driving user installs.`)
+});
+claudeSubmissionFormDataSchema.pick({
+	companyName: true,
+	appName: true,
+	mcpUrlType: true,
+	serverUrl: true,
+	tools: true,
+	readWriteCapabilities: true,
+	isMcpApp: true,
+	transportSupport: true,
+	primaryContactEmail: true,
+	primaryContactName: true
+});
+claudeSubmissionFormDataSchema.pick({
+	tagline: true,
+	description: true,
+	categories: true,
+	testCases: true
+});
+const submissionMetaFieldsSchema = z.object({
+	id: z.string(),
+	environmentId: z.string(),
+	createdAt: z.coerce.date(),
+	updatedAt: z.coerce.date()
+});
+const claudeSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
+	platform: z.literal("claudeai"),
+	formData: claudeSubmissionFormDataSchema.partial()
+});
+const chatgptSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
+	platform: z.literal("chatgpt"),
+	formData: chatgptSubmissionFormDataSchema.partial()
+});
+z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
+z.union([claudeSubmissionFormDataSchema.partial(), chatgptSubmissionFormDataSchema.partial()]);
+const subscriptionPlanSchema = z.enum([
+	"pro",
+	"business",
+	"enterprise"
+]);
+z.object({ plan: subscriptionPlanSchema.nullable() });
+//#endregion
 //#region src/schemas.ts
 const RESERVED_KEYS = [
 	"_HANDLER",
@@ -13,7 +415,11 @@ const RESERVED_KEYS = [
 	"AWS_LAMBDA_FUNCTION_VERSION",
 	"AWS_LAMBDA_INITIALIZATION_TYPE",
 	"AWS_LAMBDA_LOG_GROUP_NAME",
+	"AWS_LAMBDA_LOG_STREAM_NAME",
 	"AWS_ACCESS_KEY",
+	"AWS_ACCESS_KEY_ID",
+	"AWS_SECRET_ACCESS_KEY",
+	"AWS_SESSION_TOKEN",
 	"AWS_LAMBDA_RUNTIME_API",
 	"LAMBDA_TASK_ROOT",
 	"LAMBDA_RUNTIME_DIR",
@@ -30,7 +436,9 @@ const RESERVED_KEYS = [
 	"BUILD_ARG_BUILD_COMMAND",
 	"BUILD_ARG_BUILD_OUTPUT_DIR",
 	"BUILD_ARG_START_COMMAND",
-	"ALPIC_HOST"
+	"ALPIC_HOST",
+	"ALPIC_CUSTOM_DOMAINS",
+	"ALPIC_INTENT_META_KEY"
 ];
 const environmentVariableSchema = z.object({
 	key: z.string().min(2, "Key must be at least 2 characters").regex(/^[a-zA-Z]([a-zA-Z0-9_])+$/, "Key must start with a letter and contain only letters, numbers, and underscores").refine((key) => !RESERVED_KEYS.includes(key), "This key is reserved and cannot be used as an environment variable key"),
@@ -38,6 +446,10 @@ const environmentVariableSchema = z.object({
 	isSecret: z.boolean().default(false)
 });
 const environmentVariablesSchema = z.array(environmentVariableSchema);
+const updateEnvironmentVariableSchema = environmentVariableSchema.partial({
+	value: true,
+	isSecret: true
+});
 const buildSettingsSchema = z.object({
 	installCommand: z.string().optional(),
 	buildCommand: z.string().optional(),
@@ -55,7 +467,39 @@ const transportSchema = z.enum([
 	"sse",
 	"streamablehttp"
 ]);
-
+const playgroundHeaderSchema = z.object({
+	name: z.string().min(1).max(100),
+	description: z.string().max(200),
+	isRequired: z.boolean().default(false),
+	isSecret: z.boolean().default(false)
+});
+const playgroundExamplePromptSchema = z.object({
+	title: z.string().min(1).max(100),
+	prompt: z.string().min(1).max(500)
+});
+const serverFieldsSchema = z.object({
+	$schema: z.string(),
+	name: z.string(),
+	description: z.string(),
+	version: z.string().optional(),
+	title: z.string().optional(),
+	websiteUrl: z.url().optional(),
+	icons: z.array(z.object({
+		src: z.url(),
+		mimeType: z.string().optional(),
+		sizes: z.array(z.string()).optional()
+	})).optional(),
+	remotes: z.array(z.object({
+		type: z.string(),
+		url: z.url().optional(),
+		headers: z.array(z.object({
+			name: z.string(),
+			description: z.string(),
+			isRequired: z.boolean().optional(),
+			isSecret: z.boolean().optional()
+		})).optional()
+	})).optional()
+});
 //#endregion
 //#region src/api.contract.ts
 const deploymentStatusSchema = z.enum([
@@ -80,8 +524,16 @@ const deploymentSchema = z.object({
 	authorUsername: z.string().nullable(),
 	authorAvatarUrl: z.string().nullable(),
 	startedAt: z.coerce.date().nullable(),
-	completedAt: z.coerce.date().nullable()
+	completedAt: z.coerce.date().nullable(),
+	environmentId: z.string(),
+	environmentName: z.string(),
+	isCurrent: z.boolean(),
+	deploymentPageUrl: z.url().nullable()
 });
+const isValidLogTimeInput = (value) => {
+	if (ms(value) !== void 0) return true;
+	return !Number.isNaN(new Date(value).getTime());
+};
 const createEnvironmentContractV1 = oc.route({
 	path: "/v1/environments",
 	method: "POST",
@@ -106,7 +558,7 @@ const createEnvironmentContractV1 = oc.route({
 	projectId: z.string().describe("The ID of the project the environment belongs to")
 }));
 const getEnvironmentContractV1 = oc.route({
-	path: "/v1/environments/:environmentId",
+	path: "/v1/environments/{environmentId}",
 	method: "GET",
 	summary: "Get an environment",
 	description: "Get an environment by ID",
@@ -121,10 +573,20 @@ const getEnvironmentContractV1 = oc.route({
 	createdAt: z.coerce.date(),
 	projectId: z.string()
 }));
+const domainSchema = z.object({
+	domain: z.string(),
+	status: z.enum([
+		"ongoing",
+		"deployed",
+		"failed"
+	]),
+	createdAt: z.coerce.date()
+});
 const productionEnvironmentSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	mcpServerUrl: z.string(),
+	domains: z.array(domainSchema),
 	latestDeployment: latestDeploymentSchema.nullable()
 });
 const environmentSchema = z.object({
@@ -153,7 +615,7 @@ const projectOutputSchema = z.object({
 	environments: z.array(environmentSchema)
 });
 const getProjectContractV1 = oc.route({
-	path: "/v1/projects/:projectId",
+	path: "/v1/projects/{projectId}",
 	method: "GET",
 	summary: "Get a project",
 	description: "Get a project by ID",
@@ -167,7 +629,7 @@ const listProjectsContractV1 = oc.route({
 	description: "List all projects for a team",
 	tags: ["projects"],
 	successDescription: "The list of projects"
-}).output(z.array(projectOutputSchema));
+}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
 const createProjectContractV1 = oc.route({
 	path: "/v1/projects",
 	method: "POST",
@@ -180,7 +642,7 @@ const createProjectContractV1 = oc.route({
 	BAD_REQUEST: {}
 }).input(z.object({
 	teamId: z.string().optional(),
-	name: z.string().min(1).max(100),
+	name: z.string().trim().min(1).max(100),
 	sourceRepository: z.string().optional(),
 	branchName: z.string().min(1).optional(),
 	runtime: runtimeSchema,
@@ -210,8 +672,69 @@ const createProjectContractV1 = oc.route({
 	startCommand: z.string().nullable(),
 	createdAt: z.coerce.date()
 }));
+const environmentVariableOutputSchema = z.object({
+	id: z.string(),
+	key: z.string(),
+	value: z.string(),
+	isSecret: z.boolean(),
+	createdAt: z.coerce.date()
+});
+const listEnvironmentVariablesContractV1 = oc.route({
+	path: "/v1/environments/{environmentId}/environment-variables",
+	method: "GET",
+	summary: "List environment variables",
+	description: "List all environment variables for an environment",
+	tags: ["environments"],
+	successDescription: "The list of environment variables"
+}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(environmentVariableOutputSchema));
+const createEnvironmentVariablesContractV1 = oc.route({
+	path: "/v1/environments/{environmentId}/environment-variables",
+	method: "POST",
+	summary: "Add environment variables",
+	description: "Add one or more environment variables to an environment",
+	tags: ["environments"],
+	successDescription: "The environment variables have been added successfully"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	environmentVariables: environmentVariablesSchema
+})).output(z.object({ success: z.literal(true) }));
+const updateEnvironmentVariableContractV1 = oc.route({
+	path: "/v1/environment-variables/{environmentVariableId}",
+	method: "PATCH",
+	summary: "Update an environment variable",
+	description: "Update an environment variable by ID",
+	tags: ["environments"],
+	successDescription: "The environment variable has been updated successfully"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	environmentVariableId: z.string().describe("The ID of the environment variable"),
+	key: environmentVariableSchema.shape.key,
+	value: environmentVariableSchema.shape.value.optional(),
+	isSecret: environmentVariableSchema.shape.isSecret.optional()
+})).output(z.object({ success: z.literal(true) }));
+const deleteEnvironmentVariableContractV1 = oc.route({
+	path: "/v1/environment-variables/{environmentVariableId}",
+	method: "DELETE",
+	summary: "Delete an environment variable",
+	description: "Delete an environment variable by ID",
+	tags: ["environments"],
+	successDescription: "The environment variable has been deleted successfully"
+}).errors({ NOT_FOUND: {} }).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
+const deleteProjectContractV1 = oc.route({
+	path: "/v1/projects/{projectId}",
+	method: "DELETE",
+	summary: "Delete a project",
+	description: "Delete a project and all its environments",
+	tags: ["projects"],
+	successDescription: "The project has been deleted successfully"
+}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(z.object({ success: z.literal(true) }));
 const updateProjectContractV1 = oc.route({
-	path: "/v1/projects/:projectId",
+	path: "/v1/projects/{projectId}",
 	method: "PATCH",
 	summary: "Update a project",
 	description: "Update project settings",
@@ -222,10 +745,11 @@ const updateProjectContractV1 = oc.route({
 	BAD_REQUEST: {}
 }).input(z.object({
 	projectId: z.string().describe("The ID of the project"),
+	name: z.string().min(1).max(100).optional().describe("The new name for the project"),
 	sourceRepository: z.string().nullable().optional().describe("The source repository to connect to the project")
 })).output(projectOutputSchema);
 const deployEnvironmentContractV1 = oc.route({
-	path: "/v1/environments/:environmentId/deploy",
+	path: "/v1/environments/{environmentId}/deploy",
 	method: "POST",
 	summary: "Deploy an environment",
 	description: "Deploy an environment",
@@ -246,31 +770,108 @@ const uploadDeploymentArtifactContractV1 = oc.route({
 	tags: ["deployments"],
 	successDescription: "The presigned upload URL has been generated successfully"
 }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
-	uploadUrl: z.string().url().describe("Presigned S3 URL to upload the source archive with HTTP PUT"),
+	uploadUrl: z.url().describe("Presigned S3 URL to upload the source archive with HTTP PUT"),
 	token: z.string().describe("Token to identify the source archive"),
 	expiresAt: z.coerce.date().describe("Expiration date of the presigned URL")
 }));
-const listProjectDeploymentsContractV1 = oc.route({
-	path: "/v1/projects/:projectId/deployments",
+const listDeploymentsContractV1 = oc.route({
+	path: "/v1/projects/{projectId}/deployments",
 	method: "GET",
 	summary: "List project deployments",
 	description: "List all deployments for a project",
 	tags: ["deployments"],
 	successDescription: "The list of deployments"
-}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(z.array(deploymentSchema.extend({
-	isCurrent: z.boolean(),
-	environmentId: z.string()
-})));
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	projectId: z.string().describe("The ID of the project"),
+	status: z.array(deploymentStatusSchema).optional().describe("Filter by one or more statuses"),
+	environmentId: z.string().optional().describe("Filter by environment ID")
+})).output(z.array(deploymentSchema));
 const getDeploymentContractV1 = oc.route({
-	path: "/v1/deployments/:deploymentId",
+	path: "/v1/deployments/{deploymentId}",
 	method: "GET",
 	summary: "Get a deployment",
 	description: "Get a deployment by ID",
 	tags: ["deployments"],
 	successDescription: "The deployment details"
 }).errors({ NOT_FOUND: {} }).input(z.object({ deploymentId: z.string().describe("The ID of the deployment") })).output(deploymentSchema);
+const getLogsContractV1 = oc.route({
+	path: "/v1/environments/{environmentId}/logs",
+	method: "GET",
+	summary: "Get logs",
+	description: "Get logs for an environment",
+	tags: ["environments"],
+	successDescription: "The logs"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	since: z.string().refine(isValidLogTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." }).optional().describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
+	until: z.string().refine(isValidLogTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." }).optional().describe("End time — ISO 8601 or relative"),
+	limit: z.coerce.number().int().min(1).max(1e3).default(1e3).describe("Maximum number of log entries to return."),
+	level: z.array(z.enum([
+		"INFO",
+		"ERROR",
+		"WARNING",
+		"DEBUG"
+	])).optional().describe("Filter by log level"),
+	search: z.string().optional().describe("Filter pattern to search for in log content"),
+	nextToken: z.string().optional().describe("Pagination token from a previous response")
+})).output(z.object({
+	logs: z.array(z.object({
+		timestamp: z.coerce.date(),
+		type: z.enum([
+			"START",
+			"END",
+			"INFO",
+			"ERROR",
+			"WARNING",
+			"DEBUG"
+		]),
+		requestId: z.string(),
+		content: z.string().optional(),
+		method: z.string().optional(),
+		durationInMs: z.number().optional()
+	})),
+	nextToken: z.string().nullable()
+}));
+const getLatestLogsContractV1 = oc.route({
+	path: "/v1/environments/{environmentId}/latest-logs",
+	method: "GET",
+	summary: "Get latest logs",
+	description: "Get the N most recent logs for an environment",
+	tags: ["environments"],
+	successDescription: "The latest logs"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	limit: z.coerce.number().int().min(1).max(1e3).default(100).describe("Number of most recent log entries to return"),
+	level: z.array(z.enum([
+		"INFO",
+		"ERROR",
+		"WARNING",
+		"DEBUG"
+	])).optional().describe("Filter by log level"),
+	search: z.string().optional().describe("Filter pattern to search for in log content")
+})).output(z.object({ logs: z.array(z.object({
+	timestamp: z.coerce.date(),
+	type: z.enum([
+		"START",
+		"END",
+		"INFO",
+		"ERROR",
+		"WARNING",
+		"DEBUG"
+	]),
+	requestId: z.string(),
+	content: z.string().optional(),
+	method: z.string().optional(),
+	durationInMs: z.number().optional()
+})) }));
 const getDeploymentLogsContractV1 = oc.route({
-	path: "/v1/deployments/:deploymentId/logs",
+	path: "/v1/deployments/{deploymentId}/logs",
 	method: "GET",
 	summary: "Get deployment logs",
 	description: "Get the logs for a deployment",
@@ -297,7 +898,7 @@ const analyticsTimeSeriesSchema = z.object({
 	task_count: z.array(analyticsDataPointSchema)
 });
 const getProjectAnalyticsContractV1 = oc.route({
-	path: "/v1/analytics/:projectId",
+	path: "/v1/analytics/{projectId}",
 	method: "GET",
 	summary: "Get project analytics",
 	description: "Get analytics data for a project over a time range",
@@ -332,14 +933,129 @@ const listTeamsContractV1 = oc.route({
 	id: z.string(),
 	name: z.string(),
 	createdAt: z.coerce.date(),
-	hasStripeAccount: z.boolean(),
-	hasActiveSubscription: z.boolean()
+	hasStripeAccount: z.boolean()
 })));
+const getTunnelTicketContractV1 = oc.route({
+	path: "/v1/tunnels/ticket",
+	method: "GET",
+	summary: "Get a tunnel ticket",
+	description: "Get a signed ticket for establishing a tunnel connection. Requires user authentication (API keys are not supported).",
+	tags: ["tunnels"],
+	successDescription: "The tunnel ticket"
+}).output(z.object({
+	subdomain: z.string().describe("The subdomain assigned to the user"),
+	ticket: z.string().describe("The signed tunnel ticket"),
+	tunnelHost: z.string().describe("The tunnel host to connect to")
+}));
+const publishServerContractV1 = oc.route({
+	path: "/v1/distribution/publish",
+	method: "POST",
+	summary: "Publish a server to the MCP registry",
+	tags: ["distribution"],
+	successDescription: "The server has been published successfully"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	projectId: z.string(),
+	domain: z.string(),
+	title: z.string().min(1).max(100),
+	description: z.string().min(1).max(100),
+	websiteUrl: z.url().max(255).optional(),
+	iconSrc: z.url().max(255).optional(),
+	dryRun: z.boolean().optional()
+})).output(z.object({ serverFields: serverFieldsSchema }));
+const getServerInfoContractV1 = oc.route({
+	path: "/v1/distribution/get",
+	method: "GET",
+	summary: "Get server info",
+	description: "Get info about a server",
+	tags: ["distribution"],
+	successDescription: "The server info"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	projectId: z.string(),
+	domain: z.string()
+})).output(z.object({ serverFields: serverFieldsSchema }));
+const playgroundServerMetadataOutputSchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	headers: z.array(z.object({
+		name: z.string(),
+		description: z.string(),
+		isRequired: z.boolean(),
+		isSecret: z.boolean()
+	})),
+	examplePrompts: z.array(playgroundExamplePromptSchema)
+});
+const playgroundOutputSchema = z.object({
+	isPlaygroundEnabled: z.boolean(),
+	serverMetadata: playgroundServerMetadataOutputSchema.nullable()
+});
+const getPlaygroundContractV1 = oc.route({
+	path: "/v1/environments/{environmentId}/playground",
+	method: "GET",
+	summary: "Get playground configuration",
+	description: "Get the playground configuration for an environment",
+	tags: ["environments"],
+	successDescription: "The playground configuration"
+}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(playgroundOutputSchema);
+const upsertPlaygroundContractV1 = oc.route({
+	path: "/v1/environments/{environmentId}/playground",
+	method: "PUT",
+	summary: "Update playground configuration",
+	description: "Update the playground configuration for an environment. All fields are optional — only provided fields are updated.",
+	tags: ["environments"],
+	successDescription: "The updated playground configuration"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	isPlaygroundEnabled: z.boolean().optional(),
+	name: z.string().min(1).max(100).optional(),
+	description: z.string().min(1).max(500).optional(),
+	headers: z.array(playgroundHeaderSchema).optional(),
+	examplePrompts: z.array(playgroundExamplePromptSchema).max(3).optional()
+})).output(playgroundOutputSchema);
+const createBeaconContractV1 = oc.route({
+	path: "/v1/beacon/audits",
+	method: "POST",
+	summary: "Create a beacon audit",
+	description: "Audit an MCP server for spec compliance and AI client compatibility",
+	tags: ["beacon"],
+	successDescription: "The audit has been created"
+}).errors({
+	NOT_FOUND: {},
+	BAD_REQUEST: {}
+}).input(z.object({
+	targetUrl: z.url().describe("The HTTPS URL of the MCP server to audit"),
+	teamId: z.string().optional().describe("The team ID to associate the audit with"),
+	projectId: z.string().optional().describe("The project ID to associate the audit with"),
+	excludeCategories: z.array(checkCategorySchema).optional().describe("Check categories to exclude from the audit")
+})).output(z.object({ id: z.string() }));
+const getBeaconContractV1 = oc.route({
+	path: "/v1/beacon/audits/{auditId}",
+	method: "GET",
+	summary: "Get a beacon audit",
+	description: "Get a beacon audit by ID, including the report if completed",
+	tags: ["beacon"],
+	successDescription: "The audit details"
+}).errors({ NOT_FOUND: {} }).input(z.object({ auditId: z.string().describe("The ID of the audit") })).output(z.object({
+	id: z.string(),
+	targetUrl: z.string(),
+	status: auditStatusSchema,
+	durationMs: z.number().nullable(),
+	createdAt: z.coerce.date(),
+	report: auditReportWithScreenshotsSchema.nullable()
+}));
 const contract = {
 	teams: { list: { v1: listTeamsContractV1 } },
 	analytics: { get: { v1: getProjectAnalyticsContractV1 } },
 	deployments: {
-		list: { v1: listProjectDeploymentsContractV1 },
+		list: { v1: listDeploymentsContractV1 },
 		get: { v1: getDeploymentContractV1 },
 		uploadArtifact: { v1: uploadDeploymentArtifactContractV1 },
 		getLogs: { v1: getDeploymentLogsContractV1 }
@@ -347,15 +1063,36 @@ const contract = {
 	environments: {
 		create: { v1: createEnvironmentContractV1 },
 		get: { v1: getEnvironmentContractV1 },
-		deploy: { v1: deployEnvironmentContractV1 }
+		deploy: { v1: deployEnvironmentContractV1 },
+		getLogs: { v1: getLogsContractV1 },
+		getLatestLogs: { v1: getLatestLogsContractV1 }
+	},
+	environmentVariables: {
+		list: { v1: listEnvironmentVariablesContractV1 },
+		create: { v1: createEnvironmentVariablesContractV1 },
+		update: { v1: updateEnvironmentVariableContractV1 },
+		delete: { v1: deleteEnvironmentVariableContractV1 }
 	},
 	projects: {
 		update: { v1: updateProjectContractV1 },
 		get: { v1: getProjectContractV1 },
 		list: { v1: listProjectsContractV1 },
-		create: { v1: createProjectContractV1 }
+		create: { v1: createProjectContractV1 },
+		delete: { v1: deleteProjectContractV1 }
+	},
+	playground: {
+		get: { v1: getPlaygroundContractV1 },
+		upsert: { v1: upsertPlaygroundContractV1 }
+	},
+	tunnels: { getTicket: { v1: getTunnelTicketContractV1 } },
+	distribution: {
+		publish: { v1: publishServerContractV1 },
+		get: { v1: getServerInfoContractV1 }
+	},
+	beacon: {
+		create: { v1: createBeaconContractV1 },
+		get: { v1: getBeaconContractV1 }
 	}
 };
-
 //#endregion
-export { buildSettingsSchema, contract, createEnvironmentContractV1, environmentVariableSchema, environmentVariablesSchema, runtimeSchema, transportSchema };
+export { PLATFORM_LABELS, buildSettingsSchema, contract, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };