@memorax/memorax-code 0.1.0

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

@@ -0,0 +1,324 @@
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  injectClientHookInput,
+  readStdinJson,
+  stringOption,
+  withJsonFileLock,
+} from "../config-utils.mjs";
+import {
+  CLIENT_HOOK_RUNTIME_ABI,
+  clientHookRuntimePaths,
+  readCurrentClientHookRuntime,
+  resolveClientHookRuntimeModule,
+} from "./hook-runtime-generation.mjs";
+import {
+  readJsonRuntimeRecord,
+  writePrivateJsonRecord,
+} from "../runtime-record.mjs";
+import { isRepoMemoryJobWorker } from "../repo-memory/repo-memory-job-context.mjs";
+
+const PIN_RECORD_VERSION = 1;
+const SHELL_RECORD_VERSION = 1;
+
+export async function runClientHookLauncher({
+  client,
+  component,
+  debugEnv,
+  fallbackModuleUrl,
+  pluginRoot,
+  shellVersion,
+} = {}) {
+  try {
+    if (isRepoMemoryJobWorker()) return;
+    const input = await readStdinJson();
+    const memoraxCodeHome = resolveMemoraxCodeHome();
+    const selection = selectHookRuntime({
+      client,
+      component,
+      fallbackModuleUrl,
+      memoraxCodeHome,
+      input,
+      pluginRoot,
+      shellVersion,
+    });
+    if (!selection) return;
+    injectClientHookInput(input);
+    await import(pathToFileURL(selection.modulePath).href);
+  } catch (error) {
+    if (process.env[debugEnv] === "1") {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+
+export function readClientHookShellVersion(pluginRoot) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(pluginRoot, "hooks", "runtime-shell.json"), "utf8"));
+    if (parsed?.version !== SHELL_RECORD_VERSION
+      || parsed?.runtimeAbi !== CLIENT_HOOK_RUNTIME_ABI
+      || !stringOption(parsed?.shellVersion)) {
+      return undefined;
+    }
+    return parsed.shellVersion.trim();
+  } catch {
+    return undefined;
+  }
+}
+
+export function selectHookRuntime({
+  client,
+  component,
+  fallbackModuleUrl,
+  memoraxCodeHome,
+  input,
+  pluginRoot,
+  shellVersion,
+  } = {}) {
+  if (client !== "codex" && client !== "claude-code") return undefined;
+  const event = hookEvent(input);
+  if (!["SessionStart", "UserPromptSubmit", "Stop"].includes(event)) return undefined;
+  const sessionId = stringOption(input?.session_id) ?? stringOption(input?.sessionId);
+  const turnId = client === "claude-code"
+    ? stringOption(input?.prompt_id) ?? stringOption(input?.promptId)
+    : stringOption(input?.turn_id) ?? stringOption(input?.turnId);
+  const fallback = bundledSelection({
+    fallbackModuleUrl,
+    pluginRoot,
+    shellVersion,
+  });
+
+  if (event === "UserPromptSubmit") {
+    if (!sessionId || !turnId) return undefined;
+    const pin = pinInfo(memoraxCodeHome, client, sessionId);
+    return withJsonFileLock(pin.path, () => {
+      const turnKey = identityHash(turnId);
+      const existing = readPin(pin.path);
+      if (existing.status === "invalid") return undefined;
+      if (existing.status === "valid") {
+        if (existing.record.client !== client
+          || existing.record.sessionKey !== pin.sessionKey) return undefined;
+        if (existing.record.turnKey === turnKey) {
+          return selectionFromPin({
+            client,
+            component,
+            fallback,
+            memoraxCodeHome,
+            pin: existing.record,
+          });
+        }
+      }
+      const selected = currentSelection({
+        client,
+        component,
+        fallback,
+        memoraxCodeHome,
+      });
+      if (!selected) return undefined;
+      writePrivateJsonRecord(pin.path, {
+        version: PIN_RECORD_VERSION,
+        runtimeAbi: CLIENT_HOOK_RUNTIME_ABI,
+        client,
+        sessionKey: pin.sessionKey,
+        turnKey,
+        generationSource: selected.generationSource,
+        generationId: selected.generationId,
+        pinnedAt: new Date().toISOString(),
+      }, { durableBoundary: resolve(memoraxCodeHome) });
+      return selected;
+    });
+  }
+
+  if (event === "Stop") {
+    if (!sessionId || !turnId) return undefined;
+    const pin = pinInfo(memoraxCodeHome, client, sessionId);
+    return withJsonFileLock(pin.path, () => {
+      const existing = readPin(pin.path);
+      if (existing.status !== "valid"
+        || existing.record.client !== client
+        || existing.record.sessionKey !== pin.sessionKey
+        || existing.record.turnKey !== identityHash(turnId)) return undefined;
+      return selectionFromPin({
+        client,
+        component,
+        fallback,
+        memoraxCodeHome,
+        pin: existing.record,
+      });
+    });
+  }
+
+  if (event === "SessionStart" && stringOption(input?.source) === "compact") {
+    if (!sessionId) return undefined;
+    const pin = pinInfo(memoraxCodeHome, client, sessionId);
+    return withJsonFileLock(pin.path, () => {
+      const existing = readPin(pin.path);
+      if (existing.status !== "valid"
+        || existing.record.client !== client
+        || existing.record.sessionKey !== pin.sessionKey) return undefined;
+      return selectionFromPin({
+        client,
+        component,
+        fallback,
+        memoraxCodeHome,
+        pin: existing.record,
+      });
+    });
+  }
+
+  return currentSelection({
+    client,
+    component,
+    fallback,
+    memoraxCodeHome,
+  });
+}
+
+function currentSelection({ client, component, fallback, memoraxCodeHome }) {
+  const current = readCurrentClientHookRuntime(memoraxCodeHome);
+  if (current.status !== "valid") return fallback;
+  const resolved = resolveClientHookRuntimeModule({
+    memoraxCodeHome,
+    client,
+    component,
+    generationId: current.record.generationId,
+  });
+  return resolved
+    ? {
+      generationSource: "durable",
+      generationId: current.record.generationId,
+      modulePath: resolved.modulePath,
+    }
+    : fallback;
+}
+
+function selectionFromPin({ client, component, fallback, memoraxCodeHome, pin }) {
+  if (pin.generationSource === "bundled") {
+    return fallback?.generationId === pin.generationId ? fallback : undefined;
+  }
+  if (pin.generationSource !== "durable") return undefined;
+  const resolved = resolveClientHookRuntimeModule({
+    memoraxCodeHome,
+    client,
+    component,
+    generationId: pin.generationId,
+  });
+  return resolved
+    ? {
+      generationSource: "durable",
+      generationId: pin.generationId,
+      modulePath: resolved.modulePath,
+    }
+    : undefined;
+}
+
+function bundledSelection({ fallbackModuleUrl, pluginRoot, shellVersion }) {
+  const normalizedShellVersion = stringOption(shellVersion);
+  if (!normalizedShellVersion || !fallbackModuleUrl || !pluginRoot) return undefined;
+  let modulePath;
+  try {
+    modulePath = resolve(
+      fallbackModuleUrl instanceof URL
+        ? fileURLToPath(fallbackModuleUrl)
+        : String(fallbackModuleUrl),
+    );
+  } catch {
+    return undefined;
+  }
+  if (!isContainedRegularFile(pluginRoot, modulePath)) return undefined;
+  return {
+    generationSource: "bundled",
+    generationId: `shell-${normalizedShellVersion}`,
+    modulePath,
+  };
+}
+
+function readPin(path) {
+  const state = readJsonRuntimeRecord(path);
+  if (state.status === "absent") return { status: "absent" };
+  if (state.status !== "present" || !isRecord(state.value)) {
+    return { status: "invalid" };
+  }
+  const value = state.value;
+  if (value.version !== PIN_RECORD_VERSION
+    || value.runtimeAbi !== CLIENT_HOOK_RUNTIME_ABI
+    || !["codex", "claude-code"].includes(value.client)
+    || !/^[a-f0-9]{64}$/.test(value.sessionKey)
+    || !/^[a-f0-9]{64}$/.test(value.turnKey)
+    || !["durable", "bundled"].includes(value.generationSource)
+    || !stringOption(value.generationId)
+    || !validTimestamp(value.pinnedAt)) {
+    return { status: "invalid" };
+  }
+  return {
+    status: "valid",
+    record: {
+      version: value.version,
+      runtimeAbi: value.runtimeAbi,
+      client: value.client,
+      sessionKey: value.sessionKey,
+      turnKey: value.turnKey,
+      generationSource: value.generationSource,
+      generationId: value.generationId,
+      pinnedAt: value.pinnedAt,
+    },
+  };
+}
+
+function pinInfo(memoraxCodeHome, client, sessionId) {
+  const sessionKey = identityHash(sessionId);
+  const root = clientHookRuntimePaths(memoraxCodeHome).root;
+  return {
+    sessionKey,
+    path: join(root, "pins", client, `${sessionKey}.json`),
+  };
+}
+
+function hookEvent(input) {
+  return stringOption(input?.hook_event_name)
+    ?? stringOption(input?.hookEventName)
+    ?? stringOption(input?.event)
+    ?? stringOption(input?.type);
+}
+
+function resolveMemoraxCodeHome() {
+  return resolve(process.env.MEMORAX_CODE_HOME || join(homedir(), ".memorax-code"));
+}
+
+function identityHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function isContainedRegularFile(boundary, path) {
+  const root = resolve(boundary);
+  const target = resolve(path);
+  const child = relative(root, target);
+  if (child === ".." || child.startsWith(`..${sep}`) || isAbsolute(child)) return false;
+  let current = root;
+  try {
+    const rootMetadata = lstatSync(current);
+    if (!rootMetadata.isDirectory() || rootMetadata.isSymbolicLink()) return false;
+    const parts = child.split(sep).filter(Boolean);
+    for (let index = 0; index < parts.length; index += 1) {
+      current = join(current, parts[index]);
+      const metadata = lstatSync(current);
+      if (metadata.isSymbolicLink()) return false;
+      if (index === parts.length - 1) return metadata.isFile();
+      if (!metadata.isDirectory()) return false;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+function validTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,142 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, delimiter, join } from "node:path";
+import {
+  localBackendRecoveryArguments,
+  resolveBackendConnection,
+} from "../backend-connection.mjs";
+import { readStdinJson } from "../config-utils.mjs";
+import { isRepoMemoryJobWorker } from "../repo-memory/repo-memory-job-context.mjs";
+
+export const DEFAULT_ENSURE_BACKEND_START_TIMEOUT_MS = 90000;
+
+export async function runEnsureBackendHook(options) {
+  if (isRepoMemoryJobWorker() || ensureDisabled(options.ensureBackendValue)) return;
+
+  const input = await readStdinJson();
+  const homes = options.resolveHomes(input);
+  let connection;
+  try {
+    connection = resolveBackendConnection({ memoraxCodeHome: homes.memoraxCodeHome });
+  } catch (error) {
+    options.debug?.(error instanceof Error ? error.message : String(error));
+    return;
+  }
+  const healthTimeoutMs = parsePositiveInt(options.healthTimeoutValue, 1500);
+  if (await backendHealthy(connection, healthTimeoutMs)) {
+    await options.onHealthy?.({ homes, backendUrl: connection.url });
+    return;
+  }
+
+  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),
+  );
+  if (result.code !== 0) {
+    options.debug?.(
+      `MemoraX Code backend start failed with code ${result.code}${result.stderr ? `: ${result.stderr}` : ""}`,
+    );
+  }
+}
+
+export function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function ensureDisabled(value) {
+  return ["0", "false", "no", "off", "disabled"].includes(String(value ?? "").trim().toLowerCase());
+}
+
+async function backendHealthy(connection, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(new URL("/health", connection.url), {
+      signal: controller.signal,
+      headers: {
+        connection: "close",
+        ...(connection.token ? { "x-memorax-code-backend-token": connection.token } : {}),
+      },
+    });
+    if (!response.ok) return false;
+    const body = await response.json().catch(() => undefined);
+    return body?.ok === true && body.service === "memorax-code-backend";
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function memoraxCodeCommandInfo(explicitCommand, pluginRoot) {
+  const explicit = stringValue(explicitCommand);
+  if (explicit) return { value: explicit, removed: pathLooksRemoved(explicit) };
+  const metadata = metadataCommand(pluginRoot);
+  if (metadata) return { value: metadata, removed: pathLooksRemoved(metadata) };
+  return { value: "memorax-code", removed: false };
+}
+
+function metadataCommand(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);
+  } catch {
+    return undefined;
+  }
+}
+
+function pathLooksRemoved(command) {
+  return (command.includes("/") || command.includes("\\")) && !existsSync(command);
+}
+
+function memoraxCodeCommandAvailable(command) {
+  if (!command) return false;
+  if (command.includes("/") || command.includes("\\")) return existsSync(command);
+  const path = process.env.PATH ?? "";
+  return path.split(delimiter).some((dir) => dir && existsSync(join(dir, command)));
+}
+
+function runMemoraxCode(command, args, timeoutMs) {
+  return new Promise((resolve) => {
+    const childArgs = nodeEntrypoint(command) ? [command, ...args] : args;
+    const childCommand = nodeEntrypoint(command) ? process.execPath : command;
+    let stderr = "";
+    let settled = false;
+    const child = spawn(childCommand, childArgs, {
+      env: process.env,
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish({ code: 124, stderr: "timed out" });
+    }, timeoutMs);
+    child.stderr.on("data", (chunk) => { stderr += String(chunk); });
+    child.on("error", (error) => finish({ code: 127, stderr: error.message }));
+    child.on("close", (code) => finish({ code: code ?? 0, stderr }));
+  });
+}
+
+function nodeEntrypoint(command) {
+  const name = basename(command).toLowerCase();
+  return name.endsWith(".mjs") || name.endsWith(".js");
+}
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/lib/memorax-code-adapter-common/src/hooks/hook-runtime-generation.d.mts

