@mnemon-dev/mnemon 0.2.9-win32-x64 → 0.2.9

package/README.md

@@ -1,3 +1,18 @@
-# Mnemon win32-x64
+# Mnemon CLI
 
-Native win32/x64 artifact for `@mnemon-dev/mnemon@0.2.9-win32-x64`. Install `@mnemon-dev/mnemon` instead of this platform artifact directly.
+Mnemon gives LLM agents persistent memory and a local authority for durable,
+peer-to-peer work. This npm package installs the native Mnemon executable for
+the current operating system and CPU architecture.
+
+```bash
+npm install --global @mnemon-dev/mnemon
+mnemon --version
+mnemon update
+```
+
+The launcher supports 64-bit Intel and ARM systems on macOS, Linux, and
+Windows. Windows currently supports the Memory commands; Agency remains
+unavailable until its local authority boundary has native Windows security.
+
+Project documentation and source code are available at
+<https://github.com/mnemon-dev/mnemon>.

package/bin/mnemon.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import { existsSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { runChild, settle } from "../lib/child.js";
+import { selectTarget } from "../lib/targets.js";
+import { updateNpmInstall } from "../lib/update.js";
+
+const require = createRequire(import.meta.url);
+
+async function main() {
+  const packageRoot = realpathSync(path.join(path.dirname(fileURLToPath(import.meta.url)), ".."));
+  const args = process.argv.slice(2);
+  if (args.length === 1 && args[0] === "update") {
+    settle(await updateNpmInstall({ packageRoot }));
+    return;
+  }
+
+  const target = selectTarget(process.platform, process.arch);
+  let platformRoot;
+  try {
+    platformRoot = path.dirname(require.resolve(`${target.alias}/package.json`));
+  } catch {
+    throw new Error(
+      `Missing optional dependency ${target.alias}. Reinstall Mnemon with: ` +
+        "npm install --global --include=optional @mnemon-dev/mnemon@latest",
+    );
+  }
+
+  const binary = path.join(platformRoot, target.binary);
+  if (!existsSync(binary)) {
+    throw new Error(
+      `Mnemon native binary is missing for ${target.id}. Reinstall with: ` +
+        "npm install --global --include=optional @mnemon-dev/mnemon@latest",
+    );
+  }
+  settle(await runChild(binary, args));
+}
+
+try {
+  await main();
+} catch (error) {
+  process.stderr.write(`mnemon: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/lib/child.js

@@ -0,0 +1,38 @@
+import { spawn } from "node:child_process";
+
+export async function runChild(command, args, options = {}) {
+  const child = spawn(command, args, { stdio: "inherit", ...options });
+  const forward = (signal) => {
+    if (!child.killed) {
+      try {
+        child.kill(signal);
+      } catch {
+        // The child may have settled between the check and signal delivery.
+      }
+    }
+  };
+  const handlers = new Map();
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    const handler = () => forward(signal);
+    handlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  try {
+    return await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("exit", (code, signal) => resolve({ code, signal }));
+    });
+  } finally {
+    for (const [signal, handler] of handlers) {
+      process.off(signal, handler);
+    }
+  }
+}
+
+export function settle(result) {
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    return;
+  }
+  process.exitCode = result.code ?? 1;
+}

package/lib/targets.js

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+
+const targetFile = new URL("../targets.json", import.meta.url);
+const parsedTargets = JSON.parse(readFileSync(targetFile, "utf8"));
+
+export const targets = validateTargets(parsedTargets);
+
+export function selectTarget(platform, arch) {
+  const target = targets.find(
+    (candidate) => candidate.platform === platform && candidate.arch === arch,
+  );
+  if (!target) {
+    throw new Error(`Unsupported platform: ${platform} (${arch})`);
+  }
+  return target;
+}
+
+function validateTargets(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("Mnemon target registry is empty");
+  }
+  const ids = new Set();
+  const runtimes = new Set();
+  const aliases = new Set();
+  return Object.freeze(
+    value.map((target) => {
+      for (const field of ["id", "platform", "arch", "goos", "goarch", "alias", "binary"]) {
+        if (typeof target[field] !== "string" || target[field].length === 0) {
+          throw new Error(`Mnemon target has invalid ${field}`);
+        }
+      }
+      const runtime = `${target.platform}/${target.arch}`;
+      if (ids.has(target.id) || runtimes.has(runtime) || aliases.has(target.alias)) {
+        throw new Error(`Mnemon target registry contains a duplicate: ${target.id}`);
+      }
+      ids.add(target.id);
+      runtimes.add(runtime);
+      aliases.add(target.alias);
+      return Object.freeze({ ...target });
+    }),
+  );
+}

package/lib/update.js

@@ -0,0 +1,178 @@
+import { constants } from "node:fs";
+import { access, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+import { runChild } from "./child.js";
+
+const packageName = "@mnemon-dev/mnemon";
+
+export async function updateNpmInstall({
+  packageRoot,
+  runner = productionRunner(),
+  stdout = process.stdout,
+}) {
+  const currentRoot = await canonicalPath(packageRoot);
+  const current = await readPackage(currentRoot);
+  const npm = await resolveNpmInvocation();
+
+  const globalRoot = await npmPath(runner, npm, ["root", "--global"]);
+  let expectedRoot;
+  try {
+    expectedRoot = await canonicalPath(path.join(globalRoot, ...packageName.split("/")));
+  } catch (error) {
+    throw notManagedError(`cannot resolve the package in npm's global root: ${error.message}`);
+  }
+  if (!samePath(expectedRoot, currentRoot)) {
+    throw notManagedError("npm on PATH owns a different global installation");
+  }
+
+  const prefix = await npmPath(runner, npm, ["prefix", "--global"]);
+  if (!pathWithin(prefix, globalRoot)) {
+    throw notManagedError("npm's global package root is outside its prefix");
+  }
+
+  const result = await runner.run(npm.command, [
+    ...npm.args,
+    "install",
+    "--global",
+    "--prefix",
+    prefix,
+    "--include=optional",
+    `${packageName}@latest`,
+  ]);
+  if (result.signal) {
+    return result;
+  }
+  if (result.code !== 0) {
+    throw new Error(`npm install exited with status ${result.code ?? "unknown"}`);
+  }
+
+  const updated = await readPackage(currentRoot);
+  if (current.version === updated.version) {
+    stdout.write(`Mnemon is already up to date (${updated.version}).\n`);
+  } else {
+    stdout.write(`Updated Mnemon ${current.version} -> ${updated.version}.\n`);
+  }
+  return { code: 0, signal: null };
+}
+
+function productionRunner() {
+  return {
+    output(command, args) {
+      const result = spawnSync(command, args, { encoding: "utf8" });
+      if (result.error) {
+        throw result.error;
+      }
+      if (result.status !== 0) {
+        throw new Error(
+          `${command} ${args.join(" ")} exited with status ${result.status ?? "unknown"}: ` +
+            (result.stderr ?? "").trim(),
+        );
+      }
+      return result.stdout;
+    },
+    run(command, args) {
+      return runChild(command, args);
+    },
+  };
+}
+
+async function npmPath(runner, npm, args) {
+  try {
+    const value = runner.output(npm.command, [...npm.args, ...args]).trim();
+    return await canonicalPath(value);
+  } catch (error) {
+    throw new Error(`cannot inspect npm ${args[0]}: ${error.message}`);
+  }
+}
+
+async function resolveNpmInvocation() {
+  if (process.platform !== "win32") {
+    return { command: "npm", args: [] };
+  }
+
+  const pathValue = Object.entries(process.env).find(
+    ([name]) => name.toLowerCase() === "path",
+  )?.[1];
+  for (let entry of pathValue?.split(path.delimiter) ?? []) {
+    if (entry.startsWith('"') && entry.endsWith('"')) {
+      entry = entry.slice(1, -1);
+    }
+    if (entry === "") {
+      continue;
+    }
+    const npmExecutable = path.join(entry, "npm.exe");
+    try {
+      await access(npmExecutable, constants.F_OK);
+      return { command: npmExecutable, args: [] };
+    } catch {
+      // Standard Node.js installations expose npm through npm.cmd instead.
+    }
+    const npmCommand = path.join(entry, "npm.cmd");
+    const npmCLI = path.join(entry, "node_modules", "npm", "bin", "npm-cli.js");
+    try {
+      await Promise.all([
+        access(npmCommand, constants.F_OK),
+        access(npmCLI, constants.F_OK),
+      ]);
+      // A .cmd file cannot be spawned directly without a shell. Invoke npm's
+      // JavaScript entry point with the already-running Node executable.
+      return { command: process.execPath, args: [npmCLI] };
+    } catch {
+      // Keep searching PATH for a complete Node.js/npm installation.
+    }
+  }
+  throw new Error("npm is required to update Mnemon but was not found on PATH");
+}
+
+async function canonicalPath(value) {
+  if (typeof value !== "string" || value.trim() !== value || !path.isAbsolute(value)) {
+    throw new Error("path is not absolute and clean");
+  }
+  const cleaned = path.normalize(value);
+  if (cleaned !== value) {
+    throw new Error("path is not absolute and clean");
+  }
+  return realpath(value);
+}
+
+async function readPackage(root) {
+  let metadata;
+  try {
+    metadata = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"));
+  } catch (error) {
+    throw notManagedError(`cannot read package metadata: ${error.message}`);
+  }
+  if (
+    metadata.name !== packageName ||
+    typeof metadata.version !== "string" ||
+    metadata.version.trim() === ""
+  ) {
+    throw notManagedError("package name or version is invalid");
+  }
+  return metadata;
+}
+
+function pathWithin(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return (
+    relative !== "" &&
+    relative !== ".." &&
+    !relative.startsWith(`..${path.sep}`) &&
+    !path.isAbsolute(relative)
+  );
+}
+
+function samePath(left, right) {
+  return process.platform === "win32"
+    ? left.toLowerCase() === right.toLowerCase()
+    : left === right;
+}
+
+function notManagedError(reason) {
+  return new Error(
+    `this Mnemon installation is not managed by npm: ${reason}; ` +
+      `migrate once with: npm install --global ${packageName}@latest`,
+  );
+}

package/package.json

@@ -1,25 +1,48 @@
 {
   "name": "@mnemon-dev/mnemon",
-  "version": "0.2.9-win32-x64",
-  "description": "Mnemon native binary for win32/x64",
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
+  "version": "0.2.9",
+  "description": "Persistent memory and durable agency for LLM agents",
+  "type": "module",
+  "bin": {
+    "mnemon": "bin/mnemon.js"
+  },
   "files": [
     "bin",
+    "lib",
+    "targets.json",
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "mnemon",
+    "agent-memory",
+    "llm",
+    "cli"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mnemon-dev/mnemon.git"
   },
   "homepage": "https://github.com/mnemon-dev/mnemon",
+  "bugs": {
+    "url": "https://github.com/mnemon-dev/mnemon/issues"
+  },
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
+  },
+  "optionalDependencies": {
+    "@mnemon-dev/mnemon-darwin-x64": "npm:@mnemon-dev/mnemon@0.2.9-darwin-x64",
+    "@mnemon-dev/mnemon-darwin-arm64": "npm:@mnemon-dev/mnemon@0.2.9-darwin-arm64",
+    "@mnemon-dev/mnemon-linux-x64": "npm:@mnemon-dev/mnemon@0.2.9-linux-x64",
+    "@mnemon-dev/mnemon-linux-arm64": "npm:@mnemon-dev/mnemon@0.2.9-linux-arm64",
+    "@mnemon-dev/mnemon-win32-x64": "npm:@mnemon-dev/mnemon@0.2.9-win32-x64",
+    "@mnemon-dev/mnemon-win32-arm64": "npm:@mnemon-dev/mnemon@0.2.9-win32-arm64"
   }
 }

