@memorax/memorax-code 0.1.5 → 0.1.7

package/lib/resolve-codex-command.mjs

@@ -8,9 +8,10 @@ import {
   findVsCodeExtensionCommand,
   isExecutableCommand,
 } from "./vscode-extension-command.mjs";
+import { resolveWindowsCliInvocation } from "./windows-cli-invocation.mjs";
 
 const APP_BUNDLE_NAMES = ["ChatGPT.app", "Codex.app"];
-const WINDOWS_CODEX_APP_PROBE_TIMEOUT_MS = 10_000;
+const WINDOWS_CODEX_DISCOVERY_PROBE_TIMEOUT_MS = 2_000;
 const WINDOWS_CODEX_APP_RUNTIME_SEGMENTS = ["plugins", ".plugin-appserver", "codex.exe"];
 
 export function resolveCodexCommand({
@@ -19,10 +20,12 @@ export function resolveCodexCommand({
   platform = process.platform,
   arch = process.arch,
   applicationRoots = [join(homeDir, "Applications"), "/Applications"],
+  pathCommandAvailable = commandOnPath,
   vscodeExtensionRoots = defaultVsCodeExtensionRoots(homeDir),
   windowsAppProbe = spawnSync,
   windowsAppRuntimePaths,
   windowsPathExists = isExecutableCommand,
+  windowsPathProbe = spawnSync,
 } = {}) {
   const npmOverride = nonEmpty(env.MEMORAX_CODE_CODEX_COMMAND);
   if (npmOverride) return { command: npmOverride, source: "npm-override" };
@@ -30,7 +33,13 @@ export function resolveCodexCommand({
   const configured = nonEmpty(env.CODEX_CLI_PATH);
   if (configured) return { command: configured, source: "configured" };
 
-  if (commandOnPath("codex", env.PATH, platform, env.PATHEXT)) {
+  if (
+    pathCommandAvailable("codex", env.PATH, platform, env.PATHEXT)
+    && (
+      platform !== "win32"
+      || windowsCodexPathCommandIsRunnable("codex", env, windowsPathProbe)
+    )
+  ) {
     return { command: "codex", source: "path" };
   }
 
@@ -77,7 +86,10 @@ export function resolveWindowsCodexAppCommand({
   const codexHome = nonEmpty(env.CODEX_HOME) ?? win32.join(homeDir, ".codex");
   const candidates = runtimePaths ?? [win32.join(codexHome, ...WINDOWS_CODEX_APP_RUNTIME_SEGMENTS)];
   for (const command of candidates) {
-    if (pathExists(command, platform) && windowsCodexCommandIsRunnable(command, env, spawnSyncImpl)) {
+    if (
+      pathExists(command, platform)
+      && windowsCodexCommandIsRunnable(command, ["--version"], env, spawnSyncImpl)
+    ) {
       return command;
     }
   }
@@ -123,17 +135,31 @@ function codexPlatformDirectories(platform, arch) {
   return [];
 }
 
-function windowsCodexCommandIsRunnable(command, env, spawnSyncImpl) {
+function windowsCodexPathCommandIsRunnable(command, env, spawnSyncImpl) {
+  let invocation;
+  try {
+    invocation = resolveWindowsCliInvocation(command, ["--version"], {
+      env,
+      platform: "win32",
+      spawnSync: spawnSyncImpl,
+    });
+  } catch {
+    return false;
+  }
+  return windowsCodexCommandIsRunnable(invocation.command, invocation.args, env, spawnSyncImpl);
+}
+
+function windowsCodexCommandIsRunnable(command, args, env, spawnSyncImpl) {
   let result;
   try {
     result = spawnSyncImpl(
       command,
-      ["--version"],
+      args,
       {
         encoding: "utf8",
         env,
         stdio: ["ignore", "pipe", "pipe"],
-        timeout: WINDOWS_CODEX_APP_PROBE_TIMEOUT_MS,
+        timeout: WINDOWS_CODEX_DISCOVERY_PROBE_TIMEOUT_MS,
         windowsHide: true,
       },
     );

package/lib/setup-memory-preferences.mjs

@@ -0,0 +1,113 @@
+import { spawnSync } from "node:child_process";
+import { userInfo } from "node:os";
+import { win32 } from "node:path";
+
+const COMMAND_TIMEOUT_MS = 2_000;
+const MAX_OUTPUT_BYTES = 16 * 1024;
+
+export function detectSetupMemoryPreferences(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const account = safely(options.readUserInfo ?? userInfo);
+  const locale = systemLocale({
+    platform,
+    env,
+    runCommand: options.runCommand ?? spawnSync,
+    readIntlLocale: options.readIntlLocale ?? defaultIntlLocale,
+  });
+  return Object.freeze({
+    userId: detectedUserId(account, platform),
+    outputLanguage: memoryLanguage(locale),
+  });
+}
+
+function detectedUserId(account, platform) {
+  if (platform !== "win32" && account?.uid === 0) return undefined;
+  const username = String(account?.username ?? "").normalize("NFKC").trim();
+  if (!username || /[\0\r\n]/.test(username)) return undefined;
+  return [...username].slice(0, 120).join("");
+}
+
+function systemLocale({ platform, env, runCommand, readIntlLocale }) {
+  if (platform === "darwin") {
+    return macosPreferredLanguage(runCommand, env)
+      ?? environmentLocale(env)
+      ?? safely(readIntlLocale);
+  }
+  if (platform === "win32") {
+    return windowsUiLanguage(runCommand, env)
+      ?? safely(readIntlLocale);
+  }
+  return environmentLocale(env) ?? safely(readIntlLocale);
+}
+
+function macosPreferredLanguage(runCommand, env) {
+  const output = commandOutput(runCommand, "/usr/bin/defaults", [
+    "read",
+    "-g",
+    "AppleLanguages",
+  ], env);
+  return /"([^"]+)"/.exec(output ?? "")?.[1];
+}
+
+function windowsUiLanguage(runCommand, env) {
+  const systemRoot = nonEmpty(env.SystemRoot) ?? nonEmpty(env.SYSTEMROOT);
+  const powershell = systemRoot
+    ? win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    : "powershell.exe";
+  return commandOutput(runCommand, powershell, [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false); [System.Globalization.CultureInfo]::CurrentUICulture.Name",
+  ], env);
+}
+
+function commandOutput(runCommand, command, args, env) {
+  let result;
+  try {
+    result = runCommand(command, args, {
+      encoding: "utf8",
+      env,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: COMMAND_TIMEOUT_MS,
+      maxBuffer: MAX_OUTPUT_BYTES,
+      windowsHide: true,
+    });
+  } catch {
+    return undefined;
+  }
+  if (result?.status !== 0 || result.error || result.signal) return undefined;
+  return nonEmpty(String(result.stdout ?? "").replace(/^\uFEFF/, ""));
+}
+
+function environmentLocale(env) {
+  return nonEmpty(env.LC_ALL)
+    ?? nonEmpty(env.LC_MESSAGES)
+    ?? nonEmpty(env.LANGUAGE)?.split(":", 1)[0]
+    ?? nonEmpty(env.LANG);
+}
+
+function defaultIntlLocale() {
+  return Intl.DateTimeFormat().resolvedOptions().locale;
+}
+
+function memoryLanguage(value) {
+  const locale = nonEmpty(value)?.toLowerCase().replaceAll("_", "-");
+  if (!locale) return undefined;
+  return /^zh(?:-|$)/.test(locale) ? "zh" : "en";
+}
+
+function nonEmpty(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || undefined;
+}
+
+function safely(operation) {
+  try {
+    return operation();
+  } catch {
+    return undefined;
+  }
+}

package/lib/setup-reconcile.mjs

@@ -0,0 +1,128 @@
+export async function reconcileSetup({
+  start,
+  stop,
+  status,
+  isReady,
+  onEvent = () => {},
+}) {
+  await onEvent({ type: "start", attempt: 1 });
+  let started = await start();
+  let recovered = false;
+
+  if (!commandSucceeded(started)) {
+    await onEvent({ type: "start-failed", attempt: 1 });
+    const deterministicFailure = classifyDeterministicStartFailure(started);
+    if (deterministicFailure) {
+      return await complete(onEvent, deterministicFailure);
+    }
+
+    await onEvent({ type: "stop", reason: "start-failed" });
+    await stop();
+    await onEvent({ type: "start", attempt: 2 });
+    started = await start();
+    if (!commandSucceeded(started)) {
+      await onEvent({ type: "start-failed", attempt: 2 });
+      await onEvent({ type: "diagnostic-status" });
+      await status();
+      return await complete(onEvent, compactResult({
+        status: "not-verified",
+        reason: "start-failed-after-recovery",
+        code: commandFailureCode(started),
+      }));
+    }
+    recovered = true;
+  }
+
+  await onEvent({ type: "start-succeeded", recovered });
+  await onEvent({ type: "status", recovered });
+  const checked = await status();
+  if (!commandSucceeded(checked)) {
+    await onEvent({ type: "status-failed" });
+    return await complete(onEvent, compactResult({
+      status: "not-verified",
+      reason: "status-failed",
+      code: commandFailureCode(checked),
+    }));
+  }
+  await onEvent({ type: "status-succeeded" });
+
+  const ready = await isReady(checked);
+  if (!ready) {
+    return await complete(onEvent, {
+      status: "unavailable",
+      reason: "not-ready",
+      recovered,
+    });
+  }
+
+  return await complete(onEvent, {
+    status: "enabled",
+    reason: "ready",
+    recovered,
+  });
+}
+
+export function runtimeAuthorityFailureCode(result) {
+  const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  return output.match(/\b(BACKEND_(?:(?:CONNECTION_AUTHORITY|TOKEN_RECORD|SERVICE_STATE)_(?:ABSENT|INVALID|UNSUPPORTED)|SERVICE_STATE_CLEANUP_FAILED))\b/)?.[1];
+}
+
+export function lifecycleLockFailureCode(result) {
+  const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  return output.match(/\bBACKEND_LIFECYCLE_LOCK_TIMEOUT\b/)?.[0];
+}
+
+export function clientHookRuntimeActivationFailed(result) {
+  const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  return /client Hook runtime activation failed:/i.test(output);
+}
+
+function classifyDeterministicStartFailure(result) {
+  if (clientHookRuntimeActivationFailed(result)) {
+    return {
+      status: "not-verified",
+      reason: "hook-runtime-activation-failed",
+    };
+  }
+
+  const lifecycleCode = lifecycleLockFailureCode(result);
+  if (lifecycleCode) {
+    return {
+      status: "not-verified",
+      reason: "lifecycle-lock-timeout",
+      code: lifecycleCode,
+    };
+  }
+
+  const authorityCode = runtimeAuthorityFailureCode(result);
+  if (authorityCode) {
+    return {
+      status: "not-verified",
+      reason: "runtime-authority-failed",
+      code: authorityCode,
+    };
+  }
+
+  return undefined;
+}
+
+function commandSucceeded(result) {
+  return result?.status === 0;
+}
+
+function commandFailureCode(result) {
+  return result?.code ?? result?.error?.code ?? result?.status;
+}
+
+function compactResult(result) {
+  if (result.code === undefined) {
+    const { code: _code, ...withoutCode } = result;
+    return withoutCode;
+  }
+  return result;
+}
+
+async function complete(onEvent, result) {
+  await onEvent({ type: "complete", ...result });
+  return result;
+}

package/lib/trial-plugin-mark.mjs

@@ -0,0 +1,171 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import {
+  hostname as readHostname,
+  networkInterfaces,
+  platform as readPlatform,
+} from "node:os";
+import { spawnSync } from "node:child_process";
+
+const COMMAND_TIMEOUT_MS = 1_000;
+export const TRIAL_MARK_VERSION = 1;
+export const TRIAL_APP_SALT = "memorax-plugin-v1";
+
+export function generateTrialPluginIdentity() {
+  const platform = normalizePlatform(safely(readPlatform));
+  return deriveTrialPluginIdentity({
+    markVersion: TRIAL_MARK_VERSION,
+    appSalt: TRIAL_APP_SALT,
+    machineId: readMachineId(platform),
+    hostname: safely(readHostname),
+    platform,
+    arch: process.arch,
+    macHash: createTrialMacHash(flattenNetworkInterfaces()),
+  });
+}
+
+export function generateTrialMarkId() {
+  return generateTrialPluginIdentity().markId;
+}
+
+export function deriveTrialPluginIdentity(fields = {}) {
+  const identity = Object.freeze({
+    markVersion: fields.markVersion ?? TRIAL_MARK_VERSION,
+    appSalt: normalizeAppSalt(fields.appSalt),
+    machineId: trimmed(fields.machineId),
+    hostname: trimmed(fields.hostname),
+    platform: normalizePlatform(fields.platform),
+    arch: normalizeArch(fields.arch),
+    macHash: normalize(fields.macHash),
+  });
+  const material = [
+    identity.appSalt,
+    hashMachineId(identity.machineId),
+    identity.hostname,
+    identity.platform,
+    identity.arch,
+    identity.macHash,
+  ].join("");
+  return Object.freeze({
+    ...identity,
+    markId: `mk_${sha256Hex(material)}`,
+  });
+}
+
+export function deriveTrialMarkId(fields = {}) {
+  return deriveTrialPluginIdentity(fields).markId;
+}
+
+export function createTrialMacHash(entries = []) {
+  const macs = [...new Set(entries
+    .filter((entry) => entry?.internal === false)
+    .map((entry) => normalizeMac(entry?.mac))
+    .filter(Boolean))]
+    .sort();
+  return sha256Hex(macs.join(""));
+}
+
+function readMachineId(platform) {
+  if (platform === "linux") {
+    return readFirstFile(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
+  }
+  if (platform === "macos") {
+    const output = runCommand("/usr/sbin/ioreg", [
+      "-rd1",
+      "-c",
+      "IOPlatformExpertDevice",
+    ]);
+    return output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/i)?.[1] ?? "";
+  }
+  if (platform === "windows") {
+    const output = runCommand("reg.exe", [
+      "query",
+      "HKLM\\SOFTWARE\\Microsoft\\Cryptography",
+      "/v",
+      "MachineGuid",
+    ]);
+    return output.match(/^\s*MachineGuid\s+REG_\w+\s+(.+?)\s*$/im)?.[1] ?? "";
+  }
+  return "";
+}
+
+function readFirstFile(paths) {
+  for (const path of paths) {
+    try {
+      const value = readFileSync(path, "utf8").trim();
+      if (value) return value;
+    } catch {
+      // Try the next standard machine ID location.
+    }
+  }
+  return "";
+}
+
+function runCommand(command, args) {
+  try {
+    const result = spawnSync(command, args, {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024,
+      shell: false,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: COMMAND_TIMEOUT_MS,
+      windowsHide: true,
+    });
+    return result.status === 0 && typeof result.stdout === "string" ? result.stdout : "";
+  } catch {
+    return "";
+  }
+}
+
+function flattenNetworkInterfaces() {
+  const groups = safely(networkInterfaces);
+  if (!groups || typeof groups !== "object") return [];
+  return Object.values(groups).flatMap((entries) => Array.isArray(entries) ? entries : []);
+}
+
+function normalizeMac(value) {
+  const normalized = normalize(value);
+  if (!/^(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}$/.test(normalized)) return "";
+  const compact = normalized.replaceAll(":", "").replaceAll("-", "");
+  return compact === "000000000000" ? "" : compact;
+}
+
+function normalize(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+function trimmed(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeAppSalt(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizePlatform(value) {
+  const platform = normalize(value);
+  if (platform === "darwin" || platform === "macos") return "macos";
+  if (platform === "win32" || platform === "windows") return "windows";
+  return platform;
+}
+
+function normalizeArch(value) {
+  const arch = normalize(value);
+  return arch === "x64" ? "x86_64" : arch;
+}
+
+function hashMachineId(value) {
+  return sha256Hex(normalize(value));
+}
+
+function sha256Hex(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+
+function safely(operation) {
+  try {
+    return operation();
+  } catch {
+    return "";
+  }
+}