within-sdk 1.0.0 → 1.0.1

package/dist/thirdparty/ksuid/index.js

@@ -1,201 +1,201 @@
-"use strict";
-import { randomBytes } from "node:crypto";
-import { inspect } from "node:util";
-import { promisify } from "node:util";
-import * as base62 from "./base62.js";
-
-const customInspectSymbol = inspect.custom;
-
-const asyncRandomBytes = promisify(randomBytes);
-
-// KSUID's epoch starts more recently so that the 32-bit number space gives a
-// significantly higher useful lifetime of around 136 years from March 2014.
-// This number (14e11) was picked to be easy to remember.
-const EPOCH_IN_MS = 14e11;
-
-const MAX_TIME_IN_MS = 1e3 * (2 ** 32 - 1) + EPOCH_IN_MS;
-
-// Timestamp is a uint32
-const TIMESTAMP_BYTE_LENGTH = 4;
-
-// Payload is 16-bytes
-const PAYLOAD_BYTE_LENGTH = 16;
-
-// KSUIDs are 20 bytes when binary encoded
-const BYTE_LENGTH = TIMESTAMP_BYTE_LENGTH + PAYLOAD_BYTE_LENGTH;
-
-// The length of a KSUID when string (base62) encoded
-const STRING_ENCODED_LENGTH = 27;
-
-const TIME_IN_MS_ASSERTION =
-  `Valid KSUID timestamps must be in milliseconds since ${new Date(0).toISOString()},
-  no earlier than ${new Date(EPOCH_IN_MS).toISOString()} and no later than ${new Date(MAX_TIME_IN_MS).toISOString()}
-`
-    .trim()
-    .replace(/(\n|\s)+/g, " ")
-    .replace(/\.000Z/g, "Z");
-
-const VALID_ENCODING_ASSERTION = `Valid encoded KSUIDs are ${STRING_ENCODED_LENGTH} characters`;
-
-const VALID_BUFFER_ASSERTION = `Valid KSUID buffers are ${BYTE_LENGTH} bytes`;
-
-const VALID_PAYLOAD_ASSERTION = `Valid KSUID payloads are ${PAYLOAD_BYTE_LENGTH} bytes`;
-
-function fromParts(timeInMs, payload) {
-  const timestamp = Math.floor((timeInMs - EPOCH_IN_MS) / 1e3);
-  const timestampBuffer = Buffer.allocUnsafe(TIMESTAMP_BYTE_LENGTH);
-  timestampBuffer.writeUInt32BE(timestamp, 0);
-
-  return Buffer.concat([timestampBuffer, payload], BYTE_LENGTH);
-}
-
-const bufferLookup = new WeakMap();
-
-class KSUID {
-  constructor(buffer) {
-    if (!KSUID.isValid(buffer)) {
-      throw new TypeError(VALID_BUFFER_ASSERTION);
-    }
-
-    bufferLookup.set(this, buffer);
-    Object.defineProperty(this, "buffer", {
-      enumerable: true,
-      get() {
-        return Buffer.from(buffer);
-      },
-    });
-  }
-
-  get raw() {
-    return Buffer.from(bufferLookup.get(this).slice(0));
-  }
-
-  get date() {
-    return new Date(1e3 * this.timestamp + EPOCH_IN_MS);
-  }
-
-  get timestamp() {
-    return bufferLookup.get(this).readUInt32BE(0);
-  }
-
-  get payload() {
-    const payload = bufferLookup
-      .get(this)
-      .slice(TIMESTAMP_BYTE_LENGTH, BYTE_LENGTH);
-    return Buffer.from(payload);
-  }
-
-  get string() {
-    const encoded = base62.encode(
-      bufferLookup.get(this),
-      STRING_ENCODED_LENGTH,
-    );
-    return encoded.padStart(STRING_ENCODED_LENGTH, "0");
-  }
-
-  compare(other) {
-    if (!bufferLookup.has(other)) {
-      return 0;
-    }
-
-    return bufferLookup
-      .get(this)
-      .compare(bufferLookup.get(other), 0, BYTE_LENGTH);
-  }
-
-  equals(other) {
-    return (
-      this === other || (bufferLookup.has(other) && this.compare(other) === 0)
-    );
-  }
-
-  toString() {
-    return `${this[Symbol.toStringTag]} { ${this.string} }`;
-  }
-
-  toJSON() {
-    return this.string;
-  }
-
-  [customInspectSymbol]() {
-    return this.toString();
-  }
-
-  static async random(time = Date.now()) {
-    const payload = await asyncRandomBytes(PAYLOAD_BYTE_LENGTH);
-    return new KSUID(fromParts(Number(time), payload));
-  }
-
-  static randomSync(time = Date.now()) {
-    const payload = randomBytes(PAYLOAD_BYTE_LENGTH);
-    return new KSUID(fromParts(Number(time), payload));
-  }
-
-  static fromParts(timeInMs, payload) {
-    if (
-      !Number.isInteger(timeInMs) ||
-      timeInMs < EPOCH_IN_MS ||
-      timeInMs > MAX_TIME_IN_MS
-    ) {
-      throw new TypeError(TIME_IN_MS_ASSERTION);
-    }
-    if (
-      !Buffer.isBuffer(payload) ||
-      payload.byteLength !== PAYLOAD_BYTE_LENGTH
-    ) {
-      throw new TypeError(VALID_PAYLOAD_ASSERTION);
-    }
-
-    return new KSUID(fromParts(timeInMs, payload));
-  }
-
-  static isValid(buffer) {
-    return Buffer.isBuffer(buffer) && buffer.byteLength === BYTE_LENGTH;
-  }
-
-  static parse(string) {
-    if (string.length !== STRING_ENCODED_LENGTH) {
-      throw new TypeError(VALID_ENCODING_ASSERTION);
-    }
-
-    const decoded = base62.decode(string, BYTE_LENGTH);
-    if (decoded.byteLength === BYTE_LENGTH) {
-      return new KSUID(decoded);
-    }
-
-    const buffer = Buffer.allocUnsafe(BYTE_LENGTH);
-    const padEnd = BYTE_LENGTH - decoded.byteLength;
-    buffer.fill(0, 0, padEnd);
-    decoded.copy(buffer, padEnd);
-    return new KSUID(buffer);
-  }
-}
-Object.defineProperty(KSUID.prototype, Symbol.toStringTag, { value: "KSUID" });
-// A string-encoded maximum value for a KSUID
-Object.defineProperty(KSUID, "MAX_STRING_ENCODED", {
-  value: "aWgEPTl1tmebfsQzFP4bxwgy80V",
-});
-// A string-encoded minimum value for a KSUID
-Object.defineProperty(KSUID, "MIN_STRING_ENCODED", {
-  value: "000000000000000000000000000",
-});
-
-// Add prefix functionality
-KSUID.withPrefix = function (prefix) {
-  return {
-    random: async (time = Date.now()) => {
-      const ksuid = await KSUID.random(time);
-      return `${prefix}_${ksuid.string}`;
-    },
-    randomSync: (time = Date.now()) => {
-      const ksuid = KSUID.randomSync(time);
-      return `${prefix}_${ksuid.string}`;
-    },
-    fromParts: (timeInMs, payload) => {
-      const ksuid = KSUID.fromParts(timeInMs, payload);
-      return `${prefix}_${ksuid.string}`;
-    },
-  };
-};
-
-export default KSUID;
+"use strict";
+import { randomBytes } from "node:crypto";
+import { inspect } from "node:util";
+import { promisify } from "node:util";
+import * as base62 from "./base62.js";
+
+const customInspectSymbol = inspect.custom;
+
+const asyncRandomBytes = promisify(randomBytes);
+
+// KSUID's epoch starts more recently so that the 32-bit number space gives a
+// significantly higher useful lifetime of around 136 years from March 2014.
+// This number (14e11) was picked to be easy to remember.
+const EPOCH_IN_MS = 14e11;
+
+const MAX_TIME_IN_MS = 1e3 * (2 ** 32 - 1) + EPOCH_IN_MS;
+
+// Timestamp is a uint32
+const TIMESTAMP_BYTE_LENGTH = 4;
+
+// Payload is 16-bytes
+const PAYLOAD_BYTE_LENGTH = 16;
+
+// KSUIDs are 20 bytes when binary encoded
+const BYTE_LENGTH = TIMESTAMP_BYTE_LENGTH + PAYLOAD_BYTE_LENGTH;
+
+// The length of a KSUID when string (base62) encoded
+const STRING_ENCODED_LENGTH = 27;
+
+const TIME_IN_MS_ASSERTION =
+  `Valid KSUID timestamps must be in milliseconds since ${new Date(0).toISOString()},
+  no earlier than ${new Date(EPOCH_IN_MS).toISOString()} and no later than ${new Date(MAX_TIME_IN_MS).toISOString()}
+`
+    .trim()
+    .replace(/(\n|\s)+/g, " ")
+    .replace(/\.000Z/g, "Z");
+
+const VALID_ENCODING_ASSERTION = `Valid encoded KSUIDs are ${STRING_ENCODED_LENGTH} characters`;
+
+const VALID_BUFFER_ASSERTION = `Valid KSUID buffers are ${BYTE_LENGTH} bytes`;
+
+const VALID_PAYLOAD_ASSERTION = `Valid KSUID payloads are ${PAYLOAD_BYTE_LENGTH} bytes`;
+
+function fromParts(timeInMs, payload) {
+  const timestamp = Math.floor((timeInMs - EPOCH_IN_MS) / 1e3);
+  const timestampBuffer = Buffer.allocUnsafe(TIMESTAMP_BYTE_LENGTH);
+  timestampBuffer.writeUInt32BE(timestamp, 0);
+
+  return Buffer.concat([timestampBuffer, payload], BYTE_LENGTH);
+}
+
+const bufferLookup = new WeakMap();
+
+class KSUID {
+  constructor(buffer) {
+    if (!KSUID.isValid(buffer)) {
+      throw new TypeError(VALID_BUFFER_ASSERTION);
+    }
+
+    bufferLookup.set(this, buffer);
+    Object.defineProperty(this, "buffer", {
+      enumerable: true,
+      get() {
+        return Buffer.from(buffer);
+      },
+    });
+  }
+
+  get raw() {
+    return Buffer.from(bufferLookup.get(this).slice(0));
+  }
+
+  get date() {
+    return new Date(1e3 * this.timestamp + EPOCH_IN_MS);
+  }
+
+  get timestamp() {
+    return bufferLookup.get(this).readUInt32BE(0);
+  }
+
+  get payload() {
+    const payload = bufferLookup
+      .get(this)
+      .slice(TIMESTAMP_BYTE_LENGTH, BYTE_LENGTH);
+    return Buffer.from(payload);
+  }
+
+  get string() {
+    const encoded = base62.encode(
+      bufferLookup.get(this),
+      STRING_ENCODED_LENGTH,
+    );
+    return encoded.padStart(STRING_ENCODED_LENGTH, "0");
+  }
+
+  compare(other) {
+    if (!bufferLookup.has(other)) {
+      return 0;
+    }
+
+    return bufferLookup
+      .get(this)
+      .compare(bufferLookup.get(other), 0, BYTE_LENGTH);
+  }
+
+  equals(other) {
+    return (
+      this === other || (bufferLookup.has(other) && this.compare(other) === 0)
+    );
+  }
+
+  toString() {
+    return `${this[Symbol.toStringTag]} { ${this.string} }`;
+  }
+
+  toJSON() {
+    return this.string;
+  }
+
+  [customInspectSymbol]() {
+    return this.toString();
+  }
+
+  static async random(time = Date.now()) {
+    const payload = await asyncRandomBytes(PAYLOAD_BYTE_LENGTH);
+    return new KSUID(fromParts(Number(time), payload));
+  }
+
+  static randomSync(time = Date.now()) {
+    const payload = randomBytes(PAYLOAD_BYTE_LENGTH);
+    return new KSUID(fromParts(Number(time), payload));
+  }
+
+  static fromParts(timeInMs, payload) {
+    if (
+      !Number.isInteger(timeInMs) ||
+      timeInMs < EPOCH_IN_MS ||
+      timeInMs > MAX_TIME_IN_MS
+    ) {
+      throw new TypeError(TIME_IN_MS_ASSERTION);
+    }
+    if (
+      !Buffer.isBuffer(payload) ||
+      payload.byteLength !== PAYLOAD_BYTE_LENGTH
+    ) {
+      throw new TypeError(VALID_PAYLOAD_ASSERTION);
+    }
+
+    return new KSUID(fromParts(timeInMs, payload));
+  }
+
+  static isValid(buffer) {
+    return Buffer.isBuffer(buffer) && buffer.byteLength === BYTE_LENGTH;
+  }
+
+  static parse(string) {
+    if (string.length !== STRING_ENCODED_LENGTH) {
+      throw new TypeError(VALID_ENCODING_ASSERTION);
+    }
+
+    const decoded = base62.decode(string, BYTE_LENGTH);
+    if (decoded.byteLength === BYTE_LENGTH) {
+      return new KSUID(decoded);
+    }
+
+    const buffer = Buffer.allocUnsafe(BYTE_LENGTH);
+    const padEnd = BYTE_LENGTH - decoded.byteLength;
+    buffer.fill(0, 0, padEnd);
+    decoded.copy(buffer, padEnd);
+    return new KSUID(buffer);
+  }
+}
+Object.defineProperty(KSUID.prototype, Symbol.toStringTag, { value: "KSUID" });
+// A string-encoded maximum value for a KSUID
+Object.defineProperty(KSUID, "MAX_STRING_ENCODED", {
+  value: "aWgEPTl1tmebfsQzFP4bxwgy80V",
+});
+// A string-encoded minimum value for a KSUID
+Object.defineProperty(KSUID, "MIN_STRING_ENCODED", {
+  value: "000000000000000000000000000",
+});
+
+// Add prefix functionality
+KSUID.withPrefix = function (prefix) {
+  return {
+    random: async (time = Date.now()) => {
+      const ksuid = await KSUID.random(time);
+      return `${prefix}_${ksuid.string}`;
+    },
+    randomSync: (time = Date.now()) => {
+      const ksuid = KSUID.randomSync(time);
+      return `${prefix}_${ksuid.string}`;
+    },
+    fromParts: (timeInMs, payload) => {
+      const ksuid = KSUID.fromParts(timeInMs, payload);
+      return `${prefix}_${ksuid.string}`;
+    },
+  };
+};
+
+export default KSUID;

