@memorax/memorax-code 0.1.8 → 0.1.10

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/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;
   }

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/repo-memory/repo-memory-job-worker.mjs

@@ -21,7 +21,7 @@ let requestedSignal;
 for (const signal of ["SIGINT", "SIGTERM"]) {
   process.on(signal, () => {
     requestedSignal = signal;
-    activeChild?.kill(signal);
+    if (activeChild) terminateClient(activeChild, signal);
   });
 }
 
@@ -56,12 +56,16 @@ async function main(args) {
     runId: workerContext.runId,
   });
   if (initial.status !== "started") throw new Error(`repo memory job cannot start from status ${initial.status}`);
+  const clientTimeoutMs = repoMemoryClientTimeoutMs();
+  const clientKillGraceMs = repoMemoryClientKillGraceMs();
   let state = writeJobState(request.jobPath, {
     ...initial,
     status: "running",
     pid: process.pid,
     workerPid: process.pid,
     workerStartedAt: new Date().toISOString(),
+    clientTimeoutMs,
+    clientKillGraceMs,
   });
 
   if (requestedSignal) {
@@ -85,9 +89,18 @@ async function main(args) {
       });
     },
     finalMessagePath: state.finalMessagePath,
+    timeoutMs: clientTimeoutMs,
+    killGraceMs: clientKillGraceMs,
   });
   state = readJobState(request.jobPath);
 
