@memorax/memorax-code 0.1.0

package/lib/resolve-claude-command.mjs

@@ -0,0 +1,47 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  commandOnPath,
+  defaultVsCodeExtensionRoots,
+  findVsCodeExtensionCommand,
+} from "./vscode-extension-command.mjs";
+
+export function resolveClaudeCommand({
+  env = process.env,
+  homeDir = homedir(),
+  platform = process.platform,
+  arch = process.arch,
+  vscodeExtensionRoots = defaultVsCodeExtensionRoots(homeDir),
+} = {}) {
+  const configured = nonEmpty(env.MEMORAX_CODE_CLAUDE_COMMAND);
+  if (configured) return { command: configured, source: "configured" };
+
+  if (commandOnPath("claude", env.PATH, platform, env.PATHEXT)) {
+    return { command: "claude", source: "path" };
+  }
+
+  const vscodeCommand = findVsCodeExtensionCommand({
+    extensionId: "anthropic.claude-code",
+    extensionRoots: vscodeExtensionRoots,
+    platform,
+    arch,
+    commandCandidates: (extensionRoot) => [
+      join(extensionRoot, "resources", "native-binary", platform === "win32" ? "claude.exe" : "claude"),
+    ],
+  });
+  if (vscodeCommand) return { command: vscodeCommand, source: "vscode-bundled" };
+
+  return { command: "claude", source: "unavailable" };
+}
+
+export function ensureClaudeCommandEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const resolved = resolveClaudeCommand({ ...options, env });
+  if (resolved.source !== "unavailable") env.MEMORAX_CODE_CLAUDE_COMMAND = resolved.command;
+  return resolved;
+}
+
+function nonEmpty(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || undefined;
+}

package/lib/resolve-codex-command.mjs