package/package.json

@@ -1,43 +1,43 @@
-{
-  "name": "within-sdk",
-  "version": "1.0.0",
-  "description": "Within SDK for MCP analytics, workflow intelligence, and qualified opportunities.",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "within",
-    "sdk",
-    "workflow",
-    "qualification"
-  ],
-  "license": "MIT",
-  "homepage": "https://getwith.in",
-  "scripts": {
-    "build": "tsc -p tsconfig.json && rm -rf dist/thirdparty && cp -R src/thirdparty dist/thirdparty",
-    "prepublishOnly": "npm run build",
-    "test": "tsx --test src/*.test.ts"
-  },
-  "peerDependencies": {
-    "@modelcontextprotocol/sdk": ">=1.11"
-  },
-  "devDependencies": {
-    "@modelcontextprotocol/sdk": "~1.24.2",
-    "@types/node": "^25.5.0",
-    "tsx": "^4.21.0",
-    "typescript": "^6.0.2"
-  }
-}
+{
+  "name": "within-sdk",
+  "version": "1.0.1",
+  "description": "Within SDK for MCP analytics, workflow intelligence, and qualified opportunities.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "within",
+    "sdk",
+    "workflow",
+    "qualification"
+  ],
+  "license": "MIT",
+  "homepage": "https://getwith.in",
+  "scripts": {
+    "build": "tsc -p tsconfig.json && rm -rf dist/thirdparty && cp -R src/thirdparty dist/thirdparty",
+    "prepublishOnly": "npm run build",
+    "test": "tsx --test src/*.test.ts"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": ">=1.11"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "~1.24.2",
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  }
+}

