@davisliu2006/pi-permission-system 0.1.0 → 0.3.0

package/src/shell.ts

@@ -1,15 +1,45 @@
 /**
- * Conservative shell-chaining detector.
- * This is not a parser and is biased toward returning true.
- * 
- * Guards against:
+ * Result of a conservative shell scan.
+ *
+ * When `isComplex` is false, `segments` are commands separated only by `;`,
+ * `&&`, `||`, or newlines (or a single command).
+ *
+ * When `isComplex` is true because of `|` / `|&`, `segments` are still filled
+ * so deny rules can be checked per stage. Other complex syntax returns empty
+ * `segments`.
+ */
+export type ShellCommandAnalysis = {
+  isComplex: boolean;
+  segments: string[];
+};
+
+const COMPLEX: ShellCommandAnalysis = { isComplex: true, segments: [] };
+
+/**
+ * Conservative shell command scanner.
+ * This is not a full parser and is biased toward `isComplex: true`.
+ *
+ * Splits on:
+ * - `;`, `&&`, `||`, and newlines outside quotes
+ * - '|' and '|&' outside quotes (also treated as complex)
+ *
+ * Treats as complex:
  * - Substitutions like `command` and $(command)
- * - Chaining like ;, &&, ||, \n, and \r
+ * - Pipes `|` and background `&`
  * - Parentheses
  */
