gambi 0.2.3 → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arthur BM
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1,12 @@
-# `gambi`
+# Gambi CLI
+
+This directory is the source workspace for the Gambi CLI.
+
+Releases publish the CLI through a generated distribution:
+
+- `gambi`: public wrapper package
+- `gambi-<os>-<arch>`: platform-specific binary packages
+
+The source workspace itself is `private` and is not published directly to npm.
+
+For user-facing installation instructions, see the root `README.md` and `https://gambi.sh`.

package/bin/gambi

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+const childProcess = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const PLATFORM_MAP = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+
+const ARCH_MAP = {
+  arm64: "arm64",
+  x64: "x64",
+};
+
+function run(target) {
+  const result = childProcess.spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+    windowsHide: false,
+  });
+
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+
+  const code = typeof result.status === "number" ? result.status : 1;
+  process.exit(code);
+}
+
+function getCandidates() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+
+  if (!platform || !arch) {
+    return [];
+  }
+
+  return [`gambi-${platform}-${arch}`];
+}
+
+function getBinaryName() {
+  return process.platform === "win32" ? "gambi.exe" : "gambi";
+}
+
+function tryPath(candidate) {
+  return fs.existsSync(candidate) ? candidate : undefined;
+}
+
+function resolveViaRequire(packageName) {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageDir = path.dirname(packageJsonPath);
+    return tryPath(path.join(packageDir, "bin", getBinaryName()));
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveViaNodeModules(startDir, packageNames) {
+  let current = startDir;
+
+  for (;;) {
+    const modulesDir = path.join(current, "node_modules");
+    for (const packageName of packageNames) {
+      const resolved = tryPath(
+        path.join(modulesDir, packageName, "bin", getBinaryName())
+      );
+      if (resolved) {
+        return resolved;
+      }
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+
+function resolveViaSiblingPackages(scriptDir, packageNames) {
+  const npmDistDir = path.resolve(scriptDir, "..", "..");
+
+  for (const packageName of packageNames) {
+    const resolved = tryPath(
+      path.join(npmDistDir, packageName, "bin", getBinaryName())
+    );
+    if (resolved) {
+      return resolved;
+    }
+  }
+
+  return undefined;
+}
+
+const overridePath = process.env.GAMBI_BIN_PATH;
+if (overridePath) {
+  run(overridePath);
+}
+
+const scriptPath = fs.realpathSync(__filename);
+const scriptDir = path.dirname(scriptPath);
+const cachedBinary = path.join(
+  scriptDir,
+  process.platform === "win32" ? ".gambi.exe" : ".gambi"
+);
+if (fs.existsSync(cachedBinary)) {
+  run(cachedBinary);
+}
+
+const packageNames = getCandidates();
+if (packageNames.length === 0) {
+  console.error(
+    `Gambi does not ship a packaged binary for ${process.platform}/${process.arch} yet.`,
+  );
+  process.exit(1);
+}
+
+const resolved =
+  packageNames.map(resolveViaRequire).find(Boolean) ||
+  resolveViaSiblingPackages(scriptDir, packageNames) ||
+  resolveViaNodeModules(scriptDir, packageNames);
+
+if (!resolved) {
+  console.error(
+    "Gambi could not find a compatible platform binary. Expected one of: " +
+      packageNames.map((name) => `"${name}"`).join(" or "),
+  );
+  process.exit(1);
+}
+
+run(resolved);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gambi",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "CLI for Gambi - Share local LLMs across your network",
   "keywords": [
     "llm",
@@ -22,37 +22,18 @@
   },
   "homepage": "https://github.com/arthurbm/gambi",
   "bugs": "https://github.com/arthurbm/gambi/issues",
-  "type": "module",
   "bin": {
-    "gambi": "./src/cli.ts"
+    "gambi": "./bin/gambi"
   },
-  "exports": {
-    "./serve": "./src/commands/serve.ts",
-    "./create": "./src/commands/create.ts",
-    "./join": "./src/commands/join.ts",
-    "./list": "./src/commands/list.ts",
-    "./monitor": "./src/commands/monitor.ts"
-  },
-  "files": [
-    "src",
-    "README.md"
-  ],
   "scripts": {
-    "dev": "bun run src/cli.ts",
-    "build": "bun run build.ts",
-    "check-types": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@clack/prompts": "^1.1.0",
-    "@gambi/core": "workspace:*",
-    "clipanion": "^4.0.0-rc.4",
-    "nanoid": "^5.1.5"
-  },
-  "devDependencies": {
-    "@types/bun": "latest"
+    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
   },
-  "peerDependencies": {
-    "typescript": "^5"
+  "optionalDependencies": {
+    "gambi-linux-x64": "0.3.1",
+    "gambi-linux-arm64": "0.3.1",
+    "gambi-darwin-arm64": "0.3.1",
+    "gambi-darwin-x64": "0.3.1",
+    "gambi-windows-x64": "0.3.1"
   },
   "publishConfig": {
     "access": "public"

package/postinstall.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const wrapperDir = path.resolve(__dirname, "..");
+const wrapperBinDir = path.join(wrapperDir, "bin");
+
+function detectPackageName() {
+  const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+  };
+  const archMap = {
+    arm64: "arm64",
+    x64: "x64",
+  };
+
+  const platform = platformMap[os.platform()];
+  const arch = archMap[os.arch()];
+
+  if (!(platform && arch)) {
+    return undefined;
+  }
+
+  return `gambi-${platform}-${arch}`;
+}
+
+function findBinary(packageName) {
+  const packageJsonPath = require.resolve(`${packageName}/package.json`);
+  const packageDir = path.dirname(packageJsonPath);
+  const binaryName = os.platform() === "win32" ? "gambi.exe" : "gambi";
+  const binaryPath = path.join(packageDir, "bin", binaryName);
+
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Binary not found at ${binaryPath}`);
+  }
+
+  return binaryPath;
+}
+
+function main() {
+  const packageName = detectPackageName();
+  if (!packageName) {
+    console.warn(
+      `[gambi] No packaged binary is available for ${os.platform()}/${os.arch()}.`
+    );
+    return;
+  }
+
+  try {
+    const binaryPath = findBinary(packageName);
+    const cachePath = path.join(
+      wrapperBinDir,
+      os.platform() === "win32" ? ".gambi.exe" : ".gambi"
+    );
+
+    fs.mkdirSync(wrapperBinDir, { recursive: true });
+    if (fs.existsSync(cachePath)) {
+      fs.unlinkSync(cachePath);
+    }
+
+    if (os.platform() === "win32") {
+      fs.copyFileSync(binaryPath, cachePath);
+    } else {
+      try {
+        fs.linkSync(binaryPath, cachePath);
+      } catch {
+        fs.copyFileSync(binaryPath, cachePath);
+      }
+      fs.chmodSync(cachePath, 0o755);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[gambi] Failed to cache the platform binary: ${message}`);
+  }
+}
+
+main();

package/src/cli.ts

@@ -1,32 +0,0 @@
-#!/usr/bin/env bun
-import { Builtins, Cli } from "./utils/option.ts";
-import { CreateCommand } from "./commands/create.ts";
-import { JoinCommand } from "./commands/join.ts";
-import { ListCommand } from "./commands/list.ts";
-import { MonitorCommand } from "./commands/monitor.ts";
-import { ServeCommand } from "./commands/serve.ts";
-
-const cli = new Cli({
-  binaryLabel: "gambi",
-  binaryName: "gambi",
-  binaryVersion: "0.0.1",
-});
-
-cli.register(ServeCommand);
-cli.register(CreateCommand);
-cli.register(JoinCommand);
-cli.register(ListCommand);
-cli.register(MonitorCommand);
-cli.register(Builtins.HelpCommand);
-cli.register(Builtins.VersionCommand);
-
-// TODO: Re-add TUI support as a separate optional package.
-// Previously, running `gambi` with no args launched the TUI,
-// but bundling OpenTUI + React inflated the binary from ~50MB to ~110MB.
-// See: https://github.com/arthurbm/gambi/issues — create issue for TUI separation
-const args = process.argv.slice(2);
-if (args.length === 0) {
-  cli.runExit(["--help"]);
-} else {
-  cli.runExit(args);
-}

package/src/commands/create.ts

@@ -1,160 +0,0 @@
-import { intro, outro, password as passwordPrompt, text } from "@clack/prompts";
-import { Command, Option } from "../utils/option.ts";
-import { handleCancel, isInteractive } from "../utils/prompt.ts";
-import {
-  hasRuntimeConfig,
-  loadRuntimeConfigFile,
-  promptRuntimeConfig,
-} from "../utils/runtime-config.ts";
-
-interface CreateRoomResponse {
-  room: {
-    id: string;
-    code: string;
-    name: string;
-    hostId: string;
-    createdAt: number;
-  };
-  hostId: string;
-}
-
-interface ErrorResponse {
-  error: string;
-}
-
-export class CreateCommand extends Command {
-  static override paths = [["create"]];
-
-  static override usage = Command.Usage({
-    description: "Create a new room on a hub",
-    examples: [
-      ["Create a room (interactive)", "gambi create"],
-      ["Create a room", "gambi create --name 'My Room'"],
-      [
-        "Create on custom hub",
-        "gambi create --name 'My Room' --hub http://192.168.1.10:3000",
-      ],
-      [
-        "Create a password-protected room",
-        "gambi create --name 'My Room' --password secret123",
-      ],
-    ],
-  });
-
-  name = Option.String("--name,-n", {
-    description: "Room name",
-    required: false,
-  });
-
-  password = Option.String("--password,-p", {
-    description: "Optional password to protect the room",
-    required: false,
-  });
-
-  configPath = Option.String("--config", {
-    description: "Path to a JSON file with room defaults",
-    required: false,
-  });
-
-  hub = Option.String("--hub,-H", "http://localhost:3000", {
-    description: "Hub URL",
-  });
-
-  async execute(): Promise<number> {
-    let name = this.name;
-    let password = this.password;
-    let defaults = this.configPath
-      ? await loadRuntimeConfigFile(this.configPath).catch((error) => {
-          this.context.stderr.write(`${error}\n`);
-          return null;
-        })
-      : {};
-
-    if (defaults === null) {
-      return 1;
-    }
-
-    if (!name && isInteractive()) {
-      intro("gambi create");
-
-      const nameResult = await text({
-        message: "Room name:",
-        validate: (v) => (v ? undefined : "Room name is required"),
-      });
-      handleCancel(nameResult);
-      name = nameResult as string;
-
-      if (password === undefined) {
-        const passwordResult = await passwordPrompt({
-          message: "Room password (leave empty for no password):",
-        });
-        handleCancel(passwordResult);
-        const pwd = passwordResult as string;
-        if (pwd) {
-          password = pwd;
-        }
-      }
-
-      try {
-        defaults = await promptRuntimeConfig("room", defaults);
-      } catch (error) {
-        this.context.stderr.write(`${error}\n`);
-        return 1;
-      }
-    } else if (!name) {
-      this.context.stderr.write(
-        "Error: --name is required (or run in a terminal for interactive mode)\n"
-      );
-      return 1;
-    }
-
-    try {
-      const body: {
-        defaults?: typeof defaults;
-        name: string;
-        password?: string;
-      } = { name };
-      if (password) {
-        body.password = password;
-      }
-      if (hasRuntimeConfig(defaults)) {
-        body.defaults = defaults;
-      }
-
-      const response = await fetch(`${this.hub}/rooms`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-      });
-
-      if (!response.ok) {
-        const data = (await response.json()) as ErrorResponse;
-        this.context.stderr.write(`Error: ${data.error}\n`);
-        return 1;
-      }
-
-      const data = (await response.json()) as CreateRoomResponse;
-
-      const successMsg = [
-        "Room created!",
-        `  Code: ${data.room.code}`,
-        `  ID: ${data.room.id}`,
-        ...(password ? ["  Protection: Password-protected"] : []),
-        "",
-        "Share the code with participants to join.",
-      ].join("\n");
-
-      if (isInteractive() && !this.name) {
-        outro(successMsg);
-      } else {
-        this.context.stdout.write(`${successMsg}\n`);
-      }
-
-      return 0;
-    } catch (err) {
-      this.context.stderr.write(`Failed to connect to hub at ${this.hub}\n`);
-      this.context.stderr.write(`${err}\n`);
-      return 1;
-    }
-  }
-}