@logionsh/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Logion 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,47 @@
+# @logionsh/cli
+
+Thin npm wrapper around the canonical [`logion-cli`](https://pypi.org/project/logion-cli/) Python package.
+
+## Install
+
+```bash
+npm install -g @logionsh/cli
+# or
+npx @logionsh/cli --help
+```
+
+## Requirements
+
+- Node ≥ 22
+- Python ≥ 3.12 on the host (the wrapper auto-detects `python3` or `py`)
+- One of `pipx`, `uv`, or the wrapper falls back to a managed venv
+
+## What this package does
+
+On install, the postinstall hook:
+
+1. Finds a working Python 3.12+.
+2. Installs `logion-cli==<pinned-version>` from PyPI via `pipx`/`uv`/venv.
+3. Shims the `logion` and `lgn` binaries onto your PATH.
+
+The pinned PyPI version is baked into the npm tarball at publish
+time, so `npm install -g @logionsh/cli@0.3.0` always installs the
+exact matching Python package.
+
+## Why not pure Node?
+
+The canonical implementation is Python — the CLI is part of a
+three-package Python workspace and shares code with the Python SDK.
+A pure-Node port would double the codebase and drift from the source
+of truth. This wrapper exists so JS-ecosystem users don't need to
+think about Python package managers.
+
+## Environment variables
+
+| Variable                     | Purpose                                  |
+| ---------------------------- | ---------------------------------------- |
+| `LOGION_NPM_SKIP_INSTALL`    | Set to `1` to skip postinstall (CI/test) |
+| `LOGION_NPM_FORCE_INSTALLER` | Force `pipx`, `uv`, or `venv`            |
+| `LOGION_NPM_PYTHON`          | Override Python binary path              |
+
+See https://github.com/nicolasmelo1/logion for the full project.

package/dist/bin/lgn.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+
+// src/bin/lgn.ts
+var import_node_child_process = require("child_process");
+
+// src/lib/which.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+function candidatesForName(name) {
+  if (process.platform !== "win32") {
+    return [name];
+  }
+  const pathext = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+  if (import_node_path.default.extname(name)) {
+    return [name];
+  }
+  return [name, ...pathext.map((ext) => name + ext.toLowerCase())];
+}
+function which(name) {
+  const rawPath = process.env.PATH ?? "";
+  const dirs = rawPath.split(import_node_path.default.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const candidate of candidatesForName(name)) {
+      const full = import_node_path.default.join(dir, candidate);
+      try {
+        const stat = import_node_fs.default.statSync(full);
+        if (stat.isFile()) {
+          return full;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// src/bin/lgn.ts
+var target = which("lgn") ?? which("logion");
+if (!target) {
+  process.stderr.write(
+    "lgn/logion binary not found. Reinstall with `npm install -g @logionsh/cli` or install directly via `pipx install logion-cli`.\n"
+  );
+  process.exit(127);
+}
+var r = (0, import_node_child_process.spawnSync)(target, process.argv.slice(2), { stdio: "inherit" });
+if (r.error) {
+  process.stderr.write(`${r.error.message}
+`);
+  process.exit(1);
+}
+process.exit(r.status ?? 1);

package/dist/bin/logion.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+
+// src/bin/logion.ts
+var import_node_child_process = require("child_process");
+
+// src/lib/which.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+function candidatesForName(name) {
+  if (process.platform !== "win32") {
+    return [name];
+  }
+  const pathext = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+  if (import_node_path.default.extname(name)) {
+    return [name];
+  }
+  return [name, ...pathext.map((ext) => name + ext.toLowerCase())];
+}
+function which(name) {
+  const rawPath = process.env.PATH ?? "";
+  const dirs = rawPath.split(import_node_path.default.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const candidate of candidatesForName(name)) {
+      const full = import_node_path.default.join(dir, candidate);
+      try {
+        const stat = import_node_fs.default.statSync(full);
+        if (stat.isFile()) {
+          return full;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// src/bin/logion.ts
+var target = which("logion");
+if (!target) {
+  process.stderr.write(
+    "logion binary not found. Reinstall with `npm install -g @logionsh/cli` or install directly via `pipx install logion-cli`.\n"
+  );
+  process.exit(127);
+}
+var r = (0, import_node_child_process.spawnSync)(target, process.argv.slice(2), { stdio: "inherit" });
+if (r.error) {
+  process.stderr.write(`${r.error.message}
+`);
+  process.exit(1);
+}
+process.exit(r.status ?? 1);

package/dist/scripts/postinstall.js

@@ -0,0 +1,434 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/postinstall.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_os2 = __toESM(require("os"));
+var import_node_path3 = __toESM(require("path"));
+
+// src/lib/check-python.ts
+var import_node_child_process = require("child_process");
+
+// src/lib/which.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+function candidatesForName(name) {
+  if (process.platform !== "win32") {
+    return [name];
+  }
+  const pathext = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+  if (import_node_path.default.extname(name)) {
+    return [name];
+  }
+  return [name, ...pathext.map((ext) => name + ext.toLowerCase())];
+}
+function which(name) {
+  const rawPath = process.env.PATH ?? "";
+  const dirs = rawPath.split(import_node_path.default.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const candidate of candidatesForName(name)) {
+      const full = import_node_path.default.join(dir, candidate);
+      try {
+        const stat = import_node_fs.default.statSync(full);
+        if (stat.isFile()) {
+          return full;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// src/lib/check-python.ts
+var MIN_MAJOR = 3;
+var MIN_MINOR = 12;
+function candidates() {
+  if (process.platform === "win32") {
+    return [
+      { cmd: "py", args: ["-3"] },
+      { cmd: "python3", args: [] },
+      { cmd: "python", args: [] }
+    ];
+  }
+  return [
+    { cmd: "python3", args: [] },
+    { cmd: "python", args: [] }
+  ];
+}
+function probeVersion(cmd, args) {
+  const r = (0, import_node_child_process.spawnSync)(
+    cmd,
+    [...args, "-c", "import sys;print(sys.version_info[:2])"],
+    { encoding: "utf8", timeout: 5e3 }
+  );
+  if (r.status !== 0 || !r.stdout) {
+    return false;
+  }
+  const m = /\((\d+),\s*(\d+)\)/.exec(r.stdout);
+  if (!m) {
+    return false;
+  }
+  const major = Number(m[1]);
+  const minor = Number(m[2]);
+  if (major > MIN_MAJOR) {
+    return true;
+  }
+  return major === MIN_MAJOR && minor >= MIN_MINOR;
+}
+function detectPython() {
+  const override = process.env.LOGION_NPM_PYTHON;
+  if (override && override.trim().length > 0) {
+    return { cmd: override, args: [] };
+  }
+  for (const c of candidates()) {
+    const resolved = which(c.cmd);
+    if (!resolved) {
+      continue;
+    }
+    if (probeVersion(resolved, c.args)) {
+      return { cmd: resolved, args: c.args };
+    }
+  }
+  return null;
+}
+
+// src/lib/companion-bundle.ts
+var import_node_crypto = __toESM(require("crypto"));
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_os = __toESM(require("os"));
+var import_node_path2 = __toESM(require("path"));
+var LOGION_DIR = import_node_path2.default.join(import_node_os.default.homedir(), ".logion");
+function byCodePoint(a, b) {
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+}
+function listBundleSourceEntries(sourceDir, log2) {
+  try {
+    return import_node_fs2.default.readdirSync(sourceDir).sort(byCodePoint);
+  } catch {
+    log2(
+      `LOGION_COMPANION_BUNDLE_SOURCE=${sourceDir} read failed \u2014 skipping companion bundle copy.`
+    );
+    return null;
+  }
+}
+function findCompanionTarball(sourceDir, entries, log2) {
+  for (const name of entries) {
+    if (!/^logion-marketplace-companion-.*\.tar\.gz$/.test(name)) {
+      continue;
+    }
+    const candidatePath = import_node_path2.default.join(sourceDir, name);
+    try {
+      if (import_node_fs2.default.statSync(candidatePath).isFile()) {
+        return { tarball: name, srcPath: candidatePath };
+      }
+    } catch {
+      log2(`Could not stat companion tarball candidate ${candidatePath}.`);
+    }
+  }
+  return null;
+}
+function sha256File(filePath) {
+  const hash = import_node_crypto.default.createHash("sha256");
+  const fd = import_node_fs2.default.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  const buf = Buffer.alloc(chunkSize);
+  let bytesRead;
+  try {
+    while ((bytesRead = import_node_fs2.default.readSync(fd, buf, 0, chunkSize, null)) > 0) {
+      hash.update(buf.subarray(0, bytesRead));
+    }
+  } finally {
+    import_node_fs2.default.closeSync(fd);
+  }
+  return hash.digest("hex");
+}
+function isBundleSourceDirectory(sourceDir, log2) {
+  if (!import_node_fs2.default.existsSync(sourceDir)) {
+    log2(
+      `LOGION_COMPANION_BUNDLE_SOURCE=${sourceDir} does not exist \u2014 skipping companion bundle copy.`
+    );
+    return false;
+  }
+  try {
+    if (import_node_fs2.default.statSync(sourceDir).isDirectory()) {
+      return true;
+    }
+    log2(
+      `LOGION_COMPANION_BUNDLE_SOURCE=${sourceDir} is not a directory \u2014 skipping companion bundle copy.`
+    );
+  } catch {
+    log2(
+      `LOGION_COMPANION_BUNDLE_SOURCE=${sourceDir} stat failed \u2014 skipping companion bundle copy.`
+    );
+  }
+  return false;
+}
+function resolveCompanionBundle(sourceDir, log2) {
+  if (!isBundleSourceDirectory(sourceDir, log2)) {
+    return null;
+  }
+  const entries = listBundleSourceEntries(sourceDir, log2);
+  if (!entries) {
+    return null;
+  }
+  const bundle = findCompanionTarball(sourceDir, entries, log2);
+  if (!bundle) {
+    log2(
+      `No companion tarball found in ${sourceDir} \u2014 skipping companion bundle copy.`
+    );
+  }
+  return bundle;
+}
+function copyCompanionBundle(bundle, log2) {
+  const envHome = process.env.LOGION_HOME;
+  const logionHome = envHome && envHome.length > 0 ? envHome : LOGION_DIR;
+  const bundlesDir = import_node_path2.default.join(logionHome, "companion-bundles");
+  import_node_fs2.default.mkdirSync(bundlesDir, { recursive: true });
+  const destPath = import_node_path2.default.join(bundlesDir, bundle.tarball);
+  import_node_fs2.default.copyFileSync(bundle.srcPath, destPath);
+  log2(`Copied companion bundle to ${destPath}`);
+  const sidecarName = bundle.tarball.replace(/\.tar\.gz$/, ".source.json");
+  const sidecarPath = import_node_path2.default.join(bundlesDir, sidecarName);
+  const sidecar = {
+    sourcePath: bundle.srcPath,
+    sha256: sha256File(destPath),
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  import_node_fs2.default.writeFileSync(sidecarPath, `${JSON.stringify(sidecar, null, 2)}
+`);
+  log2(`Wrote companion marker ${sidecarPath}`);
+}
+function installCompanionBundle(log2) {
+  const sourceDir = process.env.LOGION_COMPANION_BUNDLE_SOURCE;
+  if (!sourceDir) {
+    return;
+  }
+  const bundle = resolveCompanionBundle(sourceDir, log2);
+  if (!bundle) {
+    return;
+  }
+  try {
+    copyCompanionBundle(bundle, log2);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log2(`Warning: companion bundle copy failed: ${msg}.`);
+  }
+}
+
+// src/scripts/postinstall.ts
+var HOME = import_node_os2.default.homedir();
+var LOGION_DIR2 = import_node_path3.default.join(HOME, ".logion");
+var MANAGED_VENV_DIR = import_node_path3.default.join(LOGION_DIR2, "npm-managed-venv");
+var MARKER_PATH = import_node_path3.default.join(LOGION_DIR2, "npm-wrapper-installer.json");
+var LOCAL_BIN = import_node_path3.default.join(HOME, ".local", "bin");
+var PLACEHOLDER_VERSION = "0.0.0-placeholder";
+function log(msg) {
+  process.stderr.write(`[logion-postinstall] ${msg}
+`);
+}
+function packageRoot() {
+  return import_node_path3.default.join(__dirname, "..", "..");
+}
+function getPinnedVersion() {
+  const pkgPath = import_node_path3.default.join(packageRoot(), "package.json");
+  const raw = import_node_fs3.default.readFileSync(pkgPath, "utf8");
+  const pkg = JSON.parse(raw);
+  if (pkg.logionCliVersion && pkg.logionCliVersion.length > 0) {
+    return pkg.logionCliVersion;
+  }
+  if (!pkg.version || pkg.version === PLACEHOLDER_VERSION) {
+    return null;
+  }
+  return pkg.version;
+}
+function writeMarker(installer, version) {
+  const marker = {
+    installer,
+    version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  import_node_fs3.default.mkdirSync(LOGION_DIR2, { recursive: true });
+  import_node_fs3.default.writeFileSync(MARKER_PATH, `${JSON.stringify(marker, null, 2)}
+`);
+}
+function runChecked(file, args) {
+  const r = (0, import_node_child_process2.spawnSync)(file, args, { stdio: "inherit" });
+  if (r.error) {
+    throw r.error;
+  }
+  if (r.status !== 0) {
+    throw new Error(
+      `${file} ${args.join(" ")} exited with status ${String(r.status)}`
+    );
+  }
+}
+function installViaPipx(version) {
+  log(`Installing logion-cli==${version} via pipx...`);
+  runChecked("pipx", ["install", "--force", `logion-cli==${version}`]);
+}
+function installViaUv(version) {
+  log(`Installing logion-cli==${version} via uv tool...`);
+  runChecked("uv", [
+    "tool",
+    "install",
+    "--reinstall",
+    `logion-cli==${version}`
+  ]);
+}
+function venvBin(name) {
+  if (process.platform === "win32") {
+    return import_node_path3.default.join(MANAGED_VENV_DIR, "Scripts", `${name}.exe`);
+  }
+  return import_node_path3.default.join(MANAGED_VENV_DIR, "bin", name);
+}
+function linkOrCopy(src, dest) {
+  if (import_node_fs3.default.existsSync(dest)) {
+    import_node_fs3.default.unlinkSync(dest);
+  }
+  try {
+    import_node_fs3.default.symlinkSync(src, dest);
+  } catch {
+    import_node_fs3.default.copyFileSync(src, dest);
+  }
+}
+function shimNamesFor(base) {
+  return process.platform === "win32" ? [`${base}.exe`] : [base];
+}
+function installViaVenv(version, py) {
+  log(`Installing logion-cli==${version} via managed venv...`);
+  runChecked(py.cmd, [...py.args, "-m", "venv", MANAGED_VENV_DIR]);
+  runChecked(venvBin("pip"), ["install", `logion-cli==${version}`]);
+  import_node_fs3.default.mkdirSync(LOCAL_BIN, { recursive: true });
+  for (const base of ["logion", "lgn"]) {
+    const src = venvBin(base);
+    if (!import_node_fs3.default.existsSync(src)) {
+      continue;
+    }
+    for (const destName of shimNamesFor(base)) {
+      const dest = import_node_path3.default.join(LOCAL_BIN, destName);
+      try {
+        linkOrCopy(src, dest);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log(
+          `Warning: could not create shim ${dest}: ${msg}. Add ${LOCAL_BIN} to PATH manually.`
+        );
+      }
+    }
+  }
+}
+function verifyInstall(version) {
+  const target = which("logion");
+  if (!target) {
+    log(
+      "Warning: logion not on PATH yet. Ensure your installer's bin directory is exported."
+    );
+    return;
+  }
+  const r = (0, import_node_child_process2.spawnSync)(target, ["--version"], {
+    encoding: "utf8",
+    timeout: 1e4
+  });
+  if (r.status !== 0 || !r.stdout.includes(version)) {
+    log(
+      `Warning: installed version did not match requested ${version} (got: ${r.stdout.trim() || "<no output>"}).`
+    );
+  }
+}
+function pickInstaller(forced) {
+  if (forced === "pipx" || forced === "uv" || forced === "venv") {
+    return forced;
+  }
+  if (forced !== void 0 && forced.length > 0) {
+    return null;
+  }
+  if (which("pipx")) {
+    return "pipx";
+  }
+  if (which("uv")) {
+    return "uv";
+  }
+  return "venv";
+}
+function maybePrintOnboardingPointer() {
+  if (process.env.LOGION_NPM_SKIP_ONBOARDING === "1") {
+    return;
+  }
+  if (process.env.CI || process.env.LOGION_NONINTERACTIVE) {
+    return;
+  }
+  log("Next: run `logion onboarding` to set up your agent.");
+}
+function main() {
+  installCompanionBundle(log);
+  if (process.env.LOGION_NPM_SKIP_INSTALL === "1") {
+    log("LOGION_NPM_SKIP_INSTALL=1 \u2014 skipping CLI install.");
+    return;
+  }
+  const version = getPinnedVersion();
+  if (!version) {
+    log(
+      `No pinned version found (package.json still has ${PLACEHOLDER_VERSION}). Run \`node dist/scripts/version-from-manifest.js\` first or set LOGION_NPM_SKIP_INSTALL=1.`
+    );
+    process.exit(1);
+  }
+  const py = detectPython();
+  if (!py) {
+    log(
+      "Error: Python 3.12+ not found. Install Python 3.12+ or set LOGION_NPM_PYTHON."
+    );
+    log("See: https://www.python.org/downloads/");
+    log(
+      "Or set LOGION_NPM_SKIP_INSTALL=1 and install manually: pipx install logion-cli"
+    );
+    process.exit(1);
+  }
+  log(`Using Python: ${py.cmd} ${py.args.join(" ")}`.trim());
+  const forced = process.env.LOGION_NPM_FORCE_INSTALLER;
+  const installer = pickInstaller(forced);
+  if (!installer) {
+    log(`Error: unknown installer '${forced ?? ""}'. Use pipx, uv, or venv.`);
+    process.exit(1);
+  }
+  if (installer === "pipx") {
+    installViaPipx(version);
+  } else if (installer === "uv") {
+    installViaUv(version);
+  } else {
+    installViaVenv(version, py);
+  }
+  writeMarker(installer, version);
+  verifyInstall(version);
+  maybePrintOnboardingPointer();
+  log(`Installed logion-cli ${version} via ${installer}.`);
+}
+main();

package/dist/scripts/uninstall.js

@@ -0,0 +1,132 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/uninstall.ts
+var import_node_child_process = require("child_process");
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_os = __toESM(require("os"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/lib/which.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+function candidatesForName(name) {
+  if (process.platform !== "win32") {
+    return [name];
+  }
+  const pathext = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+  if (import_node_path.default.extname(name)) {
+    return [name];
+  }
+  return [name, ...pathext.map((ext) => name + ext.toLowerCase())];
+}
+function which(name) {
+  const rawPath = process.env.PATH ?? "";
+  const dirs = rawPath.split(import_node_path.default.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const candidate of candidatesForName(name)) {
+      const full = import_node_path.default.join(dir, candidate);
+      try {
+        const stat = import_node_fs.default.statSync(full);
+        if (stat.isFile()) {
+          return full;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// src/scripts/uninstall.ts
+var HOME = import_node_os.default.homedir();
+var LOGION_DIR = import_node_path2.default.join(HOME, ".logion");
+var MANAGED_VENV_DIR = import_node_path2.default.join(LOGION_DIR, "npm-managed-venv");
+var MARKER_PATH = import_node_path2.default.join(LOGION_DIR, "npm-wrapper-installer.json");
+var LOCAL_BIN = import_node_path2.default.join(HOME, ".local", "bin");
+function log(msg) {
+  process.stderr.write(`[logion-uninstall] ${msg}
+`);
+}
+function readMarker() {
+  try {
+    const raw = import_node_fs2.default.readFileSync(MARKER_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function tryRun(file, args) {
+  const r = (0, import_node_child_process.spawnSync)(file, args, { encoding: "utf8", timeout: 1e4 });
+  if (r.status !== 0) {
+    log(`Warning: ${file} ${args.join(" ")} exited ${String(r.status)}.`);
+  }
+}
+function removeManagedVenv() {
+  if (!import_node_fs2.default.existsSync(MANAGED_VENV_DIR)) {
+    return;
+  }
+  try {
+    import_node_fs2.default.rmSync(MANAGED_VENV_DIR, { recursive: true, force: true });
+    log(`Removed managed venv at ${MANAGED_VENV_DIR}`);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log(`Warning: could not remove managed venv: ${msg}`);
+  }
+}
+function removeShims() {
+  const names = process.platform === "win32" ? ["logion.exe", "lgn.exe", "logion.cmd", "lgn.cmd"] : ["logion", "lgn"];
+  for (const name of names) {
+    const link = import_node_path2.default.join(LOCAL_BIN, name);
+    try {
+      const stat = import_node_fs2.default.lstatSync(link);
+      if (stat.isSymbolicLink() || stat.isFile()) {
+        import_node_fs2.default.unlinkSync(link);
+      }
+    } catch {
+    }
+  }
+}
+function main() {
+  const marker = readMarker();
+  if (!marker) {
+    removeShims();
+    return;
+  }
+  if (marker.installer === "venv") {
+    removeManagedVenv();
+    removeShims();
+  } else if (marker.installer === "pipx" && which("pipx")) {
+    log("Uninstalling logion-cli via pipx...");
+    tryRun("pipx", ["uninstall", "logion-cli"]);
+  } else if (marker.installer === "uv" && which("uv")) {
+    log("Uninstalling logion-cli via uv tool...");
+    tryRun("uv", ["tool", "uninstall", "logion-cli"]);
+  }
+  try {
+    import_node_fs2.default.unlinkSync(MARKER_PATH);
+  } catch {
+  }
+}
+main();

package/dist/scripts/version-from-manifest.js

@@ -0,0 +1,63 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/version-from-manifest.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var PKG_DIR = import_node_path.default.join(__dirname, "..", "..");
+var MANIFEST_PATH = import_node_path.default.join(
+  PKG_DIR,
+  "..",
+  "..",
+  "releases",
+  "manifest-stable.json"
+);
+function main() {
+  let manifest;
+  try {
+    manifest = JSON.parse(import_node_fs.default.readFileSync(MANIFEST_PATH, "utf8"));
+  } catch {
+    process.stderr.write(`Could not read manifest at ${MANIFEST_PATH}
+`);
+    process.stderr.write("Run `make release-manifest` to generate it.\n");
+    process.exit(1);
+  }
+  const cliPkg = manifest.packages["logion-cli"];
+  if (!cliPkg?.version) {
+    process.stderr.write("Manifest does not contain logion-cli version.\n");
+    process.exit(1);
+  }
+  const version = cliPkg.version;
+  const pkgPath = import_node_path.default.join(PKG_DIR, "package.json");
+  const pkg = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf8"));
+  pkg.version = version;
+  pkg.logionCliVersion = version;
+  import_node_fs.default.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  process.stdout.write(
+    `Pinned logion-cli version to ${version} in package.json
+`
+  );
+}
+main();

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@logionsh/cli",
+  "version": "0.1.0",
+  "description": "Logion CLI — installs and shims the canonical Python logion-cli from PyPI.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicolasmelo1/logion.git",
+    "directory": "packages/npm-wrapper"
+  },
+  "homepage": "https://github.com/nicolasmelo1/logion#readme",
+  "bugs": {
+    "url": "https://github.com/nicolasmelo1/logion/issues"
+  },
+  "keywords": [
+    "logion",
+    "cli",
+    "marketplace",
+    "agent"
+  ],
+  "bin": {
+    "logion": "dist/bin/logion.js",
+    "lgn": "dist/bin/lgn.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "node dist/scripts/version-from-manifest.js",
+    "postinstall": "node dist/scripts/postinstall.js",
+    "preuninstall": "node dist/scripts/uninstall.js",
+    "pretest": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"{src,test}/**/*.ts\" \"*.{ts,json,md}\"",
+    "format:check": "prettier --check \"{src,test}/**/*.ts\" \"*.{ts,json,md}\""
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.18.0",
+    "@types/node": "^22.15.0",
+    "@vitest/eslint-plugin": "^1.1.25",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import-x": "^4.6.1",
+    "eslint-plugin-n": "^17.15.1",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-sonarjs": "^3.0.1",
+    "eslint-plugin-unicorn": "^56.0.1",
+    "prettier": "^3.4.2",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.20.0",
+    "vitest": "^3.2.0"
+  },
+  "logionCliVersion": "0.1.0"
+}