@theholocron/holocron-plugin-cloudflare 3.45.0 → 3.45.2

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { AuthError, Deployment, DeploymentProject, DeploymentProjectSettings, DeploymentRecord, DeploymentTarget, DeploymentTrigger, Dns, DnsRecord, ResolveTokenInput } from "@theholocron/cli";
-import { CloudflareClient, CloudflareClientOptions, createCloudflareClient } from "@theholocron/cloudflare-client";
+import { AuthError, Deployment, DeploymentProject, DeploymentProjectSettings, DeploymentRecord, DeploymentTarget, DeploymentTrigger, Dns, DnsRecord, ResolveTokenInput, WikiProxyConfig, Workers } from "@theholocron/cli";
+import { CloudflareClient, CloudflareClientOptions, CloudflareClientOptions as CloudflareClientOptions$1, createCloudflareClient } from "@theholocron/cloudflare-client";
 //#region src/auth.d.ts
 declare const resolveToken: (input?: ResolveTokenInput) => string;
 //#endregion
@@ -52,6 +52,34 @@ declare class CloudflareDns implements Dns {
   private resolveZone;
 }
 //#endregion
+//#region src/capabilities/workers.d.ts
+interface ZonesClient {
+  list(query?: {
+    name?: string;
+    per_page?: number;
+  }): Promise<Array<{
+    id: string;
+  }>>;
+}
+declare class CloudflareWorkers implements Workers {
+  private readonly zones;
+  private readonly accountId;
+  readonly key: "workers";
+  readonly providerName = "cloudflare";
+  private readonly zoneCache;
+  private readonly baseUrl;
+  private readonly fetchImpl;
+  private readonly token;
+  constructor(zones: ZonesClient, accountId: string, opts: Pick<CloudflareClientOptions$1, "token" | "baseUrl" | "fetch">);
+  upsertProxy(hostname: string, config: WikiProxyConfig): Promise<void>;
+  private putScript;
+  private listRoutes;
+  private createRoute;
+  private updateRoute;
+  private cfRequest;
+  private resolveZone;
+}
+//#endregion
 //#region src/verify-token.d.ts
 interface VerifyTokenSuccess {
   ok: true;
@@ -86,13 +114,15 @@ interface PluginContext {
 declare function createContext(options?: CloudflarePluginOptions): PluginContext;
 declare function dns(ctx: PluginContext): Dns;
 declare function deployment(ctx: PluginContext): Deployment;
+declare function workersCapability(ctx: PluginContext): Workers;
 declare function createPlugin(options?: CloudflarePluginOptions): {
   name: string;
   capabilities: {
     deployment?: (() => Deployment) | undefined;
+    workers?: (() => Workers) | undefined;
     dns: () => Dns;
   };
 };
 declare const AUTH_HINT: string;
 //#endregion
-export { AUTH_HINT, AuthError, type CloudflareClient, type CloudflareClientOptions, CloudflareDeployment, CloudflareDns, CloudflarePluginOptions, PluginContext, type ResolveTokenInput, type VerifyTokenFailure, type VerifyTokenResult, type VerifyTokenSuccess, createCloudflareClient, createContext, createPlugin, deployment, dns, resolveToken, verifyToken };
+export { AUTH_HINT, AuthError, type CloudflareClient, type CloudflareClientOptions, CloudflareDeployment, CloudflareDns, CloudflarePluginOptions, CloudflareWorkers, PluginContext, type ResolveTokenInput, type VerifyTokenFailure, type VerifyTokenResult, type VerifyTokenSuccess, createCloudflareClient, createContext, createPlugin, deployment, dns, resolveToken, verifyToken, workersCapability };

package/dist/index.mjs

@@ -182,6 +182,123 @@ function mapRecord(raw) {
 	};
 }
 //#endregion
+//#region src/capabilities/workers.ts
+var CloudflareWorkers = class {
+	zones;
+	accountId;
+	key = "workers";
+	providerName = "cloudflare";
+	zoneCache = /* @__PURE__ */ new Map();
+	baseUrl;
+	fetchImpl;
+	token;
+	constructor(zones, accountId, opts) {
+		this.zones = zones;
+		this.accountId = accountId;
+		this.token = opts.token;
+		this.baseUrl = opts.baseUrl ?? "https://api.cloudflare.com/client/v4";
+		this.fetchImpl = opts.fetch ?? globalThis.fetch;
+	}
+	async upsertProxy(hostname, config) {
+		const scriptName = hostnameToScriptName(hostname);
+		const script = generateProxyScript(config);
+		await this.putScript(scriptName, script);
+		const zoneId = await this.resolveZone(hostname);
+		const pattern = `${hostname}/*`;
+		const existing = (await this.listRoutes(zoneId)).find((r) => r.pattern === pattern);
+		if (existing) {
+			if (existing.script !== scriptName) await this.updateRoute(zoneId, existing.id, pattern, scriptName);
+		} else await this.createRoute(zoneId, pattern, scriptName);
+	}
+	async putScript(scriptName, script) {
+		const form = new FormData();
+		form.append("metadata", new Blob([JSON.stringify({
+			main_module: "index.js",
+			compatibility_date: "2025-08-31"
+		})], { type: "application/json" }));
+		form.append("index.js", new Blob([script], { type: "application/javascript+module" }), "index.js");
+		const path = `/accounts/${this.accountId}/workers/scripts/${encodeURIComponent(scriptName)}`;
+		const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+			method: "PUT",
+			headers: { authorization: `Bearer ${this.token}` },
+			body: form
+		});
+		if (!res.ok) {
+			const body = await res.text().catch(() => "");
+			throw new ProviderApiError(`Cloudflare PUT ${path} → ${res.status}`, res.status, body);
+		}
+	}
+	listRoutes(zoneId) {
+		return this.cfRequest("GET", `/zones/${zoneId}/workers/routes`);
+	}
+	createRoute(zoneId, pattern, script) {
+		return this.cfRequest("POST", `/zones/${zoneId}/workers/routes`, {
+			pattern,
+			script
+		});
+	}
+	updateRoute(zoneId, routeId, pattern, script) {
+		return this.cfRequest("PUT", `/zones/${zoneId}/workers/routes/${routeId}`, {
+			pattern,
+			script
+		});
+	}
+	async cfRequest(method, path, body) {
+		const headers = {
+			authorization: `Bearer ${this.token}`,
+			accept: "application/json"
+		};
+		const init = {
+			method,
+			headers
+		};
+		if (body !== void 0) {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		const res = await this.fetchImpl(`${this.baseUrl}${path}`, init);
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new ProviderApiError(`Cloudflare ${method} ${path} → ${res.status}`, res.status, text);
+		}
+		const envelope = await res.json();
+		if (!envelope.success) throw new ProviderApiError(`Cloudflare ${method} ${path} returned success:false`, 0, JSON.stringify(envelope.errors));
+		return envelope.result;
+	}
+	async resolveZone(domain) {
+		const cached = this.zoneCache.get(domain);
+		if (cached) return cached;
+		const parts = domain.split(".");
+		for (let i = 0; i < parts.length - 1; i++) {
+			const candidate = parts.slice(i).join(".");
+			const zones = await this.zones.list({ name: candidate });
+			if (zones.length > 0) {
+				this.zoneCache.set(domain, zones[0].id);
+				return zones[0].id;
+			}
+		}
+		throw new ProviderApiError(`No Cloudflare zone found for domain: ${domain}`, 404, void 0);
+	}
+};
+function hostnameToScriptName(hostname) {
+	return hostname.replace(/\./g, "-") + "-proxy";
+}
+function generateProxyScript(config) {
+	const targetJson = JSON.stringify(config.target);
+	const headersJson = JSON.stringify(config.headers);
+	return [
+		`export default {`,
+		`  async fetch(request) {`,
+		`    const url = new URL(request.url);`,
+		`    const target = new URL(url.pathname + url.search, ${targetJson});`,
+		`    const headers = new Headers(request.headers);`,
+		`    for (const [k, v] of Object.entries(${headersJson})) headers.set(k, v);`,
+		`    return fetch(target, { method: request.method, headers, body: request.body, redirect: "follow" });`,
+		`  },`,
+		`};`
+	].join("\n");
+}
+//#endregion
 //#region src/verify-token.ts
 async function verifyToken(token, opts = {}) {
 	const client = createCloudflareClient({
@@ -195,6 +312,12 @@ async function verifyToken(token, opts = {}) {
 			ok: true,
 			subject: `token ${result.id} (${result.status})`
 		};
+	} catch {}
+	try {
+		return {
+			ok: true,
+			subject: `zone: ${(await client.zones.list({ per_page: 1 }))[0]?.name ?? "unknown"}`
+		};
 	} catch (err) {
 		return {
 			ok: false,
@@ -226,16 +349,28 @@ function deployment(ctx) {
 	if (!ctx.options.accountId) throw new Error("Cloudflare accountId is required for Pages deployments — set accountId in the plugin options or CLOUDFLARE_ACCOUNT_ID env var");
 	return new CloudflareDeployment(ctx.client, ctx.options.accountId);
 }
+function workersCapability(ctx) {
+	if (!ctx.options.accountId) throw new Error("Cloudflare accountId is required for Workers — set accountId in the plugin options or CLOUDFLARE_ACCOUNT_ID env var");
+	const token = resolveToken(ctx.options);
+	return new CloudflareWorkers(ctx.client.zones, ctx.options.accountId, {
+		token,
+		baseUrl: ctx.options.baseUrl,
+		fetch: ctx.options.fetch
+	});
+}
 function createPlugin(options = {}) {
 	const ctx = createContext(options);
 	return {
 		name: "@theholocron/holocron-plugin-cloudflare",
 		capabilities: {
 			dns: () => dns(ctx),
-			...ctx.options.accountId ? { deployment: () => deployment(ctx) } : {}
+			...ctx.options.accountId ? {
+				deployment: () => deployment(ctx),
+				workers: () => workersCapability(ctx)
+			} : {}
 		}
 	};
 }
-const AUTH_HINT = "create an API token at https://dash.cloudflare.com/profile/api-tokens with Zone:Read, DNS:Edit, and Cloudflare Pages:Edit permissions, then run: holocron auth set cloudflare <TOKEN>";
+const AUTH_HINT = "create an API token at https://dash.cloudflare.com/profile/api-tokens with Zone:Read, DNS:Edit, Cloudflare Pages:Edit, Workers Scripts:Edit (account-level), and Workers Routes:Edit (zone-level) permissions, then run: holocron auth set cloudflare <TOKEN>";
 //#endregion
-export { AUTH_HINT, AuthError, CloudflareDeployment, CloudflareDns, createCloudflareClient, createContext, createPlugin, deployment, dns, resolveToken, verifyToken };
+export { AUTH_HINT, AuthError, CloudflareDeployment, CloudflareDns, CloudflareWorkers, createCloudflareClient, createContext, createPlugin, deployment, dns, resolveToken, verifyToken, workersCapability };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theholocron/holocron-plugin-cloudflare",
-  "version": "3.45.0",
+  "version": "3.45.2",
   "description": "Holocron plugin for Cloudflare. Implements the dns capability against Cloudflare's REST API — zone resolution, DNS record management.",
   "keywords": [
     "cloudflare",
@@ -31,10 +31,10 @@
   ],
   "devDependencies": {
     "@theholocron/cloudflare-client": "^1.12.0",
-    "@theholocron/eslint-config": "^7.25.4",
-    "@theholocron/tsconfig": "^7.20.0",
-    "@theholocron/tsdown-config": "^7.20.0",
-    "@theholocron/vitest-config": "^7.20.0",
+    "@theholocron/eslint-config": "^7.29.0",
+    "@theholocron/tsconfig": "^7.29.0",
+    "@theholocron/tsdown-config": "^7.29.0",
+    "@theholocron/vitest-config": "^7.29.0",
     "@types/node": "^26",
     "@vitest/coverage-v8": "^4.1.10",
     "@vitest/eslint-plugin": "^1.6.27",
@@ -46,11 +46,11 @@
     "tsx": "4.23.12",
     "typescript": "^5.9.3",
     "vitest": "^4.1.10",
-    "@theholocron/cli": "3.45.0"
+    "@theholocron/cli": "3.45.2"
   },
   "peerDependencies": {
     "@theholocron/cloudflare-client": "^1.12.0",
-    "@theholocron/cli": "3.45.0"
+    "@theholocron/cli": "3.45.2"
   },
   "peerDependenciesMeta": {
     "@theholocron/cloudflare-client": {}