amalgm 0.1.153 → 0.1.154

package/runtime/scripts/amalgm-mcp/tests/apps-portable.test.js

@@ -0,0 +1,127 @@
+'use strict';
+
+process.env.AMALGM_DIR = require('node:fs').mkdtempSync(
+  require('node:path').join(require('node:os').tmpdir(), 'amalgm-apps-portable-'),
+);
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const net = require('node:net');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+
+const { APP_MANIFEST_FILE } = require('../apps/manifest');
+const { inspectPortableApp, packPortableApp } = require('../apps/portable');
+const { loadApps } = require('../apps/store');
+const { deleteApp, registerApp } = require('../apps/supervisor');
+
+function makeApp() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-portable-app-'));
+  fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'data'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'src', 'server.js'), [
+    "const http = require('http');",
+    "http.createServer((_request, response) => response.end('ok')).listen(Number(process.env.PORT), '0.0.0.0');",
+    '',
+  ].join('\n'));
+  fs.writeFileSync(path.join(dir, 'data', 'private.json'), '{"user":"state"}\n');
+  fs.writeFileSync(path.join(dir, '.env'), 'SECRET=never-share\n');
+  return dir;
+}
+
+function writeManifest(dir, overrides = {}) {
+  const manifest = {
+    schemaVersion: 1,
+    name: 'Portable Test App',
+    description: 'Exercises the portable app boundary',
+    buildCommand: null,
+    startCommand: 'node src/server.js',
+    toolIds: ['portable.test-tool'],
+    package: {
+      include: ['src/**'],
+      exclude: [],
+    },
+    ...overrides,
+  };
+  fs.writeFileSync(path.join(dir, APP_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\n`);
+  return manifest;
+}
+
+async function availablePort() {
+  const server = net.createServer();
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const port = server.address().port;
+  await new Promise((resolve) => server.close(resolve));
+  return port;
+}
+
+test('portable package uses the manifest allowlist and always carries the manifest', () => {
+  const dir = makeApp();
+  writeManifest(dir);
+
+  const packed = packPortableApp(dir);
+  assert.deepEqual(packed.files.map((file) => file.path), [APP_MANIFEST_FILE, 'src/server.js']);
+  assert.equal(packed.files.some((file) => file.path === 'data/private.json'), false);
+  assert.equal(packed.files.some((file) => file.path === '.env'), false);
+  assert.deepEqual(packed.manifest.toolIds, ['portable.test-tool']);
+});
+
+test('portable package rejects invalid manifests and stale include patterns', () => {
+  const dir = makeApp();
+  writeManifest(dir, { package: { include: ['missing/**'], exclude: [] } });
+  assert.throws(() => inspectPortableApp(dir), /pattern matched no files: missing\/\*\*/);
+
+  writeManifest(dir, { package: { include: ['src/**'], exclude: [APP_MANIFEST_FILE] } });
+  assert.throws(() => inspectPortableApp(dir), /cannot be excluded/);
+
+  writeManifest(dir, { schemaVersion: 99 });
+  assert.throws(() => inspectPortableApp(dir), /schemaVersion must be 1/);
+});
+
+test('portable package reports selected symlinks without following them', () => {
+  const dir = makeApp();
+  const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-portable-outside-'));
+  fs.writeFileSync(path.join(outside, 'secret.txt'), 'outside\n');
+  fs.symlinkSync(outside, path.join(dir, 'linked'), 'dir');
+  writeManifest(dir, { package: { include: ['src/**', 'linked/**'], exclude: [] } });
+
+  const packed = packPortableApp(dir);
+  assert.equal(packed.files.some((file) => file.path.includes('secret.txt')), false);
+  assert.deepEqual(packed.excluded.find((entry) => entry.path === 'linked'), {
+    path: 'linked',
+    reason: 'symlink',
+  });
+});
+
+test('registration rejects non-manifest inputs before persisting an app', async () => {
+  const dir = makeApp();
+  await assert.rejects(() => registerApp({ cwd: dir }), /amalgm\.app\.json is required/);
+  assert.equal(loadApps().apps.length, 0);
+
+  writeManifest(dir);
+  await assert.rejects(
+    () => registerApp({ cwd: dir, start_command: 'node src/server.js' }),
+    /reads start_command from amalgm\.app\.json/,
+  );
+  assert.equal(loadApps().apps.length, 0);
+});
+
+test('registration validates once, stores manifest values, and starts the app', async () => {
+  const dir = makeApp();
+  writeManifest(dir);
+
+  const app = await registerApp({ cwd: dir, port: await availablePort(), connect_dns: false });
+  try {
+    assert.equal(app.name, 'Portable Test App');
+    assert.equal(app.startCommand, 'node src/server.js');
+    assert.deepEqual(app.toolIds, ['portable.test-tool']);
+    assert.equal(app.status, 'running');
+    assert.equal(app.dnsConnected, false);
+  } finally {
+    await deleteApp(app.id);
+  }
+});

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

@@ -12,9 +12,9 @@ const test = require('node:test');
 
 const { createAutomation, getAutomation, listAutomations } = require('../automations/store');
 const { loadApps, saveApps } = require('../apps/store');
+const { inspectPortableApp, packPortableApp, unpackAppFiles } = require('../apps/portable');
 const { exportAutomationEntry, installAutomationEntry } = require('../agent-bundles/automation-entries');
 const { exportAppEntry, materializeAppEntry } = require('../agent-bundles/app-entries');
-const { packAppFiles, unpackAppFiles } = require('../agent-bundles/app-files');
 const { createBundle, installBundle, validateBundle } = require('../agent-bundles/bundles');
 
 function makeTempDir(prefix) {
@@ -32,19 +32,49 @@ function writeSampleApp(dir) {
   fs.writeFileSync(path.join(dir, '.git', 'HEAD'), 'ref: refs/heads/main\n');
   fs.writeFileSync(path.join(dir, 'logo.bin'), Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x00, 0x01, 0x02]));
   fs.writeFileSync(path.join(dir, 'run.sh'), '#!/bin/sh\necho run\n', { mode: 0o755 });
+  writeAppManifest(dir, { include: ['**'] });
+}
+
+function writeAppManifest(dir, overrides = {}) {
+  const include = overrides.include || fs.readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => !['amalgm.app.json', '.env', '.git', 'node_modules'].includes(entry.name))
+    .map((entry) => (entry.isDirectory() ? `${entry.name}/**` : entry.name));
+  const manifest = {
+    schemaVersion: 1,
+    name: overrides.name || 'Sample App',
+    description: overrides.description || 'A sample app',
+    buildCommand: Object.prototype.hasOwnProperty.call(overrides, 'buildCommand')
+      ? overrides.buildCommand
+      : 'npm install && npm run build',
+    startCommand: overrides.startCommand || 'npm run start -- --port {port}',
+    toolIds: overrides.toolIds || [],
+    package: { include, exclude: overrides.exclude || [] },
+  };
+  fs.writeFileSync(path.join(dir, 'amalgm.app.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+  return manifest;
 }
 
 function registerSampleApp(cwd, overrides = {}) {
+  const manifest = writeAppManifest(cwd, {
+    name: overrides.name,
+    description: overrides.description,
+    buildCommand: Object.prototype.hasOwnProperty.call(overrides, 'buildCommand')
+      ? overrides.buildCommand
+      : 'npm install && npm run build',
+    startCommand: overrides.startCommand,
+    toolIds: overrides.toolIds,
+  });
   const data = loadApps();
   const app = {
     id: 'app-sample-test',
     kind: 'app',
-    name: 'Sample App',
-    description: 'A sample app',
+    name: manifest.name,
+    description: manifest.description,
     cwd,
     port: 43210,
-    buildCommand: 'npm run build',
-    startCommand: 'npm run start -- --port {port}',
+    buildCommand: manifest.buildCommand,
+    startCommand: manifest.startCommand,
+    toolIds: manifest.toolIds,
     appRef: 'sampleref0001',
     publicUrl: 'https://sampleref0001.apps.amalgm.ai/',
     dnsConnected: true,
@@ -124,23 +154,23 @@ test('automation entry install rejects entries without workflow text', () => {
   );
 });
 
-test('app file packing excludes dependencies, env files, and vcs state', () => {
+test('portable app packaging follows the manifest and applies platform exclusions', () => {
   const dir = makeTempDir('bundle-app-src-');
   writeSampleApp(dir);
 
-  const packed = packAppFiles(dir);
+  const packed = packPortableApp(dir);
   const paths = packed.files.map((file) => file.path);
 
-  assert.deepEqual(paths, ['logo.bin', 'package.json', 'run.sh', 'src/index.js']);
+  assert.deepEqual(paths, ['amalgm.app.json', 'logo.bin', 'package.json', 'run.sh', 'src/index.js']);
   assert.equal(packed.files.find((file) => file.path === 'logo.bin').encoding, 'base64');
   assert.equal(packed.files.find((file) => file.path === 'run.sh').executable, true);
-  assert.equal(packed.skipped.some((item) => item.path === '.env'), true);
-  assert.equal(packed.skipped.some((item) => item.path === 'node_modules/'), true);
-  assert.equal(packed.skipped.some((item) => item.path === '.git/'), true);
+  assert.equal(packed.excluded.some((item) => item.path === '.env'), true);
+  assert.equal(packed.excluded.some((item) => item.path === 'node_modules/'), true);
+  assert.equal(packed.excluded.some((item) => item.path === '.git/'), true);
 
   const target = makeTempDir('bundle-app-dst-');
   const result = unpackAppFiles(packed.files, target);
-  assert.equal(result.written, 4);
+  assert.equal(result.written, 5);
   assert.equal(fs.readFileSync(path.join(target, 'src', 'index.js'), 'utf8'), 'console.log("hi");\n');
   assert.equal(fs.existsSync(path.join(target, '.env')), false);
   assert.equal(Boolean(fs.statSync(path.join(target, 'run.sh')).mode & 0o100), true);
@@ -154,7 +184,7 @@ test('unpacking rejects paths that escape the install directory', () => {
   const target = makeTempDir('bundle-app-escape-');
   assert.throws(
     () => unpackAppFiles([{ path: '../evil.txt', encoding: 'utf8', content: 'nope' }], target),
-    /escapes the install directory/,
+    /Invalid app file path/,
   );
 });
 
@@ -166,59 +196,38 @@ test('app entry export carries the portable record and install materializes a ru
   const { entry } = exportAppEntry(app.id);
   assert.equal(entry.app.name, 'Sample App');
   assert.equal(entry.app.startCommand, 'npm run start -- --port {port}');
-  assert.equal(entry.app.buildCommand, 'npm run build');
+  assert.equal(entry.app.buildCommand, 'npm install && npm run build');
+  assert.deepEqual(entry.manifest, inspectPortableApp(dir).manifest);
   assert.equal('cwd' in entry.app, false);
   assert.equal('port' in entry.app, false);
   assert.equal('appRef' in entry.app, false);
-  assert.equal(entry.files.length, 4);
+  assert.equal(entry.files.length, 5);
 
   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, 'npm install && npm run build');
+  assert.deepEqual(Object.keys(registerInput).sort(), ['autostart', 'cwd', 'keep_alive']);
   assert.equal(registerInput.cwd.startsWith(rootDir), true);
   assert.equal(fs.readFileSync(path.join(registerInput.cwd, 'package.json'), 'utf8'), JSON.stringify({ name: 'sample-app' }));
+  assert.deepEqual(inspectPortableApp(registerInput.cwd).manifest, entry.manifest);
 
   // A second install of the same entry gets its own directory.
   const secondInput = materializeAppEntry(entry, { rootDir });
   assert.notEqual(secondInput.cwd, registerInput.cwd);
 });
 
-test('materializeAppEntry bootstraps node dependencies for imported apps without duplicating install steps', () => {
+test('materializeAppEntry preserves explicit lifecycle commands without package-manager guessing', () => {
   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',
+    buildCommand: 'npm ci && 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');
+  const materialized = materializeAppEntry(buildEntry, { rootDir });
+  assert.equal(inspectPortableApp(materialized.cwd).manifest.buildCommand, 'npm ci && npm run build');
 });
 
 test('mixed bundle carries automations and apps with heads and installs everything', async () => {
@@ -254,9 +263,9 @@ test('mixed bundle carries automations and apps with heads and installs everythi
   assert.equal('content' in appElement.data.files[0], false);
   assert.equal(preview.automations.length, 1);
   assert.equal(preview.apps.length, 1);
-  assert.equal(preview.apps[0].files, 4);
-  assert.equal(bundle.apps[0].app.autostart, false);
-  assert.equal(bundle.apps[0].app.keepAlive, false);
+  assert.equal(preview.apps[0].files, 5);
+  assert.equal(bundle.apps[0].app.autostart, true);
+  assert.equal(bundle.apps[0].app.keepAlive, true);
 
   // Round-trip through JSON like the storage path does.
   const revived = JSON.parse(JSON.stringify(bundle));
@@ -294,6 +303,21 @@ test('legacy agent-only bundles still validate and empty bundles are rejected',
   );
 });
 
+test('bundle validation rejects duplicate canonical apps and manifest drift', () => {
+  const dir = makeTempDir('bundle-app-invariants-');
+  writeSampleApp(dir);
+  const app = registerSampleApp(dir, { id: 'app-invariant-test' });
+  const { bundle } = createBundle({ appIds: [app.id] });
+
+  const duplicated = JSON.parse(JSON.stringify(bundle));
+  duplicated.apps.push(JSON.parse(JSON.stringify(duplicated.apps[0])));
+  assert.throws(() => validateBundle(duplicated), /duplicate app id/);
+
+  const drifted = JSON.parse(JSON.stringify(bundle));
+  drifted.apps[0].manifest.name = 'Misleading name';
+  assert.throws(() => validateBundle(drifted), /manifest summary does not match/);
+});
+
 test('standalone tool bundle carries the tool as a head and installs it', async () => {
   const { defaultToolboxService } = require('../toolbox/service');
   defaultToolboxService.registerTool({
@@ -602,7 +626,7 @@ test('sharing an app pulls its owned tools, nested under the app in the graph',
       return { id: 'app-installed-owned', ...input, status: 'running' };
     },
   });
-  assert.deepEqual(registered[0].tool_ids, ['appowned.tool']);
+  assert.deepEqual(inspectPortableApp(registered[0].cwd).manifest.toolIds, ['appowned.tool']);
   const installedTool = result.installedTools.find((tool) => tool.id === 'appowned.tool');
   assert.equal(installedTool.appId, 'app-installed-owned');
   assert.equal(installedTool.source.cwd, result.installedApps[0].cwd);

package/runtime/scripts/amalgm-mcp/tests/platform-context.test.js

@@ -56,3 +56,18 @@ test('platform context teaches rich media embeds with GIF video previews', () =>
   assert.equal(text.includes('<name>.poster.png'), true);
   assert.equal(text.includes('≤20MB'), true);
 });
+
+test('platform context teaches the manifest-owned app registration boundary', () => {
+  const text = fs.readFileSync(CONTEXT_PATH, 'utf8');
+
+  for (const required of [
+    'amalgm.app.json',
+    '`apps_validate`',
+    'The manifest is the single source of truth',
+    '`package.include` is an allowlist',
+    'Amalgm does not guess a package manager',
+    'they are not portable and cannot be shared',
+  ]) {
+    assert.equal(text.includes(required), true, `platform context should include ${required}`);
+  }
+});

package/runtime/scripts/chat-core/tool-shape.js

@@ -113,7 +113,7 @@ function titleFromMcp(tool, input = {}) {
   if (action === 'record_stop') return 'Saving browser recording';
   if (action === 'record_list') return 'Listing browser recordings';
   if (action === 'auth_list') return 'Listing browser logins';
-  if (name === 'apps_register') return input.name ? `Registering app ${compactText(input.name, 60)}` : 'Registering app';
+  if (name === 'apps_register') return input.cwd ? `Registering app from ${compactText(input.cwd, 60)}` : 'Registering app';
   if (name === 'apps_start') return 'Starting app';
   if (name === 'apps_stop') return 'Stopping app';
   if (name === 'apps_list') return 'Listing apps';

package/runtime/scripts/platform-context.txt

@@ -54,30 +54,53 @@ Apps are **user-hosted services**. They run on the user's connected computer, no
 
 **Mental model:**
 - **App** — runs on user compute and is exposed on `https://{app_ref}.apps.amalgm.ai`
-- **App** — hyperscaler-hosted and lives on `*.apps.amalgm.ai`
 
 At the moment, the app flow is the one you can directly control from the MCP.
 
 **What an app requires:**
-1. It points to Amalgm app DNS.
-2. It must run as a production service. Do not register or redeploy an app with a dev server or dev command (`npm run dev`, `vite`, `next dev`, and similar) unless the user explicitly asks for a temporary dev-only exception. Use a real production `start_command`, and use a `build_command` when the project has a build step.
+1. Its project root contains a valid `amalgm.app.json`.
+2. It must run as a production service. Do not register or redeploy an app with a dev server or dev command (`npm run dev`, `vite`, `next dev`, and similar). Use a real production `startCommand` and a `buildCommand` when setup or compilation is required.
 3. It is registered locally so Amalgm knows to start it on boot and keep it alive while the computer is on.
 
+**Portable app manifest:**
+
+```json
+{
+  "schemaVersion": 1,
+  "name": "Design Canvas",
+  "description": "A local design workspace",
+  "buildCommand": "npm ci && npm run build",
+  "startCommand": "npm run start -- --host 0.0.0.0 --port {port}",
+  "toolIds": ["amalgm.design-canvas"],
+  "package": {
+    "include": ["package.json", "package-lock.json", "src/**", "public/**", "tool/**"],
+    "exclude": ["data/**", "exports/**"]
+  }
+}
+```
+
+The manifest is the single source of truth for portable app metadata, lifecycle commands, owned tools, and shared files. `package.include` is an allowlist; `package.exclude` subtracts from it. `amalgm.app.json` is always included automatically. Amalgm also excludes dependencies, VCS state, env files, credentials, logs, and symlinks. Put generated data and user content outside the include set. If a clean recipient needs dependencies, the declared `buildCommand` must install them; Amalgm does not guess a package manager.
+
+Create or update the manifest before registration, then call `apps_validate` and fix every error before `apps_register`. Do not pass name, description, build/start commands, or tool ids to registration; Apps reads them from the manifest. Existing legacy registrations without a manifest can keep running, but they are not portable and cannot be shared.
+
 **Tools:**
-- `apps_register` — Register an existing local project as an app. Stores the record in `~/.amalgm/apps.json`, starts it, and connects DNS by default.
+- `apps_validate` — Dry-run the exact package that registration and sharing use. Reports selected files, exclusions, and total bytes without mutating anything.
+- `apps_register` — Validate and register the manifest in an existing local project. Stores the record in `~/.amalgm/apps.json`, starts it, and connects DNS by default.
 - `apps_list` — List registered local apps.
 - `apps_routes` — Show app routes currently advertised by this computer.
 - `apps_start` — Start a stopped app with its production start command.
 - `apps_stop` — Stop a registered app and mark it intentionally stopped.
-- `apps_redeploy` — Update commands/port if needed, rerun the build command if configured, and restart the production process.
+- `apps_redeploy` — Reread and validate the manifest, update the app record, rerun `buildCommand`, and restart the production process. It can also update port/lifecycle settings.
 - `apps_connect_dns` — Reconnect an app to `*.apps.amalgm.ai` without changing the local registration.
 - `apps_disconnect_dns` — Remove public routing without deleting the app or stopping the local process.
 
 **How to think about app setup:**
 - Prefer using the user's existing project directory instead of generating a new framework wrapper.
-- If the project has a build step, require a real `build_command`.
-- Require a real production `start_command` that binds to `PORT` or `{port}`.
-- Do not use dev servers for apps by default. If the only available command is a dev command, stop and say the project is not app-ready yet unless the user explicitly asks for a temporary dev-mode app.
+- Create `amalgm.app.json` with the smallest explicit include set that makes a clean copy build and run.
+- If the project needs dependencies or a build step, declare the complete production `buildCommand`.
+- Require a real production `startCommand` that binds to `PORT` or `{port}`.
+- Do not use dev servers for apps. If the only available command is a dev command, stop and say the project is not app-ready yet.
+- Run `apps_validate` before `apps_register` and after changing the manifest.
 - If the framework needs an explicit host, `0.0.0.0` is a good default. The important thing is that the service reliably binds to the assigned port.
 - Random app refs are fine. Do not block on naming.
 
@@ -164,8 +187,8 @@ Don't just answer questions — **build systems**. If the user's need is ongoing
 
 Apps should be treated as **registered production services on user compute**, not as temporary dev servers.
 
-- Use `apps_register` only with a real production `start_command`.
-- Require a production `build_command` when the project supports one.
+- Use `apps_register` only after `apps_validate` succeeds.
+- Keep production `buildCommand` and `startCommand` in `amalgm.app.json`.
 - Reject `npm run dev`, `vite`, `next dev`, and similar dev-only commands for apps unless the user explicitly asks for a temporary exception.
 - Use `apps_redeploy` when code or commands change.
 - Use `apps_start` and `apps_stop` to control the registered service lifecycle.

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

@@ -1,160 +0,0 @@
-'use strict';
-
-/**
- * Pack and unpack an app's file tree for portable bundles.
- *
- * Files travel inline in the bundle JSON (utf8 or base64), so packing is
- * conservative: dependency dirs, VCS state, env files, and build outputs are
- * excluded — the recipient's install re-runs the app's build command — and
- * per-file/total size caps keep the bundle under the storage object limit.
- * Everything skipped is reported so the share UI can surface it.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024;
-const DEFAULT_MAX_TOTAL_BYTES = 12 * 1024 * 1024;
-
-const EXCLUDED_DIR_NAMES = new Set([
-  'node_modules',
-  '.git',
-  '.hg',
-  '.svn',
-  '.amalgm',
-  '.next',
-  '.nuxt',
-  '.turbo',
-  '.vercel',
-  '.cache',
-  '.parcel-cache',
-  '.venv',
-  'venv',
-  '__pycache__',
-  'dist',
-  'build',
-  'out',
-  'coverage',
-  'tmp',
-]);
-
-const EXCLUDED_FILE_NAMES = new Set([
-  '.DS_Store',
-  'Thumbs.db',
-  'npm-debug.log',
-  'yarn-error.log',
-]);
-
-function isExcludedFileName(name) {
-  if (EXCLUDED_FILE_NAMES.has(name)) return true;
-  // .env, .env.local, .env.production, … — never ship credentials.
-  if (name === '.env' || name.startsWith('.env.')) return true;
-  if (name.endsWith('.log')) return true;
-  return false;
-}
-
-function isBinary(buffer) {
-  const sample = buffer.subarray(0, 8192);
-  if (sample.includes(0)) return true;
-  return !buffer.equals(Buffer.from(buffer.toString('utf8'), 'utf8'));
-}
-
-function toPosixPath(relativePath) {
-  return relativePath.split(path.sep).join('/');
-}
-
-function packAppFiles(rootDir, options = {}) {
-  const root = path.resolve(rootDir);
-  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
-    throw new Error(`App directory not found: ${root}`);
-  }
-
-  const maxFileBytes = options.maxFileBytes || DEFAULT_MAX_FILE_BYTES;
-  const maxTotalBytes = options.maxTotalBytes || DEFAULT_MAX_TOTAL_BYTES;
-  const files = [];
-  const skipped = [];
-  let totalBytes = 0;
-
-  function visit(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true })
-      .sort((left, right) => left.name.localeCompare(right.name));
-    for (const dirent of entries) {
-      const absolute = path.join(dir, dirent.name);
-      const relative = toPosixPath(path.relative(root, absolute));
-
-      if (dirent.isSymbolicLink()) {
-        skipped.push({ path: relative, reason: 'symlink' });
-        continue;
-      }
-      if (dirent.isDirectory()) {
-        if (EXCLUDED_DIR_NAMES.has(dirent.name)) {
-          skipped.push({ path: `${relative}/`, reason: 'excluded' });
-          continue;
-        }
-        visit(absolute);
-        continue;
-      }
-      if (!dirent.isFile()) continue;
-      if (isExcludedFileName(dirent.name)) {
-        skipped.push({ path: relative, reason: 'excluded' });
-        continue;
-      }
-
-      const stat = fs.statSync(absolute);
-      if (stat.size > maxFileBytes) {
-        skipped.push({ path: relative, reason: 'file-too-large', size: stat.size });
-        continue;
-      }
-      if (totalBytes + stat.size > maxTotalBytes) {
-        skipped.push({ path: relative, reason: 'bundle-size-limit', size: stat.size });
-        continue;
-      }
-
-      const buffer = fs.readFileSync(absolute);
-      const binary = isBinary(buffer);
-      totalBytes += stat.size;
-      files.push({
-        path: relative,
-        encoding: binary ? 'base64' : 'utf8',
-        content: binary ? buffer.toString('base64') : buffer.toString('utf8'),
-        size: stat.size,
-        ...(stat.mode & 0o111 ? { executable: true } : {}),
-      });
-    }
-  }
-
-  visit(root);
-  return { files, totalBytes, skipped };
-}
-
-function assertInsideTarget(targetRoot, relativePath) {
-  const normalized = String(relativePath || '');
-  const resolved = path.resolve(targetRoot, normalized);
-  if (resolved !== targetRoot && !resolved.startsWith(targetRoot + path.sep)) {
-    throw new Error(`App file escapes the install directory: ${normalized}`);
-  }
-  return resolved;
-}
-
-function unpackAppFiles(files, targetDir) {
-  const targetRoot = path.resolve(targetDir);
-  fs.mkdirSync(targetRoot, { recursive: true });
-
-  let written = 0;
-  for (const file of Array.isArray(files) ? files : []) {
-    if (!file || typeof file.path !== 'string' || typeof file.content !== 'string') continue;
-    const destination = assertInsideTarget(targetRoot, file.path);
-    fs.mkdirSync(path.dirname(destination), { recursive: true });
-    const buffer = file.encoding === 'base64'
-      ? Buffer.from(file.content, 'base64')
-      : Buffer.from(file.content, 'utf8');
-    fs.writeFileSync(destination, buffer, { mode: file.executable ? 0o755 : 0o644 });
-    written += 1;
-  }
-  return { written, targetDir: targetRoot };
-}
-
-module.exports = {
-  packAppFiles,
-  unpackAppFiles,
-};