amalgm 0.1.135 → 0.1.136

package/runtime/scripts/amalgm-mcp/tests/desktop-release-server.test.js

@@ -53,6 +53,10 @@ function writeReleaseFiles(lane, version, mtimeOffsetMs = 0) {
 
 test('desktop release server resolves stable bridge download targets from metadata', () => {
   const artifacts = [
+    'amalgm-thin-0.1.1-arm64-mac.zip',
+    'amalgm-thin-0.1.1-arm64-mac.zip.blockmap',
+    'amalgm-thin-0.1.1-arm64.dmg',
+    'amalgm-thin-0.1.1-arm64.dmg.blockmap',
     'amalgm-0.1.1-arm64-mac.zip',
     'amalgm-0.1.1-arm64-mac.zip.blockmap',
     'amalgm-0.1.1-arm64.dmg',
@@ -65,10 +69,10 @@ test('desktop release server resolves stable bridge download targets from metada
   assert.deepEqual(parseDownloadPath('/main/download/zip'), { lane: 'main', kind: 'zip' });
   assert.deepEqual(parseDownloadPath('/main/latest.dmg'), { lane: 'main', kind: 'dmg' });
   assert.equal(parseDownloadPath('/main/latest-mac.yml'), null);
-  assert.equal(latestArtifactName({ artifacts }, 'dmg'), 'amalgm-0.1.1-arm64.dmg');
+  assert.equal(latestArtifactName({ artifacts }, 'dmg'), 'amalgm-thin-0.1.1-arm64.dmg');
   assert.deepEqual(latestDownloadTarget('main', 'zip'), {
     metadata: { lane: 'main', artifacts },
-    artifactName: 'amalgm-0.1.1-arm64-mac.zip',
+    artifactName: 'amalgm-thin-0.1.1-arm64-mac.zip',
   });
 });
 
@@ -81,6 +85,10 @@ test('desktop release server groups versioned release artifacts', () => {
     releaseKeyForArtifact('amalgm-preview-0.1.139882282-preview.1-arm64.dmg'),
     'amalgm-preview@0.1.139882282-preview.1',
   );
+  assert.equal(
+    releaseKeyForArtifact('amalgm-preview-thin-0.1.139882282-preview.1-arm64.dmg'),
+    'amalgm-preview-thin@0.1.139882282-preview.1',
+  );
   assert.equal(releaseKeyForArtifact('latest-mac.yml'), '');
 });
 
@@ -113,6 +121,8 @@ test('desktop release server prunes stale lane artifacts after publish', () => {
 
 test('desktop release server redirects public bridge download URLs to current assets', async () => {
   writeReleaseMetadata('preview', [
+    'amalgm-preview-thin-0.1.1-preview.1-arm64.zip',
+    'amalgm-preview-thin-0.1.1-preview.1-arm64.dmg',
     'amalgm-preview-0.1.1-preview.1-arm64.zip',
     'amalgm-preview-0.1.1-preview.1-arm64.dmg',
     'preview-mac.yml',
@@ -127,7 +137,7 @@ test('desktop release server redirects public bridge download URLs to current as
     assert.equal(response.status, 302);
     assert.equal(
       response.headers.get('location'),
-      `http://127.0.0.1:${port}/preview/amalgm-preview-0.1.1-preview.1-arm64.dmg`,
+      `http://127.0.0.1:${port}/preview/amalgm-preview-thin-0.1.1-preview.1-arm64.dmg`,
     );
 
     const zipResponse = await fetch(`http://127.0.0.1:${port}/preview/latest.zip`, {
@@ -137,7 +147,7 @@ test('desktop release server redirects public bridge download URLs to current as
     assert.equal(zipResponse.status, 302);
     assert.equal(
       zipResponse.headers.get('location'),
-      `http://127.0.0.1:${port}/preview/amalgm-preview-0.1.1-preview.1-arm64.zip`,
+      `http://127.0.0.1:${port}/preview/amalgm-preview-thin-0.1.1-preview.1-arm64.zip`,
     );
 
     const forwardedResponse = await fetch(`http://127.0.0.1:${port}/preview/download`, {
@@ -150,7 +160,7 @@ test('desktop release server redirects public bridge download URLs to current as
     assert.equal(forwardedResponse.status, 302);
     assert.equal(
       forwardedResponse.headers.get('location'),
-      'https://amalgm-desktop-releases.fly.dev/preview/amalgm-preview-0.1.1-preview.1-arm64.dmg',
+      'https://amalgm-desktop-releases.fly.dev/preview/amalgm-preview-thin-0.1.1-preview.1-arm64.dmg',
     );
   } finally {
     await new Promise((resolve) => server.close(resolve));

package/runtime/scripts/amalgm-mcp/tests/email-embeds.test.js

@@ -83,6 +83,41 @@ test('full entity embed uses chrome identity only, not centered email-only body
   assert.doesNotMatch(html, /text-transform:uppercase/);
 });
 
+test('attached video cards use the notification deep link when provided', () => {
+  const html = renderMediaEmbed(
+    'QA recording',
+    'attached:qa-pass.webm',
+    'cid:poster-1',
+    { defaultOpenUrl: 'https://amalgm.ai/session/sess-123' },
+  );
+
+  assert.match(html, /https:\/\/amalgm\.ai\/session\/sess-123/);
+  assert.doesNotMatch(html, /href="https:\/\/amalgm\.ai"(?!\/session)/);
+});
+
+test('standalone entity embeds derive canonical session routes from tile ids', () => {
+  const html = markdownToEmailHtml('[QA run](tile:chat:sess-123)');
+
+  assert.match(html, /https:\/\/amalgm\.ai\/session\/sess-123/);
+  assert.doesNotMatch(html, /href="https:\/\/amalgm\.ai"(?!\/session)/);
+});
+
+test('relative app links become absolute email links', () => {
+  const html = markdownToEmailHtml('Open [details](/session/sess-123)');
+
+  assert.match(html, /href="https:\/\/amalgm\.ai\/session\/sess-123"/);
+});
+
+test('standalone attached media lines keep the provided fallback deep link', () => {
+  const html = markdownToEmailHtml(
+    '![QA recording](attached:qa-pass.webm "cid:poster-1")',
+    { defaultOpenUrl: 'https://amalgm.ai/apps/app-03n045jhko' },
+  );
+
+  assert.match(html, /https:\/\/amalgm\.ai\/apps\/app-03n045jhko/);
+  assert.doesNotMatch(html, /href="https:\/\/amalgm\.ai"(?!\/apps)/);
+});
+
 test('file identity prefers explicit filename over path and url', () => {
   const identity = resolveFileEmbedIdentity({
     name: 'renamed.mov',

package/runtime/scripts/amalgm-mcp/workspace/rest.js

@@ -626,6 +626,7 @@ async function handleWorktreeDelete(body, sendJson) {
 }
 
 module.exports = {
+  getWorkspaceRoot,
   handleProjects,
   handleProjectRegister,
   handleProjectUpdate,

package/runtime/scripts/chat-core/adapters/acp-client.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const { spawn } = require('child_process');
+
+/**
+ * Minimal Agent Client Protocol (ACP) client: JSON-RPC 2.0 over the stdio of a
+ * spawned agent process. This is the amalgm *client* side; the CLI (cursor-agent,
+ * gemini, ...) is the ACP agent. One instance per native agent process.
+ *
+ * The reader is tolerant of non-JSON stdout lines because young ACP servers are
+ * known to corrupt stdout with log output.
+ */
+class AcpClient {
+  constructor({ binary, args = [], cwd, env, label = 'acp' }) {
+    this.label = label;
+    this.id = 1;
+    this.pending = new Map();
+    this.notificationHandlers = new Set();
+    this.requestHandler = null;
+    this.buffer = '';
+    this.closed = false;
+    this.closeError = null;
+    this.child = spawn(binary, args, {
+      cwd,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+      windowsHide: true,
+    });
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data', (chunk) => this.onData(chunk));
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data', (chunk) => {
+      const text = String(chunk || '').trim();
+      if (text && process.env.CHAT_CORE_DEBUG) console.warn(`[${this.label}]`, text.slice(0, 1000));
+    });
+    this.child.on('error', (err) => this.failAll(err));
+    this.child.on('exit', (code, signal) => {
+      this.failAll(new Error(`${this.label} agent exited (${code ?? signal ?? 'unknown'})`));
+    });
+    this.child.stdin.on('error', (err) => this.failAll(err));
+  }
+
+  failAll(err) {
+    this.closed = true;
+    this.closeError = err;
+    for (const pending of this.pending.values()) pending.reject(err);
+    this.pending.clear();
+  }
+
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (process.env.CHAT_CORE_DEBUG_ACP === '1') {
+        console.log(`[${this.label}:recv]`, JSON.stringify(msg).slice(0, 4000));
+      }
+      this.dispatch(msg);
+    }
+  }
+
+  dispatch(msg) {
+    if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        const err = new Error(msg.error.data?.message || msg.error.message || JSON.stringify(msg.error));
+        err.code = msg.error.code;
+        pending.reject(err);
+      } else {
+        pending.resolve(msg.result);
+      }
+      return;
+    }
+    if (msg.id !== undefined && msg.method) {
+      this.handleServerRequest(msg);
+      return;
+    }
+    if (msg.method) {
+      for (const handler of this.notificationHandlers) handler(msg);
+    }
+  }
+
+  async handleServerRequest(msg) {
+    if (!this.requestHandler) {
+      this.write({ jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: `Method not supported: ${msg.method}` } });
+      return;
+    }
+    try {
+      const result = await this.requestHandler(msg.method, msg.params || {});
+      this.write({ jsonrpc: '2.0', id: msg.id, result: result ?? {} });
+    } catch (err) {
+      this.write({ jsonrpc: '2.0', id: msg.id, error: { code: -32603, message: err.message || 'Internal error' } });
+    }
+  }
+
+  write(payload) {
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) return;
+    try {
+      this.child.stdin.write(`${JSON.stringify(payload)}\n`, (err) => {
+        if (err) this.failAll(err);
+      });
+    } catch (err) {
+      this.failAll(err);
+    }
+  }
+
+  request(method, params = {}, timeoutMs = 180000) {
+    if (this.closeError) return Promise.reject(this.closeError);
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) {
+      return Promise.reject(new Error(`${this.label} agent is not running`));
+    }
+    const id = this.id++;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs > 0
+        ? setTimeout(() => {
+            this.pending.delete(id);
+            reject(new Error(`${method} timed out`));
+          }, timeoutMs)
+        : null;
+      this.pending.set(id, {
+        resolve: (value) => { if (timer) clearTimeout(timer); resolve(value); },
+        reject: (err) => { if (timer) clearTimeout(timer); reject(err); },
+      });
+      this.write({ jsonrpc: '2.0', id, method, params });
+    });
+  }
+
+  notify(method, params) {
+    this.write(params === undefined ? { jsonrpc: '2.0', method } : { jsonrpc: '2.0', method, params });
+  }
+
+  onNotification(handler) {
+    this.notificationHandlers.add(handler);
+    return () => this.notificationHandlers.delete(handler);
+  }
+
+  onRequest(handler) {
+    this.requestHandler = handler;
+  }
+
+  close() {
+    try { this.child.stdin.end(); } catch {}
+    try {
+      if (process.platform !== 'win32' && this.child.pid) process.kill(-this.child.pid, 'SIGTERM');
+      else this.child.kill('SIGTERM');
+    } catch {}
+  }
+}
+
+module.exports = { AcpClient };

package/runtime/scripts/chat-core/adapters/cursor.js

@@ -0,0 +1,254 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { done, errorEvent, warningEvent } = require('../events');
+const { promptText } = require('../input');
+const { cursorPromptUsage, cursorStopReason, normalizeCursorUpdate } = require('../normalizers/cursor');
+const { recordNativeEvent } = require('../recorder');
+const { relayedMcpServers } = require('../tooling/mcp-bundle');
+const { executableExists, findOnPath } = require('../tooling/native-binaries');
+const { prepareHarnessRuntime } = require('../tooling/runtime-home');
+const { composeSystemPrompt } = require('../tooling/system-prompt');
+const { AcpClient } = require('./acp-client');
+
+const PROTOCOL_VERSION = 1;
+
+function resolveBinary() {
+  const binaryName = process.platform === 'win32' ? 'cursor-agent.exe' : 'cursor-agent';
+  const homes = [...new Set([process.env.AMALGM_NATIVE_HOME, os.homedir()].filter(Boolean))];
+  const candidates = [
+    process.env.CURSOR_AGENT_BINARY,
+    ...homes.map((home) => path.join(home, '.local', 'bin', binaryName)),
+    '/opt/homebrew/bin/cursor-agent',
+    '/usr/local/bin/cursor-agent',
+    findOnPath('cursor-agent'),
+  ].filter(Boolean);
+  const failures = [];
+  for (const candidate of candidates) {
+    if (!executableExists(candidate)) {
+      failures.push(`${candidate} (missing or not executable)`);
+      continue;
+    }
+    const res = spawnSync(candidate, ['--version'], { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' });
+    if (res.status === 0) return candidate;
+    failures.push(`${candidate} (--version failed: ${res.error?.message || res.status || res.signal || 'unknown'})`);
+  }
+  throw new Error(`Cursor Agent CLI is not available. Checked: ${failures.join(', ') || 'no candidates'}. Install it with: curl https://cursor.com/install -fsS | bash, then run cursor-agent login.`);
+}
+
+// cursor-agent's session/set_model only accepts EXACT ids from availableModels
+// (base name + bracket parameters, e.g. "gpt-5.3-codex[reasoning=medium,fast=false]").
+// Amalgm cliModels are bare base names, so match by base and return the exact id.
+function matchAcpModel(availableModels, requested) {
+  const models = Array.isArray(availableModels) ? availableModels : [];
+  const baseOf = (id) => String(id || '').split('[')[0].trim();
+  let clean = String(requested || '').trim().replace(/^cursor\//, '').split('[')[0];
+  if (!clean) return null;
+  if (clean === 'auto' || clean === 'default') clean = 'default';
+  const findBase = (base) => models.find((m) => baseOf(m.modelId) === base)
+    || models.find((m) => String(m.name || '').toLowerCase() === base.toLowerCase());
+  let candidate = clean;
+  // Legacy amalgm cursor cliModels carry effort/speed suffixes ("gpt-5.3-codex-high",
+  // "composer-2.5-fast") that ACP model ids do not; strip them until a base matches.
+  for (let i = 0; i < 6; i += 1) {
+    const match = findBase(candidate);
+    if (match) return match;
+    const stripped = candidate.replace(/-(?:fast|thinking|low|medium|high|xhigh|max)$/, '');
+    if (stripped === candidate) return null;
+    candidate = stripped;
+  }
+  return null;
+}
+
+function toAcpMcpServers(contract) {
+  return relayedMcpServers(contract).map((server) => ({
+    type: server.type === 'sse' ? 'sse' : 'http',
+    name: server.name,
+    url: server.url,
+    headers: (server.headers || []).map((header) => ({ name: header.name, value: header.value })),
+  }));
+}
+
+function pickPermissionOption(options = []) {
+  const byKind = (kind) => options.find((option) => option?.kind === kind);
+  return byKind('allow_always') || byKind('allow_once') || options[0] || null;
+}
+
+class CursorAdapter {
+  async create(contract) {
+    const runtime = prepareHarnessRuntime(contract);
+    const binary = resolveBinary();
+    const client = new AcpClient({
+      binary,
+      args: ['acp'],
+      cwd: contract.cwd,
+      env: runtime.env,
+      label: 'Cursor',
+    });
+    const session = {
+      sessionId: contract.sessionId,
+      providerSessionId: contract.providerSessionId || null,
+      client,
+      needsSystemPrompt: false,
+      modelWarning: null,
+      activePrompt: null,
+      cancelRequested: false,
+    };
+    client.onRequest((method, params) => this.handleAgentRequest(session, method, params));
+    await client.request('initialize', {
+      protocolVersion: PROTOCOL_VERSION,
+      clientInfo: { name: 'amalgm-chat-core', version: '1.0.0' },
+      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },
+    });
+    const sessionParams = { cwd: contract.cwd, mcpServers: toAcpMcpServers(contract) };
+    let acpSession = null;
+    if (session.providerSessionId) {
+      // session/load replays history as session/update notifications; nothing is
+      // subscribed yet, so the replay is discarded and the turn starts clean.
+      acpSession = await client.request('session/load', {
+        sessionId: session.providerSessionId,
+        ...sessionParams,
+      }, 600000).catch((err) => {
+        console.warn('[Cursor] Failed to load native session; starting a new one:', err.message);
+        return null;
+      });
+    }
+    if (!acpSession) {
+      acpSession = await client.request('session/new', sessionParams);
+      session.providerSessionId = acpSession.sessionId;
+      session.needsSystemPrompt = true;
+    }
+    await this.selectModel(session, acpSession, contract);
+    return session;
+  }
+
+  async selectModel(session, acpSession, contract) {
+    const requested = contract.cliModel || contract.modelId;
+    const models = acpSession?.models || {};
+    const match = matchAcpModel(models.availableModels, requested);
+    if (!match) {
+      session.modelWarning = `Cursor Agent does not offer "${requested}"; continuing with ${models.currentModelId || 'its default model'}`;
+      return;
+    }
+    if (match.modelId === models.currentModelId) return;
+    try {
+      await session.client.request('session/set_model', {
+        sessionId: session.providerSessionId,
+        modelId: match.modelId,
+      }, 30000);
+    } catch (err) {
+      session.modelWarning = `Cursor Agent rejected model "${match.modelId}": ${err.message}`;
+    }
+  }
+
+  async handleAgentRequest(session, method, params) {
+    recordNativeEvent('cursor.acp.request', { method, params }, {
+      providerSessionId: session.providerSessionId,
+      sessionId: session.sessionId,
+    });
+    if (method === 'session/request_permission') {
+      if (session.cancelRequested) return { outcome: { outcome: 'cancelled' } };
+      const pick = pickPermissionOption(params.options);
+      if (!pick) return { outcome: { outcome: 'cancelled' } };
+      return { outcome: { outcome: 'selected', optionId: pick.optionId } };
+    }
+    throw new Error(`Method not supported: ${method}`);
+  }
+
+  async resume(session, contract) {
+    if (session.client && !session.client.closed) return session;
+    return this.create({ ...contract, providerSessionId: session.providerSessionId || contract.providerSessionId });
+  }
+
+  async stop(session) {
+    session.cancelRequested = true;
+    if (!session.activePrompt) return;
+    session.client.notify('session/cancel', { sessionId: session.providerSessionId });
+  }
+
+  async destroy(session) {
+    session.client.close();
+  }
+
+  async *prompt(session, input, contract) {
+    const queue = [];
+    let complete = false;
+    let wake = null;
+    const wakeLoop = () => { if (wake) { wake(); wake = null; } };
+    const push = (e) => {
+      if (e.type === 'done' || e.type === 'error') complete = true;
+      queue.push(e);
+      wakeLoop();
+    };
+    const state = { providerSessionId: session.providerSessionId, tools: new Map() };
+    session.cancelRequested = false;
+    session.activePrompt = state;
+    if (session.modelWarning) {
+      push(warningEvent(session.modelWarning, { providerSessionId: session.providerSessionId }));
+      session.modelWarning = null;
+    }
+    const off = session.client.onNotification((msg) => {
+      if (msg.method !== 'session/update') return;
+      const params = msg.params || {};
+      if (params.sessionId && params.sessionId !== session.providerSessionId) return;
+      recordNativeEvent('cursor.acp.update', msg, {
+        providerSessionId: session.providerSessionId,
+        sessionId: contract.sessionId,
+        assistantMessageId: contract.assistantMessageId,
+        updateKind: params.update?.sessionUpdate,
+      });
+      for (const e of normalizeCursorUpdate(params.update || {}, state)) push(e);
+    });
+    let text = promptText(input, contract);
+    if (session.needsSystemPrompt) {
+      // ACP has no system-prompt slot; a fresh native session gets the composed
+      // instructions as a preamble on its first prompt only.
+      const systemPrompt = composeSystemPrompt(contract);
+      if (systemPrompt) text = `<system-instructions>\n${systemPrompt}\n</system-instructions>\n\n${text}`;
+      session.needsSystemPrompt = false;
+    }
+    session.client.request('session/prompt', {
+      sessionId: session.providerSessionId,
+      prompt: [{ type: 'text', text }],
+    }, 0).then((result) => {
+      recordNativeEvent('cursor.acp.prompt_result', result, {
+        providerSessionId: session.providerSessionId,
+        sessionId: contract.sessionId,
+        assistantMessageId: contract.assistantMessageId,
+      });
+      const usage = cursorPromptUsage(result?.usage, { providerSessionId: session.providerSessionId });
+      if (usage) push(usage);
+      const stopReason = session.cancelRequested ? 'cancelled' : cursorStopReason(result?.stopReason);
+      push(done({ providerSessionId: session.providerSessionId, stopReason }));
+    }).catch((err) => {
+      if (session.cancelRequested) {
+        push(done({ providerSessionId: session.providerSessionId, stopReason: 'cancelled' }));
+        return;
+      }
+      push(errorEvent(err.message, { providerSessionId: session.providerSessionId }));
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'error' }));
+    });
+    try {
+      while (!complete || queue.length) {
+        if (!queue.length) await new Promise((resolve) => { wake = resolve; });
+        else yield queue.shift();
+      }
+    } finally {
+      off();
+      session.activePrompt = null;
+      session.cancelRequested = false;
+    }
+  }
+}
+
+module.exports = {
+  CursorAdapter,
+  __private: {
+    matchAcpModel,
+    pickPermissionOption,
+    resolveBinary,
+    toAcpMcpServers,
+  },
+};