plugin-scanner 2.0.992__tar.gz → 2.0.994__tar.gz

{plugin_scanner-2.0.992 → plugin_scanner-2.0.994}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.992
+Version: 2.0.994
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.992 → plugin_scanner-2.0.994}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.992"
+version = "2.0.994"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.992 → plugin_scanner-2.0.994}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.992"
+version = "2.0.994"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

plugin_scanner-2.0.994/src/codex_plugin_scanner/guard/adapters/pi_extension_approval_source.py

@@ -0,0 +1,148 @@
+"""Generated Pi managed extension approval-resume helper source."""
+
+# ruff: noqa: E501
+
+from __future__ import annotations
+
+APPROVAL_RESUME_HELPERS_SOURCE = r"""function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function approvalRequestId(response: GuardResponse): string | null {
+  if (typeof response.approval_request_id !== 'string') return null;
+  const requestId = response.approval_request_id.trim();
+  if (!requestId) return null;
+  return requestId;
+}
+
+function approvalPollPath(response: GuardResponse, requestId: string): string {
+  const rawPath = typeof response.resume_poll_path === 'string' ? response.resume_poll_path.trim() : '';
+  if (rawPath.startsWith('/v1/requests/')) return rawPath;
+  return `/v1/requests/${encodeURIComponent(requestId)}`;
+}
+
+function approvalUrlFromResponse(response: GuardResponse): string | null {
+  if (typeof response.approval_url !== 'string') return null;
+  const approvalUrl = response.approval_url.trim();
+  if (!approvalUrl) return null;
+  return approvalUrl;
+}
+
+function approvalBlockedReason(response: GuardResponse, fallbackReason: string): string {
+  const reason = fallbackReason.trim() || 'Blocked by HOL Guard.';
+  const approvalUrl = approvalUrlFromResponse(response);
+  if (!approvalUrl) return reason;
+  const urlLine = `HOL Guard approval page: ${approvalUrl}`;
+  const waitLine = 'HOL Guard is already waiting for this approval and will resume this Pi session automatically after the user approves.';
+  const noAskLine = 'Do not call ask for this HOL Guard approval as the approval mechanism; HOL Guard is already polling the request.';
+  const askFallbackLine = `If you are already showing a broader recovery menu, include an option labeled "I've approved this request in HOL Guard" and include this exact URL: ${approvalUrl}`;
+  const additions = [urlLine, waitLine, noAskLine, askFallbackLine].filter(line => !reason.includes(line));
+  if (additions.length === 0) return reason;
+  return `${reason}\n\n${additions.join('\n')}`;
+}
+
+function trySpawnOpen(command: string, args: string[]): Promise<boolean> {
+  return new Promise(resolve => {
+    let settled = false;
+    const settle = (opened: boolean) => {
+      if (settled) return;
+      settled = true;
+      resolve(opened);
+    };
+    try {
+      const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+      child.once('spawn', () => {
+        child.unref();
+        settle(true);
+      });
+      child.once('error', () => settle(false));
+    } catch {
+      settle(false);
+    }
+  });
+}
+
+async function openApprovalUrl(response: GuardResponse, openedApprovalUrls: Set<string>): Promise<void> {
+  const approvalUrl = approvalUrlFromResponse(response);
+  if (!approvalUrl || openedApprovalUrls.has(approvalUrl)) return;
+  openedApprovalUrls.add(approvalUrl);
+  const platform = process.platform;
+  let commands: Array<[string, string[]]>;
+  if (platform === 'darwin') {
+    commands = [['open', [approvalUrl]]];
+  } else if (platform === 'win32') {
+    commands = [['cmd', ['/c', 'start', '', approvalUrl]]];
+  } else {
+    commands = [
+      ['xdg-open', [approvalUrl]],
+      ['gio', ['open', approvalUrl]],
+      ['exo-open', [approvalUrl]],
+      ['sensible-browser', [approvalUrl]],
+    ];
+  }
+  for (const [command, args] of commands) {
+    if (await trySpawnOpen(command, args)) return;
+  }
+}
+
+function approvalResumeMessage(details: {
+  kind: 'input' | 'tool_call';
+  requestId: string;
+  prompt?: string;
+  toolName?: string;
+}): string {
+  if (details.kind === 'input') {
+    return [
+      'HOL Guard approved the Pi user prompt that was blocked in this session.',
+      'Continue with the approved request now; do not ask the user to retry it manually.',
+      details.prompt ? `Approved prompt:\n${details.prompt}` : '',
+    ].filter(Boolean).join('\n\n');
+  }
+  const toolPart = details.toolName ? ` for ${details.toolName}` : '';
+  return [
+    `HOL Guard approved the blocked Pi tool call${toolPart}.`,
+    'Continue the original user task now. Retry that tool call once if it is still required; '
+      + 'the saved HOL Guard approval should allow it.',
+    'Do not ask the user to retry the same action manually.',
+  ].join('\n\n');
+}
+
+async function pollApprovalResolution(
+  requestId: string,
+  pollPath: string,
+): Promise<'allow' | 'block' | null> {
+  if (typeof fetch !== 'function') return null;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt <= GUARD_APPROVAL_RESUME_MAX_WAIT_MS) {
+    const connection = loadGuardDaemonConnection();
+    if (!connection) return null;
+    const controller = typeof AbortController === 'function' ? new AbortController() : undefined;
+    const timeoutHandle = setTimeout(
+      () => controller?.abort(),
+      GUARD_APPROVAL_RESUME_FETCH_TIMEOUT_MS,
+    );
+    try {
+      const response = await fetch(`http://127.0.0.1:${connection.port}${pollPath}`, {
+        method: 'GET',
+        headers: { 'X-Guard-Token': connection.authToken },
+        signal: controller?.signal,
+      });
+      if (response.status === 404) return null;
+      if (response.ok) {
+        const item = (await response.json()) as { status?: unknown; resolution_action?: unknown };
+        if (item.status === 'resolved') {
+          if (item.resolution_action === 'allow') return 'allow';
+          if (item.resolution_action === 'block') return 'block';
+          return null;
+        }
+      }
+    } catch {
+    } finally {
+      clearTimeout(timeoutHandle);
+    }
+    await sleep(GUARD_APPROVAL_RESUME_POLL_INTERVAL_MS);
+  }
+  return null;
+}
+
+"""

