madarx 2.16.3 → 2.17.0

package/app/login/login-client.jsx

@@ -153,8 +153,21 @@ export default function LoginClient({ authMode, nextPath = '/', errorCode = '',
 
   async function supabaseClient() {
     const { createBrowserClient } = await import('@supabase/ssr');
-    const url = cfg?.supabaseUrl;
-    const anonKey = cfg?.supabaseAnonKey;
+    let url = cfg?.supabaseUrl;
+    let anonKey = cfg?.supabaseAnonKey;
+    // cfg is fetched once on mount. If that fetch lost the race (server not yet
+    // able to resolve config, or a transient blip), cfg stays empty and the tab
+    // is stranded until a manual refresh. Refetch on demand before failing.
+    if (!url || !anonKey) {
+      try {
+        const d = await fetch('/api/auth/config', { cache: 'no-store' }).then((r) => r.json());
+        setCfg(d);
+        url = d?.supabaseUrl;
+        anonKey = d?.supabaseAnonKey;
+      } catch {
+        /* fall through to the configured-check below */
+      }
+    }
     if (!url || !anonKey) throw new Error('Supabase is not configured. Create a team or set it in Settings → Account.');
     return createBrowserClient(url, anonKey);
   }

package/lib/active-runs.js

@@ -0,0 +1,33 @@
+// In-process registry of agents with a LIVE manual/on-demand run.
+//
+// Manual runs triggered via POST /api/agents/[id]/run are fire-and-forget
+// promises inside the web process — they create NO `agent_runs` row (those are
+// for delegated/task runs), so there is no DB source of truth for "is this
+// agent running right now?". This module is that source for the current process.
+//
+// Scope + lifetime: process-local and best-effort. It answers the active-run
+// endpoint so the Run button can hydrate correct state after the user navigates
+// away and back within the same server process. It is intentionally NOT durable
+// (a restart clears it) — durable run tracking is the heartbeat-queue path.
+//
+// A ref count (not a boolean) tolerates overlapping ticks for the same agent.
+
+const counts = new Map();
+
+export function markRunActive(agentId) {
+  const id = String(agentId || '');
+  if (!id) return;
+  counts.set(id, (counts.get(id) || 0) + 1);
+}
+
+export function clearRunActive(agentId) {
+  const id = String(agentId || '');
+  if (!id) return;
+  const next = (counts.get(id) || 0) - 1;
+  if (next <= 0) counts.delete(id);
+  else counts.set(id, next);
+}
+
+export function isRunActive(agentId) {
+  return (counts.get(String(agentId || '')) || 0) > 0;
+}

package/lib/agent-config.js

@@ -1,6 +1,7 @@
 import { getDb } from './db.js';
 import { hasEnabledInternetTools } from './tools/registry.js';
 import { brandInstructionText, getBrandProfile } from './brand.js';
+import { commandExists } from './agent-engines.js';
 
 // Role description: user-editable identity/persona block. The dashboard's
 // InstructionsBuilder and /settings page both write to this. Replacing it
@@ -232,14 +233,6 @@ export const MODELS = ANTHROPIC_MODELS;
 
 const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || 'http://127.0.0.1:11434';
 
-async function commandExists(command) {
-  const { spawn } = await import('node:child_process');
-  return new Promise(resolve => {
-    const child = spawn('sh', ['-lc', `command -v ${command}`], { shell: false });
-    child.on('error', () => resolve(false));
-    child.on('close', code => resolve(code === 0));
-  });
-}
 
 export async function getModels() {
   const [ollamaRes, claudeCodeOk, codexOk] = await Promise.all([

package/lib/agent-engines.js

@@ -271,7 +271,13 @@ function commandSpawnTarget(command) {
   return _commandPathCache.get(command) || resolveCommandPathSync(command) || command;
 }
 
-async function commandExists(command) {
+// Exported so other surfaces (e.g. the main-chat model feed in agent-config.js)
+// use the SAME robust detection as /settings/engines — absolute-path candidates
+// + MADARX_<CMD>_BIN override + login-shell fallback. A bare `sh -lc command -v`
+// alone misses CLIs installed outside the server's inherited/login PATH (common
+// on GUI- or daemon-launched servers), which made claude-code show available in
+// engine settings but absent from the main chat picker.
+export async function commandExists(command) {
   if (resolveCommandPathSync(command)) return true;
   return new Promise(resolve => {
     const child = spawn('sh', ['-lc', `command -v ${command}`], { shell: false });

package/lib/agent-runner.js

@@ -10,6 +10,7 @@ import { executeRegistryTool, getEnabledToolSchemasForAgent } from './tools/regi
 import { assertRunnable } from './engine-capabilities.js';
 import { looksFabricatedToolTranscript } from './fabricated-tool-output.js';
 import { publishLiveEvent } from './live-events.js';
+import { markRunActive, clearRunActive } from './active-runs.js';
 import {
   addTaskComment,
   appendAgentRunEvent,
@@ -363,6 +364,11 @@ export async function runAgentTick(agentOrId, {
     updateTask(task_id, { status: 'in_progress', actor_type: 'agent', actor_id: agent.id });
   }
 
+  // Mark this agent as having a live run so GET /api/agents/[id]/active-run can
+  // report it — manual runs have no agent_runs row to read from. Cleared in the
+  // finally below regardless of outcome.
+  markRunActive(agent.id);
+
   publishLiveEvent({
     type: 'agent_run_start',
     agent_id: agent.id,
@@ -610,6 +616,34 @@ ${lastMemory.length ? lastMemory.map((entry, index) => `${index + 1}. ${entry}`)
       try {
         markAgentRunFinished(taskRun.id, { status: 'failed', error: message });
       } catch {}
+    } else {
+      // Manual / on-demand run (no taskRun). The success path persists a `runs`
+      // row + audit, but this failure path historically did neither — so a
+      // failed manual run vanished (console-only) and the agent's activity feed
+      // stayed empty ("nothing happened"). Persist a FAILED run + audit carrying
+      // the remediation message and the error code so the failure — and how to
+      // fix it (e.g. engine_cannot_run_tools → switch engine) — is visible.
+      try {
+        const { recordRun, appendAudit } = await import('./runtime.js');
+        recordRun({
+          kind: 'agent-tick',
+          title: `${agent.name} run failed`,
+          agent: agent.name,
+          agent_id: agent.id,
+          status: 'failed',
+          preview: message,
+          output: message,
+          triggered_by,
+        });
+        appendAudit({
+          type: 'agent.run.failed',
+          summary: `${agent.name} run failed: ${message}`,
+          status: 'error',
+          meta: { agent_id: agent.id, code: err?.code || null, triggered_by },
+        });
+      } catch {
+        // Failure recording is best-effort — never mask the original error.
+      }
     }
     // Always publish run_complete on the error path so the OCC entry clears,
     // regardless of whether a taskRun was attached (on-demand runs via the
@@ -626,5 +660,7 @@ ${lastMemory.length ? lastMemory.map((entry, index) => `${index + 1}. ${entry}`)
       error: message,
     });
     throw err;
+  } finally {
+    clearRunActive(agent.id);
   }
 }

package/lib/auth.js

@@ -26,14 +26,26 @@ export { getAuthMode, getSupabaseAuthConfig, getSupabaseServiceKey } from './aut
 
 const IS_NEXT_PRODUCTION_BUILD = process.env.NEXT_PHASE === 'phase-production-build';
 
-// Deploy-time guard keys off the explicit env value only (the DB may not be
-// open at module load, and the env override is the production source of truth).
-if (
-  (process.env.MADARX_AUTH_MODE || 'local').toLowerCase() === 'local' &&
-  process.env.NODE_ENV === 'production' &&
-  !IS_NEXT_PRODUCTION_BUILD
-) {
-  console.error('[auth] WARNING: MADARX_AUTH_MODE is not set to supabase in NODE_ENV=production. Configure Supabase auth (Settings → Account) or set MADARX_AUTH_MODE=supabase before exposing this deployment.');
+// Deploy-time guard. Deferred to first session resolution (not module load) so
+// it can consult the EFFECTIVE auth mode via getAuthMode() — which resolves the
+// env override AND the UI-persisted DB config. Checking the env var alone at
+// module load false-alarms whenever Supabase was configured from Settings → the
+// DB isn't open yet at import time, so the env looked 'local' even though the
+// running mode is 'supabase'. One-shot.
+let _authModeWarned = false;
+function warnIfUnsafeAuthModeOnce() {
+  if (_authModeWarned) return;
+  _authModeWarned = true;
+  if (IS_NEXT_PRODUCTION_BUILD || process.env.NODE_ENV !== 'production') return;
+  let mode;
+  try {
+    mode = getAuthMode(); // env override → DB config → 'local'
+  } catch {
+    mode = (process.env.MADARX_AUTH_MODE || 'local').toLowerCase();
+  }
+  if (mode === 'local') {
+    console.error('[auth] WARNING: auth mode is local in NODE_ENV=production. Configure Supabase auth (Settings → Account) or set MADARX_AUTH_MODE=supabase before exposing this deployment.');
+  }
 }
 
 // ── Local dev synthetic user ──────────────────────────────────────────────────
@@ -329,6 +341,7 @@ function _upsertUserRow(sbUser) {
  * - supabase mode: reads Supabase session cookie; returns null if unauthenticated.
  */
 export async function getSession(req, { _client } = {}) {
+  warnIfUnsafeAuthModeOnce();
   if (getAuthMode() === 'local') {
     return getLocalDevUser();
   }

package/lib/heartbeat-worker.js

@@ -132,7 +132,11 @@ async function executeTask(task) {
     });
   }
   return runAgentTick(payload.agent_id || task.agent_id, {
-    triggered_by: 'heartbeat-worker',
+    // Honor the enqueuer's provenance (e.g. a manual run from the dashboard sets
+    // triggered_by:'manual') so the recorded run + audit reflect why it ran,
+    // instead of flattening every queued tick to 'heartbeat-worker'.
+    triggered_by: payload.triggered_by || 'heartbeat-worker',
+    wake_reason: payload.reason || null,
     acting_on_behalf_of_user_id: actingUserId,
     heartbeat_task_id: task.id,
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madarx",
-  "version": "2.16.3",
+  "version": "2.17.0",
   "type": "module",
   "description": "Madarx OS — Next.js product with SQLite-backed runtime, scheduled cron daemon, and approval-gated local runners.",
   "license": "MIT",
@@ -41,7 +41,9 @@
   "scripts": {
     "dev": "next dev -p 8787 -H 127.0.0.1",
     "madarx": "node bin/madarx.mjs",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run build && node --no-warnings scripts/prepack-guard.mjs",
+    "prepack": "node --no-warnings scripts/prepack-guard.mjs",
+    "clean:dist-data": "node --no-warnings scripts/prepack-guard.mjs",
     "build": "NODE_OPTIONS=--no-warnings next build",
     "postbuild": "node --no-warnings scripts/postbuild-standalone.mjs",
     "postinstall": "node --no-warnings scripts/postinstall-splash.mjs",

package/scripts/prepack-guard.mjs

@@ -0,0 +1,79 @@
+/**
+ * scripts/prepack-guard.mjs — strip runtime/secret artifacts from the publish tarball.
+ *
+ * The `files` whitelist in package.json includes `.next/standalone/`. When the
+ * built standalone server is ever run from that directory (local smoke test,
+ * CI), it writes a live `data/` dir — SQLite DB (encrypted secrets vault, real
+ * user rows, audit log), WhatsApp session credentials (PLAINTEXT account creds),
+ * the auth recovery token, and report artifacts. Without this guard those files
+ * ship to the public npm registry. See the 2.16.3 leak.
+ *
+ * Runs on `prepack` (fires for both `npm pack` and `npm publish`, after build).
+ * Deletes the offending paths, then HARD-FAILS if anything sensitive remains so
+ * a broken guard can never silently publish secrets.
+ */
+
+import { rmSync, existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// Directories that must never ship — runtime data homes that can appear under
+// the bundled standalone output.
+const PURGE_DIRS = [
+  '.next/standalone/data',
+  '.next/standalone/workspace',
+];
+
+// Stray env files that could carry the master key / service-role key.
+const PURGE_GLOBS = [
+  '.next/standalone/.env',
+  '.next/standalone/.env.local',
+  '.next/standalone/.env.production',
+];
+
+// After purge, fail if any path matching these patterns still exists anywhere
+// under the publishable tree (excluding node_modules, which legitimately holds
+// files named e.g. caniuse-lite/data/*).
+const FORBIDDEN_RE = /(\.sqlite(\.|-|$)|\.sqlite\.bak|whatsapp\/session|auth-recovery-token|\.inproc-token|\.env(\.|$))/;
+
+let removed = 0;
+for (const rel of [...PURGE_DIRS, ...PURGE_GLOBS]) {
+  const abs = path.join(ROOT, rel);
+  if (existsSync(abs)) {
+    rmSync(abs, { recursive: true, force: true });
+    console.log(`[prepack-guard] removed ${rel}`);
+    removed++;
+  }
+}
+
+// Verification sweep over the standalone output (the only whitelisted tree that
+// can accrue runtime state). Skip node_modules.
+const offenders = [];
+function sweep(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (e.name === 'node_modules') continue;
+    const full = path.join(dir, e.name);
+    const relFromRoot = path.relative(ROOT, full);
+    if (FORBIDDEN_RE.test(relFromRoot)) offenders.push(relFromRoot);
+    if (e.isDirectory()) sweep(full);
+  }
+}
+const standalone = path.join(ROOT, '.next/standalone');
+if (existsSync(standalone)) sweep(standalone);
+
+if (offenders.length > 0) {
+  console.error('[prepack-guard] ABORT — sensitive files still present in the publish tree:');
+  for (const o of offenders) console.error(`  ${o}`);
+  console.error('[prepack-guard] refusing to build a tarball that would leak runtime data.');
+  process.exit(1);
+}
+
+console.log(`[prepack-guard] clean (${removed} path(s) purged, 0 sensitive files remain).`);