@amalgm/chat 0.1.1 → 0.2.0

package/host/permissions.js

@@ -0,0 +1,27 @@
+/** One host permission decision shape shared by every native adapter. */
+
+export const PERMISSION_OUTCOMES = Object.freeze([
+  'allow_once',
+  'allow_always',
+  'deny',
+  'cancel',
+]);
+
+export async function requestPermission(port, request) {
+  if (typeof port !== 'function') return Object.freeze({ outcome: 'deny' });
+  const decision = await port(Object.freeze({ ...request }));
+  const outcome = decision?.outcome;
+  if (!PERMISSION_OUTCOMES.includes(outcome)) {
+    throw new TypeError(`permission port returned an invalid outcome: ${String(outcome)}`);
+  }
+  return Object.freeze({
+    outcome,
+    ...(decision.updatedInput && typeof decision.updatedInput === 'object'
+      ? { updatedInput: decision.updatedInput }
+      : {}),
+  });
+}
+
+export function allowed(decision) {
+  return decision.outcome === 'allow_once' || decision.outcome === 'allow_always';
+}

package/host/platform-egress.js

@@ -0,0 +1,114 @@
+const HOP_HEADERS = new Set([
+  'accept-encoding',
+  'connection',
+  'content-encoding',
+  'content-length',
+  'host',
+  'transfer-encoding',
+]);
+
+function metadataHeaders(contract) {
+  return {
+    'x-amalgm-session-id': contract.sessionId,
+    'x-amalgm-message-id': contract.assistantMessageId || '',
+    'x-amalgm-turn-id': contract.assistantMessageId || '',
+    'x-amalgm-agent-id': contract.agentId,
+    'x-amalgm-harness-id': contract.harness,
+    'x-amalgm-auth-method': contract.authMethod,
+    'x-amalgm-model-id': contract.usageModelId || contract.modelId,
+    'x-amalgm-cwd': contract.cwd || '',
+    'x-amalgm-usage-owner': contract.usageOwner,
+  };
+}
+
+function requestHeaders(request) {
+  const headers = {};
+  for (const [name, value] of Object.entries(request.headers || {})) {
+    const lower = name.toLowerCase();
+    if (HOP_HEADERS.has(lower) || lower === 'authorization' || lower === 'x-api-key') continue;
+    if (value !== undefined) headers[lower] = Array.isArray(value) ? value[0] : value;
+  }
+  return headers;
+}
+
+function responseHeaders(response) {
+  const headers = {};
+  for (const [name, value] of response.headers.entries()) {
+    if (!HOP_HEADERS.has(name.toLowerCase())) headers[name] = value;
+  }
+  return headers;
+}
+
+/** Forward one provider request through the platform proxy for its bound session. */
+export async function forwardPlatformEgress({ request, response, contract, proxy, upstreamPath }) {
+  const authorization = String(request.headers.authorization || '').replace(/^Bearer\s+/i, '').trim();
+  const apiKey = String(request.headers['x-api-key'] || '').trim();
+  if (!contract.auth?.tokenRef || (authorization || apiKey) !== contract.auth.tokenRef) {
+    response.writeHead(401, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    response.end(JSON.stringify({ error: 'Invalid Chat egress token' }));
+    return;
+  }
+  const method = request.method || 'GET';
+  const url = `${proxy.baseUrl.replace(/\/$/, '')}${upstreamPath}`;
+  const body = ['GET', 'HEAD'].includes(method) ? undefined : await requestBytes(request);
+  const fetchImpl = proxy.fetch || fetch;
+  let upstream;
+  try {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const grant = await proxy.credentialBroker.authorize({
+        audience: 'amalgm-api-proxy',
+        scopes: [scopeForPath(upstreamPath)],
+        method,
+        url,
+      });
+      upstream = await fetchImpl(url, {
+        method,
+        headers: {
+          ...requestHeaders(request),
+          ...metadataHeaders(contract),
+          authorization: grant.authorization,
+          dpop: grant.dpop,
+        },
+        body,
+      });
+      if (upstream.status !== 401 || attempt === 1) break;
+      await upstream.body?.cancel().catch(() => undefined);
+      proxy.credentialBroker.invalidate(grant);
+    }
+  } catch (error) {
+    response.writeHead(503, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    response.end(JSON.stringify({
+      error: 'Platform authorization unavailable',
+      code: typeof error?.code === 'string' ? error.code : 'PLATFORM_AUTHORIZATION_FAILED',
+    }));
+    return;
+  }
+  if (!upstream) throw new Error('Platform egress produced no upstream response');
+  response.writeHead(upstream.status, responseHeaders(upstream));
+  if (upstream.body) {
+    const reader = upstream.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) response.write(Buffer.from(value));
+    }
+  }
+  response.end();
+}
+
+function scopeForPath(path) {
+  if (path.startsWith('/anthropic')) return 'llm:anthropic';
+  if (path.startsWith('/ai_gateway')) return 'llm:gateway';
+  if (path.startsWith('/google') || path.startsWith('/gemini')) return 'llm:google';
+  if (path.startsWith('/xai')) return 'llm:xai';
+  if (path.startsWith('/openai')) return 'llm:openai';
+  throw Object.assign(new Error('Platform egress route has no authorization scope'), {
+    code: 'EGRESS_SCOPE_UNKNOWN',
+  });
+}
+
+async function requestBytes(request) {
+  const chunks = [];
+  for await (const chunk of request) chunks.push(Buffer.from(chunk));
+  return chunks.length > 0 ? Buffer.concat(chunks) : undefined;
+}

package/host/recorder.js

