amalgm 0.1.111 → 0.1.112

package/lib/app-chat.js

@@ -0,0 +1,271 @@
+'use strict';
+
+function defaultFetch() {
+  if (typeof fetch !== 'function') {
+    throw new Error('A fetch implementation is required');
+  }
+  return fetch.bind(globalThis);
+}
+
+async function responseError(response, fallback) {
+  const authUrl = response.headers.get('x-amalgm-app-auth-url') || undefined;
+  const text = await response.text().catch(() => '');
+  if (!text) {
+    if (response.status === 401) return new AmalgmAppAuthRequiredError(fallback, authUrl);
+    return Object.assign(new Error(fallback), { status: response.status });
+  }
+  try {
+    const parsed = JSON.parse(text);
+    const message = parsed.error || parsed.message || fallback;
+    if (
+      response.status === 401
+      && (
+        parsed.code === 'APP_AUTH_REQUIRED'
+        || /fresh Amalgm session|app access/i.test(String(message))
+      )
+    ) {
+      return new AmalgmAppAuthRequiredError(message, parsed.authUrl || authUrl);
+    }
+    return Object.assign(new Error(message), { status: response.status });
+  } catch {
+    if (response.status === 401 && /fresh Amalgm session|app access/i.test(text)) {
+      return new AmalgmAppAuthRequiredError(text.slice(0, 500) || fallback, authUrl);
+    }
+    return Object.assign(new Error(text.slice(0, 500) || fallback), { status: response.status });
+  }
+}
+
+class AmalgmAppAuthRequiredError extends Error {
+  constructor(message = 'App access requires a fresh Amalgm session.', authUrl) {
+    super(message);
+    this.name = 'AmalgmAppAuthRequiredError';
+    this.status = 401;
+    this.code = 'APP_AUTH_REQUIRED';
+    this.authUrl = authUrl;
+  }
+}
+
+function isAmalgmAppAuthRequiredError(error) {
+  return error instanceof AmalgmAppAuthRequiredError
+    || Boolean(error && typeof error === 'object' && error.code === 'APP_AUTH_REQUIRED');
+}
+
+function refreshAmalgmAppAccess(authUrl) {
+  if (typeof window === 'undefined' || !window.location) return false;
+  const target = authUrl || `${window.location.pathname}${window.location.search}${window.location.hash}` || '/';
+  window.location.assign(target);
+  return true;
+}
+
+function parseSseText(input) {
+  const events = [];
+  let event = 'message';
+  let data = [];
+  let id;
+  const flush = () => {
+    if (data.length > 0) {
+      events.push({ event, data: data.join('\n'), ...(id !== undefined ? { id } : {}) });
+    }
+    event = 'message';
+    data = [];
+    id = undefined;
+  };
+  for (const rawLine of String(input || '').split('\n')) {
+    const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+    if (line === '') {
+      flush();
+      continue;
+    }
+    if (line.startsWith(':')) continue;
+    if (line.startsWith('event:')) event = line.slice(6).trim() || 'message';
+    if (line.startsWith('id:')) id = line.slice(3).trimStart();
+    if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
+  }
+  flush();
+  return events;
+}
+
+async function readSseStream(response, onEvent) {
+  if (!response.body) throw new Error('No response body');
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const marker = buffer.lastIndexOf('\n\n');
+    if (marker === -1) continue;
+    const ready = buffer.slice(0, marker + 2);
+    buffer = buffer.slice(marker + 2);
+    for (const event of parseSseText(ready)) onEvent(event);
+  }
+  if (buffer.trim()) {
+    for (const event of parseSseText(buffer)) onEvent(event);
+  }
+}
+
+function dispatchAgentEvent(event, handlers) {
+  handlers.onEvent?.(event);
+  if (event?._type === 'title_generated' && typeof event.title === 'string') {
+    handlers.onTitle?.(event.title, typeof event.sessionId === 'string' ? event.sessionId : undefined);
+    return false;
+  }
+  if (event?._type === 'complete') {
+    handlers.onComplete?.(event);
+    return true;
+  }
+  if (event?._type === 'error' || event?._type === 'auth_error' || event?._type === 'model_error') {
+    handlers.onError?.(new Error(event.message || event.error || 'Amalgm chat failed'));
+    return false;
+  }
+  if (event?._type === 'update') {
+    const content = event.content || {};
+    if (content.type === 'text' && typeof content.text === 'string') {
+      if (event.sessionUpdate === 'agent_thought_chunk') {
+        handlers.onReasoningDelta?.(content.text, event);
+      } else if (event.sessionUpdate === 'agent_message_chunk') {
+        handlers.onTextDelta?.(content.text, event);
+      }
+    }
+    if (content.type === 'image' && typeof content.data === 'string' && typeof content.mimeType === 'string') {
+      handlers.onImage?.(content.data, content.mimeType, event);
+    }
+  }
+  return false;
+}
+
+function jsonHeaders(extra) {
+  return { 'Content-Type': 'application/json', ...(extra || {}) };
+}
+
+class AmalgmAppChatClient {
+  constructor(options = {}) {
+    this.basePath = String(options.basePath || '/_amalgm/chat').replace(/\/$/, '');
+    this.fetch = options.fetch || defaultFetch();
+    this.headers = options.headers || undefined;
+  }
+
+  async capabilities() {
+    const response = await this.fetch(`${this.basePath}/capabilities`, {
+      method: 'GET',
+      headers: this.headers,
+      credentials: 'include',
+    });
+    if (!response.ok) throw await responseError(response, `Capabilities failed: ${response.status}`);
+    return response.json();
+  }
+
+  async createSession(request = {}) {
+    const response = await this.fetch(`${this.basePath}/sessions`, {
+      method: 'POST',
+      headers: jsonHeaders(this.headers),
+      credentials: 'include',
+      body: JSON.stringify(request),
+    });
+    if (!response.ok) throw await responseError(response, `Session create failed: ${response.status}`);
+    return response.json();
+  }
+
+  async send(request, handlers = {}) {
+    let completed = false;
+    let lastEventId = null;
+    let sessionId = request?.sessionId || null;
+    const handle = (parsed) => {
+      if (parsed.id !== undefined) lastEventId = parsed.id;
+      if (!parsed.data) return;
+      let payload;
+      try {
+        payload = JSON.parse(parsed.data);
+      } catch {
+        return;
+      }
+      if (payload._type === 'event_id' && typeof payload.eventId === 'string') {
+        lastEventId = payload.eventId;
+        return;
+      }
+      completed = dispatchAgentEvent(payload, handlers) || completed;
+    };
+    const response = await this.fetch(`${this.basePath}/stream`, {
+      method: 'POST',
+      headers: jsonHeaders(this.headers),
+      credentials: 'include',
+      body: JSON.stringify(request || {}),
+    });
+    if (!response.ok) throw await responseError(response, `Chat stream failed: ${response.status}`);
+    sessionId = response.headers.get('x-amalgm-session-id') || sessionId;
+    if (sessionId) handlers.onSession?.(sessionId);
+    await readSseStream(response, handle);
+    if (sessionId && !completed) {
+      await this.reconnect(sessionId, {
+        lastEventId,
+        handlers,
+        onComplete: () => { completed = true; },
+      });
+    }
+    return {
+      sessionId,
+      assistantMessageId: response.headers.get('x-amalgm-assistant-message-id'),
+      userMessageId: response.headers.get('x-amalgm-user-message-id'),
+      completed,
+    };
+  }
+
+  async reconnect(sessionId, options = {}) {
+    const response = await this.fetch(`${this.basePath}/reconnect`, {
+      method: 'POST',
+      headers: jsonHeaders(this.headers),
+      credentials: 'include',
+      body: JSON.stringify({ sessionId, lastEventId: options.lastEventId || undefined }),
+    });
+    if (!response.ok) throw await responseError(response, `Reconnect failed: ${response.status}`);
+    await readSseStream(response, (parsed) => {
+      if (!parsed.data) return;
+      let payload;
+      try {
+        payload = JSON.parse(parsed.data);
+      } catch {
+        return;
+      }
+      const replay = (frame) => {
+        for (const nested of parseSseText(frame || '')) {
+          if (!nested.data) continue;
+          try {
+            const event = JSON.parse(nested.data);
+            if (dispatchAgentEvent(event, options.handlers || {})) options.onComplete?.();
+          } catch {
+            // Ignore malformed replay frames.
+          }
+        }
+      };
+      if (parsed.event === 'existing' && Array.isArray(payload.chunks)) {
+        for (const chunk of payload.chunks) replay(chunk?.data);
+      }
+      if (parsed.event === 'chunk') replay(payload.chunk?.data);
+      if (parsed.event === 'complete') options.onComplete?.();
+    });
+  }
+
+  async stop(sessionId, turnId) {
+    const response = await this.fetch(`${this.basePath}/stop`, {
+      method: 'POST',
+      headers: jsonHeaders(this.headers),
+      credentials: 'include',
+      body: JSON.stringify({ sessionId, turnId }),
+    });
+    if (!response.ok) throw await responseError(response, `Stop failed: ${response.status}`);
+  }
+}
+
+function createAmalgmAppChatClient(options) {
+  return new AmalgmAppChatClient(options);
+}
+
+module.exports = {
+  AmalgmAppChatClient,
+  AmalgmAppAuthRequiredError,
+  createAmalgmAppChatClient,
+  isAmalgmAppAuthRequiredError,
+  parseSseText,
+  refreshAmalgmAppAccess,
+};

