digital-brain 1.1.11 → 1.1.15

package/README.md

@@ -84,6 +84,7 @@ node ./bin/digital-brain.js init ./Digital Brain\ Vault
 - Create AI-readable memory files for future prompts.
 - Draft WhatsApp sends by default, send with explicit `--yes`, or configure auto-send mode during init.
 - Run an explicit WhatsApp auto-responder that uses Ollama or a Codex command plus vault memory while the command is running.
+- Choose the WhatsApp auto-reply provider during init: Ollama, Codex app bridge, or Codex CLI.
 - Enforce an AI-disclosure guard after repeated AI-assisted sends.
 
 ## Core Commands
@@ -99,6 +100,7 @@ digital-brain send-whatsapp --to "Name" --message "text"
 digital-brain auto-whatsapp --allow "Name" --model llama3.1
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1
 digital-brain auto-whatsapp --allow-all --provider codex --yes
+digital-brain auto-whatsapp --allow-all --provider codex-app --yes
 ```
 
 `init` remembers your vault globally, so `run` works from anywhere. `run` syncs the live local sources you selected, extracts relationships, and writes interpreted memory in one command.
@@ -126,13 +128,14 @@ digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes --no-process-unread
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1 --yes
 digital-brain auto-whatsapp --allow-all --provider codex --yes
+digital-brain auto-whatsapp --allow-all --provider codex-app --yes
 ```
 
 If you start without `--allow`, `--contact`, or `--allow-all` in an interactive terminal, Digital Brain asks whether to cover all contacts or select contacts from your WhatsApp chat list. With `--allow-all`, it still asks once before the first AI reply to each new chat and stores the decision in `08 Sources/WhatsApp/Outbound/auto-reply-whitelist.json`. Use `--auto-approve-new-chats` only if you intentionally want unattended first sends.
 
 Even with `--allow-all`, likely business, notification, OTP, delivery, bank, and support chats are skipped by default. Use explicit `--allow "Name"` or `--contact "+15551234567"` for trusted personal chats. Pass `--include-businesses` only if you intentionally want those chats included.
 
