@chrischall/gemini-mcp 1.5.1 → 1.6.1

package/dist/put-endpoint.js

@@ -1,122 +0,0 @@
-import { loadSigningKey } from './media-url.js';
-import { verifyUploadSignature, UPLOAD_MAX_BYTES, UPLOAD_KEY_PREFIX, acceptableUploadType } from './upload-url.js';
-import { wholeMb } from './bytes.js';
-function json(body, status) {
-    return new Response(JSON.stringify(body, null, 2), {
-        status,
-        headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },
-    });
-}
-/** Every error names the fix — the caller here is a shell, not a model. */
-function fail(status, error, hint) {
-    return json({ error, hint }, status);
-}
-/** A key this endpoint is willing to even verify a signature for: the upload
- * prefix, safe segment charset, no dot-segments, no empty segments. */
-export function wellFormedUploadKey(key) {
-    if (!key.startsWith(`${UPLOAD_KEY_PREFIX}/`))
-        return false;
-    const segments = key.split('/');
-    if (segments.length < 2)
-        return false;
-    return segments.every((s) => s.length > 0 && s !== '.' && s !== '..' && /^[A-Za-z0-9._-]+$/.test(s));
-}
-/**
- * Build the `/put` handler. `basePath` is stripped from the pathname to get the
- * R2 key, mirroring the `/media` handler so the two never drift.
- */
-export function createSignedPutHandler(env, basePath = '/put/') {
-    const maxBytes = env.maxBytes ?? UPLOAD_MAX_BYTES;
-    return async function handleSignedPut(request) {
-        if (request.method === 'OPTIONS') {
-            return new Response(null, { status: 204, headers: { allow: 'PUT, OPTIONS' } });
-        }
-        if (request.method !== 'PUT') {
-            return fail(405, `Method ${request.method} not allowed; signed upload URLs are PUT-only.`, 'Send the file bytes with: curl -sS -X PUT -H "Content-Type: <the signed type>" --data-binary @photo.jpg "<upload_url>"');
-        }
-        const url = new URL(request.url);
-        if (!url.pathname.startsWith(basePath))
-            return fail(404, 'Not found.', 'Use the exact upload_url returned by gemini_get_upload_url.');
-        const key = url.pathname
-            .slice(basePath.length)
-            .split('/')
-            .map((segment) => {
-            try {
-                return decodeURIComponent(segment);
-            }
-            catch {
-                return segment;
-            }
-        })
-            .join('/');
-        // Charset-checked BEFORE signature verification: the cross-protocol safety
-        // argument in upload-url.ts rests on keys never containing control chars.
-        if (!wellFormedUploadKey(key)) {
-            return fail(404, 'Not a valid upload key.', 'Use the exact upload_url returned by gemini_get_upload_url — the key path cannot be altered.');
-        }
-        const ct = url.searchParams.get('ct');
-        if (ct && !acceptableUploadType(ct)) {
-            return fail(415, `Unsupported content type "${ct}" — signed uploads accept raster image types only ` +
-                '(jpeg/png/webp/gif/avif/heic/heif/bmp/tiff; not SVG, which can carry scripts).', 'Mint the URL with a raster image content_type (e.g. image/jpeg).');
-        }
-        const now = env.now?.() ?? Date.now();
-        // Read-only key load: verification must never CREATE a signing secret (see
-        // loadSigningKey — a stale KV read would clobber the secret every
-        // outstanding media link was signed with).
-        const signingKey = await loadSigningKey(env.secret, env.store);
-        const check = signingKey
-            ? await verifyUploadSignature(signingKey, key, ct, url.searchParams.get('exp'), url.searchParams.get('sig'), now)
-            : { ok: false, reason: 'invalid' };
-        if (!check.ok) {
-            if (check.reason === 'expired') {
-                return fail(410, 'This upload URL has expired (they are valid for ~10 minutes).', 'Mint a fresh one with gemini_get_upload_url and retry.');
-            }
-            return fail(403, 'Invalid or missing upload signature.', 'Use the upload_url exactly as returned by gemini_get_upload_url, including the ct, exp and sig query parameters.');
-        }
-        const sentType = (request.headers.get('content-type') ?? '').split(';')[0].trim().toLowerCase();
-        if (sentType !== ct) {
-            return fail(415, `Content-Type "${sentType || '(none)'}" does not match the type this URL was minted for ("${ct}").`, `Send -H "Content-Type: ${ct}", or mint a new URL with the right content_type.`);
-        }
-        const declared = Number(request.headers.get('content-length'));
-        if (!request.headers.get('content-length') || !Number.isFinite(declared) || declared <= 0) {
-            return fail(411, 'Content-Length is required (and must be > 0).', 'curl sets it automatically with --data-binary @file.');
-        }
-        if (declared > maxBytes) {
-            return fail(413, `Upload is ${wholeMb(declared)}MB; the cap is ${wholeMb(maxBytes)}MB.`, 'Downscale the image before uploading — a reference photo does not need to be full-resolution.');
-        }
-        if (!request.body) {
-            return fail(400, 'Request had no body.', 'Send the file bytes as the request body, e.g. --data-binary @photo.jpg.');
-        }
-        // Enforce the cap on bytes actually READ, not the declared length — a
-        // hostile client can under-declare and stream more.
-        const chunks = [];
-        let total = 0;
-        const reader = request.body.getReader();
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            total += value.byteLength;
-            if (total > maxBytes) {
-                await reader.cancel().catch(() => { });
-                return fail(413, `Upload exceeded the ${wholeMb(maxBytes)}MB cap while being read.`, 'Downscale the image before uploading.');
-            }
-            chunks.push(value);
-        }
-        const body = new Uint8Array(total);
-        let offset = 0;
-        for (const chunk of chunks) {
-            body.set(chunk, offset);
-            offset += chunk.byteLength;
-        }
-        await env.bucket.put(key, body, { httpMetadata: { contentType: ct ?? 'application/octet-stream' } });
-        return json({
-            r2_key: key,
-            size_bytes: total,
-            content_type: ct,
-            hint: `Uploaded. Reference it by r2_key: pass it in images_r2_keys on a generation tool (master_images_r2_keys on gemini_image_set), ` +
-                `save it permanently with gemini_save_character, or convert it to a ~48h Gemini Files API reference with gemini_upload_file({ r2_key }). ` +
-                `Uploads follow the connector's media retention schedule (MEDIA_TTL_DAYS, default 7 days); saved characters are kept indefinitely.`,
-        }, 201);
-    };
-}

