@guren/server 1.0.0-rc.9 → 1.1.0

package/dist/chunk-QH4NUKSV.js

@@ -0,0 +1,255 @@
+// src/http/dev-banner.ts
+import chalk from "chalk";
+import figlet from "figlet";
+import standard from "figlet/importable-fonts/Standard.js";
+
+// package.json
+var package_default = {
+  name: "@guren/server",
+  version: "1.1.0",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/gurenjs/guren",
+    directory: "packages/server"
+  },
+  homepage: "https://github.com/gurenjs/guren#readme",
+  bugs: {
+    url: "https://github.com/gurenjs/guren/issues"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist"
+  ],
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./auth": {
+      types: "./dist/auth/index.d.ts",
+      default: "./dist/auth/index.js"
+    },
+    "./authorization": {
+      types: "./dist/authorization/index.d.ts",
+      default: "./dist/authorization/index.js"
+    },
+    "./broadcasting": {
+      types: "./dist/broadcasting/index.d.ts",
+      default: "./dist/broadcasting/index.js"
+    },
+    "./cache": {
+      types: "./dist/cache/index.d.ts",
+      default: "./dist/cache/index.js"
+    },
+    "./encryption": {
+      types: "./dist/encryption/index.d.ts",
+      default: "./dist/encryption/index.js"
+    },
+    "./events": {
+      types: "./dist/events/index.d.ts",
+      default: "./dist/events/index.js"
+    },
+    "./health": {
+      types: "./dist/health/index.d.ts",
+      default: "./dist/health/index.js"
+    },
+    "./i18n": {
+      types: "./dist/i18n/index.d.ts",
+      default: "./dist/i18n/index.js"
+    },
+    "./logging": {
+      types: "./dist/logging/index.d.ts",
+      default: "./dist/logging/index.js"
+    },
+    "./mail": {
+      types: "./dist/mail/index.d.ts",
+      default: "./dist/mail/index.js"
+    },
+    "./notifications": {
+      types: "./dist/notifications/index.d.ts",
+      default: "./dist/notifications/index.js"
+    },
+    "./queue": {
+      types: "./dist/queue/index.d.ts",
+      default: "./dist/queue/index.js"
+    },
+    "./runtime": {
+      types: "./dist/runtime/index.d.ts",
+      default: "./dist/runtime/index.js"
+    },
+    "./scheduling": {
+      types: "./dist/scheduling/index.d.ts",
+      default: "./dist/scheduling/index.js"
+    },
+    "./storage": {
+      types: "./dist/storage/index.d.ts",
+      default: "./dist/storage/index.js"
+    },
+    "./vite": {
+      types: "./dist/vite/index.d.ts",
+      default: "./dist/vite/index.js"
+    },
+    "./mcp": {
+      types: "./dist/mcp/index.d.ts",
+      default: "./dist/mcp/index.js"
+    },
+    "./lambda": {
+      types: "./dist/lambda/index.d.ts",
+      default: "./dist/lambda/index.js"
+    },
+    "./redis": {
+      types: "./dist/redis/index.d.ts",
+      default: "./dist/redis/index.js"
+    }
+  },
+  scripts: {
+    build: "NODE_OPTIONS='--max-old-space-size=8192' tsup",
+    dev: "bun --watch src/index.ts",
+    typecheck: "tsc --noEmit",
+    test: "bun test"
+  },
+  dependencies: {
+    "@guren/orm": "^1.0.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    chalk: "^5.3.0",
+    consola: "^3.4.2",
+    figlet: "^1.7.0",
+    hono: "^4.12.29",
+    ioredis: "^5.11.1",
+    nodemailer: "^9.0.1"
+  },
+  peerDependencies: {
+    "@aws-sdk/client-s3": "^3.0.0",
+    "@aws-sdk/client-sqs": "^3.0.0",
+    "@aws-sdk/s3-request-presigner": "^3.0.0",
+    vite: ">=7.0.0",
+    "@guren/inertia-client": "^1.0.0"
+  },
+  peerDependenciesMeta: {
+    "@aws-sdk/client-s3": {
+      optional: true
+    },
+    "@aws-sdk/client-sqs": {
+      optional: true
+    },
+    "@aws-sdk/s3-request-presigner": {
+      optional: true
+    },
+    "@guren/inertia-client": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@types/ioredis": "^5.0.0",
+    "@types/node": "^20.14.10",
+    "@types/nodemailer": "^8.0.1",
+    tsup: "^8.5.0",
+    typescript: "^5.4.0",
+    vite: "^8.0.0"
+  }
+};
+
+// src/http/dev-banner.ts
+figlet.parseFont("Standard", standard);
+function generateAsciiArt(text) {
+  try {
+    const rendered = figlet.textSync(text, {
+      font: "Standard",
+      horizontalLayout: "default",
+      verticalLayout: "default"
+    });
+    return rendered;
+  } catch (error) {
+    console.error("Failed to generate FIGlet banner, falling back to plain text:", error);
+    return text.toUpperCase();
+  }
+}
+var GUREN_ASCII_ART = chalk.redBright.bold(generateAsciiArt("GUREN"));
+var GUREN_VERSION = package_default.version;
+function logDevServerBanner({
+  hostname,
+  port,
+  assetsUrl = "http://localhost:5173"
+}) {
+  const localUrl = `http://localhost:${port}`;
+  const boundUrl = `http://${hostname}:${port}`;
+  const boundLabel = hostname === "0.0.0.0" || hostname === "::" ? " (all interfaces)" : "";
+  const header = [
+    GUREN_ASCII_ART,
+    chalk.magentaBright.bold(
+      `Guren v${GUREN_VERSION} ignites \u2014 burning bright like a crimson lotus.`
+    ),
+    ""
+  ];
+  const detail = (label, value) => `${chalk.magentaBright("   \u2022")} ${chalk.bold(label.padEnd(14))}: ${chalk.cyanBright(value)}`;
+  const banner = [
+    ...header,
+    detail("App URL", localUrl),
+    detail("Bound address", `${boundUrl}${boundLabel}`),
+    detail("Asset server", `${assetsUrl} (Vite)`),
+    "",
+    chalk.yellowBright("Press Ctrl+C to douse the flames."),
+    ""
+  ].join("\n");
+  console.log(banner);
+}
+
+// src/http/vite-dev-server.ts
+async function startViteDevServer(options = {}) {
+  const { root = process.cwd(), config = {}, host = true, port } = options;
+  const { createServer } = await import("vite");
+  const mergedConfig = {
+    clearScreen: false,
+    ...config,
+    root: config.root ?? root,
+    server: {
+      host,
+      port,
+      ...config.server ?? {}
+    }
+  };
+  const server = await createServer(mergedConfig);
+  await server.listen();
+  const resolved = server.resolvedUrls;
+  const localUrls = resolved?.local?.length ? resolved.local : [`http://${typeof host === "string" ? host : "localhost"}:${server.config.server.port ?? port ?? 5173}`];
+  const networkUrls = resolved?.network ?? [];
+  return {
+    server,
+    localUrl: localUrls[0],
+    networkUrls
+  };
+}
+
+// src/support/import-map.ts
+function parseImportMap(value, options = {}) {
+  if (!value) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(value);
+    const result = {};
+    for (const [key, entry] of Object.entries(parsed)) {
+      if (typeof entry === "string" && entry.length > 0) {
+        result[key] = entry;
+      }
+    }
+    return result;
+  } catch (error) {
+    const label = options.context ?? "import map";
+    console.warn(`Failed to parse ${label}. Expected JSON object.`, error);
+    return {};
+  }
+}
+
+export {
+  parseImportMap,
+  GUREN_ASCII_ART,
+  logDevServerBanner,
+  startViteDevServer
+};

