@parallel-cli/parallel 0.4.1 → 0.4.4

package/dist/agents/tools.js

@@ -4,6 +4,19 @@ import { exec } from 'node:child_process';
 import * as Diff from 'diff';
 const IGNORED = new Set(['node_modules', '.git', '.parallel', 'dist', '__pycache__', '.venv', 'venv']);
 const MAX_OUTPUT = 12_000;
+const MUTATING_TOOLS = new Set(['write_file', 'edit_file', 'claim_files', 'remember']);
+function isMutatingShell(command) {
+    const c = command.toLowerCase();
+    if (/\b(rm|mv|cp|chmod|chown|mkdir|touch|truncate)\b/.test(c))
+        return true;
+    if (/\b(git\s+(add|commit|push|pull|merge|rebase|checkout|switch|reset|clean|stash|tag))\b/.test(c))
+        return true;
+    if (/\b(npm|pnpm|yarn)\s+(install|add|remove|update|audit\s+fix)\b/.test(c))
+        return true;
+    if (/[>|]\s*(sh|bash)\b/.test(c) || /\b(curl|wget)\b.*\|\s*(sh|bash)/.test(c))
+        return true;
+    return false;
+}
 export const TOOL_DEFINITIONS = [
     {
         type: 'function',
@@ -228,11 +241,13 @@ export class ToolExecutor {
     requestApproval;
     requestQuestion;
     skills;
+    mode;
     /** Last content this agent has seen for each file — basis of adaptive merging. */
     lastRead = new Map();
     /** Questions already asked — capped at 3 per task. */
     questionsAsked = 0;
-    constructor(board, agentId, agentName, projectRoot, requestApproval, requestQuestion, skills) {
+    planApproved = false;
+    constructor(board, agentId, agentName, projectRoot, requestApproval, requestQuestion, skills, mode = 'task') {
         this.board = board;
         this.agentId = agentId;
         this.agentName = agentName;
@@ -240,10 +255,13 @@ export class ToolExecutor {
         this.requestApproval = requestApproval;
         this.requestQuestion = requestQuestion;
         this.skills = skills;
+        this.mode = mode;
     }
     resolve(rel) {
-        const abs = path.resolve(this.projectRoot, rel);
-        if (!abs.startsWith(path.resolve(this.projectRoot))) {
+        const root = path.resolve(this.projectRoot);
+        const abs = path.resolve(root, rel);
+        const relative = path.relative(root, abs);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
             throw new Error(`Path outside the project refused: ${rel}`);
         }
         return abs;
@@ -253,6 +271,9 @@ export class ToolExecutor {
     }
     async execute(name, args) {
         try {
+            const guard = this.guardTool(name, args);
+            if (guard)
+                return guard;
             switch (name) {
                 case 'list_files':
                     return this.listFiles(args?.path ?? '.');
@@ -293,6 +314,22 @@ export class ToolExecutor {
             return `ERROR: ${err?.message ?? String(err)}`;
         }
     }
+    guardTool(name, args) {
+        if (this.mode === 'ask') {
+            if (MUTATING_TOOLS.has(name) || name === 'run_command') {
+                return `DENIED: this agent is in /ask mode. It can inspect and advise, but cannot modify files, run shell commands, claim files, or write memory.`;
+            }
+        }
+        if (this.mode === 'plan' && !this.planApproved) {
+            if (MUTATING_TOOLS.has(name)) {
+                return `DENIED: this agent is in /plan mode and the plan has not been approved yet. Present the plan with ask_user and wait for "Approve" before modifying project state.`;
+            }
+            if (name === 'run_command' && isMutatingShell(String(args?.command ?? ''))) {
+                return `DENIED: this shell command looks mutating. In /plan mode, run only read-only inspection before approval; ask_user for plan approval first.`;
+            }
+        }
+        return null;
+    }
     /**
      * Ask the user a multiple-choice question. NEVER blocks forever: the UI shows
      * a visible 30s countdown and falls back to the recommended option (auto-run).
@@ -312,9 +349,14 @@ export class ToolExecutor {
         this.questionsAsked++;
         this.board.setAgentState(this.agentId, 'waiting', `question: ${question.slice(0, 60)}`);
         this.board.log(this.agentId, 'note', `❓ ${question}`);
-        const answer = await this.requestQuestion(this.agentId, question, options, recommended);
+        const response = await this.requestQuestion(this.agentId, question, options, recommended);
+        const answer = response.answer;
+        if (this.mode === 'plan' && !response.auto && answer.trim().toLowerCase().startsWith('approve')) {
+            this.planApproved = true;
+        }
         this.board.setAgentState(this.agentId, 'working');
-        return `The user answered: "${answer}". Act on this choice now (${3 - this.questionsAsked} question(s) left for this task).`;
+        const source = response.auto ? 'The timeout auto-selected' : 'The user answered';
+        return `${source}: "${answer}". Act on this choice now (${3 - this.questionsAsked} question(s) left for this task).`;
     }
     /** Declare (advisory) work areas — visible to the user and the other agents. */
     claimFiles(args) {

package/dist/commands.js

@@ -1,5 +1,9 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { Controller, normalizeShellApprovalMode } from './controller.js';
 import { createSkillTemplate, createSpecialistTemplate } from './skills.js';
+import { isLocalProvider, isPlaceholderModel, providerNeedsApiKey } from './config.js';
 import { t } from './i18n.js';
 // Grouped by intent so /help reads as a story: create agents → steer them →
 // inspect the session → git safety net → session & config → exit.
@@ -41,11 +45,13 @@ export const COMMANDS = [
     { name: '/restore', args: '<agent>', descKey: 'cmd.restore', group: 'git' },
     // config
     { name: '/model', args: '[[provider:]model]', descKey: 'cmd.model', group: 'settings' },
-    { name: '/key', args: '<key>', descKey: 'cmd.key', group: 'settings' },
+    { name: '/key', args: '<key>', descKey: 'cmd.key', group: 'settings', hidden: true },
     { name: '/approvals', args: '<ask|auto|auto-safe|yolo>', descKey: 'cmd.approvals', group: 'settings' },
     { name: '/sound', args: '<on|off>', descKey: 'cmd.sound', group: 'settings' },
     { name: '/settings', args: '', descKey: 'cmd.settings', group: 'settings' },
     { name: '/settings-session', args: '', descKey: 'cmd.ssettings', group: 'settings', aliases: ['/ssettings'] },
+    { name: '/project', args: '[folder]', descKey: 'cmd.project', group: 'settings', aliases: ['/folder'] },
+    { name: '/wizard', args: '', descKey: 'cmd.wizard', group: 'settings', aliases: ['/setup'] },
     { name: '/doctor', args: '', descKey: 'cmd.doctor', group: 'settings' },
     // exit
     { name: '/help', args: '', descKey: 'cmd.help', group: 'other' },
@@ -63,6 +69,72 @@ export function matchCommands(input, opts = {}) {
 function agentList(ctl) {
     return [...ctl.board.agents.values()].map((a) => a.name).join(', ') || t('m.none');
 }
+function commandExists(name) {
+    try {
+        execFileSync('which', [name], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function localEndpointReachable(baseUrl) {
+    let timeout;
+    try {
+        const controller = new AbortController();
+        timeout = setTimeout(() => controller.abort(), 1500);
+        const resp = await fetch(baseUrl.replace(/\/+$/, '') + '/models', { signal: controller.signal });
+        return resp.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+async function doctorReport(ctl, ui) {
+    const p = ctl.sessionProvider();
+    const lines = [];
+    let level = 'ok';
+    if (!p) {
+        ui.system(t('m.doctorReport', { lines: t('m.doctorNoProvider') }), 'error');
+        return;
+    }
+    const activeModel = ctl.session.model || p.defaultModel || p.models[0] || '';
+    lines.push(t('m.doctorProvider', { provider: p.name, model: activeModel || '—' }));
+    if (providerNeedsApiKey(p) && !p.apiKey) {
+        level = 'error';
+        lines.push(t('m.doctorKeyMissing'));
+    }
+    else {
+        lines.push(providerNeedsApiKey(p) ? t('m.doctorKeyOk') : t('m.doctorKeySkipped'));
+    }
+    if (isPlaceholderModel(activeModel)) {
+        level = 'error';
+        lines.push(t('m.doctorModelMissing'));
+    }
+    else {
+        lines.push(t('m.doctorModelOk', { model: activeModel }));
+    }
+    if (isLocalProvider(p)) {
+        const reachable = await localEndpointReachable(p.baseUrl);
+        if (reachable) {
+            lines.push(t('m.doctorEndpointOk', { url: p.baseUrl }));
+        }
+        else {
+            if (level !== 'error')
+                level = 'warn';
+            lines.push(t('m.doctorEndpointFail', { url: p.baseUrl }));
+        }
+    }
+    const sock = path.join(ctl.projectRoot, '.parallel', 'session.sock');
+    lines.push(fs.existsSync(sock) ? t('m.doctorAttachOk') : t('m.doctorAttachMissing'));
+    lines.push(commandExists('git') ? t('m.doctorGitOk') : t('m.doctorGitMissing'));
+    lines.push(commandExists('gh') ? t('m.doctorGhOk') : t('m.doctorGhMissing'));
+    ui.system(t('m.doctorReport', { lines: lines.join('\n') }), level);
+}
 /**
  * Single-agent ergonomics: when the session has exactly ONE agent, commands
  * that target an agent (/undo, /focus, /pause…) work without naming it.
@@ -75,10 +147,12 @@ function spawnFrom(arg, ctl, ui, images, specialist, mode = 'task') {
     const p = ctl.sessionProvider();
     if (!p)
         return ui.system(t('m.missingProvider'), 'error');
-    if (!p.apiKey)
+    if (providerNeedsApiKey(p) && !p.apiKey)
         return ui.system(t('m.missingKey', { name: p.name }), 'error');
-    if (!ctl.session.model && !p.defaultModel && !p.models[0])
+    const activeModel = ctl.session.model || p.defaultModel || p.models[0] || '';
+    if (isPlaceholderModel(activeModel)) {
         return ui.system(t('m.missingModel', { name: p.name }), 'error');
+    }
     // optional --model=xxx flag
     let model;
     let task = arg;
@@ -126,8 +200,8 @@ export function executeInput(raw, ctl, ui, images) {
             return ui.system(t('m.usageAt'), 'warn');
         const [, target, content] = m;
         if (target.toLowerCase() === 'all') {
-            ctl.broadcast(content);
-            ui.system(t('m.broadcast'), 'ok');
+            const n = ctl.broadcast(content);
+            ui.system(t('m.broadcast', { n }), n > 0 ? 'ok' : 'warn');
         }
         else if (ctl.sendToAgent(target, content)) {
             ui.system(t('m.sent', { target }), 'ok');
@@ -155,7 +229,11 @@ export function executeInput(raw, ctl, ui, images) {
                     ? '/settings-session'
                     : rawCmd.toLowerCase() === '/exit'
                         ? '/quit'
-                        : rawCmd;
+                        : rawCmd.toLowerCase() === '/folder'
+                            ? '/project'
+                            : rawCmd.toLowerCase() === '/setup'
+                                ? '/wizard'
+                                : rawCmd;
     const arg = rest.join(' ').trim();
     switch (cmd.toLowerCase()) {
         case '/ask': {
@@ -210,10 +288,18 @@ export function executeInput(raw, ctl, ui, images) {
         case '/commit': {
             // Commit the files touched by one agent (or all) — staged by explicit path.
             const [target0, ...msg] = rest;
-            const target = target0 || soloAgent(ctl);
+            const solo = soloAgent(ctl);
+            const target = target0 && (target0.toLowerCase() === 'all' || ctl.board.getAgentByName(target0))
+                ? target0
+                : target0 && solo
+                    ? solo
+                    : target0 || solo;
+            const message = target0 && target === solo && target0.toLowerCase() !== solo?.toLowerCase() && !ctl.board.getAgentByName(target0)
+                ? rest.join(' ').trim()
+                : msg.join(' ').trim();
             if (!target)
                 return ui.system(t('m.usageCommit'), 'warn');
-            const r = ctl.commitFor(target, msg.join(' ').trim() || undefined);
+            const r = ctl.commitFor(target, message || undefined);
             if (r.ok)
                 return ui.system(t('m.committed', { name: target, files: String(r.files) }), 'ok');
             if (r.reason === 'not-found')
@@ -242,15 +328,19 @@ export function executeInput(raw, ctl, ui, images) {
                 ui.setView('sessions');
                 return;
             }
+            const force = rest.includes('--force');
+            const selector = rest.filter((part) => part !== '--force').join(' ').trim();
             const sessions = Controller.listSessions(ctl.projectRoot);
             if (sessions.length === 0)
                 return ui.system(t('m.usageSession'), 'warn');
-            const idx = arg.toLowerCase() === 'latest' ? 0 : Number.parseInt(arg, 10) - 1;
+            const idx = selector.toLowerCase() === 'latest' ? 0 : Number.parseInt(selector, 10) - 1;
             const session = sessions[idx];
             if (!session)
                 return ui.system(t('m.usageSession'), 'warn');
+            if (ctl.hasRunningAgents() && !force)
+                return ui.system(t('m.sessionActive'), 'warn');
             ctl.loadSession(session.data);
-            ui.system(t('m.sessionLoaded', { date: new Date(session.data.savedAt).toLocaleString() }), 'ok');
+            ui.system(t('m.sessionLoaded', { date: new Date(session.data.savedAt).toLocaleString() }) + '\n' + t('m.sessionRestoreHint'), 'ok');
             return;
         }
         case '/restore': {
@@ -260,6 +350,8 @@ export function executeInput(raw, ctl, ui, images) {
             if (!ctl.loadedSession)
                 return ui.system(t('m.usageSession'), 'warn');
             const res = ctl.respawnAgent(arg);
+            if (res === 'no-agent')
+                return ui.system(t('m.noRestoredAgent', { name: arg }), 'error');
             if (res === 'no-conversation')
                 return ui.system(t('m.noConversation', { name: arg }), 'error');
             if (!res)
@@ -308,14 +400,7 @@ export function executeInput(raw, ctl, ui, images) {
             return;
         }
         case '/doctor': {
-            const p = ctl.sessionProvider();
-            if (!p)
-                return ui.system(t('m.missingProvider'), 'error');
-            if (!p.apiKey)
-                return ui.system(t('m.missingKey', { name: p.name }), 'error');
-            if (!ctl.session.model && !p.defaultModel && !p.models[0])
-                return ui.system(t('m.missingModel', { name: p.name }), 'error');
-            ui.system(t('m.doctorOk', { pm: `${p.name}:${ctl.session.model || p.defaultModel || p.models[0]}` }), 'ok');
+            void doctorReport(ctl, ui);
             return;
         }
         case '/cost':
@@ -468,6 +553,20 @@ export function executeInput(raw, ctl, ui, images) {
         case '/settings-session':
             ui.setView('settings-session');
             return;
+        case '/project':
+            {
+                const force = rest.includes('--force');
+                const folderArg = rest.filter((part) => part !== '--force').join(' ').trim();
+                if (ctl.hasRunningAgents() && !force)
+                    return ui.system(t('m.projectActive'), 'warn');
+                ui.openProject?.(folderArg || undefined);
+            }
+            return;
+        case '/wizard':
+            if (ctl.hasRunningAgents() && arg !== '--force')
+                return ui.system(t('m.wizardActive'), 'warn');
+            ui.openWizard?.();
+            return;
         // SESSION-only approvals & sound (global defaults editable in /settings).
         case '/approvals': {
             const mode = normalizeShellApprovalMode(arg);