-The default provider is local Ollama. To use Codex instead:
+The default provider is local Ollama. `--provider codex` uses the Codex CLI. `--provider codex-app` uses a file bridge for the Codex desktop app.
 
 ```bash
 digital-brain auto-whatsapp --allow-all --provider codex --yes
@@ -140,6 +143,16 @@ digital-brain auto-whatsapp --allow-all --provider codex --yes
 
 If your Codex CLI needs a custom command, pass `--codex-command "..."` or set `DIGITAL_BRAIN_CODEX_COMMAND`. If the command contains `{promptFile}`, Digital Brain writes the reply prompt to a temp file and substitutes that path; otherwise it pipes the prompt to stdin.
 
+For the Codex desktop app bridge:
+
+```bash
+digital-brain auto-whatsapp --allow-all --provider codex-app --yes
+```
+
+Digital Brain writes requests to `08 Sources/WhatsApp/Outbound/Codex App Bridge/requests` and waits for matching JSON responses in `responses`.
+
+If you select `Codex app bridge` during `digital-brain init`, the vault also gets `Tools/Codex App Bridge Automation.md` with the exact prompt to use in the Codex app.
+
 If Digital Brain has already sent two AI-assisted messages to the same chat in the last 24 hours, the next send must disclose that AI is helping. Once that chat has received an AI disclosure, Digital Brain will not keep repeating it.
 
 ## Automation

package/bin/digital-brain.js

@@ -49,6 +49,7 @@ async function init(argv, args) {
   let activeWindow = args["active-window"] || "08:00-12:00";
   let timezone = args.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || "local";
   let outboundMode = args["outbound-mode"] || "draft";
+  let autoReplyProvider = args["auto-reply-provider"] || args.provider || "ollama";
   let privacyMode = args["privacy-mode"] || "standard";
   let sourceMarkdownMode = args["source-markdown-mode"] || "none";
   let selectedSources = parseList(args.sources || "whatsapp");
@@ -105,6 +106,13 @@ async function init(argv, args) {
       ["send-with-confirmation", "Send with confirmation", "Can send only after explicit command confirmation.", "✅"],
       ["auto-send", "Auto-send while running", "Lets auto-whatsapp send from allowlisted chats while it is running.", "🚦"],
     ], outboundMode);
+    if (outboundMode !== "disabled") {
+      autoReplyProvider = await select(rl, "WhatsApp auto-reply brain", [
+        ["ollama", "Ollama local model", "Runs fully local if Ollama and the model are installed.", "🦙"],
+        ["codex-app", "Codex app bridge", "Uses request/response files for a Codex desktop automation or thread.", "🧠"],
+        ["codex", "Codex CLI", "Uses a local codex command; only choose this if the CLI works.", "⌨️"],
+      ], autoReplyProvider);
+    }
     connectAi = await confirm(rl, "🔗 Add global AI pointers for Codex/Claude/Gemini?", true);
     responsibilityAccepted = await responsibilityGate(rl, { schedule, outboundMode });
     if (!responsibilityAccepted && needsResponsibilityGate({ schedule, outboundMode })) {
@@ -132,6 +140,7 @@ async function init(argv, args) {
     activeWindow,
     timezone,
     outboundMode,
+    autoReplyProvider,
     privacyMode,
     sourceMarkdownMode,
     selectedSources,
@@ -154,6 +163,7 @@ async function init(argv, args) {
   writeDefaultVault(vault);
   writeRefreshScript(vault, config);
   writeWatchScript(vault, config);
+  writeCodexAppBridgeGuide(vault, config);
 
   if (connectAi) {
     addGlobalPointer(path.join(os.homedir(), ".codex", "AGENTS.md"), vault, "Codex");
@@ -166,6 +176,14 @@ async function init(argv, args) {
   console.log(`Default vault saved: ${vault}`);
   console.log(`Refresh script: ${path.join(vault, "Tools", "digital-brain-refresh.sh")}`);
   console.log(`Always-on script: ${path.join(vault, "Tools", "digital-brain-watch.sh")}`);
+  if (autoReplyProvider === "codex-app") {
+    console.log(`Codex app bridge guide: ${path.join(vault, "Tools", "Codex App Bridge Automation.md")}`);
+    if (codexAppLooksAvailable()) {
+      console.log("Codex app detected. Add the generated bridge prompt as a Codex automation/thread to answer WhatsApp reply requests.");
+    } else {
+      console.log("Codex app config was not detected. The bridge guide was still generated for later use.");
+    }
+  }
   console.log("Next:");
   console.log("  digital-brain run");
   if (schedule === "always-on") console.log(`  "${path.join(vault, "Tools", "digital-brain-watch.sh")}"`);
@@ -408,6 +426,48 @@ done
   fs.chmodSync(scriptPath, 0o755);
 }
 
+function writeCodexAppBridgeGuide(vault, config) {
+  const toolsDir = path.join(vault, "Tools");
+  ensureDir(toolsDir);
+  const bridgeDir = path.join(vault, "08 Sources", "WhatsApp", "Outbound", "Codex App Bridge");
+  const requestsDir = path.join(bridgeDir, "requests");
+  const responsesDir = path.join(bridgeDir, "responses");
+  ensureDir(requestsDir);
+  ensureDir(responsesDir);
+  const prompt = `# Codex App Bridge Automation
+
+Use this prompt in a Codex desktop automation or a live Codex thread when Digital Brain is configured with:
+
+\`\`\`bash
+digital-brain auto-whatsapp --provider codex-app --yes
+\`\`\`
+
+Request folder:
+
+\`${requestsDir}\`
+
+Response folder:
+
+\`${responsesDir}\`
+
+Automation prompt:
+
+\`\`\`text
+Check for pending Digital Brain WhatsApp reply requests in ${requestsDir}. For each .json request that does not already have its response file present, read the request JSON, use its prompt field to produce exactly one WhatsApp reply as the user, and write JSON to the request's responsePath in the exact shape {"reply":"..."}. Do not send any WhatsApp message yourself. Do not write markdown or explanations in the response file. If a request cannot be answered, write {"error":"short reason"} to responsePath.
+\`\`\`
+
+Notes:
+
+- Digital Brain sends the WhatsApp message after the response file appears.
+- Keep the automation active while \`digital-brain auto-whatsapp --provider codex-app\` is running.
+- The default wait timeout is 5 minutes. Override with \`--provider-timeout-ms\`.
+`;
+  writeFileAtomic(path.join(toolsDir, "Codex App Bridge Automation.md"), prompt);
+  if (config.autoReplyProvider === "codex-app") {
+    writeFileAtomic(path.join(bridgeDir, "README.md"), prompt);
+  }
+}
+
 function addGlobalPointer(file, vault, label) {
   ensureDir(path.dirname(file));
   const block = `
@@ -522,6 +582,10 @@ function needsResponsibilityGate({ schedule, outboundMode }) {
   return schedule === "always-on" || ["send-with-confirmation", "auto-send"].includes(outboundMode);
 }
 
+function codexAppLooksAvailable() {
+  return fs.existsSync(path.join(os.homedir(), ".codex"));
+}
+
 function letterFor(index) {
   return String.fromCharCode(65 + index);
 }

package/docs/AUTOMATIONS.md

@@ -31,6 +31,7 @@ digital-brain run
 - refresh interval in minutes for always-on mode, clamped to a minimum of 1
 - active time window
 - WhatsApp outbound mode
+- WhatsApp auto-reply provider: Ollama, Codex app bridge, or Codex CLI
 - whether to add AI adapter pointers
 
 Most questions are multiple choice. Pick with `A/B/C`, `1/2/3`, the exact value, or press Enter to use the displayed default.
@@ -45,6 +46,7 @@ Important defaults:
 - skipped always-on interval uses 5 minutes, with a hard minimum of 1 minute
 - skipped active window uses `08:00-12:00`
 - skipped outbound mode uses draft-only
+- skipped auto-reply provider uses Ollama
 - auto-send mode can be selected during init, but only after the responsibility check
 - skipped AI pointers are added during the guided quiz
 
@@ -104,6 +106,7 @@ Draft-only:
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1
 digital-brain auto-whatsapp --allow-all --provider codex
+digital-brain auto-whatsapp --allow-all --provider codex-app
 ```
 
 Auto-send while the command is running:
@@ -112,6 +115,7 @@ Auto-send while the command is running:
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1 --yes
 digital-brain auto-whatsapp --allow-all --provider codex --yes
+digital-brain auto-whatsapp --allow-all --provider codex-app --yes
 ```
 
 Broad auto-send for personal chats:
@@ -129,11 +133,16 @@ Provider options:
 ```bash
 digital-brain auto-whatsapp --allow "Mom" --provider ollama --model llama3.1 --yes
 digital-brain auto-whatsapp --allow "Mom" --provider codex --yes
+digital-brain auto-whatsapp --allow "Mom" --provider codex-app --yes
 digital-brain auto-whatsapp --allow "Mom" --provider codex --codex-command "codex exec --skip-git-repo-check" --yes
 ```
 
 `--provider codex` runs a local Codex command. If `--codex-command` contains `{promptFile}`, Digital Brain writes the prompt to a temp file and substitutes the path; otherwise it pipes the prompt to stdin.
 
+`--provider codex-app` does not use the Codex CLI. It writes request JSON files to `08 Sources/WhatsApp/Outbound/Codex App Bridge/requests` and waits for response JSON files in `responses`. A Codex desktop automation or live Codex thread must process those request files and write `{"reply":"..."}` to the provided `responsePath`.
+
+When `codex-app` is selected during `init`, Digital Brain creates `Tools/Codex App Bridge Automation.md` with the exact Codex automation prompt and bridge folder paths.
+
 If you selected `Auto-send while running` during init, `auto-whatsapp` can send without `--yes` while it is running:
 
 ```bash
@@ -145,6 +154,7 @@ Guardrails:
 - with `--provider ollama`, requires Ollama running locally
 - with `--provider ollama`, requires the selected model, for example `ollama pull llama3.1`
 - with `--provider codex`, requires a working local Codex command
+- with `--provider codex-app`, requires a Codex desktop bridge automation/thread that writes response files
 - requires `--allow "Name"` or `--contact "+15551234567"` unless `--allow-all` is explicitly passed
 - single-threads reply generation so multiple incoming chats do not trigger overlapping sends
 - skips likely business, notification, OTP, and service chats unless `--include-businesses` is passed or the chat is explicitly allowlisted by name or contact number

package/docs/PRIVACY.md

@@ -7,7 +7,7 @@ Digital Brain is designed for local use.
 - No cloud API is called by default.
 - Ollama interpretation is local when enabled.
 - WhatsApp sending uses a local WhatsApp Web session.
-- WhatsApp auto-reply uses local Ollama by default or a configured local Codex command, runs only while the command is active, and requires an allowlist unless explicitly overridden. If init is configured for auto-send mode, it can send without `--yes`.
+- WhatsApp auto-reply uses local Ollama by default, a configured local Codex command, or a Codex desktop file bridge. It runs only while the command is active and requires an allowlist unless explicitly overridden. If init is configured for auto-send mode, it can send without `--yes`.
 - Raw source data stays under `08 Sources/`; normal AI context should use `06 AI Memory/` and human notes under `04 People/`.
 - Same-person matching across sources is provisional and file-based; keep source evidence visible when using merged person context.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "digital-brain",
-  "version": "1.1.11",
+  "version": "1.1.15",
   "description": "Your private digital imprint for AI assistants.",
   "type": "module",
   "bin": {

package/whatsapp-web/auto-reply.mjs

@@ -20,6 +20,7 @@ const outboundDir = path.join(whatsAppDir, "Outbound");
 const sessionDir = path.join(whatsAppDir, ".session");
 const statePath = path.join(outboundDir, "auto-reply-state.json");
 const whitelistPath = path.join(outboundDir, "auto-reply-whitelist.json");
+const codexAppBridgeDir = path.join(outboundDir, "Codex App Bridge");
 const config = readConfig(vault);
 const provider = args.provider || config.autoReplyProvider || "ollama";
 const model = args.model || config.autoReplyModel || "llama3.1";
@@ -62,8 +63,8 @@ if (!hasInitialScope && !interactiveTerminal) {
 
 if (provider === "ollama") {
   await assertOllamaModel(model);
-} else if (!["codex"].includes(provider)) {
-  throw new Error(`Unsupported auto-reply provider "${provider}". Use "ollama" or "codex".`);
+} else if (!["codex", "codex-app"].includes(provider)) {
+  throw new Error(`Unsupported auto-reply provider "${provider}". Use "ollama", "codex", or "codex-app".`);
 }
 
 const client = new Client({
@@ -82,6 +83,7 @@ client.on("ready", async () => {
   if (!hasInitialScope) await configureInteractiveScope();
   console.log(runtimeAllowAll ? "Allowlist: all chats, with first-send approval per new chat." : allowlistSummary());
   if (provider === "codex") console.log(`Codex command: ${codexCommand}`);
+  if (provider === "codex-app") console.log(`Codex App bridge: ${codexAppBridgeDir}`);
   if (!includeBusinesses) console.log("Likely business, notification, OTP, and service chats are skipped by default.");
   try {
     if (processUnreadOnStart) {
@@ -344,6 +346,7 @@ function readMemoryContext(chatName) {
 
 async function generateReply(prompt) {
   if (provider === "codex") return generateCodexReply(prompt);
+  if (provider === "codex-app") return generateCodexAppReply(prompt);
   return generateOllamaReply(prompt);
 }
 
@@ -367,6 +370,52 @@ async function generateCodexReply(prompt) {
   return runReplyCommand(codexCommand, prompt, "codex");
 }
 
+async function generateCodexAppReply(prompt) {
+  const timeoutMs = numberArg("provider-timeout-ms", 300000);
+  const request = createCodexAppRequest(prompt);
+  console.log(`Waiting for Codex App bridge response: ${request.responsePath}`);
+  return await waitForCodexAppResponse(request.responsePath, timeoutMs);
+}
+
+function createCodexAppRequest(prompt) {
+  const requestId = `${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+  const requestsDir = path.join(codexAppBridgeDir, "requests");
+  const responsesDir = path.join(codexAppBridgeDir, "responses");
+  fs.mkdirSync(requestsDir, { recursive: true });
+  fs.mkdirSync(responsesDir, { recursive: true });
+  const requestPath = path.join(requestsDir, `${requestId}.json`);
+  const responsePath = path.join(responsesDir, `${requestId}.json`);
+  writeJsonAtomic(requestPath, {
+    schemaVersion: 1,
+    requestId,
+    createdAt: new Date().toISOString(),
+    responsePath,
+    prompt,
+    instructions: [
+      "Write exactly one WhatsApp reply as the user.",
+      "Return JSON only: {\"reply\":\"...\"}.",
+      "No markdown, no explanations, no surrounding text.",
+    ],
+  });
+  return { requestId, requestPath, responsePath };
+}
+
+async function waitForCodexAppResponse(responsePath, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (fs.existsSync(responsePath)) {
+      const response = parseJsonLine(fs.readFileSync(responsePath, "utf8"));
+      if (!response) throw new Error(`Codex App bridge wrote invalid JSON: ${responsePath}`);
+      if (response.error) throw new Error(`Codex App bridge error: ${response.error}`);
+      const reply = cleanReply(response.reply || "");
+      if (!reply) throw new Error(`Codex App bridge wrote an empty reply: ${responsePath}`);
+      return reply;
+    }
+    await sleep(1000);
+  }
+  throw new Error(`Codex App bridge timed out after ${timeoutMs}ms. No response at ${responsePath}`);
+}
+
 async function runReplyCommand(command, prompt, label) {
   const timeoutMs = numberArg("provider-timeout-ms", 120000);
   const usesPromptFile = command.includes("{promptFile}");
@@ -685,6 +734,10 @@ function cleanupPromptFile(file) {
   }
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 function shellQuote(value) {
   return `'${String(value).replaceAll("'", "'\\''")}'`;
 }
@@ -752,6 +805,6 @@ function parseArgs(argv) {
 }
 
 function usage() {
-  console.error('Usage: digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --model llama3.1 [--yes] [--allow-all] [--include-groups] [--include-businesses]');
+  console.error('Usage: digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --provider ollama|codex|codex-app --model llama3.1 [--yes] [--allow-all] [--include-groups] [--include-businesses]');
   process.exit(1);
 }