@jossuealcala/madre 0.7.0 → 0.7.2

package/src/runs.mjs

@@ -0,0 +1,119 @@
+// An agent asking the human to run a command.
+//
+// Below #4 AIRLOCK no agent runs anything: it reads, it writes where its mode allows, and that is
+// all. Some answers still turn on a command — the tests after a fix, a build, a linter — and the
+// agent used to say "run npm test and tell me", leaving the human to copy it into a terminal and
+// paste the output back. This gives the request a shape. ```pulse-run carries the reason and the
+// commands; MADRE shows each one as a button; the human presses; the output lands in the room as
+// a card every agent reads on its next turn.
+//
+// Inert, like ```pulse-ask: parsing it runs nothing. The press is the human's, line by line.
+//
+//   ```pulse-run
+//   Check that the fix did not break the parser
+//   $ npm test
+//   $ node --check src/runs.mjs
+//   ```
+//
+// One command per line, and no shell. A line becomes an argv the way a POSIX shell would split
+// it — quotes and backslashes — and nothing else: no pipes, no `&&`, no redirections, no `$VAR`,
+// no globs. Without a shell those would arrive at the program as literal characters and do
+// something other than what the human read on the button, so a line that has one is refused and
+// says why. Running it through a shell instead would hand an agent's text to `sh` or `cmd.exe`
+// (WIN-016): the human approves a line, and the line that runs has to be the one they read.
+
+export const MAX_COMMANDS = 5;
+const MAX_REASON = 300;
+const MAX_LINE = 500;
+
+// Shell builtins: without a shell they are not programs, or they are programs that change nothing.
+const BUILTINS = new Set(['cd', 'export', 'source', '.', 'alias', 'unset', 'set', 'eval', 'exec', 'pushd', 'popd']);
+
+function clip(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max - 1).trimEnd()}…`;
+}
+
+// A line split into words the way sh would, without anything sh would expand. Returns
+// { argv } or { why } when the line needs a shell to mean what it says.
+export function splitCommand(line) {
+  const argv = [];
+  let word = '';
+  let inWord = false;
+  let quote = null;
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if (quote === "'") {
+      if (char === "'") quote = null; else word += char;
+      continue;
+    }
+    if (quote === '"') {
+      if (char === '"') { quote = null; continue; }
+      if (char === '\\' && i + 1 < line.length && '"\\$`'.includes(line[i + 1])) { word += line[i + 1]; i += 1; continue; }
+      if (char === '$' || char === '`') return { why: 'expands a variable or a command inside quotes; there is no shell to expand it' };
+      word += char;
+      continue;
+    }
+    if (char === "'" || char === '"') { quote = char; inWord = true; continue; }
+    if (char === '\\') {
+      if (i + 1 < line.length) { word += line[i + 1]; i += 1; inWord = true; continue; }
+      return { why: 'ends in a lone backslash' };
+    }
+    if (/\s/.test(char)) {
+      if (inWord) { argv.push(word); word = ''; inWord = false; }
+      continue;
+    }
+    if ('|&;<>()'.includes(char)) return { why: 'uses "{char}", which needs a shell; put each command on its own line', whyArgs: { char } };
+    if (char === '$' || char === '`') return { why: 'expands a variable or a command; there is no shell to expand it' };
+    if (char === '*' || char === '?' || char === '[') return { why: 'uses "{char}" as a glob; there is no shell to expand it, name the files', whyArgs: { char } };
+    if (char === '~' && !inWord) return { why: 'starts a word with "~"; there is no shell to expand it, write the path' };
+    if (char === '#' && !inWord) return { why: 'carries a "#" comment, which only a shell would drop; say it in the reason' };
+    word += char;
+    inWord = true;
+  }
+  if (quote) return { why: 'leaves a quote open' };
+  if (inWord) argv.push(word);
+  if (!argv.length) return { why: 'is empty' };
+  if (BUILTINS.has(argv[0])) return { why: '"{name}" is a shell builtin; every line already runs from the project root', whyArgs: { name: argv[0] } };
+  if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(argv[0])) return { why: 'sets an environment variable, which needs a shell' };
+  return { argv };
+}
+
+// A refusal is a template so the room can say it in the human's language; this fills it in.
+export const whyText = (command) => String(command?.why ?? '').replace(/\{(\w+)\}/g, (match, key) => command?.whyArgs?.[key] ?? match);
+
+// The last ```pulse-run block of a reply, if it closes the reply. Returns null for anything else:
+// a block quoted mid-answer is an example, and an example is not a request.
+export function parseRunRequest(text) {
+  const source = String(text ?? '');
+  const blocks = [...source.matchAll(/```pulse-run\s*\n([\s\S]*?)```/gi)];
+  if (!blocks.length) return null;
+  const last = blocks.at(-1);
+  if (source.slice(last.index + last[0].length).trim()) return null;
+
+  const lines = last[1].split('\n').map((line) => line.trim()).filter(Boolean);
+  const reason = lines[0] && !lines[0].startsWith('$') ? clip(lines[0], MAX_REASON) : null;
+  const commands = [];
+  const seen = new Set();
+  for (const raw of lines.slice(reason ? 1 : 0)) {
+    if (!raw.startsWith('$')) continue;
+    const line = raw.slice(1).trim();
+    if (!line || seen.has(line)) continue;
+    seen.add(line);
+    if (commands.length === MAX_COMMANDS) break;
+    if (line.length > MAX_LINE) { commands.push({ line: clip(line, MAX_LINE), why: 'is too long to read before pressing it' }); continue; }
+    const split = splitCommand(line);
+    commands.push(split.argv ? { line, argv: split.argv } : { line, why: split.why, ...(split.whyArgs ? { whyArgs: split.whyArgs } : {}) });
+  }
+  // A request without a reason asks the human to run something on faith.
+  if (!reason || !commands.length) return null;
+  return { reason, commands };
+}
+
+// What the reply reads as once the block has been lifted out of it: the room shows the commands
+// as buttons, so leaving the raw fence in the text would say everything twice.
+export function withoutRunRequest(text) {
+  const source = String(text ?? '');
+  if (!parseRunRequest(source)) return source;
+  const last = [...source.matchAll(/```pulse-run\s*\n[\s\S]*?```/gi)].at(-1);
+  return source.slice(0, last.index).trimEnd();
+}