package/targets.json

@@ -0,0 +1,56 @@
+[
+  {
+    "id": "darwin-x64",
+    "platform": "darwin",
+    "arch": "x64",
+    "goos": "darwin",
+    "goarch": "amd64",
+    "alias": "@mnemon-dev/mnemon-darwin-x64",
+    "binary": "bin/mnemon"
+  },
+  {
+    "id": "darwin-arm64",
+    "platform": "darwin",
+    "arch": "arm64",
+    "goos": "darwin",
+    "goarch": "arm64",
+    "alias": "@mnemon-dev/mnemon-darwin-arm64",
+    "binary": "bin/mnemon"
+  },
+  {
+    "id": "linux-x64",
+    "platform": "linux",
+    "arch": "x64",
+    "goos": "linux",
+    "goarch": "amd64",
+    "alias": "@mnemon-dev/mnemon-linux-x64",
+    "binary": "bin/mnemon"
+  },
+  {
+    "id": "linux-arm64",
+    "platform": "linux",
+    "arch": "arm64",
+    "goos": "linux",
+    "goarch": "arm64",
+    "alias": "@mnemon-dev/mnemon-linux-arm64",
+    "binary": "bin/mnemon"
+  },
+  {
+    "id": "win32-x64",
+    "platform": "win32",
+    "arch": "x64",
+    "goos": "windows",
+    "goarch": "amd64",
+    "alias": "@mnemon-dev/mnemon-win32-x64",
+    "binary": "bin/mnemon.exe"
+  },
+  {
+    "id": "win32-arm64",
+    "platform": "win32",
+    "arch": "arm64",
+    "goos": "windows",
+    "goarch": "arm64",
+    "alias": "@mnemon-dev/mnemon-win32-arm64",
+    "binary": "bin/mnemon.exe"
+  }
+]