amalgm 0.1.128 → 0.1.129

package/lib/updater.js

@@ -84,13 +84,19 @@ function npmEnv(env = process.env) {
   };
 }
 
+function npmSpawnOptions(options = {}) {
+  return {
+    env: npmEnv(options.env),
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    // Node rejects direct .cmd spawning on Windows, so npm.cmd must run via cmd.exe there.
+    shell: process.platform === 'win32',
+  };
+}
+
 function runNpm(args, options = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn(npmCommand(), args, {
-      env: npmEnv(options.env),
-      windowsHide: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    const child = spawn(npmCommand(), args, npmSpawnOptions(options));
     let stdout = '';
     let stderr = '';
     let timedOut = false;
@@ -202,6 +208,11 @@ function shouldAutoUpdate(options = {}) {
 }
 
 module.exports = {
+  _test: {
+    npmCommand,
+    npmEnv,
+    npmSpawnOptions,
+  },
   checkForUpdate,
   compareVersions,
   envDisablesAutoUpdate,

package/package.json

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

package/runtime/scripts/amalgm-mcp/agent-bundles/bundles.js

@@ -383,14 +383,12 @@ function collectToolRecords(toolIds, requires) {
 
     if (tool.origin === 'system') {
       addUnique(requires.systemTools, tool.id);
-      continue;
     }
 
     if (!tools.has(tool.id)) tools.set(tool.id, portableTool(tool, requires));
 
     if (selectedAction) {
       actions.set(selectedAction.id, portableAction(selectedAction, requires));
-      continue;
     }
 
     for (const action of Object.values(catalog.toolActions || {})) {

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

@@ -64,6 +64,8 @@ function ffmpegBinary() {
   if (process.env.AMALGM_FFMPEG) return process.env.AMALGM_FFMPEG;
   try {
     const resolved = require('ffmpeg-static');
+    const unpacked = asarUnpackedPath(resolved);
+    if (unpacked && fs.existsSync(unpacked)) return unpacked;
     if (resolved && fs.existsSync(resolved)) return resolved;
   } catch {}
   return 'ffmpeg';
@@ -90,7 +92,17 @@ function nativeAgentBrowser(wrapperPath) {
     && (fs.existsSync('/lib/ld-musl-x86_64.so.1') || fs.existsSync('/lib/ld-musl-aarch64.so.1'));
   const name = `agent-browser-${platform}${musl ? '-musl' : ''}-${arch}${platform === 'win32' ? '.exe' : ''}`;
   const candidate = path.join(path.dirname(wrapperPath), name);
-  return fs.existsSync(candidate) ? candidate : null;
+  if (fs.existsSync(candidate)) return candidate;
+  const unpacked = asarUnpackedPath(candidate);
+  return unpacked && fs.existsSync(unpacked) ? unpacked : null;
+}
+
+function asarUnpackedPath(candidate) {
+  if (!candidate) return null;
+  const marker = `${path.sep}app.asar${path.sep}`;
+  const index = String(candidate).indexOf(marker);
+  if (index === -1) return null;
+  return `${String(candidate).slice(0, index)}${path.sep}app.asar.unpacked${path.sep}${String(candidate).slice(index + marker.length)}`;
 }
 
 function agentBrowserCommand() {
@@ -238,11 +250,13 @@ module.exports = {
   DEFAULT_SESSION,
   agentBrowserCommand,
   amalgmDir,
+  asarUnpackedPath,
   asText,
   browserRoot,
   ensureDir,
   ffmpegBinary,
   ffmpegDir,
+  nativeAgentBrowser,
   profileDir,
   readText,
   runCli,

package/runtime/scripts/amalgm-mcp/events/desktop-release-runner.js

@@ -1069,6 +1069,27 @@ function uploadRequestWithRetry(params, attempts = Number(params.env?.AMALGM_DES
   throw lastError;
 }
 
+function parseUploadOffsetMismatch(error) {
+  const message = cleanString(error?.message || error);
+  const match = /Offset mismatch: expected (\d+), received (\d+)/i.exec(message);
+  if (!match) return null;
+  return {
+    expected: Number(match[1]),
+    received: Number(match[2]),
+  };
+}
+
+function recoverableUploadOffset(error, offset, bytesRead, size) {
+  const mismatch = parseUploadOffsetMismatch(error);
+  if (!mismatch) return null;
+  if (!Number.isFinite(mismatch.expected) || !Number.isFinite(mismatch.received)) return null;
+  if (mismatch.received !== offset) return null;
+  if (mismatch.expected <= offset) return null;
+  const maxExpected = Math.min(size, offset + bytesRead);
+  if (mismatch.expected > maxExpected) return null;
+  return mismatch.expected;
+}
+
 function uploadHttpReleaseFile({ filePath, cwd, env, publishTarget }) {
   const token = cleanString(env.AMALGM_DESKTOP_RELEASE_UPLOAD_TOKEN);
   if (!token) throw new Error('Missing AMALGM_DESKTOP_RELEASE_UPLOAD_TOKEN for desktop release HTTP upload.');
@@ -1102,15 +1123,22 @@ function uploadHttpReleaseFile({ filePath, cwd, env, publishTarget }) {
       fs.writeFileSync(chunkPath, buffer.subarray(0, bytesRead));
       const chunkUrl = new URL(uploadUrl);
       chunkUrl.searchParams.set('offset', String(offset));
-      uploadRequestWithRetry({
-        method: 'PUT',
-        url: chunkUrl.toString(),
-        token,
-        cwd,
-        env,
-        dataFile: chunkPath,
-      });
-      offset += bytesRead;
+      try {
+        uploadRequestWithRetry({
+          method: 'PUT',
+          url: chunkUrl.toString(),
+          token,
+          cwd,
+          env,
+          dataFile: chunkPath,
+        });
+        offset += bytesRead;
+      } catch (error) {
+        const resumedOffset = recoverableUploadOffset(error, offset, bytesRead, size);
+        if (resumedOffset == null) throw error;
+        console.warn(`desktop release upload resumed ${assetName} at server offset ${resumedOffset}.`);
+        offset = resumedOffset;
+      }
     }
 
     uploadRequestWithRetry({
@@ -1372,8 +1400,10 @@ module.exports = {
   desktopReleaseArtifactPaths,
   envForBuild,
   parseEnvFile,
+  parseUploadOffsetMismatch,
   publishLegacyGithubBridgeRelease,
   publishDesktopRelease,
+  recoverableUploadOffset,
   requestFromEnv,
   shouldHandleRequest,
 };

package/runtime/scripts/amalgm-mcp/tests/agent-bundles.test.js

@@ -12,7 +12,7 @@ const { upsertAgentConfig, getAgentConfig } = require('../agent-config/store');
 const { defaultToolboxService } = require('../toolbox/service');
 const { createAgentBundle, installAgentBundle } = require('../agent-bundles/bundles');
 
-test('agent bundle includes recursive subagents, selected user tools, and warnings', () => {
+test('agent bundle includes recursive subagents, selected user tools, system tools, and warnings', () => {
   defaultToolboxService.registerTool({
     id: 'acme.cli',
     name: 'Acme CLI',
@@ -81,8 +81,9 @@ test('agent bundle includes recursive subagents, selected user tools, and warnin
   assert.equal(bundle.kind, 'amalgm.agent.bundle');
   assert.equal(bundle.rootAgentId, root.id);
   assert.deepEqual(bundle.agents.map((entry) => entry.sourceAgentId), [root.id, child.id]);
-  assert.deepEqual(bundle.tools.map((tool) => tool.id), ['acme.cli']);
-  assert.deepEqual(bundle.toolActions.map((action) => action.id), ['acme.cli.run']);
+  assert.deepEqual(bundle.tools.map((tool) => tool.id), ['acme.cli', 'browser']);
+  assert.equal(bundle.toolActions.some((action) => action.id === 'acme.cli.run'), true);
+  assert.equal(bundle.toolActions.some((action) => action.toolId === 'browser'), true);
   assert.deepEqual(bundle.headIds, ['agent:bundle-root']);
   assert.equal(bundle.elements.some((element) => element.id === 'agent:bundle-root' && element.type === 'agent'), true);
   assert.equal(bundle.elements.some((element) => element.id === 'agent:bundle-child' && element.type === 'agent'), true);
@@ -110,10 +111,37 @@ test('agent bundle includes recursive subagents, selected user tools, and warnin
   assert.equal(bundle.requires.bindings.includes('tool:acme.cli:cwd'), true);
   assert.equal(bundle.requires.bindings.includes('tool:acme.cli:source.command'), true);
   assert.equal(preview.summary.agents, 2);
-  assert.equal(preview.summary.tools, 1);
+  assert.equal(preview.summary.tools, 2);
+  assert.equal(preview.tools.some((tool) => tool.id === 'browser' && tool.actionCount > 0), true);
   assert.equal(preview.warnings.some((warning) => warning.includes('free-text')), true);
 });
 
+test('agent bundle includes every tool action when the loadout references a single action id', () => {
+  const catalog = defaultToolboxService.readCatalog();
+  const browserActions = Object.values(catalog.toolActions || {}).filter((action) => action?.toolId === 'browser');
+  assert.ok(browserActions.length > 1);
+
+  const root = createAgent({
+    id: 'bundle-browser-action-root',
+    name: 'Bundle Browser Action Root',
+    baseHarnessId: 'codex',
+    baseModelId: 'openai/gpt-5.5',
+    systemPrompt: 'Browser action root',
+    loadout: { toolIds: [browserActions[0].id] },
+    authMethod: 'amalgm',
+  });
+  upsertAgentConfig(root.id, {
+    instructions: 'Browser action root',
+    loadout: { toolIds: [browserActions[0].id] },
+  });
+
+  const { bundle, preview } = createAgentBundle(root.id, { bundleId: 'agent-bundle-browser-action-test' });
+
+  assert.deepEqual(bundle.tools.map((tool) => tool.id), ['browser']);
+  assert.equal(bundle.toolActions.filter((action) => action.toolId === 'browser').length, browserActions.length);
+  assert.equal(preview.tools.some((tool) => tool.id === 'browser' && tool.actionCount === browserActions.length), true);
+});
+
 test('installing an agent bundle creates local copies and rewrites subagent refs', () => {
   const source = createAgent({
     id: 'install-source-root',

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

@@ -64,6 +64,20 @@ test('agent-browser spawns the native binary directly when it exists', () => {
   }
 });
 
+test('agent-browser native path resolves from packaged app.asar to app.asar.unpacked', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-asar-browser-test-'));
+  const wrapper = path.join(root, 'app.asar', 'node_modules', 'agent-browser', 'bin', 'agent-browser.js');
+  const native = path.join(root, 'app.asar.unpacked', 'node_modules', 'agent-browser', 'bin', `agent-browser-${os.platform()}-${os.arch()}`);
+  fs.mkdirSync(path.dirname(native), { recursive: true });
+  fs.writeFileSync(native, '');
+  try {
+    assert.equal(cli.asarUnpackedPath(wrapper), path.join(root, 'app.asar.unpacked', 'node_modules', 'agent-browser', 'bin', 'agent-browser.js'));
+    assert.equal(cli.nativeAgentBrowser(wrapper), native);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('CLI browser sessions stay headless unless headed mode is explicit', async () => {
   await withBrowserEnv({}, () => {
     assert.equal(cli.wantsHeaded(), false);

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

@@ -22,7 +22,9 @@ const {
   desktopVersion,
   envForBuild,
   parseEnvFile,
+  parseUploadOffsetMismatch,
   publishDesktopRelease,
+  recoverableUploadOffset,
   requestFromEnv,
   shouldHandleRequest,
 } = require('../events/desktop-release-runner');
@@ -101,6 +103,35 @@ test('desktop versions stay compatible with existing release ordering', () => {
   assert.equal(desktopVersion('0.1.124-preview.1', 'preview', 45), '0.1.124000045-preview.1');
 });
 
+test('desktop release upload parser extracts expected and received offsets', () => {
+  assert.deepEqual(
+    parseUploadOffsetMismatch(new Error('Desktop release upload PUT returned HTTP 409: {"ok":false,"error":"Offset mismatch: expected 352452608, received 352321536"}')),
+    { expected: 352452608, received: 352321536 },
+  );
+  assert.equal(parseUploadOffsetMismatch(new Error('something else')), null);
+});
+
+test('desktop release upload can resume from recoverable offset mismatches', () => {
+  const error = new Error('Desktop release upload PUT returned HTTP 409: {"ok":false,"error":"Offset mismatch: expected 352452608, received 352321536"}');
+  assert.equal(
+    recoverableUploadOffset(error, 352321536, 2097152, 369814043),
+    352452608,
+  );
+  assert.equal(
+    recoverableUploadOffset(error, 352190464, 2097152, 369814043),
+    null,
+  );
+  assert.equal(
+    recoverableUploadOffset(
+      new Error('Desktop release upload PUT returned HTTP 409: {"ok":false,"error":"Offset mismatch: expected 354500000, received 352321536"}'),
+      352321536,
+      2097152,
+      369814043,
+    ),
+    null,
+  );
+});
+
 test('desktop release runner loads env-file fallbacks without overriding explicit env', () => {
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-env-test-'));
   const envFile = path.join(tempRoot, 'desktop-release.env');