plugin_scanner-2.0.994/src/codex_plugin_scanner/guard/adapters/pi_extension_content_source.py

@@ -0,0 +1,319 @@
+"""Generated Pi managed extension content-review helper source."""
+
+# ruff: noqa: E501
+
+from __future__ import annotations
+
+CONTENT_REVIEW_HELPERS_SOURCE = r"""type OutputDigest = {
+  sha256: string | null;
+  chars: number;
+  textForExcerpt: string;
+  excerptTruncated: boolean;
+  traversalTruncated: boolean;
+};
+
+function digestOutputText(value: unknown): OutputDigest {
+  const hash = createHash('sha256');
+  let chars = 0;
+  let textForExcerpt = '';
+  let excerptTruncated = false;
+  let traversalTruncated = false;
+  const seen = new WeakSet<object>();
+  function update(text: string): void {
+    hash.update(text, 'utf8');
+    chars += text.length;
+    if (textForExcerpt.length < GUARD_TEXT_LIMIT_CHARS) {
+      const remaining = GUARD_TEXT_LIMIT_CHARS - textForExcerpt.length;
+      if (text.length <= remaining) {
+        textForExcerpt += text;
+      } else {
+        textForExcerpt += text.slice(0, remaining);
+        excerptTruncated = true;
+      }
+    }
+    if (chars > GUARD_SOURCE_REF_MAX_OUTPUT_CHARS) {
+      traversalTruncated = true;
+    }
+  }
+  function traverse(val: unknown, depth: number): void {
+    if (traversalTruncated) return;
+    if (typeof val === 'string') { update(val); return; }
+    if (val === undefined || val === null) return;
+    if (typeof val === 'number' || typeof val === 'boolean') return;
+    if (typeof val === 'bigint') { update(val.toString()); return; }
+    if (typeof val !== 'object') { traversalTruncated = true; return; }
+    const obj = val as object;
+    if (seen.has(obj)) { traversalTruncated = true; return; }
+    if (depth > GUARD_MAX_DEPTH) { traversalTruncated = true; return; }
+    seen.add(obj);
+    if (Array.isArray(val)) {
+      if (val.length > GUARD_CONTENT_ITEM_LIMIT) { traversalTruncated = true; return; }
+      for (const item of val) { if (traversalTruncated) return; traverse(item, depth + 1); }
+      return;
+    }
+    const record = val as Record<string, unknown>;
+    // Match collectOutputText: only extract text from {type: "text", text: ...}
+    // objects, not from metadata keys like "type".
+    if (record.type === 'text' && typeof record.text === 'string') {
+      update(record.text);
+      return;
+    }
+    let keyCount = 0;
+    for (const key of OUTPUT_TEXT_KEYS) {
+      if (!(key in record)) continue;
+      if (keyCount >= GUARD_OBJECT_KEY_LIMIT) { traversalTruncated = true; return; }
+      keyCount++;
+      if (traversalTruncated) return;
+      traverse(record[key], depth + 1);
+    }
+  }
+  try {
+    traverse(value, 0);
+  } catch {
+    traversalTruncated = true;
+  }
+  return {
+    sha256: traversalTruncated ? null : hash.digest('hex'),
+    chars,
+    textForExcerpt,
+    excerptTruncated,
+    traversalTruncated,
+  };
+}
+
+function sourcePathFromToolInput(toolInput: Record<string, unknown>): string | null {
+  for (const key of ['file_path', 'filePath', 'path', 'file', 'filename']) {
+    const value = toolInput[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return null;
+}
+
+function sourceFileRefForPostToolUse(
+  event: Record<string, unknown>,
+  toolInput: Record<string, unknown>,
+  digest: OutputDigest,
+): { version: number; kind: string; path: string; tool_input_path: string; output_sha256: string; output_chars: number } | null {
+  const toolName = typeof event.toolName === 'string' ? event.toolName : '';
+  if (!GUARD_SOURCE_REF_ALLOWED_TOOL_NAMES.has(toolName)) return null;
+  if (!digest.sha256 || digest.traversalTruncated) return null;
+  if (digest.chars > GUARD_SOURCE_REF_MAX_OUTPUT_CHARS) return null;
+  const path = sourcePathFromToolInput(toolInput);
+  if (!path) return null;
+  return {
+    version: 1,
+    kind: 'source_file',
+    path,
+    tool_input_path: path,
+    output_sha256: digest.sha256,
+    output_chars: digest.chars,
+  };
+}
+
+type BoundedValue = { value: unknown; truncated: boolean };
+const OUTPUT_TEXT_KEYS = ["stdout", "stderr", "output", "content", "result", "message", "text"] as const;
+
+function truncateText(value: string, limit = GUARD_TEXT_LIMIT_CHARS): string {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, Math.max(limit, 0))}\n...[truncated by HOL Guard]...`;
+}
+
+function boundValue(value: unknown, depth = 0, seen = new WeakSet<object>()): BoundedValue {
+  if (typeof value === 'string') {
+    if (value.length <= GUARD_TEXT_LIMIT_CHARS) {
+      return { value, truncated: false };
+    }
+    return { value: truncateText(value), truncated: true };
+  }
+  if (value === undefined) return { value: undefined, truncated: false };
+  if (typeof value === 'bigint') return { value: value.toString(), truncated: false };
+  if (
+    value === null ||
+    typeof value === 'number' ||
+    typeof value === 'boolean'
+  ) {
+    return { value, truncated: false };
+  }
+  if (typeof value !== 'object') {
+    return { value: String(value), truncated: true };
+  }
+  const objectValue = value as object;
+  if (seen.has(objectValue)) {
+    return { value: '[cycle omitted by HOL Guard]', truncated: true };
+  }
+  if (depth > GUARD_MAX_DEPTH) {
+    return { value: '[deep object omitted by HOL Guard]', truncated: true };
+  }
+  seen.add(objectValue);
+  try {
+    if (Array.isArray(value)) {
+      const truncated = value.length > GUARD_CONTENT_ITEM_LIMIT;
+      const items = value.slice(0, GUARD_CONTENT_ITEM_LIMIT);
+      const nextItems: unknown[] = [];
+      let childTruncated = truncated;
+      for (const item of items) {
+        const next = boundValue(item, depth + 1, seen);
+        nextItems.push(next.value);
+        childTruncated = childTruncated || next.truncated;
+      }
+      return { value: nextItems, truncated: childTruncated };
+    }
+    const record = value as Record<string, unknown>;
+    const nextRecord: Record<string, unknown> = {};
+    let truncated = false;
+    let keyCount = 0;
+    for (const key in record) {
+      if (!Object.prototype.hasOwnProperty.call(record, key)) continue;
+      if (keyCount >= GUARD_OBJECT_KEY_LIMIT) {
+        truncated = true;
+        break;
+      }
+      keyCount += 1;
+      const entryValue = record[key];
+      const next = boundValue(entryValue, depth + 1, seen);
+      nextRecord[key] = next.value;
+      truncated = truncated || next.truncated;
+    }
+    return { value: nextRecord, truncated };
+  } finally {
+    seen.delete(objectValue);
+  }
+}
+
+function appendBoundedText(accumulator: { text: string; truncated: boolean }, value: string): void {
+  if (accumulator.truncated || value.length === 0) return;
+  const prefix = accumulator.text ? "\n" : "";
+  const available = GUARD_TEXT_LIMIT_CHARS - accumulator.text.length - prefix.length;
+  if (available <= 0) {
+    accumulator.truncated = true;
+    return;
+  }
+  if (value.length > available) {
+    accumulator.text += `${prefix}${value.slice(0, available)}`;
+    accumulator.truncated = true;
+    return;
+  }
+  accumulator.text += `${prefix}${value}`;
+}
+
+function collectOutputText(
+  value: unknown,
+  accumulator: { text: string; truncated: boolean; itemCount: number },
+  depth = 0,
+  seen = new WeakSet<object>(),
+): void {
+  if (accumulator.truncated) return;
+  if (typeof value === 'string') {
+    appendBoundedText(accumulator, value);
+    return;
+  }
+  if (typeof value === 'bigint') {
+    appendBoundedText(accumulator, value.toString());
+    return;
+  }
+  if (
+    value === undefined ||
+    value === null ||
+    typeof value === 'number' ||
+    typeof value === 'boolean'
+  ) {
+    return;
+  }
+  if (typeof value !== 'object') {
+    accumulator.truncated = true;
+    return;
+  }
+  const objectValue = value as object;
+  if (seen.has(objectValue) || depth > GUARD_MAX_DEPTH) {
+    accumulator.truncated = true;
+    return;
+  }
+  seen.add(objectValue);
+  try {
+    if (Array.isArray(value)) {
+      const arrayItems = value as unknown[];
+      for (const item of arrayItems) {
+        if (accumulator.itemCount >= GUARD_CONTENT_ITEM_LIMIT) {
+          accumulator.truncated = true;
+          break;
+        }
+        accumulator.itemCount += 1;
+        collectOutputText(item, accumulator, depth + 1, seen);
+        if (accumulator.truncated) break;
+      }
+      if (arrayItems.length > GUARD_CONTENT_ITEM_LIMIT) accumulator.truncated = true;
+      return;
+    }
+    const record = value as Record<string, unknown>;
+    if (record.type === 'text' && typeof record.text === 'string') {
+      appendBoundedText(accumulator, record.text);
+      return;
+    }
+    for (const key of OUTPUT_TEXT_KEYS) {
+      if (!(key in record)) continue;
+      collectOutputText(record[key], accumulator, depth + 1, seen);
+      if (accumulator.truncated) break;
+    }
+  } finally {
+    seen.delete(objectValue);
+  }
+}
+
+function boundedOutputText(value: unknown): BoundedValue {
+  const accumulator = { text: '', truncated: false, itemCount: 0 };
+  collectOutputText(value, accumulator);
+  return { value: accumulator.text, truncated: accumulator.truncated };
+}
+
+function toolCallIdKey(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function base64Url(value: Buffer): string {
+  return value.toString('base64url');
+}
+
+function encryptedPayload(serializedPayload: string) {
+  const key = randomBytes(32);
+  const nonce = randomBytes(12);
+  const cipher = createCipheriv('aes-256-gcm', key, nonce);
+  const ciphertext = Buffer.concat([
+    cipher.update(serializedPayload, 'utf8'),
+    cipher.final(),
+    cipher.getAuthTag(),
+  ]);
+  return { ciphertext, key: base64Url(key), nonce: base64Url(nonce) };
+}
+
+function referencedPayload(payload: Record<string, unknown>, serializedPayload: string) {
+  const directory = mkdtempSync(join(tmpdir(), 'hol-guard-hook-payload-'));
+  try { chmodSync(directory, 0o700); } catch {}
+  const path = join(directory, 'payload.json');
+  const encrypted = encryptedPayload(serializedPayload);
+  writeFileSync(path, encrypted.ciphertext, { mode: 0o600 });
+  const sha256 = createHash('sha256').update(encrypted.ciphertext).digest('hex');
+  const referencePayload: Record<string, unknown> = {
+    hook_event_name: payload.hook_event_name,
+    config_path: payload.config_path,
+    tool_name: payload.tool_name,
+    is_error: payload.is_error,
+    guard_payload_ref: {
+      version: 1,
+      path,
+      sha256,
+      encoding: 'json',
+      encryption: 'aes-256-gcm',
+      key: encrypted.key,
+      nonce: encrypted.nonce,
+      serialized_chars: serializedPayload.length,
+    },
+  };
+  return {
+    payload: referencePayload,
+    cleanup: () => { try { rmSync(directory, { recursive: true, force: true }); } catch {} },
+  };
+}
+
+"""