package/dist/upload-endpoint.js

@@ -1,79 +0,0 @@
-/** Media the Files API is useful for. Anything else is a caller mistake. */
-const ACCEPTED_PREFIXES = ['image/', 'video/', 'audio/'];
-function json(body, status) {
-    return new Response(JSON.stringify(body, null, 2), {
-        status,
-        headers: { 'content-type': 'application/json; charset=utf-8' },
-    });
-}
-/** Every error names the fix, because the caller here is a shell, not a model. */
-function fail(status, error, hint) {
-    return json({ error, hint }, status);
-}
-/**
- * Build the `/upload` route handler. `buildClient` is injected rather than
- * imported so the Worker can construct a client from *this request's* OAuth
- * props (never a shared singleton — see the cross-tenant note in session.ts),
- * and so tests can drive the whole handler against a stub client.
- */
-export function createUploadHandler(buildClient) {
-    return async function handleUpload(request, ctx) {
-        if (request.method === 'OPTIONS') {
-            return new Response(null, { status: 204, headers: { allow: 'POST, OPTIONS' } });
-        }
-        if (request.method !== 'POST') {
-            return fail(405, `Method ${request.method} not allowed on /upload.`, 'POST the raw file bytes as the request body.');
-        }
-        // The OAuth provider populates props from the validated bearer token. Its
-        // absence means the route was reached some other way — refuse rather than
-        // fall back to an ambient key, which on a multi-tenant Worker would bill an
-        // unauthenticated upload to whoever configured the environment.
-        const apiKey = ctx.props?.apiKey;
-        if (typeof apiKey !== 'string' || !apiKey) {
-            return fail(401, 'Unauthenticated.', 'Send the same Authorization: Bearer <access-token> you use for the /mcp endpoint.');
-        }
-        const contentType = (request.headers.get('content-type') ?? '').split(';')[0].trim().toLowerCase();
-        if (!ACCEPTED_PREFIXES.some((p) => contentType.startsWith(p))) {
-            return fail(415, `Unsupported Content-Type "${contentType || '(none)'}".`, 'Set Content-Type to the file\'s media type, e.g. -H "Content-Type: image/jpeg".');
-        }
-        const declared = request.headers.get('content-length');
-        const contentLength = Number(declared);
-        if (!declared || !Number.isFinite(contentLength) || contentLength <= 0) {
-            return fail(411, 'Content-Length is required (and must be > 0).', 'The Files API resumable upload declares the size up front, so the body cannot be sent chunked. ' +
-                'curl sets this automatically with --data-binary @file.');
-        }
-        const body = request.body;
-        if (!body) {
-            return fail(400, 'Request had no body.', 'Send the file bytes as the request body, e.g. --data-binary @photo.jpg.');
-        }
-        try {
-            const file = await buildClient(apiKey).uploadStream(body, contentType, displayNameFor(request, contentType), contentLength);
-            return json({
-                file_uri: file.name,
-                uri: file.uri,
-                name: file.name,
-                mime_type: file.mimeType,
-                ...(file.sizeBytes ? { size_bytes: Number(file.sizeBytes) } : {}),
-                expires: file.expirationTime ?? '~48h from upload',
-                hint: `Pass "${file.name}" as images_file_uris (or video_url) on any image tool. Gemini retains it ~48h.`,
-            }, 201);
-        }
-        catch (err) {
-            // Upstream failures are the interesting case here (bad key, quota, a file
-            // over the 2 GB cap), so the message is passed through rather than
-            // flattened into "upload failed".
-            const message = err instanceof Error ? err.message : String(err);
-            return fail(502, `Upload to the Gemini Files API failed: ${message}`, 'Check the API key on this connection is still valid and funded.');
-        }
-    };
-}
-/**
- * A display name for the upload: an explicit `?name=` wins, else the
- * `X-Filename` header (what a wrapper script would send), else the media type.
- * Cosmetic — the Files API keys on the returned resource name, not this.
- */
-function displayNameFor(request, contentType) {
-    const fromQuery = new URL(request.url).searchParams.get('name');
-    const raw = fromQuery ?? request.headers.get('x-filename') ?? `upload.${contentType.split('/')[1] || 'bin'}`;
-    return raw.replace(/[^\w.\-]+/g, '-').slice(0, 120) || 'upload';
-}