-export function hasShellChaining(command: string): boolean {
+export function analyzeShellCommand(command: string): ShellCommandAnalysis {
   let quote: "'" | '"' | undefined;
   let index = 0;
+  let current = "";
+  let isComplex = false;
+  const segments: string[] = [];
+
+  const pushCurrent = (): void => {
+    const trimmed = current.trim();
+    if (trimmed) {segments.push(trimmed);}
+    current = "";
+  };
 
   while (index < command.length) {
     const character = command[index]!;
@@ -17,52 +47,93 @@ export function hasShellChaining(command: string): boolean {
     // inside quote
     if (quote === "'") {
       if (character === "'") {quote = undefined;}
+      current += character;
       index++;
       continue;
     }
     if (quote === '"') {
       if (character === "\\") {
+        current += character + (command[index+1] ?? "");
         index += 2;
         continue;
       }
       if (character === '"') {
         quote = undefined;
+        current += character;
         index++;
         continue;
       }
-      if (character === "`") {return true;}
-      if (character === "$" && command[index + 1] === "(") {return true;}
+      if (character === "`") {return COMPLEX;}
+      if (character === "$" && command[index+1] === "(") {return COMPLEX;}
+      current += character;
       index++;
       continue;
     }
 
     // escape character
     if (character === "\\") {
+      current += character + (command[index+1] ?? "");
       index += 2;
       continue;
     }
-  
-    // strat quote
+
+    // start quote
     if (character === "'") {
       quote = "'";
+      current += character;
       index++;
       continue;
     }
     if (character === '"') {
       quote = '"';
+      current += character;
       index++;
       continue;
     }
 
-    if (character === "`") {return true;}
-    if (character === "$" && command[index + 1] === "(") {return true;}
-    if (character === ";" || character === "|" || character === "&") {return true;}
-    if (character === "\n" || character === "\r") {return true;}
-    if (character === "(" || character === ")") {return true;}
+    if (character === "`") {return COMPLEX;}
+    if (character === "$" && command[index+1] === "(") {return COMPLEX;}
+    if (character === "(" || character === ")") {return COMPLEX;}
 
+    // simple separators
+    if (character === ";") {
+      pushCurrent();
+      index++;
+      continue;
+    }
+    if (character === "&") {
+      if (command[index+1] !== "&") {return COMPLEX;}
+      pushCurrent();
+      index += 2;
+      continue;
+    }
+    if (character === "|") {
+      pushCurrent();
+      if (command[index+1] === "|") {
+        index += 2;
+        continue;
+      }
+      isComplex = true;
+      index += command[index+1] === "&" ? 2 : 1;
+      continue;
+    }
+    if (character === "\n" || character === "\r") {
+      pushCurrent();
+      if (character === "\r" && command[index+1] === "\n") {index += 2;}
+      else {index++;}
+      continue;
+    }
+
+    current += character;
     index++;
   }
 
   // Unterminated quotes are unsafe to reason about.
-  return quote !== undefined;
+  if (quote !== undefined) {return COMPLEX;}
+
+  pushCurrent();
+  return {
+    isComplex,
+    segments: segments.length > 0 ? segments : [""],
+  };
 }

package/src/types-pi.ts

@@ -23,12 +23,3 @@ export type PiToolInput =
   | PathToolInput
   | BashToolInput
   | Record<string, unknown>;
-
-export function validatePathToolInput(input: PiToolInput): PathToolInput | undefined {
-  if (!("path" in input) || typeof(input.path) !== "string") {return undefined;}
-  return input as PathToolInput;
-}
-export function validateBashToolInput(input: PiToolInput): BashToolInput | undefined {
-  if (!("command" in input) || typeof(input.command) !== "string") {return undefined;}
-  return input as BashToolInput;
-}

package/src/types.ts

@@ -1,4 +1,5 @@
 import { ASK, PERMISSION_STATES } from "./constants.ts";
+import type { ShellCommandAnalysis } from "./shell.ts";
 import type { PiToolInput } from "./types-pi.ts";
 
 // utility functions
@@ -20,22 +21,42 @@ export function toPermissionState(value: unknown): PermissionState | undefined {
 
 export type PermissionSection = Record<string, PermissionState>;
 
+export interface PermissionSettings {
+  /** `provider/model-id` override for small helper completions. */
+  ai_model?: string;
+}
+
 export interface PermissionConfig {
   default: PermissionState;
   tools: PermissionSection;
   bash: PermissionSection;
   external_directory: PermissionSection;
+  settings: PermissionSettings;
 }
 
 export function createDefaultPermissionConfig(): PermissionConfig {
-  return { default: ASK, tools: {}, bash: {}, external_directory: {} };
+  return { default: ASK, tools: {}, bash: {}, external_directory: {}, settings: {} };
 }
 
-export const DEFAULT_PERMISSION_CONFIG = createDefaultPermissionConfig();
+/**
+ * Parses `provider/model-id`.
+ * Splits using the first '/'.
+ */
+export function parseAiModelRef(
+  value: string
+): { provider: string; modelId: string } | undefined {
+  const trimmed = value.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash <= 0 || slash >= trimmed.length - 1) {return undefined;}
+  const provider = trimmed.slice(0, slash).trim();
+  const modelId = trimmed.slice(slash + 1).trim();
+  if (!provider || !modelId) {return undefined;}
+  return { provider, modelId };
+}
 
 // permission request
 
-export type RequestBodyKind = "command" | "path" | "generic";
+export type RequestBodyKind = "path" | "command" | "generic";
 
 /**
  * Request for a tool.
@@ -44,6 +65,8 @@ export type RequestBodyKind = "command" | "path" | "generic";
  * @property body - The body for the permission request.
  * @property bodyKind - The meaning of the body.
  * @property cwd - The current working directory.
+ * @property isExternalDirectory - Whether the request uses path to an external directory.
+ * @property bashAnalysis - Shell scan for bash requests.
  */
 export interface PermissionRequest {
   toolName: string;
@@ -52,12 +75,12 @@ export interface PermissionRequest {
   bodyKind: RequestBodyKind;
   cwd: string;
   isExternalDirectory?: boolean;
-  isChainedBash?: boolean;
+  bashAnalysis?: ShellCommandAnalysis;
 }
 
 // resolved policy
 
-export type PolicySource = "bash" | "tool" | "default" | "external";
+export type PolicySource = "default" | "tool" | "bash" | "external";
 
 /**
  * A resolved policy.
@@ -66,18 +89,17 @@ export interface PolicyResolution {
   state: PermissionState;
   source: PolicySource;
   matchedPattern?: string;
-  isChainedBash: boolean;
 }
 
+export type AllowAlwaysMode = "wildcard" | "wildcard-list" | "exact";
+
 // other types
 
 export type AllowAlwaysRule = {
-  scope: "tool" | "external_directory";
   kind: "exact";
   tool: string;
   body: string;
 } | {
-  scope: "tool";
   kind: "wildcard";
   tool: "bash";
   body: string;

package/src/ui-strings.ts

@@ -1,8 +1,9 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
 import {
   ALLOW_ALWAYS_EXACT,
   ALLOW_ALWAYS_WILDCARD,
 } from "./constants.ts";
-import { willGenerateBashWildcard } from "./policy.ts";
+import { resolveAllowAlwaysMode } from "./policy-bash.ts";
 import type { PermissionRequest, PolicyResolution } from "./types.ts";
 
 export const STATUS_SUMMARIZING_REQUEST = "Summarizing permission request...";
@@ -10,57 +11,101 @@ export const STATUS_GENERATING_WILDCARD = "Generating bash wildcard...";
 
 export const PERMISSION_DIALOG_TITLE = "Permission Required";
 export const PERMISSION_DIALOG_QUESTION = "What should the agent be allowed to do?";
-export const PURPOSE_PREFIX = "Purpose: ";
 
 export const WILDCARD_EDITOR_TITLE = "Review bash wildcard";
+export const WILDCARD_LIST_EDITOR_TITLE = "Review bash wildcards (semicolon-separated)";
 export const BROAD_WILDCARD_TITLE = "Very broad wildcard";
-export const INVALID_WILDCARD_PREFIX = "Invalid wildcard: ";
 
 const CHAINED_BASH_NOTE = "Shell chaining detected.";
 const EXTERNAL_DIRECTORY_NOTE = "Outside the current working directory.";
 
+type SummaryLine = {
+  label?: string;
+  value: string;
+};
+
 function preview(value: string, limit: number): string {
   const normalized = value.replace(/\r\n/g, "\n");
   return normalized.length > limit ? `${normalized.slice(0, limit)}...` : normalized;
 }
 
-/**
- * Summary shown in the permission select dialog.
- */
-export function buildSelectorSummary(request: PermissionRequest): string {
-  const lines = [
-    `Tool: ${request.toolName}`,
+function buildSelectorSummaryLines(
+  request: PermissionRequest,
+  purpose?: string
+): SummaryLine[] {
+  const lines: SummaryLine[] = [
+    { label: "Tool", value: request.toolName },
   ];
-
   if (request.bodyKind === "command") {
-    lines.push(`Command: \`${preview(request.body, 600)}\``);
-    if (request.isChainedBash) {
-      lines.push(CHAINED_BASH_NOTE);
+    lines.push({ label: "Command", value: preview(request.body, 600) });
+    if (request.bashAnalysis?.isComplex) {
+      lines.push({ value: CHAINED_BASH_NOTE });
     }
   } else if (request.bodyKind === "path") {
-    lines.push(`Path: ${preview(request.body, 400)}`);
+    lines.push({ label: "Path", value: preview(request.body, 400) });
     if (request.isExternalDirectory) {
-      lines.push(EXTERNAL_DIRECTORY_NOTE);
+      lines.push({ value: EXTERNAL_DIRECTORY_NOTE });
     }
   } else {
-    lines.push(`Input: ${preview(request.body, 600)}`);
+    lines.push({ label: "Input", value: preview(request.body, 600) });
   }
+  if (purpose) {
+    lines.push({ label: "Purpose", value: purpose });
+  }
+  return lines;
+}
+
+/**
+ * Plain summary shown in the non-TUI permission dialog.
+ */
+export function buildPlainSelectorSummary(
+  request: PermissionRequest,
+  purpose?: string
+): string {
+  return buildSelectorSummaryLines(request, purpose)
+    .map((line) => (
+      line.label ? `${line.label}: ${line.value}` : line.value)
+    )
+    .join("\n");
+}
 
-  return lines.join("\n");
+/**
+ * Styled summary lines shown in the TUI permission dialog.
+ */
+export function buildStyledSelectorSummary(
+  theme: Theme,
+  request: PermissionRequest,
+  purpose?: string
+): string[] {
+  return buildSelectorSummaryLines(request, purpose).map((line) => {
+    if (!line.label) {
+      return theme.fg("muted", line.value);
+    }
+    if (line.label === "Purpose") {
+      return theme.fg("accent", theme.bold(`${line.label}:`))
+        + theme.fg("muted", ` ${line.value}`);
+    }
+    return theme.fg("accent", theme.bold(`${line.label}:`))
+      + theme.fg("text", ` ${line.value}`);
+  });
 }
 
 /**
- * Label for the "Allow Always" select option.
+ * Label for the "allow always" select option.
  */
 export function formatAllowAlwaysOption(
   request: PermissionRequest,
   policy: PolicyResolution
 ): string {
-  return willGenerateBashWildcard(request, policy)
-    ? ALLOW_ALWAYS_WILDCARD
-    : ALLOW_ALWAYS_EXACT;
+  return resolveAllowAlwaysMode(request, policy) === "exact"
+    ? ALLOW_ALWAYS_EXACT
+    : ALLOW_ALWAYS_WILDCARD;
 }
 
 export function formatBroadWildcardConfirm(pattern: string): string {
   return `This pattern can match many commands:\n\n${pattern}\n\nSave it for this session?`;
 }
+
+export function formatBroadWildcardListConfirm(patterns: readonly string[]): string {
+  return `These patterns can match many commands:\n\n${patterns.join("\n")}\n\nSave them for this session?`;
+}

package/src/warning-strings.ts

@@ -0,0 +1,58 @@
+import { EXTENSION_NAME, PERMISSION_STATES_DESCRIPTION } from "./constants.ts";
+
+export const CONFIG_WARNING_PREFIX = `${EXTENSION_NAME}: `;
+export const INVALID_WILDCARD_PREFIX = "Invalid wildcard: ";
+
+export const CONFIG_MUST_BE_OBJECT =
+  "Permission config must be a JSON object; using defaults.";
+export const IGNORED_DEFAULT_WARNING =
+  `Ignoring "default": expected ${PERMISSION_STATES_DESCRIPTION}.`;
+export const IGNORED_SETTINGS_WARNING =
+  'Ignoring "settings": expected an object.';
+export const IGNORED_AI_MODEL_WARNING =
+  'Ignoring "settings.ai_model": expected a string like "provider/model-id".';
+
+export const WILDCARD_LENGTH_REASON =
+  "Pattern must be between 1 and 500 characters.";
+export const WILDCARD_NO_MATCH_REASON =
+  "Pattern does not match the current command.";
+
+export function formatIgnoredSectionWarning(sectionName: string): string {
+  return `Ignoring "${sectionName}": expected an object mapping names to ${PERMISSION_STATES_DESCRIPTION}.`;
+}
+
+export function formatIgnoredSectionEntryWarning(
+  sectionName: string,
+  key: string
+): string {
+  return `Ignoring "${sectionName}.${key}": expected ${PERMISSION_STATES_DESCRIPTION}.`;
+}
+
+export function formatConfigReadFailure(error: unknown): string {
+  const detail = error instanceof Error ? error.message : String(error);
+  return `Failed to read permission config: ${detail}`;
+}
+
+export function formatConfigParseFailure(error: unknown): string {
+  const detail = error instanceof Error ? error.message : String(error);
+  return `Failed to parse permission config: ${detail}`;
+}
+
+export function formatSuppressedConfigWarnings(suppressed: number): string {
+  return `${suppressed} additional config warning(s) suppressed.`;
+}
+
+export function formatWildcardListCountReason(
+  expected: number,
+  actual: number
+): string {
+  return `Expected ${expected} semicolon-separated pattern(s), got ${actual}.`;
+}
+
+export function formatWildcardListItemReason(
+  index: number,
+  pattern: string,
+  reason: string
+): string {
+  return `Pattern ${index} (${JSON.stringify(pattern)}): ${reason}`;
+}

package/src/wildcard-editor.ts

@@ -0,0 +1,139 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { generateBashWildcard, generateBashWildcards } from "./ai-wildcard.ts";
+import { STATUS_KEY } from "./constants.ts";
+import { resolveAllowAlwaysMode } from "./policy-bash.ts";
+import { analyzeShellCommand } from "./shell.ts";
+import {
+  BROAD_WILDCARD_TITLE,
+  formatBroadWildcardConfirm,
+  formatBroadWildcardListConfirm,
+  STATUS_GENERATING_WILDCARD,
+  WILDCARD_EDITOR_TITLE,
+  WILDCARD_LIST_EDITOR_TITLE,
+} from "./ui-strings.ts";
+import { INVALID_WILDCARD_PREFIX } from "./warning-strings.ts";
+import {
+  validateWildcardSuggestion,
+  validateWildcardSuggestionList,
+} from "./wildcard-validation.ts";
+import type {
+  AllowAlwaysRule,
+  PermissionRequest,
+  PolicyResolution,
+} from "./types.ts";
+
+/**
+ * Single-command wildcard path.
+ */
+async function chooseSingleWildcard(
+  ctx: ExtensionContext,
+  command: string,
+  aiModel?: string
+): Promise<AllowAlwaysRule | undefined> {
+  ctx.ui.setStatus(STATUS_KEY, STATUS_GENERATING_WILDCARD);
+  let suggestion: string | undefined;
+  try {
+    suggestion = await generateBashWildcard(ctx, command, aiModel);
+  } finally {
+    ctx.ui.setStatus(STATUS_KEY, undefined);
+  }
+
+  let current = suggestion ?? command;
+  while (true) {
+    const edited = await ctx.ui.editor(WILDCARD_EDITOR_TITLE, current);
+    if (edited === undefined) {return undefined;}
+
+    const pattern = edited.trim();
+    const validation = validateWildcardSuggestion(pattern, command);
+    if (!validation.valid) {
+      ctx.ui.notify(`${INVALID_WILDCARD_PREFIX}${validation.reason}`, "warning");
+      current = pattern || command;
+      continue;
+    }
+
+    if (validation.broad) {
+      const confirmed = await ctx.ui.confirm(
+        BROAD_WILDCARD_TITLE,
+        formatBroadWildcardConfirm(pattern)
+      );
+      if (!confirmed) {
+        current = pattern;
+        continue;
+      }
+    }
+
+    return { kind: "wildcard", tool: "bash", body: pattern };
+  }
+}
+
+/**
+ * Multi-command wildcard path.
+ */
+async function chooseWildcardListRules(
+  ctx: ExtensionContext,
+  commands: readonly string[],
+  aiModel?: string
+): Promise<AllowAlwaysRule[] | undefined> {
+  ctx.ui.setStatus(STATUS_KEY, STATUS_GENERATING_WILDCARD);
+  let suggestion: string[] | undefined;
+  try {
+    suggestion = await generateBashWildcards(ctx, commands, aiModel);
+  } finally {
+    ctx.ui.setStatus(STATUS_KEY, undefined);
+  }
+
+  let current = (suggestion ?? commands).join("; ");
+  while (true) {
+    const edited = await ctx.ui.editor(WILDCARD_LIST_EDITOR_TITLE, current);
+    if (edited === undefined) {return undefined;}
+
+    const validation = validateWildcardSuggestionList(edited, commands);
+    if (!validation.valid) {
+      ctx.ui.notify(`${INVALID_WILDCARD_PREFIX}${validation.reason}`, "warning");
+      current = edited.trim() || commands.join("; ");
+      continue;
+    }
+
+    if (validation.broadPatterns.length > 0) {
+      const confirmed = await ctx.ui.confirm(
+        BROAD_WILDCARD_TITLE,
+        formatBroadWildcardListConfirm(validation.broadPatterns)
+      );
+      if (!confirmed) {
+        current = validation.patterns.join("; ");
+        continue;
+      }
+    }
+
+    return validation.patterns.map((pattern) => ({
+      kind: "wildcard" as const,
+      tool: "bash" as const,
+      body: pattern,
+    }));
+  }
+}
+
+/**
+ * Selects the "allow always" matching rules for the request.
+ */
+export async function chooseAlwaysRules(
+  ctx: ExtensionContext,
+  request: PermissionRequest,
+  policy: PolicyResolution,
+  aiModel?: string
+): Promise<AllowAlwaysRule[] | undefined> {
+  const mode = resolveAllowAlwaysMode(request, policy);
+
+  if (mode === "wildcard") {
+    const rule = await chooseSingleWildcard(ctx, request.body, aiModel);
+    return rule ? [rule] : undefined;
+  }
+
+  if (mode === "wildcard-list") {
+    const analysis = request.bashAnalysis ?? analyzeShellCommand(request.body);
+    return chooseWildcardListRules(ctx, analysis.segments, aiModel);
+  }
+
+  return [{ kind: "exact", tool: request.toolName, body: request.body }];
+}

package/src/wildcard-validation.ts

@@ -3,6 +3,29 @@ import {
   isValidWildcardPattern,
   matchesWildcard,
 } from "./matcher.ts";
+import {
+  formatWildcardListCountReason,
+  formatWildcardListItemReason,
+  WILDCARD_LENGTH_REASON,
+  WILDCARD_NO_MATCH_REASON,
+} from "./warning-strings.ts";
+
+export type WildcardValidationResult = {
+  valid: true;
+  broad: boolean;
+} | {
+  valid: false;
+  reason: string;
+};
+
+export type WildcardListValidationResult = {
+  valid: true;
+  patterns: string[];
+  broadPatterns: string[];
+} | {
+  valid: false;
+  reason: string;
+};
 
 /**
  * Validates a wildcard pattern against a command.
@@ -10,12 +33,54 @@ import {
 export function validateWildcardSuggestion(
   pattern: string,
   command: string
-): { valid: true; broad: boolean } | { valid: false; reason: string } {
+): WildcardValidationResult {
   if (!isValidWildcardPattern(pattern)) {
-    return { valid: false, reason: "Pattern must be between 1 and 500 characters." };
+    return { valid: false, reason: WILDCARD_LENGTH_REASON };
   }
   if (!matchesWildcard(pattern, command)) {
-    return { valid: false, reason: "Pattern does not match the current command." };
+    return { valid: false, reason: WILDCARD_NO_MATCH_REASON };
   }
   return { valid: true, broad: isMatchEverythingPattern(pattern) };
 }
+
+/**
+ * Splits a semicolon-separated wildcard list from the model or editor.
+ */
+export function splitWildcardList(value: string): string[] {
+  return value
+    .split(";")
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
+
+/**
+ * Validates semicolon-separated patterns against a list of commands.
+ */
+export function validateWildcardSuggestionList(
+  patternsText: string,
+  commands: readonly string[]
+): WildcardListValidationResult {
+  const patterns = splitWildcardList(patternsText);
+  if (patterns.length !== commands.length) {
+    return {
+      valid: false,
+      reason: formatWildcardListCountReason(commands.length, patterns.length),
+    };
+  }
+
+  const broadPatterns: string[] = [];
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index]!;
+    const command = commands[index]!;
+    const result = validateWildcardSuggestion(pattern, command);
+    if (!result.valid) {
+      return {
+        valid: false,
+        reason: formatWildcardListItemReason(index+1, pattern, result.reason),
+      };
+    }
+    if (result.broad) {broadPatterns.push(pattern);}
+  }
+
+  return { valid: true, patterns, broadPatterns };
+}