@weavecode/weave 0.0.0-stage → 0.1.1

package/node_modules/web-push/src/web-push-lib.js

@@ -0,0 +1,413 @@
+'use strict';
+
+const url = require('url');
+const https = require('https');
+
+const WebPushError = require('./web-push-error.js');
+const vapidHelper = require('./vapid-helper.js');
+const encryptionHelper = require('./encryption-helper.js');
+const webPushConstants = require('./web-push-constants.js');
+const urlBase64Helper = require('./urlsafe-base64-helper');
+
+// Default TTL is four weeks.
+const DEFAULT_TTL = 2419200;
+
+let gcmAPIKey = '';
+let vapidDetails;
+
+function WebPushLib() {
+
+}
+
+/**
+ * When sending messages to a GCM endpoint you need to set the GCM API key
+ * by either calling setGMAPIKey() or passing in the API key as an option
+ * to sendNotification().
+ * @param  {string} apiKey The API key to send with the GCM request.
+ */
+WebPushLib.prototype.setGCMAPIKey = function(apiKey) {
+  if (apiKey === null) {
+    gcmAPIKey = null;
+    return;
+  }
+
+  if (typeof apiKey === 'undefined'
+  || typeof apiKey !== 'string'
+  || apiKey.length === 0) {
+    throw new Error('The GCM API Key should be a non-empty string or null.');
+  }
+
+  gcmAPIKey = apiKey;
+};
+
+/**
+ * When making requests where you want to define VAPID details, call this
+ * method before sendNotification() or pass in the details and options to
+ * sendNotification.
+ * @param  {string} subject    This must be either a URL or a 'mailto:'
+ * address. For example: 'https://my-site.com/contact' or
+ * 'mailto: contact@my-site.com'
+ * @param  {string} publicKey  The public VAPID key, a URL safe, base64 encoded string
+ * @param  {string} privateKey The private VAPID key, a URL safe, base64 encoded string.
+ */
+WebPushLib.prototype.setVapidDetails = function(subject, publicKey, privateKey) {
+    if (arguments.length === 1 && arguments[0] === null) {
+      vapidDetails = null;
+      return;
+    }
+
+    vapidHelper.validateSubject(subject);
+    vapidHelper.validatePublicKey(publicKey);
+    vapidHelper.validatePrivateKey(privateKey);
+
+    vapidDetails = {
+      subject: subject,
+      publicKey: publicKey,
+      privateKey: privateKey
+    };
+  };
+
+  /**
+   * To get the details of a request to trigger a push message, without sending
+   * a push notification call this method.
+   *
+   * This method will throw an error if there is an issue with the input.
+   * @param  {PushSubscription} subscription The PushSubscription you wish to
+   * send the notification to.
+   * @param  {string|Buffer} [payload]       The payload you wish to send to the
+   * the user.
+   * @param  {Object} [options]              Options for the GCM API key and
+   * vapid keys can be passed in if they are unique for each notification you
+   * wish to send.
+   * @return {Object}                       This method returns an Object which
+   * contains 'endpoint', 'method', 'headers' and 'payload'.
+   */
+WebPushLib.prototype.generateRequestDetails = function(subscription, payload, options) {
+    if (!subscription || !subscription.endpoint) {
+      throw new Error('You must pass in a subscription with at least '
+      + 'an endpoint.');
+    }
+
+    if (typeof subscription.endpoint !== 'string'
+    || subscription.endpoint.length === 0) {
+      throw new Error('The subscription endpoint must be a string with '
+      + 'a valid URL.');
+    }
+
+    if (payload) {
+      // Validate the subscription keys
+      if (typeof subscription !== 'object' || !subscription.keys
+      || !subscription.keys.p256dh
+      || !subscription.keys.auth) {
+        throw new Error('To send a message with a payload, the '
+        + 'subscription must have \'auth\' and \'p256dh\' keys.');
+      }
+    }
+
+    let currentGCMAPIKey = gcmAPIKey;
+    let currentVapidDetails = vapidDetails;
+    let timeToLive = DEFAULT_TTL;
+    let extraHeaders = {};
+    let contentEncoding = webPushConstants.supportedContentEncodings.AES_128_GCM;
+    let urgency = webPushConstants.supportedUrgency.NORMAL;
+    let topic;
+    let proxy;
+    let agent;
+    let timeout;
+
+    if (options) {
+      const validOptionKeys = [
+        'headers',
+        'gcmAPIKey',
+        'vapidDetails',
+        'TTL',
+        'contentEncoding',
+        'urgency',
+        'topic',
+        'proxy',
+        'agent',
+        'timeout'
+      ];
+      const optionKeys = Object.keys(options);
+      for (let i = 0; i < optionKeys.length; i += 1) {
+        const optionKey = optionKeys[i];
+        if (!validOptionKeys.includes(optionKey)) {
+          throw new Error('\'' + optionKey + '\' is an invalid option. '
+          + 'The valid options are [\'' + validOptionKeys.join('\', \'')
+          + '\'].');
+        }
+      }
+
+      if (options.headers) {
+        extraHeaders = options.headers;
+        let duplicates = Object.keys(extraHeaders)
+            .filter(function (header) {
+              return typeof options[header] !== 'undefined';
+            });
+
+        if (duplicates.length > 0) {
+          throw new Error('Duplicated headers defined ['
+          + duplicates.join(',') + ']. Please either define the header in the'
+          + 'top level options OR in the \'headers\' key.');
+        }
+      }
+
+      if (options.gcmAPIKey) {
+        currentGCMAPIKey = options.gcmAPIKey;
+      }
+
+      // Falsy values are allowed here so one can skip Vapid `else if` below and use FCM
+      if (options.vapidDetails !== undefined) {
+        currentVapidDetails = options.vapidDetails;
+      }
+
+      if (options.TTL !== undefined) {
+        timeToLive = Number(options.TTL);
+        if (timeToLive < 0) {
+          throw new Error('TTL should be a number and should be at least 0');
+        }
+      }
+
+      if (options.contentEncoding) {
+        if ((options.contentEncoding === webPushConstants.supportedContentEncodings.AES_128_GCM
+          || options.contentEncoding === webPushConstants.supportedContentEncodings.AES_GCM)) {
+          contentEncoding = options.contentEncoding;
+        } else {
+          throw new Error('Unsupported content encoding specified.');
+        }
+      }
+
+      if (options.urgency) {
+        if ((options.urgency === webPushConstants.supportedUrgency.VERY_LOW
+          || options.urgency === webPushConstants.supportedUrgency.LOW
+          || options.urgency === webPushConstants.supportedUrgency.NORMAL
+          || options.urgency === webPushConstants.supportedUrgency.HIGH)) {
+          urgency = options.urgency;
+        } else {
+          throw new Error('Unsupported urgency specified.');
+        }
+      }
+
+      if (options.topic) {
+        if (!urlBase64Helper.validate(options.topic)) {
+          throw new Error('Unsupported characters set use the URL or filename-safe Base64 characters set');
+        }
+        if (options.topic.length > 32) {
+          throw new Error('use maximum of 32 characters from the URL or filename-safe Base64 characters set');
+        }
+        topic = options.topic;
+      }
+
+      if (options.proxy) {
+        if (typeof options.proxy === 'string'
+          || typeof options.proxy.host === 'string') {
+          proxy = options.proxy;
+        } else {
+          console.warn('Attempt to use proxy option, but invalid type it should be a string or proxy options object.');
+        }
+      }
+
+      if (options.agent) {
+        if (options.agent instanceof https.Agent) {
+          if (proxy) {
+            console.warn('Agent option will be ignored because proxy option is defined.');
+          }
+
+          agent = options.agent;
+        } else {
+          console.warn('Wrong type for the agent option, it should be an instance of https.Agent.');
+        }
+      }
+
+      if (typeof options.timeout === 'number') {
+        timeout = options.timeout;
+      }
+    }
+
+    if (typeof timeToLive === 'undefined') {
+      timeToLive = DEFAULT_TTL;
+    }
+
+    const requestDetails = {
+      method: 'POST',
+      headers: {
+        TTL: timeToLive
+      }
+    };
+    Object.keys(extraHeaders).forEach(function (header) {
+      requestDetails.headers[header] = extraHeaders[header];
+    });
+    let requestPayload = null;
+
+    if (payload) {
+      const encrypted = encryptionHelper
+        .encrypt(subscription.keys.p256dh, subscription.keys.auth, payload, contentEncoding);
+
+      requestDetails.headers['Content-Length'] = encrypted.cipherText.length;
+      requestDetails.headers['Content-Type'] = 'application/octet-stream';
+
+      if (contentEncoding === webPushConstants.supportedContentEncodings.AES_128_GCM) {
+        requestDetails.headers['Content-Encoding'] = webPushConstants.supportedContentEncodings.AES_128_GCM;
+      } else if (contentEncoding === webPushConstants.supportedContentEncodings.AES_GCM) {
+        requestDetails.headers['Content-Encoding'] = webPushConstants.supportedContentEncodings.AES_GCM;
+        requestDetails.headers.Encryption = 'salt=' + encrypted.salt;
+        requestDetails.headers['Crypto-Key'] = 'dh=' + encrypted.localPublicKey.toString('base64url');
+      }
+
+      requestPayload = encrypted.cipherText;
+    } else {
+      requestDetails.headers['Content-Length'] = 0;
+    }
+
+    const isGCM = subscription.endpoint.startsWith('https://android.googleapis.com/gcm/send');
+    const isFCM = subscription.endpoint.startsWith('https://fcm.googleapis.com/fcm/send');
+    // VAPID isn't supported by GCM hence the if, else if.
+    if (isGCM) {
+      if (!currentGCMAPIKey) {
+        console.warn('Attempt to send push notification to GCM endpoint, '
+        + 'but no GCM key is defined. Please use setGCMApiKey() or add '
+        + '\'gcmAPIKey\' as an option.');
+      } else {
+        requestDetails.headers.Authorization = 'key=' + currentGCMAPIKey;
+      }
+    } else if (currentVapidDetails) {
+      const parsedUrl = url.parse(subscription.endpoint);
+      const audience = parsedUrl.protocol + '//'
+      + parsedUrl.host;
+
+      const vapidHeaders = vapidHelper.getVapidHeaders(
+        audience,
+        currentVapidDetails.subject,
+        currentVapidDetails.publicKey,
+        currentVapidDetails.privateKey,
+        contentEncoding
+      );
+
+      requestDetails.headers.Authorization = vapidHeaders.Authorization;
+
+      if (contentEncoding === webPushConstants.supportedContentEncodings.AES_GCM) {
+        if (requestDetails.headers['Crypto-Key']) {
+          requestDetails.headers['Crypto-Key'] += ';'
+          + vapidHeaders['Crypto-Key'];
+        } else {
+          requestDetails.headers['Crypto-Key'] = vapidHeaders['Crypto-Key'];
+        }
+      }
+    } else if (isFCM && currentGCMAPIKey) {
+      requestDetails.headers.Authorization = 'key=' + currentGCMAPIKey;
+    }
+
+    requestDetails.headers.Urgency = urgency;
+
+    if (topic) {
+      requestDetails.headers.Topic = topic;
+    }
+
+    requestDetails.body = requestPayload;
+    requestDetails.endpoint = subscription.endpoint;
+
+    if (proxy) {
+      requestDetails.proxy = proxy;
+    }
+
+    if (agent) {
+      requestDetails.agent = agent;
+    }
+
+    if (timeout) {
+      requestDetails.timeout = timeout;
+    }
+
+    return requestDetails;
+  };
+
+/**
+ * To send a push notification call this method with a subscription, optional
+ * payload and any options.
+ * @param  {PushSubscription} subscription The PushSubscription you wish to
+ * send the notification to.
+ * @param  {string|Buffer} [payload]       The payload you wish to send to the
+ * the user.
+ * @param  {Object} [options]              Options for the GCM API key and
+ * vapid keys can be passed in if they are unique for each notification you
+ * wish to send.
+ * @return {Promise}                       This method returns a Promise which
+ * resolves if the sending of the notification was successful, otherwise it
+ * rejects.
+ */
+WebPushLib.prototype.sendNotification = function(subscription, payload, options) {
+    let requestDetails;
+    try {
+      requestDetails = this.generateRequestDetails(subscription, payload, options);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+
+    return new Promise(function(resolve, reject) {
+      const httpsOptions = {};
+      const urlParts = url.parse(requestDetails.endpoint);
+      httpsOptions.hostname = urlParts.hostname;
+      httpsOptions.port = urlParts.port;
+      httpsOptions.path = urlParts.path;
+
+      httpsOptions.headers = requestDetails.headers;
+      httpsOptions.method = requestDetails.method;
+
+      if (requestDetails.timeout) {
+        httpsOptions.timeout = requestDetails.timeout;
+      }
+
+      if (requestDetails.agent) {
+        httpsOptions.agent = requestDetails.agent;
+      }
+
+      if (requestDetails.proxy) {
+        const { HttpsProxyAgent } = require('https-proxy-agent'); // eslint-disable-line global-require
+        httpsOptions.agent = new HttpsProxyAgent(requestDetails.proxy);
+      }
+
+      const pushRequest = https.request(httpsOptions, function(pushResponse) {
+        let responseText = '';
+
+        pushResponse.on('data', function(chunk) {
+          responseText += chunk;
+        });
+
+        pushResponse.on('end', function() {
+          if (pushResponse.statusCode < 200 || pushResponse.statusCode > 299) {
+            reject(new WebPushError(
+              'Received unexpected response code',
+              pushResponse.statusCode,
+              pushResponse.headers,
+              responseText,
+              requestDetails.endpoint
+            ));
+          } else {
+            resolve({
+              statusCode: pushResponse.statusCode,
+              body: responseText,
+              headers: pushResponse.headers
+            });
+          }
+        });
+      });
+
+      if (requestDetails.timeout) {
+        pushRequest.on('timeout', function() {
+          pushRequest.destroy(new Error('Socket timeout'));
+        });
+      }
+
+      pushRequest.on('error', function(e) {
+        reject(e);
+      });
+
+      if (requestDetails.body) {
+        pushRequest.write(requestDetails.body);
+      }
+
+      pushRequest.end();
+    });
+  };
+
+module.exports = WebPushLib;

package/node_modules/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/zod/README.md

@@ -0,0 +1,208 @@
+<p align="center">
+  <img src="logo.svg" width="200px" align="center" alt="Zod logo" />
+  <h1 align="center">Zod</h1>
+  <p align="center">
+    TypeScript-first schema validation with static type inference
+    <br/>
+    by <a href="https://x.com/colinhacks">@colinhacks</a>
+  </p>
+</p>
+<br/>
+
+<p align="center">
+<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amaster"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=master" alt="Zod CI status" /></a>
+<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
+<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
+<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
+<a href="https://github.com/colinhacks/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
+</p>
+
+<div align="center">
+  <a href="https://zod.dev/api">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/colinhacks">𝕏</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://bsky.app/profile/zod.dev">Bluesky</a>
+  <br />
+</div>
+
+<br/>
+<br/>
+
+<h2 align="center">Featured sponsor: Jazz</h2>
+
+<div align="center">
+  <a href="https://jazz.tools/?utm_source=zod">
+    <picture width="85%" >
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png">
+      <img alt="jazz logo" src="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png" width="85%">
+    </picture>
+  </a>
+  <br/>
+  <p><sub>Learn more about <a target="_blank" rel="noopener noreferrer" href="mailto:sponsorship@colinhacks.com">featured sponsorships</a></sub></p>
+</div>
+
+<br/>
+<br/>
+<br/>
+
+### [Read the docs →](https://zod.dev/api)
+
+<br/>
+<br/>
+
+## What is Zod?
+
+Zod is a TypeScript-first validation library. Define a schema and parse some data with it. You'll get back a strongly typed, validated result.
+
+```ts
+import * as z from "zod/v4";
+
+const User = z.object({
+  name: z.string(),
+});
+
+// some untrusted data...
+const input = {
+  /* stuff */
+};
+
+// the parsed result is validated and type safe!
+const data = User.parse(input);
+
+// so you can use it with confidence :)
+console.log(data.name);
+```
+
+<br/>
+
+## Features
+
+- Zero external dependencies
+- Works in Node.js and all modern browsers
+- Tiny: `2kb` core bundle (gzipped)
+- Immutable API: methods return a new instance
+- Concise interface
+- Works with TypeScript and plain JS
+- Built-in JSON Schema conversion
+- Extensive ecosystem
+
+<br/>
+
+## Installation
+
+```sh
+npm install zod
+```
+
+<br/>
+
+## Basic usage
+
+Before you can do anything else, you need to define a schema. For the purposes of this guide, we'll use a simple object schema.
+
+```ts
+import * as z from "zod/v4";
+
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+```
+
+### Parsing data
+
+Given any Zod schema, use `.parse` to validate an input. If it's valid, Zod returns a strongly-typed _deep clone_ of the input.
+
+```ts
+Player.parse({ username: "billie", xp: 100 });
+// => returns { username: "billie", xp: 100 }
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.parseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.parseAsync("hello");
+// => "hello"
+```
+
+### Handling errors
+
+When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.
+
+```ts
+try {
+  Player.parse({ username: 42, xp: "100" });
+} catch (err) {
+  if (err instanceof z.ZodError) {
+    err.issues;
+    /* [
+      {
+        expected: 'string',
+        code: 'invalid_type',
+        path: [ 'username' ],
+        message: 'Invalid input: expected string'
+      },
+      {
+        expected: 'number',
+        code: 'invalid_type',
+        path: [ 'xp' ],
+        message: 'Invalid input: expected number'
+      }
+    ] */
+  }
+}
+```
+
+To avoid a `try/catch` block, you can use the `.safeParse()` method to get back a plain result object containing either the successfully parsed data or a `ZodError`. The result type is a [discriminated union](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions), so you can handle both cases conveniently.
+
+```ts
+const result = Player.safeParse({ username: 42, xp: "100" });
+if (!result.success) {
+  result.error; // ZodError instance
+} else {
+  result.data; // { username: string; xp: number }
+}
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.safeParseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.safeParseAsync("hello");
+// => { success: true; data: "hello" }
+```
+
+### Inferring types
+
+Zod infers a static type from your schema definitions. You can extract this type with the `z.infer<>` utility and use it however you like.
+
+```ts
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+
+// extract the inferred type
+type Player = z.infer<typeof Player>;
+
+// use it in your code
+const player: Player = { username: "billie", xp: 100 };
+```
+
+In some cases, the input & output types of a schema can diverge. For instance, the `.transform()` API can convert the input from one type to another. In these cases, you can extract the input and output types independently:
+
+```ts
+const mySchema = z.string().transform((val) => val.length);
+
+type MySchemaIn = z.input<typeof mySchema>;
+// => string
+
+type MySchemaOut = z.output<typeof mySchema>; // equivalent to z.infer<typeof mySchema>
+// number
+```

package/node_modules/zod/index.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = void 0;
+const z = __importStar(require("./v3/external.cjs"));
+exports.z = z;
+__exportStar(require("./v3/external.cjs"), exports);
+exports.default = z;

package/node_modules/zod/index.d.cts

@@ -0,0 +1,4 @@
+import * as z from "./v3/external.cjs";
+export * from "./v3/external.cjs";
+export { z };
+export default z;

package/node_modules/zod/index.d.ts

@@ -0,0 +1,4 @@
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
+export { z };
+export default z;

package/node_modules/zod/index.js

@@ -0,0 +1,4 @@
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
+export { z };
+export default z;