@celljs/cli 3.9.0 → 4.0.0

package/src/preset/cloudflare/cloudflare-preset.ts

@@ -0,0 +1,97 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { definePreset, type PresetOutputContext, type PresetPreviewContext, type PreviewProcess } from '@celljs/kit';
+import { Wrangler } from './wrangler.js';
+import { WranglerConfig } from './wrangler-config.js';
+
+/**
+ * Cloudflare Workers with Node.js compatibility. The Cell server (Express on the node:http server of
+ * Workers) is the worker; the frontend is served by Cloudflare as static assets, so only requests
+ * that match no asset reach the worker.
+ */
+export namespace CloudflarePreset {
+    /** `server/worker.mjs`: the worker module around the server bundle. */
+    export const WORKER = [
+        '// Generated by the Cell cloudflare preset. Do not edit.',
+        "import { createServer } from 'node:http';",
+        "import { httpServerHandler } from 'cloudflare:node';",
+        '',
+        '// Workers allow code generation (new Function) only while modules load and I/O only while a request is',
+        '// handled: the modules of the application load now, the application starts on the first request.',
+        'const server = createServer((req, res) => {',
+        '    firstRequest();',
+        '    application',
+        '        .then(handler => {',
+        '            if (!handler) {',
+        "                throw new Error('The application has no HTTP entry: add @celljs/express-adapter to the dependencies.');",
+        '            }',
+        '            handler(req, res);',
+        '        })',
+        '        .catch(error => {',
+        '            console.error(error);',
+        '            res.statusCode = 500;',
+        "            res.end('Internal Server Error');",
+        '        });',
+        '});',
+        'let firstRequest;',
+        'const requested = new Promise(resolve => (firstRequest = resolve));',
+        'let modulesLoaded;',
+        'const loaded = new Promise(resolve => (modulesLoaded = resolve));',
+        'const application = new Promise((resolve, reject) => {',
+        "    globalThis[Symbol.for('@celljs/core/application-host')] = {",
+        '        server,',
+        '        beforeStart: () => {',
+        '            modulesLoaded();',
+        '            return requested;',
+        '        },',
+        '        started: app => resolve(app.handler),',
+        '        failed: reject,',
+        '    };',
+        '});',
+        '',
+        "await import('./index.mjs');",
+        '// A module that fails to load fails the worker at startup, so wrangler dev and wrangler deploy report it.',
+        'await Promise.race([loaded, application]);',
+        '',
+        'export default httpServerHandler(server);',
+        '',
+    ].join('\n');
+
+    export function output(context: PresetOutputContext): void {
+        const { manifest, outDir, root } = context;
+        if (manifest.server) {
+            context.write(WranglerConfig.MAIN, WORKER);
+        }
+        const { config, warnings } = new WranglerConfig(root).generate(manifest, outDir, packageName(root));
+        for (const warning of warnings) {
+            context.warn(warning);
+        }
+        context.write(WranglerConfig.OUTPUT_FILE, `${JSON.stringify(config, null, 2)}\n`);
+    }
+
+    /** `wrangler dev` on the output: the worker runs in workerd, the runtime of Cloudflare, on this machine. */
+    export function preview({ root, outDir, port, env }: PresetPreviewContext): PreviewProcess {
+        const args = ['dev', '--config', join(outDir, WranglerConfig.OUTPUT_FILE), ...(port === undefined ? [] : ['--port', String(port)])];
+        const { command, args: commandArgs } = new Wrangler(root, env).command(args);
+        return { command, args: commandArgs };
+    }
+
+    export function packageName(root: string): string | undefined {
+        const file = join(root, 'package.json');
+        return existsSync(file) ? (JSON.parse(readFileSync(file, 'utf8')) as { name?: string }).name : undefined;
+    }
+}
+
+export const cloudflarePreset = definePreset({
+    name: 'cloudflare',
+    description: 'Cloudflare Workers; the frontend is served as static assets',
+    entry: 'http',
+    format: 'esm',
+    runtime: 'workerd',
+    staticHosting: true,
+    // Workers Builds (Cloudflare's CI) sets WORKERS_CI=1.
+    detect: env => env.WORKERS_CI === '1',
+    output: context => CloudflarePreset.output(context),
+    preview: context => CloudflarePreset.preview(context),
+    deployer: 'cloudflare',
+});

