@astrofoundry/pi-astro 0.6.5 → 0.6.7

package/extensions/security-guard/rules.test.ts

@@ -0,0 +1,96 @@
+import { homedir } from "node:os";
+import { describe, expect, it } from "vitest";
+import { expandHome, findMatchingRule, matchesPattern, normalizePath } from "./rules.ts";
+
+describe("expandHome", () => {
+    it("expands ~/foo", () => {
+        expect(expandHome("~/foo")).toBe(`${homedir()}/foo`);
+    });
+
+    it("expands bare ~", () => {
+        expect(expandHome("~")).toBe(homedir());
+    });
+
+    it("leaves non-tilde paths unchanged", () => {
+        expect(expandHome("/etc/hosts")).toBe("/etc/hosts");
+        expect(expandHome("foo/bar")).toBe("foo/bar");
+    });
+});
+
+describe("normalizePath", () => {
+    it("resolves relative paths against cwd", () => {
+        expect(normalizePath("foo.txt", "/tmp")).toBe("/tmp/foo.txt");
+    });
+
+    it("keeps absolute paths", () => {
+        expect(normalizePath("/abs/path", "/tmp")).toBe("/abs/path");
+    });
+
+    it("expands ~", () => {
+        expect(normalizePath("~/a", "/tmp")).toBe(`${homedir()}/a`);
+    });
+});
+
+describe("matchesPattern", () => {
+    it("substring match on bash command", () => {
+        expect(matchesPattern("sudo rm -rf /tmp/x", { pattern: "rm -rf", action: "prompt" })).toBe(true);
+    });
+
+    it("substring does NOT match when absent", () => {
+        expect(matchesPattern("ls -la", { pattern: "rm -rf", action: "prompt" })).toBe(false);
+    });
+
+    it("glob ** matches deep paths", () => {
+        expect(matchesPattern("/Users/x/.ssh/id_rsa", { pattern: "~/.ssh/**", action: "block" })).toBe(false);
+        // Reason: the test path's home isn't the CURRENT user's home. Glob is anchored.
+        const real = `${homedir()}/.ssh/id_rsa`;
+        expect(matchesPattern(real, { pattern: "~/.ssh/**", action: "block" })).toBe(true);
+    });
+
+    it("glob * does NOT cross /", () => {
+        expect(matchesPattern("/a/b/c", { pattern: "/a/*", action: "block" })).toBe(false);
+        expect(matchesPattern("/a/b", { pattern: "/a/*", action: "block" })).toBe(true);
+    });
+
+    it("glob ? matches single char", () => {
+        expect(matchesPattern("/tmp/a.env", { pattern: "/tmp/?.env", action: "block" })).toBe(true);
+        expect(matchesPattern("/tmp/ab.env", { pattern: "/tmp/?.env", action: "block" })).toBe(false);
+    });
+
+    it("character class [abc]", () => {
+        expect(matchesPattern("/tmp/a", { pattern: "/tmp/[abc]", action: "block" })).toBe(true);
+        expect(matchesPattern("/tmp/z", { pattern: "/tmp/[abc]", action: "block" })).toBe(false);
+    });
+
+    it("glob **/.env matches any depth", () => {
+        expect(matchesPattern("/src/app/.env", { pattern: "**/.env", action: "block" })).toBe(true);
+        expect(matchesPattern("/.env", { pattern: "**/.env", action: "block" })).toBe(true);
+    });
+
+    it("metacharacters in non-glob pattern are escaped (fall back to substring)", () => {
+        // Pattern has no *, ?, [ — substring path used; no regex injection
+        expect(matchesPattern("something", { pattern: "some(thing)", action: "block" })).toBe(false);
+        expect(matchesPattern("some(thing)", { pattern: "some(thing)", action: "block" })).toBe(true);
+    });
+});
+
+describe("findMatchingRule — longest wins", () => {
+    const rules = [
+        { pattern: "> /dev/", action: "block" as const },
+        { pattern: "> /dev/null", action: "allow" as const },
+    ];
+
+    it("allow /dev/null overrides block /dev/", () => {
+        const r = findMatchingRule("echo hi > /dev/null", rules);
+        expect(r?.action).toBe("allow");
+    });
+
+    it("block /dev/sda still blocks when no narrower rule exists", () => {
+        const r = findMatchingRule("echo hi > /dev/sda", rules);
+        expect(r?.action).toBe("block");
+    });
+
+    it("no match returns null", () => {
+        expect(findMatchingRule("ls -la", rules)).toBeNull();
+    });
+});