@@ -0,0 +1,61 @@
+/** Opt-in redacted native-event recorder for adapter diagnostics. */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { amalgmDir } from './lib/runtime-paths.js';
+
+const SENSITIVE_KEY = /(api[-_]?key|authorization|auth|bearer|cookie|password|secret|credential|access[-_]?token|refresh[-_]?token|session[-_]?token|id[-_]?token)/i;
+
+function recordEnabled() {
+  return process.env.AMALGM_CHAT_RECORD === '1';
+}
+
+function recordPath() {
+  if (process.env.AMALGM_CHAT_RECORD_PATH) return process.env.AMALGM_CHAT_RECORD_PATH;
+  const root = amalgmDir();
+  const session = process.env.AMALGM_CHAT_RECORD_SESSION || new Date().toISOString().slice(0, 10);
+  return path.join(root, 'chat-recordings', `${session}.ndjson`);
+}
+
+function redactString(value) {
+  const home = os.homedir();
+  let next = String(value);
+  if (home) next = next.split(home).join('~');
+  next = next.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [redacted]');
+  next = next.replace(/\b(?:sk|sk-ant|v0)_[A-Za-z0-9._-]{12,}\b/g, '[redacted-key]');
+  return next;
+}
+
+export function redact(value, depth = 0) {
+  if (depth > 8) return '[redacted-depth]';
+  if (value == null) return value;
+  if (typeof value === 'string') return redactString(value);
+  if (typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map((entry) => redact(entry, depth + 1));
+
+  const output = {};
+  for (const [key, entry] of Object.entries(value)) {
+    output[key] = SENSITIVE_KEY.test(key) ? '[redacted]' : redact(entry, depth + 1);
+  }
+  return output;
+}
+
+export function recordNativeEvent(source, payload, metadata = {}) {
+  if (!recordEnabled()) return;
+  const file = recordPath();
+  const row = {
+    recordedAt: new Date().toISOString(),
+    source,
+    metadata: redact(metadata),
+    payload: redact(payload),
+  };
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(row)}\n`);
+  } catch (err) {
+    if (process.env.AMALGM_CHAT_RECORD_DEBUG === '1') {
+      console.warn('[amalgm-chat-recorder] failed:', err.message);
+    }
+  }
+}

package/host/sqlite/index.d.ts

@@ -0,0 +1,69 @@
+import type Database from 'better-sqlite3';
+import type {
+  AppendTurnUpdateInput,
+  AppendTurnUpdatesInput,
+  BeginConversationTurnInput,
+  ConversationMessage,
+  ConversationRecord,
+  ConversationScope,
+  ConversationStorePort,
+  ConversationTurn,
+  CreateConversationInput,
+  ListConversationsOptions,
+  SealConversationTurnInput,
+  StoredTurnUpdate,
+  ProviderCheckpointRecord,
+} from '../../dist/conversations/index.js';
+
+export interface SqliteConversationStoreOptions {
+  databasePath?: string;
+  database?: Database.Database;
+  busyTimeoutMs?: number;
+  synchronous?: 'full' | 'normal';
+}
+
+export class SqliteConversationStoreError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+
+export function createSqliteJournalBatchPolicy(options?: {
+  maxUpdates?: number;
+  maxDelayMs?: number;
+}): {
+  readonly maxUpdates: number;
+  readonly maxDelayMs: number;
+  readonly wait: (milliseconds: number) => Promise<void>;
+};
+
+export class SqliteConversationStore implements ConversationStorePort {
+  readonly database: Database.Database;
+  readonly databasePath: string;
+  constructor(options: SqliteConversationStoreOptions);
+  createConversation(input: CreateConversationInput): Promise<ConversationRecord>;
+  getConversation(scope: ConversationScope, conversationId: string): Promise<ConversationRecord | null>;
+  getConversationForOwner(ownerUserId: string, conversationId: string, includeArchived?: boolean): {
+    readonly scope: ConversationScope;
+    readonly record: ConversationRecord;
+  } | null;
+  listConversations(ownerUserId: string, options?: ListConversationsOptions): Promise<readonly ConversationRecord[]>;
+  updateTitle(scope: ConversationScope, conversationId: string, title: string, updatedAt: string): Promise<ConversationRecord>;
+  markSeen(scope: ConversationScope, conversationId: string, updatedAt: string): Promise<ConversationRecord>;
+  updateProjection(scope: ConversationScope, conversationId: string, input: {
+    readonly providerSessionId?: string | null;
+    readonly lastExecutionComputerId?: string | null;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+  }, updatedAt: string): ConversationRecord;
+  archiveConversation(scope: ConversationScope, conversationId: string, archivedAt: string): Promise<ConversationRecord>;
+  beginTurn(input: BeginConversationTurnInput): Promise<ConversationTurn>;
+  appendTurnUpdate(input: AppendTurnUpdateInput): Promise<StoredTurnUpdate>;
+  appendTurnUpdates(input: AppendTurnUpdatesInput): Promise<readonly StoredTurnUpdate[]>;
+  sealTurn(input: SealConversationTurnInput): Promise<ConversationTurn>;
+  getTurn(scope: ConversationScope, turnId: string): Promise<ConversationTurn | null>;
+  getLatestTurn(scope: ConversationScope, conversationId: string): Promise<ConversationTurn | null>;
+  listTurnUpdates(scope: ConversationScope, turnId: string, afterSequence?: number, limit?: number): Promise<readonly StoredTurnUpdate[]>;
+  listMessages(scope: ConversationScope, conversationId: string): Promise<readonly ConversationMessage[]>;
+  getProviderCheckpoint(scope: ConversationScope, conversationId: string, executionRevision: string): Promise<ProviderCheckpointRecord | null>;
+  recoverInterrupted(ownerUserId: string, recoveredAt: string): Promise<readonly ConversationTurn[]>;
+  close(): void;
+}