@sync.so/mcp-server 0.1.4 → 0.2.0

package/dist/auth/resource-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-metadata.d.ts","sourceRoot":"","sources":["../../src/auth/resource-metadata.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKxD"}

package/dist/auth/resource-metadata.js

@@ -0,0 +1,3 @@
+export function resourceMetadataUrl(port) {
+    return new URL('/.well-known/oauth-protected-resource/mcp', process.env.MCP_ISSUER_URL || `http://localhost:${port}`).href;
+}

package/dist/auth/token-verification.d.ts

@@ -0,0 +1,11 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
+import { TemporarilyUnavailableError } from '@modelcontextprotocol/server-legacy/auth';
+export declare const VERIFICATION_TIMEOUT_MS = 5000;
+export declare class VerificationUnavailableError extends TemporarilyUnavailableError {
+    readonly status: 429 | 502 | 503;
+    readonly retryAfter?: string | undefined;
+    constructor(status?: 429 | 502 | 503, retryAfter?: string | undefined);
+}
+export declare function parseRetryAfter(value: string | null): string | undefined;
+export declare function verifySyncAccessToken(apiBaseUrl: string, token: string, signal?: AbortSignal): Promise<AuthInfo>;
+//# sourceMappingURL=token-verification.d.ts.map

package/dist/auth/token-verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-verification.d.ts","sourceRoot":"","sources":["../../src/auth/token-verification.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,0CAA0C,CAAC;AAGlD,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAG7C,qBAAa,4BAA6B,SAAQ,2BAA2B;IAEzE,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM;IAF9B,YACW,MAAM,GAAE,GAAG,GAAG,GAAG,GAAG,GAAS,EAC7B,UAAU,CAAC,EAAE,MAAM,YAAA,EAG7B;CACF;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAOxE;AAYD,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,QAAQ,CAAC,CA8DnB"}

package/dist/auth/token-verification.js

@@ -0,0 +1,99 @@
+import { InvalidTokenError, TemporarilyUnavailableError, } from '@modelcontextprotocol/server-legacy/auth';
+import { z } from 'zod';
+export const VERIFICATION_TIMEOUT_MS = 5_000;
+// Never include upstream bodies, exceptions, or credentials in public errors.
+export class VerificationUnavailableError extends TemporarilyUnavailableError {
+    status;
+    retryAfter;
+    constructor(status = 503, retryAfter) {
+        super('Token verification is temporarily unavailable');
+        this.status = status;
+        this.retryAfter = retryAfter;
+    }
+}
+export function parseRetryAfter(value) {
+    if (!value)
+        return undefined;
+    if (/^\d{1,15}$/.test(value) && Number.isSafeInteger(Number(value)))
+        return value;
+    // Accept canonical IMF-fixdate only, not Date.parse's permissive numeric forms.
+    const time = Date.parse(value);
+    if (Number.isFinite(time) && new Date(time).toUTCString() === value)
+        return value;
+    return undefined;
+}
+const userInfoSchema = z.object({
+    sub: z.string().refine((value) => value.trim().length > 0),
+    client_id: z.string().refine((value) => value.trim().length > 0),
+    expires_at: z.number().int().positive().optional(),
+    organization_id: z
+        .string()
+        .refine((value) => value.trim().length > 0)
+        .optional(),
+});
+export async function verifySyncAccessToken(apiBaseUrl, token, signal) {
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    signal?.addEventListener('abort', cancel, { once: true });
+    if (signal?.aborted)
+        cancel();
+    const timer = setTimeout(cancel, VERIFICATION_TIMEOUT_MS);
+    let onAbort = () => { };
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(new VerificationUnavailableError());
+        controller.signal.addEventListener('abort', onAbort, { once: true });
+        if (controller.signal.aborted)
+            onAbort();
+    });
+    try {
+        // Race the whole body read as well as headers. Abort also closes native fetch I/O.
+        return await Promise.race([
+            aborted,
+            (async () => {
+                if (controller.signal.aborted)
+                    throw new VerificationUnavailableError();
+                const res = await fetch(`${apiBaseUrl}/v2/oauth/userinfo`, {
+                    headers: { Authorization: `Bearer ${token}` },
+                    signal: controller.signal,
+                    redirect: 'error',
+                });
+                if (!res.ok) {
+                    const retryAfter = parseRetryAfter(res.headers.get('retry-after'));
+                    void res.body?.cancel().catch(() => { });
+                    if (res.status === 401 || res.status === 403) {
+                        throw new InvalidTokenError('Invalid or expired token');
+                    }
+                    throw new VerificationUnavailableError(res.status === 429 ? 429 : res.status >= 500 ? 503 : 502, retryAfter);
+                }
+                const parsed = userInfoSchema.safeParse(await res.json());
+                if (!parsed.success)
+                    throw new VerificationUnavailableError(502);
+                return {
+                    token,
+                    clientId: parsed.data.client_id,
+                    // Stable verified identity for A's session ownership checks. Never use
+                    // token bytes/expiry or copy arbitrary upstream fields into this object.
+                    extra: {
+                        sub: parsed.data.sub,
+                        ...(parsed.data.organization_id === undefined
+                            ? {}
+                            : { organizationId: parsed.data.organization_id }),
+                    },
+                    scopes: [],
+                    // Preserve the legacy expiry fallback; the provider bounds reuse to 15 seconds.
+                    expiresAt: parsed.data.expires_at ?? Math.floor(Date.now() / 1000) + 3600,
+                };
+            })(),
+        ]);
+    }
+    catch (error) {
+        if (error instanceof InvalidTokenError || error instanceof VerificationUnavailableError)
+            throw error;
+        throw new VerificationUnavailableError(error instanceof SyntaxError ? 502 : 503);
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', cancel);
+        controller.signal.removeEventListener('abort', onAbort);
+    }
+}

