@memorax/memorax-code 0.1.1 → 0.1.3

package/bin/memorax-code-plugin-postinstall.mjs

@@ -18,8 +18,10 @@ import {
   normalizeMemoraxMemoryOutputLanguage,
 } from "../lib/memorax-code-adapter-common/src/memorax-defaults.mjs";
 import { stagePackagedClientHookRuntime } from "../lib/client-hook-runtime.mjs";
+import { discoverDshProfiles } from "../lib/dsh-plugin-install.mjs";
 import { ensureClaudeCommandEnv } from "../lib/resolve-claude-command.mjs";
 import { ensureCodexCommandEnv } from "../lib/resolve-codex-command.mjs";
+import { commandOnPath } from "../lib/vscode-extension-command.mjs";
 import { resolveWindowsCliInvocation } from "../lib/windows-cli-invocation.mjs";
 
 const PLUGIN_NAME = "memorax-code-codex-adapter";
@@ -30,14 +32,17 @@ const HOOK_TRUST_SELECTION_ENV = "MEMORAX_CODE_CODEX_HOOK_TRUST_SELECTION_JSON";
 const PREFIX = "[MemoraX Code Install]:";
 const BACKEND_PREFIX = "[MemoraX Code Backend]:";
 const GREEN = "\x1b[32m";
+const BRIGHT_CYAN = "\x1b[96m";
 const BLUE = "\x1b[34m";
 const RED = "\x1b[31m";
 const BOLD = "\x1b[1m";
+const UNDERLINE = "\x1b[4m";
 const RESET = "\x1b[0m";
 
 if (truthyEnv(process.env.MEMORAX_CODE_SKIP_POSTINSTALL)) process.exit(0);
 const skipCodexPluginInstall = truthyEnv(process.env.MEMORAX_CODE_SKIP_CODEX_PLUGIN_INSTALL);
 const skipClaudeAdapterInstall = truthyEnv(process.env.MEMORAX_CODE_SKIP_CLAUDE_ADAPTER_INSTALL);
+const skipOpenCodeAdapterInstall = truthyEnv(process.env.MEMORAX_CODE_SKIP_OPENCODE_ADAPTER_INSTALL);
 
 const scriptDir = dirname(fileURLToPath(import.meta.url));
 const memoraxCodeBin = join(scriptDir, "memorax-code.mjs");
@@ -48,10 +53,23 @@ const codexCommand = codexRuntime.command;
 const claudeRuntime = ensureClaudeCommandEnv();
 const claudeCommand = claudeRuntime.command;
 const updatePostinstall = postinstallUpdateMode();
-const scriptedAnswers = (canPrompt() || canPromptForHookUpdate()) && process.stdin.isTTY !== true
+const scriptedAnswers = (canPrompt() || canPromptForUpdate()) && process.stdin.isTTY !== true
   ? parseScriptedAnswers(readFileSync(0, "utf8"))
   : undefined;
 const previousClients = readPersistedClientSelection();
