@tt-a1i/openpi 0.4.0 → 0.5.0

package/extensions/workspace-cleanup-guard/workspace-provenance.ts

@@ -0,0 +1,563 @@
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+
+type Origin = "baseline" | "session_created";
+
+interface PendingEffects {
+  creations: Array<{
+    path: string;
+    existed: boolean;
+    observeOnCommandError: boolean;
+  }>;
+  removals: string[];
+}
+
+interface BashAttempt {
+  id: string;
+  command: string;
+  cwd: string;
+  confirmDelete: (paths: readonly string[]) => Promise<boolean>;
+}
+
+interface WriteAttempt {
+  id: string;
+  path: string;
+  cwd: string;
+}
+
+interface ShellInspection {
+  creations: string[];
+  removals: string[];
+  opaqueDestructiveCommand: boolean;
+}
+
+const DYNAMIC_PATH = /[*?[$`]/u;
+const STANDALONE_CONTROL_CHARACTERS = ";&|<>(){}$`*?[]#";
+const COMMAND_FORWARDERS = new Set([
+  "!",
+  "alias",
+  "bash",
+  "builtin",
+  "chroot",
+  "command",
+  "dash",
+  "doas",
+  "env",
+  "eval",
+  "exec",
+  "find",
+  "hash",
+  "ksh",
+  "nice",
+  "nohup",
+  "sandbox-exec",
+  "setsid",
+  "sh",
+  "sudo",
+  "time",
+  "timeout",
+  "trap",
+  "watch",
+  "xargs",
+  "zsh",
+]);
+
+function splitShellSegments(command: string) {
+  const segments: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | undefined;
+  let escaped = false;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index] ?? "";
+    const next = command[index + 1] ?? "";
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      current += char;
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      current += char;
+      if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (
+      char === "\n" ||
+      char === ";" ||
+      (char === "&" && next === "&") ||
+      (char === "|" && next === "|")
+    ) {
+      if (current.trim()) segments.push(current.trim());
+      current = "";
+      if ((char === "&" || char === "|") && next === char) index += 1;
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) segments.push(current.trim());
+  return segments;
+}
+
+function shellTokens(segment: string) {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | undefined;
+  let escaped = false;
+  const push = () => {
+    if (!current) return;
+    tokens.push(current);
+    current = "";
+  };
+  for (const char of segment) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = undefined;
+      else current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      push();
+      continue;
+    }
+    if (char === ">") {
+      push();
+      tokens.push(">");
+      continue;
+    }
+    current += char;
+  }
+  push();
+  return tokens;
+}
+
+function literalPath(value: string | undefined) {
+  if (!value || value === "--" || DYNAMIC_PATH.test(value)) return undefined;
+  return value;
+}
+
+function standaloneShellTokens(command: string) {
+  const source = command.replace(/^[ \t]+|[ \t]+$/gu, "");
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | undefined;
+  let escaped = false;
+  let tokenStarted = false;
+  const push = () => {
+    if (!tokenStarted) return;
+    tokens.push(current);
+    current = "";
+    tokenStarted = false;
+  };
+
+  for (const character of source) {
+    if (quote === "'") {
+      if (character === "'") quote = undefined;
+      else current += character;
+      continue;
+    }
+    if (quote === '"') {
+      if (escaped) {
+        if (character !== "\n") {
+          current += '$`"\\'.includes(character) ? character : `\\${character}`;
+        }
+        escaped = false;
+      } else if (character === '"') {
+        quote = undefined;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === "$" || character === "`") {
+        return undefined;
+      } else {
+        current += character;
+      }
+      continue;
+    }
+    if (escaped) {
+      if (character === "\n" || character === "\r") return undefined;
+      current += character;
+      tokenStarted = true;
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      quote = character;
+      tokenStarted = true;
+      continue;
+    }
+    if (character === "\n" || character === "\r") return undefined;
+    if (character === " " || character === "\t") {
+      push();
+      continue;
+    }
+    if (STANDALONE_CONTROL_CHARACTERS.includes(character)) return undefined;
+    current += character;
+    tokenStarted = true;
+  }
+  if (quote || escaped) return undefined;
+  push();
+  return tokens;
+}
+
+function directRmTargets(command: string) {
+  const tokens = standaloneShellTokens(command);
+  if (!tokens || tokens[0] !== "rm") return undefined;
+
+  const targets: string[] = [];
+  let afterOptions = false;
+  for (const token of tokens.slice(1)) {
+    if (!afterOptions && token === "--") {
+      afterOptions = true;
+      continue;
+    }
+    if (!afterOptions && token.startsWith("-")) continue;
+    if (!token || token.startsWith("~") || path.isAbsolute(token)) {
+      return undefined;
+    }
+    targets.push(token);
+  }
+  return targets.length > 0 ? targets : undefined;
+}
+
+function inspectCreations(command: string) {
+  const creations = new Set<string>();
+  for (const segment of splitShellSegments(command)) {
+    const tokens = shellTokens(segment);
+    for (let index = 0; index < tokens.length; index += 1) {
+      if (tokens[index] !== ">") continue;
+      const target = literalPath(tokens[index + 1]);
+      if (target) creations.add(target);
+    }
+
+    if (tokens[0]?.split("/").at(-1) !== "mkdir") continue;
+    const targets: string[] = [];
+    let afterOptions = false;
+    let supported = true;
+    for (const token of tokens.slice(1)) {
+      if (!afterOptions && token === "--") {
+        afterOptions = true;
+        continue;
+      }
+      if (!afterOptions && (token === "-p" || token === "--parents")) {
+        continue;
+      }
+      if (!afterOptions && token.startsWith("-")) {
+        supported = false;
+        break;
+      }
+      const target = literalPath(token);
+      if (!target) {
+        supported = false;
+        break;
+      }
+      targets.push(target);
+    }
+    if (supported) {
+      for (const target of targets) creations.add(target);
+    }
+  }
+  return [...creations];
+}
+
+function containsRmReference(command: string) {
+  let decoded = "";
+  let quote: "'" | '"' | undefined;
+  for (let index = 0; index < command.length; index += 1) {
+    const character = command[index] ?? "";
+    const next = command[index + 1] ?? "";
+    if (!quote && character === "$" && (next === "'" || next === '"')) {
+      continue;
+    }
+    if (character === "\\" && quote !== "'") {
+      if (next !== "\n") {
+        decoded +=
+          quote === '"' && !'$`"\\'.includes(next) ? `\\${next}` : next;
+      }
+      index += 1;
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      if (!quote) quote = character;
+      else if (quote === character) quote = undefined;
+      else decoded += character;
+      continue;
+    }
+    decoded += character;
+  }
+  return /(^|[^A-Za-z0-9_.-])(?:\/[A-Za-z0-9_.-]+)*\/?rm(?=$|[^A-Za-z0-9_.-])/u.test(
+    decoded,
+  );
+}
+
+function stripShellComment(command: string) {
+  let quote: "'" | '"' | undefined;
+  let escaped = false;
+  let comment = false;
+  let source = "";
+  for (let index = 0; index < command.length; index += 1) {
+    const character = command[index] ?? "";
+    if (comment) {
+      if (character === "\n") {
+        comment = false;
+        source += character;
+      }
+      continue;
+    }
+    if (escaped) {
+      escaped = false;
+      source += character;
+      continue;
+    }
+    if (character === "\\" && quote !== "'") {
+      escaped = true;
+      source += character;
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      if (!quote) quote = character;
+      else if (quote === character) quote = undefined;
+      source += character;
+      continue;
+    }
+    if (
+      !quote &&
+      character === "#" &&
+      (index === 0 || /[\s;&|()]/u.test(command[index - 1] ?? ""))
+    ) {
+      comment = true;
+      continue;
+    }
+    source += character;
+  }
+  return source.trimEnd();
+}
+
+function heredocContainsExecutableRm(command: string) {
+  const lines = command.split("\n");
+  if (lines.length < 3) return undefined;
+  const header = lines[0] ?? "";
+  const match = /<<(-?)[ \t]*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\2[ \t]*$/u.exec(
+    header,
+  );
+  if (!match) return undefined;
+  const stripTabs = match[1] === "-";
+  const delimiterQuoted = Boolean(match[2]);
+  const delimiter = match[3] ?? "";
+  const closing = lines.findIndex((line, index) => {
+    if (index === 0) return false;
+    return (stripTabs ? line.replace(/^\t+/u, "") : line) === delimiter;
+  });
+  if (closing < 0 || lines.slice(closing + 1).some((line) => line.trim())) {
+    return undefined;
+  }
+  if (containsRmReference(stripShellComment(header))) return true;
+  if (delimiterQuoted) return false;
+  const body = lines.slice(1, closing).join("\n");
+  return /\$\(|`/u.test(body) && containsRmReference(body);
+}
+
+function containsExecutableRmReference(command: string) {
+  const heredoc = heredocContainsExecutableRm(command);
+  if (heredoc !== undefined) return heredoc;
+
+  const source = stripShellComment(command);
+  if (!containsRmReference(source)) return false;
+  const tokens = standaloneShellTokens(source);
+  if (!tokens) return true;
+
+  const executableIndex = tokens.findIndex(
+    (token) => !/^[A-Za-z_][A-Za-z0-9_]*=/u.test(token),
+  );
+  const executable = tokens[executableIndex]?.split("/").at(-1) ?? "";
+  if (
+    executable === "command" &&
+    (tokens[executableIndex + 1] === "-v" ||
+      tokens[executableIndex + 1] === "-V")
+  ) {
+    return false;
+  }
+  return COMMAND_FORWARDERS.has(executable) || executable === "rm";
+}
+
+function inspectShell(command: string): ShellInspection {
+  const removals = directRmTargets(command);
+  if (removals) {
+    return {
+      creations: [],
+      removals,
+      opaqueDestructiveCommand: false,
+    };
+  }
+  if (!containsExecutableRmReference(command)) {
+    return {
+      creations: inspectCreations(command),
+      removals: [],
+      opaqueDestructiveCommand: false,
+    };
+  }
+  return {
+    creations: [],
+    removals: [],
+    opaqueDestructiveCommand: true,
+  };
+}
+
+function containedPath(cwd: string, candidate: string) {
+  const absolute = path.resolve(cwd, candidate);
+  const relative = path.relative(cwd, absolute);
+  if (
+    relative === "" ||
+    relative === ".." ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relative)
+  ) {
+    return undefined;
+  }
+  return { absolute, relative: relative.split(path.sep).join("/") };
+}
+
+async function exists(candidate: string) {
+  try {
+    await lstat(candidate);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+export function createWorkspaceCleanupGuard() {
+  const origins = new Map<string, Origin>();
+  const pending = new Map<string, PendingEffects>();
+
+  const prepareCreation = async (
+    cwd: string,
+    candidate: string,
+    observeOnCommandError: boolean,
+  ) => {
+    const contained = containedPath(cwd, candidate);
+    if (!contained) return undefined;
+    const existed = await exists(contained.absolute);
+    if (existed && !origins.has(contained.absolute)) {
+      origins.set(contained.absolute, "baseline");
+    }
+    return { path: contained.absolute, existed, observeOnCommandError };
+  };
+
+  const unverifiedCleanup = () => ({
+    kind: "block" as const,
+    protectedPaths: [],
+    reason:
+      "Blocked cleanup: OpenPI recognized a source-visible deletion outside its supported direct rm command grammar. Use a direct rm command with literal workspace-relative paths so OpenPI can determine whether each target is session-created scratch or a pre-existing path requiring confirmation.",
+  });
+
+  return {
+    async beforeWrite(attempt: WriteAttempt) {
+      const creation = await prepareCreation(attempt.cwd, attempt.path, false);
+      pending.set(attempt.id, {
+        creations: creation ? [creation] : [],
+        removals: [],
+      });
+    },
+
+    async before(attempt: BashAttempt) {
+      const inspected = inspectShell(attempt.command);
+      if (inspected.opaqueDestructiveCommand) return unverifiedCleanup();
+
+      const containedRemovals = inspected.removals.map((candidate) =>
+        containedPath(attempt.cwd, candidate),
+      );
+      if (containedRemovals.some((candidate) => !candidate)) {
+        return unverifiedCleanup();
+      }
+
+      const creations: PendingEffects["creations"] = [];
+      for (const candidate of inspected.creations) {
+        const creation = await prepareCreation(attempt.cwd, candidate, true);
+        if (creation) creations.push(creation);
+      }
+
+      const removals: string[] = [];
+      const protectedPaths: string[] = [];
+      for (const contained of containedRemovals) {
+        if (!contained) continue;
+        const origin = origins.get(contained.absolute);
+        const present = await exists(contained.absolute);
+        if (present && !origin) origins.set(contained.absolute, "baseline");
+        if (present && origins.get(contained.absolute) !== "session_created") {
+          protectedPaths.push(contained.relative);
+        }
+        removals.push(contained.absolute);
+      }
+
+      if (
+        protectedPaths.length > 0 &&
+        !(await attempt.confirmDelete(protectedPaths))
+      ) {
+        return {
+          kind: "block" as const,
+          protectedPaths,
+          reason: `Blocked cleanup: ${protectedPaths.join(", ")} existed before this agent changed it and is not proven session-created scratch. Retry the cleanup without that path, or obtain explicit user confirmation to delete it.`,
+        };
+      }
+
+      pending.set(attempt.id, { creations, removals });
+      return { kind: "allow" as const };
+    },
+
+    async after(result: { id: string; isError: boolean }) {
+      const effects = pending.get(result.id);
+      pending.delete(result.id);
+      if (!effects) return;
+      for (const creation of effects.creations) {
+        if (
+          !creation.existed &&
+          (!result.isError || creation.observeOnCommandError) &&
+          !origins.has(creation.path) &&
+          (await exists(creation.path))
+        ) {
+          origins.set(creation.path, "session_created");
+        }
+      }
+      for (const removed of effects.removals) {
+        if (
+          origins.get(removed) === "session_created" &&
+          !(await exists(removed))
+        ) {
+          origins.delete(removed);
+        }
+      }
+    },
+
+    reset() {
+      origins.clear();
+      pending.clear();
+    },
+  };
+}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@tt-a1i/openpi",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "OpenPI — a Pi-native multi-agent workbench with background execution, isolated subagents, replay-safe workflows, goals, tasks, and observable TUI",
   "license": "MIT",
   "author": "tt-a1i",
+  "bin": {
+    "openpi": "./bin/openpi.js"
+  },
   "keywords": [
     "pi-package",
     "pi",
@@ -14,18 +17,22 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tt-a1i/openpi.git"
+    "url": "git+https://github.com/openpi-dev/openpi.git"
   },
-  "homepage": "https://github.com/tt-a1i/openpi#readme",
+  "homepage": "https://github.com/openpi-dev/openpi#readme",
   "bugs": {
-    "url": "https://github.com/tt-a1i/openpi/issues"
+    "url": "https://github.com/openpi-dev/openpi/issues"
   },
   "files": [
+    "bin",
+    "web",
     "extensions",
     "!extensions/**/*.test.ts",
     "!extensions/**/*.spec.ts",
     "!extensions/**/tsconfig.json",
+    "!extensions/**/test-support/**",
     "!extensions/*/docs",
+    "!tests/**",
     "skills",
     "themes",
     "assets",
@@ -44,12 +51,15 @@
     "themes": [
       "./themes"
     ],
-    "image": "https://raw.githubusercontent.com/tt-a1i/openpi/main/assets/openpi-package.png"
+    "image": "https://raw.githubusercontent.com/openpi-dev/openpi/main/assets/openpi-package.png"
   },
   "dependencies": {
     "@effect/platform-node": "^4.0.0-beta.99",
     "acorn": "^8.17.0",
-    "effect": "^4.0.0-beta.99"
+    "effect": "^4.0.0-beta.99",
+    "jiti": "2.7.0",
+    "marked": "^18.0.5",
+    "undici": "8.9.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.8",
@@ -61,6 +71,7 @@
     "@types/node": "^26.1.1",
     "typebox": "^1.3.6",
     "typescript": "^7.0.2",
+    "vite": "^8.2.0",
     "vitest": "4.1.10"
   },
   "peerDependencies": {
@@ -75,13 +86,22 @@
   },
   "scripts": {
     "prepublishOnly": "bun run check && bun run test",
-    "check": "bun run format:check && bun run lint && bun run typecheck",
+    "check": "bun run check:config-contract && bun run check:discipline && bun run check:web && bun run format:check && bun run lint && bun run typecheck",
+    "check:config-contract": "node scripts/check-config-contract.mjs",
+    "check:discipline": "node scripts/check-discipline-ledger.mjs",
     "prepare": "node scripts/prepare-effect-tsgo.mjs",
     "format": "biome format --write .",
     "format:check": "biome format .",
     "lint": "biome lint . --error-on-warnings",
     "typecheck": "tsc --noEmit",
-    "test": "node --test --experimental-strip-types extensions/*/*.test.ts && vitest run extensions/file-search/index.spec.ts"
+    "benchmark:workflow-journal": "node --experimental-strip-types --expose-gc benchmarks/workflow-journal.ts",
+    "dev:web": "node --experimental-strip-types scripts/dev-web.mjs",
+    "dev:web:ui": "vite --config web/vite.config.mjs --host 127.0.0.1",
+    "dev:web:backend": "node scripts/dev-web-backend.mjs",
+    "check:web": "node --check scripts/dev-web.mjs && node --check web/vite.config.mjs && node --check web/ui/app.js",
+    "benchmark:workflow-child-startup": "node --experimental-strip-types scripts/benchmark-workflow-child-startup.mjs",
+    "test": "node scripts/run-tests.mjs",
+    "provenance": "node scripts/provenance.mjs"
   },
   "packageManager": "bun@1.3.14"
 }