feat: wire the sambar bin entry to dispatch run and build a macOS app bundle

Author: ipfizz

package.json

@@ -13,6 +13,9 @@
     "url": "https://github.com/indrajeetor/sambar/issues"
   },
   "type": "module",
+  "bin": {
+    "sambar": "./src/cli/index.ts"
+  },
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {

src/cli/index.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+/**
+ * The `sambar` command-line interface: `run`, `build`, `--help`, `--version`.
+ *
+ * This is the user-facing build/launch tool, not a runtime module — it uses
+ * Bun/Node filesystem and process APIs only. Output goes through
+ * `process.stdout`/`process.stderr` because Biome bans `console.*`.
+ */
+
+import { buildMacApp } from './build-macos';
+import { type Command, parseArgs } from './parse-args';
+import { runApp } from './run';
+import { currentPlatform } from '../common/platform';
+import { SAMBAR_VERSION } from '../common/version';
+
+const out = (text: string): void => {
+  process.stdout.write(`${text}\n`);
+};
+
+const err = (text: string): void => {
+  process.stderr.write(`${text}\n`);
+};
+
+const USAGE = `sambar ${SAMBAR_VERSION}
+
+Usage:
+  sambar run <entry.ts> [args...]      Launch a Sambar app (bun run <entry>)
+  sambar build <entry.ts> [options]    Bundle a distributable app
+  sambar --help                        Show this help
+  sambar --version                     Print the Sambar version
+
+build options:
+  --name <Name>      Display/bundle name (default: derived from <entry>)
+  --id <bundle.id>   Bundle identifier (default: com.sambar.<name-slug>)
+  --out <dir>        Output directory (default: current directory)
+  --icon <path.icns> App icon (.icns)
+
+Currently 'sambar build' produces a macOS .app on macOS hosts.`;
+
+/** Derive a default app name from the entry path's base file name. */
+const deriveName = (entry: string): string => {
+  const base = entry.split(/[\\/]/).pop() ?? entry;
+  const stem = base.replace(/\.[^.]+$/, '');
+  return stem.length > 0 ? stem : 'SambarApp';
+};
+
+const runBuild = async (command: Extract<Command, { kind: 'build' }>): Promise<number> => {
+  if (currentPlatform() !== 'macos') {
+    err(
+      `sambar build: not yet supported on ${currentPlatform()} (macOS .app is the only target today).`,
+    );
+    return 1;
+  }
+  const name = command.options.name ?? deriveName(command.entry);
+  const appPath = await buildMacApp({
+    entry: command.entry,
+    name,
+    ...(command.options.id !== undefined ? { id: command.options.id } : {}),
+    ...(command.options.out !== undefined ? { out: command.options.out } : {}),
+    ...(command.options.icon !== undefined ? { icon: command.options.icon } : {}),
+  });
+  out(appPath);
+  return 0;
+};
+
+/** Execute a parsed {@link Command} and resolve to the process exit code. */
+export const dispatch = async (command: Command): Promise<number> => {
+  switch (command.kind) {
+    case 'help':
+      out(USAGE);
+      return 0;
+    case 'version':
+      out(SAMBAR_VERSION);
+      return 0;
+    case 'run':
+      return await runApp(command.entry, command.args);
+    case 'build':
+      return await runBuild(command);
+    case 'error':
+      err(command.message);
+      err('');
+      err(USAGE);
+      return 1;
+  }
+};
+
+const main = async (): Promise<void> => {
+  const command = parseArgs(process.argv.slice(2));
+  process.exit(await dispatch(command));
+};
+
+// Only auto-run when invoked as the CLI entry, never on import (e.g. in tests).
+if (import.meta.main) {
+  await main();
+}

tests/integration/macos/cli-build.test.ts

@@ -0,0 +1,75 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildMacApp } from '../../../src/cli/build-macos';
+import { currentPlatform } from '../../../src/common/platform';
+import { SAMBAR_VERSION } from '../../../src/common/version';
+
+/**
+ * Integration test for the macOS `.app` bundler. It writes a trivial entry
+ * (not a real Sambar app — the bundler only packages it), compiles it with
+ * `bun build --compile`, lays out the `.app`, then asserts the on-disk
+ * structure. The produced binary is exec'd to confirm it actually runs.
+ */
+if (currentPlatform() === 'macos') {
+  describe('buildMacApp (integration)', () => {
+    let workDir: string;
+    let entry: string;
+    let outDir: string;
+    const name = 'Hi App';
+
+    beforeAll(() => {
+      workDir = mkdtempSync(join(tmpdir(), 'sambar-cli-build-'));
+      entry = join(workDir, 'entry.ts');
+      outDir = join(workDir, 'out');
+      writeFileSync(entry, "console.log('hi');\nprocess.exit(0);\n");
+    });
+
+    afterAll(() => {
+      rmSync(workDir, { recursive: true, force: true });
+    });
+
+    test('produces a structurally valid .app from a trivial entry', async () => {
+      const appPath = await buildMacApp({
+        entry,
+        name,
+        id: 'com.example.hi',
+        out: outDir,
+      });
+
+      expect(appPath).toBe(join(outDir, `${name}.app`));
+      expect(existsSync(appPath)).toBe(true);
+
+      const infoPlist = join(appPath, 'Contents', 'Info.plist');
+      expect(existsSync(infoPlist)).toBe(true);
+      const plistText = readFileSync(infoPlist, 'utf8');
+      expect(plistText).toContain('<key>CFBundleIdentifier</key>');
+      expect(plistText).toContain('com.example.hi');
+      expect(plistText).toContain(name);
+      expect(plistText).toContain(SAMBAR_VERSION);
+
+      const exe = join(appPath, 'Contents', 'MacOS', name);
+      expect(existsSync(exe)).toBe(true);
+      const mode = statSync(exe).mode;
+      // Executable bit set for owner/group/other.
+      expect(mode & 0o111).not.toBe(0);
+
+      // The compiled binary should actually run and print 'hi'.
+      const result = spawnSync(exe, [], { encoding: 'utf8' });
+      expect(result.status).toBe(0);
+      expect(result.stdout).toContain('hi');
+    }, 30000);
+
+    test('defaults the bundle id from the name when --id is omitted', async () => {
+      const appPath = await buildMacApp({
+        entry,
+        name: 'Defaulted',
+        out: join(workDir, 'out2'),
+      });
+      const plistText = readFileSync(join(appPath, 'Contents', 'Info.plist'), 'utf8');
+      expect(plistText).toContain('com.sambar.defaulted');
+    }, 30000);
+  });
+}