+const persistedDshSelection = readPersistedDshSelection();
+let dshProfiles = [];
+let dshProfilesVerified = true;
+try {
+  dshProfiles = discoverDshProfiles();
+} catch (error) {
+  dshProfilesVerified = false;
+  const code = typeof error?.code === "string" ? ` (${error.code})` : "";
+  logRed(`DeepSeek Harness Profile discovery could not be verified${code}; DSH setup was skipped, but other client setup will continue.`);
+}
+const dshSelected = dshProfilesVerified
+  && dshProfiles.length > 0
+  && persistedDshSelection !== false;
 if (seedMissingMemoraxCodeConfig() === "failed") {
   printPostinstallSummary("not-verified");
   process.exit(0);
@@ -70,22 +88,46 @@ try {
   process.exit(0);
 }
 runCommonPreflight();
-const requestedClients = previousClients ?? ["codex", "claude"];
+const requestedClients = ["codex", "claude", "opencode"];
 const codexPreflight = requestedClients.includes("codex") && !skipCodexPluginInstall
-  ? runCodexPreflight()
+  ? runCodexPreflight({
+      integrationSelected: !updatePostinstall
+        || previousClients === undefined
+        || previousClients.includes("codex"),
+    })
   : { ok: true, pluginCache: { marketplaceName: CLI_MARKETPLACE_NAME, versions: [] } };
 const claudePreflight = requestedClients.includes("claude") && !skipClaudeAdapterInstall
-  ? runClaudePreflight()
+  ? runClaudePreflight({
+      integrationSelected: !updatePostinstall
+        || previousClients === undefined
+        || previousClients.includes("claude"),
+    })
+  : { ok: true };
+const opencodePreflight = requestedClients.includes("opencode") && !skipOpenCodeAdapterInstall
+  ? runOpenCodePreflight({
+      integrationSelected: !updatePostinstall
+        || previousClients === undefined
+        || previousClients.includes("opencode"),
+    })
   : { ok: true };
-const installClients = requestedClients.filter((client) => {
+const detectedClients = requestedClients.filter((client) => {
   if (client === "codex") return !skipCodexPluginInstall && codexPreflight.ok;
-  return !skipClaudeAdapterInstall && claudePreflight.ok;
+  if (client === "claude") return !skipClaudeAdapterInstall && claudePreflight.ok;
+  return !skipOpenCodeAdapterInstall && opencodePreflight.ok;
 });
-const selectedClients = previousClients ?? installClients;
-if (previousClients) {
-  log(clientSelectionMessage(previousClients));
+const selectedClients = updatePostinstall && previousClients !== undefined
+  ? await chooseUpdateClients(previousClients, detectedClients, scriptedAnswers)
+  : detectedClients;
+const installClients = detectedClients.filter((client) => selectedClients.includes(client));
+if (updatePostinstall && previousClients !== undefined) {
+  log(clientSelectionMessage(selectedClients, { dshSelected }));
 } else {
-  log(detectedClientMessage(installClients));
+  log(detectedClientMessage(installClients, dshSelected ? dshProfiles : []));
+}
+if (dshSelected) {
+  log(`DeepSeek Harness profiles: found (${dshProfiles.map((profile) => profile.name).join(", ")}); supported profiles will be reconciled by \`memorax-code start\`.`);
+} else if (dshProfiles.length > 0) {
+  log("DeepSeek Harness profiles were detected, but the DSH integration is disabled by [clients].dsh.");
 }
 if (requestedClients.includes("codex") && !skipCodexPluginInstall && !codexPreflight.ok) {
   log("Codex runtime was not detected; skipping its adapter setup.");
@@ -93,13 +135,18 @@ if (requestedClients.includes("codex") && !skipCodexPluginInstall && !codexPrefl
 if (requestedClients.includes("claude") && !skipClaudeAdapterInstall && !claudePreflight.ok) {
   log("Claude Code runtime was not detected; skipping its adapter setup.");
 }
+if (requestedClients.includes("opencode") && !skipOpenCodeAdapterInstall && !opencodePreflight.ok) {
+  log("OpenCode runtime or configuration was not detected; skipping its adapter setup.");
+}
 if (writeClientSelectionConfig(selectedClients) === "failed") {
   printPostinstallSummary("not-verified");
   process.exit(0);
 }
-const clientMode = clientModeFor(installClients);
+const clientMode = clientModeFor(installClients, {
+  includeDsh: dshProfilesVerified && persistedDshSelection !== false,
+});
 let memoraxConfigResult = "skipped";
-if (installClients.length > 0) {
+if (installClients.length > 0 || dshSelected) {
   memoraxConfigResult = await maybeConfigureMemoraxMemory(scriptedAnswers);
 }
 if (memoraxConfigResult === "configured") {
@@ -110,7 +157,12 @@ if (memoraxConfigResult === "configured") {
 }
 const codexClientEnabled = installClients.includes("codex");
 const claudeClientEnabled = installClients.includes("claude");
-const codexHooksBeforeUpdate = codexClientEnabled && updatePostinstall
+const opencodeClientEnabled = installClients.includes("opencode");
+const codexClientNewlyEnabled = codexClientEnabled
+  && updatePostinstall
+  && previousClients !== undefined
+  && !previousClients.includes("codex");
+const codexHooksBeforeUpdate = codexClientEnabled && updatePostinstall && !codexClientNewlyEnabled
   ? inspectCodexPluginHooksForUpdate()
   : undefined;
 const result = codexClientEnabled
@@ -122,11 +174,17 @@ if (codexClientEnabled && result.status !== 0 && process.env.npm_lifecycle_event
 }
 
 if (codexClientEnabled && result.status === 0) {
-  if (updatePostinstall) await maybeTrustUpdatedCodexPluginHooks(scriptedAnswers, codexHooksBeforeUpdate);
-  else await maybeActivateCodexPluginHooks(scriptedAnswers);
+  if (codexClientNewlyEnabled) {
+    await maybeActivateCodexPluginHooks(scriptedAnswers, { updatePrompt: true });
+  } else if (updatePostinstall) {
+    await maybeTrustUpdatedCodexPluginHooks(scriptedAnswers, codexHooksBeforeUpdate);
+  } else {
+    await maybeActivateCodexPluginHooks(scriptedAnswers);
+  }
 }
 const skipCodexAdapter = !codexClientEnabled;
 const skipClaudeAdapter = !claudeClientEnabled;
+const skipOpenCodeAdapter = !opencodeClientEnabled;
 const codexSkipReason = postinstallClientSkipReason({
   explicitlySkipped: skipCodexPluginInstall,
   selected: selectedClients.includes("codex"),
@@ -137,21 +195,39 @@ const claudeSkipReason = postinstallClientSkipReason({
   selected: selectedClients.includes("claude"),
   enabled: claudeClientEnabled,
 });
+const opencodeSkipReason = postinstallClientSkipReason({
+  explicitlySkipped: skipOpenCodeAdapterInstall,
+  selected: selectedClients.includes("opencode"),
+  enabled: opencodeClientEnabled,
+});
 
-let backendAndAdaptersStatus = startBackendAndCheck({
+const backendAndAdapters = startBackendAndCheck({
   skipCodexAdapter,
   clientMode,
   codexSkipReason,
   skipClaudeAdapter,
   claudeAdapterRequired: !skipClaudeAdapter,
   claudeSkipReason,
+  skipOpenCodeAdapter,
+  opencodeAdapterRequired: !skipOpenCodeAdapter,
+  opencodeSkipReason,
 });
+const backendAndAdaptersStatus = backendAndAdapters.status;
 if (backendAndAdaptersStatus === "enabled") {
   logGreen(`Client Hook runtime ${stagedHookRuntime.generationId} activated.`);
 }
 if (backendAndAdaptersStatus === "enabled") {
-  printNextSteps({ codexAdapterEnabled: !skipCodexAdapter, claudeAdapterEnabled: !skipClaudeAdapter });
-  printCommonCommands({ codexAdapterEnabled: !skipCodexAdapter, claudeAdapterEnabled: !skipClaudeAdapter });
+  printNextSteps({
+    codexAdapterEnabled: !skipCodexAdapter,
+    claudeAdapterEnabled: !skipClaudeAdapter,
+    dshAdapterEnabled: backendAndAdapters.dshAdapterEnabled,
+    opencodeAdapterEnabled: !skipOpenCodeAdapter,
+  });
+  printCommonCommands({
+    codexAdapterEnabled: !skipCodexAdapter,
+    claudeAdapterEnabled: !skipClaudeAdapter,
+    opencodeAdapterEnabled: !skipOpenCodeAdapter,
+  });
 }
 printPostinstallSummary(backendAndAdaptersStatus);
 if (backendAndAdaptersStatus === "enabled") {
@@ -163,26 +239,31 @@ process.exit(0);
 
 async function maybeConfigureMemoraxMemory(scriptedAnswers) {
   printMemoraxDisclosure();
-  if (!canPrompt()) {
+  const promptAvailable = canPrompt();
+  if (promptAvailable && readMemoraxInstallStatus()?.configured) {
+    log("Existing MemoraX credentials detected; keeping the effective configuration unchanged.");
+    return "preserved";
+  }
+  if (!promptAvailable) {
     log(`This install cannot prompt for a MemoraX ID and key. Register at ${MEMORAX_ACCOUNT_URL}, then edit \`~/.memorax-code/config.toml\` or rerun interactively with \`--foreground-scripts\`.`);
     return "skipped";
   }
   if (scriptedAnswers) {
     return await configureMemoraxMemoryFromAnswers(scriptedAnswers);
   }
+  printMemoraxRegistrationLink();
+  printMemoraxUserIdGuidance();
   let rl = createInterface({ input: process.stdin, output: process.stderr });
   try {
-    const configureNow = await rl.question(`${PREFIX} Connect MemoraX Code to MemoraX now? [Y/n] `);
-    if (/^n(?:o)?$/i.test(configureNow.trim())) {
-      log("MemoraX connection skipped. MemoraX Code memory is not fully configured until valid credentials are supplied.");
-      return "skipped";
-    }
-    log(`If you do not have a MemoraX account/API key, register at ${MEMORAX_ACCOUNT_URL}.`);
-    const userId = (await rl.question(`${PREFIX} MemoraX base user ID: `)).trim();
+    const userId = await questionRequiredLine(
+      rl,
+      `${PREFIX} Your MemoraX user ID (required, e.g. your-name): `,
+      "MemoraX user ID is required.",
+    );
     const outputLanguage = await questionPreferredLanguage(rl);
     rl.close();
     rl = undefined;
-    const apiKey = (await questionMasked(`${PREFIX} MemoraX API key: `)).trim();
+    const apiKey = await questionRequiredMasked(`${PREFIX} MemoraX API key (required): `);
     return await writeMemoraxConfigFromInput({
       userId,
       apiKey,
@@ -194,29 +275,67 @@ async function maybeConfigureMemoraxMemory(scriptedAnswers) {
   }
 }
 
-async function configureMemoraxMemoryFromAnswers(answers) {
-  if (answers.length === 0) {
-    log(`No MemoraX connection response was received. Register at ${MEMORAX_ACCOUNT_URL}, then edit \`~/.memorax-code/config.toml\` or rerun interactively with \`--foreground-scripts\`.`);
-    return "skipped";
+async function chooseUpdateClients(previousClients, detectedClients, scriptedAnswers) {
+  const selected = new Set(previousClients);
+  const availableDisabledClients = detectedClients.filter((client) => !selected.has(client));
+  if (availableDisabledClients.length === 0) return [...previousClients];
+
+  if (!canPromptForUpdate()) {
+    for (const client of availableDisabledClients) {
+      const label = clientLabel(client);
+      log(`${label} runtime is available, but its integration remains disabled because this update cannot prompt. Rerun \`memorax-code update\` from an interactive terminal to choose whether to enable it.`);
+    }
+    return [...previousClients];
   }
-  log("Connect MemoraX Code to MemoraX now? [Y/n]");
-  const configureNow = String(answers.shift() ?? "").trim();
-  if (/^n(?:o)?$/i.test(configureNow)) {
-    log("MemoraX connection skipped. MemoraX Code memory is not fully configured until valid credentials are supplied.");
-    return "skipped";
+
+  let rl;
+  try {
+    for (const client of availableDisabledClients) {
+      const label = clientLabel(client);
+      const question = `${label} runtime is available, but its integration is disabled in [clients]. Enable it now? [Y/n]`;
+      let answer;
+      if (scriptedAnswers) {
+        log(question);
+        answer = String(scriptedAnswers.shift() ?? "").trim();
+      } else {
+        rl ??= createInterface({ input: process.stdin, output: process.stderr });
+        answer = (await rl.question(`${PREFIX} ${question} `)).trim();
+      }
+      if (/^n(?:o)?$/i.test(answer)) {
+        log(`Keeping the ${label} integration disabled.`);
+      } else {
+        selected.add(client);
+        logGreen(`Enabling the ${label} integration.`);
+      }
+    }
+  } finally {
+    rl?.close();
   }
-  log(`If you do not have a MemoraX account/API key, register at ${MEMORAX_ACCOUNT_URL}.`);
-  log("MemoraX base user ID: <provided>");
-  const userId = String(answers.shift() ?? "").trim();
-  const outputLanguageAnswer = String(answers.shift() ?? "").trim();
-  log(`Preferred language [ZH/en] (used for Memory extraction): ${outputLanguageAnswer ? "<provided>" : "<default>"}`);
-  log("MemoraX API key: <provided>");
-  const apiKey = String(answers.shift() ?? "").trim();
+  return ["codex", "claude", "opencode"].filter((client) => selected.has(client));
+}
+
+async function configureMemoraxMemoryFromAnswers(answers) {
+  printMemoraxRegistrationLink();
+  printMemoraxUserIdGuidance();
+  const userId = requiredScriptedAnswer(answers, {
+    prompt: "Your MemoraX user ID (required, e.g. your-name)",
+    requiredMessage: "MemoraX user ID is required.",
+    missingMessage: "No MemoraX user ID response was received; MemoraX configuration is incomplete.",
+  });
+  if (!userId) return "skipped";
+  const outputLanguage = scriptedPreferredLanguage(answers);
+  if (!outputLanguage) return "skipped";
+  const apiKey = requiredScriptedAnswer(answers, {
+    prompt: "MemoraX API key (required)",
+    requiredMessage: "MemoraX API key is required.",
+    missingMessage: "No MemoraX API key response was received; MemoraX configuration is incomplete.",
+  });
+  if (!apiKey) return "skipped";
   return await writeMemoraxConfigFromInput({
     userId,
     apiKey,
     endpoint: memoraxInstallEndpoint(),
-    outputLanguage: preferredLanguage(outputLanguageAnswer),
+    outputLanguage,
   });
 }
 
@@ -226,9 +345,19 @@ function printMemoraxDisclosure() {
   log("Newly generated configuration enables automatic writeback. Existing configuration is never enabled implicitly; disable it with `[memory.writeback] enabled = false` or `MEMORAX_CODE_MEMORAX_WRITEBACK_ENABLED=false`.");
 }
 
+function printMemoraxUserIdGuidance() {
+  log("MemoraX uses one user ID to keep your coding memories consistent across supported agents and devices.");
+  log("Choose a stable ID and use the same value everywhere; MemoraX Code separates repositories automatically.");
+}
+
+function printMemoraxRegistrationLink() {
+  log("No MemoraX account or API key yet?");
+  log(`→ Register here: ${BRIGHT_CYAN}${BOLD}${UNDERLINE}${MEMORAX_ACCOUNT_URL}${RESET}`);
+}
+
 async function writeMemoraxConfigFromInput({ userId, apiKey, endpoint, outputLanguage }) {
   if (!userId || !apiKey) {
-    logRed("MemoraX config was not written because base user ID or API key was empty.");
+    logRed("MemoraX config was not written because MemoraX user ID or API key was empty.");
     return "skipped";
   }
   if (!outputLanguage) {
@@ -244,6 +373,45 @@ async function writeMemoraxConfigFromInput({ userId, apiKey, endpoint, outputLan
   return "configured";
 }
 
+async function questionRequiredLine(rl, prompt, requiredMessage) {
+  while (true) {
+    const answer = (await rl.question(prompt)).trim();
+    if (answer) return answer;
+    logRed(requiredMessage);
+  }
+}
+
+async function questionRequiredMasked(prompt) {
+  while (true) {
+    const answer = (await questionMasked(prompt)).trim();
+    if (answer) return answer;
+    logRed("MemoraX API key is required.");
+  }
+}
+
+function requiredScriptedAnswer(answers, { prompt, requiredMessage, missingMessage }) {
+  while (answers.length > 0) {
+    const answer = String(answers.shift() ?? "").trim();
+    log(`${prompt}: ${answer ? "<provided>" : "<empty>"}`);
+    if (answer) return answer;
+    logRed(requiredMessage);
+  }
+  logRed(missingMessage);
+  return undefined;
+}
+
+function scriptedPreferredLanguage(answers) {
+  while (answers.length > 0) {
+    const answer = String(answers.shift() ?? "").trim();
+    log(`Preferred language [ZH/en] (used for Memory extraction): ${answer ? "<provided>" : "<default>"}`);
+    const language = preferredLanguage(answer);
+    if (language) return language;
+    logRed("Preferred language must be zh or en.");
+  }
+  logRed("No preferred language response was received; MemoraX configuration is incomplete.");
+  return undefined;
+}
+
 async function questionPreferredLanguage(rl) {
   while (true) {
     const answer = await rl.question(`${PREFIX} Preferred language [ZH/en] (used for Memory extraction): `);
@@ -350,7 +518,7 @@ async function maybeTrustUpdatedCodexPluginHooks(scriptedAnswers, previousHooks)
   if (report.hooks.length === 0) return "unchanged";
 
   printUpdatedCodexHooks(report.hooks, previousHooks);
-  if (!canPromptForHookUpdate()) {
+  if (!canPromptForUpdate()) {
     warnUpdatedHookTrustSkipped("This update is running without an interactive terminal, so the new or changed Hooks remain untrusted.");
     return "skipped";
   }
@@ -470,8 +638,8 @@ function warnUpdatedHookTrustSkipped(message) {
   logRed("Review and authorize the current MemoraX Code Codex Hooks with `memorax-code codex-plugin trust-hooks`.");
 }
 
-async function maybeActivateCodexPluginHooks(scriptedAnswers) {
-  if (!canPrompt()) {
+async function maybeActivateCodexPluginHooks(scriptedAnswers, { updatePrompt = false } = {}) {
+  if (!(updatePrompt ? canPromptForUpdate() : canPrompt())) {
     log("Codex hook activation was not prompted. Run `memorax-code codex-plugin activate --yes` later to activate and trust MemoraX Code Codex Adapter hooks.");
     return "skipped";
   }
@@ -512,7 +680,7 @@ function canPrompt() {
   return canPromptOnStderr();
 }
 
-function canPromptForHookUpdate() {
+function canPromptForUpdate() {
   return updatePostinstall && canPromptOnStderr();
 }
 
@@ -543,7 +711,22 @@ function readPersistedClientSelection() {
   try {
     const clients = parse(readFileSync(path, "utf8"))?.clients;
     if (!clients || typeof clients !== "object" || typeof clients.codex !== "boolean" || typeof clients.claude !== "boolean") return undefined;
-    return [clients.codex ? "codex" : undefined, clients.claude ? "claude" : undefined].filter(Boolean);
+    return [
+      clients.codex ? "codex" : undefined,
+      clients.claude ? "claude" : undefined,
+      clients.opencode === true ? "opencode" : undefined,
+    ].filter(Boolean);
+  } catch {
+    return undefined;
+  }
+}
+
+function readPersistedDshSelection() {
+  const path = memoraxCodeConfigPath();
+  if (!existsSync(path)) return undefined;
+  try {
+    const value = parse(readFileSync(path, "utf8"))?.clients?.dsh;
+    return typeof value === "boolean" ? value : undefined;
   } catch {
     return undefined;
   }
@@ -561,7 +744,8 @@ function writeClientSelectionConfig(clients) {
 }
 
 function setManagedClientSelection(text, clients) {
-  const withClaude = setTomlField(text, "clients", "claude", String(clients.includes("claude")));
+  const withOpenCode = setTomlField(text, "clients", "opencode", String(clients.includes("opencode")));
+  const withClaude = setTomlField(withOpenCode, "clients", "claude", String(clients.includes("claude")));
   return setTomlField(withClaude, "clients", "codex", String(clients.includes("codex")));
 }
 
@@ -609,6 +793,8 @@ function defaultMemoraxCodeConfig() {
     "[clients]",
     "codex = true # Manage the Codex adapter.",
     "claude = true # Manage the Claude adapter.",
+    "dsh = true # Manage the DeepSeek Harness adapter when Profiles exist.",
+    "opencode = true # Manage the OpenCode adapter.",
     "",
     "# MemoraX remote-memory connection. Credentials may also come from the environment.",
     "[memorax]",
@@ -628,7 +814,7 @@ function defaultMemoraxCodeConfig() {
     "[memory.add]",
     `output_language = "${MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE}" # Language for newly generated MemoraX memories.`,
     "",
-    "# Controls how often Codex and Claude Code native client sessions see the MemoraX Code skill reminder.",
+    "# Controls how often supported native client sessions see the MemoraX Code skill reminder.",
     "[memory.skill_reminder]",
     "interval_turns = 5 # Show the MemoraX Code skill reminder every N native client turns, starting on the first turn.",
     "",
@@ -647,6 +833,14 @@ function defaultMemoraxCodeConfig() {
     "enabled = true # Enable local Claude session memory trace collection.",
     "capture_content = true # Store content in local Claude trace events.",
     "",
+    "[trace.dsh]",
+    "enabled = true # Enable local DSH session memory trace collection.",
+    "capture_content = true # Store content in local DSH trace events.",
+    "",
+    "[trace.opencode]",
+    "enabled = true # Enable local OpenCode session memory trace collection.",
+    "capture_content = true # Store content in local OpenCode trace events.",
+    "",
   ].join("\n");
 }
 
@@ -705,20 +899,23 @@ function tomlString(value) {
 function runCommonPreflight() {
   log("Checking local install state...");
   if (updatePostinstall) {
-    log("Package update detected; refreshing MemoraX Code assets without interactive setup prompts.");
+    log("Package update detected; refreshing MemoraX Code assets and checking client availability.");
   }
   const memoraxCodeVersion = runNodeMemoraxCodeCommand(["--version"], { print: false });
   log(`MemoraX Code backend package: ${commandSummary(memoraxCodeVersion) ?? packageVersionSummary()}`);
   if (skipCodexPluginInstall) {
-    log("Codex plugin registration is disabled for this npm postinstall; backend and Claude Code setup can still continue.");
+    log("Codex plugin registration is disabled for this npm postinstall; other client setup can still continue.");
   }
   if (skipClaudeAdapterInstall) {
-    log("Claude Code adapter setup is disabled for this npm postinstall; backend and Codex setup can still continue.");
+    log("Claude Code adapter setup is disabled for this npm postinstall; other client setup can still continue.");
+  }
+  if (skipOpenCodeAdapterInstall) {
+    log("OpenCode adapter setup is disabled for this npm postinstall; other client setup can still continue.");
   }
   return {};
 }
 
-function runCodexPreflight() {
+function runCodexPreflight({ integrationSelected = true } = {}) {
   const version = runExternalCommand(codexCommand, ["--version"], { print: false, timeout: 10_000 });
   const runtimeLabel = codexRuntime.source === "app-bundled"
     ? "Codex App runtime"
@@ -732,16 +929,45 @@ function runCodexPreflight() {
   const pluginCache = installedPluginCache();
   log(`Existing Codex plugin cache: ${pluginCache.versions.length > 0 ? `found (${pluginCache.versions.join(", ")})` : "not installed"}`);
   log(`Codex client process: ${codexClientRunning() ? "running" : "not detected"}`);
-  log("Keeping Codex provider config unchanged and enabling the shared memory hook integration.");
+  log(integrationSelected
+    ? "Keeping Codex provider config unchanged and enabling the shared memory hook integration."
+    : "Keeping Codex provider config unchanged while checking whether to enable its integration.");
   return { ok: true, pluginCache };
 }
 
-function runClaudePreflight() {
+function runClaudePreflight({ integrationSelected = true } = {}) {
   const version = runExternalCommand(claudeCommand, ["--version"], { print: false, timeout: 10_000 });
-  const runtimeLabel = claudeRuntime.source === "vscode-bundled" ? "Claude VS Code runtime" : "Claude CLI";
+  const runtimeLabel = claudeRuntime.source === "app-bundled"
+    ? "Claude Code App runtime"
+    : claudeRuntime.source === "vscode-bundled"
+      ? "Claude VS Code runtime"
+      : "Claude CLI";
   log(`${runtimeLabel}: ${commandSummary(version) ?? "not runnable"}`);
   if (version.status !== 0) return { ok: false };
-  log("Keeping Claude Code provider config unchanged and enabling the shared memory Hook integration.");
+  log(integrationSelected
+    ? "Keeping Claude Code provider config unchanged and enabling the shared memory Hook integration."
+    : "Keeping Claude Code provider config unchanged while checking whether to enable its integration.");
+  return { ok: true };
+}
+
+function runOpenCodePreflight({ integrationSelected = true } = {}) {
+  const explicitConfigDir = stringOption(process.env.OPENCODE_CONFIG_DIR);
+  const configHome = stringOption(process.env.XDG_CONFIG_HOME) ?? join(homedir(), ".config");
+  const configDir = resolve(explicitConfigDir ?? join(configHome, "opencode"));
+  const configDetected = explicitConfigDir !== undefined || existsSync(configDir);
+  const cliDetected = commandOnPath(
+    "opencode",
+    process.env.PATH,
+    process.platform,
+    process.env.PATHEXT,
+  );
+  const detected = configDetected || cliDetected;
+  log(`OpenCode configuration: ${configDetected ? `found (${configDir})` : "not detected"}`);
+  log(`OpenCode CLI: ${cliDetected ? "found in PATH" : "not detected"}`);
+  if (!detected) return { ok: false };
+  log(integrationSelected
+    ? "Keeping OpenCode provider config unchanged and enabling the shared memory plugin integration."
+    : "Keeping OpenCode provider config unchanged while checking whether to enable its integration.");
   return { ok: true };
 }
 
@@ -768,7 +994,17 @@ function installedPluginCacheVersions(marketplaceName) {
   }
 }
 
-function startBackendAndCheck({ skipCodexAdapter = false, clientMode = "all", codexSkipReason, skipClaudeAdapter = false, claudeAdapterRequired = !skipClaudeAdapter, claudeSkipReason } = {}) {
+function startBackendAndCheck({
+  skipCodexAdapter = false,
+  clientMode = "all",
+  codexSkipReason,
+  skipClaudeAdapter = false,
+  claudeAdapterRequired = !skipClaudeAdapter,
+  claudeSkipReason,
+  skipOpenCodeAdapter = false,
+  opencodeAdapterRequired = !skipOpenCodeAdapter,
+  opencodeSkipReason,
+} = {}) {
   logGreen("Starting backend with `memorax-code start`...");
   const adapterFlags = clientLifecycleFlags({ clientMode });
   const startArgs = ["start", ...adapterFlags];
@@ -780,18 +1016,18 @@ function startBackendAndCheck({ skipCodexAdapter = false, clientMode = "all", co
     if (clientHookRuntimeActivationFailed(started)) {
       logRed("Client Hook runtime activation failed; automatic lifecycle recovery was skipped.");
       logRed("The previously active runtime remains authoritative.");
-      return "not-verified";
+      return { status: "not-verified", dshAdapterEnabled: false };
     }
     if (lifecycleLockFailureCode(started)) {
       logRed("Automatic stop/start recovery is skipped because another MemoraX Code lifecycle command still owns the Backend authority.");
       printLifecycleLockFailureSuggestions();
-      return "not-verified";
+      return { status: "not-verified", dshAdapterEnabled: false };
     }
     const runtimeAuthorityFailure = runtimeAuthorityFailureCode(started);
     if (runtimeAuthorityFailure) {
       logRed("Automatic stop/start recovery is skipped because persisted Backend runtime authority requires explicit repair.");
       printRuntimeAuthorityFailureSuggestions(runtimeAuthorityFailure);
-      return "not-verified";
+      return { status: "not-verified", dshAdapterEnabled: false };
     }
     logRed("Attempting automatic recovery: `memorax-code stop` then `memorax-code start`...");
     runMemoraxCodeCommand(["stop", ...adapterFlags]);
@@ -802,7 +1038,7 @@ function startBackendAndCheck({ skipCodexAdapter = false, clientMode = "all", co
       logRed("Diagnostic: running `memorax-code status` so the failure is visible.");
       runMemoraxCodeCommand(statusArgs);
       printFailureSuggestions();
-      return "not-verified";
+      return { status: "not-verified", dshAdapterEnabled: false };
     }
   }
   logGreen(recovered ? "Backend start completed after automatic recovery." : "Backend start completed.");
@@ -811,19 +1047,27 @@ function startBackendAndCheck({ skipCodexAdapter = false, clientMode = "all", co
   if (checked.status !== 0) {
     logRed("Backend status check failed during npm postinstall.");
     printFailureSuggestions();
-    return "not-verified";
+    return { status: "not-verified", dshAdapterEnabled: false };
   }
   logGreen("Backend status check completed.");
   const enabled = memoraxCodeEnabled(checked, {
     codexAdapterRequired: !skipCodexAdapter,
     claudeAdapterRequired,
+    opencodeAdapterRequired,
   });
   if (!enabled) {
-    if (skipCodexAdapter || skipClaudeAdapter) printSkippedAdapterDiagnostics({ codexSkipReason, claudeSkipReason });
-    else printUnavailableDiagnostics();
-    return "unavailable";
+    printUnavailableDiagnostics({ codexSkipReason, claudeSkipReason, opencodeSkipReason });
+    return { status: "unavailable", dshAdapterEnabled: false };
   }
-  return "enabled";
+  return {
+    status: "enabled",
+    dshAdapterEnabled: dshAdapterReady(checked),
+  };
+}
+
+function dshAdapterReady(statusResult) {
+  const output = `${statusResult.stdout ?? ""}\n${statusResult.stderr ?? ""}`;
+  return /\bDSH adapter:\s*ok\b[^\r\n]*\bintegration=plugin\b/im.test(stripAnsi(output));
 }
 
 function pendingClientHookRuntimeEnv() {
@@ -862,13 +1106,12 @@ function clientLifecycleFlags({ clientMode = "all" } = {}) {
   return ["--clients", clientMode];
 }
 
-function clientModeFor(clients) {
-  const hasCodex = clients.includes("codex");
-  const hasClaude = clients.includes("claude");
-  if (hasCodex && hasClaude) return "all";
-  if (hasCodex) return "codex";
-  if (hasClaude) return "claude";
-  return "none";
+function clientModeFor(clients, { includeDsh = false } = {}) {
+  const selected = ["codex", "claude", "dsh", "opencode"].filter((client) => (
+    client === "dsh" ? includeDsh : clients.includes(client)
+  ));
+  if (selected.length === 4) return "all";
+  return selected.length > 0 ? selected.join(",") : "none";
 }
 
 function postinstallClientSkipReason({ explicitlySkipped, selected, enabled }) {
@@ -877,22 +1120,51 @@ function postinstallClientSkipReason({ explicitlySkipped, selected, enabled }) {
   return enabled ? undefined : "client-selection";
 }
 
-function clientSelectionMessage(clients) {
+function clientSelectionMessage(clients, { dshSelected = false } = {}) {
+  if (dshSelected) {
+    const labels = [
+      clients.includes("codex") ? "Codex" : undefined,
+      clients.includes("claude") ? "Claude Code" : undefined,
+      "DeepSeek Harness",
+      clients.includes("opencode") ? "OpenCode" : undefined,
+    ].filter(Boolean);
+    return `Configuring MemoraX Code for ${joinedLabels(labels)}.`;
+  }
   const hasCodex = clients.includes("codex");
   const hasClaude = clients.includes("claude");
+  const hasOpenCode = clients.includes("opencode");
+  if (hasCodex && hasClaude && hasOpenCode) return "Configuring MemoraX Code for Codex, Claude Code, and OpenCode.";
   if (hasCodex && hasClaude) return "Configuring MemoraX Code for Codex and Claude Code.";
+  if (hasCodex && hasOpenCode) return "Configuring MemoraX Code for Codex and OpenCode.";
+  if (hasClaude && hasOpenCode) return "Configuring MemoraX Code for Claude Code and OpenCode.";
   if (hasCodex) return "Configuring MemoraX Code for Codex only.";
   if (hasClaude) return "Configuring MemoraX Code for Claude Code only.";
+  if (hasOpenCode) return "Configuring MemoraX Code for OpenCode only.";
   return "Skipping client adapter setup for this npm postinstall.";
 }
 
-function detectedClientMessage(clients) {
-  if (clients.length === 0) {
+function clientLabel(client) {
+  if (client === "codex") return "Codex";
+  if (client === "claude") return "Claude Code";
+  return "OpenCode";
+}
+
+function detectedClientMessage(clients, dshProfiles = []) {
+  if (clients.length === 0 && dshProfiles.length === 0) {
     return "No supported client runtime was detected; starting the shared Backend without client adapters.";
   }
+  if (clients.length === 0) {
+    return "Detected existing DeepSeek Harness profiles; configuring the native DSH plugin and shared Backend.";
+  }
   return `Detected supported client runtimes. ${clientSelectionMessage(clients)}`;
 }
 
+function joinedLabels(labels) {
+  if (labels.length < 2) return labels[0] ?? "";
+  if (labels.length === 2) return `${labels[0]} and ${labels[1]}`;
+  return `${labels.slice(0, -1).join(", ")}, and ${labels.at(-1)}`;
+}
+
 function codexHome() {
   return process.env.CODEX_HOME || join(homedir(), ".codex");
 }
@@ -1020,35 +1292,65 @@ function codexClientRunning() {
   });
 }
 
-function printNextSteps({ codexAdapterEnabled = true, claudeAdapterEnabled = true } = {}) {
-  const clientText = enabledClientText({ codexAdapterEnabled, claudeAdapterEnabled });
-  if (clientText && updatePostinstall) {
+function printNextSteps({
+  codexAdapterEnabled = true,
+  claudeAdapterEnabled = true,
+  dshAdapterEnabled = false,
+  opencodeAdapterEnabled = true,
+} = {}) {
+  const hookClientText = enabledClientText({
+    codexAdapterEnabled,
+    claudeAdapterEnabled,
+    opencodeAdapterEnabled,
+  });
+  if (hookClientText && updatePostinstall) {
     logGreen(`${bold("The new Hook runtime is active")}; existing sessions with the stable shell select it on their next user prompt.`);
-    log(`Restart or refresh ${clientText} only if its plugin shell was installed, changed, or newly enabled, or if MemoraX Code is not active on the next prompt.`);
-  } else if (clientText) {
-    logGreen(`${bold(`Restart or refresh ${clientText}`)} before opening a new MemoraX Code session.`);
-  } else {
+    log(`Restart or refresh ${hookClientText} only if its plugin shell was installed, changed, or newly enabled, or if MemoraX Code is not active on the next prompt.`);
+  } else if (hookClientText) {
+    logGreen(`${bold(`Restart or refresh ${hookClientText}`)} before opening a new MemoraX Code session.`);
+  }
+  if (dshAdapterEnabled) {
+    logGreen(`${bold("Restart or refresh DeepSeek Harness")} so its Profiles load the installed MemoraX Code plugin.`);
+  } else if (!hookClientText) {
     logGreen(`${bold("MemoraX Code backend is running")}; client adapters were skipped for this install.`);
   }
   if (codexAdapterEnabled && !updatePostinstall) {
     logGreen(`After restart, ${bold("enable the MemoraX Code Codex Adapter plugin")} from Codex Plugins or CLI \`/plugins\` if it is not already enabled.`);
   }
-  const statusCommands = statusCommandText({ codexAdapterEnabled, claudeAdapterEnabled });
-  log(`If MemoraX Code is not active ${updatePostinstall ? "on the next prompt" : "in new sessions"}, run ${statusCommands}.`);
+  const statusCommands = statusCommandText({ codexAdapterEnabled, claudeAdapterEnabled, opencodeAdapterEnabled });
+  if (hookClientText || !dshAdapterEnabled) {
+    log(`If MemoraX Code is not active ${updatePostinstall ? "on the next prompt" : "in new sessions"}, run ${statusCommands}.`);
+  }
+  if (dshAdapterEnabled) {
+    log("If MemoraX Code is not active after restarting or refreshing DeepSeek Harness, run `memorax-code status`.");
+  }
   log("If npm hides install details, reinstall with `--foreground-scripts`.");
 }
 
-function enabledClientText({ codexAdapterEnabled = true, claudeAdapterEnabled = true } = {}) {
-  if (codexAdapterEnabled && claudeAdapterEnabled) return "Codex or Claude Code";
-  if (codexAdapterEnabled) return "Codex";
-  if (claudeAdapterEnabled) return "Claude Code";
-  return "";
-}
-
-function statusCommandText({ codexAdapterEnabled = true, claudeAdapterEnabled = true } = {}) {
+function enabledClientText({
+  codexAdapterEnabled = true,
+  claudeAdapterEnabled = true,
+  opencodeAdapterEnabled = true,
+} = {}) {
+  const labels = [
+    codexAdapterEnabled ? "Codex" : undefined,
+    claudeAdapterEnabled ? "Claude Code" : undefined,
+    opencodeAdapterEnabled ? "OpenCode" : undefined,
+  ].filter(Boolean);
+  if (labels.length < 2) return labels[0] ?? "";
+  if (labels.length === 2) return `${labels[0]} or ${labels[1]}`;
+  return `${labels.slice(0, -1).join(", ")}, or ${labels.at(-1)}`;
+}
+
+function statusCommandText({
+  codexAdapterEnabled = true,
+  claudeAdapterEnabled = true,
+  opencodeAdapterEnabled = true,
+} = {}) {
   const commands = ["`memorax-code status`"];
   if (codexAdapterEnabled) commands.push("`memorax-code-codex status`");
   if (claudeAdapterEnabled) commands.push("`memorax-code-claude status`");
+  if (opencodeAdapterEnabled) commands.push("`memorax-code-opencode status`");
   if (commands.length === 1) return commands[0];
   if (commands.length === 2) return `${commands[0]} and ${commands[1]}`;
   return `${commands.slice(0, -1).join(", ")}, and ${commands.at(-1)}`;
@@ -1128,19 +1430,17 @@ function readMemoraxInstallStatus() {
   }
 }
 
-function printUnavailableDiagnostics() {
+function printUnavailableDiagnostics({ codexSkipReason, claudeSkipReason, opencodeSkipReason } = {}) {
   logRed("MemoraX Code is not enabled for new client sessions.");
-  logRed("Check `memorax-code status`, `memorax-code-codex status`, and `memorax-code-claude status` for Backend and adapter details.");
-  logRed("If Codex or Claude Code is open, restart or refresh it after fixing the reported status.");
-  printCommonCommands();
-}
-
-function printSkippedAdapterDiagnostics({ codexSkipReason, claudeSkipReason } = {}) {
+  logRed("Check `memorax-code status`, `memorax-code-codex status`, `memorax-code-claude status`, and `memorax-code-opencode status` for Backend and adapter details.");
+  logRed("If Codex, Claude Code, or OpenCode is open, restart or refresh it after fixing the reported status.");
   if (codexSkipReason) printCodexSkippedDiagnostics(codexSkipReason);
   if (claudeSkipReason) printClaudeSkippedDiagnostics(claudeSkipReason);
+  if (opencodeSkipReason) printOpenCodeSkippedDiagnostics(opencodeSkipReason);
   printCommonCommands({
     codexAdapterEnabled: !codexSkipReason,
     claudeAdapterEnabled: !claudeSkipReason,
+    opencodeAdapterEnabled: !opencodeSkipReason,
   });
 }
 
@@ -1156,10 +1456,15 @@ function printClaudeSkippedDiagnostics() {
   log("Run `memorax-code start` after installing Claude Code, then restart or refresh Claude Code.");
 }
 
+function printOpenCodeSkippedDiagnostics() {
+  logRed("OpenCode adapter setup was skipped for this npm postinstall, so MemoraX Code left the OpenCode integration unchanged.");
+  log("Run `memorax-code start --clients opencode` after installing OpenCode, then restart or refresh OpenCode.");
+}
+
 function printFailureSuggestions() {
   logRed("Suggested recovery: run `memorax-code stop`, then `memorax-code start`, then `memorax-code status`.");
   logRed("If the Backend port is busy, stop the process using 127.0.0.1:8787 and retry `memorax-code start`.");
-  logRed("If client sessions still bypass MemoraX Code, restart or refresh Codex or Claude Code and verify the relevant adapter status.");
+  logRed("If client sessions still bypass MemoraX Code, restart or refresh the affected client and verify the relevant adapter status.");
   printCommonCommands();
 }
 
@@ -1181,7 +1486,11 @@ function printLifecycleLockFailureSuggestions() {
   printCommonCommands();
 }
 
-function printCommonCommands({ codexAdapterEnabled = true, claudeAdapterEnabled = true } = {}) {
+function printCommonCommands({
+  codexAdapterEnabled = true,
+  claudeAdapterEnabled = true,
+  opencodeAdapterEnabled = true,
+} = {}) {
   log("Common commands:");
   log("- `memorax-code status`: check the local backend and adapter state.");
   log("- `memorax-cli status`: check required MemoraX configuration and effective memory switches.");
@@ -1189,9 +1498,14 @@ function printCommonCommands({ codexAdapterEnabled = true, claudeAdapterEnabled
   log("- `memorax-code stop`: stop the local memory backend and disable managed client integrations.");
   if (codexAdapterEnabled) log("- `memorax-code-codex sessions`: verify recent native Codex session registration.");
   if (claudeAdapterEnabled) log("- `memorax-code-claude sessions`: verify recent native Claude Code session registration.");
+  if (opencodeAdapterEnabled) log("- `memorax-code-opencode doctor`: verify the managed OpenCode plugin, runtime evidence, and Backend health.");
 }
 
-function memoraxCodeEnabled(statusResult, { codexAdapterRequired = true, claudeAdapterRequired = true } = {}) {
+function memoraxCodeEnabled(statusResult, {
+  codexAdapterRequired = true,
+  claudeAdapterRequired = true,
+  opencodeAdapterRequired = true,
+} = {}) {
   const output = `${statusResult.stdout ?? ""}\n${statusResult.stderr ?? ""}`;
   const normalized = stripAnsi(output);
   const backendOk = /MemoraX Code Backend status:\s*Enabled\b/im.test(normalized)
@@ -1201,10 +1515,12 @@ function memoraxCodeEnabled(statusResult, { codexAdapterRequired = true, claudeA
     || /Backend:\s*(?:running|ok)\b/im.test(normalized);
   const codexAdapterOk = /Codex adapter:\s*ok\b/im.test(normalized);
   const claudeAdapterOk = /Claude adapter:\s*ok\b/im.test(normalized);
+  const opencodeAdapterOk = /OpenCode adapter:\s*ok\b/im.test(normalized);
   return backendOk
     && serviceOk
     && (!codexAdapterRequired || codexAdapterOk)
-    && (!claudeAdapterRequired || claudeAdapterOk);
+    && (!claudeAdapterRequired || claudeAdapterOk)
+    && (!opencodeAdapterRequired || opencodeAdapterOk);
 }
 
 function log(message) {