@buildwithharbor/pier 0.1.5

package/dist/local-worker-runtime-child.mjs

@@ -0,0 +1,377 @@
+import { watchFile, unwatchFile } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { resolve } from "node:path";
+
+import Cloudflare from "cloudflare";
+import { Miniflare } from "miniflare";
+import {
+  maybeStartOrUpdateRemoteProxySession,
+  unstable_convertConfigBindingsToStartWorkerBindings,
+  unstable_getMiniflareWorkerOptions,
+} from "wrangler";
+
+const runtimeConfig = await readRuntimeConfig();
+const adapterConfig = await readJson(runtimeConfig.adapterConfigPath);
+const port = runtimeConfig.port ?? 8787;
+const remoteBindings = convertRemoteBindings(adapterConfig);
+
+if (!Number.isInteger(port) || port <= 0) {
+  throw new Error(
+    `Worker dev port must be a positive integer. Received: ${String(port)}`
+  );
+}
+
+const cloudflareCredentials =
+  remoteBindings.length > 0
+    ? {
+        accountId: requiredEnv("CLOUDFLARE_ACCOUNT_ID"),
+        apiToken: requiredEnv("CLOUDFLARE_API_TOKEN"),
+      }
+    : undefined;
+
+if (cloudflareCredentials) {
+  await ensureRemoteResources({ ...cloudflareCredentials, adapterConfig });
+}
+const proxySession =
+  remoteBindings.length > 0 && cloudflareCredentials
+    ? await maybeStartOrUpdateRemoteProxySession(
+        {
+          account_id: cloudflareCredentials.accountId,
+          bindings: remoteBindings,
+          name: runtimeConfig.workerName,
+        },
+        null
+      )
+    : undefined;
+
+if (remoteBindings.length > 0 && !proxySession) {
+  throw new Error("Pier could not start the Cloudflare remote binding proxy.");
+}
+
+const remoteProxyConnectionString =
+  proxySession?.session.remoteProxyConnectionString;
+const miniflare = new Miniflare(miniflareOptions(remoteProxyConnectionString));
+await miniflare.ready;
+
+const server = createServer(async (request, response) => {
+  try {
+    const miniflareResponse = await dispatchToMiniflare(miniflare, request);
+    response.writeHead(
+      miniflareResponse.status,
+      Object.fromEntries(miniflareResponse.headers.entries())
+    );
+    response.end(Buffer.from(await miniflareResponse.arrayBuffer()));
+  } catch (error) {
+    response.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+    response.end(`${errorMessage(error)}\n`);
+  }
+});
+
+await new Promise((resolveListen, rejectListen) => {
+  server.once("error", rejectListen);
+  server.listen(port, "127.0.0.1", () => {
+    server.off("error", rejectListen);
+    resolveListen();
+  });
+});
+
+console.log(`Pier Worker runtime: http://127.0.0.1:${port}`);
+console.log(`Project: ${runtimeConfig.projectName}`);
+console.log(`App: ${runtimeConfig.appName}`);
+console.log(`Worker: ${runtimeConfig.workerName}`);
+printRemoteBindingSummary(adapterConfig);
+for (const serviceWorker of runtimeConfig.serviceWorkers) {
+  console.log(
+    `Local service binding worker: ${serviceWorker.appName} -> ${serviceWorker.workerName}`
+  );
+}
+console.log(`Watching Worker bundle: ${runtimeConfig.workerPath}`);
+
+watchFile(runtimeConfig.workerPath, { interval: 250 }, () => {
+  void reloadMiniflare();
+});
+for (const serviceWorker of runtimeConfig.serviceWorkers) {
+  watchFile(serviceWorker.workerPath, { interval: 250 }, () => {
+    void reloadMiniflare();
+  });
+}
+
+let disposed = false;
+const dispose = async () => {
+  if (disposed) {
+    return;
+  }
+  disposed = true;
+  unwatchFile(runtimeConfig.workerPath);
+  for (const serviceWorker of runtimeConfig.serviceWorkers) {
+    unwatchFile(serviceWorker.workerPath);
+  }
+  await new Promise((resolveClose) => server.close(() => resolveClose()));
+  await miniflare.dispose();
+  await proxySession?.session.dispose();
+};
+
+process.once("SIGINT", () => {
+  dispose()
+    .catch((error) => {
+      console.error(errorMessage(error));
+      process.exitCode = 1;
+    })
+    .finally(() => process.exit(process.exitCode ?? 0));
+});
+process.once("SIGTERM", () => {
+  dispose()
+    .catch((error) => {
+      console.error(errorMessage(error));
+      process.exitCode = 1;
+    })
+    .finally(() => process.exit(process.exitCode ?? 0));
+});
+
+await new Promise(() => {});
+
+async function dispatchToMiniflare(miniflareInstance, request) {
+  const url = new URL(
+    request.url ?? "/",
+    `http://${request.headers.host ?? `127.0.0.1:${port}`}`
+  );
+  const init = {
+    headers: request.headers,
+    method: request.method,
+    redirect: "manual",
+  };
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    init.body = await readRequestBody(request);
+  }
+  return miniflareInstance.dispatchFetch(url, init);
+}
+
+async function reloadMiniflare() {
+  const startedAt = Date.now();
+  try {
+    await miniflare.setOptions(miniflareOptions(remoteProxyConnectionString));
+    logRuntime("pier.worker.reloaded", "Worker runtime reloaded", {
+      durationMs: Date.now() - startedAt,
+      workerPath: runtimeConfig.workerPath,
+    });
+  } catch (error) {
+    logRuntime(
+      "pier.worker.reload_failed",
+      "Worker runtime reload failed",
+      {
+        error: errorMessage(error),
+        workerPath: runtimeConfig.workerPath,
+      },
+      "error"
+    );
+  }
+}
+
+function logRuntime(name, message, metadata = {}, level = "info") {
+  const event = {
+    app: runtimeConfig.appName,
+    environment: "dev",
+    level,
+    message,
+    metadata,
+    name,
+    timestamp: new Date().toISOString(),
+    worker: runtimeConfig.workerName,
+  };
+  const line = JSON.stringify(event);
+  if (level === "error") {
+    console.error(line);
+    return;
+  }
+  console.log(line);
+}
+
+function miniflareOptions(remoteProxyConnectionString) {
+  const converted = unstable_getMiniflareWorkerOptions(
+    runtimeConfig.adapterConfigPath,
+    undefined,
+    remoteProxyConnectionString ? { remoteProxyConnectionString } : undefined
+  );
+  const workerOptions = {
+    ...converted.workerOptions,
+    modules: true,
+    name: runtimeConfig.workerName,
+    scriptPath: runtimeConfig.workerPath,
+  };
+
+  return {
+    defaultPersistRoot: runtimeConfig.persistRoot,
+    workers: [
+      workerOptions,
+      ...runtimeConfig.serviceWorkers.flatMap((serviceWorker) =>
+        serviceWorkerOptions(serviceWorker, remoteProxyConnectionString)
+      ),
+      ...converted.externalWorkers,
+    ],
+  };
+}
+
+function serviceWorkerOptions(serviceWorker, remoteProxyConnectionString) {
+  const converted = unstable_getMiniflareWorkerOptions(
+    serviceWorker.adapterConfigPath,
+    undefined,
+    remoteProxyConnectionString ? { remoteProxyConnectionString } : undefined
+  );
+  return [
+    {
+      ...converted.workerOptions,
+      modules: true,
+      name: serviceWorker.workerName,
+      scriptPath: serviceWorker.workerPath,
+    },
+    ...converted.externalWorkers,
+  ];
+}
+
+function convertRemoteBindings(config) {
+  const bindings = unstable_convertConfigBindingsToStartWorkerBindings({
+    d1_databases: remoteOnly(config.d1_databases),
+    kv_namespaces: remoteOnly(config.kv_namespaces),
+    r2_buckets: remoteOnly(config.r2_buckets),
+  });
+  if (!bindings || bindings.length === 0) {
+    return [];
+  }
+  return bindings;
+}
+
+async function ensureRemoteResources(input) {
+  const client = new Cloudflare({ apiToken: input.apiToken });
+  await ensureRemoteR2Buckets({ ...input, client });
+}
+
+async function ensureRemoteR2Buckets(input) {
+  const buckets = remoteOnly(input.adapterConfig.r2_buckets);
+  if (buckets.length === 0) {
+    return;
+  }
+
+  await mkdir(resolve(".pier", "state"), { recursive: true });
+  const existing = await input.client.r2.buckets.list({
+    account_id: input.accountId,
+  });
+  const existingNames = new Set(
+    (existing.buckets ?? []).map((bucket) => bucket.name)
+  );
+
+  for (const bucket of buckets) {
+    if (existingNames.has(bucket.bucket_name)) {
+      console.log(`Remote R2 bucket exists: ${bucket.bucket_name}`);
+      continue;
+    }
+
+    let created = true;
+    await input.client.r2.buckets
+      .create({
+        account_id: input.accountId,
+        name: bucket.bucket_name,
+      })
+      .catch((error) => {
+        if (isAlreadyOwnedBucketError(error)) {
+          created = false;
+          return;
+        }
+        throw error;
+      });
+    console.log(
+      `${created ? "Remote R2 bucket created" : "Remote R2 bucket exists"}: ${bucket.bucket_name}`
+    );
+  }
+}
+
+function printRemoteBindingSummary(config) {
+  for (const bucket of remoteOnly(config.r2_buckets)) {
+    console.log(
+      `Remote binding: ${bucket.binding} -> R2 bucket ${bucket.bucket_name}`
+    );
+  }
+  for (const namespace of remoteOnly(config.kv_namespaces)) {
+    console.log(
+      `Remote binding: ${namespace.binding} -> KV namespace ${namespace.id}`
+    );
+  }
+  for (const database of remoteOnly(config.d1_databases)) {
+    console.log(
+      `Remote binding: ${database.binding} -> D1 database ${database.database_name}`
+    );
+  }
+}
+
+function remoteOnly(values) {
+  return Array.isArray(values)
+    ? values.filter((value) => value?.remote === true)
+    : [];
+}
+
+async function readRuntimeConfig() {
+  const configPath = process.argv[2];
+  if (!configPath) {
+    throw new Error("Missing runtime config path.");
+  }
+  const config = await readJson(resolve(configPath));
+  return {
+    appName: stringValue(config.appName, "worker"),
+    persistRoot: stringValue(
+      config.persistRoot,
+      resolve(".pier/state/miniflare/worker")
+    ),
+    port: typeof config.port === "number" ? config.port : undefined,
+    projectName: stringValue(config.projectName, "pier"),
+    serviceWorkers: Array.isArray(config.serviceWorkers)
+      ? config.serviceWorkers.map((serviceWorker) => ({
+          appName: stringValue(serviceWorker.appName, "service"),
+          workerName: stringValue(serviceWorker.workerName, "pier-service"),
+          workerPath: stringValue(serviceWorker.workerPath, ""),
+          adapterConfigPath: stringValue(serviceWorker.adapterConfigPath, ""),
+        }))
+      : [],
+    workerName: stringValue(config.workerName, "pier-worker"),
+    workerPath: stringValue(config.workerPath, ""),
+    adapterConfigPath: stringValue(config.adapterConfigPath, ""),
+  };
+}
+
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+function readRequestBody(request) {
+  return new Promise((resolveBody, rejectBody) => {
+    const chunks = [];
+    request.on("data", (chunk) => chunks.push(chunk));
+    request.on("end", () => resolveBody(Buffer.concat(chunks)));
+    request.on("error", rejectBody);
+  });
+}
+
+function requiredEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`${name} is required for Pier remote Worker dev.`);
+  }
+  return value;
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isAlreadyOwnedBucketError(error) {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "status" in error &&
+    error.status === 409 &&
+    errorMessage(error).includes("you own it")
+  );
+}
+
+function stringValue(value, fallback) {
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@buildwithharbor/pier",
+  "version": "0.1.5",
+  "bin": {
+    "pier": "dist/index.js"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:npm": "bun build src/index.ts --target bun --outfile dist/index.js && cp src/local-worker-runtime-child.mjs dist/local-worker-runtime-child.mjs",
+    "check-types": "tsgo -p tsconfig.json"
+  },
+  "devDependencies": {
+    "@pier/app-build": "0.1.15",
+    "@pier/backend": "0.1.15",
+    "@pier/cloudflare": "0.1.18",
+    "@pier/core": "0.1.16",
+    "@pier/credentials": "0.1.15",
+    "@pier/db": "0.1.15",
+    "@pier/log": "0.1.15",
+    "@pier/sync": "0.1.21",
+    "@pier/worker-bundler": "0.1.15",
+    "@repo/api-contract": "workspace:*",
+    "@repo/api-sync-contract": "workspace:*",
+    "@repo/api-sync-schema": "workspace:*",
+    "@repo/local-daemon-contract": "workspace:*",
+    "@rocicorp/zero": "^1.6.1",
+    "clipanion": "4.0.0-rc.4",
+    "cloudflare": "6.4.0",
+    "miniflare": "4.20260603.0",
+    "postgres": "^3.4.9",
+    "wrangler": "4.98.0",
+    "@types/bun": "^1.3.4",
+    "typescript": "^5.9.3"
+  }
+}