package/dist/auth/verification-cache.d.ts

@@ -0,0 +1,8 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
+export declare const VERIFICATION_CACHE_MS = 15000;
+/** Provider-scoped cache: successful checks only, bounded by both TTL and token expiry. */
+export declare function createTokenVerifier(apiBaseUrl: string): {
+    verify: (token: string, signal?: AbortSignal) => Promise<AuthInfo>;
+    clear: () => void;
+};
+//# sourceMappingURL=verification-cache.d.ts.map

package/dist/auth/verification-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-cache.d.ts","sourceRoot":"","sources":["../../src/auth/verification-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAG7D,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAK5C,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM;oBAcvB,MAAM,WAAW,WAAW,KAAG,OAAO,CAAC,QAAQ,CAAC;;EAkF9E"}

package/dist/auth/verification-cache.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+import { VerificationUnavailableError, verifySyncAccessToken } from './token-verification.js';
+export const VERIFICATION_CACHE_MS = 15_000;
+const MAX_ENTRIES = 512;
+const MAX_PENDING = 128;
+/** Provider-scoped cache: successful checks only, bounded by both TTL and token expiry. */
+export function createTokenVerifier(apiBaseUrl) {
+    const cache = new Map();
+    const pending = new Map();
+    let epoch = 0;
+    const cooldowns = new Map();
+    function clear() {
+        epoch++;
+        cache.clear();
+        cooldowns.clear();
+        for (const entry of pending.values())
+            entry.controller.abort();
+        pending.clear();
+    }
+    async function verify(token, signal) {
+        if (signal?.aborted)
+            throw new VerificationUnavailableError();
+        const key = createHash('sha256').update(token).digest('hex');
+        const now = Date.now();
+        const cached = cache.get(key);
+        if (cached && cached.until > now) {
+            cache.delete(key);
+            cache.set(key, cached);
+            return structuredClone(cached.info);
+        }
+        cache.delete(key);
+        const cooldownUntil = cooldowns.get(key) ?? 0;
+        if (cooldownUntil > now)
+            throw new VerificationUnavailableError(429, String(Math.ceil((cooldownUntil - now) / 1000)));
+        cooldowns.delete(key);
+        let entry = pending.get(key);
+        if (!entry) {
+            if (pending.size >= MAX_PENDING)
+                throw new VerificationUnavailableError(503, '1');
+            const controller = new AbortController();
+            const startedEpoch = epoch;
+            entry = { controller, waiters: 0, promise: Promise.resolve({}) };
+            const current = entry;
+            entry.promise = verifySyncAccessToken(apiBaseUrl, token, controller.signal)
+                .then((info) => {
+                const until = Math.min(now + VERIFICATION_CACHE_MS, (info.expiresAt ?? 0) * 1000);
+                if (!controller.signal.aborted && epoch === startedEpoch && until > Date.now()) {
+                    for (const [cacheKey, value] of cache)
+                        if (value.until <= Date.now())
+                            cache.delete(cacheKey);
+                    if (cache.size >= MAX_ENTRIES)
+                        cache.delete(cache.keys().next().value);
+                    cache.set(key, { info: structuredClone(info), until });
+                }
+                return info;
+            })
+                .catch((error) => {
+                if (error instanceof VerificationUnavailableError && error.status === 429) {
+                    const delay = error.retryAfter
+                        ? /^\d+$/.test(error.retryAfter)
+                            ? Number(error.retryAfter) * 1000
+                            : Date.parse(error.retryAfter) - Date.now()
+                        : 1000;
+                    for (const [cooldownKey, until] of cooldowns)
+                        if (until <= Date.now())
+                            cooldowns.delete(cooldownKey);
+                    if (cooldowns.size >= MAX_ENTRIES)
+                        cooldowns.delete(cooldowns.keys().next().value);
+                    const boundedDelay = Number.isFinite(delay)
+                        ? Math.min(VERIFICATION_CACHE_MS, Math.max(1000, delay))
+                        : 1000;
+                    if (epoch === startedEpoch)
+                        cooldowns.set(key, Date.now() + boundedDelay);
+                }
+                throw error;
+            })
+                .finally(() => {
+                if (pending.get(key) === current)
+                    pending.delete(key);
+            });
+            pending.set(key, entry);
+        }
+        // Cancelling one HTTP request must not cancel another caller's shared check.
+        entry.waiters++;
+        const current = entry;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error, info) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal?.removeEventListener('abort', abort);
+                current.waiters--;
+                if (current.waiters === 0 && pending.get(key) === current) {
+                    pending.delete(key);
+                    current.controller.abort();
+                }
+                if (error)
+                    reject(error);
+                else
+                    resolve(structuredClone(info));
+            };
+            const abort = () => finish(new VerificationUnavailableError());
+            signal?.addEventListener('abort', abort, { once: true });
+            current.promise.then((info) => finish(undefined, info), (error) => finish(error));
+            if (signal?.aborted)
+                abort();
+        });
+    }
+    return { verify, clear };
+}

