alchemy 0.70.0 → 0.70.2

package/src/cloudflare/worker-metadata.ts

@@ -1,4 +1,5 @@
 import { assertNever } from "../util/assert-never.ts";
+import { camelToSnakeObjectDeep } from "../util/camel-to-snake.ts";
 import { logger } from "../util/logger.ts";
 import { memoize } from "../util/memoize.ts";
 import { extractCloudflareResult } from "./api-response.ts";
@@ -180,8 +181,20 @@ export interface WorkerMetadata {
   compatibility_date: string;
   compatibility_flags?: string[];
   bindings: WorkerBindingSpec[];
-  observability: {
-    enabled: boolean;
+  observability?: {
+    enabled?: boolean;
+    head_sampling_rate?: number;
+    logs?: {
+      enabled?: boolean;
+      head_sampling_rate?: number;
+      invocation_logs?: boolean;
+    };
+    traces?: {
+      enabled?: boolean;
+      head_sampling_rate?: number;
+      persist?: boolean;
+      destinations?: string[];
+    };
   };
   logpush?: boolean;
   migrations?: SingleStepMigration;
@@ -235,6 +248,7 @@ export async function prepareWorkerMetadata(
       ...(oldSettings?.tags ?? []),
     ]),
   );
+
   const oldBindings = oldSettings?.bindings;
   // we use Cloudflare Worker tags to store a mapping between Alchemy's stable identifier and the binding name
   // e.g.
@@ -315,6 +329,8 @@ export async function prepareWorkerMetadata(
     return [];
   });
 
+  const observability = camelToSnakeObjectDeep(props.observability);
+
   // Prepare metadata with bindings
   const meta: WorkerMetadata = {
     compatibility_date: props.compatibilityDate,
@@ -324,7 +340,8 @@ export async function prepareWorkerMetadata(
     ),
     bindings: [],
     observability: {
-      enabled: props.observability?.enabled !== false,
+      ...observability,
+      enabled: observability?.enabled !== false,
     },
     logpush: props.logpush ?? false,
     // TODO(sam): base64 encode instead? 0 collision risk vs readability.

package/src/cloudflare/worker-stub.ts

@@ -128,7 +128,7 @@ export const WorkerStub = Resource("cloudflare::WorkerStub", async function <
   } as WorkerStub<RPC>;
 });
 
