@memorax/memorax-code 0.1.1 → 0.1.3

package/lib/memorax-code-backend/dist/{service.js → lifecycle/backend/service.js}

@@ -3,21 +3,21 @@ import { spawn } from "node:child_process";
 import { closeSync, existsSync, openSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { BackendConnectionAuthorityError, DEFAULT_BACKEND_URL, resolveBackendConnection, writeBackendConnectionAuthority, } from "../../memorax-code-adapter-common/src/backend-connection.mjs";
-import { ensurePrivateDirectory, } from "../../memorax-code-adapter-common/src/runtime-record.mjs";
-import { backendEnv, parseBooleanEnv } from "./backend-env.js";
-import { isProcessAlive, managedServiceCommandLine, probeProcessCommandLine, terminateProcessTree, } from "./backend-process.js";
-import { clearBackendServiceState } from "./backend-service-cleanup.js";
-import { readBackendServiceRecordAtPath, readBackendServiceStateAtPath, writeBackendServiceStateAtPath, } from "./backend-service-record.js";
-import { assertBackendTokenPersistenceEligible } from "./backend-token-record.js";
-import { clearBackendShutdownRequest, writeBackendShutdownRequest, } from "./backend-shutdown-request.js";
-import { runtimeRecordDurabilityWarning, runtimeRecordErrorFields, runtimeRecordServiceFailure, withRuntimeRecordWarnings, } from "./backend-service-result.js";
-import { persistBackendToken, readBackendToken, writeBackendToken, } from "./backend-service-token.js";
-import { backendServiceHome } from "./backend-lifecycle-lock.js";
-import { isLoopbackHost } from "./backend-state.js";
-import { withLoopbackProxyBypass } from "./proxy-env.js";
-export { BACKEND_SERVICE_RECORD_VERSION, BackendServiceStateError, } from "./backend-service-record.js";
-export { isProcessAlive, terminateProcessTree } from "./backend-process.js";
+import { BackendConnectionAuthorityError, DEFAULT_BACKEND_URL, resolveBackendConnection, writeBackendConnectionAuthority, } from "../../../../memorax-code-adapter-common/src/backend-connection.mjs";
+import { ensurePrivateDirectory, } from "../../../../memorax-code-adapter-common/src/runtime-record.mjs";
+import { backendEnv, parseBooleanEnv } from "../../config/backend-env.js";
+import { isProcessAlive, managedServiceCommandLine, probeProcessCommandLine, terminateProcessTree, } from "./process.js";
+import { clearBackendServiceState } from "./cleanup.js";
+import { readBackendServiceRecordAtPath, readBackendServiceStateAtPath, writeBackendServiceStateAtPath, } from "./record.js";
+import { assertBackendTokenPersistenceEligible } from "./token-record.js";
+import { clearBackendShutdownRequest, writeBackendShutdownRequest, } from "./shutdown-request.js";
+import { runtimeRecordDurabilityWarning, runtimeRecordErrorFields, runtimeRecordServiceFailure, withRuntimeRecordWarnings, } from "./result.js";
+import { persistBackendToken, readBackendToken, writeBackendToken, } from "./token.js";
+import { backendServiceHome } from "../lock.js";
+import { isLoopbackHost } from "../../app/state.js";
+import { withLoopbackProxyBypass } from "../../config/proxy-env.js";
+export { BACKEND_SERVICE_RECORD_VERSION, BackendServiceStateError, } from "./record.js";
+export { isProcessAlive, terminateProcessTree } from "./process.js";
 export { readBackendToken, writeBackendToken };
 function serviceDir(options) {
     return join(backendServiceHome(options), "runtime", "backend");
@@ -131,7 +131,7 @@ export async function startBackendService(options = {}, runtime = {}) {
     const logs = logPath(options);
     const outFd = openSync(logs, "a");
     const errFd = openSync(logs, "a");
-    const serverPath = fileURLToPath(new URL("./service-entrypoint.js", import.meta.url));
+    const serverPath = fileURLToPath(new URL("../../service-entrypoint.js", import.meta.url));
     const instanceId = randomBytes(24).toString("base64url");
     let child;
     try {

package/lib/memorax-code-backend/dist/{backend-token-record.js → lifecycle/backend/token-record.js}

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { backendTokenPath, BackendTokenRecordError, readBackendTokenRecordState, writeBackendTokenRecord, } from "../../memorax-code-adapter-common/src/backend-connection.mjs";
+import { backendTokenPath, BackendTokenRecordError, readBackendTokenRecordState, writeBackendTokenRecord, } from "../../../../memorax-code-adapter-common/src/backend-connection.mjs";
 export function readBackendTokenForHome(memoraxCodeHome) {
     const state = readBackendTokenRecordState(memoraxCodeHome);
     if (state.status === "absent")

package/lib/memorax-code-backend/dist/{backend-service-token.js → lifecycle/backend/token.js}

@@ -1,5 +1,5 @@
-import { backendServiceHome } from "./backend-lifecycle-lock.js";
-import { persistBackendTokenForHome, readBackendTokenForHome, writeBackendTokenForHome, } from "./backend-token-record.js";
+import { backendServiceHome } from "../lock.js";
+import { persistBackendTokenForHome, readBackendTokenForHome, writeBackendTokenForHome, } from "./token-record.js";
 export function readBackendToken(options = {}) {
     return readBackendTokenForHome(backendServiceHome(options));
 }

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

@@ -0,0 +1,109 @@
+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 "../clients/codex/plugin-install.js";
+import { withBackendLifecycleLock } from "./lock.js";
+export async function prepareClientPluginRemovalCleanup(options = {}) {
+    const claudePluginInstaller = await loadClaudePluginInstaller();
+    const dshProfileLifecycle = await loadDshProfileLifecycle();
+    const openCodePluginInstaller = await loadOpenCodePluginInstaller();
+    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 () => {
+        try {
+            return await withBackendLifecycleLock({ home: memoraxCodeHome }, async () => {
+                const [codexPlugin, claudePlugin, dshPlugin, opencodePlugin] = 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)),
+                    dshProfileLifecycle.withDshPluginLifecycleLock({
+                        memoraxCodeHome,
+                        homeDir: home,
+                        ...(options.dshHome ? { dshHome: options.dshHome } : {}),
+                        ...(options.dshAdapterRoot ? { adapterRoot: options.dshAdapterRoot } : {}),
+                        ...(options.dshCommand ? { dshCommand: options.dshCommand } : {}),
+                    }, (lifecycle) => lifecycle.remove())
+                        .catch((error) => removalFailure("dsh-plugin-remove", error)),
+                    Promise.resolve()
+                        .then(() => openCodePluginInstaller.removeOpenCodePluginInstallation({
+                        memoraxCodeHome,
+                        ...(options.openCodeConfigDir
+                            ? { openCodeConfigDir: options.openCodeConfigDir }
+                            : {}),
+                    }))
+                        .catch((error) => removalFailure("opencode-plugin-remove", error)),
+                ]);
+                return {
+                    ok: codexPlugin.ok && claudePlugin.ok && dshPlugin.ok && opencodePlugin.ok,
+                    action: "client-plugin-removal-cleanup",
+                    codexPlugin,
+                    claudePlugin,
+                    dshPlugin,
+                    opencodePlugin,
+                };
+            });
+        }
+        catch (error) {
+            const failure = removalFailure("client-plugin-removal-cleanup", error);
+            return {
+                ok: false,
+                action: "client-plugin-removal-cleanup",
+                codexPlugin: failure,
+                claudePlugin: failure,
+                dshPlugin: failure,
+                opencodePlugin: failure,
+            };
+        }
+    };
+}
+async function loadClaudePluginInstaller() {
+    return await import(new URL("../../../memorax-code-claude-adapter/src/plugin-install.mjs", import.meta.url).href);
+}
+async function loadOpenCodePluginInstaller() {
+    return await import(new URL("../../../memorax-code-opencode-adapter/src/plugin-install.mjs", import.meta.url).href);
+}
+async function loadDshProfileLifecycle() {
+    return await import(new URL("../../../memorax-code-dsh-adapter/src/profile-lifecycle.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);
+}

package/lib/memorax-code-backend/dist/{client-selection.js → lifecycle/client-selection.js}

@@ -1,5 +1,5 @@
-import { loadLifecycleMemoraxCodeConfig } from "./memorax-code-config.js";
-const allClients = Object.freeze({ codex: true, claude: true });
+import { loadLifecycleMemoraxCodeConfig } from "../config/memorax-code.js";
+const allClients = Object.freeze({ codex: true, claude: true, dsh: true, opencode: true });
 export function resolveManagedClients(argv, config = {}) {
     const explicit = argValue(argv, "--clients");
     if (explicit !== undefined)
@@ -8,6 +8,10 @@ export function resolveManagedClients(argv, config = {}) {
         return {
             codex: config.clients.codex === true,
             claude: config.clients.claude === true,
+            // DSH was added after the original clients table. An omitted value keeps
+            // automatic local-Harness discovery enabled for existing installations.
+            dsh: config.clients.dsh !== false,
+            opencode: config.clients.opencode === true,
         };
     }
     return allClients;
@@ -17,14 +21,16 @@ export function parseManagedClients(value) {
     if (normalized === "all")
         return allClients;
     if (normalized === "none")
-        return { codex: false, claude: false };
+        return { codex: false, claude: false, dsh: false, opencode: false };
     const names = normalized.split(",").map((name) => name.trim()).filter(Boolean);
-    if (names.length === 0 || names.some((name) => name !== "codex" && name !== "claude")) {
-        throw new Error(`invalid --clients value: ${value}; expected codex, claude, codex,claude, all, or none`);
+    if (names.length === 0 || names.some((name) => (name !== "codex" && name !== "claude" && name !== "dsh" && name !== "opencode"))) {
+        throw new Error(`invalid --clients value: ${value}; expected a comma-separated subset of codex, claude, dsh, opencode, or all or none`);
     }
     return {
         codex: names.includes("codex"),
         claude: names.includes("claude"),
+        dsh: names.includes("dsh"),
+        opencode: names.includes("opencode"),
     };
 }
 export function loadManagedClientsConfig(memoraxCodeHome) {

package/lib/memorax-code-backend/dist/{backend-lifecycle-lock.js → lifecycle/lock.js}

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { withJsonFileLockAsync } from "../../memorax-code-adapter-common/src/config-utils.mjs";
+import { withJsonFileLockAsync } from "../../../memorax-code-adapter-common/src/config-utils.mjs";
 const BACKEND_LIFECYCLE_LOCK_TIMEOUT_MS = 25000;
 const BACKEND_LIFECYCLE_LOCK_STALE_MS = 5000;
 const BACKEND_LIFECYCLE_LOCK_RETRY_MS = 20;