package/dist/chatgpt-analytics.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { type HttpClient } from './http-client.js';
+import type { ParsedOperation } from './openapi/types.js';
+import type { McpToolDefinition } from './tools/generator.js';
+export declare const uiAnalyticsSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    invocation_source: z.ZodEnum<{
+        background: "background";
+        ui: "ui";
+    }>;
+    journey_id: z.ZodUUID;
+    action_id: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>;
+/** Which tool events the API accepts, read from its published schema. */
+export type ToolAnalytics = {
+    tools: ReadonlySet<string>;
+    errorDetails: boolean;
+};
+export declare function toolAnalyticsSupport(operations: ParsedOperation[]): ToolAnalytics | undefined;
+export declare function trackToolExecution<T>(name: string, args: Record<string, unknown>, meta: Record<string, unknown> | undefined, profile: string, http: HttpClient, execute: (args: Record<string, unknown>) => Promise<T>, analytics?: ToolAnalytics): Promise<T>;
+export declare function createAnalyticsTool(http: HttpClient): McpToolDefinition;
+//# sourceMappingURL=chatgpt-analytics.d.ts.map

package/dist/chatgpt-analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatgpt-analytics.d.ts","sourceRoot":"","sources":["../src/chatgpt-analytics.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAgC,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAM1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,eAAO,MAAM,iBAAiB;;;;;;;;kBAOnB,CAAC;AAsCZ,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC;AAIlF,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,aAAa,GAAG,SAAS,CAe7F;AA+BD,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACzC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EACtD,SAAS,CAAC,EAAE,aAAa,GACxB,OAAO,CAAC,CAAC,CAAC,CAmDZ;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,CA+BvE"}