package/src/preset/cloudflare/wrangler-config.ts

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join, relative, resolve } from 'node:path';
+import { CellError, type OutputManifest } from '@celljs/kit';
+import { ConfigUtil } from '@celljs/vite';
+import { JsonUtil } from '../../utils/json-util.js';
+
+export type WranglerJson = Record<string, unknown>;
+
+export interface GeneratedWranglerConfig {
+    config: WranglerJson;
+    /** The project's configuration file the output is based on. */
+    source?: string;
+    warnings: string[];
+}
+
+/**
+ * The Wrangler configuration of the output (`<outDir>/wrangler.json`). Cloudflare settings (name,
+ * bindings, vars, routes, compatibility date) stay where Cloudflare documents them, in the project's
+ * `wrangler.json` or `wrangler.jsonc`; Cell adds what the build decides: the worker entry, the
+ * frontend as static assets and Node.js compatibility.
+ */
+export class WranglerConfig {
+    /** Project files, in Wrangler's order of precedence. */
+    static readonly FILES = ['wrangler.json', 'wrangler.jsonc', 'wrangler.toml'];
+    static readonly OUTPUT_FILE = 'wrangler.json';
+    /** The worker module, relative to the output directory. */
+    static readonly MAIN = 'server/worker.mjs';
+    /**
+     * From this date on `nodejs_compat` includes every Node.js module the Cell server needs: the
+     * node:http server Express runs on (2025-09-01) and node:tty (2026-03-17, used by `debug`).
+     */
+    static readonly MIN_COMPATIBILITY_DATE = '2026-03-17';
+    static readonly NODEJS_COMPAT = 'nodejs_compat';
+    static readonly DEFAULT_NAME = 'cell-app';
+
+    constructor(protected readonly root: string) {}
+
+    /** The project's Wrangler configuration file, if it has one. */
+    get file(): string | undefined {
+        return WranglerConfig.FILES.map(name => join(this.root, name)).find(file => existsSync(file));
+    }
+
+    /** The project's configuration, `{}` without a file. */
+    readProject(): WranglerJson {
+        const file = this.file;
+        if (!file) {
+            return {};
+        }
+        if (file.endsWith('.toml')) {
+            throw new CellError({
+                code: 'CELL_CLOUDFLARE_CONFIG_UNSUPPORTED',
+                message: 'The cloudflare preset reads wrangler.json or wrangler.jsonc; wrangler.toml is not supported.',
+                file,
+                hint: 'Rewrite wrangler.toml as wrangler.jsonc (the same keys in JSON syntax) and delete it.',
+            });
+        }
+        let config: unknown;
+        try {
+            config = JsonUtil.parseJsonc(readFileSync(file, 'utf8'));
+        } catch (cause) {
+            throw new CellError({
+                code: 'CELL_CLOUDFLARE_CONFIG_INVALID',
+                message: `${basename(file)} is not valid JSON: ${(cause as Error).message}`,
+                file,
+                hint: 'Fix the syntax; comments and trailing commas are allowed.',
+                cause,
+            });
+        }
+        if (!ConfigUtil.isPlainObject(config)) {
+            throw new CellError({
+                code: 'CELL_CLOUDFLARE_CONFIG_INVALID',
+                message: `${basename(file)} must contain an object.`,
+                file,
+                hint: 'Write the configuration as one JSON object, e.g. { "name": "my-app" }.',
+            });
+        }
+        return config;
+    }
+
+    /** The configuration of a build output whose manifest is `manifest`, written to `outDir`. */
+    generate(manifest: OutputManifest, outDir: string, packageName?: string): GeneratedWranglerConfig {
+        const project = this.readProject();
+        const source = this.file;
+        const where = source ? relative(this.root, source) : 'wrangler.json';
+        const warnings: string[] = [];
+        const { $schema: _schema, main, ...rest } = project;
+        if (main !== undefined && manifest.server) {
+            warnings.push(`${where}: \`main\` is ignored; the worker is the Cell application (${WranglerConfig.MAIN}).`);
+        }
+        const config: WranglerJson = {
+            name: WranglerConfig.workerName(packageName),
+            ...rest,
+            ...(manifest.server ? { main: WranglerConfig.MAIN } : {}),
+            compatibility_date: this.compatibilityDate(project.compatibility_date, source),
+            compatibility_flags: this.compatibilityFlags(project.compatibility_flags, source),
+        };
+        const assets = this.assets(project.assets, manifest, outDir, where, warnings);
+        if (assets) {
+            config.assets = assets;
+        }
+        return { config, source, warnings };
+    }
+
+    /** A valid worker name from a package name: `@scope/my-app` → `scope-my-app`. */
+    static workerName(packageName?: string): string {
+        const name = (packageName ?? '')
+            .toLowerCase()
+            .replace(/[^a-z0-9-]+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 63)
+            .replace(/-$/, '');
+        return name || WranglerConfig.DEFAULT_NAME;
+    }
+
+    protected compatibilityDate(value: unknown, file?: string): string {
+        if (value === undefined) {
+            return WranglerConfig.MIN_COMPATIBILITY_DATE;
+        }
+        if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+            throw new CellError({
+                code: 'CELL_CLOUDFLARE_CONFIG_INVALID',
+                message: `compatibility_date must be a date like "${WranglerConfig.MIN_COMPATIBILITY_DATE}", got ${JSON.stringify(value)}.`,
+                file,
+                hint: `Set "compatibility_date": "${WranglerConfig.MIN_COMPATIBILITY_DATE}" or a later date.`,
+            });
+        }
+        if (value < WranglerConfig.MIN_COMPATIBILITY_DATE) {
+            throw new CellError({
+                code: 'CELL_CLOUDFLARE_COMPATIBILITY_DATE',
+                message: `compatibility_date ${value} is too old: the Node.js modules the Cell server needs (node:http server, node:tty) are available from ${WranglerConfig.MIN_COMPATIBILITY_DATE}.`,
+                file,
+                hint: `Set "compatibility_date" to "${WranglerConfig.MIN_COMPATIBILITY_DATE}" or later.`,
+            });
+        }
+        return value;
+    }
+
+    protected compatibilityFlags(value: unknown, file?: string): string[] {
+        if (value !== undefined && !(Array.isArray(value) && value.every(flag => typeof flag === 'string'))) {
+            throw new CellError({
+                code: 'CELL_CLOUDFLARE_CONFIG_INVALID',
+                message: `compatibility_flags must be an array of strings, got ${JSON.stringify(value)}.`,
+                file,
+                hint: `Write "compatibility_flags": ["${WranglerConfig.NODEJS_COMPAT}"].`,
+            });
+        }
+        const flags = (value as string[] | undefined) ?? [];
+        return flags.includes(WranglerConfig.NODEJS_COMPAT) ? flags : [WranglerConfig.NODEJS_COMPAT, ...flags];
+    }
+
+    /**
+     * The frontend becomes the static assets of the worker; the project's other asset settings
+     * (`binding`, `not_found_handling`, ...) are kept. Cell frontends are single-page applications
+     * (`@celljs/serve-static` answers unknown paths with index.html on Node.js), so navigation to a
+     * path that is not a file gets index.html from Cloudflare unless the project sets
+     * `not_found_handling`; other requests, such as API calls, still reach the worker. Without a frontend, the project's own asset
+     * directory is kept, relative to the output directory now.
+     */
+    protected assets(value: unknown, manifest: OutputManifest, outDir: string, where: string, warnings: string[]): WranglerJson | undefined {
+        const assets = ConfigUtil.isPlainObject(value) ? (value as WranglerJson) : undefined;
+        if (manifest.public) {
+            if (typeof assets?.directory === 'string') {
+                warnings.push(`${where}: \`assets.directory\` is ignored; the assets are the Cell frontend (${manifest.public}).`);
+            }
+            return { not_found_handling: 'single-page-application', ...assets, directory: manifest.public };
+        }
+        if (typeof assets?.directory === 'string') {
+            return { ...assets, directory: relative(outDir, resolve(this.root, assets.directory)) || '.' };
+        }
+        return assets;
+    }
+}

