amalgm 0.1.137 → 0.1.138

package/runtime/scripts/amalgm-mcp/tests/bundle-entries.test.js

@@ -34,7 +34,7 @@ function writeSampleApp(dir) {
   fs.writeFileSync(path.join(dir, 'run.sh'), '#!/bin/sh\necho run\n', { mode: 0o755 });
 }
 
-function registerSampleApp(cwd) {
+function registerSampleApp(cwd, overrides = {}) {
   const data = loadApps();
   const app = {
     id: 'app-sample-test',
@@ -54,6 +54,7 @@ function registerSampleApp(cwd) {
     status: 'running',
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
+    ...overrides,
   };
   data.apps = data.apps.filter((item) => item.id !== app.id);
   data.apps.push(app);
@@ -174,7 +175,7 @@ test('app entry export carries the portable record and install materializes a ru
   const rootDir = makeTempDir('bundle-app-install-root-');
   const registerInput = materializeAppEntry(entry, { rootDir });
   assert.equal(registerInput.start_command, entry.app.startCommand);
-  assert.equal(registerInput.build_command, entry.app.buildCommand);
+  assert.equal(registerInput.build_command, 'npm install && npm run build');
   assert.equal(registerInput.cwd.startsWith(rootDir), true);
   assert.equal(fs.readFileSync(path.join(registerInput.cwd, 'package.json'), 'utf8'), JSON.stringify({ name: 'sample-app' }));
 
@@ -183,6 +184,43 @@ test('app entry export carries the portable record and install materializes a ru
   assert.notEqual(secondInput.cwd, registerInput.cwd);
 });
 
+test('materializeAppEntry bootstraps node dependencies for imported apps without duplicating install steps', () => {
+  const rootDir = makeTempDir('bundle-app-bootstrap-root-');
+
+  const buildDir = makeTempDir('bundle-app-bootstrap-src-');
+  fs.writeFileSync(path.join(buildDir, 'package.json'), JSON.stringify({ name: 'bootstrap-build' }));
+  fs.writeFileSync(path.join(buildDir, 'package-lock.json'), JSON.stringify({ name: 'bootstrap-build', lockfileVersion: 3 }));
+  fs.writeFileSync(path.join(buildDir, 'server.js'), 'console.log("serve");\n');
+  const buildApp = registerSampleApp(buildDir, {
+    buildCommand: 'npm run build',
+    startCommand: 'node server.js',
+  });
+  const buildEntry = exportAppEntry(buildApp.id).entry;
+  assert.equal(materializeAppEntry(buildEntry, { rootDir }).build_command, 'npm install && npm run build');
+
+  const preinstallDir = makeTempDir('bundle-app-bootstrap-preinstall-src-');
+  fs.writeFileSync(path.join(preinstallDir, 'package.json'), JSON.stringify({ name: 'bootstrap-preinstall' }));
+  fs.writeFileSync(path.join(preinstallDir, 'package-lock.json'), JSON.stringify({ name: 'bootstrap-preinstall', lockfileVersion: 3 }));
+  fs.writeFileSync(path.join(preinstallDir, 'server.js'), 'console.log("serve");\n');
+  const preinstallApp = registerSampleApp(preinstallDir, {
+    buildCommand: 'npm install && npm run build',
+    startCommand: 'node server.js',
+  });
+  const preinstallEntry = exportAppEntry(preinstallApp.id).entry;
+  assert.equal(materializeAppEntry(preinstallEntry, { rootDir }).build_command, 'npm install && npm run build');
+
+  const startOnlyDir = makeTempDir('bundle-app-bootstrap-startonly-src-');
+  fs.writeFileSync(path.join(startOnlyDir, 'package.json'), JSON.stringify({ name: 'bootstrap-startonly' }));
+  fs.writeFileSync(path.join(startOnlyDir, 'package-lock.json'), JSON.stringify({ name: 'bootstrap-startonly', lockfileVersion: 3 }));
+  fs.writeFileSync(path.join(startOnlyDir, 'server.js'), 'console.log("serve");\n');
+  const startOnlyApp = registerSampleApp(startOnlyDir, {
+    buildCommand: null,
+    startCommand: 'node server.js',
+  });
+  const startOnlyEntry = exportAppEntry(startOnlyApp.id).entry;
+  assert.equal(materializeAppEntry(startOnlyEntry, { rootDir }).build_command, 'npm install');
+});
+
 test('mixed bundle carries automations and apps with heads and installs everything', async () => {
   const dir = makeTempDir('bundle-mixed-app-');
   writeSampleApp(dir);
@@ -390,3 +428,131 @@ test('rest handlers round-trip a share: preview exports a bundle and install rec
   await handlePreview({}, empty.sendJson);
   assert.equal(empty.result.status, 400);
 });
+
+test('app-backed tool paths export as bindings and install rewritten to the installed app', async () => {
+  const { defaultToolboxService } = require('../toolbox/service');
+  const appDir = makeTempDir('bundle-appbound-src-');
+  fs.mkdirSync(path.join(appDir, 'tool'), { recursive: true });
+  fs.writeFileSync(path.join(appDir, 'package.json'), JSON.stringify({ name: 'appbound' }));
+  fs.writeFileSync(path.join(appDir, 'server.js'), 'console.log("serve");\n');
+  fs.writeFileSync(path.join(appDir, 'tool', 'cli.mjs'), 'console.log("tool");\n');
+  fs.writeFileSync(path.join(appDir, 'tool', 'SKILL.md'), '# Tool skill\n');
+
+  const app = registerSampleApp(appDir, {
+    id: 'app-appbound-test',
+    name: 'App Bound',
+    appRef: 'appboundref01',
+    startCommand: 'PORT={port} node server.js',
+  });
+  defaultToolboxService.registerTool({
+    id: 'appbound.tool',
+    name: 'App Bound Tool',
+    type: 'cli',
+    origin: 'user',
+    source: {
+      command: 'node',
+      args: [path.join(appDir, 'tool', 'cli.mjs')],
+      cwd: appDir,
+      inputMode: 'json-stdin',
+      outputMode: 'json',
+    },
+    guide: { kind: 'skill', path: path.join(appDir, 'tool', 'SKILL.md') },
+  });
+
+  const { bundle } = createBundle({ appIds: [app.id], toolIds: ['appbound.tool'] });
+
+  const toolEntry = bundle.tools.find((tool) => tool.id === 'appbound.tool');
+  const bindings = toolEntry.appPathBindings;
+  assert.equal(Array.isArray(bindings), true);
+  const byLabel = Object.fromEntries(bindings.map((b) => [b.path.join('.'), b]));
+  assert.deepEqual(byLabel['source.cwd'], { appId: app.id, path: ['source', 'cwd'], relative: '' });
+  assert.deepEqual(byLabel['source.args.0'], { appId: app.id, path: ['source', 'args', 0], relative: 'tool/cli.mjs' });
+  assert.deepEqual(byLabel['guide.path'], { appId: app.id, path: ['guide', 'path'], relative: 'tool/SKILL.md' });
+  // Bound paths are portable — no manual rebinding requirements remain.
+  assert.equal(bundle.requires.bindings.some((entry) => entry.includes('appbound.tool')), false);
+
+  const revived = JSON.parse(JSON.stringify(bundle));
+  const rootDir = makeTempDir('bundle-appbound-install-');
+  const result = await installBundle(revived, {
+    appsRootDir: rootDir,
+    registerApp: async (input) => ({ id: 'app-installed-appbound', ...input, status: 'running' }),
+  });
+
+  const installedAppDir = result.installedApps[0].cwd;
+  assert.equal(installedAppDir.startsWith(rootDir), true);
+  const installedTool = result.installedTools.find((tool) => tool.id === 'appbound.tool');
+  assert.equal(installedTool.source.cwd, installedAppDir);
+  assert.equal(installedTool.source.args[0], path.join(installedAppDir, 'tool', 'cli.mjs'));
+  assert.equal(installedTool.guide.path, path.join(installedAppDir, 'tool', 'SKILL.md'));
+  // The rewritten paths point at real materialized files.
+  assert.equal(fs.existsSync(installedTool.source.args[0]), true);
+  assert.equal(fs.existsSync(installedTool.guide.path), true);
+  // Nothing in the installed tool leaks the sharer's directory.
+  assert.equal(JSON.stringify(installedTool).includes(appDir), false);
+  assert.equal(result.warnings.some((warning) => warning.includes('bound to app')), false);
+});
+
+test('app-backed tool paths still bind when the tool uses a symlink alias of the app cwd', () => {
+  const { defaultToolboxService } = require('../toolbox/service');
+  const appDir = makeTempDir('bundle-appbound-alias-src-');
+  const aliasParent = makeTempDir('bundle-appbound-alias-link-');
+  const aliasDir = path.join(aliasParent, 'app-alias');
+  fs.mkdirSync(path.join(appDir, 'tool'), { recursive: true });
+  fs.writeFileSync(path.join(appDir, 'package.json'), JSON.stringify({ name: 'appbound-alias' }));
+  fs.writeFileSync(path.join(appDir, 'server.js'), 'console.log("serve");\n');
+  fs.writeFileSync(path.join(appDir, 'tool', 'cli.mjs'), 'console.log("tool");\n');
+  fs.writeFileSync(path.join(appDir, 'tool', 'SKILL.md'), '# Tool skill\n');
+  fs.symlinkSync(appDir, aliasDir, 'dir');
+
+  const app = registerSampleApp(appDir, {
+    id: 'app-appbound-alias-test',
+    name: 'App Bound Alias',
+    appRef: 'appboundalias01',
+    startCommand: 'PORT={port} node server.js',
+  });
+  defaultToolboxService.registerTool({
+    id: 'appbound.alias.tool',
+    name: 'App Bound Alias Tool',
+    type: 'cli',
+    origin: 'user',
+    source: {
+      command: 'node',
+      args: [path.join(aliasDir, 'tool', 'cli.mjs')],
+      cwd: aliasDir,
+      inputMode: 'json-stdin',
+      outputMode: 'json',
+    },
+    guide: { kind: 'skill', path: path.join(aliasDir, 'tool', 'SKILL.md') },
+  });
+
+  const { bundle } = createBundle({ appIds: [app.id], toolIds: ['appbound.alias.tool'] });
+  const toolEntry = bundle.tools.find((tool) => tool.id === 'appbound.alias.tool');
+  const bindings = toolEntry.appPathBindings;
+  assert.equal(Array.isArray(bindings), true);
+  const byLabel = Object.fromEntries(bindings.map((binding) => [binding.path.join('.'), binding]));
+  assert.deepEqual(byLabel['source.cwd'], { appId: app.id, path: ['source', 'cwd'], relative: '' });
+  assert.deepEqual(byLabel['source.args.0'], { appId: app.id, path: ['source', 'args', 0], relative: 'tool/cli.mjs' });
+  assert.deepEqual(byLabel['guide.path'], { appId: app.id, path: ['guide', 'path'], relative: 'tool/SKILL.md' });
+  assert.equal(bundle.requires.bindings.some((entry) => entry.includes('appbound.alias.tool')), false);
+});
+
+test('installBundle defaults app materialization to the owned apps root', async () => {
+  const appDir = makeTempDir('bundle-appsroot-src-');
+  fs.writeFileSync(path.join(appDir, 'package.json'), JSON.stringify({ name: 'appsroot' }));
+  fs.writeFileSync(path.join(appDir, 'server.js'), 'console.log("serve");\n');
+  const app = registerSampleApp(appDir, {
+    id: 'app-appsroot-test',
+    name: 'Apps Root',
+    appRef: 'appsrootref01',
+    startCommand: 'PORT={port} node server.js',
+  });
+
+  const { bundle } = createBundle({ appIds: [app.id] });
+  const result = await installBundle(JSON.parse(JSON.stringify(bundle)), {
+    registerApp: async (input) => ({ id: 'app-installed-appsroot', ...input, status: 'running' }),
+  });
+
+  const expectedRoot = path.join(process.env.AMALGM_DIR, 'apps');
+  assert.equal(result.installedApps[0].cwd.startsWith(expectedRoot), true);
+  assert.equal(fs.existsSync(path.join(result.installedApps[0].cwd, 'server.js')), true);
+});

package/runtime/scripts/lib/project-paths.js

@@ -22,7 +22,7 @@ function isWithin(root, target) {
 }
 
 function legacyWorkspaceRoots() {
-  const home = process.env.AMALGM_HOME || path.join(os.homedir(), '.amalgm');
+  const home = require('../amalgm-mcp/lib/layout').resolveAmalgmHome(process.env);
   return [
     process.env.AMALGM_LEGACY_WORKSPACES_DIR,
     path.join(home, 'workspaces'),
@@ -33,7 +33,7 @@ function legacyWorkspaceRoots() {
 }
 
 function workspaceRootPaths() {
-  const home = process.env.AMALGM_HOME || path.join(os.homedir(), '.amalgm');
+  const home = require('../amalgm-mcp/lib/layout').resolveAmalgmHome(process.env);
   const stateRoot = process.env.AMALGM_DIR;
   return [
     process.env.AMALGM_WORKSPACES_DIR,

package/runtime/scripts/lib/runtime-paths.js

@@ -11,7 +11,7 @@ function normalizeRuntimeLabel(value) {
 }
 
 function amalgmDir() {
-  return process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+  return process.env.AMALGM_DIR || require('../amalgm-mcp/lib/layout').resolveAmalgmHome(process.env);
 }
 
 function runtimeLabel() {