package/dist/chatgpt-analytics.js

@@ -0,0 +1,172 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { ApiRequestError, cameFromApi } from './http-client.js';
+import { schemaProperty } from './openapi/parser.js';
+import { getToolAnalytics, runWithToolAnalytics, } from './tool-analytics-context.js';
+export const uiAnalyticsSchema = z
+    .object({
+    version: z.literal(1),
+    invocation_source: z.enum(['ui', 'background']),
+    journey_id: z.uuid(),
+    action_id: z.uuid().optional(),
+})
+    .strict();
+const attributionSchema = uiAnalyticsSchema.extend({
+    invocation_source: z.enum(['model', 'ui', 'background', 'unknown']),
+    journey_id: z.uuid().optional(),
+    conversation_id: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/)
+        .optional(),
+});
+// The API's names for these tools: the collector predates the tool rename, so events
+// keep the legacy names (see previousToolName in tool-names.ts).
+const toolNames = [
+    'open-sync-app',
+    'create-lipsync',
+    'create-lipsync-from-assets',
+    'create-translate-and-dub',
+    'create-dialogue-video',
+    'update-studio-draft',
+    'open-studio-project',
+];
+const eventSchema = z
+    .object({
+    event: z.enum([
+        'chatgpt_ui_loaded',
+        'chatgpt_project_opened',
+        'chatgpt_asset_selected',
+        'chatgpt_generate_clicked',
+        'chatgpt_tool_called',
+    ]),
+    event_id: z.uuid(),
+    attribution: attributionSchema,
+    tool_name: z.enum(toolNames).optional(),
+    outcome: z.enum(['success', 'error']).optional(),
+    duration_ms: z.number().finite().nonnegative().max(3_600_000).optional(),
+})
+    .strict();
+// The API rejects a whole event for an unknown tool or field, so new ones wait until
+// the deployed API's schema lists them.
+export function toolAnalyticsSupport(operations) {
+    const operation = operations.find((candidate) => candidate.operationId === 'analytics_captureChatgptEvent');
+    if (!operation)
+        return undefined;
+    const schema = operation.requestBody?.schema;
+    const names = schemaProperty(schema, 'tool_name')?.enum;
+    return {
+        tools: new Set(Array.isArray(names) ? names.filter((name) => typeof name === 'string') : toolNames),
+        errorDetails: ['error_source', 'error_status', 'error_code'].every((key) => Boolean(schemaProperty(schema, key))),
+    };
+}
+const ERROR_CODE = /^[A-Za-z0-9_.:-]{1,80}$/;
+function errorCode(error, reported) {
+    if (error instanceof ApiRequestError)
+        return error.code;
+    if (error instanceof z.ZodError)
+        return 'invalid_arguments';
+    if (error instanceof Error && ['AbortError', 'TimeoutError'].includes(error.name))
+        return 'aborted';
+    return reported?.code;
+}
+// Why a call failed, without its message: messages can echo user input.
+function errorDetails(error, result) {
+    const reported = result && typeof result === 'object' && 'structuredContent' in result
+        ? result.structuredContent?.error
+        : undefined;
+    const status = error instanceof ApiRequestError ? error.status : reported?.status;
+    const code = errorCode(error, reported);
+    return {
+        error_source: cameFromApi(error) ? 'api' : 'mcp',
+        ...(typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 599
+            ? { error_status: status }
+            : {}),
+        ...(typeof code === 'string' && ERROR_CODE.test(code) ? { error_code: code } : {}),
+    };
+}
+export async function trackToolExecution(name, args, meta, profile, http, execute, analytics) {
+    const { syncAnalytics, ...businessArgs } = args;
+    if (profile !== 'chatgpt')
+        return execute(businessArgs);
+    const ui = uiAnalyticsSchema.safeParse(syncAnalytics);
+    const session = meta?.['openai/session'];
+    const attribution = {
+        version: 1,
+        invocation_source: 'unknown',
+        ...(ui.success ? ui.data : {}),
+        ...(typeof session === 'string' && session.length <= 1024
+            ? {
+                conversation_id: createHash('sha256').update(session).digest('hex'),
+            }
+            : {}),
+    };
+    return runWithToolAnalytics(attribution, async () => {
+        const started = performance.now();
+        let outcome = 'error';
+        let result;
+        let failure;
+        try {
+            result = await execute(businessArgs);
+            outcome =
+                result && typeof result === 'object' && 'isError' in result && result.isError
+                    ? 'error'
+                    : 'success';
+            return result;
+        }
+        catch (error) {
+            failure = error;
+            throw error;
+        }
+        finally {
+            if (analytics?.tools.has(name) && attribution.invocation_source !== 'background') {
+                void http
+                    .request('post', '/v2/analytics/chatgpt-events', {
+                    signal: AbortSignal.timeout(1500),
+                    body: {
+                        event: 'chatgpt_tool_called',
+                        event_id: randomUUID(),
+                        attribution,
+                        tool_name: name,
+                        outcome,
+                        duration_ms: Math.min(performance.now() - started, 3_600_000),
+                        ...(outcome === 'error' && analytics.errorDetails
+                            ? errorDetails(failure, result)
+                            : {}),
+                    },
+                })
+                    .catch(() => undefined);
+            }
+        }
+    });
+}
+export function createAnalyticsTool(http) {
+    return {
+        name: 'analytics_track-event',
+        title: 'Record Sync interface interaction',
+        description: 'Record bounded interface telemetry for the authenticated Sync user. No prompts, media, credentials or account identifiers are accepted.',
+        inputSchema: eventSchema.shape,
+        outputSchema: { accepted: z.boolean() },
+        meta: { ui: { visibility: ['app'] }, 'openai/visibility': 'private' },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+        handler: async (args) => {
+            const event = eventSchema.parse(args);
+            const attribution = getToolAnalytics();
+            await http.request('post', '/v2/analytics/chatgpt-events', {
+                signal: AbortSignal.timeout(1500),
+                body: {
+                    ...event,
+                    attribution: {
+                        ...event.attribution,
+                        ...(attribution?.conversation_id && { conversation_id: attribution.conversation_id }),
+                    },
+                },
+            });
+            return { accepted: true };
+        },
+    };
+}

