@theholocron/holocron-plugin-vercel 5.0.0-alpha.4 → 5.0.0-alpha.41

package/README.md

@@ -55,10 +55,39 @@ Capability covers:
 - `updateProjectSettings()` — toggle preview deploys, git-creates-deploys
 - `setEnvVar()` / `listEnvVars()` — per-target env vars
 - `triggerDeployment()` — branch deploys with optional named target
+  (requires a project already linked to a Git repo)
+- `deployFunction()` — deploy directly from source files, bypassing Git
+  entirely: `POST /v13/deployments` with an inline `files` array, no
+  linked repo required. For a consumer with no repo to deploy from — a
+  webhook receiver shipped as an npm package, for instance. Always
+  deploys with `projectSettings.framework: null` (a bare function, not
+  an app) — `defaultFramework` only applies to `ensureProject()`'s
+  Git-linked path.
 - `getDeployment()` — fetch a deployment by id
+- `ensureCustomDomain()` — idempotent add (list → add-if-missing →
+  check DNS routing). Ownership (`verified`) and DNS routing are
+  separate: once a team already owns a domain's apex, every new
+  subdomain auto-verifies immediately with no fresh challenge, so
+  attachment alone can't tell you whether traffic is actually routed
+  to Vercel yet. `domains.config()` answers that regardless of
+  ownership state, returning a per-project CNAME target — never a
+  fixed well-known host — only when DNS isn't already configured. The
+  returned DNS record is handed to the configured `dns` provider by
+  `holocron setup`.
+
+Declare the production domain in the Vercel provider options. On `holocron setup`,
+the domain is attached to the project and any Vercel verification CNAME is
+upserted through the configured DNS provider:
+
+```ts
+providers: {
+	deployment: ["vercel", { teamId: "team_…", domain: "sentinel.example.com" }],
+	dns: "cloudflare",
+}
+```
 
 Out of scope for alpha.0 (file a follow-up if needed):
 
-- Domain management (`addDomain` / `removeDomain`)
+- Domain removal (`removeDomain`)
 - Deletion (`deleteProject`)
 - Marketplace integrations (e.g. `vercel install neon` for vault-managed databases)

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AuthError, Deployment, DeploymentProject, DeploymentProjectSettings, DeploymentRecord, DeploymentTarget, DeploymentTrigger, ResolveTokenInput } from "@theholocron/cli";
+import { AuthError, DeployFunctionConfig, DeployFunctionResult, Deployment, DeploymentProject, DeploymentProjectSettings, DeploymentRecord, DeploymentTarget, DeploymentTrigger, DnsRecordRequest, ResolveTokenInput } from "@theholocron/cli";
 import { VercelClient, VercelClient as VercelClient$1, VercelClientOptions, createVercelClient } from "@theholocron/vercel-client";
 //#region src/auth.d.ts
 declare const resolveToken: (input?: ResolveTokenInput) => string;
@@ -7,11 +7,14 @@ declare const resolveToken: (input?: ResolveTokenInput) => string;
 interface DeploymentOptions {
   /** Optional framework hint passed to project creates. Defaults to "nextjs". */
   defaultFramework?: string;
+  /** Custom domain that `holocron setup` should attach to this project. */
+  domain?: string;
 }
 declare class VercelDeployment implements Deployment {
   private readonly client;
   readonly key: "deployment";
   readonly providerName = "vercel";
+  readonly domain?: string;
   private readonly defaultFramework;
   constructor(client: () => VercelClient$1, opts?: DeploymentOptions);
   listProjects(): Promise<DeploymentProject[]>;
@@ -30,6 +33,27 @@ declare class VercelDeployment implements Deployment {
     target?: DeploymentTrigger;
   }): Promise<DeploymentRecord>;
   getDeployment(deploymentId: string): Promise<DeploymentRecord>;
+  deployFunction(projectId: string, config: DeployFunctionConfig): Promise<DeployFunctionResult>;
+  /**
+   * Idempotent — matches `Deployment.ensureCustomDomain`'s contract
+   * (never break on re-runs, per CLAUDE.md's probe-then-act standard).
+   *
+   * Ownership (`domains.add`'s `verified`) and DNS routing are separate
+   * concerns: once a team already owns the domain's apex (true for any
+   * org with more than one project on the same domain), every new
+   * subdomain auto-verifies immediately with no `verification`
+   * challenge — re-adding an already-attached domain returns 409, not
+   * a fresh one. So attachment alone can't tell us whether traffic is
+   * actually routed to Vercel yet. `domains.config()` (Vercel's DNS
+   * *configuration* check) answers that regardless of ownership state:
+   * `misconfigured` + a `recommendedCNAME`, per-project, never a fixed
+   * well-known host — always read it from this response, never
+   * hardcode it. Returned as a `DnsRecordRequest` — the caller (e.g.
+   * `holocron setup`'s custom-domain step) hands it straight to
+   * `dns.upsertRecord()`, same as `Wiki.dnsRecord()` already does for
+   * the wiki's own domain.
+   */
+  ensureCustomDomain(projectId: string, hostname: string): Promise<DnsRecordRequest | null>;
   private getProjectByName;
 }
 //#endregion
