@getmikie/cli 1.1.72

package/README.md

@@ -0,0 +1,18 @@
+# Mikie
+
+This package is a thin launcher for Mikie's compiled native relay.
+
+```sh
+npx -y @getmikie/cli mcp
+```
+
+For a persistent command path:
+
+```sh
+npm install --global @getmikie/cli
+mikie mcp
+```
+
+The launcher contains no relay, pricing, receipt, or model logic. npm installs
+the matching `@getmikie/*` optional platform package and the launcher executes that
+binary with inherited stdio.

package/bin/mikie.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+import { createRequire } from "node:module";
+
+import {
+  launchNative,
+  resolveNativeBinary,
+  translateArguments,
+} from "../lib/launcher.mjs";
+
+const require = createRequire(import.meta.url);
+const packageMetadata = require("../package.json");
+const arguments_ = process.argv.slice(2);
+
+if (arguments_.length === 1 && ["--version", "-v"].includes(arguments_[0])) {
+  console.log(packageMetadata.version);
+} else if (arguments_.length === 1 && ["--help", "-h"].includes(arguments_[0])) {
+  console.log(`Mikie ${packageMetadata.version}
+
+Usage:
+  mikie mcp [--adapter codex|claude_code]
+  mikie login
+  mikie connect .
+  mikie doctor
+
+All commands execute the compiled Mikie native engine.`);
+} else {
+  try {
+    const binary = await resolveNativeBinary();
+    process.exitCode = await launchNative(binary, translateArguments(arguments_));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Mikie is unavailable";
+    console.error(`mikie: ${message}`);
+    process.exitCode = 1;
+  }
+}

package/lib/launcher.mjs

@@ -0,0 +1,124 @@
+import { createRequire } from "node:module";
+import { access, stat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+const PLATFORM_PACKAGES = new Map([
+  ["win32-x64", { packageName: "@getmikie/win32-x64", binaryPath: "bin/mikie.exe" }],
+  ["darwin-arm64", { packageName: "@getmikie/darwin-arm64", binaryPath: "bin/mikie" }],
+  ["darwin-x64", { packageName: "@getmikie/darwin-x64", binaryPath: "bin/mikie" }],
+  ["linux-x64-gnu", { packageName: "@getmikie/linux-x64-gnu", binaryPath: "bin/mikie" }],
+]);
+
+const SIGNAL_EXIT_CODES = new Map([
+  ["SIGHUP", 129],
+  ["SIGINT", 130],
+  ["SIGTERM", 143],
+]);
+
+function currentRuntimeUsesGlibc() {
+  try {
+    const report = process.report?.getReport();
+    return Boolean(report?.header?.glibcVersionRuntime);
+  } catch {
+    return false;
+  }
+}
+
+export function selectPlatformPackage({
+  platform = process.platform,
+  arch = process.arch,
+  glibc = platform === "linux" ? currentRuntimeUsesGlibc() : undefined,
+} = {}) {
+  const key = platform === "linux" && glibc ? `${platform}-${arch}-gnu` : `${platform}-${arch}`;
+  const selected = PLATFORM_PACKAGES.get(key);
+  if (!selected) {
+    throw new Error("Mikie does not publish a native npm engine for this platform");
+  }
+  return { ...selected };
+}
+
+export function translateArguments(arguments_) {
+  if (arguments_[0] !== "mcp") {
+    return [...arguments_];
+  }
+  return ["serve", ...arguments_.slice(1)];
+}
+
+export async function resolveNativeBinary({
+  platform = process.platform,
+  arch = process.arch,
+  glibc,
+  resolvePackage,
+} = {}) {
+  const selected = selectPlatformPackage({ platform, arch, glibc });
+  const require = createRequire(import.meta.url);
+  let packageJson;
+  try {
+    packageJson = (resolvePackage ?? ((name) => require.resolve(name)))(
+      `${selected.packageName}/package.json`,
+    );
+  } catch {
+    throw new Error(`Required Mikie native package ${selected.packageName} is unavailable`);
+  }
+
+  const binary = path.join(path.dirname(packageJson), ...selected.binaryPath.split("/"));
+  try {
+    const metadata = await stat(binary);
+    if (!metadata.isFile() || metadata.size === 0) {
+      throw new Error("invalid binary");
+    }
+    if (platform !== "win32") {
+      await access(binary, fsConstants.X_OK);
+    }
+  } catch {
+    throw new Error(`Required Mikie native package ${selected.packageName} is invalid`);
+  }
+  return binary;
+}
+
+export function launchNative(
+  binary,
+  arguments_,
+  { spawnProcess = spawn, parentProcess = process, environment = process.env } = {},
+) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const child = spawnProcess(binary, arguments_, {
+      shell: false,
+      stdio: "inherit",
+      windowsHide: true,
+      env: { ...environment, MIKIE_DISTRIBUTION_MODE: "npm" },
+    });
+    const handlers = new Map();
+    const cleanup = () => {
+      for (const [signal, handler] of handlers) {
+        parentProcess.off(signal, handler);
+      }
+    };
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+      const handler = () => {
+        try {
+          child.kill(signal);
+        } catch {
+          // The native process may already have exited.
+        }
+      };
+      handlers.set(signal, handler);
+      parentProcess.on(signal, handler);
+    }
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error("Mikie native engine could not be started", { cause: error }));
+    });
+    child.once("exit", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(Number.isInteger(code) ? code : (SIGNAL_EXIT_CODES.get(signal) ?? 1));
+    });
+  });
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@getmikie/cli",
+  "version": "1.1.72",
+  "description": "Native Mikie relay launcher for MCP clients",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "mikie": "bin/mikie.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "optionalDependencies": {
+    "@getmikie/darwin-arm64": "1.1.72",
+    "@getmikie/darwin-x64": "1.1.72",
+    "@getmikie/linux-x64-gnu": "1.1.72",
+    "@getmikie/win32-x64": "1.1.72"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}