package/dist/chatgpt-app.d.ts

@@ -0,0 +1,15 @@
+import type { ResourceMetadata } from '@modelcontextprotocol/server';
+import type { SyncMcpConfig } from './config.js';
+import type { McpToolDefinition } from './tools/index.js';
+export type ChatgptApp = {
+    uri: string;
+    html: string;
+    initialProjectsVersion?: number;
+    metadata: ResourceMetadata;
+};
+/** Load once per server factory so every session serves the same verified bytes. */
+export declare function loadChatgptApp(config: SyncMcpConfig['chatgptApp']): Promise<ChatgptApp | undefined>;
+/** Retain immutable releases so cached tool descriptors remain readable after upgrades. */
+export declare function loadChatgptAppReleases(config: SyncMcpConfig['chatgptApp']): Promise<ChatgptApp[]>;
+export declare function createOpenSyncAppTool(app: ChatgptApp, projects?: McpToolDefinition): McpToolDefinition;
+//# sourceMappingURL=chatgpt-app.d.ts.map

package/dist/chatgpt-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatgpt-app.d.ts","sourceRoot":"","sources":["../src/chatgpt-app.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAIrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAuB1D,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAUF,oFAAoF;AACpF,wBAAsB,cAAc,CAClC,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,GAClC,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAoCjC;AAED,2FAA2F;AAC3F,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,GAClC,OAAO,CAAC,UAAU,EAAE,CAAC,CAcvB;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,UAAU,EACf,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,iBAAiB,CAuDnB"}

package/dist/chatgpt-app.js