@@ -0,0 +1,38 @@
+export type ClientHookRuntimeGeneration = Readonly<{
+  version: number;
+  runtimeAbi: number;
+  generationId: string;
+  packageVersion: string;
+  contentDigest: string;
+  createdAt: string;
+  generationPath?: string;
+  reused?: boolean;
+}>;
+
+export type ActivatedClientHookRuntimeGeneration = Readonly<{
+  version: number;
+  runtimeAbi: number;
+  generationId: string;
+  packageVersion: string;
+  contentDigest: string;
+  activatedAt: string;
+  generationPath: string;
+  durability: "confirmed" | "uncertain";
+  durabilityErrorCode?: string;
+}>;
+
+export const CLIENT_HOOK_RUNTIME_ABI: number;
+
+export function stageClientHookRuntimeGeneration(options: {
+  packageRoot: string;
+  memoraxCodeHome: string;
+  now?: () => Date;
+  syncFile?: (path: string) => void;
+  syncDirectory?: (path: string) => void;
+}): ClientHookRuntimeGeneration;
+
+export function activateClientHookRuntimeGeneration(options: {
+  memoraxCodeHome: string;
+  generation: ClientHookRuntimeGeneration;
+  now?: () => Date;
+}): ActivatedClientHookRuntimeGeneration;