sticky-note-cli 3.1.13 → 3.1.15

package/README.md

@@ -50,6 +50,23 @@ their next session by relevance.
 
 ---
 
+## What's New in V3.2
+
+- **claude.ai cowork session tracking**: Sessions in claude.ai (cowork, projects) are now
+  captured with full fidelity — every tool call, AI response, thinking block, and user
+  prompt — matching the richness of local Claude Code sessions. Connect the remote MCP
+  endpoint once in your claude.ai project settings and capture happens automatically.
+- **AI blame**: Trace any line of code back to the prompt, reasoning chain, and tool calls
+  that produced it. Every session event is stored in KV keyed by thread ID. `get-line-attribution`
+  maps file lines to thread IDs; from there you can fetch the full event stream and walk back
+  to the `user_prompt` → `ai_thinking` → `tool_call` → `tool_result` chain.
+- **Enriched local event stream**: Claude Code hook sessions now emit structured events
+  (not just audit entries) — full tool args, results capped at 10 KB, AI thinking and
+  response blocks extracted from transcript at session end, all pushed to KV for team access.
+- **Init wizard cowork setup**: After cloud backend provisioning, `npx sticky-note init`
+  now prompts for a GitHub PAT (for Worker→git commits) and prints the remote MCP connector
+  URL + project system prompt to paste into claude.ai. See [Setup: claude.ai Cowork](#setup-claudeai-cowork).
+
 ## What's New in V3.1
 
 - **Full transcript capture**: Every session's complete verbatim transcript
@@ -160,6 +177,66 @@ in the background via hooks — capturing threads and surfacing context.
 
 ---
 
+## Setup: claude.ai Cowork
+
+To capture sessions from claude.ai (cowork, projects), you need the cloud backend running
+and a remote MCP connector configured in your claude.ai project settings.
+
+### Prerequisites
+
+Cloud backend must be set up first (`npx sticky-note init` → answer **y** to cloud backend).
+
+### Step 1: Run init with GitHub PAT (optional but recommended)
+
+After cloud provisioning, `npx sticky-note init` prompts:
+
+```
+Optional: GitHub PAT for Worker → git commits (enables remote cowork session tracking).
+Create at https://github.com/settings/tokens/new (fine-grained, Contents read+write).
+PAT (leave blank to skip):
+```
+
+Enter a PAT to enable the Worker to commit thread metadata to `sticky-note.json` after each session.
+Leave blank if you only want KV event storage (metadata won't appear in git history).
+
+The wizard then prints your connector details:
+
+```
+── claude.ai Cowork MCP Connector ──────────────────────────
+To track cowork sessions, add this connector in claude.ai project settings:
+  URL:    https://sticky-{owner}-{repo}.workers.dev/mcp
+  Header: X-Sticky-API-Key: <your-key>
+
+The CLAUDE.md project system prompt (paste into claude.ai project instructions):
+  1. Call open_thread at session start with the verbatim first user prompt
+  2. Call append_event for every action: ai_thinking, ai_response, tool_call,
+     tool_result, tool_error, tool_denied, context_compressed, git_commit,
+     subagent_spawn, subagent_result, checkpoint
+  3. Call set_checkpoint when the user switches topics
+  4. Call close_thread at session end with narrative and work_type
+```
+
+### Step 2: Configure claude.ai project
+
+1. Open your claude.ai project → **Settings** → **Integrations** → **Add MCP Server**
+2. Enter the URL and header from the wizard output
+3. Paste the system prompt block into your project instructions
+
+That's it. The next cowork session in that project will open a thread, stream events live,
+and commit thread metadata to git when the session ends.
+
+### Worker secrets (manual / CI)
+
+If you need to set secrets without the wizard:
+
+```bash
+cd sticky-server
+wrangler secret put GITHUB_PAT     # fine-grained PAT, Contents read+write
+wrangler secret put GITHUB_REPO    # value: owner/repo (e.g. acme/frontend)
+```
+
+---
+
 ## How Context Gets Injected
 
 Sticky Note injects context through **four mechanisms**: two that run

package/bin/cli.js

@@ -198,6 +198,14 @@ function makeExecutable(filePath) {
   }
 }
 
+// Markers used by older sticky-note versions to wrap blocks in .git/hooks/pre-commit
+// and .git/hooks/post-commit. These were removed in V3 (data branch handles persistence),
+// but cmdUpdate() and cmdMigrateDataBranch() still need to strip them from old repos.
+const STICKY_PRE_COMMIT_MARKER = "# [sticky-note:auto-stage]";
+const STICKY_PRE_COMMIT_END    = "# [/sticky-note:auto-stage]";
+const STICKY_POST_COMMIT_MARKER = "# [sticky-note:auto-sync]";
+const STICKY_POST_COMMIT_END    = "# [/sticky-note:auto-sync]";
+
 function installGitHook(hookName) {
   try {
     const gitDir = path.join(process.cwd(), ".git");
@@ -748,6 +756,59 @@ async function cmdInit() {
     print("  [OK] .env.sticky (cloud backend configured)");
   }
 
+  // GitHub PAT collection + MCP connector URL output (cloud backend only, interactive only)
+  const workerUrl = cloudProvisionedUrl || configStickyUrl;
+  if (workerUrl && !ciMode) {
+    const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask2 = (q) => new Promise((res) => rl2.question(q, res));
+
+    const pat = await ask2(
+      "\nOptional: GitHub PAT for Worker → git commits (enables remote cowork session tracking).\n" +
+      "Create at https://github.com/settings/tokens/new (fine-grained, Contents read+write).\n" +
+      "PAT (leave blank to skip): "
+    );
+
+    if (pat && pat.trim()) {
+      const repo = await ask2("GitHub repo in owner/repo format (e.g. acme/frontend): ");
+      if (repo && repo.trim().includes("/")) {
+        try {
+          execSync(`wrangler secret put GITHUB_PAT`, { input: pat.trim(), stdio: ["pipe", "inherit", "inherit"] });
+          execSync(`wrangler secret put GITHUB_REPO`, { input: repo.trim(), stdio: ["pipe", "inherit", "inherit"] });
+          print("  ✓ GitHub PAT and repo stored as Worker secrets");
+        } catch (_) {
+          print("  ⚠ Could not store secrets via wrangler — set manually:");
+          print(`    wrangler secret put GITHUB_PAT`);
+          print(`    wrangler secret put GITHUB_REPO  # value: ${repo.trim()}`);
+        }
+      }
+    }
+    rl2.close();
+
+    // Always print connector instructions if Worker URL is configured
+    let envStickyApiKey = "";
+    try {
+      const envStickyPath = path.join(process.cwd(), ".env.sticky");
+      const envContent = fs.readFileSync(envStickyPath, "utf-8");
+      const m = envContent.match(/^STICKY_API_KEY=(.+)$/m);
+      if (m && m[1].trim()) envStickyApiKey = m[1].trim();
+    } catch (_) { /* no .env.sticky yet */ }
+
+    print("\n── claude.ai Cowork MCP Connector ──────────────────────────");
+    print("To track cowork sessions, add this connector in claude.ai project settings:");
+    print(`  URL:    ${workerUrl}/mcp`);
+    if (envStickyApiKey) {
+      print(`  Header: X-Sticky-API-Key: ${envStickyApiKey}`);
+    }
+    print("\nThe CLAUDE.md project system prompt (paste into claude.ai project instructions):");
+    print("  1. Call open_thread at session start with the verbatim first user prompt");
+    print("  2. Call append_event for every action: ai_thinking, ai_response, tool_call,");
+    print("     tool_result, tool_error, tool_denied, context_compressed, git_commit,");
+    print("     subagent_spawn, subagent_result, checkpoint");
+    print("  3. Call set_checkpoint when the user switches topics");
+    print("  4. Call close_thread at session end with narrative and work_type");
+    print("────────────────────────────────────────────────────────────\n");
+  }
+
   print("\n  📁 Creating files...\n");
 
   // Create directories
@@ -847,6 +908,9 @@ async function cmdInit() {
     configTemplate.inject_token_budget = injectTokenBudgetResolved;
     configTemplate.hook_version = VERSION;
     configTemplate.min_version = VERSION;
+    // When cloud is configured, default auto_push to true so threads reach
+    // GitHub even when Cloudflare KV hits its daily write limit.
+    if (cloudProvisionedUrl || configStickyUrl) configTemplate.auto_push = true;
     fs.writeFileSync(configDest, JSON.stringify(configTemplate, null, 2) + "\n");
   } else {
     // Update existing config with new settings
@@ -859,6 +923,10 @@ async function cmdInit() {
     existing.hook_version = VERSION;
     existing.min_version = bumpMinVersion(existing.min_version, VERSION);
     if (cloudProvisionedUrl) existing.sticky_url = cloudProvisionedUrl;
+    // Enable auto_push when cloud is configured (if not already explicitly set)
+    if ((cloudProvisionedUrl || configStickyUrl) && existing.auto_push === false) {
+      existing.auto_push = true;
+    }
     fs.writeFileSync(configDest, JSON.stringify(existing, null, 2) + "\n");
   }
   print("  [OK] .sticky-note/sticky-note-config.json");

package/bin/mcp-server.js

@@ -508,17 +508,19 @@ function toolCheckOverlaps(params) {
   };
 }
 
-function toolGetEnvironmentStatus() {
+async function toolGetEnvironmentStatus() {
   const envDir = path.join(stickyDir(), "environment");
   const mcpPath = path.join(PROJECT_ROOT, ".mcp.json");
 
-  // No environment directory — feature not set up
+  // No environment directory — feature not set up, but still check cloud health
   if (!fs.existsSync(envDir)) {
-    return {
+    const result = {
       status: "not_configured",
       message: "No .sticky-note/environment/ directory found. Environment sync is not set up for this repo.",
       action: "none",
     };
+    result.cloud = await _checkCloudHealth();
+    return result;
   }
 
   const manifest = readJsonSafe(path.join(envDir, "manifest.json"), {});
@@ -604,9 +606,42 @@ function toolGetEnvironmentStatus() {
     }
   }
 
+  result.cloud = await _checkCloudHealth();
+  if (result.cloud.status === "auth_error" && result.status === "complete") {
+    result.status = "incomplete";
+  }
+
   return result;
 }
 
+async function _checkCloudHealth() {
+  const { url: cloudUrl, apiKey } = getCloudConfig();
+  if (!cloudUrl) return { status: "not_configured" };
+  try {
+    const headers = {};
+    if (apiKey) headers["X-Sticky-API-Key"] = apiKey;
+    const resp = await fetch(`${cloudUrl}/health`, { method: "GET", headers, signal: AbortSignal.timeout(5000) });
+    if (resp.ok) {
+      const body = await resp.json().catch(() => ({}));
+      return { status: "ok", url: cloudUrl, version: body.version || null };
+    } else if (resp.status === 401) {
+      return {
+        status: "auth_error",
+        url: cloudUrl,
+        message: "Cloud reachable but API key rejected — check STICKY_API_KEY in .env.sticky",
+        action: "fix_api_key",
+      };
+    }
+    return { status: "error", url: cloudUrl, message: `HTTP ${resp.status}` };
+  } catch (err) {
+    return {
+      status: "unreachable",
+      url: cloudUrl,
+      message: err.name === "TimeoutError" ? "Cloud timed out (5s)" : err.message,
+    };
+  }
+}
+
 function toolGetThreadContextForFiles(params) {
   const { files } = params;
   if (!files || !Array.isArray(files) || files.length === 0) {
@@ -819,7 +854,7 @@ const CAPABILITIES = {
   tools: {},
 };
 
-function handleRequest(msg) {
+async function handleRequest(msg) {
   const { method, params, id } = msg;
 
   switch (method) {
@@ -872,7 +907,7 @@ function handleRequest(msg) {
       }
 
       try {
-        const result = tool.handler(toolArgs);
+        const result = await tool.handler(toolArgs);
         return {
           jsonrpc: "2.0",
           id,
@@ -953,10 +988,17 @@ function handleRequest(msg) {
         continue;
       }
 
-      const response = handleRequest(msg);
-      if (response) {
-        process.stdout.write(JSON.stringify(response) + "\n");
-      }
+      handleRequest(msg).then((response) => {
+        if (response) {
+          process.stdout.write(JSON.stringify(response) + "\n");
+        }
+      }).catch((err) => {
+        process.stdout.write(JSON.stringify({
+          jsonrpc: "2.0",
+          id: msg.id,
+          error: { code: -32603, message: `Internal error: ${err.message}` },
+        }) + "\n");
+      });
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "3.1.13",
+  "version": "3.1.15",
   "description": "Human-to-human handoff for AI coding assistants. Git-backed shared memory for Claude Code and Copilot CLI.",
   "license": "MIT",
   "bin": {

package/sticky-server/.wrangler/cache/cf.json

@@ -0,0 +1 @@
+{"httpProtocol":"HTTP/1.1","clientAcceptEncoding":"gzip, deflate, br","requestPriority":"","edgeRequestKeepAliveStatus":1,"requestHeaderNames":{},"clientTcpRtt":7,"clientQuicRtt":0,"colo":"SEA","asn":209,"asOrganization":"CenturyLink Communications, LLC","country":"US","isEUCountry":false,"city":"Seattle","continent":"NA","region":"Washington","regionCode":"WA","timezone":"America/Los_Angeles","longitude":"-122.33207","latitude":"47.60621","postalCode":"98101","metroCode":"819","tlsVersion":"TLSv1.3","tlsCipher":"AEAD-AES256-GCM-SHA384","tlsClientRandom":"XQNGM/m2YSoD+2/DfSjDYbB2Sp72SCXcbv9uvodPXVE=","tlsClientCiphersSha1":"kXrN3VEKDdzz2cPKTQaKzpxVTxQ=","tlsClientExtensionsSha1":"1eY97BUYYO8vDaTfHQywB1pcNdM=","tlsClientExtensionsSha1Le":"u4wtEMFQBY18l3BzHAvORm+KGRw=","tlsExportedAuthenticator":{"clientHandshake":"f0ba9bf76868d7072bc036be30b47e1e52b95cb14ad9335c8ced6c6111a717f35199ac65e82d44e7e40953dfbe17ece3","serverHandshake":"eee30a00abc412c4338e37496a61e82a6a645fdbcd5c143c9e0ce63eac2a96313112bc19879848ea58d8133239726287","clientFinished":"926eadd8221a92f6e9f21352b1857815711f83deea9c9960be964e3d9eca3a9311620fec3037ff128e697b449aa2ca37","serverFinished":"93f0c496a5a2e85128652abdb1e9e2155f7202217144390b29b544e0a7a228190c0a4e4ec7e85ab4342c63f377a1edcd"},"tlsClientHelloLength":"1605","tlsClientAuth":{"certPresented":"0","certVerified":"NONE","certRevoked":"0","certIssuerDN":"","certSubjectDN":"","certIssuerDNRFC2253":"","certSubjectDNRFC2253":"","certIssuerDNLegacy":"","certSubjectDNLegacy":"","certSerial":"","certIssuerSerial":"","certSKI":"","certIssuerSKI":"","certFingerprintSHA1":"","certFingerprintSHA256":"","certNotBefore":"","certNotAfter":"","certRFC9440":"","certRFC9440TooLarge":false,"certChainRFC9440":"","certChainRFC9440TooLarge":false},"verifiedBotCategory":"","edgeL4":{"deliveryRate":460059},"botManagement":{"corporateProxy":false,"verifiedBot":false,"jsDetection":{"passed":false},"staticResource":false,"detectionIds":{},"score":99}}

package/sticky-server/.wrangler/state/v3/kv/PLACEHOLDER_KV_NAMESPACE_ID/blobs/24473f36cce8fd4dcc0287333b336236fef2ffd176b20d9f9861257480f2d2f0000001a0272e56bb

@@ -0,0 +1 @@
+["test-thread-1"]

package/sticky-server/.wrangler/state/v3/kv/PLACEHOLDER_KV_NAMESPACE_ID/blobs/896e937930a2be286388f1ae1003af2a41171bcdb97993b90e66a5836c4bce88000001a0272e57be

@@ -0,0 +1 @@
+{"id":"test-thread-1","status":"open","user":"dheer","_event_chunks":1}

package/sticky-server/.wrangler/state/v3/kv/PLACEHOLDER_KV_NAMESPACE_ID/blobs/cb1dad011015782163f59d1e79653f10a354fc026eea8e482fe7417f4c4d7426000001a0272e57b2

@@ -0,0 +1 @@
+[{"type":"tool_call","ts":"2026-08-21T10:00:00Z","data":{"tool":"Read"}}]

package/sticky-server/.wrangler/tmp/bundle-BhcBKo/checked-fetch.js

@@ -0,0 +1,28 @@
+const urls = new Set();
+
+function checkURL(request, init) {
+	const url =
+		request instanceof URL
+			? request
+			: new URL(
+					(typeof request === "string" ? new Request(request, init) : request)
+						.url
+				);
+	if (url.port && url.port !== "443" && url.protocol === "https:") {
+		if (!urls.has(url.toString())) {
+			urls.add(url.toString());
+			console.warn(
+				`WARNING: known issue with \`fetch()\` requests to custom HTTPS ports in published Workers:\n` +
+					` - ${url.toString()} - the custom port will be ignored when the Worker is published using the \`wrangler deploy\` command.\n`
+			);
+		}
+	}
+}
+
+globalThis.fetch = new Proxy(globalThis.fetch, {
+	apply(target, thisArg, argArray) {
+		const [request, init] = argArray;
+		checkURL(request, init);
+		return Reflect.apply(target, thisArg, argArray);
+	},
+});

package/sticky-server/.wrangler/tmp/bundle-BhcBKo/middleware-insertion-facade.js

@@ -0,0 +1,11 @@
+				import worker, * as OTHER_EXPORTS from "C:\\Users\\dheer\\OneDrive\\Desktop\\Projects\\sticky-note\\sticky-server\\worker.js";
+				import * as __MIDDLEWARE_0__ from "C:\\Users\\dheer\\AppData\\Roaming\\npm\\node_modules\\wrangler\\templates\\middleware\\middleware-ensure-req-body-drained.ts";
+import * as __MIDDLEWARE_1__ from "C:\\Users\\dheer\\AppData\\Roaming\\npm\\node_modules\\wrangler\\templates\\middleware\\middleware-miniflare3-json-error.ts";
+
+				export * from "C:\\Users\\dheer\\OneDrive\\Desktop\\Projects\\sticky-note\\sticky-server\\worker.js";
+				const MIDDLEWARE_TEST_INJECT = "__INJECT_FOR_TESTING_WRANGLER_MIDDLEWARE__";
+				export const __INTERNAL_WRANGLER_MIDDLEWARE__ = [
+					
+					__MIDDLEWARE_0__.default,__MIDDLEWARE_1__.default
+				]
+				export default worker;

package/sticky-server/.wrangler/tmp/bundle-BhcBKo/middleware-loader.entry.ts

@@ -0,0 +1,134 @@
+// This loads all middlewares exposed on the middleware object and then starts
+// the invocation chain. The big idea is that we can add these to the middleware
+// export dynamically through wrangler, or we can potentially let users directly
+// add them as a sort of "plugin" system.
+
+import ENTRY, { __INTERNAL_WRANGLER_MIDDLEWARE__ } from "C:\\Users\\dheer\\OneDrive\\Desktop\\Projects\\sticky-note\\sticky-server\\.wrangler\\tmp\\bundle-BhcBKo\\middleware-insertion-facade.js";
+import { __facade_invoke__, __facade_register__, Dispatcher } from "C:\\Users\\dheer\\AppData\\Roaming\\npm\\node_modules\\wrangler\\templates\\middleware\\common.ts";
+import type { WorkerEntrypointConstructor } from "C:\\Users\\dheer\\OneDrive\\Desktop\\Projects\\sticky-note\\sticky-server\\.wrangler\\tmp\\bundle-BhcBKo\\middleware-insertion-facade.js";
+
+// Preserve all the exports from the worker
+export * from "C:\\Users\\dheer\\OneDrive\\Desktop\\Projects\\sticky-note\\sticky-server\\.wrangler\\tmp\\bundle-BhcBKo\\middleware-insertion-facade.js";
+
+class __Facade_ScheduledController__ implements ScheduledController {
+	readonly #noRetry: ScheduledController["noRetry"];
+
+	constructor(
+		readonly scheduledTime: number,
+		readonly cron: string,
+		noRetry: ScheduledController["noRetry"]
+	) {
+		this.#noRetry = noRetry;
+	}
+
+	noRetry() {
+		if (!(this instanceof __Facade_ScheduledController__)) {
+			throw new TypeError("Illegal invocation");
+		}
+		// Need to call native method immediately in case uncaught error thrown
+		this.#noRetry();
+	}
+}
+
+function wrapExportedHandler(worker: ExportedHandler): ExportedHandler {
+	// If we don't have any middleware defined, just return the handler as is
+	if (
+		__INTERNAL_WRANGLER_MIDDLEWARE__ === undefined ||
+		__INTERNAL_WRANGLER_MIDDLEWARE__.length === 0
+	) {
+		return worker;
+	}
+	// Otherwise, register all middleware once
+	for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+		__facade_register__(middleware);
+	}
+
+	const fetchDispatcher: ExportedHandlerFetchHandler = function (
+		request,
+		env,
+		ctx
+	) {
+		if (worker.fetch === undefined) {
+			throw new Error("Handler does not export a fetch() function.");
+		}
+		return worker.fetch(request, env, ctx);
+	};
+
+	return {
+		...worker,
+		fetch(request, env, ctx) {
+			const dispatcher: Dispatcher = function (type, init) {
+				if (type === "scheduled" && worker.scheduled !== undefined) {
+					const controller = new __Facade_ScheduledController__(
+						Date.now(),
+						init.cron ?? "",
+						() => {}
+					);
+					return worker.scheduled(controller, env, ctx);
+				}
+			};
+			return __facade_invoke__(request, env, ctx, dispatcher, fetchDispatcher);
+		},
+	};
+}
+
+function wrapWorkerEntrypoint(
+	klass: WorkerEntrypointConstructor
+): WorkerEntrypointConstructor {
+	// If we don't have any middleware defined, just return the handler as is
+	if (
+		__INTERNAL_WRANGLER_MIDDLEWARE__ === undefined ||
+		__INTERNAL_WRANGLER_MIDDLEWARE__.length === 0
+	) {
+		return klass;
+	}
+	// Otherwise, register all middleware once
+	for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+		__facade_register__(middleware);
+	}
+
+	// `extend`ing `klass` here so other RPC methods remain callable
+	return class extends klass {
+		#fetchDispatcher: ExportedHandlerFetchHandler<Record<string, unknown>> = (
+			request,
+			env,
+			ctx
+		) => {
+			this.env = env;
+			this.ctx = ctx;
+			if (super.fetch === undefined) {
+				throw new Error("Entrypoint class does not define a fetch() function.");
+			}
+			return super.fetch(request);
+		};
+
+		#dispatcher: Dispatcher = (type, init) => {
+			if (type === "scheduled" && super.scheduled !== undefined) {
+				const controller = new __Facade_ScheduledController__(
+					Date.now(),
+					init.cron ?? "",
+					() => {}
+				);
+				return super.scheduled(controller);
+			}
+		};
+
+		fetch(request: Request<unknown, IncomingRequestCfProperties>) {
+			return __facade_invoke__(
+				request,
+				this.env,
+				this.ctx,
+				this.#dispatcher,
+				this.#fetchDispatcher
+			);
+		}
+	};
+}
+
+let WRAPPED_ENTRY: ExportedHandler | WorkerEntrypointConstructor | undefined;
+if (typeof ENTRY === "object") {
+	WRAPPED_ENTRY = wrapExportedHandler(ENTRY);
+} else if (typeof ENTRY === "function") {
+	WRAPPED_ENTRY = wrapWorkerEntrypoint(ENTRY);
+}
+export default WRAPPED_ENTRY;

package/sticky-server/.wrangler/tmp/bundle-EyT3Z4/checked-fetch.js

@@ -0,0 +1,28 @@
+const urls = new Set();
+
+function checkURL(request, init) {
+	const url =
+		request instanceof URL
+			? request
+			: new URL(
+					(typeof request === "string" ? new Request(request, init) : request)
+						.url
+				);
+	if (url.port && url.port !== "443" && url.protocol === "https:") {
+		if (!urls.has(url.toString())) {
+			urls.add(url.toString());
+			console.warn(
+				`WARNING: known issue with \`fetch()\` requests to custom HTTPS ports in published Workers:\n` +
+					` - ${url.toString()} - the custom port will be ignored when the Worker is published using the \`wrangler deploy\` command.\n`
+			);
+		}
+	}
+}
+
+globalThis.fetch = new Proxy(globalThis.fetch, {
+	apply(target, thisArg, argArray) {
+		const [request, init] = argArray;
+		checkURL(request, init);
+		return Reflect.apply(target, thisArg, argArray);
+	},
+});

package/sticky-server/.wrangler/tmp/bundle-EyT3Z4/middleware-insertion-facade.js

@@ -0,0 +1,11 @@
+				import worker, * as OTHER_EXPORTS from "C:\\Users\\dheer\\OneDrive\\Desktop\\Projects\\sticky-note\\sticky-server\\worker.js";
+				import * as __MIDDLEWARE_0__ from "C:\\Users\\dheer\\AppData\\Roaming\\npm\\node_modules\\wrangler\\templates\\middleware\\middleware-ensure-req-body-drained.ts";
+import * as __MIDDLEWARE_1__ from "C:\\Users\\dheer\\AppData\\Roaming\\npm\\node_modules\\wrangler\\templates\\middleware\\middleware-miniflare3-json-error.ts";
+
+				export * from "C:\\Users\\dheer\\OneDrive\\Desktop\\Projects\\sticky-note\\sticky-server\\worker.js";
+				const MIDDLEWARE_TEST_INJECT = "__INJECT_FOR_TESTING_WRANGLER_MIDDLEWARE__";
+				export const __INTERNAL_WRANGLER_MIDDLEWARE__ = [
+					
+					__MIDDLEWARE_0__.default,__MIDDLEWARE_1__.default
+				]
+				export default worker;