@dreki-gg/pi-plan-mode 0.4.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @dreki-gg/pi-plan-mode
 
+## 0.5.1
+
+### Patch Changes
+
+- [`8e9aa09`](https://github.com/dreki-gg/pi-extensions/commit/8e9aa0963fe81286e9c5972f6a9d666645807f1a) Thanks [@jalbarrang](https://github.com/jalbarrang)! - fix(plan-mode): allow safe bash commands that were incorrectly blocked in plan mode
+
+  Three fixes to `isSafeCommand`:
+
+  - Allow `mkdir -p .plans/` since the planner needs to create plan directories
+  - Fix redirect pattern to not false-positive on stderr redirects like `2>/dev/null`
+  - Split piped commands and validate each segment independently, so `curl ... | grep ... | head` works correctly
+
+## 0.5.0
+
+### Minor Changes
+
+- [`32797ff`](https://github.com/dreki-gg/pi-extensions/commit/32797ff18d968e22c6c44e95c46e3393d8928cef) Thanks [@jalbarrang](https://github.com/jalbarrang)! - feat(plan-mode): add Windows compatibility — replace Unix shell commands with cross-platform Bun/Node APIs
+
+  Plan-mode no longer shells out to `cat`, `bash`, or `mkdir` via `pi.exec()`. File I/O now uses `Bun.file()` / `Bun.write()` and `node:fs/promises` `mkdir`, making the extension fully cross-platform. Destructive and safe command pattern lists now include Windows equivalents (`del`, `rd`, `copy`, `move`, `powershell`, `dir`, `where`, `tasklist`, etc.).
+
+  Also fixes Windows compatibility in three other packages:
+
+  - **browser-tools**: `spawn` now uses `shell: true` on Windows so `.cmd` wrappers resolve correctly; `shellEscape` uses double-quote style on Windows; install guidance is platform-aware (Homebrew shown only on macOS).
+  - **subagent**: `spawn` uses `shell: true` on Windows when the command is bare `pi`, allowing `pi.cmd` resolution.
+  - **lsp**: `globalConfigPath()` now uses `os.homedir()` on Windows instead of the unreliable `process.env.HOME`.
+
 ## 0.4.0
 
 ### Minor Changes

package/extensions/plan-mode/index.ts

@@ -22,6 +22,7 @@ import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { AssistantMessage, TextContent } from '@earendil-works/pi-ai';
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { Key } from '@earendil-works/pi-tui';
+import { mkdir } from 'node:fs/promises';
 import {
   extractTodoItems,
   isSafeCommand,
@@ -111,7 +112,7 @@ export default function planMode(pi: ExtensionAPI): void {
     status: 'in-progress' | 'done',
     title?: string,
   ): Promise<void> {
-    const manifest = await readPlansJson((cmd, args) => pi.exec(cmd, args));
+    const manifest = await readPlansJson();
     const existing = manifest[planName];
     const now = new Date().toISOString();
 
@@ -122,10 +123,9 @@ export default function planMode(pi: ExtensionAPI): void {
       completed: status === 'done' ? now : null,
     };
 
-    await pi.exec('mkdir', ['-p', '.plans']);
+    await mkdir('.plans', { recursive: true });
     const content = serializePlansJson(manifest);
-    // Write via a temp approach — use bash echo to avoid needing the write tool
-    await pi.exec('bash', ['-c', `cat > .plans/plans.json << 'PLANS_EOF'\n${content}PLANS_EOF`]);
+    await Bun.write('.plans/plans.json', content);
   }
 
   // ── UI updates ────────────────────────────────────────────────────────────
@@ -419,10 +419,8 @@ Execute each step in order. You MUST include [DONE:n] in your response after com
       let title = 'Untitled plan';
       if (path.endsWith('PLAN.md')) {
         try {
-          const result = await pi.exec('cat', [path]);
-          if (result.code === 0) {
-            title = extractPlanTitle(result.stdout);
-          }
+          const content = await Bun.file(path).text();
+          title = extractPlanTitle(content);
         } catch {
           // Fall through
         }
@@ -432,11 +430,9 @@ Execute each step in order. You MUST include [DONE:n] in your response after com
     } else if (match && planDir && path.endsWith('PLAN.md')) {
       // planDir already set but PLAN.md just written — update title
       try {
-        const result = await pi.exec('cat', [path]);
-        if (result.code === 0) {
-          const title = extractPlanTitle(result.stdout);
-          await updatePlansManifest(match[1], 'in-progress', title);
-        }
+        const content = await Bun.file(path).text();
+        const title = extractPlanTitle(content);
+        await updatePlansManifest(match[1], 'in-progress', title);
       } catch {
         // Fall through
       }
@@ -500,10 +496,7 @@ Execute each step in order. You MUST include [DONE:n] in your response after com
       // Read the plan to extract todos
       let planContent = '';
       try {
-        const result = await pi.exec('cat', [planMdPath]);
-        if (result.code === 0) {
-          planContent = result.stdout;
-        }
+        planContent = await Bun.file(planMdPath).text();
       } catch {
         // Fall through — will use empty plan content
       }
@@ -516,10 +509,7 @@ Execute each step in order. You MUST include [DONE:n] in your response after com
       // Read the start prompt for clean handoff
       let startPrompt = '';
       try {
-        const result = await pi.exec('cat', [startPromptPath]);
-        if (result.code === 0) {
-          startPrompt = result.stdout.trim();
-        }
+        startPrompt = (await Bun.file(startPromptPath).text()).trim();
       } catch {
         // Fall through
       }

package/extensions/plan-mode/plans-json.ts

@@ -25,12 +25,15 @@ export type PlansManifest = Record<string, PlanEntry>;
 
 const PLANS_JSON = '.plans/plans.json';
 
-/** Read plans.json via pi.exec, returning current manifest (empty object if missing). */
-export async function readPlansJson(exec: (cmd: string, args: string[]) => Promise<{ code: number; stdout: string }>): Promise<PlansManifest> {
+/** Read plans.json, returning current manifest (empty object if missing). */
+export async function readPlansJson(): Promise<PlansManifest> {
   try {
-    const result = await exec('cat', [PLANS_JSON]);
-    if (result.code === 0 && result.stdout.trim()) {
-      return JSON.parse(result.stdout) as PlansManifest;
+    const file = Bun.file(PLANS_JSON);
+    if (await file.exists()) {
+      const text = await file.text();
+      if (text.trim()) {
+        return JSON.parse(text) as PlansManifest;
+      }
     }
   } catch {
     // File doesn't exist or isn't valid JSON

package/extensions/plan-mode/utils.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from 'bun:test';
+import { isSafeCommand } from './utils.js';
+
+describe('isSafeCommand', () => {
+  // ── Commands that SHOULD be allowed ──────────────────────────────────────
+  describe('allowed commands', () => {
+    test('mkdir -p .plans/<name>', () => {
+      expect(isSafeCommand('mkdir -p .plans/monorepo-src-migration')).toBe(true);
+    });
+
+    test('mkdir .plans/<name>', () => {
+      expect(isSafeCommand('mkdir .plans/my-plan')).toBe(true);
+    });
+
+    test('curl with 2>/dev/null pipe chain', () => {
+      expect(
+        isSafeCommand(
+          `curl -sL "https://effect.website/docs/platform/introduction/" 2>/dev/null | grep -oP '(?<=href=")[^"]*' | grep -iE "(http|server|rpc)" | head -20`,
+        ),
+      ).toBe(true);
+    });
+
+    test('curl with 2>/dev/null simple', () => {
+      expect(
+        isSafeCommand(
+          `curl -s "https://raw.githubusercontent.com/Effect-TS/effect/main/packages/platform/README.md" 2>/dev/null | head -100`,
+        ),
+      ).toBe(true);
+    });
+
+    test('simple ls', () => {
+      expect(isSafeCommand('ls -la')).toBe(true);
+    });
+
+    test('git status', () => {
+      expect(isSafeCommand('git status')).toBe(true);
+    });
+
+    test('git log', () => {
+      expect(isSafeCommand('git log --oneline -10')).toBe(true);
+    });
+
+    test('find piped to grep', () => {
+      expect(isSafeCommand('find . -name "*.ts" | grep -v node_modules')).toBe(true);
+    });
+
+    test('cat piped to head', () => {
+      expect(isSafeCommand('cat README.md | head -50')).toBe(true);
+    });
+
+    test('rg (ripgrep)', () => {
+      expect(isSafeCommand('rg "pattern" src/')).toBe(true);
+    });
+
+    test('grep with context', () => {
+      expect(isSafeCommand('grep -rn "export" src/ | head -20')).toBe(true);
+    });
+
+    test('npm list', () => {
+      expect(isSafeCommand('npm list --depth=0')).toBe(true);
+    });
+
+    test('curl piped to jq', () => {
+      expect(isSafeCommand('curl -s https://api.example.com | jq .name')).toBe(true);
+    });
+  });
+
+  // ── Commands that SHOULD be blocked ──────────────────────────────────────
+  describe('blocked commands', () => {
+    test('rm -rf', () => {
+      expect(isSafeCommand('rm -rf node_modules')).toBe(false);
+    });
+
+    test('mkdir outside .plans/', () => {
+      expect(isSafeCommand('mkdir -p src/new-dir')).toBe(false);
+    });
+
+    test('stdout redirect to file', () => {
+      expect(isSafeCommand('echo "hello" > file.txt')).toBe(false);
+    });
+
+    test('append redirect', () => {
+      expect(isSafeCommand('echo "hello" >> file.txt')).toBe(false);
+    });
+
+    test('git commit', () => {
+      expect(isSafeCommand('git commit -m "test"')).toBe(false);
+    });
+
+    test('npm install', () => {
+      expect(isSafeCommand('npm install lodash')).toBe(false);
+    });
+
+    test('mv file', () => {
+      expect(isSafeCommand('mv old.ts new.ts')).toBe(false);
+    });
+
+    test('sudo anything', () => {
+      expect(isSafeCommand('sudo ls')).toBe(false);
+    });
+
+    test('cp file', () => {
+      expect(isSafeCommand('cp a.ts b.ts')).toBe(false);
+    });
+
+    test('touch file', () => {
+      expect(isSafeCommand('touch newfile.ts')).toBe(false);
+    });
+  });
+});

package/extensions/plan-mode/utils.ts

@@ -24,7 +24,8 @@ const DESTRUCTIVE_PATTERNS = [
   /\btruncate\b/i,
   /\bdd\b/i,
   /\bshred\b/i,
-  /(^|[^<])>(?!>)/,
+  // stdout redirect — but NOT stderr redirects like 2>/dev/null or 2>&1
+  /(?<!\d)>(?!>|&)/,
   />>/,
   /\bnpm\s+(install|uninstall|update|ci|link|publish)/i,
   /\byarn\s+(add|remove|install|publish)/i,
@@ -43,6 +44,17 @@ const DESTRUCTIVE_PATTERNS = [
   /\bsystemctl\s+(start|stop|restart|enable|disable)/i,
   /\bservice\s+\S+\s+(start|stop|restart)/i,
   /\b(vim?|nano|emacs|code|subl)\b/i,
+  // Windows equivalents
+  /\bdel\b/i,
+  /\brd\b/i,
+  /\bcopy\b/i,
+  /\bmove\b/i,
+  /\bren\b/i,
+  /\brename\b/i,
+  /\bicacls\b/i,
+  /\battrib\b/i,
+  /\bpowershell\b/i,
+  /\bpwsh\b/i,
 ];
 
 // ── Safe read-only bash patterns (allowed in plan mode) ─────────────────────
@@ -98,12 +110,78 @@ const SAFE_PATTERNS = [
   /^\s*fd\b/,
   /^\s*bat\b/,
   /^\s*eza\b/,
+  // Windows equivalents
+  /^\s*dir\b/,
+  /^\s*where\b/,
+  /^\s*set\b/,
+  /^\s*systeminfo\b/,
+  /^\s*tasklist\b/,
 ];
 
+/**
+ * Check if a command is safe for plan mode.
+ *
+ * For simple commands, checks that the command starts with a safe pattern and
+ * doesn't contain destructive patterns. For piped commands, each segment is
+ * checked individually. Special exceptions allow `mkdir -p` for `.plans/` paths.
+ */
 export function isSafeCommand(command: string): boolean {
-  const isDestructive = DESTRUCTIVE_PATTERNS.some((p) => p.test(command));
-  const isSafe = SAFE_PATTERNS.some((p) => p.test(command));
-  return !isDestructive && isSafe;
+  // Special case: allow mkdir for .plans/ directory (planner needs this)
+  if (/^\s*mkdir\s+(-p\s+)?\.plans(\/|\\|\s|$)/.test(command)) {
+    return true;
+  }
+
+  // Split piped commands and check each segment independently
+  const segments = splitPipeSegments(command);
+  return segments.every((seg) => {
+    const trimmed = seg.trim();
+    const isDestructive = DESTRUCTIVE_PATTERNS.some((p) => p.test(trimmed));
+    const isSafe = SAFE_PATTERNS.some((p) => p.test(trimmed));
+    return !isDestructive && isSafe;
+  });
+}
+
+/**
+ * Split a command on unquoted pipe (`|`) characters.
+ * Respects single/double quotes and escaped characters.
+ */
+function splitPipeSegments(command: string): string[] {
+  const segments: string[] = [];
+  let current = '';
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+
+  for (const ch of command) {
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === '\\') {
+      current += ch;
+      escaped = true;
+      continue;
+    }
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (ch === '|' && !inSingle && !inDouble) {
+      segments.push(current);
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+  if (current) segments.push(current);
+  return segments;
 }
 
 // ── Plan extraction ─────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-plan-mode",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Two-phase planning workflow for pi — plan with claude-opus-4-6:medium, execute with gpt-5.5:low, with .plans/ file-based handoff",
   "keywords": [
     "pi-package"
@@ -36,6 +36,7 @@
   },
   "devDependencies": {
     "@types/node": "24",
+    "bun-types": "latest",
     "oxfmt": "^0.43.0",
     "oxlint": "^1.58.0",
     "typescript": "^6.0.0"