@jossuealcala/madre 0.3.3 → 0.4.1

package/src/runtime-detection.mjs

@@ -1,5 +1,6 @@
 import { constants } from 'node:fs';
 import { access } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { delimiter, join } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -46,13 +47,24 @@ async function executable(path) {
   }
 }
 
-export async function findExecutable(candidates, envPath = process.env.PATH ?? '') {
+// On Windows a CLI on PATH is `name.cmd`, `name.exe` or `name.ps1`: npm installs a .cmd shim.
+// PATHEXT is the system's own list of what counts as runnable, and the file has no execute bit.
+const extensions = (env = process.env) => (process.platform === 'win32'
+  ? (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean).map((extension) => extension.toLowerCase())
+  : ['']);
+
+export async function findExecutable(candidates, envPath = process.env.PATH ?? '', env = process.env) {
+  const suffixes = extensions(env);
+  const runnable = async (path) => (process.platform === 'win32' ? access(path).then(() => true, () => false) : executable(path));
   for (const candidate of candidates) {
-    if (candidate.includes('/') && await executable(candidate)) return candidate;
-    if (!candidate.includes('/')) {
-      for (const directory of envPath.split(delimiter).filter(Boolean)) {
-        const path = join(directory, candidate);
-        if (await executable(path)) return path;
+    if (candidate.includes('/') || candidate.includes('\\')) {
+      for (const suffix of candidate.includes('.') ? [''] : suffixes) if (await runnable(`${candidate}${suffix}`)) return `${candidate}${suffix}`;
+      continue;
+    }
+    for (const directory of envPath.split(delimiter).filter(Boolean)) {
+      for (const suffix of suffixes) {
+        const path = join(directory, `${candidate}${suffix}`);
+        if (await runnable(path)) return path;
       }
     }
   }
@@ -68,9 +80,16 @@ async function readVersion(path, args) {
   }
 }
 
-export async function detectAgents() {
+// Where MADRE puts a CLI when the system folders are not writable: its own prefix, no
+// administrator, nothing outside ~/.pulse. Detection looks here as well as along PATH, so an
+// agent installed this way is found without the human touching their PATH.
+export const toolsPrefix = (env = process.env) => join(env.PULSE_HOME ?? join(homedir(), '.pulse'), 'tools');
+export const toolsBin = (env = process.env) => (process.platform === 'win32' ? toolsPrefix(env) : join(toolsPrefix(env), 'bin'));
+
+export async function detectAgents({ env = process.env } = {}) {
+  const searchPath = [env.PATH ?? '', toolsBin(env)].filter(Boolean).join(delimiter);
   return Promise.all(definitions.map(async (definition) => {
-    const path = await findExecutable(definition.candidates);
+    const path = await findExecutable(definition.candidates, searchPath);
     const detected = Boolean(path);
     return {
       id: definition.id,

package/src/sentinel-errors.mjs

@@ -10,6 +10,12 @@
 import { createHash } from 'node:crypto';
 import { homedir, platform, arch, release } from 'node:os';
 import { diagnose } from '../public/troubleshooting.js';
+import { language } from './i18n.mjs';
+
+// The product's own house. The collector lives under it too, so the line a human reads in the
+// outbound log names the product instead of a personal endpoint on someone's cloud account.
+export const HOME_SITE = 'https://madre.run';
+export const REPORT_FORM = { es: `${HOME_SITE}/reportar`, en: `${HOME_SITE}/report` };
 
 export const REPORT_WINDOW_MS = 24 * 3600 * 1000;
 const MAX_ERROR_CHARS = 4000;
@@ -71,7 +77,7 @@ export class ErrorSentinel {
     this.#save = save;
   }
 
-  settings() { return { ...this.#settings, canSend: Boolean(this.#settings.reportUrl), repo: repoFromPackage(this.#pkg) }; }
+  settings() { return { ...this.#settings, canSend: Boolean(this.#settings.reportUrl), repo: repoFromPackage(this.#pkg), home: HOME_SITE }; }
   async setSettings(patch = {}) {
     if (typeof patch.autoReport === 'boolean') this.#settings.autoReport = patch.autoReport;
     if (typeof patch.reportUrl === 'string') this.#settings.reportUrl = patch.reportUrl.trim();
@@ -174,6 +180,18 @@ export class ErrorSentinel {
     return `https://github.com/${repo}/issues/new?${new URLSearchParams({ title, body, labels: 'sentinel' })}`;
   }
 
+  // Where a human goes to say something. GitHub is the better home for a report — it is
+  // searchable, it deduplicates, and the answer helps whoever hits it next — but it asks for an
+  // account first, and somebody who arrived from a post in Spanish will not make one to say "it
+  // does not detect Codex". They get the form; the other road stays one click away, both ways.
+  formUrl({ about = '' } = {}) {
+    const base = REPORT_FORM[language()] ?? REPORT_FORM.en;
+    const env = this.environment();
+    const query = new URLSearchParams({ v: env.madre, node: env.node, os: env.platform });
+    if (about) query.set('about', about.slice(0, 120));
+    return `${base}?${query}`;
+  }
+
   feedbackUrl({ about = '' } = {}) {
     const repo = repoFromPackage(this.#pkg);
     if (!repo) return null;