sticky-note-cli 3.1.13 → 3.1.15

package/sticky-server/.wrangler/tmp/dev-QZJJpV/worker.js

@@ -0,0 +1,579 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// .wrangler/tmp/bundle-jSM6YE/checked-fetch.js
+var urls = /* @__PURE__ */ 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:
+ - ${url.toString()} - the custom port will be ignored when the Worker is published using the \`wrangler deploy\` command.
+`
+      );
+    }
+  }
+}
+__name(checkURL, "checkURL");
+globalThis.fetch = new Proxy(globalThis.fetch, {
+  apply(target, thisArg, argArray) {
+    const [request, init] = argArray;
+    checkURL(request, init);
+    return Reflect.apply(target, thisArg, argArray);
+  }
+});
+
+// adapters/cf-kv.js
+async function getThreads(kv, project, filters = {}) {
+  const indexKey = `${project}:thread-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (index.length === 0) return [];
+  const threads = await Promise.all(
+    index.map(async (id) => {
+      const raw = await kv.get(`${project}:thread:${id}`);
+      return raw ? JSON.parse(raw) : null;
+    })
+  );
+  let result = threads.filter(Boolean);
+  if (filters.status) {
+    result = result.filter((t) => t.status === filters.status);
+  }
+  if (filters.q) {
+    const q = filters.q.toLowerCase();
+    result = result.filter(
+      (t) => (t.narrative || "").toLowerCase().includes(q) || (t.handoff_summary || "").toLowerCase().includes(q) || (t.last_note || "").toLowerCase().includes(q) || (t.files_touched || []).some((f) => f.toLowerCase().includes(q))
+    );
+  }
+  return result;
+}
+__name(getThreads, "getThreads");
+async function getThread(kv, project, id) {
+  const raw = await kv.get(`${project}:thread:${id}`);
+  return raw ? JSON.parse(raw) : null;
+}
+__name(getThread, "getThread");
+async function putThread(kv, project, thread) {
+  const id = thread.id;
+  await kv.put(`${project}:thread:${id}`, JSON.stringify(thread));
+  const indexKey = `${project}:thread-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (!index.includes(id)) {
+    index.push(id);
+    await kv.put(indexKey, JSON.stringify(index));
+  }
+}
+__name(putThread, "putThread");
+async function deleteThread(kv, project, id) {
+  const existing = await getThread(kv, project, id);
+  if (existing) {
+    const tombstone = {
+      id: existing.id,
+      user: existing.user,
+      status: "expired",
+      closed_at: existing.closed_at || (/* @__PURE__ */ new Date()).toISOString(),
+      created_at: existing.created_at
+    };
+    await kv.put(`${project}:thread:${id}`, JSON.stringify(tombstone));
+  }
+}
+__name(deleteThread, "deleteThread");
+async function appendAudit(kv, project, record) {
+  const ts = record.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const uid = crypto.randomUUID();
+  const key = `${project}:audit:${ts}:${uid}`;
+  await kv.put(key, JSON.stringify(record));
+  const indexKey = `${project}:audit-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  index.push(key);
+  if (index.length > 1e4) {
+    const removed = index.splice(0, index.length - 1e4);
+    await Promise.all(removed.map((k) => kv.delete(k)));
+  }
+  await kv.put(indexKey, JSON.stringify(index));
+}
+__name(appendAudit, "appendAudit");
+async function queryAudit(kv, project, filters = {}) {
+  const indexKey = `${project}:audit-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (index.length === 0) return [];
+  const records = await Promise.all(
+    index.map(async (key) => {
+      const raw = await kv.get(key);
+      return raw ? JSON.parse(raw) : null;
+    })
+  );
+  let result = records.filter(Boolean);
+  if (filters.user) {
+    result = result.filter((r) => r.user === filters.user);
+  }
+  if (filters.file) {
+    result = result.filter((r) => (r.file || "").includes(filters.file));
+  }
+  if (filters.tool) {
+    result = result.filter((r) => r.tool === filters.tool);
+  }
+  if (filters.since) {
+    const since = new Date(filters.since).getTime();
+    result = result.filter(
+      (r) => new Date(r.timestamp || 0).getTime() >= since
+    );
+  }
+  return result;
+}
+__name(queryAudit, "queryAudit");
+var PRESENCE_TTL_SECONDS = 15 * 60;
+async function getPresence(kv, project) {
+  const indexKey = `${project}:presence-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (index.length === 0) return [];
+  const records = await Promise.all(
+    index.map(async (user) => {
+      const raw = await kv.get(`${project}:presence:${user}`);
+      return raw ? JSON.parse(raw) : null;
+    })
+  );
+  return records.filter(Boolean);
+}
+__name(getPresence, "getPresence");
+async function upsertPresence(kv, project, record) {
+  const user = record.user;
+  await kv.put(`${project}:presence:${user}`, JSON.stringify(record), {
+    expirationTtl: PRESENCE_TTL_SECONDS
+  });
+  const indexKey = `${project}:presence-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (!index.includes(user)) {
+    index.push(user);
+    await kv.put(indexKey, JSON.stringify(index));
+  }
+}
+__name(upsertPresence, "upsertPresence");
+async function deletePresence(kv, project, user) {
+  await kv.delete(`${project}:presence:${user}`);
+  const indexKey = `${project}:presence-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  const filtered = index.filter((u) => u !== user);
+  await kv.put(indexKey, JSON.stringify(filtered));
+}
+__name(deletePresence, "deletePresence");
+var MAX_CHUNK_BYTES = 2 * 1024 * 1024;
+async function getEvents(kv, project, threadId) {
+  const metaKey = `${project}:thread:${threadId}`;
+  const meta = await kv.get(metaKey, { type: "json" }).catch(() => null);
+  const chunkCount = meta && meta._event_chunks || 0;
+  if (chunkCount === 0) {
+    const single = await kv.get(`${metaKey}:events`, { type: "json" }).catch(() => null);
+    return Array.isArray(single) ? single : [];
+  }
+  const chunks = await Promise.all(
+    Array.from(
+      { length: chunkCount },
+      (_, i) => kv.get(`${metaKey}:events:${i}`, { type: "json" }).catch(() => [])
+    )
+  );
+  return chunks.flat().filter(Boolean);
+}
+__name(getEvents, "getEvents");
+async function appendEvents(kv, project, threadId, newEvents) {
+  if (!newEvents || newEvents.length === 0) return;
+  const metaKey = `${project}:thread:${threadId}`;
+  const meta = await kv.get(metaKey, { type: "json" }).catch(() => ({}));
+  const chunkCount = meta && meta._event_chunks || 0;
+  let currentChunkIdx = chunkCount === 0 ? 0 : chunkCount - 1;
+  let currentChunk = [];
+  if (chunkCount > 0) {
+    currentChunk = await kv.get(`${metaKey}:events:${currentChunkIdx}`, { type: "json" }).catch(() => []) || [];
+  }
+  for (const event of newEvents) {
+    const eventBytes = new TextEncoder().encode(JSON.stringify(event)).length;
+    const chunkBytes = new TextEncoder().encode(JSON.stringify(currentChunk)).length;
+    if (chunkBytes + eventBytes > MAX_CHUNK_BYTES && currentChunk.length > 0) {
+      await kv.put(`${metaKey}:events:${currentChunkIdx}`, JSON.stringify(currentChunk));
+      currentChunkIdx++;
+      currentChunk = [];
+    }
+    currentChunk.push(event);
+  }
+  await kv.put(`${metaKey}:events:${currentChunkIdx}`, JSON.stringify(currentChunk));
+  const newMeta = { ...meta || {}, _event_chunks: currentChunkIdx + 1 };
+  await kv.put(metaKey, JSON.stringify(newMeta));
+}
+__name(appendEvents, "appendEvents");
+async function getConfig(kv, project) {
+  const raw = await kv.get(`${project}:config`);
+  return raw ? JSON.parse(raw) : null;
+}
+__name(getConfig, "getConfig");
+async function putConfig(kv, project, config) {
+  await kv.put(`${project}:config`, JSON.stringify(config));
+}
+__name(putConfig, "putConfig");
+
+// worker.js
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+__name(json, "json");
+function error(message, status = 400) {
+  return json({ error: message }, status);
+}
+__name(error, "error");
+function authenticate(request, env) {
+  const key = request.headers.get("X-Sticky-API-Key");
+  if (!env.STICKY_API_KEY) return true;
+  return key === env.STICKY_API_KEY;
+}
+__name(authenticate, "authenticate");
+function getProject(request) {
+  return request.headers.get("X-Sticky-Project") || "default";
+}
+__name(getProject, "getProject");
+function matchRoute(method, pathname) {
+  if (method === "POST" && pathname === "/threads") return { handler: "createThread" };
+  if (method === "GET" && pathname === "/threads") return { handler: "listThreads" };
+  if (method === "POST" && pathname.match(/^\/threads\/[^/]+\/events$/)) {
+    const id = pathname.split("/")[2];
+    return { handler: "appendThreadEvents", id };
+  }
+  if (method === "GET" && pathname.match(/^\/threads\/[^/]+\/events$/)) {
+    const id = pathname.split("/")[2];
+    return { handler: "getThreadEvents", id };
+  }
+  if (method === "GET" && pathname.startsWith("/threads/")) {
+    return { handler: "getThread", id: pathname.slice("/threads/".length) };
+  }
+  if (method === "PUT" && pathname.startsWith("/threads/")) {
+    return { handler: "updateThread", id: pathname.slice("/threads/".length) };
+  }
+  if (method === "DELETE" && pathname.startsWith("/threads/")) {
+    return { handler: "deleteThread", id: pathname.slice("/threads/".length) };
+  }
+  if (method === "GET" && pathname === "/audit") return { handler: "queryAudit" };
+  if (method === "POST" && pathname === "/audit") return { handler: "appendAudit" };
+  if (method === "GET" && pathname === "/presence") return { handler: "getPresence" };
+  if (method === "POST" && pathname === "/presence") return { handler: "upsertPresence" };
+  if (method === "DELETE" && pathname.startsWith("/presence/")) {
+    return { handler: "deletePresence", user: decodeURIComponent(pathname.slice("/presence/".length)) };
+  }
+  if (method === "GET" && pathname === "/config") return { handler: "getConfig" };
+  if (method === "PUT" && pathname === "/config") return { handler: "putConfig" };
+  if (method === "GET" && pathname === "/health") return { handler: "health" };
+  return null;
+}
+__name(matchRoute, "matchRoute");
+var handlers = {
+  async health() {
+    return json({ status: "ok", version: "3.0.0" });
+  },
+  // ── Threads ──
+  async createThread(request, kv, project) {
+    const thread = await request.json();
+    if (!thread.id) return error("thread.id is required");
+    await putThread(kv, project, thread);
+    return json(thread, 201);
+  },
+  async listThreads(request, kv, project) {
+    const url = new URL(request.url);
+    const filters = {
+      status: url.searchParams.get("status") || void 0,
+      q: url.searchParams.get("q") || void 0
+    };
+    const threads = await getThreads(kv, project, filters);
+    return json({ threads });
+  },
+  async getThread(_request, kv, project, { id }) {
+    const thread = await getThread(kv, project, id);
+    if (!thread) return error("Thread not found", 404);
+    return json(thread);
+  },
+  async updateThread(request, kv, project, { id }) {
+    const thread = await request.json();
+    thread.id = id;
+    await putThread(kv, project, thread);
+    return json(thread);
+  },
+  async deleteThread(_request, kv, project, { id }) {
+    await deleteThread(kv, project, id);
+    return json({ deleted: id });
+  },
+  // ── Thread Events ──
+  async appendThreadEvents(request, kv, project, { id }) {
+    const body = await request.json().catch(() => ({}));
+    const events = Array.isArray(body.events) ? body.events : [];
+    await appendEvents(kv, project, id, events);
+    return json({ ok: true, appended: events.length });
+  },
+  async getThreadEvents(_request, kv, project, { id }) {
+    const events = await getEvents(kv, project, id);
+    return json({ events });
+  },
+  // ── Audit ──
+  async queryAudit(request, kv, project) {
+    const url = new URL(request.url);
+    const filters = {
+      user: url.searchParams.get("user") || void 0,
+      file: url.searchParams.get("file") || void 0,
+      tool: url.searchParams.get("tool") || void 0,
+      since: url.searchParams.get("since") || void 0
+    };
+    const records = await queryAudit(kv, project, filters);
+    return json({ audit: records });
+  },
+  async appendAudit(request, kv, project) {
+    const record = await request.json();
+    await appendAudit(kv, project, record);
+    return json({ ok: true }, 201);
+  },
+  // ── Presence ──
+  async getPresence(_request, kv, project) {
+    const records = await getPresence(kv, project);
+    return json({ presence: records });
+  },
+  async upsertPresence(request, kv, project) {
+    const record = await request.json();
+    if (!record.user) return error("record.user is required");
+    await upsertPresence(kv, project, record);
+    return json({ ok: true });
+  },
+  async deletePresence(_request, kv, project, { user }) {
+    await deletePresence(kv, project, user);
+    return json({ deleted: user });
+  },
+  // ── Config ──
+  async getConfig(_request, kv, project) {
+    const config = await getConfig(kv, project);
+    if (!config) return json({});
+    return json(config);
+  },
+  async putConfig(request, kv, project) {
+    const config = await request.json();
+    await putConfig(kv, project, config);
+    return json(config);
+  }
+};
+var worker_default = {
+  async fetch(request, env) {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, X-Sticky-API-Key, X-Sticky-Project"
+        }
+      });
+    }
+    if (!authenticate(request, env)) {
+      return error("Unauthorized", 401);
+    }
+    const url = new URL(request.url);
+    const route = matchRoute(request.method, url.pathname);
+    if (!route) {
+      return error("Not found", 404);
+    }
+    const project = getProject(request);
+    const kv = env.STICKY_KV;
+    try {
+      const handler = handlers[route.handler];
+      const response = await handler(request, kv, project, route);
+      const headers = new Headers(response.headers);
+      headers.set("Access-Control-Allow-Origin", "*");
+      return new Response(response.body, {
+        status: response.status,
+        headers
+      });
+    } catch (err) {
+      return error(`Internal error: ${err.message}`, 500);
+    }
+  }
+};
+
+// ../../../../../AppData/Roaming/npm/node_modules/wrangler/templates/middleware/middleware-ensure-req-body-drained.ts
+var drainBody = /* @__PURE__ */ __name(async (request, env, _ctx, middlewareCtx) => {
+  try {
+    return await middlewareCtx.next(request, env);
+  } finally {
+    try {
+      if (request.body !== null && !request.bodyUsed) {
+        const reader = request.body.getReader();
+        while (!(await reader.read()).done) {
+        }
+      }
+    } catch (e) {
+      console.error("Failed to drain the unused request body.", e);
+    }
+  }
+}, "drainBody");
+var middleware_ensure_req_body_drained_default = drainBody;
+
+// ../../../../../AppData/Roaming/npm/node_modules/wrangler/templates/middleware/middleware-miniflare3-json-error.ts
+function reduceError(e) {
+  return {
+    name: e?.name,
+    message: e?.message ?? String(e),
+    stack: e?.stack,
+    cause: e?.cause === void 0 ? void 0 : reduceError(e.cause)
+  };
+}
+__name(reduceError, "reduceError");
+var jsonError = /* @__PURE__ */ __name(async (request, env, _ctx, middlewareCtx) => {
+  try {
+    return await middlewareCtx.next(request, env);
+  } catch (e) {
+    const error2 = reduceError(e);
+    const body = JSON.stringify(error2);
+    const headers = {
+      "Content-Type": "application/json",
+      "MF-Experimental-Error-Stack": "true"
+    };
+    const encoded = encodeURIComponent(body);
+    if (encoded.length <= 8192) {
+      headers["MF-Experimental-Error-Stack-Payload"] = encoded;
+    }
+    return new Response(body, { status: 500, headers });
+  }
+}, "jsonError");
+var middleware_miniflare3_json_error_default = jsonError;
+
+// .wrangler/tmp/bundle-jSM6YE/middleware-insertion-facade.js
+var __INTERNAL_WRANGLER_MIDDLEWARE__ = [
+  middleware_ensure_req_body_drained_default,
+  middleware_miniflare3_json_error_default
+];
+var middleware_insertion_facade_default = worker_default;
+
+// ../../../../../AppData/Roaming/npm/node_modules/wrangler/templates/middleware/common.ts
+var __facade_middleware__ = [];
+function __facade_register__(...args) {
+  __facade_middleware__.push(...args.flat());
+}
+__name(__facade_register__, "__facade_register__");
+function __facade_invokeChain__(request, env, ctx, dispatch, middlewareChain) {
+  const [head, ...tail] = middlewareChain;
+  const middlewareCtx = {
+    dispatch,
+    next(newRequest, newEnv) {
+      return __facade_invokeChain__(newRequest, newEnv, ctx, dispatch, tail);
+    }
+  };
+  return head(request, env, ctx, middlewareCtx);
+}
+__name(__facade_invokeChain__, "__facade_invokeChain__");
+function __facade_invoke__(request, env, ctx, dispatch, finalMiddleware) {
+  return __facade_invokeChain__(request, env, ctx, dispatch, [
+    ...__facade_middleware__,
+    finalMiddleware
+  ]);
+}
+__name(__facade_invoke__, "__facade_invoke__");
+
+// .wrangler/tmp/bundle-jSM6YE/middleware-loader.entry.ts
+var __Facade_ScheduledController__ = class ___Facade_ScheduledController__ {
+  constructor(scheduledTime, cron, noRetry) {
+    this.scheduledTime = scheduledTime;
+    this.cron = cron;
+    this.#noRetry = noRetry;
+  }
+  scheduledTime;
+  cron;
+  static {
+    __name(this, "__Facade_ScheduledController__");
+  }
+  #noRetry;
+  noRetry() {
+    if (!(this instanceof ___Facade_ScheduledController__)) {
+      throw new TypeError("Illegal invocation");
+    }
+    this.#noRetry();
+  }
+};
+function wrapExportedHandler(worker) {
+  if (__INTERNAL_WRANGLER_MIDDLEWARE__ === void 0 || __INTERNAL_WRANGLER_MIDDLEWARE__.length === 0) {
+    return worker;
+  }
+  for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+    __facade_register__(middleware);
+  }
+  const fetchDispatcher = /* @__PURE__ */ __name(function(request, env, ctx) {
+    if (worker.fetch === void 0) {
+      throw new Error("Handler does not export a fetch() function.");
+    }
+    return worker.fetch(request, env, ctx);
+  }, "fetchDispatcher");
+  return {
+    ...worker,
+    fetch(request, env, ctx) {
+      const dispatcher = /* @__PURE__ */ __name(function(type, init) {
+        if (type === "scheduled" && worker.scheduled !== void 0) {
+          const controller = new __Facade_ScheduledController__(
+            Date.now(),
+            init.cron ?? "",
+            () => {
+            }
+          );
+          return worker.scheduled(controller, env, ctx);
+        }
+      }, "dispatcher");
+      return __facade_invoke__(request, env, ctx, dispatcher, fetchDispatcher);
+    }
+  };
+}
+__name(wrapExportedHandler, "wrapExportedHandler");
+function wrapWorkerEntrypoint(klass) {
+  if (__INTERNAL_WRANGLER_MIDDLEWARE__ === void 0 || __INTERNAL_WRANGLER_MIDDLEWARE__.length === 0) {
+    return klass;
+  }
+  for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+    __facade_register__(middleware);
+  }
+  return class extends klass {
+    #fetchDispatcher = /* @__PURE__ */ __name((request, env, ctx) => {
+      this.env = env;
+      this.ctx = ctx;
+      if (super.fetch === void 0) {
+        throw new Error("Entrypoint class does not define a fetch() function.");
+      }
+      return super.fetch(request);
+    }, "#fetchDispatcher");
+    #dispatcher = /* @__PURE__ */ __name((type, init) => {
+      if (type === "scheduled" && super.scheduled !== void 0) {
+        const controller = new __Facade_ScheduledController__(
+          Date.now(),
+          init.cron ?? "",
+          () => {
+          }
+        );
+        return super.scheduled(controller);
+      }
+    }, "#dispatcher");
+    fetch(request) {
+      return __facade_invoke__(
+        request,
+        this.env,
+        this.ctx,
+        this.#dispatcher,
+        this.#fetchDispatcher
+      );
+    }
+  };
+}
+__name(wrapWorkerEntrypoint, "wrapWorkerEntrypoint");
+var WRAPPED_ENTRY;
+if (typeof middleware_insertion_facade_default === "object") {
+  WRAPPED_ENTRY = wrapExportedHandler(middleware_insertion_facade_default);
+} else if (typeof middleware_insertion_facade_default === "function") {
+  WRAPPED_ENTRY = wrapWorkerEntrypoint(middleware_insertion_facade_default);
+}
+var middleware_loader_entry_default = WRAPPED_ENTRY;
+export {
+  __INTERNAL_WRANGLER_MIDDLEWARE__,
+  middleware_loader_entry_default as default
+};
+//# sourceMappingURL=worker.js.map