agent-canvas 0.2.0 → 0.6.0

package/daemon/client/shareCrypto.ts

@@ -18,106 +18,106 @@
  *   the marked fields contain ciphertext rather than plaintext.
  */
 
-export const CRYPTO_ALG = "AES-GCM" as const;
-export const CRYPTO_VERSION = 1 as const;
+export const CRYPTO_ALG = 'AES-GCM' as const
+export const CRYPTO_VERSION = 1 as const
 
 export interface EncryptionMeta {
-  alg: typeof CRYPTO_ALG;
-  v: typeof CRYPTO_VERSION;
+	alg: typeof CRYPTO_ALG
+	v: typeof CRYPTO_VERSION
 }
 
-export const ENCRYPTION_META: EncryptionMeta = { alg: CRYPTO_ALG, v: CRYPTO_VERSION };
+export const ENCRYPTION_META: EncryptionMeta = { alg: CRYPTO_ALG, v: CRYPTO_VERSION }
 
 /** Generate a fresh 256-bit AES-GCM key. */
 export async function generateShareKey(): Promise<CryptoKey> {
-  return crypto.subtle.generateKey(
-    { name: CRYPTO_ALG, length: 256 },
-    true,
-    ["encrypt", "decrypt"],
-  );
+	return crypto.subtle.generateKey(
+		{ name: CRYPTO_ALG, length: 256 },
+		true,
+		['encrypt', 'decrypt'],
+	)
 }
 
 /** Export a CryptoKey to a base64url string suitable for URL fragments. */
 export async function exportShareKey(key: CryptoKey): Promise<string> {
-  const raw = await crypto.subtle.exportKey("raw", key);
-  return b64urlFromBytes(new Uint8Array(raw));
+	const raw = await crypto.subtle.exportKey('raw', key)
+	return b64urlFromBytes(new Uint8Array(raw))
 }
 
 /** Import a base64url-encoded key for AES-GCM. */
 export async function importShareKey(encoded: string): Promise<CryptoKey> {
-  const raw = bytesFromB64url(encoded);
-  return crypto.subtle.importKey(
-    "raw",
-    raw as BufferSource,
-    { name: CRYPTO_ALG, length: 256 },
-    false,
-    ["encrypt", "decrypt"],
-  );
+	const raw = bytesFromB64url(encoded)
+	return crypto.subtle.importKey(
+		'raw',
+		raw as BufferSource,
+		{ name: CRYPTO_ALG, length: 256 },
+		false,
+		['encrypt', 'decrypt'],
+	)
 }
 
 /** Encrypt a UTF-8 string. Returns base64(IV || ciphertext+tag). */
 export async function encryptString(key: CryptoKey, plaintext: string): Promise<string> {
-  const iv = crypto.getRandomValues(new Uint8Array(12));
-  const data = new TextEncoder().encode(plaintext);
-  const ct = await crypto.subtle.encrypt(
-    { name: CRYPTO_ALG, iv: iv as BufferSource },
-    key,
-    data as BufferSource,
-  );
-  const combined = new Uint8Array(iv.byteLength + ct.byteLength);
-  combined.set(iv, 0);
-  combined.set(new Uint8Array(ct), iv.byteLength);
-  return b64FromBytes(combined);
+	const iv = crypto.getRandomValues(new Uint8Array(12))
+	const data = new TextEncoder().encode(plaintext)
+	const ct = await crypto.subtle.encrypt(
+		{ name: CRYPTO_ALG, iv: iv as BufferSource },
+		key,
+		data as BufferSource,
+	)
+	const combined = new Uint8Array(iv.byteLength + ct.byteLength)
+	combined.set(iv, 0)
+	combined.set(new Uint8Array(ct), iv.byteLength)
+	return b64FromBytes(combined)
 }
 
 /** Decrypt a base64-encoded ciphertext back to a UTF-8 string. */
 export async function decryptString(key: CryptoKey, ciphertext: string): Promise<string> {
-  const combined = bytesFromB64(ciphertext);
-  if (combined.byteLength < 12 + 16) throw new Error("Ciphertext too short");
-  const iv = combined.subarray(0, 12);
-  const ct = combined.subarray(12);
-  const pt = await crypto.subtle.decrypt(
-    { name: CRYPTO_ALG, iv: iv as BufferSource },
-    key,
-    ct as BufferSource,
-  );
-  return new TextDecoder().decode(pt);
+	const combined = bytesFromB64(ciphertext)
+	if (combined.byteLength < 12 + 16) throw new Error('Ciphertext too short')
+	const iv = combined.subarray(0, 12)
+	const ct = combined.subarray(12)
+	const pt = await crypto.subtle.decrypt(
+		{ name: CRYPTO_ALG, iv: iv as BufferSource },
+		key,
+		ct as BufferSource,
+	)
+	return new TextDecoder().decode(pt)
 }
 
 /** Convenience: encrypt a JSON-serializable value as a single ciphertext blob. */
 export async function encryptJson(key: CryptoKey, value: unknown): Promise<string> {
-  return encryptString(key, JSON.stringify(value));
+	return encryptString(key, JSON.stringify(value))
 }
 
 /** Convenience: decrypt a ciphertext blob into a JSON value. */
 export async function decryptJson<T = unknown>(key: CryptoKey, ciphertext: string): Promise<T> {
-  return JSON.parse(await decryptString(key, ciphertext)) as T;
+	return JSON.parse(await decryptString(key, ciphertext)) as T
 }
 
 // --- base64 helpers ---------------------------------------------------------
 
 function b64FromBytes(bytes: Uint8Array): string {
-  let bin = "";
-  // Chunk to avoid stack overflow on large inputs.
-  const CHUNK = 0x8000;
-  for (let i = 0; i < bytes.byteLength; i += CHUNK) {
-    bin += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK)));
-  }
-  return btoa(bin);
+	let bin = ''
+	// Chunk to avoid stack overflow on large inputs.
+	const CHUNK = 0x8000
+	for (let i = 0; i < bytes.byteLength; i += CHUNK) {
+		bin += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK)))
+	}
+	return btoa(bin)
 }
 
 function bytesFromB64(s: string): Uint8Array {
-  const bin = atob(s);
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  return out;
+	const bin = atob(s)
+	const out = new Uint8Array(bin.length)
+	for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+	return out
 }
 
 function b64urlFromBytes(bytes: Uint8Array): string {
-  return b64FromBytes(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	return b64FromBytes(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 }
 
 function bytesFromB64url(s: string): Uint8Array {
-  const padded = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4);
-  return bytesFromB64(padded);
+	const padded = s.replace(/-/g, '+').replace(/_/g, '/') + '==='.slice((s.length + 3) % 4)
+	return bytesFromB64(padded)
 }