package/dist/chunk-QQKTH5KX.js

@@ -0,0 +1,114 @@
+// src/encryption/Hash.ts
+import {
+  createHash,
+  createHmac,
+  randomBytes,
+  scrypt,
+  timingSafeEqual
+} from "crypto";
+import { promisify } from "util";
+var scryptAsync = promisify(scrypt);
+function hash(value, algorithm = "sha256", encoding = "hex") {
+  return createHash(algorithm).update(value).digest(encoding);
+}
+function hmac(value, key, options = {}) {
+  const { algorithm = "sha256", encoding = "hex" } = options;
+  return createHmac(algorithm, key).update(value).digest(encoding);
+}
+function verifyHmac(value, signature, key, options = {}) {
+  const expected = hmac(value, key, options);
+  return secureCompare(signature, expected);
+}
+function sha256(value) {
+  return hash(value, "sha256");
+}
+function sha512(value) {
+  return hash(value, "sha512");
+}
+function md5(value) {
+  return hash(value, "md5");
+}
+async function hashPassword(password, options = {}) {
+  const {
+    cost = 16384,
+    // N
+    memory = 8,
+    // r (block size)
+    saltLength = 16,
+    keyLength = 64
+  } = options;
+  const salt = randomBytes(saltLength);
+  const derived = await scryptAsync(password, salt, keyLength, {
+    N: cost,
+    r: memory,
+    p: 1
+  });
+  const params = `N=${cost},r=${memory},p=1`;
+  return `$scrypt$${params}$${salt.toString("base64")}$${derived.toString("base64")}`;
+}
+async function verifyPassword(password, hash2) {
+  if (!hash2.startsWith("$scrypt$")) {
+    throw new Error("Invalid password hash format.");
+  }
+  const parts = hash2.split("$");
+  if (parts.length !== 5) {
+    throw new Error("Invalid password hash format.");
+  }
+  const [, , paramsStr, saltB64, hashB64] = parts;
+  const params = {};
+  for (const param of paramsStr.split(",")) {
+    const [key, value] = param.split("=");
+    params[key] = parseInt(value, 10);
+  }
+  const salt = Buffer.from(saltB64, "base64");
+  const expectedHash = Buffer.from(hashB64, "base64");
+  const derived = await scryptAsync(password, salt, expectedHash.length, {
+    N: params.N,
+    r: params.r,
+    p: params.p ?? 1
+  });
+  return timingSafeEqual(derived, expectedHash);
+}
+function needsRehash(hash2, options = {}) {
+  const { cost = 16384, memory = 8 } = options;
+  if (!hash2.startsWith("$scrypt$")) {
+    return true;
+  }
+  const parts = hash2.split("$");
+  if (parts.length !== 5) {
+    return true;
+  }
+  const paramsStr = parts[2];
+  const params = {};
+  for (const param of paramsStr.split(",")) {
+    const [key, value] = param.split("=");
+    params[key] = parseInt(value, 10);
+  }
+  return params.N !== cost || params.r !== memory;
+}
+function secureCompare(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  return timingSafeEqual(bufA, bufB);
+}
+function check(value, hash2, algorithm = "sha256") {
+  const computed = createHash(algorithm).update(value).digest("hex");
+  return secureCompare(computed, hash2);
+}
+
+export {
+  hash,
+  hmac,
+  verifyHmac,
+  sha256,
+  sha512,
+  md5,
+  hashPassword,
+  verifyPassword,
+  needsRehash,
+  secureCompare,
+  check
+};