@czottmann/pi-automode 1.11.0 → 1.13.0

package/extensions/auto-mode/config.ts

@@ -1,8 +1,17 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { dirname, resolve } from "node:path";
 import {
   DEFAULT_ALLOW,
   DEFAULT_ALLOW_INSIDE_WORKING_DIRECTORY,
+  DEFAULT_CLASSIFIER_TIMEOUT_MS,
   DEFAULT_CLASSIFY_READ_ONLY_TOOLS,
   DEFAULT_DENIED_PATHS,
   DEFAULT_ENVIRONMENT,
@@ -14,10 +23,14 @@ import {
   DEFAULT_PROTECTED_PATHS,
   DEFAULT_SOFT_DENY,
   PI_GLOBAL_SETTINGS,
+  PI_LEGACY_GLOBAL_SETTINGS,
   PI_PROJECT_LOCAL_SETTINGS,
   PI_PROJECT_SHARED_SETTINGS,
 } from "./constants.ts";
-import { parseToolPattern } from "./permissions.ts";
+import {
+  MAX_WILDCARD_PATTERN_LENGTH,
+  parseToolPattern,
+} from "./permissions.ts";
 import type {
   AutoModeSettings,
   ClassifierReasoningLevel,
@@ -31,6 +44,169 @@ import type {
 } from "./types.ts";
 import { hasOwn, stringArray } from "./utils.ts";
 
+export type GlobalConfigPreparation = {
+  status: "current" | "migrated" | "conflict" | "failed";
+  activePath: string;
+  diagnostic?: string;
+  notification?: string;
+  writeBlockedReason?: string;
+};
+
+export type PrepareGlobalConfigOptions = {
+  currentPath?: string;
+  legacyPath?: string;
+  moveFile?: (source: string, destination: string) => void;
+  unlinkFile?: (path: string) => void;
+};
+
+function sameFileIdentity(firstPath: string, secondPath: string): boolean {
+  try {
+    const first = lstatSync(firstPath);
+    const second = lstatSync(secondPath);
+    return first.dev === second.dev && first.ino === second.ino;
+  } catch {
+    return false;
+  }
+}
+
+function cleanupPublishedDestination(
+  destination: string,
+  unlinkFile: (path: string) => void,
+  originalError: unknown,
+): AggregateError | undefined {
+  try {
+    unlinkFile(destination);
+    return undefined;
+  } catch (cleanupError) {
+    return new AggregateError(
+      [originalError, cleanupError],
+      `Could not clean up interrupted Auto Mode config migration at ${destination}`,
+    );
+  }
+}
+
+function moveFileWithoutOverwrite(
+  source: string,
+  destination: string,
+  unlinkFile: (path: string) => void,
+): void {
+  linkSync(source, destination);
+  try {
+    unlinkFile(source);
+  } catch (error) {
+    throw cleanupPublishedDestination(destination, unlinkFile, error) ?? error;
+  }
+}
+
+function globalConfigFailure(
+  currentPath: string,
+  legacyPath: string,
+  error: unknown,
+  writeBlockedReason?: string,
+): GlobalConfigPreparation {
+  const message =
+    `Could not move Auto Mode config from ${legacyPath} to ${currentPath}: ${
+      error instanceof Error ? error.message : String(error)
+    }. Using the legacy config for this session${
+      writeBlockedReason ? "; global config writes are disabled" : ""
+    }.`;
+  return {
+    status: "failed",
+    activePath: legacyPath,
+    diagnostic: message,
+    notification: message,
+    writeBlockedReason,
+  };
+}
+
+function globalConfigConflict(
+  currentPath: string,
+  legacyPath: string,
+): GlobalConfigPreparation {
+  const message =
+    `Auto Mode config conflict: using ${currentPath}; legacy config ${legacyPath} is ignored and was not changed.`;
+  return {
+    status: "conflict",
+    activePath: currentPath,
+    diagnostic: message,
+    notification: message,
+  };
+}
+
+/** Select one global config path for this runtime and migrate a legacy file when possible. */
+export function prepareGlobalConfig(
+  options: PrepareGlobalConfigOptions = {},
+): GlobalConfigPreparation {
+  const currentPath = options.currentPath ?? PI_GLOBAL_SETTINGS[0];
+  const legacyPath = options.legacyPath ?? PI_LEGACY_GLOBAL_SETTINGS;
+  const currentExists = existsSync(currentPath);
+  const legacyExists = existsSync(legacyPath);
+  const unlinkFile = options.unlinkFile ?? unlinkSync;
+
+  if (currentExists && legacyExists) {
+    if (!sameFileIdentity(currentPath, legacyPath)) {
+      return globalConfigConflict(currentPath, legacyPath);
+    }
+    try {
+      unlinkFile(legacyPath);
+      return {
+        status: "migrated",
+        activePath: currentPath,
+        notification:
+          `Completed interrupted Auto Mode config migration from ${legacyPath} to ${currentPath}.`,
+      };
+    } catch (error) {
+      const cleanupError = cleanupPublishedDestination(
+        currentPath,
+        unlinkFile,
+        error,
+      );
+      return globalConfigFailure(
+        currentPath,
+        legacyPath,
+        cleanupError ?? error,
+        cleanupError?.message,
+      );
+    }
+  }
+  if (currentExists || !legacyExists) {
+    return { status: "current", activePath: currentPath };
+  }
+
+  try {
+    mkdirSync(dirname(currentPath), { recursive: true });
+    const moveFile = options.moveFile ??
+      ((source: string, destination: string) =>
+        moveFileWithoutOverwrite(source, destination, unlinkFile));
+    moveFile(legacyPath, currentPath);
+    return {
+      status: "migrated",
+      activePath: currentPath,
+      notification: `Moved Auto Mode config from ${legacyPath} to ${currentPath}.`,
+    };
+  } catch (error) {
+    if (existsSync(currentPath)) {
+      if (!sameFileIdentity(currentPath, legacyPath)) {
+        return globalConfigConflict(currentPath, legacyPath);
+      }
+      const cleanupError = cleanupPublishedDestination(
+        currentPath,
+        unlinkFile,
+        error,
+      );
+      if (cleanupError) {
+        return globalConfigFailure(
+          currentPath,
+          legacyPath,
+          cleanupError,
+          cleanupError.message,
+        );
+      }
+    }
+    return globalConfigFailure(currentPath, legacyPath, error);
+  }
+}
+
 function readSettingsFile(path: string): LoadedSettingsFile | undefined {
   if (!existsSync(path)) return undefined;
   try {
@@ -103,6 +279,7 @@ export function validateSettingsFile(
         "enabled",
         "classifierModel",
         "classifierReasoningLevel",
+        "classifierTimeoutMs",
         "classifyReadOnlyTools",
         "fastClassifierMaxTokens",
         "allowInsideWorkingDirectory",
@@ -144,6 +321,15 @@ export function validateSettingsFile(
           `${source}: autoMode.classifierReasoningLevel must be one of low, medium, high, xhigh, max`,
         );
       }
+      if (
+        hasOwn(autoMode, "classifierTimeoutMs") &&
+        (!Number.isInteger(autoMode.classifierTimeoutMs) ||
+          (autoMode.classifierTimeoutMs as number) < 1000)
+      ) {
+        diagnostics.push(
+          `${source}: autoMode.classifierTimeoutMs must be an integer of at least 1000`,
+        );
+      }
       if (
         hasOwn(autoMode, "classifyReadOnlyTools") &&
         typeof autoMode.classifyReadOnlyTools !== "boolean"
@@ -235,11 +421,11 @@ export function validateSettingsFile(
     } else {
       const permissions = settings.permissions as Record<string, unknown>;
       for (const key of Object.keys(permissions)) {
-        if (key !== "deny" && key !== "ask") {
+        if (key !== "deny" && key !== "ask" && key !== "allow") {
           diagnostics.push(`${source}: unknown permissions key ${key}`);
         }
       }
-      for (const key of ["deny", "ask"] as const) {
+      for (const key of ["deny", "ask", "allow"] as const) {
         const value = permissions[key];
         if (value === undefined) continue;
         if (!Array.isArray(value)) {
@@ -253,6 +439,10 @@ export function validateSettingsFile(
             diagnostics.push(
               `${source}: permissions.${key}[${index}] must be a tool pattern string`,
             );
+          } else if (entry.length > MAX_WILDCARD_PATTERN_LENGTH) {
+            diagnostics.push(
+              `${source}: permissions.${key}[${index}] must be at most ${MAX_WILDCARD_PATTERN_LENGTH} characters`,
+            );
           }
         }
       }
@@ -265,28 +455,36 @@ export function validateSettingsFile(
 type RuleAccumulator = {
   defaults: string[];
   includeDefaults: boolean;
-  seen: boolean;
   entries: string[];
 };
 
 function createRuleAccumulator(defaults: string[]): RuleAccumulator {
-  return { defaults, includeDefaults: true, seen: false, entries: [] };
+  return { defaults, includeDefaults: true, entries: [] };
 }
 
-function applyRuleSetting(accumulator: RuleAccumulator, value: unknown): void {
+function applyRuleSetting(
+  accumulator: RuleAccumulator,
+  value: unknown,
+  acceptEntry: (entry: string) => boolean = () => true,
+): void {
   const entries = stringArray(value);
   if (!entries) return;
-  accumulator.seen = true;
-  accumulator.includeDefaults = entries.includes("$defaults");
+  // Any entry that stringArray or acceptEntry drops marks the list malformed.
+  // Fail conservative: keep defaults rather than replace them with a partial list.
+  let malformed = Array.isArray(value) && value.length !== entries.length;
   for (const entry of entries) {
-    if (entry !== "$defaults") accumulator.entries.push(entry);
+    if (entry === "$defaults") continue;
+    if (acceptEntry(entry)) {
+      accumulator.entries.push(entry);
+    } else {
+      malformed = true;
+    }
   }
+  accumulator.includeDefaults = entries.includes("$defaults") || malformed;
 }
 
 function finalizeRuleSetting(accumulator: RuleAccumulator): string[] {
-  const base = accumulator.includeDefaults || !accumulator.seen
-    ? accumulator.defaults
-    : [];
+  const base = accumulator.includeDefaults ? accumulator.defaults : [];
   return [...new Set([...base, ...accumulator.entries])];
 }
 
@@ -316,8 +514,8 @@ function mergeLog(
 ): LogConfig {
   if (!patch) return base;
   return {
-    enabled: patch.enabled ?? base.enabled,
-    classifierIo: patch.classifierIo ?? base.classifierIo,
+    enabled: typeof patch.enabled === "boolean" ? patch.enabled : base.enabled,
+    classifierIo: typeof patch.classifierIo === "boolean" ? patch.classifierIo : base.classifierIo,
   };
 }
 
@@ -345,6 +543,12 @@ function validateDeniedPathsSetting(
       );
       continue;
     }
+    if (entry.length > MAX_WILDCARD_PATTERN_LENGTH) {
+      diagnostics.push(
+        `${source}: deniedPaths[${index}] must be at most ${MAX_WILDCARD_PATTERN_LENGTH} characters`,
+      );
+      continue;
+    }
     if (!DENIED_PATH_PATTERN_PREFIX.test(entry)) {
       diagnostics.push(
         `${source}: deniedPaths[${index}] "${entry}" can never match a resolved absolute path; start it with *, ~, $HOME, \${HOME}, or / (e.g. "**/${entry}")`,
@@ -386,6 +590,10 @@ function validFastClassifierBudget(value: unknown): value is number {
   return Number.isInteger(value) && Number(value) >= 16;
 }
 
+function validClassifierTimeout(value: unknown): value is number {
+  return Number.isInteger(value) && Number(value) >= 1000;
+}
+
 function applyAutoModeScalars(
   base: EffectiveConfig,
   settings: AutoModeSettings | undefined,
@@ -393,22 +601,28 @@ function applyAutoModeScalars(
   if (!settings) return base;
   return {
     ...base,
-    enabled: settings.enabled ?? base.enabled,
+    enabled: typeof settings.enabled === "boolean" ? settings.enabled : base.enabled,
     classifierModel: settings.classifierModel ?? base.classifierModel,
     classifierReasoningLevel: isClassifierReasoningLevel(
         settings.classifierReasoningLevel,
       )
       ? settings.classifierReasoningLevel
       : base.classifierReasoningLevel,
-    classifyReadOnlyTools: settings.classifyReadOnlyTools ??
-      base.classifyReadOnlyTools,
+    classifyReadOnlyTools: typeof settings.classifyReadOnlyTools === "boolean"
+      ? settings.classifyReadOnlyTools
+      : base.classifyReadOnlyTools,
     allowInsideWorkingDirectory:
-      settings.allowInsideWorkingDirectory ?? base.allowInsideWorkingDirectory,
+      typeof settings.allowInsideWorkingDirectory === "boolean"
+        ? settings.allowInsideWorkingDirectory
+        : base.allowInsideWorkingDirectory,
     fastClassifierMaxTokens: validFastClassifierBudget(
         settings.fastClassifierMaxTokens,
       )
       ? settings.fastClassifierMaxTokens
       : base.fastClassifierMaxTokens,
+    classifierTimeoutMs: validClassifierTimeout(settings.classifierTimeoutMs)
+      ? settings.classifierTimeoutMs
+      : base.classifierTimeoutMs,
     maxUserTranscriptTokens: validTranscriptBudget(
         settings.maxUserTranscriptTokens,
       )
@@ -426,11 +640,12 @@ function applyAutoModeScalars(
 function appendPermissionPatterns(
   target: ToolPattern[],
   settings: SettingsFile | undefined,
-  key: "deny" | "ask",
+  key: "deny" | "ask" | "allow",
 ): void {
   const values = stringArray(settings?.permissions?.[key]);
   if (!values) return;
   for (const value of values) {
+    if (value.length > MAX_WILDCARD_PATTERN_LENGTH) continue;
     const pattern = parseToolPattern(value);
     if (pattern) target.push(pattern);
   }
@@ -440,8 +655,9 @@ function appendPermissionPatterns(
  * Merge settings with Claude Code-style precedence using Pi-owned config files.
  *
  * Important details:
- * - shared project `.pi/automode.json` contributes `permissions.*` but not `autoMode`,
- *   so a checked-in repo cannot weaken classifier rules;
+ * - shared project `.pi/automode.json` contributes `permissions.deny` and
+ *   `permissions.ask` but not `permissions.allow` or `autoMode`, so checked-in
+ *   config can only add permission barriers;
  * - global, project-local, and inline `autoMode` settings combine additively across scopes;
  * - omitting `$defaults` in any scope for a rule list means "replace built-ins" for that list.
  */
@@ -454,6 +670,7 @@ export function buildEffectiveConfigFromSources(
     allowInsideWorkingDirectory: DEFAULT_ALLOW_INSIDE_WORKING_DIRECTORY,
     deniedPaths: [...DEFAULT_DENIED_PATHS],
     fastClassifierMaxTokens: DEFAULT_FAST_CLASSIFIER_MAX_TOKENS,
+    classifierTimeoutMs: DEFAULT_CLASSIFIER_TIMEOUT_MS,
     maxUserTranscriptTokens: DEFAULT_MAX_USER_TRANSCRIPT_TOKENS,
     maxToolTranscriptTokens: DEFAULT_MAX_TOOL_TRANSCRIPT_TOKENS,
     environment: [...DEFAULT_ENVIRONMENT],
@@ -463,6 +680,7 @@ export function buildEffectiveConfigFromSources(
     hardDeny: [...DEFAULT_HARD_DENY],
     permissionDeny: [],
     permissionAsk: [],
+    permissionAllow: [],
     log: { ...DEFAULT_LOG_CONFIG },
   };
 
@@ -488,7 +706,11 @@ export function buildEffectiveConfigFromSources(
     applyRuleSetting(environment, settings.autoMode?.environment);
     applyRuleSetting(allow, settings.autoMode?.allow);
     applyRuleSetting(protectedPaths, settings.autoMode?.protectedPaths);
-    applyRuleSetting(deniedPaths, settings.autoMode?.deniedPaths);
+    applyRuleSetting(
+      deniedPaths,
+      settings.autoMode?.deniedPaths,
+      (entry) => entry.length <= MAX_WILDCARD_PATTERN_LENGTH,
+    );
     applyRuleSetting(
       softDeny,
       settings.autoMode?.soft_deny ?? settings.autoMode?.softDeny,
@@ -520,6 +742,15 @@ export function buildEffectiveConfigFromSources(
     appendPermissionPatterns(config.permissionDeny, settings, "deny");
     appendPermissionPatterns(config.permissionAsk, settings, "ask");
   }
+  for (
+    const settings of [
+      ...globalSettings,
+      ...projectLocalSettings,
+      ...inlineSettings,
+    ]
+  ) {
+    appendPermissionPatterns(config.permissionAllow, settings, "allow");
+  }
 
   return config;
 }
@@ -536,9 +767,23 @@ function loadedSettingsDiagnostics(
   return files.flatMap((file) => file?.diagnostics ?? []);
 }
 
-/** Load config from disk and environment variables, including diagnostics for `/automode config`. */
+function ignoredSharedAllowDiagnostics(
+  files: Array<LoadedSettingsFile | undefined>,
+): string[] {
+  return files.flatMap((file) => {
+    const permissions = file?.settings?.permissions;
+    if (!file || !permissions || !hasOwn(permissions, "allow")) return [];
+    return [
+      `${file.path}: permissions.allow is ignored in shared project config. Use a user-owned config source instead`,
+    ];
+  });
+}
+
+/** Load config from disk and environment variables, including diagnostics for `/automode config`. Project files require explicit trust. */
 export function loadEffectiveConfigWithDiagnostics(
   cwd: string,
+  projectTrusted = false,
+  globalSettingsPath = PI_GLOBAL_SETTINGS[0],
 ): ConfigLoadResult {
   const inlineSettings: SettingsFile[] = [];
   const diagnostics: string[] = [];
@@ -560,18 +805,36 @@ export function loadEffectiveConfigWithDiagnostics(
     }
   }
 
-  const globalFiles = PI_GLOBAL_SETTINGS.map(readSettingsFile);
-  const projectLocalFiles = PI_PROJECT_LOCAL_SETTINGS.map((file) =>
-    readSettingsFile(resolve(cwd, file))
+  const globalFiles = [readSettingsFile(globalSettingsPath)];
+  const projectLocalPaths = PI_PROJECT_LOCAL_SETTINGS.map((file) =>
+    resolve(cwd, file)
   );
-  const projectSharedFiles = PI_PROJECT_SHARED_SETTINGS.map((file) =>
-    readSettingsFile(resolve(cwd, file))
+  const projectSharedPaths = PI_PROJECT_SHARED_SETTINGS.map((file) =>
+    resolve(cwd, file)
   );
+  const projectLocalFiles = projectTrusted
+    ? projectLocalPaths.map(readSettingsFile)
+    : [];
+  const projectSharedFiles = projectTrusted
+    ? projectSharedPaths.map(readSettingsFile)
+    : [];
+  if (!projectTrusted) {
+    for (
+      const path of [...projectLocalPaths, ...projectSharedPaths].filter(
+        existsSync,
+      )
+    ) {
+      diagnostics.push(`${path}: ignored because project is not trusted`);
+    }
+  }
   const fileDiagnostics = loadedSettingsDiagnostics([
     ...globalFiles,
     ...projectLocalFiles,
     ...projectSharedFiles,
   ]);
+  const sharedAllowDiagnostics = ignoredSharedAllowDiagnostics(
+    projectSharedFiles,
+  );
 
   return {
     config: buildEffectiveConfigFromSources({
@@ -580,13 +843,25 @@ export function loadEffectiveConfigWithDiagnostics(
       projectSharedSettings: loadedSettingsToSettings(projectSharedFiles),
       inlineSettings,
     }),
-    diagnostics: [...fileDiagnostics, ...diagnostics],
+    diagnostics: [
+      ...fileDiagnostics,
+      ...sharedAllowDiagnostics,
+      ...diagnostics,
+    ],
   };
 }
 
 /** Load config from disk and environment variables. Exported for tests and diagnostics. */
-export function loadEffectiveConfig(cwd: string): EffectiveConfig {
-  return loadEffectiveConfigWithDiagnostics(cwd).config;
+export function loadEffectiveConfig(
+  cwd: string,
+  projectTrusted = false,
+  globalSettingsPath = PI_GLOBAL_SETTINGS[0],
+): EffectiveConfig {
+  return loadEffectiveConfigWithDiagnostics(
+    cwd,
+    projectTrusted,
+    globalSettingsPath,
+  ).config;
 }
 
 function readWritableSettingsFile(path: string): SettingsFile {

package/extensions/auto-mode/constants.ts

@@ -59,6 +59,9 @@ export const DEFAULT_MAX_USER_TRANSCRIPT_TOKENS = 4000;
 export const DEFAULT_MAX_TOOL_TRANSCRIPT_TOKENS = 4000;
 export const DENIAL_HISTORY_LIMIT = 12;
 
+/** Per-request timeout for classifier completions (fast and detailed stages). */
+export const DEFAULT_CLASSIFIER_TIMEOUT_MS = 20_000;
+
 /** Built-in trusted environment. Users extend this with `$defaults`. */
 export const DEFAULT_ENVIRONMENT = [
   "Trusted repo: the repository pi started in and its configured git remotes.",
@@ -161,7 +164,10 @@ Valid decision/tier combinations:
 - block: hard_deny, soft_deny, or none
 If an allow exception or explicit user intent overrides a soft-deny rule, return allow with tier allow or explicit_intent, never soft_deny.`;
 
-export const PI_GLOBAL_SETTINGS = [resolve(HOME, ".pi/agent/automode.json")];
+export const PI_GLOBAL_SETTINGS = [
+  resolve(HOME, ".pi/agent/extensions/pi-automode/config.json"),
+];
+export const PI_LEGACY_GLOBAL_SETTINGS = resolve(HOME, ".pi/agent/automode.json");
 export const PI_PROJECT_LOCAL_SETTINGS = [".pi/automode.local.json"];
 export const PI_PROJECT_SHARED_SETTINGS = [".pi/automode.json"];