@memorax/memorax-code 0.1.8 → 0.1.10

package/lib/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-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-backend/dist/app/backend-server.js

@@ -8,7 +8,7 @@ import { handleHealthRequest } from "../transport/http/health.js";
 import { authorized, publicErrorMessage, statusCodeFromError } from "../transport/http/request.js";
 import { json } from "../transport/http/json.js";
 import { createBackendState } from "./state.js";
-import { TRACE_CLIENTS } from "../trace/config.js";
+import { TRACE_RUNTIME_CLIENTS } from "../trace/config.js";
 import { pruneExpiredTraceSessionsForClient } from "../trace/store.js";
 const DEFAULT_BACKEND_SHUTDOWN_TIMEOUT_MS = 4_000;
 export function createBackendServer(state = createBackendState(), options = {}) {
@@ -28,7 +28,7 @@ export function createBackendServer(state = createBackendState(), options = {})
             memoraxCodeHome: state.sessionHome,
         }),
     };
-    for (const client of TRACE_CLIENTS) {
+    for (const client of TRACE_RUNTIME_CLIENTS) {
         void pruneExpiredTraceSessionsForClient({
             client,
             memoraxCodeHome: state.sessionHome,

package/lib/memorax-code-backend/dist/app/memory-observability.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { backendDebug } from "../shared/debug-log.js";
-import { TRACE_CLIENTS, clientTraceConfigFromEnv, } from "../trace/config.js";
+import { TRACE_RUNTIME_CLIENTS, clientTraceConfigFromEnv, } from "../trace/config.js";
 import { recordTraceEvent } from "../trace/store.js";
 export function createBackendMemoryObservability(memoraxCodeHome, existingHook, env = process.env) {
     if (existingHook)
@@ -47,7 +47,7 @@ export function composeMemoryObservabilityHooks(hooks) {
     };
 }
 function sessionTraceObservabilityHook(memoraxCodeHome, env) {
-    const enabledClients = new Set(TRACE_CLIENTS.filter((client) => clientTraceConfigFromEnv(client, env).enabled));
+    const enabledClients = new Set(TRACE_RUNTIME_CLIENTS.filter((client) => clientTraceConfigFromEnv(client, env).enabled));
     if (enabledClients.size === 0)
         return undefined;
     const pending = new Set();

package/lib/memorax-code-backend/dist/clients/codebuddy/jsonl-history.js

@@ -0,0 +1,208 @@
+import { readFile } from "node:fs/promises";
+import { codeBuddyPromptDigest, parseCodeBuddyTurnId } from "./turn-id.js";
+const RECORD_OFFSET = Symbol("codebuddyRecordOffset");
+export async function readCodeBuddyTranscriptTurn(input) {
+    let text;
+    try {
+        text = await readFile(input.transcriptPath, "utf8");
+    }
+    catch (error) {
+        return { ok: false, reason: "transcript_unavailable", error: error instanceof Error ? error.message : String(error) };
+    }
+    return codeBuddyTranscriptTurnFromJsonLines(text, input);
+}
+export async function readCodeBuddyInterruptedTranscriptTurn(input) {
+    let text;
+    try {
+        text = await readFile(input.transcriptPath, "utf8");
+    }
+    catch (error) {
+        return { ok: false, reason: "transcript_unavailable", error: error instanceof Error ? error.message : String(error) };
+    }
+    return codeBuddyInterruptedTranscriptTurnFromJsonLines(text, input);
+}
+export function codeBuddyTranscriptTurnFromJsonLines(text, input) {
+    const selected = selectCodeBuddyTurnBranch(text, input);
+    if (!selected.ok)
+        return selected;
+    const branch = selected.records.filter((record) => record.role === "assistant" && record.status === "completed" && belongsTo(record, selected.userId, selected.records));
+    if (branch.length !== 1)
+        return { ok: false, reason: branch.length > 1 ? "turn_ambiguous" : "assistant_message_missing" };
+    const assistant = branch[0];
+    const reply = assistantText(assistant);
+    if (!reply)
+        return { ok: false, reason: "assistant_message_missing" };
+    return {
+        ok: true,
+        turn: {
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            userPrompt: selected.userPrompt,
+            assistantReply: reply,
+            activities: activitiesBetween(selected.records, selected.userId, assistant),
+            sessionTurnIndex: selected.sessionTurnIndex,
+        },
+    };
+}
+export function codeBuddyInterruptedTranscriptTurnFromJsonLines(text, input) {
+    const selected = selectCodeBuddyTurnBranch(text, input);
+    if (!selected.ok)
+        return selected;
+    const assistants = selected.records.filter((record) => (record.role === "assistant"
+        && (record.type === "message" || stringField(record, "status") !== undefined)
+        && belongsTo(record, selected.userId, selected.records)));
+    if (assistants.length > 1)
+        return { ok: false, reason: "turn_ambiguous" };
+    const assistant = assistants[0];
+    if (assistant && assistant.status !== "incomplete") {
+        return { ok: false, reason: "turn_not_interrupted" };
+    }
+    return {
+        ok: true,
+        turn: {
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            userPrompt: selected.userPrompt,
+            assistantReply: assistant ? assistantText(assistant) ?? "" : "",
+            activities: assistant ? activitiesBetween(selected.records, selected.userId, assistant) : [],
+            sessionTurnIndex: selected.sessionTurnIndex,
+        },
+    };
+}
+function selectCodeBuddyTurnBranch(text, input) {
+    const identity = parseCodeBuddyTurnId(input);
+    if (!identity)
+        return { ok: false, reason: "turn_not_found" };
+    const records = parseJsonLines(text);
+    if (!records)
+        return { ok: false, reason: "malformed_transcript" };
+    const session = records.filter((record) => stringField(record, "sessionId") === input.sessionId);
+    const users = session.filter((record) => record.role === "user" && visibleUserPrompt(record));
+    const candidates = users.filter((record) => {
+        const prompt = visibleUserPrompt(record);
+        return Boolean(prompt
+            && (record[RECORD_OFFSET] ?? Number.MAX_SAFE_INTEGER) >= identity.boundary
+            && codeBuddyPromptDigest(prompt) === identity.promptDigest);
+    });
+    if (candidates.length === 0)
+        return { ok: false, reason: "user_prompt_missing" };
+    if (candidates.length > 1)
+        return { ok: false, reason: "turn_ambiguous" };
+    const user = candidates[0];
+    const userId = stringField(user, "id");
+    const userPrompt = visibleUserPrompt(user);
+    if (!userId || !userPrompt)
+        return { ok: false, reason: "turn_not_found" };
+    return {
+        ok: true,
+        records,
+        userId,
+        userPrompt,
+        sessionTurnIndex: users.indexOf(user) + 1,
+    };
+}
+function parseJsonLines(text) {
+    const records = [];
+    let cursor = 0;
+    let byteOffset = 0;
+    while (cursor < text.length) {
+        const newline = text.indexOf("\n", cursor);
+        const lineEnd = newline >= 0 ? newline : text.length;
+        const rawLine = text.slice(cursor, lineEnd);
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (line.trim()) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    Object.defineProperty(parsed, RECORD_OFFSET, { configurable: false, enumerable: false, value: byteOffset });
+                    records.push(parsed);
+                }
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const newlineBytes = newline >= 0 ? (rawLine.endsWith("\r") ? 2 : 1) : 0;
+        byteOffset += Buffer.byteLength(rawLine, "utf8") + newlineBytes;
+        cursor = newline >= 0 ? newline + 1 : text.length;
+    }
+    const byId = new Map();
+    const withoutId = [];
+    for (const record of records) {
+        const id = stringField(record, "id");
+        if (id)
+            byId.set(id, record);
+        else
+            withoutId.push(record);
+    }
+    return [...withoutId, ...byId.values()];
+}
+function visibleUserPrompt(record) {
+    const content = messageContentText(record.content, "input_text");
+    if (!content)
+        return undefined;
+    const match = content.match(/<user_query>([\s\S]*?)<\/user_query>/);
+    return (match?.[1] ?? content).trim() || undefined;
+}
+function assistantText(record) {
+    return messageContentText(record.content, "output_text")?.trim() || undefined;
+}
+function messageContentText(value, expectedType) {
+    if (!Array.isArray(value))
+        return undefined;
+    const parts = value.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const block = item;
+        return block.type === expectedType && typeof block.text === "string" ? [block.text] : [];
+    });
+    return parts.join("\n") || undefined;
+}
+function contentText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value))
+        return undefined;
+    const parts = value.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const text = item.text;
+        return typeof text === "string" ? [text] : [];
+    });
+    return parts.join("\n") || undefined;
+}
+function belongsTo(record, userId, records) {
+    let current = record;
+    const seen = new Set();
+    for (let depth = 0; current && depth < 100; depth += 1) {
+        const id = stringField(current, "id");
+        if (id && seen.has(id))
+            return false;
+        if (id)
+            seen.add(id);
+        const parent = stringField(current, "parentId");
+        if (!parent)
+            return false;
+        if (parent === userId)
+            return true;
+        current = records.find((candidate) => stringField(candidate, "id") === parent);
+    }
+    return false;
+}
+function activitiesBetween(records, userId, assistant) {
+    const result = [];
+    for (const record of records) {
+        const type = stringField(record, "type");
+        if (type !== "function_call" && type !== "function_call_result")
+            continue;
+        if (!belongsTo(record, userId, records) || !belongsTo(assistant, userId, records))
+            continue;
+        const name = stringField(record, "name") ?? stringField(record, "function") ?? "tool";
+        result.push({ kind: "tool", name, ...(contentText(record.arguments) ? { input: contentText(record.arguments) } : {}), ...(contentText(record.output) ? { output: contentText(record.output) } : {}) });
+    }
+    return result;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-backend/dist/clients/codebuddy/lifecycle.js

@@ -0,0 +1,44 @@
+export const codeBuddyAdapterLifecycle = {
+    async status({ argv, serviceOptions }) {
+        try {
+            return (await load()).readCodeBuddyAdapterStatus(options(argv, serviceOptions));
+        }
+        catch (error) {
+            return failure("status", error);
+        }
+    },
+    async prepareEnable({ argv, serviceOptions }) {
+        try {
+            return (await load()).enableCodeBuddyAdapter(options(argv, serviceOptions));
+        }
+        catch (error) {
+            return failure("enable", error);
+        }
+    },
+    async disable({ argv, serviceOptions }) {
+        try {
+            return (await load()).disableCodeBuddyAdapter(options(argv, serviceOptions));
+        }
+        catch (error) {
+            return failure("disable", error);
+        }
+    },
+    async remove({ argv, serviceOptions }) {
+        try {
+            return (await load()).removeCodeBuddyPluginInstallation(options(argv, serviceOptions));
+        }
+        catch (error) {
+            return {
+                ok: false,
+                action: "codebuddy-plugin-remove",
+                reason: "plugin_remove_failed",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+};
+async function load() { return await import(new URL("../../../../memorax-code-codebuddy-adapter/src/config.mjs", import.meta.url).href); }
+function options(argv, serviceOptions) { const index = argv.indexOf("--codebuddy-home"); return { ...(index >= 0 && argv[index + 1] ? { codeBuddyHome: argv[index + 1] } : {}), memoraxCodeHome: serviceOptions.home }; }
+function failure(action, error) {
+    return { ok: false, action, error: error instanceof Error ? error.message : String(error) };
+}