package/dist/middleware.d.ts

@@ -1,40 +0,0 @@
-/**
- * With.in MCP Auth SDK — sealed request handler.
- *
- * Exposes ONE function, `createWithinHandler`, that returns a handler with:
- *   - `mcpHandler(req, res)`   — node HTTP handler for the MCP endpoint
- *   - `subscribeHandler(req,res)` — node HTTP handler for the /subscribe route
- *   - `vendorSlug`, `authServerUrl` — readonly fields for logging
- *
- * Everything else — token validation, tool-call reporting, trial-exhausted
- * gating, subscriber cross-check + auto conversion, transport construction
- * and session caching, network-tool injection, auth propagation into tool
- * handlers — is hidden inside `mcpHandler`. Vendors cannot accidentally
- * skip a step.
- */
-export interface WithinRequestLike {
-    url?: string;
-    method?: string;
-    headers: Record<string, string | string[] | undefined>;
-    on(event: 'data', listener: (chunk: any) => void): unknown;
-    on(event: 'end', listener: () => void): unknown;
-}
-export interface WithinResponseLike {
-    writeHead(status: number, headers?: Record<string, string>): unknown;
-    write(chunk: any): unknown;
-    end(body?: string): unknown;
-}
-import type { WithinConfig } from './types.js';
-export interface WithinHandler {
-    mcpHandler: (req: WithinRequestLike, res: WithinResponseLike) => Promise<void>;
-    subscribeHandler: (req: WithinRequestLike, res: WithinResponseLike) => Promise<void>;
-    /** Serves RFC 9728 Protected Resource Metadata at the vendor's well-known
-     *  path. Derives `resource` from the incoming Host + X-Forwarded-Proto so
-     *  the byte-equality check in §3.3 passes no matter what hostname the
-     *  vendor runs under. Vendors route GET /.well-known/oauth-protected-resource
-     *  through this handler instead of hand-rolling their own JSON. */
-    prmHandler: (req: WithinRequestLike, res: WithinResponseLike) => void;
-    readonly vendorSlug: string;
-    readonly authServerUrl: string;
-}
-export declare function createWithinHandler(config: WithinConfig): WithinHandler;