package/src/preset/cloudflare/wrangler.ts

@@ -0,0 +1,113 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { stripVTControlCharacters } from 'node:util';
+
+/** How to start Wrangler, and whether it is the project's own. */
+export interface WranglerCommand {
+    command: string;
+    args: string[];
+    /** `project`: installed in the project; `npx`: {@link Wrangler.PACKAGE}, downloaded once by npm and cached. */
+    source: 'project' | 'npx';
+}
+
+export interface WranglerResult {
+    code: number;
+    /** stdout and stderr together, without terminal colours. */
+    output: string;
+    source: WranglerCommand['source'];
+}
+
+/**
+ * Runs Wrangler, Cloudflare's CLI, which bundles, previews and uploads workers and owns the
+ * Cloudflare credentials (`CLOUDFLARE_API_TOKEN` or `wrangler login`). It is not a dependency of
+ * Cell: the project's wrangler is used when it has one, otherwise npx installs it on first use.
+ */
+export class Wrangler {
+    static readonly PACKAGE = 'wrangler@4';
+
+    constructor(
+        protected readonly root: string,
+        protected readonly env: NodeJS.ProcessEnv = process.env,
+    ) {}
+
+    /** Node.js, also when the CLI itself runs on Bun (Wrangler supports Node.js only). */
+    static get node(): string {
+        return process.execPath.includes('bun') ? 'node' : process.execPath;
+    }
+
+    command(args: string[]): WranglerCommand {
+        const bin = this.projectBin();
+        if (bin) {
+            return { command: Wrangler.node, args: [bin, ...args], source: 'project' };
+        }
+        return { command: process.platform === 'win32' ? 'npx.cmd' : 'npx', args: ['--yes', Wrangler.PACKAGE, ...args], source: 'npx' };
+    }
+
+    /** The wrangler executable installed for the project, looked up like Node.js resolves packages. */
+    projectBin(): string | undefined {
+        for (let dir = this.root; ; dir = dirname(dir)) {
+            const manifest = join(dir, 'node_modules', 'wrangler', 'package.json');
+            if (existsSync(manifest)) {
+                const { bin } = JSON.parse(readFileSync(manifest, 'utf8')) as { bin?: string | Record<string, string> };
+                const path = typeof bin === 'string' ? bin : bin?.wrangler;
+                return path ? join(dirname(manifest), path) : undefined;
+            }
+            if (dirname(dir) === dir) {
+                return undefined;
+            }
+        }
+    }
+
+    /** Runs Wrangler in the project root without standard input; `relay` receives its output as it comes. */
+    run(args: string[], relay: (chunk: string, stream: 'stdout' | 'stderr') => void): Promise<WranglerResult> {
+        const { command, args: commandArgs, source } = this.command(args);
+        return new Promise((resolve, 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 => resolve({ code: code ?? 1, output: stripVTControlCharacters(output), source }));
+        });
+    }
+
+    /** The first error Wrangler reported (`✘ [ERROR] ...` and its indented continuation, e.g. a link), else its last line of output. */
+    static errorOf(output: string): string {
+        const lines = output.split('\n');
+        const start = lines.findIndex(line => line.trim().startsWith('✘ [ERROR]'));
+        if (start < 0) {
+            return (
+                lines
+                    .map(line => line.trim())
+                    .filter(Boolean)
+                    .pop() ?? 'Wrangler failed without output.'
+            );
+        }
+        const message = [lines[start].trim().replace(/^✘ \[ERROR\]\s*/, '')];
+        for (const line of lines.slice(start + 1)) {
+            if (line.trim() && !/^\s/.test(line)) {
+                break;
+            }
+            if (line.trim()) {
+                message.push(line.trim());
+            }
+        }
+        return message.join(' ');
+    }
+
+    /** Whether the account has no workers.dev subdomain yet, so a worker without `routes` has nowhere to go. */
+    static isSubdomainError(output: string): boolean {
+        return /register a workers\.dev subdomain/i.test(output);
+    }
+
+    /** Whether the failure is about missing or wrong Cloudflare credentials. */
+    static isAuthError(output: string): boolean {
+        return /CLOUDFLARE_API_TOKEN|wrangler login|not authenticated|Authentication error|Invalid access token|\[code: 10000\]|\[code: 9109\]/i.test(output);
+    }
+}

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