package/src/server.mjs

@@ -17,7 +17,7 @@ import { createEmbedder } from './embeddings.mjs';
 import { memoryServerFor } from './memory-tools.mjs';
 import { MotherChannel, CODE000_STRIKES } from './mother.mjs';
 import { ErrorSentinel } from './sentinel-errors.mjs';
-import { probeOllama, ollamaEmbedder, ollamaInvoker, pullModel } from './ollama.mjs';
+import { probeOllama, ollamaEmbedder, ollamaInvoker, pullModel, ollamaVersions, ownOllamaServers } from './ollama.mjs';
 import { moduleById, describeModules, findModuleRoute, toolsForTurn as modulesToolsForTurn, loadExternalModules, loadFailures, moduleFolders, moduleCommands, installModuleFile, installModuleText, verifyModuleText, moduleOrigin, removeExternalModule } from './modules/index.mjs';
 import { madreAgent, madreInvoker, MADRE_AGENT_ID, MADRE_ADAPTER } from './adapters/madre.mjs';
 import { exportDataset, readiness as datasetReadiness } from './dataset.mjs';
@@ -65,7 +65,7 @@ import { setImageModule } from './capabilities.mjs';
 import { resolveGeminiKey } from './image-studio.mjs';
 import { commandByName, listCommands, parseCommand } from './commands.mjs';
 import { listDirectory, searchFiles, readServable, storeAttachment, resolveInside, MAX_ATTACHMENT_BYTES } from './files.mjs';
-import { planFileOp, CREATIONS } from './file-ops.mjs';
+import { planFileOp, freeCopyPath, CREATIONS } from './file-ops.mjs';
 import { Eyecat } from './eyecat-watch.mjs';
 import { economy } from './room/economy.mjs';
 import { maturity } from './maturity.mjs';
