@theholocron/holocron-plugin-vercel 5.0.0-alpha.20 → 5.0.0-alpha.200

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 repo setup`.
+
+Declare the production domain in the Vercel provider options. On `holocron repo 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, VerifyTokenFailure, VerifyTokenResult, VerifyTokenResult as VerifyTokenResult$1, VerifyTokenSuccess } 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 repo 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,29 +33,36 @@ 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 repo 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
 //#region src/verify-token.d.ts
-/**
- * `verifyToken` — plugin-level export used by `holocron auth set` +
- * `holocron auth check`. Hits `GET /v2/user` and translates the
- * response into the normalized `VerifyTokenResult` shape.
- */
-interface VerifyTokenSuccess {
-  ok: true;
-  subject: string;
-}
-interface VerifyTokenFailure {
-  ok: false;
-  message: string;
-}
-type VerifyTokenResult = VerifyTokenSuccess | VerifyTokenFailure;
 interface VerifyTokenOptions {
   baseUrl?: string;
   fetch?: typeof fetch;
 }
-declare function verifyToken(token: string, opts?: VerifyTokenOptions): Promise<VerifyTokenResult>;
+declare function verifyToken(token: string, opts?: VerifyTokenOptions): Promise<VerifyTokenResult$1>;
 //#endregion
 //#region src/index.d.ts
 interface VercelPluginOptions extends ResolveTokenInput {
@@ -60,6 +70,8 @@ interface VercelPluginOptions extends ResolveTokenInput {
   teamId?: string;
   /** Default framework slug for new project creates. Defaults to "nextjs". */
   defaultFramework?: string;
+  /** Custom domain that `holocron repo setup` should attach to the Vercel project. */
+  domain?: string;
   /** Override base URL for tests. */
   baseUrl?: string;
   /** Override `fetch` for tests. */

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { AuthError, ProviderApiError, createResolveToken } from "@theholocron/cli";
 import { createVercelClient } from "@theholocron/vercel-client";
+import { errorMessage } from "@theholocron/misc-utils";
 //#region src/auth.ts
 const resolveToken = createResolveToken({
 	envName: "HOLOCRON_VERCEL_TOKEN",
@@ -13,10 +14,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 +63,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 repo 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));
@@ -87,6 +148,7 @@ function mapDeployment(raw, branch) {
 		status: normalizeState(raw.readyState)
 	};
 	if (raw.target) record.target = raw.target;
+	if (raw.errorMessage) record.errorMessage = raw.errorMessage;
 	return record;
 }
 function normalizeState(s) {
@@ -101,11 +163,6 @@ function normalizeState(s) {
 }
 //#endregion
 //#region src/verify-token.ts
-/**
-* `verifyToken` — plugin-level export used by `holocron auth set` +
-* `holocron auth check`. Hits `GET /v2/user` and translates the
-* response into the normalized `VerifyTokenResult` shape.
-*/
 async function verifyToken(token, opts = {}) {
 	const client = createVercelClient({
 		token,
@@ -121,7 +178,7 @@ async function verifyToken(token, opts = {}) {
 	} catch (err) {
 		return {
 			ok: false,
-			message: err instanceof Error ? err.message : String(err)
+			message: errorMessage(err)
 		};
 	}
 }
@@ -142,6 +199,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.20",
+  "version": "5.0.0-alpha.200",
   "description": "Holocron plugin for Vercel. Implements the deployment capability against the Vercel REST API.",
   "keywords": [
     "deployment",
@@ -8,12 +8,12 @@
     "plugin",
     "vercel"
   ],
-  "homepage": "https://github.com/theholocron/holocron/tree/main/packages/holocron-plugin-vercel#readme",
+  "homepage": "https://github.com/theholocron/holocron/tree/main/plugins/holocron-plugin-vercel#readme",
   "bugs": "https://github.com/theholocron/holocron/issues",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/theholocron/holocron.git",
-    "directory": "packages/holocron-plugin-vercel"
+    "directory": "plugins/holocron-plugin-vercel"
   },
   "license": "MIT",
   "author": "Newton Koumantzelis",
@@ -30,12 +30,13 @@
     "dist"
   ],
   "devDependencies": {
-    "@theholocron/eslint-config": "^8.0.0",
-    "@theholocron/http-client": "^1.20.0",
-    "@theholocron/tsconfig": "^8.0.0",
-    "@theholocron/tsdown-config": "^8.0.0",
-    "@theholocron/vercel-client": "^1.20.0",
-    "@theholocron/vitest-config": "^8.0.0",
+    "@theholocron/eslint-config": "^8.8.2",
+    "@theholocron/http-client": "^1.43.1",
+    "@theholocron/misc-utils": "^1.16.0",
+    "@theholocron/tsconfig": "^8.8.2",
+    "@theholocron/tsdown-config": "^8.8.2",
+    "@theholocron/vercel-client": "^1.43.1",
+    "@theholocron/vitest-config": "^8.8.2",
     "@types/node": "^26",
     "@vitest/coverage-v8": "^4.1.11",
     "@vitest/eslint-plugin": "^1.6.27",
@@ -43,14 +44,15 @@
     "eslint-plugin-n": "^18.3.0",
     "globals": "^17.11.0",
     "tsdown": "^0.22.14",
-    "tsx": "4.23.12",
+    "tsx": "4.23.15",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "@theholocron/cli": "5.0.0-alpha.20"
+    "@theholocron/cli": "5.0.0-alpha.200"
   },
   "peerDependencies": {
-    "@theholocron/vercel-client": "^1.20.0",
-    "@theholocron/cli": "5.0.0-alpha.20"
+    "@theholocron/misc-utils": "^1.16.0",
+    "@theholocron/vercel-client": "^1.43.1",
+    "@theholocron/cli": "5.0.0-alpha.200"
   },
   "peerDependenciesMeta": {
     "@theholocron/vercel-client": {}