@@ -0,0 +1,237 @@
+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 { FcPreset } from './fc-preset.js';
+
+type Credentials = NonNullable<ReturnType<typeof CloudCredentials.alibaba>>;
+
+/** The calls of the Function Compute 3.0 API (2023-03-30, ROA) that the deployer makes. */
+export class FcClient {
+    static readonly VERSION = '2023-03-30';
+    readonly host: string;
+
+    constructor(
+        readonly region: string,
+        protected readonly credentials: Credentials,
+        protected readonly io: CloudIo = DEFAULT_IO,
+    ) {
+        this.host = `fcv3.${region}.aliyuncs.com`;
+    }
+
+    async call<T = Record<string, any>>(action: string, method: string, path: string, body?: unknown): Promise<T> {
+        const text = body === undefined ? '' : JSON.stringify(body);
+        const headers = RequestSigner.acs3(
+            { method, host: this.host, path, action, version: FcClient.VERSION, body: text, headers: text ? { 'content-type': 'application/json' } : {} },
+            this.credentials,
+            this.io.now(),
+        );
+        const response = await CloudApi.send(this.io, `https://${this.host}${path}`, { method, headers, body: text || undefined }, 'Alibaba Cloud FC');
+        const raw = await response.text();
+        const json = raw ? (JSON.parse(raw) as Record<string, any>) : {};
+        if (!response.ok) {
+            throw new CloudApiError(
+                response.status,
+                json.Code ?? json.code ?? String(response.status),
+                json.Message ?? json.message ?? raw,
+                json.RequestId ?? json.requestId,
+            );
+        }
+        return json as T;
+    }
+
+    /** The function, or undefined when there is none of that name. */
+    async getFunction(name: string): Promise<Record<string, any> | undefined> {
+        return this.orUndefined(() => this.call('GetFunction', 'GET', `/${FcClient.VERSION}/functions/${name}`));
+    }
+
+    async getTrigger(name: string, trigger: string): Promise<Record<string, any> | undefined> {
+        return this.orUndefined(() => this.call('GetTrigger', 'GET', `/${FcClient.VERSION}/functions/${name}/triggers/${trigger}`));
+    }
+
+    protected async orUndefined<T>(call: () => Promise<T>): Promise<T | undefined> {
+        try {
+            return await call();
+        } catch (error) {
+            if (error instanceof CloudApiError && error.status === 404) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+}
+
+/**
+ * Deploys the output of the fc preset with the Function Compute 3.0 API: the output directory as
+ * the code of a custom runtime function, and an anonymous HTTP trigger. Credentials:
+ * ALIBABA_CLOUD_ACCESS_KEY_ID / ALIBABA_CLOUD_ACCESS_KEY_SECRET (/ ALIBABA_CLOUD_SECURITY_TOKEN).
+ */
+export class FcDeployment {
+    static readonly TRIGGER = 'http';
+    /** Code of a direct upload, base64 in the request body. */
+    static readonly MAX_PACKAGE = 100 * 1024 * 1024;
+    static readonly CREDENTIALS = 'ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET';
+
+    readonly name: string;
+    readonly region: 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, 64);
+        this.region = (options.region as string | undefined) ?? env.ALIBABA_CLOUD_REGION_ID ?? 'cn-hangzhou';
+        this.credentials = CloudCredentials.alibaba(env);
+    }
+
+    /** Memory in MB and vCPUs: FC wants memory (GB) between 1 and 4 times the vCPUs, cpu in steps of 0.05. */
+    get resources(): { memorySize: number; cpu: number; timeout: number; instanceConcurrency: number } {
+        const { options } = this.context;
+        const memorySize = Math.ceil(((options.memory as number | undefined) ?? 1024) / 64) * 64;
+        const cpu = (options.cpu as number | undefined) ?? Math.max(0.05, Math.round(memorySize / 2048 / 0.05) * 0.05);
+        return {
+            memorySize,
+            cpu: Number(cpu.toFixed(2)),
+            timeout: (options.timeout as number | undefined) ?? 60,
+            instanceConcurrency: (options.concurrency as number | undefined) ?? 20,
+        };
+    }
+
+    functionConfig(code: CodePackage): Record<string, unknown> {
+        return {
+            description: 'Deployed by Cell (cell deploy --preset fc)',
+            runtime: FcPreset.RUNTIME,
+            handler: 'index.handler',
+            code: { zipFile: code.base64 },
+            customRuntimeConfig: { command: [`/code/${FcPreset.BOOTSTRAP}`], port: FcPreset.PORT },
+            ...this.resources,
+            diskSize: 512,
+            internetAccess: true,
+            environmentVariables: { NODE_ENV: 'production', ...((this.context.options.env as Record<string, string> | undefined) ?? {}) },
+        };
+    }
+
+    async plan(): Promise<DeployPlan> {
+        this.checkOutput();
+        const code = CodePackage.of(this.context.outDir);
+        let exists: { fn?: boolean; trigger?: boolean } = {};
+        if (this.credentials) {
+            const client = new FcClient(this.region, this.credentials, this.io);
+            const fn = await this.step('GetFunction', () => client.getFunction(this.name));
+            exists = { fn: Boolean(fn), trigger: Boolean(fn && (await this.step('GetTrigger', () => client.getTrigger(this.name, FcDeployment.TRIGGER)))) };
+        } else {
+            this.context.warn(`No Alibaba Cloud credentials (${FcDeployment.CREDENTIALS}): the plan does not say whether the function exists.`);
+        }
+        const action = (found?: boolean): DeployResource['action'] => (found === undefined ? 'deploy' : found ? 'update' : 'create');
+        return {
+            deployer: 'fc',
+            resources: [
+                {
+                    type: 'function',
+                    name: this.name,
+                    action: action(exists.fn),
+                    details: {
+                        region: this.region,
+                        runtime: `${FcPreset.RUNTIME} (Node.js ${this.context.options.node ?? '20'})`,
+                        ...this.resources,
+                        package: code.describe(),
+                    },
+                },
+                // An existing trigger is kept as it is (its settings may have been changed in the console).
+                ...(exists.trigger
+                    ? []
+                    : [
+                          {
+                              type: 'http-trigger',
+                              name: FcDeployment.TRIGGER,
+                              action: action(exists.trigger),
+                              details: { authType: 'anonymous' },
+                          } satisfies DeployResource,
+                      ]),
+            ],
+            details: {
+                region: this.region,
+                credentials: this.credentials ? 'ALIBABA_CLOUD_ACCESS_KEY_ID' : 'missing',
+                note: 'The default fcapp.run URL makes browsers download HTML pages; bind a custom domain to serve web pages.',
+            },
+        };
+    }
+
+    async apply(): Promise<Deployment> {
+        this.checkOutput();
+        if (!this.credentials) {
+            throw CloudCredentials.missing('Alibaba Cloud', FcDeployment.CREDENTIALS, ' (an AccessKey of a RAM user with AliyunFCFullAccess)');
+        }
+        const client = new FcClient(this.region, this.credentials, this.io);
+        const code = CodePackage.of(this.context.outDir);
+        code.checkSize(FcDeployment.MAX_PACKAGE, 'Function Compute', 'Keep large packages out of the server bundle (build.external) and the output directory.');
+        const config = this.functionConfig(code);
+        const path = `/${FcClient.VERSION}/functions/${this.name}`;
+        if (await this.step('GetFunction', () => client.getFunction(this.name))) {
+            this.context.info(`Updating function ${this.name} in ${this.region} (${code.describe()})…`);
+            await this.step('UpdateFunction', () => client.call('UpdateFunction', 'PUT', path, config));
+        } else {
+            this.context.info(`Creating function ${this.name} in ${this.region} (${code.describe()})…`);
+            await this.step('CreateFunction', () =>
+                client.call('CreateFunction', 'POST', `/${FcClient.VERSION}/functions`, { functionName: this.name, ...config }),
+            );
+        }
+        const fn = await CloudApi.poll(
+            this.io,
+            () => this.step('GetFunction', async () => (await client.getFunction(this.name)) ?? {}),
+            f => f.state !== 'Pending' && f.lastUpdateStatus !== 'InProgress',
+            `function ${this.name} to become active`,
+        );
+        if (fn.state === 'Failed' || fn.lastUpdateStatus === 'Failed') {
+            throw new CellError({
+                code: 'CELL_DEPLOY_FAILED',
+                message: `Function ${this.name} failed to become active: ${fn.stateReason ?? fn.lastUpdateStatusReason ?? 'no reason given'}`,
+                hint: 'Look at the function in the Function Compute console; fix the reported problem and deploy again.',
+            });
+        }
+        let trigger = await this.step('GetTrigger', () => client.getTrigger(this.name, FcDeployment.TRIGGER));
+        if (!trigger) {
+            this.context.info(`Creating HTTP trigger ${FcDeployment.TRIGGER}…`);
+            trigger = await this.step('CreateTrigger', () =>
+                client.call('CreateTrigger', 'POST', `${path}/triggers`, {
+                    triggerName: FcDeployment.TRIGGER,
+                    triggerType: 'http',
+                    qualifier: 'LATEST',
+                    triggerConfig: JSON.stringify({
+                        authType: 'anonymous',
+                        methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'],
+                        disableURLInternet: false,
+                    }),
+                }),
+            );
+        }
+        return { url: trigger?.httpTrigger?.urlInternet, details: { region: this.region, function: this.name } };
+    }
+
+    protected checkOutput(): void {
+        if (this.context.manifest.preset !== 'fc') {
+            throw new CellError({
+                code: 'CELL_DEPLOY_OUTPUT_MISMATCH',
+                message: `${this.context.outDir} has no output of the fc preset (built with: ${this.context.manifest.preset ?? 'no preset'}).`,
+                hint: 'Run cell deploy --preset fc without --skip-build, or cell build --preset fc first.',
+            });
+        }
+    }
+
+    protected async step<T>(name: string, call: () => Promise<T>): Promise<T> {
+        try {
+            return await call();
+        } catch (error) {
+            throw error instanceof CloudApiError ? CloudApi.failure('Function Compute', name, error) : error;
+        }
+    }
+}
+
+export const fcDeployer = defineDeployer({
+    name: 'fc',
+    description: 'Alibaba Cloud Function Compute 3.0 through its API (ALIBABA_CLOUD_ACCESS_KEY_ID / _SECRET)',
+    plan: context => new FcDeployment(context).plan(),
+    apply: context => new FcDeployment(context).apply(),
+});

