volter 0.0.171 → 0.0.172

package/package.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://json.schemastore.org/package",
 	"name": "volter",
-	"version": "0.0.171",
+	"version": "0.0.172",
 	"description": "Secure, lightweight, and user-friendly modern JavaScript toolchain optimized for performance and minimalism.",
 	"main": "index.ts",
 	"module": "index.ts",
@@ -11,11 +11,13 @@
 	},
 	"exports": {
 		"./*": {
-			"types": "./dist/*.d.ts",
-			"import": "./dist/*.js",
+			"types": "./src/*.d.ts",
+			"import": "./src/*.ts",
 			"default": "./src/*.ts"
 		}
 	},
+	"types": "./src/types.d.ts",
+	"typings": "./src/types.d.ts",
 	"devDependencies": {
 		"typescript": "latest",
 		"@types/bun": "latest"
@@ -23,7 +25,7 @@
 	"peerDependencies": {},
 	"dependencies": {
 		"@paralleldrive/cuid2": "latest",
-		"chalk": "latest",
+		"ansi-colors": "^4.1.3",
 		"drizzle-orm": "latest",
 		"zod": "latest"
 	}

package/src/crypto.d.ts

@@ -0,0 +1,21 @@
+export declare interface CipherText {
+	text: string
+	iv: Uint8Array<ArrayBuffer>
+	buffer: ArrayBuffer
+}
+
+export declare function hash(password: string, hmac?: string): string
+
+export declare function key(raw?: CryptoKey | Uint8Array<ArrayBuffer> | string): Promise<CryptoKey>
+export declare function exportKey(key: CryptoKey, format: "raw" | "spki" | "pkcs8"): Promise<string>
+
+export declare function cipher(text: string, key: CryptoKey | string): Promise<CipherText>
+export declare function decipher(cipher: CipherText, key: CryptoKey | string): Promise<string>
+
+export declare function keypair(): Promise<CryptoKeyPair>
+export declare function encrypt(text: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>>
+export declare function decrypt(text: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<string>
+
+export declare function signature(): Promise<CryptoKeyPair>
+export declare function sign(message: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>>
+export declare function verifySign(message: string, signature: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<boolean>

package/src/crypto.ts

@@ -0,0 +1,151 @@
+export function hash(password: string, hmac?: string): string {
+	const hasher = new Bun.CryptoHasher("sha256", hmac)
+	return hasher.update(password).digest("hex")
+}
+
+export interface CipherText {
+	text: string
+	iv: Uint8Array<ArrayBuffer>
+	buffer: ArrayBuffer
+}
+
+export async function cryptoKey(raw?: CryptoKey | Uint8Array<ArrayBuffer> | string): Promise<CryptoKey> {
+	if (raw) {
+		if (raw instanceof CryptoKey) return raw
+		if (raw instanceof Uint8Array) {
+			if (raw.length === 32) {
+				return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"])
+			}
+			return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"])
+		}
+		if (raw.length === 64) {
+			return await crypto.subtle.importKey(
+				"raw",
+				Uint8Array.fromHex(raw),
+				{
+					name: "AES-GCM",
+					length: 256,
+				},
+				true,
+				["encrypt", "decrypt"],
+			)
+		} else {
+			return await crypto.subtle.importKey(
+				"raw",
+				Uint8Array.fromHex(hash(raw)),
+				{
+					name: "AES-GCM",
+					length: 256,
+				},
+				true,
+				["encrypt", "decrypt"],
+			)
+		}
+	} else {
+		return await crypto.subtle.generateKey(
+			{
+				name: "AES-GCM",
+				length: 256,
+			},
+			true,
+			["encrypt", "decrypt"],
+		)
+	}
+}
+export async function exportKey(key: CryptoKey, format: "raw" | "pkcs8" | "spki") {
+	const buffer = await crypto.subtle.exportKey(format, key)
+	return new Uint8Array(buffer).toBase64()
+}
+
+export async function generateECDSAKeyPair(): Promise<CryptoKeyPair> {
+	return await crypto.subtle.generateKey(
+		{
+			name: "ECDSA",
+			namedCurve: "P-256", // SECG curve
+		},
+		true,
+		["sign", "verify"],
+	)
+}
+
+export async function exportJWK(key: CryptoKey): Promise<JsonWebKey> {
+	return await crypto.subtle.exportKey("jwk", key)
+}
+
+export async function importJWK(jwk: JsonWebKey, usage: KeyUsage[]): Promise<CryptoKey> {
+	return await crypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: "P-256" }, true, usage)
+}
+
+export async function sign(message: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>> {
+	const data = new TextEncoder().encode(message)
+
+	const signature = await crypto.subtle.sign(
+		{
+			name: "ECDSA",
+			hash: { name: "SHA-256" },
+		},
+		key,
+		data,
+	)
+
+	return new Uint8Array(signature)
+}
+export async function verifySign(message: string, signature: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<boolean> {
+	const data = new TextEncoder().encode(message)
+
+	return await crypto.subtle.verify(
+		{
+			name: "ECDSA",
+			hash: { name: "SHA-256" },
+		},
+		key,
+		signature,
+		data,
+	)
+}
+
+export async function cipher(text: string, key: CryptoKey | string): Promise<CipherText> {
+	const encoder = new TextEncoder()
+
+	const data = encoder.encode(text)
+	const iv = crypto.getRandomValues(new Uint8Array(12))
+	const buffer = await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv }, await cryptoKey(key), data)
+
+	return {
+		text: new Uint8Array(buffer).toHex(),
+		iv: iv,
+		buffer: buffer,
+	}
+}
+export async function decipher(cipher: CipherText, key: CryptoKey | string) {
+	const decoder = new TextDecoder()
+
+	const buffer = await crypto.subtle.decrypt({ name: "AES-GCM", iv: cipher.iv }, await cryptoKey(key), Uint8Array.fromHex(cipher.text))
+
+	const data = decoder.decode(buffer)
+
+	return data
+}
+
+export async function keypair(): Promise<CryptoKeyPair> {
+	return await crypto.subtle.generateKey(
+		{
+			name: "RSA-OAEP",
+			modulusLength: 2048,
+			publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 65537
+			hash: { name: "SHA-256" },
+		},
+		true,
+		["encrypt", "decrypt"],
+	)
+}
+export async function encrypt(text: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>> {
+	const data = new TextEncoder().encode(text)
+	const buffer = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, key, data)
+	return new Uint8Array(buffer)
+}
+export async function decrypt(text: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<string> {
+	const buffer = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, key, text)
+	const data = new TextDecoder().decode(buffer)
+	return data
+}

package/src/network.ts

@@ -0,0 +1,34 @@
+import os from "node:os"
+
+interface Adapter {
+	adapter: string
+	networks: Bun.SocketAddress[]
+}
+
+export function listAdapters(): Adapter[] {
+	const interfaces = os.networkInterfaces()
+	const results: Adapter[] = []
+
+	for (const [name, infos] of Object.entries(interfaces)) {
+		if (!infos) continue
+
+		const networks: Bun.SocketAddress[] = []
+
+		for (const info of infos) {
+			if (!info.address) continue
+
+			networks.push({
+				address: info.address,
+				family: info.family,
+				port: 0,
+			})
+		}
+
+		results.push({
+			adapter: name,
+			networks,
+		})
+	}
+
+	return results
+}

package/src/types.d.ts

@@ -0,0 +1,37 @@
+declare module "volter/utils" {
+	export function createPIN(): string
+	export function createID(): string
+
+	export function timestamp(date?: Date): string
+
+	export function log(...message: unknown[]): void
+	export function error(...message: unknown[]): void
+	export function debug(...message: unknown[]): void
+
+	export function input(prompt?: string): string
+
+	export function prettifyRequest(request: Request): string
+}
+
+declare module "volter/crypto" {
+	export interface CipherText {
+		text: string
+		iv: Uint8Array<ArrayBuffer>
+		buffer: ArrayBuffer
+	}
+
+	export function hash(password: string, hmac?: string): string
+
+	export function key(raw?: CryptoKey | Uint8Array<ArrayBuffer> | string): Promise<CryptoKey>
+	export function exportKey(key: CryptoKey, format: "raw" | "spki" | "pkcs8"): Promise<string>
+
+	export function cipher(text: string, key: CryptoKey | string): Promise<CipherText>
+	export function decipher(cipher: CipherText, key: CryptoKey | string): Promise<string>
+
+	export function keypair(): Promise<CryptoKeyPair>
+	export function encrypt(text: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>>
+	export function decrypt(text: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<string>
+
+	export function sign(message: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>>
+	export function verifySign(message: string, signature: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<boolean>
+}

package/src/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function createPIN(): string
+export declare function createID(): string
+
+export declare function timestamp(date?: Date): string
+
+export declare function log(...message: unknown[]): void
+export declare function error(...message: unknown[]): void
+export declare function debug(...message: unknown[]): void
+
+export declare function input(prompt?: string): string
+
+export declare function prettifyRequest(request: Request): string

package/src/utils.ts

@@ -1,44 +1,43 @@
-import { privateDecrypt, publicEncrypt, randomInt } from "node:crypto"
-import os from "node:os"
-import chalk from "chalk"
-import cuid2 from "@paralleldrive/cuid2"
-import { generateKeyPairSync } from "node:crypto"
+import ansi from "ansi-colors"
 import z from "zod"
-import type { SocketAddress } from "node:net"
+import { init } from "@paralleldrive/cuid2"
 
 declare global {
 	interface Request {
-		ip: SocketAddress
+		ip: Bun.SocketAddress
 	}
 }
 
 export const pin = z.string().min(6).max(6).regex(/\d{6}/)
 
-export function createPIN(): string {
-	return randomInt(0, 1000000).toString().padStart(6, "0")
+export function createRandom(length = 32) {
+	const bytes = crypto.getRandomValues(new Uint8Array(length))
+	return bytes
 }
-export const createID = cuid2.init({ length: 32 })
 
-export function hash(password: string): string {
-	const hasher = new Bun.CryptoHasher("sha256")
-	return hasher.update(password).digest("hex")
+export const createID = init({ length: 32 })
+export function createPIN(): string {
+	const array = new Uint32Array(1)
+	crypto.getRandomValues(array)
+	return ((array[0] ?? 0) % 1000000).toString().padStart(6, "0")
 }
 
-export function timestamp(): string
-export function timestamp(date: Date): string
 export function timestamp(date?: Date): string {
 	if (!date) date = new Date()
 	return date.toISOString().slice(0, 19).replace("T", " ")
 }
 
 export function log(...message: unknown[]) {
-	console.log(chalk.gray(timestamp()), ...message)
+	console.log(ansi.gray(timestamp()), ...message)
 }
 export function error(...message: unknown[]) {
-	console.error(chalk.red(timestamp()), ...message)
+	console.error(ansi.red(timestamp()), ...message)
+}
+export function debug(...message: unknown[]) {
+	console.log(ansi.gray(timestamp()), ...message)
 }
 
-export async function input(prompt: string = chalk.black("> ")) {
+export async function input(prompt: string = ansi.black("> ")) {
 	await Bun.stdout.write(prompt)
 	for await (const line of console) {
 		return line
@@ -49,7 +48,7 @@ export type HTTPLog = {
 	timestamp: string
 	method: string
 	url: string
-	IP: string
+	ip: string
 	request_id?: string
 	service?: string
 	level: "info" | "warn" | "error"
@@ -63,7 +62,7 @@ export function formatRequest(req: Request): HTTPLog {
 		timestamp: new Date().toISOString(),
 		method: req.method,
 		url: new URL(req.url).pathname,
-		IP: req.headers.get("x-forwarded-for") ?? "unknown",
+		ip: req.headers.get("x-forwarded-for") ?? "unknown",
 		request_id: req.headers.get("x-request-id") ?? "none",
 		service: "app",
 		level: "info",
@@ -74,75 +73,6 @@ export function formatRequest(req: Request): HTTPLog {
  * Returns a one-line pretty string with colors using chalk
  */
 export function prettifyRequest(req: Request): string {
-	const url = chalk.white(new URL(req.url).pathname)
-	return `${chalk.gray(timestamp())} ${chalk.red(req.ip.address)} ${chalk.green(req.method)} ${url}`
-}
-
-interface Adapter {
-	adapter: string
-	networks: Bun.SocketAddress[]
-}
-
-export function listAdapters(): Adapter[] {
-	const interfaces = os.networkInterfaces()
-	const results: Adapter[] = []
-
-	for (const [name, infos] of Object.entries(interfaces)) {
-		if (!infos) continue
-
-		const networks: Bun.SocketAddress[] = []
-
-		for (const info of infos) {
-			if (!info.address) continue
-
-			networks.push({
-				address: info.address,
-				family: info.family,
-				port: 0,
-			})
-		}
-
-		results.push({
-			adapter: name,
-			networks,
-		})
-	}
-
-	return results
-}
-
-type KeyPair = {
-	public: string
-	private: string
-}
-
-export async function key(): Promise<KeyPair> {
-	const { publicKey, privateKey } = generateKeyPairSync("rsa", {
-		modulusLength: 2048,
-		publicKeyEncoding: {
-			type: "spki",
-			format: "pem",
-		},
-		privateKeyEncoding: {
-			type: "pkcs8",
-			format: "pem",
-		},
-	})
-
-	return {
-		public: publicKey,
-		private: privateKey,
-	}
-}
-
-export function encrypt(key: string, data: string) {
-	const buffer = Buffer.from(data, "utf-8")
-	const encrypted = publicEncrypt(key, buffer)
-	return encrypted.toString("hex")
-}
-
-export function decrypt(key: string, encrypted: string) {
-	const buffer = Buffer.from(encrypted, "hex")
-	const decrypted = privateDecrypt(key, buffer)
-	return decrypted.toString("utf-8")
+	const url = ansi.white(new URL(req.url).pathname)
+	return `${ansi.gray(timestamp())} ${ansi.red(req.ip.address)} ${ansi.green(req.method)} ${url}`
 }

package/tsconfig.json

@@ -1,23 +1,32 @@
 {
-	"$schema": "https://json.schemastore.org/tsconfig",
-	"compilerOptions": {
-		"declaration": true,
-		"declarationMap": true,
-		"esModuleInterop": true,
-		"incremental": false,
-		"isolatedModules": true,
-		"lib": ["es2022", "DOM", "DOM.Iterable"],
-		"module": "NodeNext",
-		"moduleDetection": "force",
-		"moduleResolution": "NodeNext",
-		"noUncheckedIndexedAccess": true,
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"strict": true,
-		"target": "ES2022",
-		"outDir": "dist",
-		"rootDir": "src"
-	},
-	"include": ["src"],
-	"exclude": ["node_modules", "dist"]
+    "$schema": "https://json.schemastore.org/tsconfig",
+    "compilerOptions": {
+        "declaration": true,
+        "declarationMap": true,
+        "esModuleInterop": true,
+        "incremental": false,
+        "isolatedModules": true,
+        "lib": [
+            "ESNext",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "module": "esnext",
+        "moduleDetection": "force",
+        "moduleResolution": "bundler",
+        "noUncheckedIndexedAccess": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "strict": true,
+        "target": "esnext",
+        "outDir": "dist",
+        "rootDir": "src"
+    },
+    "include": [
+        "src"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
 }

package/src/receive.ts

@@ -1,33 +0,0 @@
-export interface Email {
-	from: string
-	to: string[]
-	subject: string
-	bcc?: string[]
-	cc?: string[]
-	scheduled_at?: Date
-	reply_to?: string[]
-	html?: string
-	text?: string
-	tags?: {
-		name: string
-		value: string
-	}[]
-	created_at: Date
-}
-
-export class Receive {
-	constructor(key?: string) {
-		this.key = key
-	}
-	key?: string
-	emails(listener: (email: Email) => void) {
-		const ws = new WebSocket("wss://mail.modlin.dev:84/emails", {
-			headers: {
-				authorization: this.key ? `Basic ${this.key}` : undefined,
-			},
-		})
-		ws.onmessage = ev => listener(JSON.parse(ev.data))
-	}
-}
-
-export default Receive

package/src/session.ts

@@ -1,37 +0,0 @@
-import { getRandomValues, randomBytes } from "node:crypto"
-
-function pad(input: string) {
-	const result: string[] = []
-	for (let i = 0; i < input.length; i++) {
-		result.push(input[i] as string)
-		if ((i + 1) % 4 === 0 && i !== input.length - 1) {
-			result.push("-")
-		}
-	}
-	return result.join("")
-}
-
-export function randomID() {
-	const session = randomBytes(16).toHex()
-
-	return pad(session)
-}
-export function randomPN(): string {
-	const MAX = 100_000_000
-	const LIMIT = Math.floor(0x1_0000_0000 / MAX) * MAX
-	const buf = new Uint32Array(1)
-
-	let v: number
-	while (true) {
-		getRandomValues(buf)
-		v = buf[0] as number
-		if (v < LIMIT) break
-	}
-
-	const padded = (v % MAX).toString().padStart(8, "0")
-	return `${padded.slice(0, 4)} ${padded.slice(4)}`
-}
-
-do {
-	console.log(randomID())
-} while (true)