package/extensions/security-guard/rules.ts

@@ -0,0 +1,90 @@
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+import type { SecurityRule } from "./types.ts";
+
+export function expandHome(pattern: string): string {
+    if (pattern === "~") return homedir();
+    if (pattern.startsWith("~/")) return `${homedir()}/${pattern.slice(2)}`;
+    return pattern;
+}
+
+/**
+ * Normalize a filesystem path for matching: expand `~`, resolve relative paths
+ * against cwd. Non-filesystem strings (bash commands) should NOT go through this.
+ */
+export function normalizePath(p: string, cwd: string): string {
+    const expanded = expandHome(p);
+    return isAbsolute(expanded) ? expanded : resolve(cwd, expanded);
+}
+
+/**
+ * Convert a glob pattern to a RegExp source. Supports:
+ *   ?       any single non-separator char
+ *   *       any run of non-separator chars
+ *   **      any run of chars including separators
+ *   [abc]   character class
+ * All other regex metacharacters are escaped.
+ */
+function globToRegex(glob: string): RegExp {
+    let src = "";
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === "*") {
+            if (glob[i + 1] === "*") {
+                src += ".*";
+                i++;
+            } else {
+                src += "[^/]*";
+            }
+        } else if (c === "?") {
+            src += "[^/]";
+        } else if (c === "[") {
+            const end = glob.indexOf("]", i);
+            if (end === -1) {
+                src += "\\[";
+            } else {
+                src += glob.slice(i, end + 1);
+                i = end;
+            }
+        } else if (/[.+^${}()|\\]/.test(c)) {
+            src += `\\${c}`;
+        } else {
+            src += c;
+        }
+    }
+    return new RegExp(`^${src}$`);
+}
+
+function isGlob(pattern: string): boolean {
+    return /[*?[]/.test(pattern);
+}
+
+/**
+ * Does `text` match `rule.pattern`? For globs, matches as a whole path / whole
+ * string. For non-glob patterns, falls back to substring match (friendlier for
+ * bash commands and filename fragments).
+ */
+export function matchesPattern(text: string, rule: SecurityRule): boolean {
+    const expanded = expandHome(rule.pattern);
+    if (isGlob(rule.pattern)) {
+        const re = globToRegex(expanded);
+        return re.test(text);
+    }
+    return text.includes(expanded) || text.includes(rule.pattern);
+}
+
+/**
+ * Longest-match wins, so narrow `allow` exceptions override broad `block` rules
+ * (e.g. `> /dev/` = block, `> /dev/null` = allow).
+ */
+export function findMatchingRule(text: string, rules: readonly SecurityRule[]): SecurityRule | null {
+    let best: SecurityRule | null = null;
+    for (const rule of rules) {
+        if (matchesPattern(text, rule)) {
+            if (best === null || rule.pattern.length > best.pattern.length) {
+                best = rule;
+            }
+        }
+    }
+    return best;
+}

package/extensions/security-guard/types.ts

@@ -0,0 +1,12 @@
+export type RuleAction = "prompt" | "block" | "allow";
+
+export interface SecurityRule {
+    pattern: string;
+    action: RuleAction;
+}
+
+export interface SecurityRules {
+    operations: SecurityRule[];
+    writes: SecurityRule[];
+    reads: SecurityRule[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"