-async function exists(
+export async function exists(
   api: CloudflareApi,
   workerName: string,
 ): Promise<boolean> {
@@ -145,9 +145,10 @@ async function exists(
   }
 }
 
-async function createEmptyWorker(
+export async function createEmptyWorker(
   api: CloudflareApi,
   workerName: string,
+  version?: string,
 ): Promise<void> {
   // Minimal empty worker script
   const emptyScript = `export default { 
@@ -178,6 +179,12 @@ async function createEmptyWorker(
           main_module: "worker.js",
           compatibility_date: "2025-04-20",
           bindings: [],
+          ...(version != null && {
+            annotations: {
+              "workers/tag": version,
+              "workers/message": `Version ${version}`,
+            },
+          }),
         }),
       ],
       {
@@ -189,14 +196,24 @@ async function createEmptyWorker(
   // Upload worker script
   await extractCloudflareResult(
     `create empty worker "${workerName}"`,
-    api.put(
-      `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-      formData,
-      {
-        headers: {
-          "Content-Type": "multipart/form-data",
-        },
-      },
-    ),
+    version != null
+      ? api.post(
+          `/accounts/${api.accountId}/workers/scripts/${workerName}/versions`,
+          formData,
+          {
+            headers: {
+              "Content-Type": "multipart/form-data",
+            },
+          },
+        )
+      : api.put(
+          `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+          formData,
+          {
+            headers: {
+              "Content-Type": "multipart/form-data",
+            },
+          },
+        ),
   );
 }

package/src/cloudflare/worker.ts

@@ -61,6 +61,7 @@ import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 import "../esbuild/bundle.ts";
 import { Scope } from "../scope.ts";
 import type { WorkerRef } from "./worker-ref.ts";
+import { createEmptyWorker, exists } from "./worker-stub.ts";
 
 /**
  * Configuration options for static assets
@@ -166,18 +167,12 @@ export interface BaseWorkerProps<
   url?: boolean;
 
   /**
-   * Observability configuration for the worker
+   * Specify the observability behavior of the Worker.
    *
-   * Controls whether worker logs are enabled
-   * @default { enabled: true }
+   * @see https://developers.cloudflare.com/workers/wrangler/configuration/#observability
+   * @default - `enabled: true`
    */
-  observability?: {
-    /**
-     * Whether to enable worker logs
-     * @default true
-     */
-    enabled?: boolean;
-  };
+  observability?: WorkerObservability;
 
   /**
    * Enable Workers Logpush to export trace events (request/response metadata,
@@ -393,6 +388,85 @@ export interface BaseWorkerProps<
   tailConsumers?: Array<Worker | { service: string }>;
 }
 
+export interface WorkerObservability {
+  /**
+   * If observability is enabled for this Worker
+   *
+   * @default true
+   */
+  enabled?: boolean;
+
+  /**
+   * A number between 0 and 1, where 0 indicates zero out of one hundred requests are logged, and 1 indicates every request is logged.
+   * If head_sampling_rate is unspecified, it is configured to a default value of 1 (100%).
+   * @see https://developers.cloudflare.com/workers/observability/logs/workers-logs/#head-based-sampling
+   * @default 1
+   */
+  headSamplingRate?: number;
+
+  /**
+   * Configuration for worker logs
+   */
+  logs?: {
+    /**
+     * Whether logs are enabled
+     * @default true
+     */
+    enabled?: boolean;
+
+    /**
+     * The sampling rate for logs
+     */
+    headSamplingRate?: number;
+
+    /**
+     * Set to false to disable invocation logs
+     * @default true
+     */
+    invocationLogs?: boolean;
+
+    /**
+     * If logs should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+     * @default true
+     */
+    persist?: boolean;
+
+    /**
+     * What destinations logs emitted from the Worker should be sent to.
+     * @default []
+     */
+    destinations?: string[];
+  };
+
+  /**
+   * Configuration for worker traces
+   */
+  traces?: {
+    /**
+     * Whether traces are enabled
+     * @default true
+     */
+    enabled?: boolean;
+
+    /**
+     * The sampling rate for traces
+     */
+    headSamplingRate?: number;
+
+    /**
+     * If traces should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+     * @default true
+     */
+    persist?: boolean;
+
+    /**
+     * What destinations traces emitted from the Worker should be sent to.
+     * @default []
+     */
+    destinations?: string[];
+  };
+}
+
 export interface InlineWorkerProps<
   B extends Bindings | undefined = Bindings,
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
@@ -863,13 +937,20 @@ const _Worker = Resource(
         durableObjects: options.durableObjects,
         workflows: options.workflows,
       });
-      if (!props.version && this.output?.dev?.hasRemote !== false) {
+      if (this.output?.dev?.hasRemote !== false) {
         const api = await createCloudflareApi(props);
-        await deleteQueueConsumers(api, options.name);
-        await deleteWorker(api, {
-          scriptName: options.name,
-          dispatchNamespace: options.dispatchNamespace,
-        });
+        if (props.version) {
+          //* if the worker exists we deploy an empty version so we can destroy
+          if (await exists(api, options.name)) {
+            await createEmptyWorker(api, options.name, props.version);
+          }
+        } else {
+          await deleteQueueConsumers(api, options.name);
+          await deleteWorker(api, {
+            scriptName: options.name,
+            dispatchNamespace: options.dispatchNamespace,
+          });
+        }
       }
       return this.destroy();
     }
@@ -1607,7 +1688,7 @@ async function assertWorkerDoesNotExist(
   );
 }
 
-async function getScriptMetadata(
+export async function getScriptMetadata(
   api: CloudflareApi,
   scriptName: string,
 ): Promise<WorkerScriptMetadata | undefined> {

package/src/scope.ts

@@ -103,6 +103,10 @@ export interface ScopeOptions extends ProviderCredentials {
    * @default process.cwd()
    */
   rootDir?: string;
+  /**
+   * The Alchemy profile to use for authoriziing requests.
+   */
+  profile?: string;
   /**
    * Whether this is the application that was selected with `--app`
    *
@@ -203,6 +207,7 @@ export class Scope {
   public readonly rootDir: string;
   public readonly dotAlchemy: string;
   public readonly isSelected: boolean | undefined;
+  public readonly profile: string | undefined;
 
   // Provider credentials for scope-level credential overrides
   public readonly providerCredentials: ProviderCredentials;
@@ -242,6 +247,7 @@ export class Scope {
       rootDir,
       isSelected,
       noTrack,
+      profile,
       ...providerCredentials
     } = options;
 
@@ -268,6 +274,7 @@ export class Scope {
     }
 
     this.stage = stage ?? this.parent?.stage ?? DEFAULT_STAGE;
+    this.profile = profile ?? this.parent?.profile;
     this.parent?.children.set(this.scopeName!, this);
     this.quiet = quiet ?? this.parent?.quiet ?? false;
     if (this.parent && !this.scopeName) {

package/src/util/camel-to-snake.ts

@@ -0,0 +1,88 @@
+export interface LogPushProps {
+  maxFooBar: string;
+}
+
+export function camelToSnakeObjectDeep<T extends object | undefined>(
+  obj: T,
+): T extends undefined ? undefined : CamelToSnake<T> {
+  return (
+    obj
+      ? Object.fromEntries(
+          Object.entries(obj).map(([key, value]) => [
+            key
+              .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2") // Handle consecutive capitals: "FOOBar" -> "FOO_Bar"
+              .replace(/([a-z])([A-Z])/g, "$1_$2") // Handle normal camelCase: "fooBar" -> "foo_Bar"
+              .toLowerCase(),
+            Array.isArray(value)
+              ? value.map(camelToSnakeObjectDeep)
+              : typeof value === "object" && value !== null
+                ? camelToSnakeObjectDeep(value)
+                : value,
+          ]),
+        )
+      : undefined
+  ) as T extends undefined ? undefined : CamelToSnake<T>;
+}
+
+// Helper to check if a character is uppercase
+type IsUpper<C extends string> = C extends Uppercase<C>
+  ? C extends Lowercase<C>
+    ? false // Not a letter
+    : true // Uppercase letter
+  : false;
+
+// Helper to check if a character is lowercase
+type IsLower<C extends string> = C extends Lowercase<C>
+  ? C extends Uppercase<C>
+    ? false // Not a letter
+    : true // Lowercase letter
+  : false;
+
+// Convert a camelCase string to snake_case at the type level
+type CamelToSnakeString<
+  S extends string,
+  Acc extends string = "",
+> = S extends `${infer First}${infer Second}${infer Rest}`
+  ? IsUpper<First> extends true
+    ? IsUpper<Second> extends true
+      ? // FOO... pattern - check if next char is lowercase
+        Rest extends `${infer Third}${infer _}`
+        ? IsLower<Third> extends true
+          ? // FOOBar -> add First, add _, add Second lowercase, continue with Rest
+            CamelToSnakeString<
+              Rest,
+              `${Acc}${Lowercase<First>}_${Lowercase<Second>}`
+            >
+          : // FOO -> continue
+            CamelToSnakeString<`${Second}${Rest}`, `${Acc}${Lowercase<First>}`>
+        : // Only two chars left, both upper
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${Lowercase<First>}`>
+      : // FooBar or Foo - add underscore before uppercase if not at start
+        CamelToSnakeString<
+          `${Second}${Rest}`,
+          Acc extends "" ? `${Lowercase<First>}` : `${Acc}_${Lowercase<First>}`
+        >
+    : IsLower<First> extends true
+      ? IsUpper<Second> extends true
+        ? // fooBar -> just add the lowercase char, underscore will be added when processing uppercase
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+        : // foobar -> continue
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+      : // Number or special char
+        CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+  : S extends `${infer Last}`
+    ? `${Acc}${Lowercase<Last>}`
+    : Acc;
+
+// Deep transformation for objects
+type CamelToSnake<T> = T extends object
+  ? T extends Array<infer U>
+    ? Array<CamelToSnake<U>>
+    : T extends Date | RegExp | Function
+      ? T // Don't transform special object types
+      : {
+          [K in keyof T as K extends string
+            ? CamelToSnakeString<K>
+            : K]: CamelToSnake<T[K]>;
+        }
+  : T;

package/src/util/idempotent-spawn.ts

@@ -112,7 +112,7 @@ export async function idempotentSpawn({
     const child = spawn(cmd, {
       shell: true,
       cwd,
-      stdio: ["ignore", out.fd, out.fd], // stdout/stderr -> files (OS-level)
+      stdio: ["inherit", out.fd, out.fd], // stdout/stderr -> files (OS-level)
       env,
       detached: false,
     });

package/src/util/telemetry.ts

@@ -1,6 +1,6 @@
 import envPaths from "env-paths";
 import { exec } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import fs from "node:fs/promises";
 import os from "node:os";
 import path from "pathe";
 import pkg from "../../package.json" with { type: "json" };
@@ -9,11 +9,13 @@ import { Scope } from "../scope.ts";
 import { logger } from "./logger.ts";
 import { memoize } from "./memoize.ts";
 
-export const CONFIG_PATH = path.join(os.homedir(), ".alchemy", "id");
-export const CONFIG_PATH_LEGACY = path.join(
+const ALCHEMY_DIR = path.join(os.homedir(), ".alchemy");
+const ID_PATH = path.join(ALCHEMY_DIR, "id");
+const ID_PATH_LEGACY = path.join(
   envPaths("alchemy", { suffix: "" }).config,
   "id",
 );
+const DISABLED_PATH = path.join(ALCHEMY_DIR, "telemetry-disabled");
 
 export const TELEMETRY_DISABLED =
   !!process.env.ALCHEMY_TELEMETRY_DISABLED || !!process.env.DO_NOT_TRACK;
@@ -23,26 +25,43 @@ export const TELEMETRY_API_URL =
 export const SUPPRESS_TELEMETRY_ERRORS =
   !!process.env.ALCHEMY_TELEMETRY_SUPPRESS_ERRORS;
 
+export const getGlobalTelemetryDisabled = memoize(async () => {
+  const disabled = await fs
+    .readFile(DISABLED_PATH, "utf-8")
+    .then((data) => data.trim() === "true")
+    .catch(() => false);
+  return disabled;
+});
+
+export async function setGlobalTelemetryDisabled() {
+  await fs.mkdir(ALCHEMY_DIR, { recursive: true });
+  await fs.writeFile(DISABLED_PATH, "true");
+}
+
+export async function setGlobalTelemetryEnabled() {
+  await fs.rm(DISABLED_PATH, { force: true });
+}
+
 async function getOrCreateUserId() {
   async function readUserId(path: string) {
     try {
-      return (await readFile(path, "utf-8")).trim();
+      return (await fs.readFile(path, "utf-8")).trim();
     } catch {
       return null;
     }
   }
 
-  const id = await readUserId(CONFIG_PATH);
+  const id = await readUserId(ID_PATH);
   if (id) {
     return id;
   }
 
-  const legacyId = await readUserId(CONFIG_PATH_LEGACY);
+  const legacyId = await readUserId(ID_PATH_LEGACY);
 
   try {
     const id = legacyId ?? crypto.randomUUID();
-    await mkdir(path.dirname(CONFIG_PATH), { recursive: true });
-    await writeFile(CONFIG_PATH, id);
+    await fs.mkdir(ALCHEMY_DIR, { recursive: true });
+    await fs.writeFile(ID_PATH, id);
     if (!legacyId) {
       console.warn(
         [
@@ -59,7 +78,11 @@ async function getOrCreateUserId() {
 
 async function getRootCommitHash() {
   return new Promise<string | null>((resolve) => {
-    exec("git rev-list --max-parents=0 HEAD", (err, stdout) => {
+    const command =
+      process.platform === "win32"
+        ? `git rev-list --max-parents=0 HEAD | ForEach-Object { if (-not (git cat-file -p $_ | Select-String "^parent ")) { $_ } }`
+        : `git rev-list --max-parents=0 HEAD | xargs -r -I{} sh -c 'git cat-file -p {} | grep -q "^parent " || echo {}'`;
+    exec(command, (err, stdout) => {
       if (err) {
         resolve(null);
         return;
@@ -236,6 +259,14 @@ export type AlchemyTelemetryData = {
   duration: number;
 };
 
+async function isTelemetryDisabled() {
+  return (
+    Scope.getScope()?.noTrack ||
+    TELEMETRY_DISABLED ||
+    (await getGlobalTelemetryDisabled())
+  );
+}
+
 export async function createAndSendEvent(
   data:
     | CliTelemetryData
@@ -244,7 +275,7 @@ export async function createAndSendEvent(
     | AlchemyTelemetryData,
   error?: Error,
 ) {
-  if (Scope.getScope()?.noTrack || TELEMETRY_DISABLED) {
+  if (await isTelemetryDisabled()) {
     return;
   }
   try {

package/templates/tanstack-start/package.json

@@ -24,8 +24,8 @@
     "vite-tsconfig-paths": "^5.1.4"
   },
   "devDependencies": {
-    "@cloudflare/vite-plugin": "catalog:",
-    "@cloudflare/workers-types": "catalog:",
+    "@cloudflare/vite-plugin": "^1.11.6",
+    "@cloudflare/workers-types": "^4.20250805.0",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/react": "^16.2.0",
     "@types/node": "^22.10.2",

package/workers/tunnel-proxy.js

@@ -34,7 +34,7 @@ var h={async fetch(e,r){let n=new URL(e.url);n.host=r.TUNNEL_HOST;let l=new Head
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.70.0</p>
+        <p class="text-sm text-slate-500">Alchemy 0.70.2</p>
       </div>
     </div>
   </body>