agent-canvas 0.2.1 → 0.6.0

package/daemon/client/clientApi.ts

@@ -21,182 +21,170 @@
  * work in cleartext.
  */
 
-import {
-  importShareKey,
-  encryptString,
-  decryptString,
-  ENCRYPTION_META,
-  type EncryptionMeta,
-} from "./shareCrypto";
-import type { CanvasHost } from "@fabrika/canvas-kernel/client";
+import type { CanvasHost } from '@fabrika/canvas-kernel/client'
+import { type SessionMeta, sessionMetaSchema } from './apiSchemas'
+import { decryptString, ENCRYPTION_META, type EncryptionMeta, encryptString, importShareKey } from './shareCrypto'
 
 declare global {
-  interface Window {
-    __CANVAS_SHARE__?: {
-      shareId: string;
-      mode: "shared";
-    };
-  }
+	interface Window {
+		__CANVAS_SHARE__?: {
+			shareId: string
+			mode: 'shared'
+		}
+	}
 }
 
 export interface SharedModeInfo {
-  isShared: true;
-  shareId: string;
-  /** Lazy-imported AES-GCM key parsed from the URL fragment, if any. */
-  encryptionKey: Promise<CryptoKey> | null;
+	isShared: true
+	shareId: string
+	/** Lazy-imported AES-GCM key parsed from the URL fragment, if any. */
+	encryptionKey: Promise<CryptoKey> | null
 }
 
 export interface LocalModeInfo {
-  isShared: false;
-  sessionId: string;
+	isShared: false
+	sessionId: string
 }
 
