@mystilleef/pi-subagent 0.7.0 → 0.9.0

package/src/progress/result-details.ts

@@ -16,6 +16,7 @@ import {
   patchProgressState,
   renderToolActivity,
 } from "./progress.js";
+import { SENSITIVE_PATTERN } from "./progress-state.js";
 
 export function hasSubagentFailed(result: SingleResult): boolean {
   return (
@@ -41,6 +42,46 @@ export function createSubagentError(result: SingleResult): Error {
   return new Error(`Agent ${result.stopReason || "failed"}: ${msg}`);
 }
 
+const DEBUG_REDACTED_PLACEHOLDER = "[redacted]";
+const SENSITIVE_ASSIGNMENT_PATTERN =
+  /\b(?:secret|password|[A-Za-z0-9_-]*token)(?:\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi;
+const SENSITIVE_TERM_PATTERN = new RegExp(SENSITIVE_PATTERN.source, "gi");
+const TOKEN_COUNT_KEY_PATTERN = /tokens$/i;
+
+function redactSensitiveDebugString(text: string): string {
+  return text
+    .replace(SENSITIVE_ASSIGNMENT_PATTERN, DEBUG_REDACTED_PLACEHOLDER)
+    .replace(SENSITIVE_TERM_PATTERN, DEBUG_REDACTED_PLACEHOLDER);
+}
+
+function isSensitiveDebugKey(key: string): boolean {
+  const lowerKey = key.toLowerCase();
+  if (TOKEN_COUNT_KEY_PATTERN.test(lowerKey)) return false;
+  return (
+    lowerKey.includes("secret") ||
+    lowerKey.includes("password") ||
+    lowerKey.endsWith("token")
+  );
+}
+
+function redactSensitiveDebugValue(value: unknown): unknown {
+  if (typeof value === "string") return redactSensitiveDebugString(value);
+  if (Array.isArray(value)) return value.map(redactSensitiveDebugValue);
+  if (typeof value !== "object" || value === null) return value;
+  const redacted: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value)) {
+    redacted[key] = isSensitiveDebugKey(key)
+      ? DEBUG_REDACTED_PLACEHOLDER
+      : redactSensitiveDebugValue(child);
+  }
+  return redacted;
+}
+
+function redactSensitiveDebugMessages(messages: unknown): unknown {
+  if (!Array.isArray(messages)) return messages;
+  return messages.map(redactSensitiveDebugValue);
+}
+
 export function sanitizeDetailsForDisplay(
   details: SubagentDetails,
   includeMessages = false,
@@ -50,9 +91,11 @@ export function sanitizeDetailsForDisplay(
     results: details.results.map(({ messages, termination, ...result }) => ({
       ...result,
       stderr: includeMessages ? result.stderr : "",
-      ...(includeMessages ? { messages, termination } : {}),
+      ...(includeMessages
+        ? { messages: redactSensitiveDebugMessages(messages), termination }
+        : {}),
     })),
-  };
+  } as SubagentDetails;
 }
 
 export function getLatestResult(
@@ -90,26 +133,27 @@ export function patchProgressFromDetails(
     nextActivity = current.activeToolActivity;
   }
   if (toolResultCompleted && nextActivity?.child) {
-    nextActivity = { ...nextActivity, child: undefined };
+    const { child: _child, ...rest } = nextActivity;
+    nextActivity = rest;
   } else if (toolResultCompleted) {
     nextActivity = undefined;
   }
-  patch.activeToolActivity = nextActivity;
+  patch["activeToolActivity"] = nextActivity;
   const renderedPreview = renderToolActivity(nextActivity);
   if (renderedPreview) {
-    patch.lastToolPreview = renderedPreview;
+    patch["lastToolPreview"] = renderedPreview;
   } else if (toolResultCompleted && !nextActivity) {
-    patch.lastToolPreview = undefined;
+    patch["lastToolPreview"] = undefined;
   }
   if (toolResultCompleted) {
-    patch.toolResultCompleted = true;
+    patch["toolResultCompleted"] = true;
   }
   // Token accounting always applies when usage data is available
   if (latestResult?.usage) {
-    patch.inputTokens = latestResult.usage.input;
-    patch.outputTokens = latestResult.usage.output;
-    patch.contextTokens = latestResult.usage.contextTokens;
-    patch.contextWindowTokens = latestResult.usage.contextWindowTokens;
+    patch["inputTokens"] = latestResult.usage.input;
+    patch["outputTokens"] = latestResult.usage.output;
+    patch["contextTokens"] = latestResult.usage.contextTokens;
+    patch["contextWindowTokens"] = latestResult.usage.contextWindowTokens;
   }
   patchProgressState(
     requestId,

package/src/shared/types.ts

@@ -15,9 +15,9 @@ export interface UsageStats {
 
 export interface ToolActivity {
   toolName: string;
-  inputSummary?: string;
-  instanceName?: string;
-  child?: ToolActivity;
+  inputSummary?: string | undefined;
+  instanceName?: string | undefined;
+  child?: ToolActivity | undefined;
 }
 
 export interface StreamingProgressToolCall {
@@ -26,30 +26,30 @@ export interface StreamingProgressToolCall {
 }
 
 export interface StreamingProgress {
-  activityText?: string;
-  activeToolActivity?: ToolActivity;
+  activityText?: string | undefined;
+  activeToolActivity?: ToolActivity | undefined;
   toolCalls: StreamingProgressToolCall[];
-  lastToolPreview?: string;
-  toolResultCompleted?: boolean;
+  lastToolPreview?: string | undefined;
+  toolResultCompleted?: boolean | undefined;
 }
 
 export interface SingleResult {
   agent: string;
-  instanceName?: string;
+  instanceName?: string | undefined;
   agentSource: "user" | "project" | "unknown";
   task: string;
   exitCode: number;
   finalOutput: string;
   stderr: string;
   usage: UsageStats;
-  model?: string;
-  stopReason?: string;
-  errorMessage?: string;
-  durationMs?: number;
-  progress?: StreamingProgress;
-  messages?: Message[];
-  termination?: TerminationMetadata;
-  thinkingWarning?: string;
+  model?: string | undefined;
+  stopReason?: string | undefined;
+  errorMessage?: string | undefined;
+  durationMs?: number | undefined;
+  progress?: StreamingProgress | undefined;
+  messages?: Message[] | undefined;
+  termination?: TerminationMetadata | undefined;
+  thinkingWarning?: string | undefined;
 }
 
 export interface SubagentDetails {

package/src/shared/utils.ts

@@ -9,35 +9,63 @@ import {
 
 export const DEFAULT_MAX_OUTPUT_BYTES = 50_000;
 export const DEFAULT_MAX_OUTPUT_LINES = 500;
+export const DEFAULT_AGENT_END_GRACE_MS = 250;
+export const DEFAULT_MAX_STDERR_BYTES = 10_000;
+export const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+export const MAX_SUBAGENT_DEPTH_CEILING = 10;
 
 export interface SubagentOutputLimits {
   maxBytes: number;
   maxLines: number;
 }
 
-type OutputLimitConfig = Partial<Record<string, string | number | undefined>>;
+export interface SubagentRuntimeLimits {
+  agentEndGraceMs: number;
+  maxStderrBytes: number;
+  maxDepth: number;
+}
+
+type EnvLimitConfig = Partial<Record<string, string | number | undefined>>;
 
 function parsePositiveInteger(
   value: string | number | undefined,
 ): number | undefined {
   const parsed = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(parsed) || parsed < 1) return undefined;
-  return Math.floor(parsed);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 1)
+    return undefined;
+  return parsed;
 }
 
 export function getSubagentOutputLimits(
-  config: OutputLimitConfig = process.env,
+  config: EnvLimitConfig = process.env,
 ): SubagentOutputLimits {
   return {
     maxBytes:
-      parsePositiveInteger(config.PI_SUBAGENT_MAX_OUTPUT_BYTES) ??
+      parsePositiveInteger(config["PI_SUBAGENT_MAX_OUTPUT_BYTES"]) ??
       DEFAULT_MAX_OUTPUT_BYTES,
     maxLines:
-      parsePositiveInteger(config.PI_SUBAGENT_MAX_OUTPUT_LINES) ??
+      parsePositiveInteger(config["PI_SUBAGENT_MAX_OUTPUT_LINES"]) ??
       DEFAULT_MAX_OUTPUT_LINES,
   };
 }
 
+export function getSubagentRuntimeLimits(
+  config: EnvLimitConfig = process.env,
+): SubagentRuntimeLimits {
+  const maxDepth =
+    parsePositiveInteger(config["PI_SUBAGENT_MAX_DEPTH"]) ??
+    DEFAULT_MAX_SUBAGENT_DEPTH;
+  return {
+    agentEndGraceMs:
+      parsePositiveInteger(config["PI_SUBAGENT_AGENT_END_GRACE_MS"]) ??
+      DEFAULT_AGENT_END_GRACE_MS,
+    maxStderrBytes:
+      parsePositiveInteger(config["PI_SUBAGENT_MAX_STDERR_BYTES"]) ??
+      DEFAULT_MAX_STDERR_BYTES,
+    maxDepth: Math.min(maxDepth, MAX_SUBAGENT_DEPTH_CEILING),
+  };
+}
+
 export function truncateOutput(
   text: string,
   limits: SubagentOutputLimits = getSubagentOutputLimits(),
@@ -89,15 +117,54 @@ export function getPiInvocation(args: string[]): {
   return { command: "pi", args };
 }
 
+const SKILL_DISCOVERY_CACHE_TTL_MS = 300_000;
+
+type ResolvedSkillArgsCacheEntry = {
+  skillPaths: Map<string, string>;
+  ts: number;
+};
+
+const resolvedSkillArgsCache = new Map<string, ResolvedSkillArgsCacheEntry>();
+
+async function canonicalPath(filePath: string): Promise<string> {
+  try {
+    return await fs.promises.realpath(filePath);
+  } catch {
+    return path.resolve(filePath);
+  }
+}
+
+function buildSkillArgs(
+  requested: string[],
+  skillPaths: Map<string, string>,
+): string[] {
+  return requested.flatMap((name) => ["--skill", skillPaths.get(name) ?? name]);
+}
+
+export function resetResolvedAgentSkillArgsCache(): void {
+  resolvedSkillArgsCache.clear();
+}
+
 export async function resolveAgentSkillArgs(
   cwd: string,
   skillNames: string[],
 ): Promise<{ args: string[] } | { error: string }> {
   const requested = Array.from(new Set(skillNames));
   if (requested.length === 0) return { args: [] };
+  const cacheIdentitySkills = [...requested].sort();
+  const agentDir = getAgentDir();
+  const cacheKey = JSON.stringify({
+    cwd: await canonicalPath(cwd),
+    agentDir: await canonicalPath(agentDir),
+    skills: cacheIdentitySkills,
+  });
+  const cached = resolvedSkillArgsCache.get(cacheKey);
+  if (cached && Date.now() - cached.ts <= SKILL_DISCOVERY_CACHE_TTL_MS) {
+    return { args: buildSkillArgs(requested, cached.skillPaths) };
+  }
   const loader = new DefaultResourceLoader({
     cwd,
-    agentDir: getAgentDir(),
+    agentDir,
     noContextFiles: true,
     noPromptTemplates: true,
     noThemes: true,
@@ -124,12 +191,12 @@ export async function resolveAgentSkillArgs(
         .join(", ")}. Available skills: ${available}.`,
     };
   }
-  return {
-    args: requested.flatMap((name) => [
-      "--skill",
-      skillMap.get(name)?.filePath ?? name,
-    ]),
-  };
+  const skillPaths = new Map(
+    requested.map((name) => [name, skillMap.get(name)?.filePath ?? name]),
+  );
+  const args = buildSkillArgs(requested, skillPaths);
+  resolvedSkillArgsCache.set(cacheKey, { skillPaths, ts: Date.now() });
+  return { args };
 }
 
 export function getSubagentDepth(): number {

package/tsconfig.json

@@ -1,30 +1,28 @@
 {
   "compilerOptions": {
-    // Environment setup & latest features
     "lib": ["ESNext"],
     "target": "ESNext",
     "module": "Preserve",
     "moduleDetection": "force",
     "jsx": "react-jsx",
-    "allowJs": true,
     "types": ["bun"],
-
-    // Bundler mode
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
     "noEmit": true,
-
-    // Best practices
     "strict": true,
     "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedIndexedAccess": true,
     "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
+    "noImplicitReturns": true,
+    "erasableSyntaxOnly": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "exactOptionalPropertyTypes": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false
   }
 }