package/src/preset/fc/fc-preset.ts

@@ -0,0 +1,51 @@
+import { definePreset, type PresetOutputContext } from '@celljs/kit';
+import { PresetOptionsSchema } from '../../deploy/cloud-api.js';
+import { ServerlessScripts } from '../serverless-scripts.js';
+
+/**
+ * Alibaba Cloud Function Compute 3.0, custom runtime: `bootstrap` starts the Cell server with the
+ * Node.js of the image on port 9000, and an HTTP trigger sends requests to it. The frontend, if
+ * any, is served by the server from `public/` like on Node.js.
+ */
+export namespace FcPreset {
+    export const BOOTSTRAP = 'bootstrap';
+    export const RUNTIME = 'custom.debian10';
+    export const PORT = 9000;
+    /** Node.js versions built into the custom.debian10 runtime. */
+    export const NODE = { '20': '/var/fc/lang/nodejs20/bin/node', '18': '/var/fc/lang/nodejs18/bin/node' } as const;
+
+    export const OPTIONS = PresetOptionsSchema.of({
+        name: 'string',
+        region: 'string',
+        node: ['20', '18'],
+        memory: 'number',
+        cpu: 'number',
+        timeout: 'number',
+        concurrency: 'number',
+        env: 'env',
+    });
+
+    export function output(context: PresetOutputContext): void {
+        const { manifest, options } = context;
+        if (!manifest.server) {
+            context.warn('The fc preset deploys a server, but the project builds no backend.');
+            return;
+        }
+        const node = NODE[(options.node as keyof typeof NODE | undefined) ?? '20'];
+        context.write(
+            BOOTSTRAP,
+            ServerlessScripts.bootstrap({ preset: 'fc', node, port: PORT, portVariable: 'FC_SERVER_PORT', server: manifest.server }),
+            0o755,
+        );
+    }
+}
+
+export const fcPreset = definePreset({
+    name: 'fc',
+    description: 'Alibaba Cloud Function Compute 3.0 (custom runtime, HTTP trigger)',
+    entry: 'http',
+    format: 'esm',
+    options: FcPreset.OPTIONS,
+    output: context => FcPreset.output(context),
+    deployer: 'fc',
+});