@@ -60,6 +84,8 @@ interface VercelPluginOptions extends ResolveTokenInput {
   teamId?: string;
   /** Default framework slug for new project creates. Defaults to "nextjs". */
   defaultFramework?: string;
+  /** Custom domain that `holocron setup` should attach to the Vercel project. */
+  domain?: string;
   /** Override base URL for tests. */
   baseUrl?: string;
   /** Override `fetch` for tests. */

package/dist/index.mjs

@@ -13,10 +13,12 @@ var VercelDeployment = class {
 	client;
 	key = "deployment";
 	providerName = "vercel";
+	domain;
 	defaultFramework;
 	constructor(client, opts = {}) {
 		this.client = client;
 		this.defaultFramework = opts.defaultFramework ?? "nextjs";
+		this.domain = opts.domain;
 	}
 	async listProjects() {
 		const { projects } = await this.client().projects.list();
@@ -60,6 +62,64 @@ var VercelDeployment = class {
 		const raw = await this.client().deployments.get(deploymentId);
 		return mapDeployment(raw, raw.meta?.githubCommitRef ?? null);
 	}
+	async deployFunction(projectId, config) {
+		const raw = await this.client().deployments.create({
+			projectName: projectId,
+			files: Object.entries(config.files).map(([file, content]) => ({
+				file,
+				content
+			})),
+			framework: null,
+			target: config.target
+		});
+		return {
+			deploymentId: raw.id,
+			url: raw.url
+		};
+	}
+	/**
+	* Idempotent — matches `Deployment.ensureCustomDomain`'s contract
+	* (never break on re-runs, per CLAUDE.md's probe-then-act standard).
+	*
+	* Ownership (`domains.add`'s `verified`) and DNS routing are separate
+	* concerns: once a team already owns the domain's apex (true for any
+	* org with more than one project on the same domain), every new
+	* subdomain auto-verifies immediately with no `verification`
+	* challenge — re-adding an already-attached domain returns 409, not
+	* a fresh one. So attachment alone can't tell us whether traffic is
+	* actually routed to Vercel yet. `domains.config()` (Vercel's DNS
+	* *configuration* check) answers that regardless of ownership state:
+	* `misconfigured` + a `recommendedCNAME`, per-project, never a fixed
+	* well-known host — always read it from this response, never
+	* hardcode it. Returned as a `DnsRecordRequest` — the caller (e.g.
+	* `holocron setup`'s custom-domain step) hands it straight to
+	* `dns.upsertRecord()`, same as `Wiki.dnsRecord()` already does for
+	* the wiki's own domain.
+	*/
+	async ensureCustomDomain(projectId, hostname) {
+		const { domains: existing } = await this.client().domains.list(projectId);
+		let apexName = existing.find((d) => d.name === hostname)?.apexName;
+		if (!apexName) try {
+			apexName = (await this.client().domains.add(projectId, hostname)).apexName;
+		} catch (err) {
+			if (!(err instanceof ProviderApiError && err.status === 409)) throw err;
+			const { domains: refreshed } = await this.client().domains.list(projectId);
+			apexName = refreshed.find((d) => d.name === hostname)?.apexName;
+		}
+		if (!apexName) return null;
+		const config = await this.client().domains.config(hostname, projectId);
+		if (!config.misconfigured) return null;
+		const cname = config.recommendedCNAME[0]?.value;
+		if (!cname) return null;
+		return {
+			zone: apexName,
+			record: {
+				type: "CNAME",
+				name: hostname,
+				content: cname
+			}
+		};
+	}
 	async getProjectByName(name) {
 		try {
 			return mapProject(await this.client().projects.get(name));
@@ -142,6 +202,7 @@ function createContext(options = {}) {
 function deployment(ctx) {
 	const opts = {};
 	if (ctx.options.defaultFramework !== void 0) opts.defaultFramework = ctx.options.defaultFramework;
+	if (ctx.options.domain !== void 0) opts.domain = ctx.options.domain;
 	return new VercelDeployment(ctx.client, opts);
 }
 function createPlugin(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theholocron/holocron-plugin-vercel",
-  "version": "5.0.0-alpha.4",
+  "version": "5.0.0-alpha.41",
   "description": "Holocron plugin for Vercel. Implements the deployment capability against the Vercel REST API.",
   "keywords": [
     "deployment",
@@ -31,9 +31,10 @@
   ],
   "devDependencies": {
     "@theholocron/eslint-config": "^8.0.0",
+    "@theholocron/http-client": "^1.24.0",
     "@theholocron/tsconfig": "^8.0.0",
     "@theholocron/tsdown-config": "^8.0.0",
-    "@theholocron/vercel-client": "^1.14.2",
+    "@theholocron/vercel-client": "^1.24.0",
     "@theholocron/vitest-config": "^8.0.0",
     "@types/node": "^26",
     "@vitest/coverage-v8": "^4.1.11",
@@ -45,11 +46,11 @@
     "tsx": "4.23.12",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "@theholocron/cli": "5.0.0-alpha.4"
+    "@theholocron/cli": "5.0.0-alpha.41"
   },
   "peerDependencies": {
-    "@theholocron/vercel-client": "^1.14.2",
-    "@theholocron/cli": "5.0.0-alpha.4"
+    "@theholocron/vercel-client": "^1.24.0",
+    "@theholocron/cli": "5.0.0-alpha.41"
   },
   "peerDependenciesMeta": {
     "@theholocron/vercel-client": {}