@@ -560,6 +560,7 @@ export async function createPulseServer({
   setImageModule(startupConfig.modules?.imageStudio ?? {});
   room.setAsh(Boolean(startupConfig.modules?.ash?.enabled));
   room.setChoices(Boolean(startupConfig.modules?.choices?.enabled));
+  room.setRuns(Boolean(startupConfig.modules?.runs?.enabled));
   const recoveredTurns = await room.reconcile();
   if (recoveredTurns) console.error(`MADRE recovered ${recoveredTurns} unfinished turn(s) from a previous run.`);
   const quotaMonitor = new QuotaMonitor({
@@ -771,6 +772,29 @@ export async function createPulseServer({
             await room.record('extension.install.finished', { id: 'ollama', name: 'OLLAMA', ok: status.running, installed: true, detail: status.running ? `running · ${status.chatModel ? `@madre with ${status.chatModel}` : 'no chat model yet'}` : 'Ollama did not answer; open the Ollama app and press RECHECK.', ollama: status });
             return status.running ? { ok: true } : { ok: false, error: t('Ollama did not answer. Open the Ollama app, then press RECHECK.') };
           },
+          // After an upgrade the binary is new and the server answering on the port is still the old
+          // one, so the card kept reading the old version and the update looked like it did nothing.
+          // An `ollama serve` this user started is stopped and started again from the new binary;
+          // anything else (the app, a service of another user) is named, not touched.
+          async restart() {
+            const binary = await findOnPath('ollama');
+            if (!binary) return { ok: false, error: t('Ollama is not on this computer yet.') };
+            const run = (command, args) => new Promise((resolve) => execFile(command, args, { timeout: 5000 }, (error, stdout, stderr) => resolve(`${stdout ?? ''}${stderr ?? ''}`)));
+            const { client } = ollamaVersions(await run(binary, ['--version']));
+            const status = await wireOllama();
+            if (!status.running) return this.start();
+            if (!client || !status.version || status.version === client) return { ok: true, already: true };
+            const pids = process.platform === 'win32' || typeof process.getuid !== 'function' ? [] : ownOllamaServers(await run('ps', ['-axo', 'pid=,uid=,args=']), process.getuid());
+            if (!pids.length) return { ok: false, error: t('Ollama {client} is installed, but {running} is still the one answering. Quit Ollama (or restart its service) and open it again, then RECHECK.', { client, running: status.version }) };
+            for (const pid of pids) { try { process.kill(pid, 'SIGTERM'); } catch { /* already gone */ } }
+            let down = status;
+            for (let attempt = 0; attempt < 20 && down.running; attempt += 1) {
+              await new Promise((resolve) => setTimeout(resolve, 500));
+              down = await wireOllama();
+            }
+            if (down.running) return { ok: false, error: t('The old Ollama ({running}) did not stop. Quit it by hand, then press START OLLAMA.', { running: status.version }) };
+            return this.start();
+          },
           // Pulls stream into the room like a module install; one at a time.
           pull: async (model) => {
             if (installing) return { ok: false, error: `Another install is running (${installing}).` };
@@ -909,6 +933,7 @@ export async function createPulseServer({
           agents: agents.map((agent) => ({ ...agent, login: loginPlanFor(agent), install: installPlanFor(agent), key: keyPlanFor(agent.id), ...(accountNoteFor(agent.id) ?? {}) })),
           ash: { enabled: room.ashEnabled() },
           choices: { enabled: room.choicesEnabled() },
+          runs: { enabled: room.runsEnabled() },
           // Read live, not from the config this process loaded at boot. A switch the human moves
           // in MODULES while the room is open has to be the answer the room gives afterwards —
           // otherwise the switch says on and the browser keeps refusing, which is how a setting
@@ -959,8 +984,18 @@ export async function createPulseServer({
       // room guards from agents ask for the project's designation first.
       if (request.method === 'POST' && url.pathname === '/api/tree/op') {
         const payload = await body(request).catch(() => ({}));
+        // Pasting a copy where its name is taken — beside itself, most often — names the copy
+        // instead of refusing. Only a copy, and only when the page asked: a move or a rename onto
+        // a taken name is still a mistake the human should hear about.
+        if (payload.operation === 'copy' && payload.unique) {
+          payload.to = await freeCopyPath(payload.to, { word: t('copy'), taken: async (path) => {
+            const dir = path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '.';
+            const parent = await resolveInside(canonicalProjectRoot, dir);
+            return Boolean(parent) && access(join(parent, path.slice(path.lastIndexOf('/') + 1))).then(() => true, () => false);
+          } });
+        }
         const plan = planFileOp(payload);
-        if (!plan.ok) return sendJson(response, 400, { error: plan.error });
+        if (!plan.ok) return sendJson(response, 400, { error: t(plan.error) });
         if (plan.guarded && !designationOk(payload.designation)) {
           return sendJson(response, 403, { error: t('UNABLE TO COMPUTE. UNABLE TO CLARIFY.'), guarded: true });
         }
@@ -980,7 +1015,7 @@ export async function createPulseServer({
           else if (plan.operation === 'copy') await cp(source, destination, { recursive: true, errorOnExist: true, force: false });
           else await rename(source, destination);
         } catch (error) {
-          return sendJson(response, 500, { error: error.message });
+          return sendJson(response, 500, { error: t('That could not be done: {error}', { error: error.message }) });
         }
         await room.record(CREATIONS.includes(plan.operation) ? 'project.file.created' : 'project.file.moved', { operation: plan.operation, from: plan.from, to: plan.to, guarded: plan.guarded });
         return sendJson(response, 200, { ok: true, operation: plan.operation, from: plan.from, to: plan.to });
@@ -1481,11 +1516,15 @@ export async function createPulseServer({
         await room.record('extension.install.started', { id: module.id, name: item.name, command: plan.display, platforms: [], alreadyInstalled: true });
         void (async () => {
           const result = await runInstaller({ command: plan.command, args: plan.args, projectRoot: canonicalProjectRoot, timeoutMs: 900000, onLine: (line) => { void room.record('extension.install.output', { id: module.id, lines: [String(line).slice(0, 500)] }); } });
-          await plan.after?.().catch(() => null);
+          // What the plan does once the command is done (Ollama: restart the old server). If it could
+          // not, that is the outcome: «now runs <the old version>» would read as an update that worked.
+          const settled = result.code === 0 ? await (async () => plan.after?.())().catch((error) => ({ ok: false, error: error.message })) : null;
           const after = await module.describe(await moduleContext()).catch(() => null);
           await room.record('extension.install.finished', {
-            id: module.id, name: item.name, ok: result.code === 0, installed: Boolean(after?.version),
-            detail: result.code === 0 ? `${item.name} now runs ${after?.version ?? 'what it found'}` : (result.error ?? `exit ${result.code}`),
+            id: module.id, name: item.name, ok: result.code === 0 && settled?.ok !== false, installed: Boolean(after?.version),
+            detail: result.code !== 0 ? (result.error ?? `exit ${result.code}`)
+              : settled?.ok === false ? settled.error
+                : `${item.name} now runs ${after?.version ?? 'what it found'}`,
           });
           installing = null;
         })();
@@ -1617,6 +1656,15 @@ export async function createPulseServer({
         const stopped = await room.stopPlan(stopMatch[1]);
         return sendJson(response, stopped ? 202 : 404, stopped ? { stopped: true } : { error: t('No running plan with that id.') });
       }
+      // One line of a ```pulse-run, pressed by the human. The body names the request and the line;
+      // the command itself is read from the room's record, never from the page.
+      if (request.method === 'POST' && url.pathname === '/api/runs') {
+        const payload = await body(request).catch(() => ({}));
+        const index = Number(payload.index);
+        if (typeof payload.responseMessageId !== 'string' || !Number.isInteger(index) || index < 0) return sendJson(response, 400, { error: t('Name the request and the line to run.') });
+        const outcome = await room.runRequested({ responseMessageId: payload.responseMessageId, index });
+        return sendJson(response, outcome.status, outcome.ok ? outcome.result : { error: outcome.error });
+      }
       if (request.method === 'GET' && url.pathname === '/api/commands') {
         const ctx = await moduleContext();
         const fromModules = await Promise.all(moduleCommands().map(async (command) => {