package/lib/react.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const React = require('react');
+const {
+  AmalgmAppChatClient,
+  isAmalgmAppAuthRequiredError,
+  refreshAmalgmAppAccess,
+} = require('./app-chat');
+
+function id(prefix) {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') return crypto.randomUUID();
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+function partsForRequest(request) {
+  if (Array.isArray(request?.parts) && request.parts.length > 0) return request.parts;
+  if (Array.isArray(request?.chatInput?.parts) && request.chatInput.parts.length > 0) return request.chatInput.parts;
+  return request?.prompt ? [{ type: 'text', text: request.prompt }] : [];
+}
+
+function appendText(parts, text) {
+  const next = parts.slice();
+  const last = next[next.length - 1];
+  if (last && last.type === 'text') next[next.length - 1] = { ...last, text: `${last.text || ''}${text}` };
+  else next.push({ type: 'text', text });
+  return next;
+}
+
+function useAmalgmChat(options = {}) {
+  const client = React.useMemo(
+    () => new AmalgmAppChatClient({ basePath: options.basePath, fetch: options.fetch, headers: options.headers }),
+    [options.basePath, options.fetch, options.headers],
+  );
+  const [sessionId, setSessionIdState] = React.useState(options.sessionId || null);
+  const [messages, setMessages] = React.useState([]);
+  const [events, setEvents] = React.useState([]);
+  const [isStreaming, setIsStreaming] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const sessionRef = React.useRef(options.sessionId || null);
+  const assistantRef = React.useRef(null);
+
+  const setSessionId = React.useCallback((next) => {
+    sessionRef.current = next;
+    setSessionIdState(next);
+    if (next) options.onSession?.(next);
+  }, [options]);
+
+  const send = React.useCallback(async (input) => {
+    const request = typeof input === 'string' ? { prompt: input } : (input || {});
+    const userParts = partsForRequest(request);
+    const userId = id('user');
+    const assistantId = id('assistant');
+    assistantRef.current = assistantId;
+    setError(null);
+    setIsStreaming(true);
+    setMessages((current) => [
+      ...current,
+      { id: userId, role: 'user', parts: userParts },
+      { id: assistantId, role: 'assistant', parts: [] },
+    ]);
+    try {
+      const result = await client.send({
+        ...request,
+        sessionId: request.sessionId || sessionRef.current,
+        agent: request.agent || options.agent,
+        origin: request.origin || options.origin,
+        context: request.context ?? options.context,
+      }, {
+        onSession: setSessionId,
+        onEvent: (event) => {
+          setEvents((current) => [...current, event]);
+          options.onEvent?.(event);
+        },
+        onTextDelta: (text) => {
+          setMessages((current) => current.map((message) => (
+            message.id === assistantId ? { ...message, parts: appendText(message.parts, text) } : message
+          )));
+        },
+        onComplete: options.onFinish,
+        onError: (nextError) => {
+          setError(nextError);
+          options.onError?.(nextError);
+        },
+      });
+      if (result.sessionId) setSessionId(result.sessionId);
+      return result;
+    } catch (err) {
+      const nextError = err instanceof Error ? err : new Error(String(err));
+      setError(nextError);
+      options.onError?.(nextError);
+      if (options.refreshOnAuthRequired !== false && isAmalgmAppAuthRequiredError(nextError)) {
+        refreshAmalgmAppAccess(nextError.authUrl);
+      }
+      throw nextError;
+    } finally {
+      setIsStreaming(false);
+      assistantRef.current = null;
+    }
+  }, [client, options, setSessionId]);
+
+  const stop = React.useCallback(async () => {
+    if (!sessionRef.current) return;
+    await client.stop(sessionRef.current, assistantRef.current);
+    setIsStreaming(false);
+  }, [client]);
+
+  return {
+    client,
+    sessionId,
+    setSessionId,
+    messages,
+    setMessages,
+    events,
+    isStreaming,
+    error,
+    send,
+    stop,
+  };
+}
+
+module.exports = {
+  useAmalgmChat,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.111",
+  "version": "0.1.112",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,
@@ -17,11 +17,19 @@
     "sync-runtime": "node ../../scripts/sync-npm-package-runtime.mjs",
     "prepack": "node ../../scripts/sync-npm-package-runtime.mjs",
     "pack:dry": "npm pack --dry-run",
-    "check": "node --check bin/amalgm.js && node --check lib/auth-store.js && node --check lib/cli.js && node --check lib/paths.js && node --check lib/process-cleanup.js && node --check lib/runtime-identity.js && node --check lib/runtime-manifest.js && node --check lib/service.js && node --check lib/state-migration.js && node --check lib/supervisor.js && node --check lib/tunnel-chat.js && node --check lib/tunnel-events.js && node --check lib/updater.js && node --check runtime/lib/runtime-manifest.js && node --check runtime/scripts/runtime-auth.js && node --check runtime/scripts/proxy-token-store.js && node --check runtime/scripts/local-gateway.js && node --check runtime/scripts/port-monitor.js && node --check runtime/scripts/chat-server.js && node --check runtime/scripts/chat-server/index.js && node --check runtime/scripts/chat-server/config.js && node --check runtime/scripts/chat-core/tooling/native-binaries.js && node --check runtime/scripts/chat-core/tooling/package-import.js && node --check runtime/scripts/chat-core/tooling/runtime-home.js && node --check runtime/scripts/amalgm-mcp/index.js && node --check runtime/scripts/amalgm-mcp/config.js && node --check runtime/scripts/lib/project-paths.js && node --check runtime/scripts/lib/runtime-paths.js"
+    "check": "node --check bin/amalgm.js && node --check lib/app-chat.js && node --check lib/react.js && node --check lib/auth-store.js && node --check lib/cli.js && node --check lib/paths.js && node --check lib/process-cleanup.js && node --check lib/runtime-identity.js && node --check lib/runtime-manifest.js && node --check lib/service.js && node --check lib/state-migration.js && node --check lib/supervisor.js && node --check lib/tunnel-chat.js && node --check lib/tunnel-events.js && node --check lib/updater.js && node --check runtime/lib/runtime-manifest.js && node --check runtime/scripts/runtime-auth.js && node --check runtime/scripts/proxy-token-store.js && node --check runtime/scripts/local-gateway.js && node --check runtime/scripts/port-monitor.js && node --check runtime/scripts/chat-server.js && node --check runtime/scripts/chat-server/index.js && node --check runtime/scripts/chat-server/config.js && node --check runtime/scripts/chat-core/tooling/native-binaries.js && node --check runtime/scripts/chat-core/tooling/package-import.js && node --check runtime/scripts/chat-core/tooling/runtime-home.js && node --check runtime/scripts/amalgm-mcp/index.js && node --check runtime/scripts/amalgm-mcp/config.js && node --check runtime/scripts/lib/project-paths.js && node --check runtime/scripts/lib/runtime-paths.js"
   },
   "engines": {
     "node": ">=20"
   },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "@ai-sdk/gateway": "^3.0.131",
     "@anthropic-ai/claude-agent-sdk": "^0.3.177",