@malmhq/intermesh-cli 0.1.0

package/dist/generation/scripts/check-package.mjs

@@ -0,0 +1,45 @@
+import { spawnSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+
+const [packagePath, opencode] = process.argv.slice(2);
+const checks = [];
+for (const args of [
+  ['install', '--frozen-lockfile', '--ignore-scripts'],
+  ['check'],
+  ['test'],
+  ['build'],
+]) {
+  const result = spawnSync('pnpm', args, { cwd: packagePath, stdio: 'inherit', timeout: 120_000 });
+  checks.push({ command: `pnpm ${args.join(' ')}`, exit_code: result.status });
+  writeFileSync(
+    '.generation/starter-checks.json',
+    JSON.stringify({ passed: result.status === 0, checks }, null, 2),
+  );
+  if (result.status !== 0) process.exit(1);
+}
+function version(command) {
+  const result = spawnSync(command, ['--version'], { encoding: 'utf8', timeout: 30_000 });
+  if (result.status !== 0) {
+    const reason =
+      result.error?.message ??
+      result.signal ??
+      result.stderr.trim() ??
+      `exit ${String(result.status)}`;
+    throw new Error(`Environment check failed: ${command} (${reason})`);
+  }
+  return result.stdout.trim();
+}
+writeFileSync(
+  '.generation/environment.json',
+  JSON.stringify(
+    {
+      node: process.version,
+      pnpm: version('pnpm'),
+      opencode: version(opencode),
+      shell: process.env.SHELL,
+    },
+    null,
+    2,
+  ),
+  { flag: 'wx' },
+);

package/dist/generation/scripts/installed-help.mjs

@@ -0,0 +1,98 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+const execute = promisify(execFile);
+
+async function editableHash(directory, prefix = '') {
+  const hash = createHash('sha256');
+  for (const entry of (await readdir(directory, { withFileTypes: true })).sort((a, b) =>
+    a.name.localeCompare(b.name),
+  )) {
+    if (['dist', 'node_modules'].includes(entry.name)) continue;
+    const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) hash.update(await editableHash(path, relative));
+    else if (entry.isFile())
+      hash
+        .update(relative)
+        .update('\0')
+        .update(await readFile(path));
+  }
+  return hash.digest();
+}
+
+export async function createInstalledHelp(packageDirectory, receiptPath) {
+  const packagePath = resolve(packageDirectory);
+  const sourceHash = (await editableHash(packagePath)).toString('hex');
+  const pkg = JSON.parse(await readFile(join(packagePath, 'package.json'), 'utf8'));
+  const binary = Object.keys(pkg.bin ?? {})[0];
+  if (!binary) throw new TypeError('Package has no binary');
+  const manifest = JSON.parse(await readFile(join(packagePath, 'capabilities.json'), 'utf8'));
+  const commands = manifest.commands.map((item) => item.command);
+  const scratch = await mkdtemp(join(tmpdir(), 'intermesh-preliminary-help-'));
+  const environment = Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([name]) => !['OPENROUTER_API_KEY', 'DEEPSEEK_API_KEY'].includes(name),
+    ),
+  );
+  try {
+    await execute('pnpm', ['build'], { cwd: packagePath, env: environment, timeout: 120_000 });
+    const tarball = join(scratch, 'candidate.tgz');
+    await execute('pnpm', ['pack', '--out', tarball, '--json'], {
+      cwd: packagePath,
+      env: environment,
+      timeout: 120_000,
+    });
+    await writeFile(join(scratch, 'package.json'), '{"private":true}');
+    await execute('pnpm', ['add', '--ignore-scripts', tarball], {
+      cwd: scratch,
+      env: environment,
+      timeout: 120_000,
+    });
+    const executable = join(scratch, 'node_modules/.bin', binary);
+    const help = {};
+    for (const command of ['', ...commands]) {
+      const args = command ? [...command.split(/\s+/u), '--help'] : ['--help'];
+      const result = await execute(executable, args, {
+        cwd: scratch,
+        env: environment,
+        timeout: 30_000,
+      });
+      help[command || '$root'] = result.stdout;
+    }
+    const currentHash = (await editableHash(packagePath)).toString('hex');
+    if (currentHash !== sourceHash)
+      throw new TypeError('Editable package changed during installed-help capture');
+    const receipt = {
+      schema_version: '1.0.0',
+      editable_source_sha256: sourceHash,
+      binary,
+      commands,
+      help,
+      preliminary_only: true,
+    };
+    await writeFile(receiptPath, `${JSON.stringify(receipt, null, 2)}\n`, { flag: 'wx' });
+    return receipt;
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+}
+
+export async function verifyInstalledHelp(packageDirectory, receiptPath) {
+  const receipt = JSON.parse(await readFile(receiptPath, 'utf8'));
+  const currentHash = (await editableHash(resolve(packageDirectory))).toString('hex');
+  if (receipt.preliminary_only !== true || receipt.editable_source_sha256 !== currentHash)
+    throw new TypeError('Installed-help receipt does not match current editable source');
+  return receipt;
+}
+
+if (process.argv[1] === new URL(import.meta.url).pathname) {
+  const [command, packageDirectory, receiptPath] = process.argv.slice(2);
+  if (command === 'create') await createInstalledHelp(packageDirectory, receiptPath);
+  else if (command === 'verify') await verifyInstalledHelp(packageDirectory, receiptPath);
+  else throw new TypeError('Expected create or verify');
+}