+  if (childResult.timedOut) {
+    return finishFailed(request, state, workerContext, `${runner}_timeout`, {
+      timeoutMs: childResult.timeoutMs,
+      elapsedMs: childResult.elapsedMs,
+      signal: childResult.signal,
+    });
+  }
   if (childResult.error) {
     return finishFailed(request, state, workerContext, `${runner}_spawn_failed`, {
       error: childResult.error.message,
@@ -213,6 +226,11 @@ async function waitForOwnedMarker(input) {
 function runClient(command, options) {
   return new Promise((resolveResult) => {
     let settled = false;
+    let timeoutHandle;
+    let killHandle;
+    let timedOut = false;
+    let timeoutMs;
+    const startedAt = Date.now();
     let invocation;
     try {
       invocation = process.platform === "win32" && /\.[cm]?js$/i.test(command[0])
@@ -228,6 +246,7 @@ function runClient(command, options) {
     const child = spawn(invocation.command, invocation.args, {
       cwd: options.cwd,
       env: options.env,
+      detached: process.platform !== "win32",
       stdio: options.captureStdout ? ["ignore", "pipe", "inherit"] : "inherit",
     });
     activeChild = child;
@@ -243,8 +262,10 @@ function runClient(command, options) {
     const finish = (result) => {
       if (settled) return;
       settled = true;
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      if (killHandle) clearTimeout(killHandle);
       activeChild = undefined;
-      resolveResult(result);
+      resolveResult({ ...result, timedOut, timeoutMs, elapsedMs: Date.now() - startedAt });
     };
     child.once("error", (error) => finish({ code: undefined, signal: undefined, error }));
     child.once("close", (code, signal) => {
@@ -258,10 +279,74 @@ function runClient(command, options) {
       }
       finish({ code, signal, error: undefined });
     });
-    if (requestedSignal) child.kill(requestedSignal);
+    if (Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        timeoutMs = options.timeoutMs;
+        timedOut = true;
+        const terminated = terminateClient(child, "SIGTERM");
+        // A broken or ignored CLI must not leave a detached job behind forever.
+        // The grace period is deliberately short and only targets this child.
+        killHandle = setTimeout(() => {
+          if (!settled) terminateClient(child, "SIGKILL");
+        }, options.killGraceMs);
+        if (!terminated && !settled) {
+          finish({
+            code: undefined,
+            signal: "SIGTERM",
+            error: undefined,
+            timedOut: true,
+            timeoutMs,
+          });
+        }
+      }, options.timeoutMs);
+    }
+    if (requestedSignal) terminateClient(child, requestedSignal);
   });
 }
 
+function terminateClient(child, signal) {
+  if (!child || !Number.isInteger(child.pid) || child.pid <= 0) return false;
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, signal);
+      return true;
+    } catch {
+      // The process group may have exited between the timeout and this call.
+    }
+  }
+  if (process.platform === "win32") {
+    try {
+      const result = spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "ignore"],
+      });
+      if (result.status === 0) return true;
+    } catch {
+      // Fall through to the direct child termination below.
+    }
+  }
+  try {
+    return child.kill(signal);
+  } catch {
+    return false;
+  }
+}
+
+function repoMemoryClientTimeoutMs(env = process.env) {
+  return positiveEnvInteger(env.MEMORAX_CODE_REPO_MEMORY_JOB_TIMEOUT_MS, 10 * 60 * 1000);
+}
+
+function repoMemoryClientKillGraceMs(env = process.env) {
+  return positiveEnvInteger(env.MEMORAX_CODE_REPO_MEMORY_JOB_KILL_GRACE_MS, 5000);
+}
+
+function positiveEnvInteger(value, fallback) {
+  if (typeof value !== "string" || !/^\d+$/.test(value.trim())) return fallback;
+  const parsed = Number(value.trim());
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 function validateBundle(repo, validator) {
   const python = process.env.MEMORAX_CODE_REPO_MEMORY_PYTHON_COMMAND || "python3";
   process.stdout.write("\n[repo-memory-worker] validating generated repo memory\n");

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/windows-cli-invocation.mjs

@@ -24,6 +24,9 @@ export function resolveWindowsCliInvocation(command, args, options = {}) {
   }
   resolvedCommand ??= command;
   if (/\.(?:exe|com)$/i.test(resolvedCommand)) return { command: resolvedCommand, args };
+  if (isBareCodeBuddyEntrypoint(resolvedCommand, pathApi) && fileExists(resolvedCommand)) {
+    return { command: options.nodePath ?? process.execPath, args: [resolvedCommand, ...args] };
+  }
   if (!/\.(?:cmd|bat)$/i.test(resolvedCommand)) {
     throw new Error(`refusing to execute unsupported Windows command shim: ${resolvedCommand}`);
   }
@@ -104,9 +107,16 @@ export function selectWindowsCommandCandidate(command, output) {
     .map((value) => value.trim())
     .filter(Boolean);
   const selected = candidates.find((value) => /\.(?:cmd|bat)$/i.test(value))
-    ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value));
+    ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value))
+    ?? (path.win32.basename(command).toLowerCase() === "codebuddy"
+      ? candidates.find((value) => isBareCodeBuddyEntrypoint(value, path.win32))
+      : undefined);
   if (!selected) {
     throw new Error(`where.exe did not return a safe executable or command shim for ${command}`);
   }
   return selected;
 }
