amalgm 0.1.36 → 0.1.38

package/runtime/scripts/chat-core/tooling/system-prompt.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { PLATFORM_CONTEXT } = require('../../chat-server/config');
+const { activeMemoryContextBlock } = require('./active-memory');
 
 function trimBlock(value) {
   return String(value || '').trim();
@@ -10,7 +11,9 @@ function composeSystemPrompt(contract) {
   const parts = [];
   const platform = trimBlock(PLATFORM_CONTEXT);
   const custom = trimBlock(contract?.systemPrompt);
+  const active = contract?.providerSessionId ? '' : trimBlock(activeMemoryContextBlock(contract));
   if (platform) parts.push(platform);
+  if (active) parts.push(active);
   if (custom) parts.push(custom);
   return parts.join('\n\n');
 }

package/runtime/scripts/chat-server/db.js

@@ -17,6 +17,7 @@ const {
   OPENAI_PROXY_URL,
   AI_GATEWAY_PROXY_URL,
 } = require('./config');
+const { importPackage } = require('../chat-core/tooling/package-import');
 
 // ── Supabase primitives ─────────────────────────────────────────────────────
 
@@ -153,8 +154,19 @@ function gatewaySdkBaseUrl(baseUrl) {
   return clean.endsWith('/v1/ai') ? clean : `${clean}/v1/ai`;
 }
 
-function titleEndpoints() {
+async function currentProxyToken({ forceRefresh = false } = {}) {
+  if (!AI_GATEWAY_PROXY_URL && !OPENAI_PROXY_URL) return '';
+  try {
+    return await ensureFreshProxyToken?.({ force: forceRefresh, logger: console }) || readProxyToken?.() || PROXY_TOKEN || '';
+  } catch (err) {
+    console.warn('[DB] Proxy token refresh failed for title generation:', err.message);
+    return readProxyToken?.() || PROXY_TOKEN || '';
+  }
+}
+
+async function titleEndpoints({ forceRefresh = false } = {}) {
   const endpoints = [];
+  const proxyToken = await currentProxyToken({ forceRefresh });
   if (AI_GATEWAY_API_KEY_TITLE) {
     endpoints.push({
       name: 'vercel_ai_sdk_gateway',
@@ -164,22 +176,24 @@ function titleEndpoints() {
       model: gatewayTitleModel(TITLE_MODEL),
     });
   }
-  if (AI_GATEWAY_PROXY_URL && PROXY_TOKEN) {
+  if (AI_GATEWAY_PROXY_URL && proxyToken) {
     endpoints.push({
       name: 'ai_gateway_proxy',
       kind: 'openai_compat',
       url: `${AI_GATEWAY_PROXY_URL}/chat/completions`,
-      token: PROXY_TOKEN,
+      token: proxyToken,
       model: gatewayTitleModel(TITLE_MODEL),
+      usesProxyToken: true,
     });
   }
-  if (OPENAI_PROXY_URL && PROXY_TOKEN) {
+  if (OPENAI_PROXY_URL && proxyToken) {
     endpoints.push({
       name: 'openai_proxy',
       kind: 'openai_compat',
       url: `${OPENAI_PROXY_URL}/v1/chat/completions`,
-      token: PROXY_TOKEN,
+      token: proxyToken,
       model: openAiTitleModel(TITLE_MODEL),
+      usesProxyToken: true,
     });
   }
   if (OPENAI_API_KEY_TITLE) {
@@ -196,8 +210,8 @@ function titleEndpoints() {
 
 async function requestTitleWithAiSdkGateway(endpoint, prompt, signal) {
   const [{ generateText }, { createGatewayProvider }] = await Promise.all([
-    import('ai'),
-    import('@ai-sdk/gateway'),
+    importPackage('ai'),
+    importPackage('@ai-sdk/gateway'),
   ]);
   const gateway = createGatewayProvider({
     apiKey: endpoint.token,
@@ -240,11 +254,26 @@ async function requestTitle(endpoint, prompt, signal) {
   return cleanGeneratedTitle(extractResponseText(await res.json()));
 }
 
+function isProxyAuthFailure(error) {
+  return /\b(401|403)\b|invalid or expired token|unauthorized/i.test(String(error?.message || error || ''));
+}
+
+async function requestTitleWithProxyRetry(endpoint, prompt, signal) {
+  try {
+    return await requestTitle(endpoint, prompt, signal);
+  } catch (err) {
+    if (!endpoint.usesProxyToken || !isProxyAuthFailure(err)) throw err;
+    const refreshedToken = await currentProxyToken({ forceRefresh: true });
+    if (!refreshedToken || refreshedToken === endpoint.token) throw err;
+    return requestTitle({ ...endpoint, token: refreshedToken }, prompt, signal);
+  }
+}
+
 async function generateTitle(prompt) {
   const text = String(prompt || '').trim();
   if (!text) return '';
 
-  const endpoints = titleEndpoints();
+  const endpoints = await titleEndpoints();
   if (endpoints.length === 0) {
     console.warn('[DB] Title generation skipped: no gateway/proxy credentials');
     return '';
@@ -254,7 +283,7 @@ async function generateTitle(prompt) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), TITLE_TIMEOUT_MS);
     try {
-      const title = await requestTitle(endpoint, text, controller.signal);
+      const title = await requestTitleWithProxyRetry(endpoint, text, controller.signal);
       if (title) return title;
     } catch (err) {
       console.warn('[DB] Title generation endpoint failed:', err.message);

package/runtime/scripts/local-gateway.js

@@ -46,12 +46,34 @@ const pty = loadPty();
 const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
 const STATE_FILE = path.join(AMALGM_DIR, 'runtime-state.json');
 const ARTIFACTS_FILE = path.join(AMALGM_DIR, 'artifacts.json');
+const LOG_DIR = path.join(AMALGM_DIR, 'logs');
 const BIND_HOST = process.env.AMALGM_BIND_HOST || '127.0.0.1';
 const OWNER = process.env.AMALGM_RUNTIME_SOURCE || 'local';
 const VERSION = process.env.npm_package_version || process.env.AMALGM_RUNTIME_VERSION || '';
 const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || os.homedir();
 const PORT = Number.parseInt(process.env.AMALGM_GATEWAY_PORT || '28781', 10);
 const RUNTIME_TOKEN_HEADER = 'x-amalgm-runtime-token';
+const DEFAULT_DIAGNOSTIC_LOG_TAIL_BYTES = 256 * 1024;
+const MAX_DIAGNOSTIC_LOG_TAIL_BYTES = 2 * 1024 * 1024;
+
+const DIAGNOSTIC_LOG_FILES = Object.freeze({
+  daemon: 'daemon.log',
+  'chat-server': 'chat-server.log',
+  'local-gateway': 'local-gateway.log',
+  'amalgm-mcp': 'amalgm-mcp.log',
+  'fs-watcher': 'fs-watcher.log',
+  'port-monitor': 'port-monitor.log',
+});
+
+const DIAGNOSTIC_LOG_ALIASES = Object.freeze({
+  chat: 'chat-server',
+  mcp: 'amalgm-mcp',
+  gateway: 'local-gateway',
+  events: 'daemon',
+  'event-tunnel': 'daemon',
+  'chat-tunnel': 'daemon',
+  tunnel: 'daemon',
+});
 
 const SERVICE_PORTS = {
   gateway: PORT,
@@ -314,6 +336,137 @@ function sendJson(res, statusCode, payload) {
   res.end(JSON.stringify(payload));
 }
 
+function diagnosticLogServices() {
+  return Object.keys(DIAGNOSTIC_LOG_FILES);
+}
+
+function normalizeDiagnosticLogService(value) {
+  let service = String(value || 'daemon').trim().toLowerCase();
+  if (service.endsWith('.log')) service = service.slice(0, -4);
+  service = service.replace(/[^a-z0-9_-]/g, '');
+  return DIAGNOSTIC_LOG_ALIASES[service] || service;
+}
+
+function parseDiagnosticTailBytes(value) {
+  const parsed = Number.parseInt(String(value || ''), 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_DIAGNOSTIC_LOG_TAIL_BYTES;
+  return Math.min(parsed, MAX_DIAGNOSTIC_LOG_TAIL_BYTES);
+}
+
+function parseDiagnosticLineLimit(value) {
+  const parsed = Number.parseInt(String(value || ''), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return Math.min(parsed, 5000);
+}
+
+function redactDiagnosticLogContent(content) {
+  return String(content)
+    .replace(/(authorization\s*[:=]\s*)(?:Bearer\s+)?[A-Za-z0-9._~+/=-]{8,}/gi, '$1[REDACTED]')
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{20,}\b/gi, 'Bearer [REDACTED]')
+    .replace(/\b(?:sk|pk|rk|ghp|github_pat|glpat|xox[baprs])[-_][A-Za-z0-9_./+=-]{16,}\b/g, '[REDACTED_TOKEN]')
+    .replace(
+      /((?:api[_-]?key|apikey|token|secret|password|cookie|set-cookie)[^:=\n]{0,32}[:=]\s*["']?)[^\s"',;}]+/gi,
+      '$1[REDACTED]',
+    );
+}
+
+function applyDiagnosticLineLimit(content, lineLimit) {
+  if (!lineLimit) return { content, lineTruncated: false };
+  const lines = String(content).split(/\r?\n/);
+  if (lines.length <= lineLimit) return { content, lineTruncated: false };
+  return {
+    content: lines.slice(-lineLimit).join('\n'),
+    lineTruncated: true,
+  };
+}
+
+async function readDiagnosticLogTail(logPath, maxBytes) {
+  const stats = await fs.promises.stat(logPath);
+  if (!stats.isFile()) {
+    const error = new Error('Diagnostic log path is not a file');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  const bytes = Math.min(stats.size, maxBytes);
+  if (bytes === 0) {
+    return {
+      stats,
+      bytes,
+      content: '',
+      byteTruncated: false,
+    };
+  }
+
+  const handle = await fs.promises.open(logPath, 'r');
+  try {
+    const buffer = Buffer.alloc(bytes);
+    await handle.read(buffer, 0, bytes, stats.size - bytes);
+    return {
+      stats,
+      bytes,
+      content: buffer.toString('utf8'),
+      byteTruncated: stats.size > bytes,
+    };
+  } finally {
+    await handle.close();
+  }
+}
+
+async function handleDiagnosticLogs(req, res, url) {
+  if (req.method !== 'GET') {
+    res.writeHead(405, { Allow: 'GET' });
+    res.end();
+    return;
+  }
+
+  const service = normalizeDiagnosticLogService(
+    url.searchParams.get('service') || url.searchParams.get('name'),
+  );
+  const filename = DIAGNOSTIC_LOG_FILES[service];
+  if (!filename) {
+    sendJson(res, 400, {
+      error: 'Unknown diagnostic log service',
+      availableServices: diagnosticLogServices(),
+    });
+    return;
+  }
+
+  const tailBytes = parseDiagnosticTailBytes(url.searchParams.get('tailBytes'));
+  const lineLimit = parseDiagnosticLineLimit(url.searchParams.get('lines'));
+  const logPath = path.join(LOG_DIR, filename);
+
+  try {
+    const tail = await readDiagnosticLogTail(logPath, tailBytes);
+    const lineLimited = applyDiagnosticLineLimit(tail.content, lineLimit);
+    sendJson(res, 200, {
+      service,
+      path: logPath,
+      exists: true,
+      size: tail.stats.size,
+      mtime: tail.stats.mtime.toISOString(),
+      tailBytes: tail.bytes,
+      truncated: tail.byteTruncated || lineLimited.lineTruncated,
+      content: redactDiagnosticLogContent(lineLimited.content),
+    });
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      sendJson(res, 404, {
+        service,
+        path: logPath,
+        exists: false,
+        error: 'Diagnostic log file not found',
+      });
+      return;
+    }
+    const status = typeof error?.statusCode === 'number' ? error.statusCode : 500;
+    sendJson(res, status, {
+      service,
+      error: error instanceof Error ? error.message : 'Failed to read diagnostic log',
+    });
+  }
+}
+
 async function readBody(req) {
   const chunks = [];
   for await (const chunk of req) chunks.push(Buffer.from(chunk));
@@ -760,6 +913,11 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === '/diagnostics/logs') {
+      await handleDiagnosticLogs(req, res, url);
+      return;
+    }
+
     if (url.pathname === '/pty/session' || url.pathname === '/pty/resize') {
       await handlePtyHttp(req, res, url.pathname);
       return;