@tjcoder/cli 0.9.164

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TJ Coder
+
+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,122 @@
+# @tjcoder/cli
+
+> Terminal-first AI coding assistant by TJ Coder / AI Labs.
+
+`coder` is a Go TUI that pairs a conversational AI agent with real
+developer tools, streams the model's reasoning live in a "cognition"
+pane, and ships 7 specialized agents plus 31 tools. It defaults to local
+Ollama models (your code never leaves your machine) and optionally uses
+Google Gemini. This package is the npm distribution: it downloads the
+right prebuilt binary for your platform on `npm install`, so you don't
+need a Go toolchain.
+
+## Install
+
+```bash
+npm install -g @tjcoder/cli
+```
+
+That's it. After install, `coder` is on your `PATH`:
+
+```bash
+coder --version
+```
+
+### Prerequisites
+
+`coder` itself is a self-contained Go binary — the only requirement is
+`node >= 18` (to run the postinstall downloader). To actually use the
+TUI you'll also need:
+
+- An [Ollama](https://ollama.com) server running locally
+  (default: `http://localhost:11434`)
+- At least one model pulled (`ollama pull gemma4:cloud` or similar)
+
+Don't have Ollama yet? The shell installer can set it up in one go:
+
+```bash
+INSTALL_OLLAMA=1 curl -fsSL https://raw.githubusercontent.com/tjcoder-labs/cli/main/install.sh | bash
+```
+
+## Features
+
+- **Live cognition pane** — watch the model reason in real time
+- **7 specialized agents** — software engineer, terminal specialist, code reviewer, Android assistant, cloud expert, social researcher, storyteller
+- **31 tools** — filesystem, shell, Git, browser automation (CDP), Cloudflare DNS, email, and more
+- **Multi-line paste** — paste code blocks or documents; they're kept as one message
+- **Headless mode** — script it with `coder -p "…"` for CI and automation
+- **Session persistence** — conversation history, tasks, and memories survive across runs
+- **Local-first privacy** — defaults to Ollama; your code never leaves your machine
+
+## Updating
+
+```bash
+npm update -g @tjcoder/cli
+```
+
+The `postinstall` hook is idempotent and won't redownload a binary
+that's already present.
+
+## Uninstalling
+
+```bash
+npm uninstall -g @tjcoder/cli
+```
+
+The `preuninstall` hook removes the cached binary.
+
+## Usage
+
+```bash
+coder                              # launch the TUI
+coder --version                    # print version and exit
+coder --provider ollama --host http://localhost:11434
+coder --provider gemini --gemini-api-key $GEMINI_API_KEY
+coder --provider gemini models     # list available Gemini models
+coder --workspace-root ~/code/foo
+coder --model gemma4:cloud
+coder --timeout 30m
+```
+
+### Environment variables
+
+| Var | Default | Purpose |
+|---|---|---|
+| `GEMINI_API_KEY` | _(required for gemini)_ | API key for Google's Gemini API |
+| `CODER_HTTP_TIMEOUT` | `5m` | HTTP client timeout (`time.ParseDuration`) |
+| `CODER_CLI_REPO` | `tjcoder-labs/cli` | Override the GitHub repo used by `postinstall` |
+| `CODER_CLI_VERSION` | _(matches this package)_ | Pin a specific `coder` binary version |
+| `CODER_CLI_REQUIRE_DOWNLOAD` | _(unset)_ | Set to `1` to make a failed download fatal |
+
+## Pinning a version
+
+```bash
+# install a specific coder version regardless of the @tjcoder/cli wrapper version
+CODER_CLI_VERSION=v0.9.164 npm install -g @tjcoder/cli
+```
+
+## Troubleshooting
+
+**`coder: native binary not found at .../lib/coder`**
+
+The postinstall hook was skipped. Re-run with scripts enabled:
+
+```bash
+npm rebuild @tjcoder/cli
+# or
+npm install -g @tjcoder/cli --foreground-scripts
+```
+
+**`coder: download failed: 404 ...`**
+
+There is no published release for your platform/arch, or the version
+you pinned doesn't exist. Try a different version, or fall back to the
+Go-based installer:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/tjcoder-labs/cli/main/install.sh | bash
+```
+
+## License
+
+MIT — see the [LICENSE](./LICENSE) file. Built by [TJ Coder / AI Labs](https://github.com/tjcoder-labs).

package/bin/coder.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// coder.js - thin Node shim that exec()s the native `coder` binary.
+//
+// This file is registered as the `coder` bin in package.json so that
+// `npm install -g @tjcoder/cli` puts `coder` on the user's PATH.
+// The actual implementation is a Go binary that is downloaded by
+// ./lib/fetch-binary.js during `postinstall`.
+
+const { spawn } = require("node:child_process");
+const path = require("node:path");
+const fs = require("node:fs");
+const os = require("node:os");
+
+// Resolve the platform-specific binary name. Windows gets a .exe suffix.
+const ext = process.platform === "win32" ? ".exe" : "";
+const binName = `coder${ext}`;
+
+// The binary is downloaded next to this file under lib/<bin>.
+const binPath = path.join(__dirname, "..", "lib", binName);
+
+if (!fs.existsSync(binPath)) {
+  console.error(
+    [
+      `coder: native binary not found at ${binPath}`,
+      ``,
+      `This usually means the postinstall hook was skipped (e.g. when`,
+      `installing with --ignore-scripts). To fix:`,
+      ``,
+      `  npm rebuild @tjcoder/cli`,
+      `  # or`,
+      `  npm install -g @tjcoder/cli --foreground-scripts`,
+      ``,
+      `If the problem persists, install via the Go-based installer instead:`,
+      `  curl -fsSL https://raw.githubusercontent.com/tjcoder-labs/cli/main/install.sh | bash`,
+    ].join("\n"),
+  );
+  process.exit(1);
+}
+
+// Spawn the binary, inheriting stdio so the TUI / streaming output works
+// exactly as if the user had run `coder` directly. Forward signals so
+// Ctrl+C cleanly tears down the child.
+const child = spawn(binPath, process.argv.slice(2), {
+  stdio: "inherit",
+  env: process.env,
+  windowsHide: true,
+});
+
+const forward = (sig) => () => {
+  if (!child.killed) child.kill(sig);
+};
+process.on("SIGINT", forward("SIGINT"));
+process.on("SIGTERM", forward("SIGTERM"));
+process.on("SIGHUP", forward("SIGHUP"));
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    // Mirror the conventional shell behavior: 128 + signal number.
+    const map = { SIGHUP: 1, SIGINT: 2, SIGTERM: 15 };
+    process.exit(128 + (map[signal] || 15));
+  }
+  process.exit(code ?? 0);
+});
+
+child.on("error", (err) => {
+  console.error(`coder: failed to exec ${binPath}: ${err.message}`);
+  process.exit(1);
+});

