@memorax/memorax-code 0.1.8 → 0.1.10

package/lib/automatic-update.mjs

@@ -0,0 +1,233 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { withJsonFileLockAsync } from "./memorax-code-adapter-common/src/config-utils.mjs";
+import {
+  AUTOMATIC_UPDATE_CHECK_INTERVAL_MS,
+  AUTOMATIC_UPDATE_RECORD_VERSION,
+  AUTOMATIC_UPDATE_RETRY_INTERVAL_MS,
+  automaticUpdateStatePath,
+  readAutomaticUpdateState,
+  writeAutomaticUpdateState,
+} from "./memorax-code-adapter-common/src/automatic-update-state.mjs";
+import {
+  readSetupCompletionRecord,
+  withSetupCompletionLock,
+} from "./memorax-code-adapter-common/src/setup-completion.mjs";
+import {
+  npmCommandCwd,
+  resolveNpmInvocation,
+  runNpmCommand,
+  waitForChildProcess,
+} from "./npm-invocation.mjs";
+
+export {
+  AUTOMATIC_UPDATE_CHECK_INTERVAL_MS,
+  AUTOMATIC_UPDATE_RECORD_VERSION,
+  AUTOMATIC_UPDATE_RETRY_INTERVAL_MS,
+  automaticUpdateStatePath,
+  readAutomaticUpdateState,
+};
+
+export async function runAutomaticUpdate(options) {
+  const memoraxCodeHome = resolve(requiredString(options?.memoraxCodeHome, "memoraxCodeHome"));
+  const packageRoot = resolve(requiredString(options?.packageRoot, "packageRoot"));
+  const packageName = requiredString(options?.packageName, "packageName");
+  const packageVersion = requiredString(options?.packageVersion, "packageVersion");
+  const env = options?.env ?? process.env;
+  if (automaticUpdateDisabled(env.MEMORAX_CODE_AUTO_UPDATE)) {
+    return { ok: true, disposition: "disabled" };
+  }
+
+  const completion = readSetupCompletionRecord(memoraxCodeHome);
+  if (completion.status === "absent") {
+    return { ok: true, disposition: "setup-incomplete" };
+  }
+  if (completion.status !== "valid") {
+    return { ok: false, disposition: "failed", reason: "setup_completion_invalid" };
+  }
+
+  const channel = packageVersion.includes("-") ? "preview" : "latest";
+  return await runAutomaticUpdateCore({
+    memoraxCodeHome,
+    installedVersion: packageVersion,
+    completedByVersion: completion.record.completedByVersion,
+    channel,
+    resolveTargetVersion: async (targetChannel) => resolveTargetVersion({
+      channel: targetChannel,
+      env,
+      packageName,
+    }),
+    installVersion: async (targetVersion) => (
+      await runNpmCommand(["install", "-g", `${packageName}@${targetVersion}`], {
+        env: {
+          ...env,
+          MEMORAX_CODE_AUTOMATIC_UPDATE_PROCESS: "1",
+          MEMORAX_CODE_HOME: memoraxCodeHome,
+        },
+        stdio: "ignore",
+        windowsHide: true,
+      })
+    ).exitCode === 0,
+    reconcile: async (targetVersion) => await runAutomaticSetup({
+      env,
+      memoraxCodeHome,
+      packageRoot,
+      targetVersion,
+    }),
+  });
+}
+
+export async function runAutomaticUpdateCore(options) {
+  const memoraxCodeHome = resolve(requiredString(options?.memoraxCodeHome, "memoraxCodeHome"));
+  const installedVersion = requiredString(options?.installedVersion, "installedVersion");
+  const completedByVersion = requiredString(options?.completedByVersion, "completedByVersion");
+  const channel = options?.channel === "preview" ? "preview" : "latest";
+  const resolveTargetVersion = requiredFunction(options?.resolveTargetVersion, "resolveTargetVersion");
+  const installVersion = requiredFunction(options?.installVersion, "installVersion");
+  const reconcile = requiredFunction(options?.reconcile, "reconcile");
+  const path = automaticUpdateStatePath(memoraxCodeHome);
+
+  return await withJsonFileLockAsync(path, async () => {
+    const nowMs = currentTime(options);
+    const finish = (result, effectiveVersion, retry) => {
+      const state = writeAutomaticUpdateState({
+        memoraxCodeHome,
+        nowMs,
+        installedVersion: effectiveVersion,
+        retry,
+      });
+      return { ...result, state };
+    };
+    const state = readAutomaticUpdateState(memoraxCodeHome);
+    if (state.status === "valid"
+      && state.record.installedVersion === installedVersion
+      && nowMs < Date.parse(state.record.nextCheckAt)) {
+      return { ok: true, disposition: "throttled", state: state.record };
+    }
+
+    let targetVersion;
+    try {
+      targetVersion = requiredString(
+        await resolveTargetVersion(channel),
+        "targetVersion",
+      );
+    } catch {
+      return finish({ ok: false, disposition: "failed", reason: "check_failed" }, installedVersion, true);
+    }
+
+    let effectiveVersion = installedVersion;
+    let updated = false;
+    if (targetVersion !== installedVersion) {
+      let installed = false;
+      try {
+        installed = await installVersion(targetVersion) === true;
+      } catch {
+        installed = false;
+      }
+      if (!installed) {
+        return finish({ ok: false, disposition: "failed", reason: "update_failed" }, installedVersion, true);
+      }
+      effectiveVersion = targetVersion;
+      updated = true;
+    }
+
+    if (updated || completedByVersion !== effectiveVersion) {
+      let reconciled = false;
+      try {
+        reconciled = await reconcile(effectiveVersion) === true;
+      } catch {
+        reconciled = false;
+      }
+      if (!reconciled) {
+        return finish({ ok: false, disposition: "failed", reason: "reconcile_failed" }, effectiveVersion, true);
+      }
+    }
+
+    const outcome = updated
+      ? "updated"
+      : completedByVersion === effectiveVersion
+        ? "up-to-date"
+        : "reconciled";
+    return finish({ ok: true, disposition: outcome }, effectiveVersion, false);
+  });
+}
+
+function resolveTargetVersion({ channel, env, packageName }) {
+  const args = ["view", `${packageName}@${channel}`, "version", "--json"];
+  const invocation = resolveNpmInvocation(args, { env });
+  const cwd = npmCommandCwd(env);
+  const result = spawnSync(invocation.command, invocation.args, {
+    cwd,
+    encoding: "utf8",
+    env: { ...env, PWD: cwd, MEMORAX_CODE_AUTOMATIC_UPDATE_PROCESS: "1" },
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 30_000,
+    maxBuffer: 64 * 1024,
+    windowsHide: true,
+  });
+  if (result.error || result.signal || result.status !== 0) {
+    throw new Error("npm registry version check failed");
+  }
+  let version;
+  try {
+    version = JSON.parse(String(result.stdout ?? ""));
+  } catch {
+    throw new Error("npm registry returned an invalid version response");
+  }
+  if (typeof version !== "string"
+    || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error("npm registry returned an invalid package version");
+  }
+  return version;
+}
+
+async function runAutomaticSetup({ env, memoraxCodeHome, packageRoot, targetVersion }) {
+  return await withSetupCompletionLock(memoraxCodeHome, async (completion) => {
+    if (completion.status !== "valid") return false;
+    const setupPath = join(packageRoot, "bin", "memorax-code-setup.mjs");
+    if (!existsSync(setupPath)) return false;
+    const setupEnv = {
+      ...env,
+      MEMORAX_CODE_AUTOMATIC_UPDATE_PROCESS: "1",
+      MEMORAX_CODE_HOME: memoraxCodeHome,
+      MEMORAX_CODE_SETUP_AUTOMATIC_UPDATE: "1",
+      MEMORAX_CODE_SETUP_UPDATE: "1",
+    };
+    delete setupEnv.MEMORAX_CODE_SETUP_MODE;
+    const child = spawn(process.execPath, [setupPath], {
+      env: setupEnv,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    if ((await waitForChildProcess(child)).exitCode !== 0) return false;
+    const reconciled = readSetupCompletionRecord(memoraxCodeHome);
+    return reconciled.status === "valid"
+      && reconciled.record.completedByVersion === targetVersion;
+  });
+}
+
+function currentTime(options) {
+  const value = typeof options?.now === "function" ? Number(options.now()) : Date.now();
+  if (!Number.isFinite(value)) throw new TypeError("automatic update now must return a timestamp");
+  return value;
+}
+
+function requiredFunction(value, name) {
+  if (typeof value !== "function") throw new TypeError(`automatic update requires ${name}`);
+  return value;
+}
+
+function requiredString(value, name) {
+  const result = nonEmptyString(value);
+  if (!result) throw new TypeError(`automatic update requires ${name}`);
+  return result;
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function automaticUpdateDisabled(value) {
+  return ["0", "false", "no", "off", "disabled"].includes(String(value ?? "").trim().toLowerCase());
+}

package/lib/memorax-code-adapter-common/src/automatic-update-state.d.mts

@@ -0,0 +1,24 @@
+export type AutomaticUpdateRecord = Readonly<{
+  version: 1;
+  installedVersion: string;
+  nextCheckAt: string;
+}>;
+
+export type AutomaticUpdateState =
+  | Readonly<{ status: "absent" }>
+  | Readonly<{ status: "valid"; record: AutomaticUpdateRecord }>
+  | Readonly<{ status: "invalid"; reason: string }>
+  | Readonly<{ status: "unsupported"; version: number }>;
+
+export const AUTOMATIC_UPDATE_RECORD_VERSION: 1;
+export const AUTOMATIC_UPDATE_CHECK_INTERVAL_MS: number;
+export const AUTOMATIC_UPDATE_RETRY_INTERVAL_MS: number;
+
+export function automaticUpdateStatePath(memoraxCodeHome: string): string;
+export function readAutomaticUpdateState(memoraxCodeHome: string): AutomaticUpdateState;
+export function writeAutomaticUpdateState(options: {
+  memoraxCodeHome: string;
+  nowMs: number;
+  installedVersion: string;
+  retry: boolean;
+}): AutomaticUpdateRecord;

package/lib/memorax-code-adapter-common/src/automatic-update-state.mjs

@@ -0,0 +1,73 @@
+import { join, resolve } from "node:path";
+import {
+  readJsonRuntimeRecord,
+  writePrivateJsonRecord,
+} from "./runtime-record.mjs";
+
+export const AUTOMATIC_UPDATE_RECORD_VERSION = 1;
+export const AUTOMATIC_UPDATE_CHECK_INTERVAL_MS = 8 * 60 * 60 * 1_000;
+export const AUTOMATIC_UPDATE_RETRY_INTERVAL_MS = 15 * 60 * 1_000;
+
+const RECORD_KEYS = new Set(["version", "installedVersion", "nextCheckAt"]);
+
+export function automaticUpdateStatePath(memoraxCodeHome) {
+  return join(resolve(memoraxCodeHome), "runtime", "install", "automatic-update.json");
+}
+
+export function readAutomaticUpdateState(memoraxCodeHome) {
+  const state = readJsonRuntimeRecord(automaticUpdateStatePath(memoraxCodeHome));
+  if (state.status !== "present") return state;
+  const value = state.value;
+  if (value.version !== AUTOMATIC_UPDATE_RECORD_VERSION) {
+    return Number.isSafeInteger(value.version) && value.version > 0
+      ? { status: "unsupported", version: value.version }
+      : { status: "invalid", reason: "invalid_version" };
+  }
+  if (Object.keys(value).length !== RECORD_KEYS.size
+    || Object.keys(value).some((key) => !RECORD_KEYS.has(key))) {
+    return { status: "invalid", reason: "unknown_or_missing_fields" };
+  }
+  const installedVersion = nonEmptyString(value.installedVersion);
+  const nextCheckAt = timestamp(value.nextCheckAt);
+  if (!installedVersion || !nextCheckAt) {
+    return { status: "invalid", reason: "invalid_fields" };
+  }
+  return {
+    status: "valid",
+    record: {
+      version: AUTOMATIC_UPDATE_RECORD_VERSION,
+      installedVersion,
+      nextCheckAt,
+    },
+  };
+}
+
+export function writeAutomaticUpdateState({ memoraxCodeHome, nowMs, installedVersion, retry }) {
+  const timestampMs = Number(nowMs);
+  const version = nonEmptyString(installedVersion);
+  if (!Number.isFinite(timestampMs) || !version) {
+    throw new TypeError("automatic update state requires a timestamp and installed version");
+  }
+  const record = {
+    version: AUTOMATIC_UPDATE_RECORD_VERSION,
+    installedVersion: version,
+    nextCheckAt: new Date(
+      timestampMs + (retry ? AUTOMATIC_UPDATE_RETRY_INTERVAL_MS : AUTOMATIC_UPDATE_CHECK_INTERVAL_MS),
+    ).toISOString(),
+  };
+  writePrivateJsonRecord(automaticUpdateStatePath(memoraxCodeHome), record, {
+    durableBoundary: memoraxCodeHome,
+  });
+  return record;
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function timestamp(value) {
+  const candidate = nonEmptyString(value);
+  return candidate && Number.isFinite(Date.parse(candidate))
+    ? new Date(Date.parse(candidate)).toISOString()
+    : undefined;
+}

package/lib/memorax-code-adapter-common/src/clients/codebuddy-command.mjs

@@ -0,0 +1,82 @@
+import { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, win32 } from "node:path";
+
+const APP_NAMES = ["WorkBuddy.app", "CodeBuddy.app"];
+const BUNDLED_SEGMENTS = ["Contents", "Resources", "app.asar.unpacked", "cli", "bin", "codebuddy"];
+const WINDOWS_SEGMENTS = [
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy"],
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy.exe"],
+];
+
+/**
+ * Resolve the CodeBuddy executable from the environment, installed adapter
+ * metadata, or the WorkBuddy/CodeBuddy application bundle.  Hooks are often
+ * launched by a GUI process and therefore cannot rely on the user's shell
+ * PATH or on npm's environment setup.
+ */
+export function resolveHookCodeBuddyCommand({
+  env = process.env,
+  pluginRoot,
+  homeDir = homedir(),
+  platform = process.platform,
+  pathExists = commandPathExists,
+} = {}) {
+  const configured = stringValue(env.MEMORAX_CODE_CODEBUDDY_COMMAND)
+    ?? stringValue(env.CODEBUDDY_CLI_PATH)
+    ?? stringValue(env.WORKBUDDY_CODEBUDDY_PATH);
+  if (configured) return configured;
+
+  const metadataCommand = readMetadataCommand(stringValue(pluginRoot) ?? stringValue(env.CODEBUDDY_PLUGIN_ROOT));
+  if (metadataCommand && pathExists(metadataCommand, platform)) return metadataCommand;
+
+  if (platform === "darwin") {
+    for (const root of [join(homeDir, "Applications"), "/Applications"]) {
+      for (const appName of APP_NAMES) {
+        const command = join(root, appName, ...BUNDLED_SEGMENTS);
+        if (pathExists(command, platform)) return command;
+      }
+    }
+  }
+  if (platform === "win32") {
+    for (const root of [
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "Programs", "WorkBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "Programs", "CodeBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "WorkBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "CodeBuddy"),
+      env.ProgramFiles && win32.join(env.ProgramFiles, "WorkBuddy"),
+      env.ProgramFiles && win32.join(env.ProgramFiles, "CodeBuddy"),
+    ].filter(Boolean)) {
+      for (const segments of WINDOWS_SEGMENTS) {
+        const command = win32.join(root, ...segments);
+        if (pathExists(command, platform)) return command;
+      }
+    }
+  }
+  return "codebuddy";
+}
+
+function readMetadataCommand(pluginRoot) {
+  if (!pluginRoot) return undefined;
+  try {
+    const metadata = JSON.parse(readFileSync(join(pluginRoot, ".memorax-code-package.json"), "utf8"));
+    return stringValue(metadata?.codeBuddyCommand);
+  } catch {
+    return undefined;
+  }
+}
+
+function commandPathExists(command, platform) {
+  if (!command.includes("/") && !command.includes("\\")) return true;
+  if (!existsSync(command)) return false;
+  try {
+    accessSync(command, platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-adapter-common/src/config-utils.d.mts

@@ -13,6 +13,8 @@ export function readJsonFile(path: string): any;
 export function readJsonValue(path: string): any;
 export function readStdinJson(): Promise<any>;
 export function injectClientHookInput(input: Record<string, unknown>): void;
+export function injectClientHookPluginRoot(pluginRoot: string): void;
+export function readClientHookPluginRoot(): string | undefined;
 export function sha256(value: string | NodeJS.ArrayBufferView): string;
 export function stringOption(value: unknown): string | undefined;
 export function atomicWriteJson(path: string, value: unknown): void;

package/lib/memorax-code-adapter-common/src/config-utils.mjs

@@ -24,6 +24,7 @@ const JSON_FILE_LOCK_RETRY_MS = 10;
 const PROCESS_START_TOLERANCE_MS = 5000;
 const LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 const HOOK_INPUT_SYMBOL = Symbol.for("memorax-code.client-hook.input.v1");
+const HOOK_PLUGIN_ROOT_SYMBOL = Symbol.for("memorax-code.client-hook.plugin-root.v1");
 
 export function readAdapterState(path) {
   const state = readJsonFile(path);
@@ -64,6 +65,16 @@ export function injectClientHookInput(input) {
   globalThis[HOOK_INPUT_SYMBOL] = input;
 }
 
+export function injectClientHookPluginRoot(pluginRoot) {
+  const root = stringOption(pluginRoot);
+  if (!root) throw new TypeError("client Hook plugin root must be a non-empty string");
+  globalThis[HOOK_PLUGIN_ROOT_SYMBOL] = root;
+}
+
+export function readClientHookPluginRoot() {
+  return stringOption(globalThis[HOOK_PLUGIN_ROOT_SYMBOL]);
+}
+
 export function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }

package/lib/memorax-code-adapter-common/src/hooks/client-hook-launcher.mjs

@@ -5,6 +5,7 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   injectClientHookInput,
+  injectClientHookPluginRoot,
   readStdinJson,
   stringOption,
   withJsonFileLock,
@@ -47,6 +48,8 @@ export async function runClientHookLauncher({
     });
     if (!selection) return;
     injectClientHookInput(input);
+    const originalPluginRoot = stringOption(pluginRoot);
+    if (originalPluginRoot) injectClientHookPluginRoot(originalPluginRoot);
     await import(pathToFileURL(selection.modulePath).href);
   } catch (error) {
     if (process.env[debugEnv] === "1") {

package/lib/memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { basename, delimiter, join } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, delimiter, isAbsolute, join } from "node:path";
 import {
   localBackendRecoveryArguments,
   resolveBackendConnection,
@@ -16,8 +16,17 @@ export async function runEnsureBackendHook(options) {
 }
 
 export async function ensureBackendAvailable(options, input = {}) {
-  if (isRepoMemoryJobWorker() || ensureDisabled(options.ensureBackendValue)) return;
+  if (isRepoMemoryJobWorker()) return;
   const homes = options.resolveHomes(input);
+  const metadata = packageMetadata(options.pluginRoot);
+  const command = memoraxCodeCommandInfo(
+    options.memoraxCodeCommand,
+    metadata,
+    options.platform,
+  );
+  if (ensureDisabled(options.ensureBackendValue)) {
+    return;
+  }
   let connection;
   try {
     connection = options.backendConnection
@@ -34,19 +43,19 @@ export async function ensureBackendAvailable(options, input = {}) {
 
   const recoveryArguments = localBackendRecoveryArguments(connection);
   if (recoveryArguments === undefined) return;
-  const command = memoraxCodeCommandInfo(options.memoraxCodeCommand, options.pluginRoot);
   if (!command.value || command.removed === true || !memoraxCodeCommandAvailable(command.value)) return;
   const result = await runMemoraxCode(
     command.value,
     options.buildStartArgs(homes, recoveryArguments),
     parsePositiveInt(options.startTimeoutValue, DEFAULT_ENSURE_BACKEND_START_TIMEOUT_MS),
     options.nodePath,
-    options.recoveryEnv,
+    recoveryEnvironment(options.recoveryEnv, metadata),
   );
   if (result.code !== 0) {
     options.debug?.(
       `MemoraX Code backend start failed with code ${result.code}${result.stderr ? `: ${result.stderr}` : ""}`,
     );
+    return;
   }
 }
 
@@ -79,22 +88,48 @@ async function backendHealthy(connection, timeoutMs) {
   }
 }
 
-function memoraxCodeCommandInfo(explicitCommand, pluginRoot) {
+function memoraxCodeCommandInfo(explicitCommand, metadata, platform = process.platform) {
   const explicit = stringValue(explicitCommand);
   if (explicit) return { value: explicit, removed: pathLooksRemoved(explicit) };
-  const metadata = metadataCommand(pluginRoot);
-  if (metadata) return { value: metadata, removed: pathLooksRemoved(metadata) };
+  const command = stringValue(metadata?.memoraxCodeCommand);
+  if (command) return { value: command, removed: pathLooksRemoved(command) };
+  if (platform === "win32") return { value: undefined, removed: false };
   return { value: "memorax-code", removed: false };
 }
 
-function metadataCommand(pluginRoot) {
+function packageMetadata(pluginRoot) {
   const root = stringValue(pluginRoot);
   if (!root) return undefined;
   const path = join(root, ".memorax-code-package.json");
   if (!existsSync(path)) return undefined;
   try {
     const metadata = JSON.parse(readFileSync(path, "utf8"));
-    return stringValue(metadata.memoraxCodeCommand);
+    return metadata && typeof metadata === "object" && !Array.isArray(metadata)
+      ? metadata
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function recoveryEnvironment(recoveryEnv, metadata) {
+  if (stringValue(recoveryEnv?.MEMORAX_CODE_NPM_EXEC_PATH)
+    || stringValue(process.env.MEMORAX_CODE_NPM_EXEC_PATH)) {
+    return recoveryEnv;
+  }
+  const npmExecPath = metadataNpmExecPath(metadata);
+  return npmExecPath
+    ? { ...(recoveryEnv ?? {}), MEMORAX_CODE_NPM_EXEC_PATH: npmExecPath }
+    : recoveryEnv;
+}
+
+function metadataNpmExecPath(metadata) {
+  const npmExecPath = stringValue(metadata?.npmExecPath);
+  if (!npmExecPath || !isAbsolute(npmExecPath) || !/\.(?:cjs|js|mjs)$/i.test(npmExecPath)) {
+    return undefined;
+  }
+  try {
+    return statSync(npmExecPath).isFile() ? npmExecPath : undefined;
   } catch {
     return undefined;
   }