@@ -0,0 +1,94 @@
+import { readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  commandOnPath,
+  defaultVsCodeExtensionRoots,
+  findVsCodeExtensionCommand,
+  isExecutableCommand,
+} from "./vscode-extension-command.mjs";
+
+const APP_BUNDLE_NAMES = ["ChatGPT.app", "Codex.app"];
+
+export function resolveCodexCommand({
+  env = process.env,
+  homeDir = homedir(),
+  platform = process.platform,
+  arch = process.arch,
+  applicationRoots = [join(homeDir, "Applications"), "/Applications"],
+  vscodeExtensionRoots = defaultVsCodeExtensionRoots(homeDir),
+} = {}) {
+  const npmOverride = nonEmpty(env.MEMORAX_CODE_CODEX_COMMAND);
+  if (npmOverride) return { command: npmOverride, source: "npm-override" };
+
+  const configured = nonEmpty(env.CODEX_CLI_PATH);
+  if (configured) return { command: configured, source: "configured" };
+
+  if (commandOnPath("codex", env.PATH, platform, env.PATHEXT)) {
+    return { command: "codex", source: "path" };
+  }
+
+  if (platform === "darwin") {
+    for (const root of applicationRoots) {
+      for (const appName of APP_BUNDLE_NAMES) {
+        const command = join(root, appName, "Contents", "Resources", "codex");
+        if (isExecutableCommand(command, platform)) return { command, source: "app-bundled" };
+      }
+    }
+  }
+
+  const vscodeCommand = findVsCodeExtensionCommand({
+    extensionId: "openai.chatgpt",
+    extensionRoots: vscodeExtensionRoots,
+    platform,
+    arch,
+    commandCandidates: (extensionRoot) => codexExtensionCommandCandidates(extensionRoot, platform, arch),
+  });
+  if (vscodeCommand) return { command: vscodeCommand, source: "vscode-bundled" };
+
+  return { command: "codex", source: "unavailable" };
+}
+
+export function ensureCodexCommandEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const resolved = resolveCodexCommand({ ...options, env });
+  if (resolved.source !== "unavailable") env.CODEX_CLI_PATH = resolved.command;
+  return resolved;
+}
+
+function codexExtensionCommandCandidates(extensionRoot, platform, arch) {
+  const executable = platform === "win32" ? "codex.exe" : "codex";
+  const binRoot = join(extensionRoot, "bin");
+  const preferred = codexPlatformDirectories(platform, arch)
+    .map((directory) => join(binRoot, directory, executable));
+  let discovered = [];
+  try {
+    discovered = readdirSync(binRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+      .map((entry) => join(binRoot, entry.name, executable));
+  } catch {
+    // The preferred paths still provide deterministic candidates.
+  }
+  return [...new Set([...preferred, ...discovered])];
+}
+
+function codexPlatformDirectories(platform, arch) {
+  if (platform === "darwin") {
+    if (arch === "arm64") return ["macos-aarch64", "darwin-arm64"];
+    if (arch === "x64") return ["macos-x86_64", "macos-x64", "darwin-x64"];
+  }
+  if (platform === "linux") {
+    if (arch === "arm64") return ["linux-aarch64", "linux-arm64"];
+    if (arch === "x64") return ["linux-x86_64", "linux-x64"];
+  }
+  if (platform === "win32") {
+    if (arch === "arm64") return ["windows-aarch64", "windows-arm64", "win32-arm64"];
+    if (arch === "x64") return ["windows-x86_64", "windows-x64", "win32-x64"];
+  }
+  return [];
+}
+
+function nonEmpty(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || undefined;
+}

package/lib/run-entrypoint.mjs

@@ -0,0 +1,83 @@
+import { delimiter, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { unsupportedNodeVersionMessage } from "./node-version.mjs";
+import { ensureClaudeCommandEnv } from "./resolve-claude-command.mjs";
+import { ensureCodexCommandEnv } from "./resolve-codex-command.mjs";
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+function ensureBundledSkillEnv() {
+  const skillsRoot = join(packageRoot, "lib", "memorax-code-codex-adapter", "skills");
+  if (!process.env.MEMORAX_CODE_CODEX_DEFAULT_SKILLS_ROOT?.trim()) {
+    process.env.MEMORAX_CODE_CODEX_DEFAULT_SKILLS_ROOT = skillsRoot;
+  }
+}
+
+export function ensureClaudeMarketplaceEnv() {
+  const marketplaceRoot = join(packageRoot, "lib", "memorax-code-claude-marketplace");
+  if (!process.env.MEMORAX_CODE_CLAUDE_MARKETPLACE_ROOT?.trim()) {
+    process.env.MEMORAX_CODE_CLAUDE_MARKETPLACE_ROOT = marketplaceRoot;
+  }
+  const skillsRoot = join(packageRoot, "lib", "memorax-code-claude-adapter", "skills");
+  if (!process.env.MEMORAX_CODE_CLAUDE_SKILLS_ROOT?.trim()) {
+    process.env.MEMORAX_CODE_CLAUDE_SKILLS_ROOT = skillsRoot;
+  }
+}
+
+export function installWatchPathsForPackageRoot(root = packageRoot) {
+  return [
+    join(root, "package.json"),
+    join(root, "bin", "memorax-code.mjs"),
+    join(root, "lib", "memorax-code-backend", "dist", "server.js"),
+  ];
+}
+
+export function ensureInstallWatchdogEnv(root = packageRoot) {
+  if (!process.env.MEMORAX_CODE_INSTALL_WATCH_PATHS?.trim()) {
+    process.env.MEMORAX_CODE_INSTALL_WATCH_PATHS = installWatchPathsForPackageRoot(root).join(delimiter);
+  }
+  if (!process.env.MEMORAX_CODE_INSTALL_WATCHDOG?.trim()) {
+    process.env.MEMORAX_CODE_INSTALL_WATCHDOG = "1";
+  }
+}
+
+export async function runBackendEntrypoint(relativeEntrypoint) {
+  if (!ensureSupportedNodeRuntime()) return;
+  ensureCodexCommandEnv();
+  ensureClaudeCommandEnv();
+  ensureBundledSkillEnv();
+  ensureClaudeMarketplaceEnv();
+  ensureInstallWatchdogEnv();
+  const entrypoint = join(packageRoot, "lib", "memorax-code-backend", "dist", relativeEntrypoint);
+  const previousArgv1 = process.argv[1];
+  process.argv[1] = entrypoint;
+  try {
+    await import(pathToFileURL(entrypoint).href);
+  } finally {
+    process.argv[1] = previousArgv1;
+  }
+}
+
+export async function runCodexAdapterCli() {
+  if (!ensureSupportedNodeRuntime()) return;
+  ensureCodexCommandEnv();
+  ensureBundledSkillEnv();
+  const entrypoint = join(packageRoot, "lib", "memorax-code-codex-adapter", "src", "cli.mjs");
+  await import(pathToFileURL(entrypoint).href);
+}
+
+export async function runClaudeAdapterCli() {
+  if (!ensureSupportedNodeRuntime()) return;
+  ensureClaudeCommandEnv();
+  ensureClaudeMarketplaceEnv();
+  const entrypoint = join(packageRoot, "lib", "memorax-code-claude-adapter", "src", "cli.mjs");
+  await import(pathToFileURL(entrypoint).href);
+}
+
+function ensureSupportedNodeRuntime() {
+  const message = unsupportedNodeVersionMessage();
+  if (!message) return true;
+  console.error(`memorax-code: ${message}`);
+  process.exitCode = 1;
+  return false;
+}

package/lib/vscode-extension-command.mjs

@@ -0,0 +1,119 @@
+import { accessSync, constants, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+
+export function defaultVsCodeExtensionRoots(homeDir = homedir()) {
+  return [
+    join(homeDir, ".vscode", "extensions"),
+    join(homeDir, ".vscode-insiders", "extensions"),
+    join(homeDir, ".vscode-server", "extensions"),
+    join(homeDir, ".vscode-server-insiders", "extensions"),
+  ];
+}
+
+export function findVsCodeExtensionCommand({
+  extensionId,
+  extensionRoots,
+  commandCandidates,
+  platform = process.platform,
+  arch = process.arch,
+} = {}) {
+  if (typeof extensionId !== "string" || !extensionId.trim()) return undefined;
+  if (!Array.isArray(extensionRoots) || typeof commandCandidates !== "function") return undefined;
+
+  for (const root of new Set(extensionRoots)) {
+    for (const extensionRoot of matchingExtensionRoots(root, extensionId, platform, arch)) {
+      for (const command of commandCandidates(extensionRoot)) {
+        if (isExecutableCommand(command, platform)) return command;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function commandOnPath(command, pathValue, platform = process.platform, pathExtValue) {
+  const extensions = platform === "win32"
+    ? String(pathExtValue ?? ".EXE;.CMD;.BAT;.COM").split(";")
+    : [""];
+  for (const root of String(pathValue ?? "").split(delimiter)) {
+    if (!root) continue;
+    for (const extension of extensions) {
+      if (isExecutableCommand(join(root, `${command}${extension}`), platform)) return true;
+    }
+  }
+  return false;
+}
+
+export function isExecutableCommand(path, platform = process.platform) {
+  try {
+    accessSync(path, platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function matchingExtensionRoots(root, extensionId, platform, arch) {
+  const [expectedPublisher, expectedName] = extensionId.toLowerCase().split(".", 2);
+  if (!expectedPublisher || !expectedName) return [];
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  return entries
+    .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+    .map((entry) => {
+      const extensionRoot = join(root, entry.name);
+      const manifest = readExtensionManifest(extensionRoot);
+      return {
+        extensionRoot,
+        publisher: String(manifest?.publisher ?? "").toLowerCase(),
+        name: String(manifest?.name ?? "").toLowerCase(),
+        version: String(manifest?.version ?? ""),
+        targetPlatform: manifest?.__metadata?.targetPlatform,
+      };
+    })
+    .filter((entry) => (
+      entry.publisher === expectedPublisher
+      && entry.name === expectedName
+      && targetPlatformMatches(entry.targetPlatform, platform, arch)
+    ))
+    .sort((left, right) => (
+      right.version.localeCompare(left.version, "en", { numeric: true, sensitivity: "base" })
+      || right.extensionRoot.localeCompare(left.extensionRoot, "en", { numeric: true, sensitivity: "base" })
+    ))
+    .map((entry) => entry.extensionRoot);
+}
+
+function readExtensionManifest(extensionRoot) {
+  try {
+    return JSON.parse(readFileSync(join(extensionRoot, "package.json"), "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function targetPlatformMatches(value, platform, arch) {
+  const target = String(value ?? "").trim().toLowerCase();
+  if (!target || target === "undefined" || target === "universal") return true;
+  return vscodeTargetPlatformAliases(platform, arch).includes(target);
+}
+
+function vscodeTargetPlatformAliases(platform, arch) {
+  if (platform === "darwin") {
+    if (arch === "arm64") return ["darwin-arm64"];
+    if (arch === "x64") return ["darwin-x64"];
+  }
+  if (platform === "linux") {
+    if (arch === "arm64") return ["linux-arm64", "alpine-arm64"];
+    if (arch === "x64") return ["linux-x64", "alpine-x64"];
+  }
+  if (platform === "win32") {
+    if (arch === "arm64") return ["win32-arm64"];
+    if (arch === "x64") return ["win32-x64"];
+  }
+  return [`${platform}-${arch}`];
+}

package/lib/windows-cli-invocation.mjs

@@ -0,0 +1,100 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+export function resolveWindowsCliInvocation(command, args, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") return { command, args };
+  const pathApi = path.win32;
+  const fileExists = options.existsSync ?? existsSync;
+  const env = options.env ?? process.env;
+  let resolvedCommand = options.resolvedCommand;
+  if (!resolvedCommand && !/[\\/]/.test(command)) {
+    const located = options.whereOutput === undefined
+      ? (options.spawnSync ?? spawnSync)("where.exe", [command], {
+        env,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+      })
+      : { status: 0, stdout: options.whereOutput };
+    if (located.status === 0) {
+      resolvedCommand = selectWindowsCommandCandidate(command, located.stdout);
+    }
+  }
+  resolvedCommand ??= command;
+  if (/\.(?:exe|com)$/i.test(resolvedCommand)) return { command: resolvedCommand, args };
+  if (!/\.(?:cmd|bat)$/i.test(resolvedCommand)) {
+    throw new Error(`refusing to execute unsupported Windows command shim: ${resolvedCommand}`);
+  }
+
+  const name = pathApi.basename(resolvedCommand).replace(/\.(?:cmd|bat)$/i, "").toLowerCase();
+  const nativeCli = nativeCliEntrypointCandidates(name, resolvedCommand, env, pathApi)
+    .filter(isNativeEntrypoint)
+    .find((candidate) => fileExists(candidate));
+  if (nativeCli) return { command: nativeCli, args };
+  const cli = cliEntrypointCandidates(name, resolvedCommand, env, pathApi)
+    .filter(isNodeEntrypoint)
+    .find((candidate) => fileExists(candidate));
+  if (!cli) {
+    const override = name === "claude" ? "MEMORAX_CODE_CLAUDE_CLI_JS" : "MEMORAX_CODE_CODEX_CLI_JS";
+    throw new Error(
+      `refusing to execute ${pathApi.basename(resolvedCommand)} through a command shell; `
+      + `set ${override} to its Node entrypoint`,
+    );
+  }
+  return { command: options.nodePath ?? process.execPath, args: [cli, ...args] };
+}
+
+function nativeCliEntrypointCandidates(name, command, env, pathApi) {
+  if (name !== "claude") return [];
+  const root = pathApi.dirname(command);
+  return [
+    env.MEMORAX_CODE_CLAUDE_CLI_EXE,
+    env.CLAUDE_CLI_EXE,
+    pathApi.join(root, "node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"),
+    pathApi.join(root, "..", "@anthropic-ai", "claude-code", "bin", "claude.exe"),
+  ];
+}
+
+function cliEntrypointCandidates(name, command, env, pathApi) {
+  const root = pathApi.dirname(command);
+  if (name === "codex") {
+    return [
+      env.MEMORAX_CODE_CODEX_CLI_JS,
+      env.CODEX_CLI_JS,
+      pathApi.join(root, "node_modules", "@openai", "codex", "bin", "codex.js"),
+      pathApi.join(root, "..", "@openai", "codex", "bin", "codex.js"),
+    ];
+  }
+  if (name === "claude") {
+    return [
+      env.MEMORAX_CODE_CLAUDE_CLI_JS,
+      env.CLAUDE_CLI_JS,
+      pathApi.join(root, "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+      pathApi.join(root, "..", "@anthropic-ai", "claude-code", "cli.js"),
+    ];
+  }
+  return [];
+}
+
+function isNativeEntrypoint(value) {
+  return typeof value === "string" && /\.(?:exe|com)$/i.test(value);
+}
+
+function isNodeEntrypoint(value) {
+  return typeof value === "string" && /\.(?:cjs|js|mjs)$/i.test(value);
+}
+
+export function selectWindowsCommandCandidate(command, output) {
+  const candidates = String(output ?? "")
+    .split(/\r?\n/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const selected = candidates.find((value) => /\.(?:cmd|bat)$/i.test(value))
+    ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value));
+  if (!selected) {
+    throw new Error(`where.exe did not return a safe executable or command shim for ${command}`);
+  }
+  return selected;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@memorax/memorax-code",
+  "version": "0.1.0",
+  "description": "MemoraX Code CLI, local memory backend, Codex and Claude Code adapters, skills, and Memory Viewer.",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/memorax-ai/memorax-code#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/memorax-ai/memorax-code.git"
+  },
+  "bugs": {
+    "url": "https://github.com/memorax-ai/memorax-code/issues"
+  },
+  "keywords": [
+    "agent",
+    "codex",
+    "memory",
+    "memorax"
+  ],
+  "bin": {
+    "memorax-code": "bin/memorax-code.mjs",
+    "memorax-cli": "bin/memorax-cli.mjs",
+    "memorax-code-backend": "bin/memorax-code-backend.mjs",
+    "memorax-code-claude": "bin/memorax-code-claude.mjs",
+    "memorax-code-codex": "bin/memorax-code-codex.mjs"
+  },
+  "files": [
+    "bin",
+    "docs",
+    "lib",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "smol-toml": "^1.7.0"
+  },
+  "scripts": {
+    "preinstall": "node ./bin/memorax-code-npm-preinstall.mjs",
+    "postinstall": "node ./bin/memorax-code-plugin-postinstall.mjs"
+  }
+}