@sodapop-sh/cli 0.1.0-rc.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sodapop contributors
+
+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

@@ -0,0 +1,35 @@
+# `@sodapop-sh/cli`
+
+The npm launcher for [Sodapop](https://sodapop.sh), a terminal
+application backed by the official GitHub Copilot SDK.
+
+After the corresponding packages are published, install with
+`npm install --global @sodapop-sh/cli` and run `sodapop`.
+
+The package installs an exact-version native payload through an
+OS/architecture-specific optional dependency. It does not download executables
+from a release URL at installation or first run. Available targets are declared
+by this package's release metadata:
+
+- macOS on Apple silicon or Intel
+- glibc-based Linux on arm64 or amd64
+- Windows x64, only in releases with a qualified Windows payload
+
+Other operating system or CPU combinations, musl Linux, and ambiguous Linux
+libc detection are not supported.
+Installing with optional dependencies disabled leaves no native payload and
+causes the launcher to report a corrective error. There is no installed Copilot
+fallback. The launcher checks exact versions, platform metadata, and the native
+binary SHA-256 before launch. Node 18 or later is needed; Go is not required.
+
+The launcher preserves terminal input/output, working directory, arguments, and
+native exit status. Uninstalling the npm packages does not remove Sodapop state,
+runtime caches, credentials, or shell profiles.
+
+Sodapop's original code is MIT-licensed. Native optional dependencies are
+composite bundles whose upstream licenses and runtime terms are included in
+their `LICENSES/` and `THIRD_PARTY_NOTICES.md`; they are not licensed only as MIT.
+Sodapop is not an official GitHub product.
+
+Source, documentation, and license information are available in the
+[Sodapop repository](https://github.com/VeVarunSharma/sodapop).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,17 @@
+# Third-party notices
+
+Sodapop uses the GitHub Copilot Go SDK and Charm's Bubble Tea, Bubbles, Lip Gloss, Glamour, and Harmonica libraries, along with their Go dependencies. These components retain their respective copyrights and licenses.
+
+- [GitHub Copilot SDK](https://github.com/github/copilot-sdk): MIT.
+- [Bubble Tea](https://github.com/charmbracelet/bubbletea): MIT.
+- [Bubbles](https://github.com/charmbracelet/bubbles): MIT.
+- [Lip Gloss](https://github.com/charmbracelet/lipgloss): MIT.
+- [Glamour](https://github.com/charmbracelet/glamour): MIT.
+- [Harmonica](https://github.com/charmbracelet/harmonica): MIT; its spring implementation also retains Ryan Juckett's original license notice.
+- [Copilot runtime releases](https://github.com/github/copilot-cli/releases): distributed under the accompanying runtime terms.
+
+The pinned Copilot runtime is a separate GitHub distribution. Its applicable license and notices are included by the official SDK bundler. A candidate archive includes that runtime license and dependency license/notice files under `LICENSES/`.
+
+Sodapop does not incorporate Crush application code or artwork. Crush's application license is separate from the licenses of the Charm UI libraries.
+
+Sodapop's original code is licensed under the MIT license in `LICENSE`. That license does not replace the separate terms of the bundled runtime or dependencies. Sodapop is not an official GitHub product.

package/bin/sodapop.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { main } = require("../lib/launcher");
+
+main(process.argv.slice(2)).then((code) => { process.exitCode = code; }).catch((error) => {
+  console.error(`sodapop: ${error.message}`);
+  process.exitCode = 1;
+});

package/lib/launcher.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { createHash } = require("node:crypto");
+const { spawn } = require("node:child_process");
+
+const TARGETS = Object.freeze({
+  "darwin-arm64": { package: "@sodapop-sh/darwin-arm64", platform: "darwin/arm64", os: "darwin", cpu: "arm64", binary: "sodapop" },
+  "darwin-x64": { package: "@sodapop-sh/darwin-amd64", platform: "darwin/amd64", os: "darwin", cpu: "x64", binary: "sodapop" },
+  "linux-arm64": { package: "@sodapop-sh/linux-arm64", platform: "linux/arm64", os: "linux", cpu: "arm64", binary: "sodapop" },
+  "linux-x64": { package: "@sodapop-sh/linux-amd64", platform: "linux/amd64", os: "linux", cpu: "x64", binary: "sodapop" },
+  "win32-x64": { package: "@sodapop-sh/windows-amd64", platform: "windows/amd64", os: "win32", cpu: "x64", binary: "sodapop.exe" }
+});
+const PLATFORM_PACKAGES = Object.freeze(Object.fromEntries(Object.entries(TARGETS).map(([key, target]) => [key, target.package])));
+
+function failure(code, message) {
+  return Object.assign(new Error(`${code}: ${message}`), { code });
+}
+
+function selectTarget(platform = process.platform, arch = process.arch) {
+  const target = TARGETS[`${platform}-${arch}`];
+  if (!target) throw failure("SODAPOP_UNSUPPORTED_PLATFORM", `unsupported platform ${platform}/${arch}`);
+  return target;
+}
+
+function platformPackage(platform, arch) {
+  return selectTarget(platform, arch).package;
+}
+
+function requireGlibc(getReport = () => process.report.getReport()) {
+  let report;
+  try {
+    report = getReport();
+  } catch {
+    throw failure("SODAPOP_AMBIGUOUS_LIBC", "cannot identify the Linux C library; a glibc-based Node.js runtime is required");
+  }
+  const glibc = typeof report?.header?.glibcVersionRuntime === "string" && /^\d+\.\d+/.test(report.header.glibcVersionRuntime);
+  const musl = Array.isArray(report?.sharedObjects) && report.sharedObjects.some((name) => /(?:^|[/\\])(?:ld-musl-|libc\.musl-)/.test(name));
+  if (musl && !glibc) throw failure("SODAPOP_UNSUPPORTED_LIBC", "Linux musl is unsupported; use glibc Linux");
+  if (!glibc || musl) throw failure("SODAPOP_AMBIGUOUS_LIBC", "cannot unambiguously identify glibc Linux");
+}
+
+function hashFile(filename) {
+  const hash = createHash("sha256");
+  const fd = fs.openSync(filename, "r");
+  try {
+    const buffer = Buffer.alloc(1024 * 1024);
+    let count;
+    while ((count = fs.readSync(fd, buffer, 0, buffer.length, null)) !== 0) hash.update(buffer.subarray(0, count));
+  } finally {
+    fs.closeSync(fd);
+  }
+  return hash.digest("hex");
+}
+
+function resolvePayload(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const target = selectTarget(options.platform, options.arch);
+  if (target.os === "linux") requireGlibc(options.getReport);
+  const cli = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+  const entries = cli.sodapop?.artifacts?.filter((artifact) => artifact.platform === target.platform);
+  if (!entries || entries.length === 0 || !Object.hasOwn(cli.optionalDependencies || {}, target.package)) {
+    throw failure("SODAPOP_UNAVAILABLE_PLATFORM", `${target.platform} is not declared by @sodapop-sh/cli@${cli.version}`);
+  }
+  if (entries.length !== 1) throw failure("SODAPOP_AMBIGUOUS_PLATFORM", `multiple payloads declared for ${target.platform}`);
+  const artifact = entries[0];
+  if (cli.sodapop.schema_version !== 1 || cli.sodapop.version !== cli.version ||
+      cli.optionalDependencies[target.package] !== cli.version) {
+    throw failure("SODAPOP_PAYLOAD_MISMATCH", "CLI release metadata or exact-version dependency is inconsistent");
+  }
+
+  let metadataPath;
+  try {
+    metadataPath = require.resolve(`${target.package}/package.json`, { paths: [packageRoot] });
+  } catch (error) {
+    if (error.code !== "MODULE_NOT_FOUND") throw error;
+    throw failure("SODAPOP_MISSING_PAYLOAD", `native payload ${target.package}@${cli.version} is missing; reinstall @sodapop-sh/cli with optional dependencies enabled`);
+  }
+  const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+  if (metadata.version !== cli.version) {
+    throw failure("SODAPOP_VERSION_MISMATCH", `native payload version mismatch: @sodapop-sh/cli is ${cli.version}, ${target.package} is ${metadata.version}; reinstall @sodapop-sh/cli`);
+  }
+  const single = (value, expected) => Array.isArray(value) && value.length === 1 && value[0] === expected;
+  const binding = metadata.sodapop;
+  if (metadata.name !== target.package || !single(metadata.os, target.os) || !single(metadata.cpu, target.cpu) ||
+      (target.os === "linux" && !single(metadata.libc, "glibc")) ||
+      ["schema_version", "version", "commit", "copilot_sdk_version", "copilot_runtime_version"].some((key) => binding?.[key] !== cli.sodapop[key]) ||
+      ["platform", "archive", "archive_sha256", "binary_sha256"].some((key) => binding?.artifact?.[key] !== artifact[key]) ||
+      !/^[a-f0-9]{64}$/.test(artifact.binary_sha256)) {
+    throw failure("SODAPOP_PAYLOAD_MISMATCH", `native payload metadata mismatch for ${target.package}`);
+  }
+  const binary = path.join(path.dirname(metadataPath), "bin", target.binary);
+  try {
+    if (!fs.lstatSync(binary).isFile()) throw failure("SODAPOP_PAYLOAD_MISMATCH", "native payload must be a regular file");
+    fs.accessSync(binary, target.os === "win32" ? fs.constants.R_OK : fs.constants.X_OK);
+  } catch (error) {
+    if (error.code === "SODAPOP_PAYLOAD_MISMATCH") throw error;
+    if (!["ENOENT", "EACCES", "EPERM"].includes(error.code)) throw error;
+    throw failure("SODAPOP_MISSING_PAYLOAD", `${target.package}@${cli.version} does not contain executable bin/${target.binary}`);
+  }
+  if (hashFile(binary) !== artifact.binary_sha256) {
+    throw failure("SODAPOP_PAYLOAD_MISMATCH", `native payload binary hash mismatch for ${target.package}; reinstall @sodapop-sh/cli`);
+  }
+  return binary;
+}
+
+async function main(args, options = {}) {
+  const runtime = options.process || process;
+  const errorOutput = options.errorOutput || ((message) => console.error(message));
+  let binary;
+  try {
+    binary = resolvePayload(options);
+  } catch (error) {
+    errorOutput(`sodapop: ${error.message}`);
+    return 1;
+  }
+  // Replacing Node preserves terminal job control and delivers each POSIX signal
+  // once. Older Node and Windows use the inherited-console subprocess path.
+  if (!options.spawn && runtime.platform !== "win32" && typeof runtime.execve === "function") {
+    try {
+      runtime.execve(binary, [binary, ...args], runtime.env);
+    } catch (error) {
+      errorOutput(`sodapop: SODAPOP_START_FAILED: ${error.message}`);
+      return 1;
+    }
+  }
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = (options.spawn || spawn)(binary, args, { stdio: "inherit", env: runtime.env, cwd: runtime.cwd(), shell: false });
+    } catch (error) {
+      errorOutput(`sodapop: SODAPOP_START_FAILED: ${error.message}`);
+      resolve(1);
+      return;
+    }
+    const handlers = new Map();
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+      const handler = () => {
+        // Windows broadcasts Ctrl+C to the inherited console. kill(SIGINT)
+        // would forcibly terminate the child instead of letting it handle it.
+        if (!(runtime.platform === "win32" && signal === "SIGINT")) child.kill(signal);
+      };
+      handlers.set(signal, handler);
+      runtime.on(signal, handler);
+    }
+    const cleanup = () => {
+      for (const [signal, handler] of handlers) runtime.removeListener(signal, handler);
+    };
+    let settled = false;
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      errorOutput(`sodapop: SODAPOP_START_FAILED: ${error.message}`);
+      resolve(1);
+    });
+    child.once("exit", (status, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (signal) {
+        runtime.kill(runtime.pid, signal);
+        resolve(1);
+      } else resolve(status === null ? 1 : status);
+    });
+  });
+}
+
+module.exports = { TARGETS, PLATFORM_PACKAGES, hashFile, main, platformPackage, requireGlibc, resolvePayload };

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@sodapop-sh/cli",
+  "version": "0.1.0-rc.9",
+  "description": "Sodapop terminal application backed by the official GitHub Copilot SDK",
+  "license": "MIT",
+  "homepage": "https://sodapop.sh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VeVarunSharma/sodapop.git"
+  },
+  "bugs": {
+    "url": "https://github.com/VeVarunSharma/sodapop/issues"
+  },
+  "keywords": [
+    "copilot",
+    "github-copilot",
+    "terminal",
+    "cli",
+    "tui"
+  ],
+  "bin": {
+    "sodapop": "bin/sodapop.js"
+  },
+  "files": [
+    "bin/sodapop.js",
+    "lib/launcher.js",
+    "LICENSE",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "optionalDependencies": {
+    "@sodapop-sh/darwin-amd64": "0.1.0-rc.9",
+    "@sodapop-sh/darwin-arm64": "0.1.0-rc.9",
+    "@sodapop-sh/linux-amd64": "0.1.0-rc.9",
+    "@sodapop-sh/linux-arm64": "0.1.0-rc.9",
+    "@sodapop-sh/windows-amd64": "0.1.0-rc.9"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sodapop": {
+    "schema_version": 1,
+    "version": "0.1.0-rc.9",
+    "commit": "9670eb81481c6eebd751b54e3546939e4db4659d",
+    "copilot_runtime_version": "1.0.83",
+    "copilot_sdk_version": "1.0.13",
+    "artifacts": [
+      {
+        "platform": "darwin/amd64",
+        "archive": "sodapop-0.1.0-rc.9-darwin-amd64.tar.gz",
+        "archive_sha256": "19f171e8f9afe8548b5720f11e6b0aa657092ceb3485bd062b5a3a7ac96aac11",
+        "binary_sha256": "37e0c546ca7c4085d43c85c37d1a18ed68ee3e622664b4a7dfe9320dd470b334"
+      },
+      {
+        "platform": "darwin/arm64",
+        "archive": "sodapop-0.1.0-rc.9-darwin-arm64.tar.gz",
+        "archive_sha256": "eab963e3f4051a117dfa3b9ba7b8dd6e7f78f4ba9df60d18cfe32d24ab58ea62",
+        "binary_sha256": "89b7e059ab11ad29f375893bd3e16dc5e3acfe9a1ed674bfedddc26d0a7fdbe6"
+      },
+      {
+        "platform": "linux/amd64",
+        "archive": "sodapop-0.1.0-rc.9-linux-amd64.tar.gz",
+        "archive_sha256": "3d0713dca2e766c2f1aa73cae8dfb1ea1f21e7f28a01ad14e52d7bbb6a2b653e",
+        "binary_sha256": "3aac57c12a8eb9ac2e166df37d17d62ec9d7fa5bb81fe0437c4924e707a049ce"
+      },
+      {
+        "platform": "linux/arm64",
+        "archive": "sodapop-0.1.0-rc.9-linux-arm64.tar.gz",
+        "archive_sha256": "ddaa4bb8725cd394cafbac3087741303219e3764d2b9e703f4ab6bc77fe95d97",
+        "binary_sha256": "20bf017d1e4bb0f0bc3593ee62110cbef3dce264d76e3cbd2b344ceb1f00b8c5"
+      },
+      {
+        "platform": "windows/amd64",
+        "archive": "sodapop-0.1.0-rc.9-windows-amd64.zip",
+        "archive_sha256": "898c955fbfa01a719ba9d1b3b1542cdb92582a2447d218345cf7ff321697a081",
+        "binary_sha256": "d84c057284ec9eb823c29b9ec0e6b9291ac11d20d7746b02dac96495f8551474"
+      }
+    ]
+  }
+}