amalgm 0.1.104 → 0.1.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.104",
+  "version": "0.1.105",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/browser/attach.js

@@ -101,11 +101,10 @@ async function surfaceRect(session, hintUrl) {
 }
 
 /**
- * Attached mode's product promise is a surface the user can see. A webview
- * target can exist while the splitview panel is hidden — input silently
- * drops and captures have nothing to show. When that happens, ask the UI to
- * reopen it (repeat browser_surfaces events open or focus the existing
- * surface) and poll until it has real on-screen geometry.
+ * Attached mode's product promise is a compositor-backed session surface.
+ * The surface may be visible to the user or held in the automation compositor
+ * slot; either way it must have real layout geometry. When it does not, ask
+ * the UI to mount it and poll until geometry appears.
  */
 async function ensureSurfaceVisible(session, hintUrl, context, waitMs = WEBVIEW_WAIT_MS) {
   let found = await surfaceRect(session, hintUrl);
@@ -216,6 +215,28 @@ async function focusSurface(session, surface) {
   }
 }
 
+function commandNeedsOwnedFocus(command) {
+  const action = String(command?.[0] || '');
+  if (action === 'mouse' || action === 'click' || action === 'select') return true;
+  if (action === 'focus' || action === 'fill' || action === 'press' || action === 'keyboard') return true;
+  return false;
+}
+
+/**
+ * Focus is owned by the browser session, not by the user's currently selected
+ * Amalgm tab. Before commands that need native guest focus, reacquire focus on
+ * this session's stamped surface. Reads and evals do not disturb the user.
+ */
+async function acquireOwnedFocus(session, context, surface, hintUrl = '') {
+  if (!surface || surface.external) return;
+  if (surface.embedderWsUrl) {
+    const visible = await ensureSurfaceVisible(session, hintUrl, context);
+    if (!visible) throw new Error(SURFACE_HIDDEN_MESSAGE);
+    surface.embedderWsUrl = visible.pageWsUrl || surface.embedderWsUrl;
+  }
+  await focusSurface(session, surface);
+}
+
 /**
  * Connect the session to the advertised chromium on first use: select the
  * in-tab webview in the daemon, stamp the guest over a persistent raw-CDP
@@ -277,10 +298,10 @@ async function ensureReady(session, context) {
     );
   }
 
-  // The webview target existing is not enough — the splitview panel must be
-  // on screen, or input drops and captures have nothing to render. (The app
-  // window itself may be hidden or minimized; that no longer matters — the
-  // app keeps an attached surface compositing wherever the window is.)
+  // The webview target existing is not enough — the session surface must be
+  // compositor-backed, or input drops and captures have nothing to render.
+  // The app window itself may be hidden or minimized; the app keeps attached
+  // surfaces compositing while the browser tool owns them.
   const visible = await ensureSurfaceVisible(session, selected.url, context);
   if (!visible) throw new Error(SURFACE_HIDDEN_MESSAGE);
 
@@ -369,6 +390,8 @@ async function execute(session, commands, options = {}, single) {
   const { context, ...cliExtra } = options;
   const surface = await ensureReady(session, context);
   const guarded = Boolean(surface) && !surface.external;
+  const needsOwnedFocus = guarded && commands.some(commandNeedsOwnedFocus);
+  if (needsOwnedFocus) await acquireOwnedFocus(session, context, surface);
 
   const attempt = async () => {
     const batchCommands = guarded ? [guardCommand(session), ...commands] : commands;
@@ -399,7 +422,8 @@ async function execute(session, commands, options = {}, single) {
       // The app restarted, the webview remounted, or the daemon drifted off
       // this session's page; re-attach once against current reality.
       detach(session);
-      await ensureReady(session, context);
+      const nextSurface = await ensureReady(session, context);
+      if (needsOwnedFocus) await acquireOwnedFocus(session, context, nextSurface);
       return attempt();
     }
     throw err;

package/runtime/scripts/amalgm-mcp/browser/engine.js

@@ -190,7 +190,8 @@ async function passthrough(args = {}, context) {
   const session = sessionFor(args, context);
   const commandArgs = (args.args || []).map(String);
   if (!commandArgs.length) throw new Error('args is required, e.g. ["scroll", "down"] or ["get", "text", "@e1"]');
-  if (sessions.backendFor(session) === 'attached' && commandArgs[0] === 'tab' && commandArgs.length > 1) {
+  const attached = sessions.backendFor(session) === 'attached';
+  if (attached && commandArgs[0] === 'tab' && commandArgs.length > 1) {
     // In the desktop app a session IS its surface; hopping targets is how a
     // session ends up driving another session's page. Listing stays allowed.
     throw new Error(
@@ -198,6 +199,16 @@ async function passthrough(args = {}, context) {
       + 'Use a different `session` id for a second page.',
     );
   }
+  if (attached && commandArgs[0] === 'keyboard' && commandArgs[1] === 'type') {
+    const text = commandArgs.slice(2).join(' ');
+    const result = await run(session, ['eval', typing.insertTextScript(text)], { timeoutMs: args.timeoutMs || 60_000, context });
+    return { ...sessionInfo(session), result: result?.data ?? result };
+  }
+  if (attached && commandArgs[0] === 'press') {
+    const key = commandArgs.slice(1).join('+');
+    const result = await run(session, ['eval', typing.keyScript(key)], { timeoutMs: args.timeoutMs || 60_000, context });
+    return { ...sessionInfo(session), result: result?.data ?? result };
+  }
   const result = await run(session, commandArgs, { timeoutMs: args.timeoutMs || 60_000, context });
   return { ...sessionInfo(session), result: result?.data ?? result };
 }
@@ -252,8 +263,20 @@ async function cua(action, args = {}, context) {
     ], options);
   }
   if (action === 'cua_scroll') await run(session, ['mouse', 'wheel', args.scrollY || 0, args.scrollX || 0], options);
-  if (action === 'cua_type') await run(session, ['keyboard', 'type', args.text || ''], options);
-  if (action === 'cua_keypress') await run(session, ['press', (args.keys || []).join('+')], options);
+  if (action === 'cua_type') {
+    if (backendFor(session) === 'attached') {
+      await run(session, ['eval', typing.insertTextScript(args.text || '')], options);
+    } else {
+      await run(session, ['keyboard', 'type', args.text || ''], options);
+    }
+  }
+  if (action === 'cua_keypress') {
+    if (backendFor(session) === 'attached') {
+      await run(session, ['eval', typing.keyScript((args.keys || []).join('+'))], options);
+    } else {
+      await run(session, ['press', (args.keys || []).join('+')], options);
+    }
+  }
   if (action === 'cua_drag') {
     const points = Array.isArray(args.path) ? args.path : [];
     if (points.length < 2) throw new Error('drag path must contain at least two points');

package/runtime/scripts/amalgm-mcp/browser/typing.js

@@ -46,6 +46,64 @@ function setValueScript(text) {
   })()`;
 }
 
+/**
+ * Insert text at the focused field/caret without using browser-window
+ * keyboard focus. This is the attached-mode implementation for cua_type and
+ * CLI keyboard typing: if the page did not focus an editable element, fail
+ * closed instead of letting real keystrokes leak into Amalgm's own UI.
+ */
+function insertTextScript(text) {
+  return `(() => {
+    const el = document.activeElement;
+    if (!el || el === document.body || el === document.documentElement) {
+      throw new Error('focus did not land on an editable field');
+    }
+    const text = ${JSON.stringify(String(text))};
+    const inputEvent = (inputType, data = text) => new InputEvent('input', {
+      bubbles: true,
+      data,
+      inputType,
+    });
+
+    if (el.isContentEditable) {
+      const selection = window.getSelection();
+      if (selection && selection.rangeCount) {
+        const range = selection.getRangeAt(0);
+        range.deleteContents();
+        const node = document.createTextNode(text);
+        range.insertNode(node);
+        range.setStartAfter(node);
+        range.setEndAfter(node);
+        selection.removeAllRanges();
+        selection.addRange(range);
+      } else {
+        el.textContent = (el.textContent || '') + text;
+      }
+      el.dispatchEvent(inputEvent('insertText'));
+      return true;
+    }
+
+    const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype
+      : el instanceof HTMLInputElement ? HTMLInputElement.prototype
+      : null;
+    if (!proto && !('value' in el)) {
+      throw new Error('focused element <' + el.tagName.toLowerCase() + '> is not editable');
+    }
+    const value = String(el.value || '');
+    const start = typeof el.selectionStart === 'number' ? el.selectionStart : value.length;
+    const end = typeof el.selectionEnd === 'number' ? el.selectionEnd : start;
+    const next = value.slice(0, start) + text + value.slice(end);
+    const setter = proto && Object.getOwnPropertyDescriptor(proto, 'value').set;
+    if (setter) setter.call(el, next); else el.value = next;
+    const caret = start + text.length;
+    if (typeof el.setSelectionRange === 'function') {
+      try { el.setSelectionRange(caret, caret); } catch {}
+    }
+    el.dispatchEvent(inputEvent('insertText'));
+    return true;
+  })()`;
+}
+
 /** "KeyA" for letters, "Digit1" for digits, the key's own name otherwise. */
 function codeFor(key) {
   if (/^[a-z]$/i.test(key)) return `Key${key.toUpperCase()}`;
@@ -77,10 +135,49 @@ function keyScript(combo) {
   return `(() => {
     const el = document.activeElement || document.body;
     const init = ${JSON.stringify(init)};
+    const isInput = el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement;
+    const isEditable = isInput || el.isContentEditable;
+    const inputEvent = (inputType, data = null) => new InputEvent('input', {
+      bubbles: true,
+      data,
+      inputType,
+    });
+    const setValue = (next, start, end = start) => {
+      const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype
+        : el instanceof HTMLInputElement ? HTMLInputElement.prototype
+        : null;
+      const setter = proto && Object.getOwnPropertyDescriptor(proto, 'value').set;
+      if (setter) setter.call(el, next); else el.value = next;
+      if (typeof el.setSelectionRange === 'function') {
+        try { el.setSelectionRange(start, end); } catch {}
+      }
+    };
     const proceed = el.dispatchEvent(new KeyboardEvent('keydown', init));
     if (proceed) {
       el.dispatchEvent(new KeyboardEvent('keypress', init));
-      if (init.key === 'Enter') {
+      if ((init.ctrlKey || init.metaKey) && init.key.toLowerCase() === 'a' && isEditable) {
+        if (isInput && typeof el.select === 'function') {
+          el.select();
+        } else {
+          const range = document.createRange();
+          range.selectNodeContents(el);
+          const selection = window.getSelection();
+          selection.removeAllRanges();
+          selection.addRange(range);
+        }
+      } else if ((init.key === 'Backspace' || init.key === 'Delete') && isInput) {
+        const value = String(el.value || '');
+        const selectionStart = typeof el.selectionStart === 'number' ? el.selectionStart : value.length;
+        const selectionEnd = typeof el.selectionEnd === 'number' ? el.selectionEnd : selectionStart;
+        let start = selectionStart;
+        let end = selectionEnd;
+        if (start === end && init.key === 'Backspace' && start > 0) start -= 1;
+        if (start === end && init.key === 'Delete' && end < value.length) end += 1;
+        if (start !== end) {
+          setValue(value.slice(0, start) + value.slice(end), start);
+          el.dispatchEvent(inputEvent(init.key === 'Backspace' ? 'deleteContentBackward' : 'deleteContentForward'));
+        }
+      } else if (init.key === 'Enter') {
         if (el instanceof HTMLButtonElement || el instanceof HTMLAnchorElement) {
           el.click();
         } else if (el instanceof HTMLInputElement && el.form) {
@@ -93,4 +190,4 @@ function keyScript(combo) {
   })()`;
 }
 
-module.exports = { codeFor, keyScript, setValueScript };
+module.exports = { codeFor, insertTextScript, keyScript, setValueScript };

package/runtime/scripts/amalgm-mcp/tests/browser-transport.test.js

@@ -78,6 +78,39 @@ test('passthrough refuses tab hops in attached mode, allows listing', async () =
   }
 });
 