-export type ModeInfo = SharedModeInfo | LocalModeInfo;
+export type ModeInfo = SharedModeInfo | LocalModeInfo
 
 /** Strip the `#k=...` fragment and parse out the key (base64url). */
 function readFragmentKey(): string | null {
-  if (typeof window === "undefined") return null;
-  const hash = window.location.hash.replace(/^#/, "");
-  if (!hash) return null;
-  for (const part of hash.split("&")) {
-    const [k, v] = part.split("=");
-    if (k === "k" && v) return decodeURIComponent(v);
-  }
-  return null;
+	if (typeof window === 'undefined') return null
+	const hash = window.location.hash.replace(/^#/, '')
+	if (!hash) return null
+	for (const part of hash.split('&')) {
+		const [k, v] = part.split('=')
+		if (k === 'k' && v) return decodeURIComponent(v)
+	}
+	return null
 }
 
 /** One-time detection. In shared mode the daemon-provided sessionId from
  *  the URL path is ignored in favor of the worker-injected shareId. */
 export function detectMode(): ModeInfo {
-  if (typeof window !== "undefined" && window.__CANVAS_SHARE__?.shareId) {
-    const encoded = readFragmentKey();
-    return {
-      isShared: true,
-      shareId: window.__CANVAS_SHARE__.shareId,
-      encryptionKey: encoded ? importShareKey(encoded) : null,
-    };
-  }
-  // Local: session id is the path suffix /s/:sessionId
-  const sessionId = typeof window !== "undefined"
-    ? window.location.pathname.replace("/s/", "")
-    : "";
-  return { isShared: false, sessionId };
+	if (typeof window !== 'undefined' && window.__CANVAS_SHARE__?.shareId) {
+		const encoded = readFragmentKey()
+		return {
+			isShared: true,
+			shareId: window.__CANVAS_SHARE__.shareId,
+			encryptionKey: encoded ? importShareKey(encoded) : null,
+		}
+	}
+	// Local: session id is the path suffix /s/:sessionId
+	const sessionId = typeof window !== 'undefined'
+		? window.location.pathname.replace('/s/', '')
+		: ''
+	return { isShared: false, sessionId }
 }
 
-export const MODE: ModeInfo = detectMode();
+export const MODE: ModeInfo = detectMode()
 
 /** True iff we're in a shared canvas AND have a fragment key. */
 export function isEncryptedShare(): boolean {
-  return MODE.isShared && MODE.encryptionKey !== null;
+	return MODE.isShared && MODE.encryptionKey !== null
 }
 
 /** Build a canonical id-ish string used as React keys / identifiers. */
 export function getIdentifier(): string {
-  return MODE.isShared ? MODE.shareId : MODE.sessionId;
+	return MODE.isShared ? MODE.shareId : MODE.sessionId
 }
 
 // --- URL builders -----------------------------------------------------------
 
 /** Metadata endpoint (revisions, canvas files, project root). */
 export function metaUrl(): string {
-  if (MODE.isShared) return `/s/${MODE.shareId}/meta`;
-  return `/api/session/${MODE.sessionId}/meta`;
+	if (MODE.isShared) return `/s/${MODE.shareId}/meta`
+	return `/api/session/${MODE.sessionId}/meta`
 }
 
 /** Compiled canvas JS module for a given filename (+ optional revision). */
 export function canvasJsUrl(filename: string, revision?: number): string {
-  const jsName = filename.replace(/\.jsx$/, ".js");
-  if (MODE.isShared) {
-    return `/s/${MODE.shareId}/canvas/${encodeURIComponent(jsName)}`;
-  }
-  const rev = revision ? `?rev=${revision}&t=${Date.now()}` : `?t=${Date.now()}`;
-  return `/api/session/${MODE.sessionId}/canvas/${encodeURIComponent(jsName)}${rev}`;
+	const jsName = filename.replace(/\.jsx$/, '.js')
+	if (MODE.isShared) {
+		return `/s/${MODE.shareId}/canvas/${encodeURIComponent(jsName)}`
+	}
+	const rev = revision ? `?rev=${revision}&t=${Date.now()}` : `?t=${Date.now()}`
+	return `/api/session/${MODE.sessionId}/canvas/${encodeURIComponent(jsName)}${rev}`
 }
 
 /** Upload endpoint for annotation images. */
 export function uploadUrl(): string {
-  if (MODE.isShared) return `/s/${MODE.shareId}/upload`;
-  return `/api/session/${MODE.sessionId}/upload`;
+	if (MODE.isShared) return `/s/${MODE.shareId}/upload`
+	return `/api/session/${MODE.sessionId}/upload`
 }
 
-function localSecretUrl(fieldId: string, suffix: "status" | "value"): string {
-  if (MODE.isShared) throw new Error("Secret inputs are available only on the local canvas daemon");
-  return `/api/session/${encodeURIComponent(MODE.sessionId)}/secrets/${encodeURIComponent(fieldId)}/${suffix}`;
+function localSecretUrl(fieldId: string, suffix: 'status' | 'value'): string {
+	if (MODE.isShared) throw new Error('Secret inputs are available only on the local canvas daemon')
+	return `/api/session/${encodeURIComponent(MODE.sessionId)}/secrets/${encodeURIComponent(fieldId)}/${suffix}`
 }
 
 async function secretApiError(response: Response): Promise<Error> {
-  const raw: unknown = await response.json().catch(() => null);
-  if (typeof raw === "object" && raw !== null && "error" in raw && typeof raw.error === "string") {
-    return new Error(raw.error);
-  }
-  return new Error(`Secret API request failed with status ${response.status}`);
+	const raw: unknown = await response.json().catch(() => null)
+	if (typeof raw === 'object' && raw !== null && 'error' in raw && typeof raw.error === 'string') {
+		return new Error(raw.error)
+	}
+	return new Error(`Secret API request failed with status ${response.status}`)
 }
 
 /** Return only readiness metadata. The secret value is never sent back to the browser. */
 export async function getLocalSecretStatus(fieldId: string): Promise<boolean> {
-  const response = await fetch(localSecretUrl(fieldId, "status"), { cache: "no-store" });
-  if (!response.ok) throw await secretApiError(response);
-  const raw: unknown = await response.json();
-  return typeof raw === "object" && raw !== null && "ready" in raw && raw.ready === true;
+	const response = await fetch(localSecretUrl(fieldId, 'status'), { cache: 'no-store' })
+	if (!response.ok) throw await secretApiError(response)
+	const raw: unknown = await response.json()
+	return typeof raw === 'object' && raw !== null && 'ready' in raw && raw.ready === true
 }
 
 /** Deposit a secret into the daemon's in-memory vault. */
 export async function storeLocalSecret(fieldId: string, value: string): Promise<void> {
-  const response = await fetch(localSecretUrl(fieldId, "value"), {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    cache: "no-store",
-    body: JSON.stringify({ value }),
-  });
-  if (!response.ok) throw await secretApiError(response);
+	const response = await fetch(localSecretUrl(fieldId, 'value'), {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		cache: 'no-store',
+		body: JSON.stringify({ value }),
+	})
+	if (!response.ok) throw await secretApiError(response)
 }
 
 /** Remove a deposited secret without retrieving its value. */
 export async function clearLocalSecret(fieldId: string): Promise<void> {
-  const response = await fetch(localSecretUrl(fieldId, "value"), {
-    method: "DELETE",
-    cache: "no-store",
-  });
-  if (!response.ok) throw await secretApiError(response);
+	const response = await fetch(localSecretUrl(fieldId, 'value'), {
+		method: 'DELETE',
+		cache: 'no-store',
+	})
+	if (!response.ok) throw await secretApiError(response)
 }
 
 // --- Meta fetch (with optional decryption) ---------------------------------
 
-interface RawMetaResponse {
-  encryption?: EncryptionMeta;
-  origin?: { sessionId?: string; label?: string; revision?: number; createdAt?: string };
-  [key: string]: unknown;
-}
-
 /** Fetch + parse meta, decrypting origin.sessionId/label for encrypted
  *  shares. The shape returned is the same as the worker/daemon emits, so
  *  callers don't have to branch. */
-export async function fetchMeta(): Promise<any> {
-  const res = await fetch(metaUrl());
-  if (!res.ok) throw new Error(`meta ${res.status}`);
-  const data = (await res.json()) as RawMetaResponse;
-
-  if (data.encryption && MODE.isShared && MODE.encryptionKey) {
-    const key = await MODE.encryptionKey;
-    if (data.origin) {
-      const o: any = { ...data.origin };
-      if (o.sessionId) o.sessionId = await decryptString(key, o.sessionId);
-      if (o.label) o.label = await decryptString(key, o.label);
-      data.origin = o;
-    }
-    // The worker synthesizes a one-element revisions array from the same
-    // ShareRecord.origin, so its `label` is also ciphertext — decrypt it
-    // in lockstep with origin.label above.
-    const revs = (data as any).revisions;
-    if (Array.isArray(revs)) {
-      for (const r of revs) {
-        if (r.label) {
-          try { r.label = await decryptString(key, r.label); } catch {}
-        }
-      }
-    }
-  }
-  return data;
+export async function fetchMeta(): Promise<SessionMeta> {
+	const res = await fetch(metaUrl())
+	if (!res.ok) throw new Error(`meta ${res.status}`)
+	const data = sessionMetaSchema.parse(await res.json())
+
+	if (data.encryption && MODE.isShared && MODE.encryptionKey) {
+		const key = await MODE.encryptionKey
+		if (data.origin) {
+			const o = { ...data.origin }
+			if (o.sessionId) o.sessionId = await decryptString(key, o.sessionId)
+			if (o.label) o.label = await decryptString(key, o.label)
+			data.origin = o
+		}
+		// The worker synthesizes a one-element revisions array from the same
+		// ShareRecord.origin, so its `label` is also ciphertext — decrypt it
+		// in lockstep with origin.label above.
+		for (const r of data.revisions ?? []) {
+			if (r.label) {
+				try {
+					r.label = await decryptString(key, r.label)
+				} catch {}
+			}
+		}
+	}
+	return data
 }
 
 // --- Canvas module loading -------------------------------------------------
@@ -207,24 +195,24 @@ export async function fetchMeta(): Promise<any> {
  *  Import maps still apply to Blob-URL module imports, so the resulting
  *  module's `#canvas/runtime` / `#canvas/components` imports resolve
  *  exactly as they would for an in-place script. */
-export async function loadCanvasModule(filename: string, revision?: number): Promise<any> {
-  const url = canvasJsUrl(filename, revision);
-  if (!isEncryptedShare()) {
-    return import(/* @vite-ignore */ url);
-  }
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`canvas ${res.status}`);
-  const ciphertext = await res.text();
-  const key = await (MODE as SharedModeInfo).encryptionKey!;
-  const js = await decryptString(key, ciphertext);
-  const blob = new Blob([js], { type: "application/javascript" });
-  const blobUrl = URL.createObjectURL(blob);
-  try {
-    return await import(/* @vite-ignore */ blobUrl);
-  } finally {
-    // Revoke after a tick so the import has fully resolved its source.
-    setTimeout(() => URL.revokeObjectURL(blobUrl), 0);
-  }
+export const loadCanvasModule: CanvasHost['loadCanvasModule'] = async (filename, revision) => {
+	const url = canvasJsUrl(filename, revision)
+	if (!isEncryptedShare()) {
+		return import(/* @vite-ignore */ url)
+	}
+	const res = await fetch(url)
+	if (!res.ok) throw new Error(`canvas ${res.status}`)
+	const ciphertext = await res.text()
+	const key = await (MODE as SharedModeInfo).encryptionKey!
+	const js = await decryptString(key, ciphertext)
+	const blob = new Blob([js], { type: 'application/javascript' })
+	const blobUrl = URL.createObjectURL(blob)
+	try {
+		return await import(/* @vite-ignore */ blobUrl)
+	} finally {
+		// Revoke after a tick so the import has fully resolved its source.
+		setTimeout(() => URL.revokeObjectURL(blobUrl), 0)
+	}
 }
 
 // --- Feedback submission ----------------------------------------------------
@@ -233,27 +221,27 @@ export async function loadCanvasModule(filename: string, revision?: number): Pro
  * Local-mode author info used when submitting feedback in shared mode.
  * Prompted on first submit and cached in localStorage.
  */
-const REVIEWER_KEY = "canvas-reviewer-identity";
+const REVIEWER_KEY = 'canvas-reviewer-identity'
 
 export function getReviewerIdentity(): { id: string; name: string } | null {
-  try {
-    const raw = localStorage.getItem(REVIEWER_KEY);
-    if (!raw) return null;
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
+	try {
+		const raw = localStorage.getItem(REVIEWER_KEY)
+		if (!raw) return null
+		return JSON.parse(raw)
+	} catch {
+		return null
+	}
 }
 
 export function setReviewerIdentity(name: string): { id: string; name: string } {
-  let existing = getReviewerIdentity();
-  if (!existing) {
-    existing = { id: crypto.randomUUID?.() || String(Date.now()), name };
-  } else {
-    existing.name = name;
-  }
-  localStorage.setItem(REVIEWER_KEY, JSON.stringify(existing));
-  return existing;
+	let existing = getReviewerIdentity()
+	if (!existing) {
+		existing = { id: crypto.randomUUID?.() || String(Date.now()), name }
+	} else {
+		existing.name = name
+	}
+	localStorage.setItem(REVIEWER_KEY, JSON.stringify(existing))
+	return existing
 }
 
 /**
@@ -261,47 +249,47 @@ export function setReviewerIdentity(name: string): { id: string; name: string }
  * feedback. Matches the worker's `FeedbackPostBody`.
  */
 export interface SharedFeedbackPayload {
-  author: { id: string; name: string };
-  revision: number;
-  annotations: Array<Record<string, unknown>>;
-  generalNote?: string;
+	author: { id: string; name: string }
+	revision: number
+	annotations: Array<Record<string, unknown>>
+	generalNote?: string
 }
 
 /** Encrypt the secret fields of a feedback payload in-place semantics. */
 async function encryptFeedback(
-  payload: SharedFeedbackPayload,
-  key: CryptoKey,
+	payload: SharedFeedbackPayload,
+	key: CryptoKey,
 ): Promise<SharedFeedbackPayload & { encryption: EncryptionMeta }> {
-  const annotations = await Promise.all(
-    payload.annotations.map(async (a) => {
-      const out: Record<string, unknown> = {
-        id: a.id,
-        createdAt: a.createdAt,
-        snippet: await encryptString(key, String(a.snippet ?? "")),
-        note: await encryptString(key, String(a.note ?? "")),
-      };
-      if (a.filePath) out.filePath = await encryptString(key, String(a.filePath));
-      if (a.canvasFile) out.canvasFile = await encryptString(key, String(a.canvasFile));
-      if (a.context !== undefined && a.context !== null) {
-        out.context = await encryptString(key, JSON.stringify(a.context));
-      }
-      // Image attachments are content-addressed worker URLs — already public
-      // by virtue of being served by the worker, so leaving them plaintext
-      // is fine and avoids breaking client-side rendering of the URL.
-      if (a.attachments) out.attachments = a.attachments;
-      return out;
-    }),
-  );
-  return {
-    author: {
-      id: payload.author.id,
-      name: await encryptString(key, payload.author.name),
-    },
-    revision: payload.revision,
-    annotations,
-    ...(payload.generalNote ? { generalNote: await encryptString(key, payload.generalNote) } : {}),
-    encryption: ENCRYPTION_META,
-  };
+	const annotations = await Promise.all(
+		payload.annotations.map(async (a) => {
+			const out: Record<string, unknown> = {
+				id: a.id,
+				createdAt: a.createdAt,
+				snippet: await encryptString(key, String(a.snippet ?? '')),
+				note: await encryptString(key, String(a.note ?? '')),
+			}
+			if (a.filePath) out.filePath = await encryptString(key, String(a.filePath))
+			if (a.canvasFile) out.canvasFile = await encryptString(key, String(a.canvasFile))
+			if (a.context !== undefined && a.context !== null) {
+				out.context = await encryptString(key, JSON.stringify(a.context))
+			}
+			// Image attachments are content-addressed worker URLs — already public
+			// by virtue of being served by the worker, so leaving them plaintext
+			// is fine and avoids breaking client-side rendering of the URL.
+			if (a.attachments) out.attachments = a.attachments
+			return out
+		}),
+	)
+	return {
+		author: {
+			id: payload.author.id,
+			name: await encryptString(key, payload.author.name),
+		},
+		revision: payload.revision,
+		annotations,
+		...(payload.generalNote ? { generalNote: await encryptString(key, payload.generalNote) } : {}),
+		encryption: ENCRYPTION_META,
+	}
 }
 
 /**
@@ -311,30 +299,30 @@ async function encryptFeedback(
  * fragment key.
  */
 export async function submitSharedFeedback(payload: SharedFeedbackPayload): Promise<void> {
-  if (!MODE.isShared) throw new Error("submitSharedFeedback called outside shared mode");
-  let body: unknown = payload;
-  if (MODE.encryptionKey) {
-    const key = await MODE.encryptionKey;
-    body = await encryptFeedback(payload, key);
-  }
-  const res = await fetch(`/s/${MODE.shareId}/feedback`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`Feedback submission failed: ${res.status} ${text}`);
-  }
+	if (!MODE.isShared) throw new Error('submitSharedFeedback called outside shared mode')
+	let body: unknown = payload
+	if (MODE.encryptionKey) {
+		const key = await MODE.encryptionKey
+		body = await encryptFeedback(payload, key)
+	}
+	const res = await fetch(`/s/${MODE.shareId}/feedback`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(body),
+	})
+	if (!res.ok) {
+		const text = await res.text().catch(() => '')
+		throw new Error(`Feedback submission failed: ${res.status} ${text}`)
+	}
 }
 
 // --- Feature flags ----------------------------------------------------------
 
 /** Are daemon-only filesystem endpoints (file tree, file viewer) available? */
-export const FS_AVAILABLE: boolean = !MODE.isShared;
+export const FS_AVAILABLE: boolean = !MODE.isShared
 
 /** Is live WebSocket session updates available? */
-export const WS_AVAILABLE: boolean = !MODE.isShared;
+export const WS_AVAILABLE: boolean = !MODE.isShared
 
 // --- Kernel host binding ----------------------------------------------------
 
@@ -344,11 +332,11 @@ export const WS_AVAILABLE: boolean = !MODE.isShared;
  * defaults: shared canvases come from the worker (and may be encrypted).
  */
 export const canvasHost: CanvasHost = {
-  get sessionId() {
-    return getIdentifier();
-  },
-  isShared: MODE.isShared,
-  fsAvailable: FS_AVAILABLE,
-  uploadUrl,
-  loadCanvasModule,
-};
+	get sessionId() {
+		return getIdentifier()
+	},
+	isShared: MODE.isShared,
+	fsAvailable: FS_AVAILABLE,
+	uploadUrl,
+	loadCanvasModule,
+}