bharatcode-cli 0.2.0

package/README.md

@@ -0,0 +1,56 @@
+# bharatcode
+
+> **OpenCode for India** — a Go-native, MIT-licensed, open-weight-first CLI coding agent. Your code stays in India.
+
+This is the npm distribution of [BharatCode](https://github.com/arbazkhan971/bharatcode). Installing it downloads the prebuilt native binary for your platform from GitHub Releases — there is no compilation step.
+
+## Install
+
+Global install (adds `bharatcode` to your PATH):
+
+```bash
+npm install -g bharatcode-cli
+```
+
+Or run it once without installing:
+
+```bash
+npx bharatcode-cli
+```
+
+Then:
+
+```bash
+bharatcode --help
+bharatcode version
+```
+
+## How it works
+
+On install, a `postinstall` script (`install.js`) detects your operating system and CPU architecture, downloads the matching release archive from `https://github.com/arbazkhan971/bharatcode/releases`, and extracts the `bharatcode` binary. The `bharatcode` command is a thin Node shim that execs that binary, passing through all arguments and exit codes.
+
+Supported platforms:
+
+| OS      | Architectures |
+| ------- | ------------- |
+| macOS   | arm64, x64    |
+| Linux   | arm64, x64    |
+| Windows | arm64, x64    |
+
+## Environment variables
+
+- `BHARATCODE_SKIP_DOWNLOAD=1` — skip the binary download during `npm install` (useful for air-gapped CI; you must place the binary in `bin/` yourself).
+
+## Troubleshooting
+
+If the postinstall download fails (e.g. no network during install), you can re-run it:
+
+```bash
+node node_modules/bharatcode/install.js
+```
+
+Or download the archive for your platform manually from the [Releases page](https://github.com/arbazkhan971/bharatcode/releases) and extract the `bharatcode` binary onto your PATH.
+
+## License
+
+MIT — see the [main repository](https://github.com/arbazkhan971/bharatcode).

package/bin/bharatcode.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Launcher shim for the BharatCode CLI.
+ *
+ * `npm install -g bharatcode` symlinks this file onto the user's PATH as
+ * `bharatcode`. It locates the platform binary that install.js downloaded into
+ * ./bharatcode (or ./bharatcode.exe on Windows), spawns it with the same argv
+ * and stdio, and exits with the binary's exit code.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// The real executable lives next to this shim, dropped here by install.js.
+const binName = process.platform === 'win32' ? 'bharatcode.exe' : 'bharatcode';
+const binPath = path.join(__dirname, binName);
+
+if (!fs.existsSync(binPath)) {
+  console.error(
+    `[bharatcode] The native binary is missing (expected at ${binPath}).\n` +
+      'The postinstall download may have failed. Try reinstalling:\n' +
+      '  npm install -g bharatcode\n' +
+      'or run the installer directly:\n' +
+      '  node ' + path.join(__dirname, '..', 'install.js') + '\n'
+  );
+  process.exit(1);
+}
+
+// Forward every argument after `node <shim>` and inherit stdio so the TUI,
+// prompts, and pipes all work transparently.
+const result = spawnSync(binPath, process.argv.slice(2), { stdio: 'inherit' });
+
+// Propagate signal-based termination as a conventional 128+signal code.
+if (result.signal) {
+  const signals = { SIGINT: 2, SIGTERM: 15, SIGHUP: 1, SIGQUIT: 3 };
+  process.exit(128 + (signals[result.signal] || 0));
+}
+
+// spawnSync sets .error (e.g. ENOENT/EACCES) if the binary couldn't run.
+if (result.error) {
+  console.error(`[bharatcode] Failed to launch binary: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status === null ? 1 : result.status);

package/install.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * BharatCode npm postinstall script.
+ *
+ * This runs automatically after `npm install -g bharatcode` (or `npx bharatcode`).
+ * It downloads the prebuilt binary matching the user's OS/arch from the
+ * corresponding GitHub Release and extracts it into ./bin/ next to the launcher
+ * shim (bin/bharatcode.js).
+ *
+ * Design constraints:
+ *   - No external dependencies. Only Node built-ins (https, fs, os, path,
+ *     child_process) plus the system `tar` (unix) / PowerShell (windows) for
+ *     archive extraction. This keeps the dependency tree at zero, which is the
+ *     same approach esbuild/Biome-class tools use.
+ *   - Fail loudly with an actionable message, and tell the user how to install
+ *     manually if the automated download cannot work (e.g. air-gapped CI).
+ *
+ * Asset naming (from .goreleaser.yaml):
+ *   bharatcode_{title Os}_{x86_64|arm64}.{tar.gz|zip}
+ *   e.g. bharatcode_Darwin_arm64.tar.gz, bharatcode_Windows_x86_64.zip
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const https = require('https');
+const { execFileSync } = require('child_process');
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const REPO = 'arbazkhan971/bharatcode';
+const pkg = require('./package.json');
+
+// The release tag is derived from the package version. GoReleaser tags releases
+// as `v<version>` (e.g. v0.1.0), so the published npm version MUST match a real
+// GitHub release tag for the download to succeed.
+const VERSION = pkg.version;
+const TAG = 'v' + VERSION;
+
+const BIN_DIR = path.join(__dirname, 'bin');
+// On Windows the real executable carries a .exe suffix; elsewhere it is bare.
+const BIN_NAME = process.platform === 'win32' ? 'bharatcode.exe' : 'bharatcode';
+const BIN_PATH = path.join(BIN_DIR, BIN_NAME);
+
+// ---------------------------------------------------------------------------
+// Platform -> GitHub asset mapping
+// ---------------------------------------------------------------------------
+
+// Maps Node's process.platform to the title-cased GOOS string GoReleaser uses.
+const PLATFORM_TO_OS = {
+  darwin: 'Darwin',
+  linux: 'Linux',
+  win32: 'Windows',
+};
+
+// Maps Node's process.arch to GoReleaser's arch token. GoReleaser rewrites
+// amd64 -> x86_64 and leaves arm64 as-is.
+const ARCH_TO_TOKEN = {
+  x64: 'x86_64',
+  arm64: 'arm64',
+};
+
+/**
+ * Build the GitHub asset filename for the current platform.
+ * Returns { asset, isZip } or throws if the platform is unsupported.
+ */
+function resolveAsset() {
+  const osName = PLATFORM_TO_OS[process.platform];
+  const archToken = ARCH_TO_TOKEN[process.arch];
+
+  if (!osName || !archToken) {
+    throw new Error(
+      `Unsupported platform: ${process.platform}/${process.arch}.\n` +
+        `BharatCode ships prebuilt binaries for: ` +
+        `darwin (x64, arm64), linux (x64, arm64), win32 (x64, arm64).\n` +
+        `If you need this platform, build from source: ` +
+        `https://github.com/${REPO}`
+    );
+  }
+
+  // Windows archives are .zip; everything else is .tar.gz (see .goreleaser.yaml).
+  const isZip = process.platform === 'win32';
+  const ext = isZip ? 'zip' : 'tar.gz';
+  const asset = `bharatcode_${osName}_${archToken}.${ext}`;
+  return { asset, isZip };
+}
+
+// ---------------------------------------------------------------------------
+// Download (follows redirects — GitHub release assets 302 to a CDN)
+// ---------------------------------------------------------------------------
+
+/**
+ * Download a URL to a local file, following up to `maxRedirects` redirects.
+ * Resolves when the file is fully written. Rejects on HTTP errors.
+ */
+function download(url, dest, maxRedirects = 10) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(
+      url,
+      {
+        headers: {
+          // Some networks/proxies reject requests without a User-Agent.
+          'User-Agent': `bharatcode-npm/${VERSION} (node ${process.version})`,
+          Accept: 'application/octet-stream',
+        },
+      },
+      (res) => {
+        const { statusCode, headers } = res;
+
+        // Follow redirects (GitHub serves assets from a redirected CDN URL).
+        if (statusCode >= 300 && statusCode < 400 && headers.location) {
+          res.resume(); // discard body so the socket can be reused
+          if (maxRedirects <= 0) {
+            reject(new Error(`Too many redirects while downloading ${url}`));
+            return;
+          }
+          const next = new URL(headers.location, url).toString();
+          resolve(download(next, dest, maxRedirects - 1));
+          return;
+        }
+
+        if (statusCode !== 200) {
+          res.resume();
+          reject(
+            new Error(
+              `Download failed: HTTP ${statusCode} for ${url}\n` +
+                `Make sure release ${TAG} exists and publishes that asset:\n` +
+                `  https://github.com/${REPO}/releases/tag/${TAG}`
+            )
+          );
+          return;
+        }
+
+        const file = fs.createWriteStream(dest);
+        res.pipe(file);
+        file.on('finish', () => file.close(() => resolve()));
+        file.on('error', (err) => {
+          fs.rm(dest, { force: true }, () => reject(err));
+        });
+      }
+    );
+
+    request.on('error', reject);
+    // Guard against a hung connection.
+    request.setTimeout(120000, () => {
+      request.destroy(new Error(`Timed out downloading ${url}`));
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Extraction (shells out to system tar / PowerShell — no JS tar dependency)
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the bharatcode binary from `archivePath` into BIN_DIR.
+ * Uses `tar` on unix and PowerShell's Expand-Archive on Windows.
+ */
+function extract(archivePath, isZip) {
+  if (isZip) {
+    // Expand-Archive unpacks the whole zip into BIN_DIR; the binary lands as
+    // bharatcode.exe at the archive root (the archive contains no nested dir).
+    execFileSync(
+      'powershell',
+      [
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        // -Force overwrites a stale copy from a previous install.
+        `Expand-Archive -LiteralPath '${archivePath}' -DestinationPath '${BIN_DIR}' -Force`,
+      ],
+      { stdio: 'inherit' }
+    );
+  } else {
+    // GNU/BSD tar both accept -xzf; extract directly into BIN_DIR.
+    execFileSync('tar', ['-xzf', archivePath, '-C', BIN_DIR], {
+      stdio: 'inherit',
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  // Allow CI/offline installs to skip the network step entirely.
+  if (process.env.BHARATCODE_SKIP_DOWNLOAD === '1') {
+    console.log('[bharatcode] BHARATCODE_SKIP_DOWNLOAD=1 set; skipping binary download.');
+    return;
+  }
+
+  const { asset, isZip } = resolveAsset();
+  const url = `https://github.com/${REPO}/releases/download/${TAG}/${asset}`;
+
+  fs.mkdirSync(BIN_DIR, { recursive: true });
+
+  // If a usable binary is already present (e.g. reinstall), skip the download.
+  if (fs.existsSync(BIN_PATH)) {
+    console.log(`[bharatcode] Binary already present at ${BIN_PATH}; skipping download.`);
+    return;
+  }
+
+  const tmpArchive = path.join(
+    os.tmpdir(),
+    `bharatcode-${VERSION}-${process.pid}-${asset}`
+  );
+
+  console.log(`[bharatcode] Downloading ${asset} (${TAG}) for ${process.platform}/${process.arch}...`);
+
+  try {
+    await download(url, tmpArchive);
+    console.log('[bharatcode] Extracting binary...');
+    extract(tmpArchive, isZip);
+
+    if (!fs.existsSync(BIN_PATH)) {
+      throw new Error(
+        `Extraction completed but ${BIN_NAME} was not found in ${BIN_DIR}.\n` +
+          `The release archive layout may have changed.`
+      );
+    }
+
+    // Ensure the binary is executable on unix (tar usually preserves the bit,
+    // but make it explicit so the shim can spawn it).
+    if (process.platform !== 'win32') {
+      fs.chmodSync(BIN_PATH, 0o755);
+    }
+
+    console.log(`[bharatcode] Installed ${BIN_NAME} -> ${BIN_PATH}`);
+  } catch (err) {
+    console.error('\n[bharatcode] Installation failed.');
+    console.error(err.message || err);
+    console.error(
+      '\nYou can install manually instead:\n' +
+        `  1. Download the right archive from https://github.com/${REPO}/releases/tag/${TAG}\n` +
+        `  2. Extract the 'bharatcode' binary onto your PATH.\n` +
+        'Or build from source with Go: ' +
+        `https://github.com/${REPO}\n`
+    );
+    process.exit(1);
+  } finally {
+    fs.rm(tmpArchive, { force: true }, () => {});
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "bharatcode-cli",
+  "version": "0.2.0",
+  "description": "BharatCode \u2014 an open, sovereign terminal coding agent. OpenCode for India. This npm package downloads the correct prebuilt binary for your platform from GitHub Releases.",
+  "keywords": [
+    "bharatcode",
+    "cli",
+    "coding-agent",
+    "ai",
+    "terminal",
+    "tui",
+    "llm"
+  ],
+  "homepage": "https://github.com/arbazkhan971/bharatcode#readme",
+  "bugs": {
+    "url": "https://github.com/arbazkhan971/bharatcode/issues"
+  },
+  "license": "MIT",
+  "author": "Arbaz",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arbazkhan971/bharatcode.git",
+    "directory": "npm"
+  },
+  "bin": {
+    "bharatcode": "bin/bharatcode.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "files": [
+    "bin/bharatcode.js",
+    "install.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}