@memorax/memorax-code 0.1.1 → 0.1.3

package/lib/memorax-code-opencode-adapter/src/repo-memory-server-runner.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const OPENCODE_REPO_MEMORY_AGENT = "memorax-code-repo-memory";
+
+export async function runOpenCodeRepoMemory(input, options = {}) {
+  const env = options.env ?? process.env;
+  const managedServerUrl = stringValue(env.MEMORAX_CODE_OPENCODE_SERVER_URL);
+  const serverUrl = stringValue(input?.serverUrl) ?? managedServerUrl;
+  if (!serverUrl) {
+    throw new Error(
+      "OpenCode repo memory runner requires --server-url or MEMORAX_CODE_OPENCODE_SERVER_URL",
+    );
+  }
+  const repo = stringValue(input?.repo);
+  if (!repo) throw new Error("OpenCode repo memory runner requires --repo");
+  const prompt = stringValue(input?.prompt);
+  if (!prompt) throw new Error("OpenCode repo memory runner requires --prompt");
+
+  const baseUrl = normalizedServerUrl(serverUrl);
+  const authorization = serverAuthorization(env, baseUrl, managedServerUrl);
+  const directory = resolve(repo);
+  const parentID = stringValue(input?.parentID)
+    ?? stringValue(env.MEMORAX_CODE_MEMORY_CLI_SESSION_ID);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  let sessionID;
+  try {
+    const session = await requestJson(fetchImpl, endpoint(baseUrl, "/session", directory), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(authorization ? { authorization } : {}),
+      },
+      body: JSON.stringify({
+        ...(parentID ? { parentID } : {}),
+        title: "MemoraX Code Repo Memory",
+        permission: [
+          { permission: "edit", pattern: "*", action: "allow" },
+          { permission: "bash", pattern: "*", action: "allow" },
+          { permission: "webfetch", pattern: "*", action: "allow" },
+          { permission: "doom_loop", pattern: "*", action: "allow" },
+          { permission: "external_directory", pattern: "*", action: "allow" },
+        ],
+      }),
+    }, "session creation");
+    sessionID = stringValue(session?.id);
+    if (!sessionID) throw new Error("OpenCode session creation returned no session id");
+
+    const message = await requestJson(
+      fetchImpl,
+      endpoint(baseUrl, `/session/${encodeURIComponent(sessionID)}/message`, directory),
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...(authorization ? { authorization } : {}),
+        },
+        body: JSON.stringify({
+          agent: OPENCODE_REPO_MEMORY_AGENT,
+          parts: [{ type: "text", text: prompt }],
+        }),
+      },
+      "blocking prompt",
+    );
+    const finalText = messageText(message);
+    if (!finalText) throw new Error("OpenCode repo memory runner received no final text");
+    return finalText;
+  } finally {
+    if (sessionID) {
+      await bestEffortDelete(
+        fetchImpl,
+        endpoint(baseUrl, `/session/${encodeURIComponent(sessionID)}`, directory),
+        authorization,
+      );
+    }
+  }
+}
+
+function parseArgs(values) {
+  const result = {};
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (value === "--server-url") result.serverUrl = requiredValue(values, ++index, value);
+    else if (value === "--repo") result.repo = requiredValue(values, ++index, value);
+    else if (value === "--prompt") result.prompt = requiredValue(values, ++index, value);
+    else if (value === "--parent-id") result.parentID = requiredValue(values, ++index, value);
+    else throw new Error(`unknown argument: ${value}`);
+  }
+  return result;
+}
+
+function requiredValue(values, index, option) {
+  const value = values[index];
+  if (!value || value.startsWith("--")) throw new Error(`${option} requires a value`);
+  return value;
+}
+
+function normalizedServerUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error();
+    return url;
+  } catch {
+    throw new Error("OpenCode repo memory runner requires a valid HTTP server URL");
+  }
+}
+
+function endpoint(baseUrl, pathname, directory) {
+  const url = new URL(pathname, baseUrl);
+  url.searchParams.set("directory", directory);
+  return url;
+}
+
+function serverAuthorization(env, targetUrl, managedServerUrl) {
+  const password = rawString(env.OPENCODE_SERVER_PASSWORD);
+  if (!password || !managedServerUrl) return undefined;
+  let managedUrl;
+  try {
+    managedUrl = normalizedServerUrl(managedServerUrl);
+  } catch {
+    return undefined;
+  }
+  if (targetUrl.origin !== managedUrl.origin) return undefined;
+  const username = rawString(env.OPENCODE_SERVER_USERNAME) ?? "opencode";
+  return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+}
+
+async function requestJson(fetchImpl, url, init, operation) {
+  let response;
+  try {
+    response = await fetchImpl(url, init);
+  } catch (error) {
+    throw new Error(`OpenCode ${operation} request failed: ${errorMessage(error)}`);
+  }
+  const body = await response.text();
+  if (!response.ok) {
+    const detail = responseDetail(body);
+    throw new Error(
+      `OpenCode ${operation} failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}`,
+    );
+  }
+  if (!body.trim()) throw new Error(`OpenCode ${operation} returned an empty response`);
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new Error(`OpenCode ${operation} returned invalid JSON`);
+  }
+}
+
+async function bestEffortDelete(fetchImpl, url, authorization) {
+  try {
+    await fetchImpl(url, {
+      method: "DELETE",
+      headers: authorization ? { authorization } : {},
+    });
+  } catch {
+    // Session cleanup must not replace the prompt result or its error.
+  }
+}
+
+function messageText(message) {
+  const payload = message?.data ?? message;
+  if (!Array.isArray(payload?.parts)) return undefined;
+  return payload.parts
+    .flatMap((part) => part?.type === "text" && stringValue(part.text) ? [part.text.trim()] : [])
+    .join("\n\n")
+    .trim() || undefined;
+}
+
+function responseDetail(body) {
+  if (!body.trim()) return undefined;
+  try {
+    const parsed = JSON.parse(body);
+    return stringValue(parsed?.data?.message)
+      ?? stringValue(parsed?.message)
+      ?? stringValue(parsed?.error);
+  } catch {
+    return body.trim().slice(0, 300);
+  }
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function rawString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isDirectExecution() {
+  return process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+
+if (isDirectExecution()) {
+  try {
+    const finalText = await runOpenCodeRepoMemory(parseArgs(process.argv.slice(2)));
+    process.stdout.write(`${finalText}\n`);
+  } catch (error) {
+    process.stderr.write(`${errorMessage(error)}\n`);
+    process.exitCode = 1;
+  }
+}

package/lib/resolve-claude-command.mjs

@@ -1,17 +1,30 @@
+import { spawnSync } from "node:child_process";
+import { readdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, win32 } from "node:path";
 import {
   commandOnPath,
   defaultVsCodeExtensionRoots,
   findVsCodeExtensionCommand,
+  isExecutableCommand,
 } from "./vscode-extension-command.mjs";
 
+const CLAUDE_DESKTOP_MACOS_RUNTIME_SEGMENTS = ["claude.app", "Contents", "MacOS", "claude"];
+const CLAUDE_DESKTOP_CODE_PROBE_TIMEOUT_MS = 10_000;
+const CLAUDE_DESKTOP_WINDOWS_PACKAGE_NAME = "Claude";
+const CLAUDE_DESKTOP_WINDOWS_QUERY_TIMEOUT_MS = 10_000;
+const CLAUDE_DESKTOP_WINDOWS_RUNTIME_SEGMENTS = ["claude.exe"];
+
 export function resolveClaudeCommand({
   env = process.env,
   homeDir = homedir(),
   platform = process.platform,
   arch = process.arch,
+  desktopCodeRoots = defaultClaudeDesktopCodeRoots(env, homeDir, platform),
+  desktopCodeProbe = spawnSync,
   vscodeExtensionRoots = defaultVsCodeExtensionRoots(homeDir),
+  windowsAppPackageFamilies,
+  windowsAppQuery = spawnSync,
 } = {}) {
   const configured = nonEmpty(env.MEMORAX_CODE_CLAUDE_COMMAND);
   if (configured) return { command: configured, source: "configured" };
@@ -20,6 +33,24 @@ export function resolveClaudeCommand({
     return { command: "claude", source: "path" };
   }
 
+  const desktopCommand = findClaudeDesktopCodeCommand(
+    desktopCodeRoots,
+    platform,
+    env,
+    desktopCodeProbe,
+  );
+  if (desktopCommand) return { command: desktopCommand, source: "app-bundled" };
+
+  const windowsDesktopCommand = resolveWindowsClaudeDesktopCodeCommand({
+    env,
+    homeDir,
+    packageFamilies: windowsAppPackageFamilies,
+    platform,
+    desktopCodeProbe,
+    spawnSyncImpl: windowsAppQuery,
+  });
+  if (windowsDesktopCommand) return { command: windowsDesktopCommand, source: "app-bundled" };
+
   const vscodeCommand = findVsCodeExtensionCommand({
     extensionId: "anthropic.claude-code",
     extensionRoots: vscodeExtensionRoots,
@@ -41,6 +72,128 @@ export function ensureClaudeCommandEnv(options = {}) {
   return resolved;
 }
 
+export function resolveWindowsClaudeDesktopCodeCommand({
+  env = process.env,
+  homeDir = homedir(),
+  packageFamilies,
+  platform = process.platform,
+  desktopCodeProbe = spawnSync,
+  spawnSyncImpl = spawnSync,
+} = {}) {
+  if (platform !== "win32") return undefined;
+  const localAppData = nonEmpty(env.LOCALAPPDATA) ?? join(homeDir, "AppData", "Local");
+  const families = packageFamilies ?? queryWindowsClaudeAppPackageFamilies(env, spawnSyncImpl);
+  const roots = families.map((family) => join(
+    localAppData,
+    "Packages",
+    family,
+    "LocalCache",
+    "Roaming",
+    "Claude",
+    "claude-code",
+  ));
+  return findClaudeDesktopCodeCommand(roots, platform, env, desktopCodeProbe);
+}
+
+function findClaudeDesktopCodeCommand(roots, platform, env, spawnSyncImpl) {
+  const runtimeSegments = claudeDesktopRuntimeSegments(platform);
+  if (!runtimeSegments) return undefined;
+  for (const root of new Set(roots)) {
+    let versions;
+    try {
+      versions = readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+        .map((entry) => entry.name)
+        .sort((left, right) => right.localeCompare(left, "en", { numeric: true, sensitivity: "base" }));
+    } catch {
+      continue;
+    }
+    for (const version of versions) {
+      const command = join(root, version, ...runtimeSegments);
+      if (
+        isExecutableCommand(command, platform)
+        && claudeDesktopCodeCommandIsRunnable(command, env, spawnSyncImpl)
+      ) {
+        return command;
+      }
+    }
+  }
+  return undefined;
+}
+
+function claudeDesktopCodeCommandIsRunnable(command, env, spawnSyncImpl) {
+  let result;
+  try {
+    result = spawnSyncImpl(
+      command,
+      ["--version"],
+      {
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: CLAUDE_DESKTOP_CODE_PROBE_TIMEOUT_MS,
+        windowsHide: true,
+      },
+    );
+  } catch {
+    return false;
+  }
+  return result.status === 0 && !result.error && !result.signal;
+}
+
+function defaultClaudeDesktopCodeRoots(env, homeDir, platform) {
+  if (platform === "darwin") {
+    return [join(homeDir, "Library", "Application Support", "Claude", "claude-code")];
+  }
+  if (platform === "win32") {
+    const appData = nonEmpty(env.APPDATA) ?? join(homeDir, "AppData", "Roaming");
+    return [join(appData, "Claude", "claude-code")];
+  }
+  return [];
+}
+
+function claudeDesktopRuntimeSegments(platform) {
+  if (platform === "darwin") return CLAUDE_DESKTOP_MACOS_RUNTIME_SEGMENTS;
+  if (platform === "win32") return CLAUDE_DESKTOP_WINDOWS_RUNTIME_SEGMENTS;
+  return undefined;
+}
+
+function queryWindowsClaudeAppPackageFamilies(env, spawnSyncImpl) {
+  const powershell = windowsPowerShellCommand(env);
+  const script = [
+    "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+    `Get-AppxPackage -Name '${CLAUDE_DESKTOP_WINDOWS_PACKAGE_NAME}' -ErrorAction SilentlyContinue | ForEach-Object { $_.PackageFamilyName }`,
+  ].join("; ");
+  let result;
+  try {
+    result = spawnSyncImpl(
+      powershell,
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
+      {
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: CLAUDE_DESKTOP_WINDOWS_QUERY_TIMEOUT_MS,
+        windowsHide: true,
+      },
+    );
+  } catch {
+    return [];
+  }
+  if (result.status !== 0 || result.error || result.signal) return [];
+  return [...new Set(String(result.stdout ?? "")
+    .split(/\r?\n/)
+    .map((value) => value.replace(/^\uFEFF/, "").trim())
+    .filter((value) => /^[A-Za-z0-9][A-Za-z0-9.-]*_[A-Za-z0-9]+$/.test(value)))];
+}
+
+function windowsPowerShellCommand(env) {
+  const systemRoot = nonEmpty(env.SystemRoot) ?? nonEmpty(env.SYSTEMROOT);
+  return systemRoot
+    ? win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    : "powershell.exe";
+}
+
 function nonEmpty(value) {
   const normalized = String(value ?? "").trim();
   return normalized || undefined;

package/lib/resolve-codex-command.mjs

@@ -1,6 +1,7 @@
+import { spawnSync } from "node:child_process";
 import { readdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, win32 } from "node:path";
 import {
   commandOnPath,
   defaultVsCodeExtensionRoots,
@@ -9,6 +10,8 @@ import {
 } from "./vscode-extension-command.mjs";
 
 const APP_BUNDLE_NAMES = ["ChatGPT.app", "Codex.app"];
+const WINDOWS_CODEX_APP_PROBE_TIMEOUT_MS = 10_000;
+const WINDOWS_CODEX_APP_RUNTIME_SEGMENTS = ["plugins", ".plugin-appserver", "codex.exe"];
 
 export function resolveCodexCommand({
   env = process.env,
@@ -17,6 +20,9 @@ export function resolveCodexCommand({
   arch = process.arch,
   applicationRoots = [join(homeDir, "Applications"), "/Applications"],
   vscodeExtensionRoots = defaultVsCodeExtensionRoots(homeDir),
+  windowsAppProbe = spawnSync,
+  windowsAppRuntimePaths,
+  windowsPathExists = isExecutableCommand,
 } = {}) {
   const npmOverride = nonEmpty(env.MEMORAX_CODE_CODEX_COMMAND);
   if (npmOverride) return { command: npmOverride, source: "npm-override" };
@@ -37,6 +43,16 @@ export function resolveCodexCommand({
     }
   }
 
+  const windowsAppCommand = resolveWindowsCodexAppCommand({
+    env,
+    homeDir,
+    pathExists: windowsPathExists,
+    platform,
+    runtimePaths: windowsAppRuntimePaths,
+    spawnSyncImpl: windowsAppProbe,
+  });
+  if (windowsAppCommand) return { command: windowsAppCommand, source: "app-bundled" };
+
   const vscodeCommand = findVsCodeExtensionCommand({
     extensionId: "openai.chatgpt",
     extensionRoots: vscodeExtensionRoots,
@@ -49,6 +65,25 @@ export function resolveCodexCommand({
   return { command: "codex", source: "unavailable" };
 }
 
+export function resolveWindowsCodexAppCommand({
+  env = process.env,
+  homeDir = homedir(),
+  pathExists = isExecutableCommand,
+  platform = process.platform,
+  runtimePaths,
+  spawnSyncImpl = spawnSync,
+} = {}) {
+  if (platform !== "win32") return undefined;
+  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)) {
+      return command;
+    }
+  }
+  return undefined;
+}
+
 export function ensureCodexCommandEnv(options = {}) {
   const env = options.env ?? process.env;
   const resolved = resolveCodexCommand({ ...options, env });
@@ -88,6 +123,26 @@ function codexPlatformDirectories(platform, arch) {
   return [];
 }
 
+function windowsCodexCommandIsRunnable(command, env, spawnSyncImpl) {
+  let result;
+  try {
+    result = spawnSyncImpl(
+      command,
+      ["--version"],
+      {
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: WINDOWS_CODEX_APP_PROBE_TIMEOUT_MS,
+        windowsHide: true,
+      },
+    );
+  } catch {
+    return false;
+  }
+  return result.status === 0 && !result.error && !result.signal;
+}
+
 function nonEmpty(value) {
   const normalized = String(value ?? "").trim();
   return normalized || undefined;

package/lib/run-entrypoint.mjs

@@ -74,6 +74,12 @@ export async function runClaudeAdapterCli() {
   await import(pathToFileURL(entrypoint).href);
 }
 
+export async function runOpenCodeAdapterCli() {
+  if (!ensureSupportedNodeRuntime()) return;
+  const entrypoint = join(packageRoot, "lib", "memorax-code-opencode-adapter", "src", "cli.mjs");
+  await import(pathToFileURL(entrypoint).href);
+}
+
 function ensureSupportedNodeRuntime() {
   const message = unsupportedNodeVersionMessage();
   if (!message) return true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memorax/memorax-code",
-  "version": "0.1.1",
-  "description": "MemoraX Code CLI, local memory backend, Codex and Claude Code adapters, skills, and Memory Viewer.",
+  "version": "0.1.3",
+  "description": "Persistent coding memory for Codex, Claude Code, DeepSeek Harness, and OpenCode.",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/memorax-ai/memorax-code#readme",
@@ -15,6 +15,9 @@
   "keywords": [
     "agent",
     "codex",
+    "deepseek-harness",
+    "dsh",
+    "opencode",
     "memory",
     "memorax"
   ],
@@ -23,7 +26,8 @@
     "memorax-cli": "bin/memorax-cli.mjs",
     "memorax-code-backend": "bin/memorax-code-backend.mjs",
     "memorax-code-claude": "bin/memorax-code-claude.mjs",
-    "memorax-code-codex": "bin/memorax-code-codex.mjs"
+    "memorax-code-codex": "bin/memorax-code-codex.mjs",
+    "memorax-code-opencode": "bin/memorax-code-opencode.mjs"
   },
   "files": [
     "bin",

package/lib/memorax-code-backend/dist/client-plugin-removal.js

@@ -1,67 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { cleanupCodexAfterBackendRemoval, } from "./codex-plugin-install.js";
-export async function prepareClientPluginRemovalCleanup(options = {}) {
-    const claudePluginInstaller = await loadClaudePluginInstaller();
-    const home = resolveHome(options.homeDir);
-    const memoraxCodeHome = resolve(options.memoraxCodeHome ?? process.env.MEMORAX_CODE_HOME ?? join(home, ".memorax-code"));
-    const claudeState = await readJsonRecord(join(memoraxCodeHome, "adapters", "claude-code", "state.json"));
-    const claudeHome = options.claudeHome ?? stringField(claudeState, "claudeHome");
-    return async () => {
-        const [codexPlugin, claudePlugin] = await Promise.all([
-            cleanupCodexAfterBackendRemoval({
-                memoraxCodeHome,
-                homeDir: home,
-                codexHome: options.codexHome,
-                codexCommand: options.codexCommand,
-            }).catch((error) => removalFailure("backend-removal-cleanup", error)),
-            Promise.resolve()
-                .then(() => claudePluginInstaller.removeClaudePluginInstallation({
-                memoraxCodeHome,
-                ...(claudeHome ? { claudeHome } : {}),
-                ...(options.claudeCommand ? { claudeCommand: options.claudeCommand } : {}),
-            }))
-                .catch((error) => removalFailure("claude-plugin-remove", error)),
-        ]);
-        return {
-            ok: codexPlugin.ok && claudePlugin.ok,
-            action: "client-plugin-removal-cleanup",
-            codexPlugin,
-            claudePlugin,
-        };
-    };
-}
-async function loadClaudePluginInstaller() {
-    return await import(new URL("../../memorax-code-claude-adapter/src/plugin-install.mjs", import.meta.url).href);
-}
-async function readJsonRecord(path) {
-    if (!existsSync(path))
-        return undefined;
-    try {
-        const parsed = JSON.parse(await readFile(path, "utf8"));
-        return isRecord(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function stringField(record, key) {
-    const value = record?.[key];
-    return typeof value === "string" && value.trim() ? value : undefined;
-}
-function resolveHome(value) {
-    return resolve(value ?? process.env.HOME ?? homedir());
-}
-function removalFailure(action, error) {
-    return {
-        ok: false,
-        action,
-        reason: "plugin_remove_failed",
-        message: error instanceof Error ? error.message : String(error),
-    };
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}