@celljs/cli 3.9.0 → 4.0.0

package/src/preset/scf/scf-deployer.ts

@@ -0,0 +1,232 @@
+import { CellError, type DeployContext, type Deployment, type DeployPlan, type DeployResource, defineDeployer } from '@celljs/kit';
+import { CloudApi, CloudApiError, CloudCredentials, type CloudIo, CloudNames, DEFAULT_IO } from '../../deploy/cloud-api.js';
+import { CodePackage } from '../../deploy/code-package.js';
+import { RequestSigner } from '../../deploy/request-signer.js';
+import { ScfPreset } from './scf-preset.js';
+
+type Credentials = NonNullable<ReturnType<typeof CloudCredentials.tencent>>;
+
+/** Tencent Cloud API 3.0 calls of SCF (version 2018-04-16). */
+export class ScfClient {
+    static readonly HOST = 'scf.tencentcloudapi.com';
+    static readonly VERSION = '2018-04-16';
+
+    constructor(
+        readonly region: string,
+        protected readonly credentials: Credentials,
+        protected readonly io: CloudIo = DEFAULT_IO,
+    ) {}
+
+    async call<T = Record<string, any>>(action: string, params: Record<string, unknown>): Promise<T> {
+        const body = JSON.stringify(params);
+        const headers = RequestSigner.tc3(
+            { service: 'scf', host: ScfClient.HOST, action, version: ScfClient.VERSION, region: this.region, body },
+            this.credentials,
+            this.io.now(),
+        );
+        const response = await CloudApi.send(this.io, `https://${ScfClient.HOST}/`, { method: 'POST', headers, body }, 'Tencent Cloud SCF');
+        const raw = await response.text();
+        const json = (raw ? JSON.parse(raw) : {}) as { Response?: Record<string, any> & { Error?: { Code: string; Message: string }; RequestId?: string } };
+        const result = json.Response ?? {};
+        if (result.Error || !response.ok) {
+            throw new CloudApiError(response.status, result.Error?.Code ?? String(response.status), result.Error?.Message ?? raw, result.RequestId);
+        }
+        return result as T;
+    }
+
+    async getFunction(name: string, namespace: string): Promise<Record<string, any> | undefined> {
+        try {
+            return await this.call('GetFunction', { FunctionName: name, Namespace: namespace });
+        } catch (error) {
+            if (error instanceof CloudApiError && error.code.startsWith('ResourceNotFound')) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+}
+
+/**
+ * Deploys the output of the scf preset with the SCF API: a web function (Type HTTP) with the output
+ * directory as code, and a public function URL without authentication. Credentials:
+ * TENCENTCLOUD_SECRET_ID / TENCENTCLOUD_SECRET_KEY (/ TENCENTCLOUD_SESSION_TOKEN).
+ */
+export class ScfDeployment {
+    /** ZipFile of the API: base64 of at most 20 MB. */
+    static readonly MAX_PACKAGE = 20 * 1024 * 1024;
+    static readonly CREDENTIALS = 'TENCENTCLOUD_SECRET_ID and TENCENTCLOUD_SECRET_KEY';
+    static readonly TRIGGER = 'cell-url';
+
+    readonly name: string;
+    readonly region: string;
+    readonly namespace: string;
+    protected readonly credentials?: Credentials;
+
+    constructor(
+        protected readonly context: DeployContext,
+        protected readonly io: CloudIo = DEFAULT_IO,
+    ) {
+        const { options, env, root } = context;
+        this.name = CloudNames.functionName(root, options.name, 60);
+        this.region = (options.region as string | undefined) ?? env.TENCENTCLOUD_REGION ?? 'ap-guangzhou';
+        this.namespace = (options.namespace as string | undefined) ?? 'default';
+        this.credentials = CloudCredentials.tencent(env);
+    }
+
+    get runtime(): ScfPreset.Runtime {
+        return (this.context.options.runtime as ScfPreset.Runtime | undefined) ?? ScfPreset.DEFAULT_RUNTIME;
+    }
+
+    get settings(): { MemorySize: number; Timeout: number; Environment: { Variables: { Key: string; Value: string }[] } } {
+        const { options } = this.context;
+        const env = { NODE_ENV: 'production', ...((options.env as Record<string, string> | undefined) ?? {}) };
+        return {
+            MemorySize: Math.ceil(((options.memory as number | undefined) ?? 512) / 128) * 128,
+            Timeout: (options.timeout as number | undefined) ?? 60,
+            Environment: { Variables: Object.entries(env).map(([Key, Value]) => ({ Key, Value })) },
+        };
+    }
+
+    async plan(): Promise<DeployPlan> {
+        this.checkOutput();
+        const code = CodePackage.of(this.context.outDir);
+        let fn: boolean | undefined;
+        let url: boolean | undefined;
+        if (this.credentials) {
+            const client = new ScfClient(this.region, this.credentials, this.io);
+            fn = Boolean(await this.step('GetFunction', () => client.getFunction(this.name, this.namespace)));
+            url = fn && (await this.urlTrigger(client)) !== undefined;
+        } else {
+            this.context.warn(`No Tencent Cloud credentials (${ScfDeployment.CREDENTIALS}): the plan does not say whether the function exists.`);
+        }
+        const action = (found?: boolean): DeployResource['action'] => (found === undefined ? 'deploy' : found ? 'update' : 'create');
+        return {
+            deployer: 'scf',
+            resources: [
+                {
+                    type: 'web-function',
+                    name: this.name,
+                    action: action(fn),
+                    details: {
+                        region: this.region,
+                        namespace: this.namespace,
+                        runtime: this.runtime,
+                        memorySize: this.settings.MemorySize,
+                        timeout: this.settings.Timeout,
+                        package: code.describe(),
+                    },
+                },
+                ...(url
+                    ? []
+                    : [{ type: 'function-url', name: ScfDeployment.TRIGGER, action: action(url), details: { authType: 'NONE' } } satisfies DeployResource]),
+            ],
+            details: { region: this.region, credentials: this.credentials ? 'TENCENTCLOUD_SECRET_ID' : 'missing' },
+        };
+    }
+
+    async apply(): Promise<Deployment> {
+        this.checkOutput();
+        if (!this.credentials) {
+            throw CloudCredentials.missing('Tencent Cloud', ScfDeployment.CREDENTIALS, ' (an API key of a sub-user with QcloudSCFFullAccess)');
+        }
+        const client = new ScfClient(this.region, this.credentials, this.io);
+        const code = CodePackage.of(this.context.outDir);
+        code.checkSize(
+            ScfDeployment.MAX_PACKAGE,
+            'SCF',
+            'Keep large packages out of the server bundle and the output directory, or upload the package with COS from the SCF console.',
+        );
+        const id = { FunctionName: this.name, Namespace: this.namespace };
+        if (await this.step('GetFunction', () => client.getFunction(this.name, this.namespace))) {
+            this.context.info(`Updating web function ${this.name} in ${this.region} (${code.describe()})…`);
+            await this.waitActive(client);
+            await this.step('UpdateFunctionCode', () => client.call('UpdateFunctionCode', { ...id, ZipFile: code.base64, CodeSource: 'ZipFile' }));
+            await this.waitActive(client);
+            await this.step('UpdateFunctionConfiguration', () =>
+                client.call('UpdateFunctionConfiguration', { ...id, Runtime: this.runtime, ...this.settings }),
+            );
+        } else {
+            this.context.info(`Creating web function ${this.name} in ${this.region} (${code.describe()})…`);
+            await this.step('CreateFunction', () =>
+                client.call('CreateFunction', {
+                    ...id,
+                    Type: 'HTTP',
+                    Runtime: this.runtime,
+                    Code: { ZipFile: code.base64 },
+                    Description: 'Deployed by Cell (cell deploy --preset scf)',
+                    ...this.settings,
+                }),
+            );
+        }
+        await this.waitActive(client);
+        let url = await this.urlTrigger(client);
+        if (url === undefined) {
+            this.context.info('Creating the function URL…');
+            await this.step('CreateTrigger', () =>
+                client.call('CreateTrigger', {
+                    ...id,
+                    TriggerName: ScfDeployment.TRIGGER,
+                    Type: 'http',
+                    Qualifier: '$DEFAULT',
+                    TriggerDesc: JSON.stringify({ AuthType: 'NONE', NetConfig: { EnableIntranet: false, EnableExtranet: true } }),
+                }),
+            );
+            url = await this.urlTrigger(client);
+        }
+        return { url: url || undefined, details: { region: this.region, namespace: this.namespace, function: this.name } };
+    }
+
+    /** The public URL of the function URL trigger: '' when there is one without a URL yet, undefined when there is none. */
+    protected async urlTrigger(client: ScfClient): Promise<string | undefined> {
+        const { Triggers = [] } = await this.step('ListTriggers', () =>
+            client.call<{ Triggers?: Record<string, any>[] }>('ListTriggers', { FunctionName: this.name, Namespace: this.namespace }),
+        );
+        const trigger = Triggers.find(t => String(t.Type).toLowerCase() === 'http');
+        if (!trigger) {
+            return undefined;
+        }
+        return /https:\/\/[^\s"\\]+/.exec(JSON.stringify(trigger))?.[0] ?? '';
+    }
+
+    protected async waitActive(client: ScfClient): Promise<void> {
+        const fn = await CloudApi.poll(
+            this.io,
+            () => this.step('GetFunction', async () => (await client.getFunction(this.name, this.namespace)) ?? {}),
+            f => !/ing$/.test(String(f.Status ?? '')),
+            `web function ${this.name} to become active`,
+        );
+        if (fn.Status !== 'Active') {
+            const reasons = (fn.StatusReasons as { ErrorMessage?: string }[] | undefined)?.map(r => r.ErrorMessage).join('; ');
+            throw new CellError({
+                code: 'CELL_DEPLOY_FAILED',
+                message: `Web function ${this.name} is ${fn.Status}${reasons ? `: ${reasons}` : ''}.`,
+                hint: 'Look at the function in the SCF console (its logs show why scf_bootstrap failed); fix it and deploy again.',
+            });
+        }
+    }
+
+    protected checkOutput(): void {
+        if (this.context.manifest.preset !== 'scf') {
+            throw new CellError({
+                code: 'CELL_DEPLOY_OUTPUT_MISMATCH',
+                message: `${this.context.outDir} has no output of the scf preset (built with: ${this.context.manifest.preset ?? 'no preset'}).`,
+                hint: 'Run cell deploy --preset scf without --skip-build, or cell build --preset scf first.',
+            });
+        }
+    }
+
+    protected async step<T>(name: string, call: () => Promise<T>): Promise<T> {
+        try {
+            return await call();
+        } catch (error) {
+            throw error instanceof CloudApiError ? CloudApi.failure('SCF', name, error) : error;
+        }
+    }
+}
+
+export const scfDeployer = defineDeployer({
+    name: 'scf',
+    description: 'Tencent Cloud SCF through its API (TENCENTCLOUD_SECRET_ID / _KEY)',
+    plan: context => new ScfDeployment(context).plan(),
+    apply: context => new ScfDeployment(context).apply(),
+});

package/src/preset/scf/scf-preset.ts

@@ -0,0 +1,45 @@
+import { definePreset, type PresetOutputContext } from '@celljs/kit';
+import { PresetOptionsSchema } from '../../deploy/cloud-api.js';
+import { ServerlessScripts } from '../serverless-scripts.js';
+
+/**
+ * Tencent Cloud SCF web functions: `scf_bootstrap` starts the Cell server with the Node.js of the
+ * runtime on port 9000, and a function URL sends requests to it. Only /tmp is writable there.
+ */
+export namespace ScfPreset {
+    export const BOOTSTRAP = 'scf_bootstrap';
+    export const PORT = 9000;
+    export const RUNTIMES = { 'Nodejs18.15': '/var/lang/node18/bin/node', 'Nodejs16.13': '/var/lang/node16/bin/node' } as const;
+    export type Runtime = keyof typeof RUNTIMES;
+    export const DEFAULT_RUNTIME: Runtime = 'Nodejs18.15';
+
+    export const OPTIONS = PresetOptionsSchema.of({
+        name: 'string',
+        region: 'string',
+        namespace: 'string',
+        runtime: Object.keys(RUNTIMES),
+        memory: 'number',
+        timeout: 'number',
+        env: 'env',
+    });
+
+    export function output(context: PresetOutputContext): void {
+        const { manifest, options } = context;
+        if (!manifest.server) {
+            context.warn('The scf preset deploys a server, but the project builds no backend.');
+            return;
+        }
+        const node = RUNTIMES[(options.runtime as Runtime | undefined) ?? DEFAULT_RUNTIME];
+        context.write(BOOTSTRAP, ServerlessScripts.bootstrap({ preset: 'scf', node, port: PORT, server: manifest.server }), 0o755);
+    }
+}
+
+export const scfPreset = definePreset({
+    name: 'scf',
+    description: 'Tencent Cloud SCF web function (function URL)',
+    entry: 'http',
+    format: 'esm',
+    options: ScfPreset.OPTIONS,
+    output: context => ScfPreset.output(context),
+    deployer: 'scf',
+});

package/src/preset/serverless-scripts.ts

@@ -0,0 +1,132 @@
+/** What the generated scripts of the serverless presets need. */
+export interface BootstrapOptions {
+    preset: string;
+    /** Node.js of the platform's image; `node` from PATH is used when it is not there (local runs). */
+    node: string;
+    /** Port the platform sends requests to; `portVariable` overrides it when the platform sets one. */
+    port: number;
+    portVariable?: string;
+    /** Server bundle, relative to the output directory. */
+    server: string;
+}
+
+/**
+ * Start scripts and handlers around the server bundle for function platforms. Each runs the Cell
+ * server unchanged: FC and SCF start it as a web server on their port; Lambda and Vercel hand it
+ * requests in process through the application host (`Symbol.for('@celljs/core/application-host')`).
+ */
+export namespace ServerlessScripts {
+    const HOST_KEY = "Symbol.for('@celljs/core/application-host')";
+    const NO_HTTP = 'The application has no HTTP entry: add @celljs/express-adapter to the dependencies.';
+
+    /** A bash start script for FC custom runtimes and SCF web functions, run from the code directory. */
+    export function bootstrap({ preset, node, port, portVariable, server }: BootstrapOptions): string {
+        const portValue = portVariable ? `\${${portVariable}:-${port}}` : String(port);
+        return [
+            '#!/bin/bash',
+            `# Generated by the Cell ${preset} preset. Do not edit.`,
+            'cd "$(dirname "$0")" || exit 1',
+            `NODE=${node}`,
+            '[ -x "$NODE" ] || NODE=node',
+            'export NODE_ENV="${NODE_ENV:-production}"',
+            // The platform forwards requests to this port on all interfaces.
+            'export CELL_BACKEND__SERVER__HOST=0.0.0.0',
+            `export CELL_BACKEND__SERVER__PORT="${portValue}"`,
+            `exec "$NODE" ${server}`,
+            '',
+        ].join('\n');
+    }
+
+    /**
+     * `server/lambda.mjs`: the Lambda handler. The application serves HTTP on a loopback port during
+     * the init phase; each function URL / API Gateway HTTP API (payload 2.0) event becomes a request
+     * to it, and the response comes back base64-encoded.
+     */
+    export const LAMBDA_HANDLER = [
+        '// Generated by the Cell lambda preset. Do not edit.',
+        "import { createServer, request } from 'node:http';",
+        "import { fileURLToPath } from 'node:url';",
+        '',
+        "process.env.NODE_ENV ??= 'production';",
+        '// The package root: public/ (the frontend) is there.',
+        "process.chdir(fileURLToPath(new URL('..', import.meta.url)));",
+        'const server = createServer();',
+        'const application = new Promise((resolve, reject) => {',
+        `    globalThis[${HOST_KEY}] = {`,
+        '        server,',
+        '        started: app => {',
+        '            if (!app.handler) {',
+        `                reject(new Error('${NO_HTTP}'));`,
+        '                return;',
+        '            }',
+        "            server.on('request', app.handler);",
+        '            resolve();',
+        '        },',
+        '        failed: reject,',
+        '    };',
+        '});',
+        "await import('./index.mjs');",
+        'await application;',
+        "await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));",
+        'const { port } = server.address();',
+        '',
+        'export async function handler(event) {',
+        "    const method = event.requestContext?.http?.method ?? event.httpMethod ?? 'GET';",
+        "    const path = event.rawPath ?? event.path ?? '/';",
+        "    const query = event.rawQueryString ?? '';",
+        '    const headers = { ...event.headers };',
+        '    if (event.cookies?.length) {',
+        "        headers.cookie = event.cookies.join('; ');",
+        '    }',
+        "    delete headers['transfer-encoding'];",
+        "    const body = event.body == null ? undefined : Buffer.from(event.body, event.isBase64Encoded ? 'base64' : 'utf8');",
+        '    if (body) {',
+        "        headers['content-length'] = String(body.length);",
+        '    }',
+        '    const { res, data } = await new Promise((resolve, reject) => {',
+        "        const req = request({ host: '127.0.0.1', port, method, path: query ? `${path}?${query}` : path, headers }, res => {",
+        '            const chunks = [];',
+        "            res.on('data', chunk => chunks.push(chunk));",
+        "            res.on('end', () => resolve({ res, data: Buffer.concat(chunks) }));",
+        "            res.on('error', reject);",
+        '        });',
+        "        req.on('error', reject);",
+        '        req.end(body);',
+        '    });',
+        '    const responseHeaders = {};',
+        '    let cookies = [];',
+        '    for (const [name, value] of Object.entries(res.headers)) {',
+        "        if (name === 'set-cookie') {",
+        '            cookies = value;',
+        '        } else {',
+        "            responseHeaders[name] = Array.isArray(value) ? value.join(', ') : value;",
+        '        }',
+        '    }',
+        "    return { statusCode: res.statusCode, headers: responseHeaders, cookies, body: data.toString('base64'), isBase64Encoded: true };",
+        '}',
+        '',
+    ].join('\n');
+
+    /** `functions/index.func/vercel.mjs`: a Vercel Node.js function that hands each request to the application. */
+    export const VERCEL_FUNCTION = [
+        '// Generated by the Cell vercel preset. Do not edit.',
+        "import { fileURLToPath } from 'node:url';",
+        '',
+        "process.env.NODE_ENV ??= 'production';",
+        '// The function directory: public/index.html (the single-page fallback) is there.',
+        "process.chdir(fileURLToPath(new URL('.', import.meta.url)));",
+        'const application = new Promise((resolve, reject) => {',
+        `    globalThis[${HOST_KEY}] = {`,
+        `        started: app => (app.handler ? resolve(app.handler) : reject(new Error('${NO_HTTP}'))),`,
+        '        failed: reject,',
+        '    };',
+        '});',
+        "await import('./server/index.mjs');",
+        'const handler = await application;',
+        '',
+        'export default function cell(req, res) {',
+        '    handler(req, res);',
+        '}',
+        '',
+    ].join('\n');
+}

package/src/preset/vercel/vercel-deployer.ts

@@ -0,0 +1,168 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { stripVTControlCharacters } from 'node:util';
+import { CellError, type DeployContext, type Deployment, type DeployPlan, defineDeployer } from '@celljs/kit';
+import { CloudNames } from '../../deploy/cloud-api.js';
+import { VercelPreset } from './vercel-preset.js';
+
+/**
+ * Runs the Vercel CLI, which uploads prebuilt outputs and owns the credentials (`VERCEL_TOKEN` or
+ * `vercel login`). Like Wrangler it is not a dependency: the project's is used, else npx installs
+ * {@link VercelCli.PACKAGE} on first use.
+ */
+export class VercelCli {
+    static readonly PACKAGE = 'vercel@65';
+
+    constructor(
+        protected readonly root: string,
+        protected readonly env: NodeJS.ProcessEnv,
+    ) {}
+
+    command(args: string[]): { command: string; args: string[]; source: 'project' | 'npx' } {
+        for (let dir = this.root; ; dir = dirname(dir)) {
+            const manifest = join(dir, 'node_modules', 'vercel', 'package.json');
+            if (existsSync(manifest)) {
+                const { bin } = JSON.parse(readFileSync(manifest, 'utf8')) as { bin?: Record<string, string> };
+                if (bin?.vercel) {
+                    return {
+                        command: process.execPath.includes('bun') ? 'node' : process.execPath,
+                        args: [join(dirname(manifest), bin.vercel), ...args],
+                        source: 'project',
+                    };
+                }
+            }
+            if (dirname(dir) === dir) {
+                break;
+            }
+        }
+        return { command: process.platform === 'win32' ? 'npx.cmd' : 'npx', args: ['--yes', VercelCli.PACKAGE, ...args], source: 'npx' };
+    }
+
+    run(args: string[], relay: (chunk: string, stream: 'stdout' | 'stderr') => void): Promise<{ code: number; output: string; source: 'project' | 'npx' }> {
+        const { command, args: commandArgs, source } = this.command(args);
+        return new Promise((done, reject) => {
+            let output = '';
+            const child = spawn(command, commandArgs, { cwd: this.root, env: this.env, stdio: ['ignore', 'pipe', 'pipe'] });
+            for (const stream of ['stdout', 'stderr'] as const) {
+                child[stream].setEncoding('utf8');
+                child[stream].on('data', (chunk: string) => {
+                    output += chunk;
+                    relay(chunk, stream);
+                });
+            }
+            child.on('error', reject);
+            child.on('close', code => done({ code: code ?? 1, output: stripVTControlCharacters(output), source }));
+        });
+    }
+
+    static isAuthError(output: string): boolean {
+        return /no existing credentials|not logged in|vercel login|invalid token|token is not valid|missing.*token|authentication/i.test(output);
+    }
+
+    /** The last line Vercel printed with `Error`, else its last line. */
+    static errorOf(output: string): string {
+        const lines = output
+            .split('\n')
+            .map(l => l.trim())
+            .filter(Boolean);
+        return lines.filter(l => /error/i.test(l)).pop() ?? lines.pop() ?? 'The Vercel CLI failed without output.';
+    }
+}
+
+/** Deploys `.vercel/output` with `vercel deploy --prebuilt`: no build runs on Vercel. */
+export class VercelDeployment {
+    readonly project: string;
+    protected readonly cli: VercelCli;
+
+    constructor(protected readonly context: DeployContext) {
+        this.project = CloudNames.functionName(context.root, context.options.project, 100);
+        this.cli = new VercelCli(context.root, context.env);
+    }
+
+    get production(): boolean {
+        return (this.context.options.environment ?? 'production') === 'production';
+    }
+
+    async plan(): Promise<DeployPlan> {
+        this.checkOutput();
+        const { outDir, manifest, env, options } = this.context;
+        const config = JSON.parse(readFileSync(join(outDir, VercelPreset.FUNCTION, '.vc-config.json'), 'utf8').toString()) as { runtime: string };
+        const staticFiles = manifest.public ? (readdirSync(join(outDir, manifest.public), { recursive: true }) as string[]).length : 0;
+        return {
+            deployer: 'vercel',
+            resources: [
+                {
+                    type: 'deployment',
+                    name: this.project,
+                    action: 'deploy',
+                    details: {
+                        environment: this.production ? 'production' : 'preview',
+                        ...(options.scope ? { scope: options.scope } : {}),
+                        function: `index (${config.runtime})`,
+                        staticFiles,
+                    },
+                },
+            ],
+            details: {
+                output: relative(this.context.root, outDir),
+                cli: this.cli.command([]).source === 'project' ? 'project' : VercelCli.PACKAGE,
+                credentials: env.VERCEL_TOKEN ? 'VERCEL_TOKEN' : 'vercel login',
+            },
+        };
+    }
+
+    async apply(): Promise<Deployment> {
+        this.checkOutput();
+        const { env, options } = this.context;
+        const args = [
+            'deploy',
+            '--prebuilt',
+            '--yes',
+            '--project',
+            this.project,
+            '--create-if-missing',
+            ...(this.production ? ['--prod'] : []),
+            ...(options.scope ? ['--scope', String(options.scope)] : []),
+            ...(env.VERCEL_TOKEN ? ['--token', env.VERCEL_TOKEN] : []),
+        ];
+        this.context.info(`Deploying ${this.project} with vercel deploy --prebuilt…`);
+        const result = await this.cli.run(args, (chunk, stream) => this.context.relay(chunk, stream));
+        if (result.code !== 0) {
+            throw new CellError({
+                code: VercelCli.isAuthError(result.output) ? 'CELL_DEPLOY_UNAUTHORIZED' : 'CELL_DEPLOY_FAILED',
+                message: `vercel deploy failed: ${VercelCli.errorOf(result.output)}`,
+                hint: VercelCli.isAuthError(result.output)
+                    ? 'Set VERCEL_TOKEN (a token from vercel.com/account/tokens; vercel.scope for a team), or run npx vercel login once.'
+                    : 'Fix the reported problem (the Vercel CLI printed the details above), then run cell deploy again.',
+            });
+        }
+        const urls = result.output.match(/https:\/\/[\w.-]+\.vercel\.app\b/g) ?? [];
+        return { url: urls.pop(), details: { project: this.project, environment: this.production ? 'production' : 'preview' } };
+    }
+
+    protected checkOutput(): void {
+        const { manifest, outDir, root } = this.context;
+        if (manifest.preset !== 'vercel') {
+            throw new CellError({
+                code: 'CELL_DEPLOY_OUTPUT_MISMATCH',
+                message: `${outDir} has no output of the vercel preset (built with: ${manifest.preset ?? 'no preset'}).`,
+                hint: 'Run cell deploy --preset vercel without --skip-build, or cell build --preset vercel first.',
+            });
+        }
+        if (resolve(outDir) !== resolve(root, VercelPreset.OUT_DIR)) {
+            throw new CellError({
+                code: 'CELL_DEPLOY_OUTPUT_MISMATCH',
+                message: `vercel deploy --prebuilt reads .vercel/output, but the output is in ${relative(root, outDir)}.`,
+                hint: 'Build without --out-dir (the vercel preset writes to .vercel/output).',
+            });
+        }
+    }
+}
+
+export const vercelDeployer = defineDeployer({
+    name: 'vercel',
+    description: "Vercel through vercel deploy --prebuilt (the project's CLI, or vercel@65 installed on first use)",
+    plan: context => new VercelDeployment(context).plan(),
+    apply: context => new VercelDeployment(context).apply(),
+});