+
+function isBareCodeBuddyEntrypoint(value, pathApi) {
+  return pathApi.basename(value).toLowerCase() === "codebuddy" && pathApi.extname(value) === "";
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/claude-adapter",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "description": "Claude Code Hook adapter for MemoraX Code memory services.",

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/runtime-hooks/ensure-backend.mjs

@@ -2,6 +2,7 @@
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { readClientHookPluginRoot } from "../memorax-code-adapter-common/src/config-utils.mjs";
 import {
   runEnsureBackendHook,
   stringValue,
@@ -31,6 +32,7 @@ process.exit(0);
 function pluginRoot() {
   return stringValue(process.env.CLAUDE_PLUGIN_ROOT)
     ?? stringValue(process.env.PLUGIN_ROOT)
+    ?? readClientHookPluginRoot()
     ?? dirname(dirname(fileURLToPath(import.meta.url)));
 }
 

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/src/plugin-install.mjs

@@ -32,6 +32,7 @@ const STABLE_SHELL_REQUIRED_FILES = Object.freeze([
   "memorax-code-adapter-common/src/hooks/capture-cwd-hook.mjs",
   "memorax-code-adapter-common/src/hooks/client-hook-launcher.mjs",
   "memorax-code-adapter-common/src/config-utils.mjs",
+  "memorax-code-adapter-common/src/setup-completion.mjs",
   "memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs",
   "memorax-code-adapter-common/src/hooks/hook-runtime-generation.mjs",
   "memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs",
@@ -226,10 +227,12 @@ export function ensureClaudePluginInstalled(options = {}) {
 }
 
 function writeInstalledPluginMetadata(installPath, claudeCommand) {
+  const npmExecPath = stringOption(process.env.MEMORAX_CODE_NPM_EXEC_PATH);
   atomicWriteJson(join(installPath, ".memorax-code-package.json"), {
     version: 1,
     memoraxCodeCommand: process.argv[1],
     claudeCommand,
+    ...(npmExecPath ? { npmExecPath } : {}),
     writtenAt: new Date().toISOString(),
   });
 }

package/lib/memorax-code-codebuddy-adapter/.codebuddy-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "memorax-code-codebuddy-adapter",
+  "version": "0.1.10",
+  "description": "MemoraX Code memory integration for CodeBuddy and WorkBuddy.",
+  "hooks": "./hooks/hooks.json",
+  "skills": ["./skills/memorax-code"]
+}

package/lib/memorax-code-codebuddy-adapter/hooks/common-runtime.mjs

@@ -0,0 +1,13 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export function resolveCommonSourceRoot(pluginRoot) {
+  const candidates = [
+    join(pluginRoot, "memorax-code-adapter-common", "src"),
+    join(pluginRoot, "..", "memorax-code-adapter-common", "src"),
+    join(pluginRoot, "..", "..", "memorax-code-adapter-common", "src"),
+  ];
+  const root = candidates.find((candidate) => existsSync(join(candidate, "repo-memory", "repo-memory-job-supervisor.mjs")));
+  if (!root) throw new Error(`MemoraX Code shared runtime is unavailable for CodeBuddy plugin: ${pluginRoot}`);
+  return root;
+}

package/lib/memorax-code-codebuddy-adapter/hooks/hooks.json

@@ -0,0 +1,38 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CODEBUDDY_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" turn",
+            "timeout": 35
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CODEBUDDY_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" turn",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CODEBUDDY_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" turn",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}

package/lib/memorax-code-codebuddy-adapter/hooks/repo-memory-job.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+import { resolveCommonSourceRoot } from "./common-runtime.mjs";
+
+const hookDir = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = dirname(hookDir);
+const commonRoot = resolveCommonSourceRoot(pluginRoot);
+const { resolveHookCodeBuddyCommand } = await import(pathToFileURL(join(commonRoot, "clients", "codebuddy-command.mjs")).href);
+const { runRepoMemoryJob } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-memory-job-supervisor.mjs")).href);
+const { evaluateRepository } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-memory-update-policy-evaluator.mjs")).href);
+
+try {
+  const payload = runRepoMemoryJob(process.argv.slice(2), {
+    runner: "codebuddy",
+    finalMessageSource: "stdout",
+    memorySkillInvocation: "the `memorax-code` skill",
+    validatorPath: resolve(pluginRoot, "skills/memorax-code/scripts/validate_memory.py"),
+    evaluateRepository,
+    createCommand({ prompt }) {
+      const codeBuddy = resolveHookCodeBuddyCommand({
+        pluginRoot,
+      });
+      return [
+        codeBuddy,
+        "--print",
+        "--output-format",
+        "text",
+        "--dangerously-skip-permissions",
+        "--no-session-persistence",
+        prompt,
+      ];
+    },
+  });
+  process.stdout.write(`${JSON.stringify(payload)}\n`);
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+}