+test('attached text entry is translated to in-page scripts instead of real keyboard events', async () => {
+  const saved = process.env.AMALGM_BROWSER_BACKEND;
+  process.env.AMALGM_BROWSER_BACKEND = 'attached';
+  try {
+    calls.length = 0;
+    nextResults = [
+      { success: true, data: { result: true } },
+      { success: true, data: { result: true } },
+      { success: true, data: { result: true } },
+      { success: true, data: { result: true } },
+    ];
+
+    await engine.cua('cua_type', { text: 'cyanheads', session: 'typing-test' }, {});
+    await engine.cua('cua_keypress', { keys: ['Control', 'a'], session: 'typing-test' }, {});
+    await engine.passthrough({ args: ['keyboard', 'type', 'safe text'], session: 'typing-test' }, {});
+    await engine.passthrough({ args: ['press', 'Enter'], session: 'typing-test' }, {});
+
+    assert.deepEqual(calls[0].commandArgs[0], 'eval');
+    assert.match(calls[0].commandArgs[1], /insertText/);
+    assert.deepEqual(calls[1].commandArgs[0], 'eval');
+    assert.match(calls[1].commandArgs[1], /KeyboardEvent/);
+    assert.deepEqual(calls[2].commandArgs[0], 'eval');
+    assert.match(calls[2].commandArgs[1], /safe text/);
+    assert.deepEqual(calls[3].commandArgs[0], 'eval');
+    assert.match(calls[3].commandArgs[1], /requestSubmit|KeyboardEvent/);
+    assert.equal(calls.some((call) => call.commandArgs[0] === 'keyboard'), false);
+    assert.equal(calls.some((call) => call.commandArgs[0] === 'press'), false);
+  } finally {
+    if (saved === undefined) delete process.env.AMALGM_BROWSER_BACKEND;
+    else process.env.AMALGM_BROWSER_BACKEND = saved;
+  }
+});
+
 // The guard itself: execute() turns every attached call into a batch that
 // leads with the stamp-check eval, and maps the single-command result back to
 // its unbatched shape. The guard never appears in caller-visible results.