@@ -0,0 +1,133 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { combineSignals } from './abort-signals.js';
+import { MAX_PREVIOUS_CHATGPT_RELEASES } from './chatgpt-release.js';
+import { MCP_APP_RESOURCE_MIME_TYPE } from './tools/upload-widget.js';
+const originSchema = z
+    .url({ protocol: /^https$/ })
+    .refine((value) => !value.includes('*') && new URL(value).origin === value, 'Use an exact HTTPS origin without paths, credentials, or wildcards.');
+const configSchema = z.object({
+    directory: z.string().min(1),
+    domain: originSchema,
+    resourceDomains: originSchema.array(),
+    connectDomains: originSchema.array().default([]),
+    uploadOrigins: originSchema.array().optional(),
+});
+const manifestSchema = z.object({
+    version: z.literal(1),
+    file: z.literal('app.html'),
+    initialProjectsVersion: z.number().int().positive().optional(),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+});
+async function readBounded(path, limit) {
+    if ((await stat(path)).size > limit)
+        throw new Error('ChatGPT app artifact exceeds its size limit.');
+    const bytes = await readFile(path);
+    if (bytes.length > limit)
+        throw new Error('ChatGPT app artifact exceeds its size limit.');
+    return bytes;
+}
+/** Load once per server factory so every session serves the same verified bytes. */
+export async function loadChatgptApp(config) {
+    if (!config)
+        return undefined;
+    const { directory, domain, resourceDomains, connectDomains } = configSchema.parse(config);
+    // Recording previews use object URLs; the verified bundle embeds Studio's font.
+    // Resource schemes do not expand backend connection origins.
+    const resourceSources = [...resourceDomains, 'blob:', 'data:'];
+    const manifest = manifestSchema.parse(JSON.parse((await readBounded(join(directory, 'manifest.json'), 4096)).toString('utf8')));
+    const bytes = await readBounded(join(directory, manifest.file), 8 * 1024 * 1024);
+    if (createHash('sha256').update(bytes).digest('hex') !== manifest.sha256)
+        throw new Error('ChatGPT app SHA256 does not match its release manifest.');
+    return {
+        uri: `ui://sync/app-${manifest.sha256}.html`,
+        html: new TextDecoder('utf-8', { fatal: true }).decode(bytes),
+        initialProjectsVersion: manifest.initialProjectsVersion,
+        metadata: {
+            title: 'Sync',
+            description: 'Browse your Sync projects and create videos using your existing assets.',
+            mimeType: MCP_APP_RESOURCE_MIME_TYPE,
+            _meta: {
+                ui: {
+                    domain,
+                    prefersBorder: true,
+                    csp: { connectDomains, resourceDomains: resourceSources },
+                    permissions: { camera: {}, microphone: {} },
+                },
+                'openai/widgetDomain': domain,
+                'openai/widgetCSP': { connect_domains: connectDomains, resource_domains: resourceSources },
+                'openai/widgetPrefersBorder': true,
+                'openai/widgetDescription': 'Sync projects and video creation interface. A successful open request does not confirm that the interface has rendered.',
+                'openai/ui': { availableDisplayModes: ['inline'] },
+            },
+        },
+    };
+}
+/** Retain immutable releases so cached tool descriptors remain readable after upgrades. */
+export async function loadChatgptAppReleases(config) {
+    if (!config)
+        return [];
+    const previous = z
+        .array(z.string().min(1))
+        .max(MAX_PREVIOUS_CHATGPT_RELEASES)
+        .parse(config.previousDirectories ?? []);
+    const apps = await Promise.all([config.directory, ...previous].map((directory) => loadChatgptApp({ ...config, directory })));
+    return [
+        ...new Map(apps.filter((app) => !!app).map((app) => [app.uri, app])).values(),
+    ];
+}
+export function createOpenSyncAppTool(app, projects) {
+    return {
+        name: 'app_open',
+        title: 'sync. labs',
+        description: 'Use this when the user asks to open Sync, upload media in its interface, or visually configure a talking photo, lipsync video, Translate & Dub, or Edit Dialogue workflow. Browse existing projects and choose media before generating. This interface does not provide subtitle-only output, standalone MP3 voiceovers, trimming, or background-music mixing; explain that limitation rather than opening it to fulfill those tasks. Requesting the interface does not start a generation or spend credits. The result only confirms the request; do not claim the interface rendered unless the user confirms it.',
+        inputSchema: {},
+        outputSchema: { requested: z.boolean(), renderStatus: z.literal('awaiting_client') },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+        meta: {
+            ui: { resourceUri: app.uri },
+            'openai/outputTemplate': app.uri,
+            'openai/toolInvocation/invoking': 'Preparing Sync',
+            'openai/toolInvocation/invoked': 'Sync interface requested',
+            'openai/ui': { entrypoints: [{ type: 'global' }, { type: 'thread' }] },
+        },
+        resultFormat: 'mcp',
+        handler: async (_args, context) => {
+            const structuredContent = { requested: true, renderStatus: 'awaiting_client' };
+            const result = {
+                content: [{ type: 'text', text: JSON.stringify(structuredContent) }],
+                structuredContent,
+            };
+            if (!projects || app.initialProjectsVersion !== 1)
+                return result;
+            // Optional read: never make opening the UI depend on a slow project API.
+            const deadline = AbortSignal.timeout(500);
+            const { signal, dispose } = combineSignals(context?.signal ? [context.signal, deadline] : [deadline]);
+            try {
+                const page = await projects.handler({ searchQuery: '', limit: 12, sortBy: 'updatedAt' }, { signal });
+                return {
+                    ...result,
+                    _meta: {
+                        // Per-invocation, authenticated data, never part of shared resource HTML.
+                        'sync/initialProjects': { version: 1, fetchedAt: Date.now(), page },
+                    },
+                };
+            }
+            catch {
+                // The widget can fetch normally and display the canonical API error/retry.
+                context?.signal?.throwIfAborted();
+                return result;
+            }
+            finally {
+                dispose();
+            }
+        },
+    };
+}