package/lib/cleanup.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// cleanup.js - remove the platform-specific `coder` binary on uninstall.
+//
+// Invoked by the package.json `preuninstall` script. Best-effort: never
+// throws, so a cleanup failure can't block `npm rm`.
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const ext = process.platform === "win32" ? ".exe" : "";
+const candidates = [
+  path.join(__dirname, `coder${ext}`),
+  path.join(__dirname, "coder"),
+  path.join(__dirname, "coder.exe"),
+  path.join(__dirname, "coder.sha256"),
+];
+
+for (const p of candidates) {
+  try {
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  } catch {
+    // ignore — best effort
+  }
+}

package/lib/fetch-binary.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// fetch-binary.js - download the platform-appropriate `coder` binary from
+// the project's GitHub Releases page during `npm install`.
+//
+// This is invoked by the package.json `postinstall` script. It is
+// idempotent: if the binary is already present for the current
+// platform/arch, it does nothing.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const https = require("node:https");
+const { URL } = require("node:url");
+
+// --- configuration ---------------------------------------------------------
+
+const pkg = require("../package.json");
+const REPO = process.env.CODER_CLI_REPO || "tjcoder-labs/cli";
+// Allow pinning a version (matches the @tjcoder/cli package version by
+// default so that `npm i @tjcoder/cli@0.9.164` installs coder v0.9.164).
+const VERSION = process.env.CODER_CLI_VERSION || `v${pkg.version}`;
+
+// --- platform detection ----------------------------------------------------
+
+function detect() {
+  // Map Node's platform/arch names to the suffixes we use in release assets.
+  const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+    freebsd: "freebsd",
+  };
+  const archMap = {
+    x64: "amd64",
+    arm64: "arm64",
+    x32: "386",
+  };
+
+  const os = platformMap[process.platform];
+  const arch = archMap[process.arch];
+
+  if (!os) {
+    throw new Error(
+      `unsupported platform: ${process.platform} ` +
+        `(coder publishes darwin, linux, windows, freebsd)`,
+    );
+  }
+  if (!arch) {
+    throw new Error(
+      `unsupported architecture: ${process.arch} ` +
+        `(coder publishes amd64, arm64, 386)`,
+    );
+  }
+
+  const ext = os === "windows" ? ".zip" : ".tar.gz";
+  const asset = `coder_${VERSION}_${os}_${arch}${ext}`;
+  return { os, arch, ext, asset };
+}
+
+// --- download --------------------------------------------------------------
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(
+      url,
+      { headers: { "User-Agent": `${pkg.name}/${pkg.version}` } },
+      (res) => {
+        // GitHub returns 301/302 to the S3-backed download URL. Follow.
+        if (
+          res.statusCode &&
+          [301, 302, 303, 307, 308].includes(res.statusCode) &&
+          res.headers.location
+        ) {
+          res.resume();
+          download(new URL(res.headers.location, url).toString(), dest)
+            .then(resolve)
+            .catch(reject);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(
+            new Error(
+              `download failed: ${res.statusCode} ${res.statusMessage} for ${url}`,
+            ),
+          );
+          return;
+        }
+        const out = fs.createWriteStream(dest);
+        res.pipe(out);
+        out.on("finish", () => out.close(() => resolve(dest)));
+        out.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.setTimeout(60_000, () => {
+      req.destroy(new Error(`download timeout after 60s: ${url}`));
+    });
+  });
+}
+
+function extract(archivePath, workDir, info) {
+  const { execFileSync } = require("node:child_process");
+  const binName = info.os === "windows" ? "coder.exe" : "coder";
+  if (info.ext === ".tar.gz") {
+    execFileSync("tar", ["-xzf", archivePath, "-C", workDir], {
+      stdio: "ignore",
+    });
+  } else if (info.ext === ".zip") {
+    // `tar` on Windows 10+ and modern macOS handles .zip too; fall back to
+    // a system unzip if not.
+    try {
+      execFileSync("tar", ["-xf", archivePath, "-C", workDir], {
+        stdio: "ignore",
+      });
+    } catch {
+      execFileSync("unzip", ["-q", archivePath, "-d", workDir], {
+        stdio: "ignore",
+      });
+    }
+  } else {
+    throw new Error(`unknown archive extension: ${info.ext}`);
+  }
+  // The archive contains a top-level `coder` (or `coder.exe`) binary.
+  const extracted = path.join(workDir, binName);
+  if (!fs.existsSync(extracted)) {
+    // Some releases nest the binary in a subdirectory; try one level.
+    const nested = path.join(workDir, `coder_${VERSION}_${info.os}_${info.arch}`, binName);
+    if (fs.existsSync(nested)) return nested;
+    throw new Error(
+      `expected binary not found in archive: ${extracted} (and ${nested})`,
+    );
+  }
+  return extracted;
+}
+
+async function checksum(filePath) {
+  // Optional SHA256 verification against a sibling .sha256 file. We try, but
+  // never fail the install if the file is missing — that keeps dev installs
+  // working before the first signed release.
+  const fs = require("node:fs/promises");
+  const crypto = require("node:crypto");
+  const shaPath = `${filePath}.sha256`;
+  if (!fs.existsSync(shaPath)) return;
+  const expected = (await fs.readFile(shaPath, "utf8")).trim().split(/\s+/)[0];
+  const actual = crypto
+    .createHash("sha256")
+    .update(await fs.readFile(filePath))
+    .digest("hex");
+  if (expected.toLowerCase() !== actual.toLowerCase()) {
+    throw new Error(
+      `sha256 mismatch: expected ${expected}, got ${actual} for ${filePath}`,
+    );
+  }
+}
+
+// --- main ------------------------------------------------------------------
+
+async function main() {
+  const info = detect();
+  const libDir = path.join(__dirname);
+  const binName = info.os === "windows" ? "coder.exe" : "coder";
+  const binPath = path.join(libDir, binName);
+
+  if (fs.existsSync(binPath)) {
+    // Already installed (e.g. `npm rebuild`); leave the existing binary
+    // alone so we don't clobber a working install with a broken download.
+    return;
+  }
+
+  const url = `https://github.com/${REPO}/releases/download/${VERSION}/${info.asset}`;
+  process.stdout.write(`coder: downloading ${info.asset} ...\n`);
+
+  const tmp = fs.mkdtempSync(path.join(require("node:os").tmpdir(), "coder-"));
+  const archivePath = path.join(tmp, info.asset);
+  try {
+    await download(url, archivePath);
+    const extracted = extract(archivePath, tmp, info);
+    if (info.os !== "windows") {
+      fs.chmodSync(extracted, 0o755);
+    }
+    await checksum(extracted);
+    fs.renameSync(extracted, binPath);
+    process.stdout.write(`coder: installed ${binPath}\n`);
+  } catch (err) {
+    process.stderr.write(
+      `coder: ${err.message}\n` +
+        `coder: install via the Go-based installer instead:\n` +
+        `coder:   curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash\n`,
+    );
+    // Don't fail the install for an optional postinstall: leave the JS shim
+    // in place so users can still see the error when they run `coder`.
+    // Set CODER_CLI_REQUIRE_DOWNLOAD=1 to make this fatal.
+    if (process.env.CODER_CLI_REQUIRE_DOWNLOAD === "1") process.exit(1);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`coder: unexpected error: ${err.stack || err}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@tjcoder/cli",
+  "version": "0.9.164",
+  "description": "Terminal-first AI coding assistant by TJ Coder / AI Labs. A keyboard-driven TUI with a live cognition pane, 7 specialized agents, and 31 tools, running on local Ollama models by default.",
+  "license": "MIT",
+  "private": false,
+  "bin": {
+    "coder": "bin/coder.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node ./lib/fetch-binary.js",
+    "preuninstall": "node ./lib/cleanup.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tjcoder-labs/cli.git",
+    "directory": "npm/coder-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/tjcoder-labs/cli/issues"
+  },
+  "homepage": "https://github.com/tjcoder-labs/cli#readme",
+  "keywords": [
+    "ai",
+    "coding",
+    "cli",
+    "tui",
+    "terminal",
+    "ollama",
+    "gemini",
+    "agent",
+    "assistant"
+  ]
+}