supipowers 1.2.6 → 1.5.0

package/src/context-mode/routing.ts

@@ -7,7 +7,13 @@ const HTTP_PATTERNS = [
   /^\s*wget\s/,
   /\bcurl\s+(-[a-zA-Z]*\s+)*https?:\/\//,
   /\bwget\s+(-[a-zA-Z]*\s+)*https?:\/\//,
-];
+  // Inline HTTP patterns
+  /\bfetch\s*\(/,
+  /\brequests\.(get|post|put|delete|patch)\s*\(/,
+  /\bhttp\.(get|request)\s*\(/,
+  /\burllib\.request/,
+  /\bInvoke-WebRequest/,
+]; 
 
 /** Bash commands that are search/find operations */
 const BASH_SEARCH_PATTERNS = [
@@ -41,10 +47,10 @@ export function isBashSearchCommand(command: unknown): boolean {
   return BASH_SEARCH_PATTERNS.some((p) => p.test(command));
 }
 
-/** Check if a Read call is a full-file read (no limit/offset = likely analysis, not edit prep) */
+/** Check if a Read call is a full-file read (no limit/offset/sel = likely analysis, not edit prep) */
 export function isFullFileRead(input: Record<string, unknown> | undefined): boolean {
   if (!input) return true;
-  return input.limit == null && input.offset == null;
+  return input.limit == null && input.offset == null && input.sel == null;
 }
 
 /** Block result returned by routing functions */
@@ -57,14 +63,13 @@ export interface BlockResult {
 export function routeToolCall(
   toolName: string,
   input: Record<string, unknown> | undefined,
-  status: ContextModeStatus,
+  _status: ContextModeStatus,
   options: { enforceRouting: boolean; blockHttpCommands: boolean },
 ): BlockResult | undefined {
-  if (!status.available) return undefined;
+  // Native tools are always available — no availability check needed.
 
   // Grep → block, redirect to ctx_search
   if (options.enforceRouting && toolName === "grep") {
-    if (!status.tools.ctxSearch) return undefined;
     return {
       block: true,
       reason:
@@ -75,7 +80,6 @@ export function routeToolCall(
 
   // Find/Glob → block, redirect to ctx_execute or ctx_batch_execute
   if (options.enforceRouting && toolName === "find") {
-    if (!status.tools.ctxExecute) return undefined;
     return {
       block: true,
       reason:
@@ -86,7 +90,6 @@ export function routeToolCall(
 
   // Fetch/WebFetch → block, redirect to ctx_fetch_and_index
   if (toolName === "fetch" || toolName === "web_fetch") {
-    if (!status.tools.ctxFetchAndIndex) return undefined;
     return {
       block: true,
       reason:
@@ -95,25 +98,12 @@ export function routeToolCall(
     };
   }
 
-  // Read (full-file, no limit/offset) → block, redirect to ctx_execute_file
-  if (options.enforceRouting && toolName === "read") {
-    if (!status.tools.ctxExecuteFile) return undefined;
-    if (!isFullFileRead(input)) return undefined;
-    return {
-      block: true,
-      reason:
-        "Use ctx_execute_file(path, language, code) for file analysis instead of Read. " +
-        "If you need to Read before editing, re-call with a limit parameter.",
-    };
-  }
-
   // Bash routing
   if (toolName === "bash") {
     const command = input?.command;
 
     // Bash search commands → block, redirect to ctx_execute
     if (options.enforceRouting && isBashSearchCommand(command)) {
-      if (!status.tools.ctxExecute) return undefined;
       return {
         block: true,
         reason:
@@ -124,7 +114,6 @@ export function routeToolCall(
 
     // Bash HTTP commands → block, redirect to ctx_fetch_and_index
     if (options.blockHttpCommands && isHttpCommand(command)) {
-      if (!status.tools.ctxFetchAndIndex) return undefined;
       return {
         block: true,
         reason:
@@ -135,4 +124,4 @@ export function routeToolCall(
   }
 
   return undefined;
-}
+}

package/src/context-mode/sandbox/executor.ts

@@ -0,0 +1,183 @@
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import { getRunner } from "./runners.js";
+
+export interface ExecuteOptions {
+  timeout?: number;
+  background?: boolean;
+  cwd?: string;
+  env?: Record<string, string>;
+}
+
+export interface ExecuteResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  duration: number;
+}
+
+const DEFAULT_TIMEOUT = 30_000;
+
+export async function executeCode(
+  language: string,
+  code: string,
+  options?: ExecuteOptions,
+): Promise<ExecuteResult> {
+  const runner = getRunner(language);
+  const opts = options ?? {};
+  const timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+  const cwd = opts.cwd ?? process.cwd();
+
+  const id = randomUUID();
+  const srcPath = path.join(os.tmpdir(), `ctx-exec-${id}${runner.fileExt}`);
+  const outPath = runner.needsCompile
+    ? path.join(os.tmpdir(), `ctx-exec-${id}`)
+    : undefined;
+
+  fs.writeFileSync(srcPath, code);
+  const start = performance.now();
+
+  try {
+    // Compile step for compiled languages
+    if (runner.needsCompile && runner.compileCmd && outPath) {
+      const compileArgs = runner.compileCmd(srcPath, outPath);
+      const compileProc = Bun.spawn(compileArgs, {
+        stdout: "pipe",
+        stderr: "pipe",
+        cwd,
+      });
+      const [compStdout, compStderr] = await Promise.all([
+        new Response(compileProc.stdout).text(),
+        new Response(compileProc.stderr).text(),
+      ]);
+      const compileExit = await compileProc.exited;
+      if (compileExit !== 0) {
+        return {
+          stdout: compStdout,
+          stderr: compStderr,
+          exitCode: compileExit,
+          duration: performance.now() - start,
+        };
+      }
+    }
+
+    const execPath = outPath ?? srcPath;
+    const args = runner.needsCompile ? [execPath] : [...runner.binary, execPath];
+
+    const proc = Bun.spawn(args, {
+      stdout: "pipe",
+      stderr: "pipe",
+      cwd,
+      env: { ...process.env, ...opts.env },
+    });
+
+    if (opts.background) {
+      // Wait up to timeout collecting partial output, then return without killing
+      const partial = await collectWithTimeout(proc, timeout);
+      return {
+        stdout: partial.stdout,
+        stderr: partial.stderr,
+        exitCode: 0,
+        duration: performance.now() - start,
+      };
+    }
+
+    // Foreground: enforce hard timeout
+    const result = await raceTimeout(proc, timeout);
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode,
+      duration: performance.now() - start,
+    };
+  } finally {
+    cleanup(srcPath);
+    if (outPath) cleanup(outPath);
+  }
+}
+
+/** Race process completion against a timeout. Kills on timeout. */
+async function raceTimeout(
+  proc: ReturnType<typeof Bun.spawn>,
+  timeout: number,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  // Start reading streams immediately — they can only be consumed once
+  const stdoutP = new Response(proc.stdout as ReadableStream<Uint8Array> | undefined).text();
+  const stderrP = new Response(proc.stderr as ReadableStream<Uint8Array> | undefined).text();
+
+  const timedOut = await Promise.race([
+    proc.exited.then(() => false),
+    new Promise<boolean>((r) => setTimeout(() => r(true), timeout)),
+  ]);
+
+  if (timedOut) {
+    proc.kill("SIGKILL");
+    await proc.exited;
+  }
+
+  const [stdout, stderr] = await Promise.all([stdoutP, stderrP]);
+
+  if (timedOut) {
+    return {
+      stdout,
+      stderr: stderr + `\n[Timeout after ${timeout}ms]`,
+      exitCode: 124,
+    };
+  }
+
+  return { stdout, stderr, exitCode: await proc.exited };
+}
+
+/** Collect output for up to `ms` milliseconds without killing. */
+async function collectWithTimeout(
+  proc: ReturnType<typeof Bun.spawn>,
+  ms: number,
+): Promise<{ stdout: string; stderr: string }> {
+  const chunks: { out: string[]; err: string[] } = { out: [], err: [] };
+  const decoder = new TextDecoder();
+
+  const readStream = async (
+    stream: ReadableStream<Uint8Array>,
+    bucket: string[],
+  ) => {
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        bucket.push(decoder.decode(value, { stream: true }));
+      }
+    } catch {
+      // Stream may error when we cancel — that's fine
+    } finally {
+      reader.releaseLock();
+    }
+  };
+
+  // Start reading both streams
+  const outP = readStream(proc.stdout as ReadableStream<Uint8Array>, chunks.out);
+  const errP = readStream(proc.stderr as ReadableStream<Uint8Array>, chunks.err);
+
+  // Wait for timeout, then return whatever we have
+  await Promise.race([
+    Promise.all([outP, errP]),
+    new Promise<void>((r) => setTimeout(r, ms)),
+  ]);
+
+  // proc.unref() is not available on Bun.spawn, but the process
+  // continues running since we never kill it.
+  return {
+    stdout: chunks.out.join(""),
+    stderr: chunks.err.join(""),
+  };
+}
+
+function cleanup(filePath: string): void {
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+    // Ignore — file may already be gone
+  }
+}

package/src/context-mode/sandbox/runners.ts

@@ -0,0 +1,40 @@
+export interface LanguageRunner {
+  binary: string[];
+  fileExt: string;
+  needsCompile?: boolean;
+  compileCmd?: (srcPath: string, outPath: string) => string[];
+}
+
+const RUNNERS: Record<string, LanguageRunner> = {
+  javascript: { binary: ["bun", "run"], fileExt: ".js" },
+  typescript: { binary: ["bun", "run"], fileExt: ".ts" },
+  python: { binary: ["python3"], fileExt: ".py" },
+  shell: { binary: ["bash"], fileExt: ".sh" },
+  ruby: { binary: ["ruby"], fileExt: ".rb" },
+  go: { binary: ["go", "run"], fileExt: ".go" },
+  rust: {
+    binary: ["rustc"],
+    fileExt: ".rs",
+    needsCompile: true,
+    compileCmd: (src, out) => ["rustc", src, "-o", out],
+  },
+  php: { binary: ["php"], fileExt: ".php" },
+  perl: { binary: ["perl"], fileExt: ".pl" },
+  r: { binary: ["Rscript"], fileExt: ".R" },
+  elixir: { binary: ["elixir"], fileExt: ".exs" },
+};
+
+export function getRunner(language: string): LanguageRunner {
+  const runner = RUNNERS[language];
+  if (!runner) {
+    const supported = getSupportedLanguages().join(", ");
+    throw new Error(
+      `Unsupported language: "${language}". Supported: ${supported}`,
+    );
+  }
+  return runner;
+}
+
+export function getSupportedLanguages(): string[] {
+  return Object.keys(RUNNERS).sort();
+}

package/src/context-mode/snapshot-builder.ts

@@ -9,19 +9,255 @@ const CAPS = {
   git: 5,
 };
 
+/** Escape all 5 XML special characters in user data */
+function escapeXML(str: string): string {
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+interface SnapshotOpts {
+  compactCount?: number;
+  searchTool?: string;
+  searchAvailable?: boolean;
+}
+
 /** Build a resume snapshot from tracked events for a session */
-export function buildResumeSnapshot(eventStore: EventStore, sessionId: string): string {
+export function buildResumeSnapshot(
+  eventStore: EventStore,
+  sessionId: string,
+  opts?: SnapshotOpts,
+): string {
   const counts = eventStore.getEventCounts(sessionId);
   const hasAnyEvents = Object.values(counts).some((c) => c > 0);
   if (!hasAnyEvents) return "";
 
+  if (opts?.searchAvailable) {
+    return buildReferenceSnapshot(eventStore, sessionId, opts);
+  }
+  return buildFallbackSnapshot(eventStore, sessionId);
+}
+
+// ---------------------------------------------------------------------------
+// Reference-based format (supi-context-mode MCP available)
+// ---------------------------------------------------------------------------
+
+function buildReferenceSnapshot(eventStore: EventStore, sessionId: string, opts: SnapshotOpts): string {
+  const compactCount = opts.compactCount ?? 0;
+  const now = new Date().toISOString();
+  const sections: string[] = [
+    `<session_knowledge compact_count="${compactCount}" generated_at="${escapeXML(now)}">`,
+    "  <how_to_search>",
+    "  Each section below contains a summary of prior work.",
+    "  For FULL DETAILS, run the exact tool call shown under each section.",
+    "  Do NOT ask the user to re-explain prior work. Search first.",
+    "  </how_to_search>",
+  ];
+
+  let hasSections = false;
+
+  // --- rules ---
+  const ruleEvents = eventStore.getEvents(sessionId, { categories: ["rule"] });
+  if (ruleEvents.length > 0) {
+    const files = new Set<string>();
+    for (const r of ruleEvents) {
+      const data = safeParse(r.data);
+      const file = typeof data?.file === "string" ? data.file : typeof data?.path === "string" ? data.path : null;
+      if (file) files.add(file);
+    }
+    if (files.size > 0) {
+      const fileList = [...files];
+      sections.push("");
+      sections.push(`  <rules>`);
+      sections.push(`    Loaded ${fileList.length} project rule files: ${fileList.map(escapeXML).join(", ")}`);
+      sections.push(`    For full details:`);
+      sections.push(`    ctx_search(queries: [${fileList.map((f) => `"${escapeXML(f)}"`).join(", ")}], source: "session-events")`);
+      sections.push(`  </rules>`);
+      hasSections = true;
+    }
+  }
+
+  // --- files ---
+  const fileEvents = eventStore.getEvents(sessionId, { categories: ["file"], limit: 200 });
+  if (fileEvents.length > 0) {
+    const edited = new Set<string>();
+    const read = new Set<string>();
+    for (const f of fileEvents) {
+      const data = safeParse(f.data);
+      const p = typeof data?.path === "string" ? data.path : null;
+      if (!p) continue;
+      if (data?.op === "edit" || data?.op === "write") edited.add(p);
+      else if (data?.op === "read") read.add(p);
+    }
+    if (edited.size > 0 || read.size > 0) {
+      sections.push("");
+      sections.push(`  <files count="${edited.size + read.size}">`);
+      if (edited.size > 0) sections.push(`    Edited: ${[...edited].map(escapeXML).join(", ")}`);
+      if (read.size > 0) sections.push(`    Read: ${[...read].map(escapeXML).join(", ")}`);
+      const queryPaths = [...edited, ...read].slice(0, 5);
+      sections.push(`    For full details:`);
+      sections.push(`    ctx_search(queries: [${queryPaths.map((p) => `"${escapeXML(p)}"`).join(", ")}], source: "session-events")`);
+      sections.push(`  </files>`);
+      hasSections = true;
+    }
+  }
+
+  // --- tasks ---
+  const tasks = eventStore.getEvents(sessionId, { categories: ["task"], limit: CAPS.tasks });
+  if (tasks.length > 0) {
+    const summaries: string[] = [];
+    for (const t of tasks) {
+      const data = safeParse(t.data);
+      const content = extractTaskContent(data);
+      if (content) summaries.push(escapeXML(content.slice(0, 100)));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <tasks>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`    For full details:`);
+      sections.push(`    ctx_search(queries: ["task", "todo"], source: "session-events")`);
+      sections.push(`  </tasks>`);
+      hasSections = true;
+    }
+  }
+
+  // --- decisions ---
+  const decisions = eventStore.getEvents(sessionId, { categories: ["decision"], limit: CAPS.decisions });
+  if (decisions.length > 0) {
+    const summaries: string[] = [];
+    for (const d of decisions) {
+      const data = safeParse(d.data);
+      const prompt = typeof data?.prompt === "string" ? data.prompt.slice(0, 100) : "";
+      if (prompt) summaries.push(escapeXML(prompt));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <decisions>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`  </decisions>`);
+      hasSections = true;
+    }
+  }
+
+  // --- errors ---
+  const errors = eventStore.getEvents(sessionId, { categories: ["error"], limit: CAPS.errors });
+  if (errors.length > 0) {
+    const summaries: string[] = [];
+    for (const e of errors) {
+      const data = safeParse(e.data);
+      const summary = formatErrorSummary(data);
+      if (summary) summaries.push(escapeXML(summary.slice(0, 150)));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <errors>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`  </errors>`);
+      hasSections = true;
+    }
+  }
+
+  // --- git ---
+  const gitEvents = eventStore.getEvents(sessionId, { categories: ["git"], limit: CAPS.git });
+  if (gitEvents.length > 0) {
+    const summaries: string[] = [];
+    for (const g of gitEvents) {
+      const data = safeParse(g.data);
+      const cmd = typeof data?.command === "string" ? data.command.slice(0, 100) : "";
+      if (cmd) summaries.push(escapeXML(cmd));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <git>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`  </git>`);
+      hasSections = true;
+    }
+  }
+
+  // --- skills ---
+  const skillEvents = eventStore.getEvents(sessionId, { categories: ["skill"] });
+  if (skillEvents.length > 0) {
+    const names = new Set<string>();
+    for (const s of skillEvents) {
+      const data = safeParse(s.data);
+      const name = typeof data?.name === "string" ? data.name : typeof data?.skill === "string" ? data.skill : null;
+      if (name) names.add(name);
+    }
+    if (names.size > 0) {
+      sections.push("");
+      sections.push(`  <skills>`);
+      sections.push(`    Activated: ${[...names].map(escapeXML).join(", ")}`);
+      sections.push(`  </skills>`);
+      hasSections = true;
+    }
+  }
+
+  // --- intent ---
+  const intentEvents = eventStore.getEvents(sessionId, { categories: ["intent"], limit: 1 });
+  if (intentEvents.length > 0) {
+    const data = safeParse(intentEvents[0].data);
+    const mode = typeof data?.mode === "string" ? data.mode : typeof data?.intent === "string" ? data.intent : null;
+    if (mode) {
+      sections.push("");
+      sections.push(`  <intent>Session mode: ${escapeXML(mode)}</intent>`);
+      hasSections = true;
+    }
+  }
+
+  // --- env ---
+  const envEvents = eventStore.getEvents(sessionId, { categories: ["env"] });
+  if (envEvents.length > 0) {
+    const details: string[] = [];
+    for (const e of envEvents) {
+      const data = safeParse(e.data);
+      const detail = typeof data?.detail === "string" ? data.detail : typeof data?.env === "string" ? data.env : null;
+      if (detail) details.push(escapeXML(detail.slice(0, 100)));
+    }
+    if (details.length > 0) {
+      sections.push("");
+      sections.push(`  <env>`);
+      for (const d of details) sections.push(`    ${d}`);
+      sections.push(`  </env>`);
+      hasSections = true;
+    }
+  }
+
+  // --- cwd ---
+  const cwdEvents = eventStore.getEvents(sessionId, { categories: ["cwd"], limit: 1 });
+  if (cwdEvents.length > 0) {
+    const data = safeParse(cwdEvents[0].data);
+    const cwd = typeof data?.cwd === "string" ? data.cwd : typeof data?.path === "string" ? data.path : null;
+    if (cwd) {
+      sections.push("");
+      sections.push(`  <cwd>${escapeXML(cwd)}</cwd>`);
+      hasSections = true;
+    }
+  }
+
+  sections.push("</session_knowledge>");
+
+  if (!hasSections) return "";
+
+  return sections.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Fallback inline-truncated format (no supi-context-mode MCP)
+// ---------------------------------------------------------------------------
+
+function buildFallbackSnapshot(eventStore: EventStore, sessionId: string): string {
   const sections: string[] = ["<session_knowledge>"];
 
   // Last request
   const prompts = eventStore.getEvents(sessionId, { categories: ["prompt"], limit: 1 });
   if (prompts.length > 0) {
     const data = safeParse(prompts[0].data);
-    const prompt = typeof data?.prompt === "string" ? data.prompt.slice(0, 200) : "";
+    const prompt = typeof data?.prompt === "string" ? escapeXML(data.prompt.slice(0, 200)) : "";
     if (prompt) {
       sections.push(`  <last_request>${prompt}</last_request>`);
     }
@@ -34,7 +270,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     for (const t of tasks) {
       const data = safeParse(t.data);
       const content = extractTaskContent(data);
-      if (content) sections.push(`    - ${content.slice(0, 100)}`);
+      if (content) sections.push(`    - ${escapeXML(content.slice(0, 100))}`);
     }
     sections.push("  </pending_tasks>");
   }
@@ -45,7 +281,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     sections.push("  <key_decisions>");
     for (const d of decisions) {
       const data = safeParse(d.data);
-      const prompt = typeof data?.prompt === "string" ? data.prompt.slice(0, 100) : "";
+      const prompt = typeof data?.prompt === "string" ? escapeXML(data.prompt.slice(0, 100)) : "";
       if (prompt) sections.push(`    - ${prompt}`);
     }
     sections.push("  </key_decisions>");
@@ -63,7 +299,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
   if (modifiedPaths.size > 0) {
     sections.push("  <files_modified>");
     const paths = [...modifiedPaths].slice(0, CAPS.files);
-    for (const p of paths) sections.push(`    - ${p}`);
+    for (const p of paths) sections.push(`    - ${escapeXML(p)}`);
     sections.push("  </files_modified>");
   }
 
@@ -74,7 +310,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     for (const e of errors) {
       const data = safeParse(e.data);
       const summary = formatErrorSummary(data);
-      if (summary) sections.push(`    - ${summary.slice(0, 150)}`);
+      if (summary) sections.push(`    - ${escapeXML(summary.slice(0, 150))}`);
     }
     sections.push("  </recent_errors>");
   }
@@ -85,7 +321,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     sections.push("  <git_state>");
     for (const g of gitEvents) {
       const data = safeParse(g.data);
-      const cmd = typeof data?.command === "string" ? data.command.slice(0, 100) : "";
+      const cmd = typeof data?.command === "string" ? escapeXML(data.command.slice(0, 100)) : "";
       if (cmd) sections.push(`    - ${cmd}`);
     }
     sections.push("  </git_state>");