package/dist/chatgpt-release.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const MAX_PREVIOUS_CHATGPT_RELEASES = 11;
+export declare const chatgptReleaseSchema: z.ZodObject<{
+    current: z.ZodString;
+    previous: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** The image owns release selection; legacy environment paths remain readable. */
+export declare function resolveChatgptRelease(catalogPath: string, legacyDirectories: string[]): {
+    directory: string;
+    previousDirectories: string[];
+};
+//# sourceMappingURL=chatgpt-release.d.ts.map

package/dist/chatgpt-release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatgpt-release.d.ts","sourceRoot":"","sources":["../src/chatgpt-release.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAChD,eAAO,MAAM,oBAAoB;;;kBAM9B,CAAC;AAEJ,kFAAkF;AAClF,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE;;;EAuBrF"}

package/dist/chatgpt-release.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
+import { z } from 'zod';
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+export const MAX_PREVIOUS_CHATGPT_RELEASES = 11;
+export const chatgptReleaseSchema = z
+    .object({ current: digest, previous: z.array(digest).max(MAX_PREVIOUS_CHATGPT_RELEASES) })
+    .strict()
+    .refine(({ current, previous }) => new Set([current, ...previous]).size === previous.length + 1, 'Release hashes must be unique.');
+/** The image owns release selection; legacy environment paths remain readable. */
+export function resolveChatgptRelease(catalogPath, legacyDirectories) {
+    const catalog = chatgptReleaseSchema.parse(JSON.parse(readFileSync(catalogPath, 'utf8')));
+    const root = dirname(resolve(catalogPath));
+    const directory = resolve(root, catalog.current);
+    const previousDirectories = [
+        ...new Set([
+            ...catalog.previous.map((hash) => resolve(root, hash)),
+            ...legacyDirectories
+                .map((path) => resolve(path))
+                // Ignore only absent old image pins; a mount at the same path must stay readable.
+                .filter((path) => dirname(path) !== root || !digest.safeParse(basename(path)).success || existsSync(path)),
+        ]),
+    ].filter((path) => path !== directory);
+    z.array(z.string())
+        .max(MAX_PREVIOUS_CHATGPT_RELEASES, {
+        message: 'ChatGPT UI retention exceeds eleven previous bundles across the release manifest and legacy settings. Retire unused releases explicitly before deploying.',
+    })
+        .parse(previousDirectories);
+    return { directory, previousDirectories };
+}