@memorax/memorax-code 0.1.2 → 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/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.2",
-  "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);
-}