@@ -123,6 +156,52 @@ console.log(JSON.stringify({ success: true, data: cmds.map((c) => ({ command: c,
   }
 });
 
+test('attached focus-dependent commands reacquire the session surface focus', async () => {
+  const fs = require('node:fs');
+  const os = require('node:os');
+  const path = require('node:path');
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-focus-test-'));
+  const stub = path.join(dir, 'stub.sh');
+  fs.writeFileSync(stub, `#!/bin/sh
+input=$(cat)
+node -e '
+const cmds = JSON.parse(process.argv[1]);
+console.log(JSON.stringify({ success: true, data: cmds.map((c) => ({ command: c, success: true, result: true })) }));
+' "$input"
+`, { mode: 0o755 });
+
+  const focusCalls = [];
+  const savedBin = process.env.AMALGM_AGENT_BROWSER_BIN;
+  const savedBackend = process.env.AMALGM_BROWSER_BACKEND;
+  const savedCdp = process.env.AMALGM_BROWSER_CDP_URL;
+  process.env.AMALGM_AGENT_BROWSER_BIN = stub;
+  process.env.AMALGM_BROWSER_BACKEND = 'attached';
+  process.env.AMALGM_BROWSER_CDP_URL = '9242';
+  surfaces.set('focus-test', {
+    tabId: 't9',
+    wsUrl: 'ws://x/guest',
+    client: {
+      async call(method, params) {
+        focusCalls.push([method, params?.expression || '']);
+        return {};
+      },
+      close() {},
+    },
+    external: false,
+  });
+  try {
+    await attach.run('focus-test', ['mouse', 'move', 5, 7], { timeoutMs: 5000 });
+    assert.deepEqual(focusCalls, [['Runtime.evaluate', 'window.focus()']]);
+  } finally {
+    surfaces.delete('focus-test');
+    knownSessions.delete('focus-test');
+    if (savedBin === undefined) delete process.env.AMALGM_AGENT_BROWSER_BIN; else process.env.AMALGM_AGENT_BROWSER_BIN = savedBin;
+    if (savedBackend === undefined) delete process.env.AMALGM_BROWSER_BACKEND; else process.env.AMALGM_BROWSER_BACKEND = savedBackend;
+    if (savedCdp === undefined) delete process.env.AMALGM_BROWSER_CDP_URL; else process.env.AMALGM_BROWSER_CDP_URL = savedCdp;
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test('a guard failure is classified as a lost target; page errors are not', () => {
   // Guard failures and dead connections re-attach. Ordinary page errors must
   // NOT look like lost connections — a spurious re-attach on "Element not

package/runtime/scripts/platform-context.txt

@@ -132,7 +132,7 @@ The loop: `open` a URL → `snapshot` to see interactive elements as @refs → `
 - `screenshot` — PNG when you need pixels (snapshot is cheaper for driving); image coordinates match cua input 1:1
 - `cli` — the full agent-browser command surface: scroll, hover, back, cookies, storage, network, traces, find-by-role, and more
 - `close` — end the session (in the desktop app this also tidies away its split view)
-- `cua_screenshot` / `cua_click` / `cua_type` / … — coordinate-based control for vision loops
+- `cua_screenshot` / `cua_click` / `cua_type` / … — coordinate-based control for vision loops. In the desktop app, text/key CUA actions are scoped inside the target page so they cannot type into Amalgm's own chat UI.
 - `record_start` / `record_stop` / `record_list` — capture the session to a local WebM video (QA evidence)
 - `auth_list` / `auth_link_create` / `auth_save` / `auth_load` — reuse logins: in the desktop app the login page opens directly in the split view for the user to sign in; from the web, share the minted link. Save/load encrypted auth bundles afterward