ClawHub
Back to skill

Security audit

Auto Free Banana

Security checks for vulnerabilities and agentic risk

Overview

The skill mainly automates Google Flow image generation, but it also extracts and stores reusable Google authentication data in ways users should review carefully before installing.

Review this skill before installing. Use only a dedicated Chrome profile or test Google account, avoid pointing `--cookie-path` at shared or synced folders, delete cached credentials when finished, and prefer installing a trusted pinned Bun runtime instead of allowing the `npx -y bun` fallback.

A.I.G

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (4)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/flow-webapi/utils/paths.ts:34
Finding

Shell Command Injection Through WSL Profile Path Conversion

Content
View full analysis

Vulnerability Details

File Location: scripts/flow-webapi/utils/paths.ts:34-37, with environment-variable sources at scripts/flow-webapi/utils/paths.ts:47-51
Vulnerability Type: OS command injection
Risk Level: High

Vulnerable Code

ts
function toWslPath(rawWindowsPath: string): string | null {
  try {
    return execSync(`wslpath -u "${rawWindowsPath}"`, { encoding: 'utf-8', timeout: 5000 }).trim() || null;
  } catch {
    return null;
  }
}

The value passed to this function originates from environment variables:

ts
const winOverride = process.env.AGENT_BROWSER_USER_DATA_DIR_WIN?.trim() || process.env.FLOW_WEB_CHROME_USER_DATA_DIR_WIN?.trim();
if (winOverride) {
  const converted = toWslPath(winOverride);
  if (converted) return converted;
}

Technical Analysis

rawWindowsPath is inserted directly into a command string executed by execSync. Because execSync invokes a shell for string commands, embedded quotation marks and shell metacharacters can terminate the intended argument and introduce an additional command.

The input is obtained from AGENT_BROWSER_USER_DATA_DIR_WIN or FLOW_WEB_CHROME_USER_DATA_DIR_WIN. No validation, escaping, or argument separation is performed. An attacker who can influence the Skill's environment can therefore convert a profile-path configuration value into arbitrary command execution.

Attack Path

  1. An attacker or untrusted execution environment sets AGENT_BROWSER_USER_DATA_DIR_WIN or FLOW_WEB_CHROME_USER_DATA_DIR_WIN to a value containing a closing quotation mark and shell syntax.
  2. The Skill runs under WSL and calls resolveFlowWebChromeProfileDir().
  3. The environment value is passed to toWslPath().
  4. execSync parses the injected syntax as part of the shell command.
  5. The injected command executes with the privileges of the user running the Skill.

Impact Assessment

Successful exploitation pr ...[truncated 317 chars]

Remediation
View remediation

Remediation Suggestions

Do not pass environment-derived data through a shell command string. Invoke wslpath with an argument array:

ts
import { execFileSync } from 'node:child_process';

function toWslPath(rawWindowsPath: string): string | null {
  try {
    return execFileSync('wslpath', ['-u', rawWindowsPath], {
      encoding: 'utf8',
      timeout: 5000,
    }).trim() || null;
  } catch {
    return null;
  }
}

Additionally:

  • Reject null bytes, control characters, and newline characters.
  • Validate that the input conforms to an expected Windows path format.
  • Treat environment configuration as untrusted input.
  • Avoid shell execution wherever a direct process API can be used.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/flow-webapi/utils/load-browser-cookies.ts:339
Finding

Excessive Google Account Cookie Collection and Cross-Scope Replay

Content
View full analysis

Vulnerability Details

File Location: scripts/flow-webapi/utils/load-browser-cookies.ts:339-348, scripts/flow-webapi/utils/load-browser-cookies.ts:382-388, and scripts/flow-webapi/utils/get-auth-token.ts:13-22
Vulnerability Type: Excessive credential access and loss of cookie-origin restrictions
Risk Level: High

Vulnerable Code

The authentication flow requests cookies matching both Flow and Google Accounts URLs:

ts
// Grab cookies
const { cookies } = await cdp.send<{ cookies: Array<{ name: string; value: string }> }>(
  'Network.getCookies',
  { urls: ['https://labs.google/', 'https://labs.google/fx/', 'https://accounts.google.com/'] },
  { sessionId, timeoutMs: 10_000 },
);

const m: CookieMap = {};
for (const c of cookies) {
  if (c?.name && typeof c.value === 'string') m[c.name] = c.value;
}

All collected cookies are retained and persisted:

ts
const filtered: CookieMap = {};
for (const [k, v] of Object.entries(result.cookies)) {
  if (typeof v === 'string' && v.length > 0) filtered[k] = v;
}

await write_cookie_file(result.accessToken, filtered, resolveFlowWebCookiePath(), 'cdp');
return { accessToken: result.accessToken, cookies: filtered };

The resulting name/value map is later sent in its entirety to the Flow session endpoint:

ts
const res = await fetch_with_timeout('https://labs.google/fx/api/auth/session', {
  method: 'GET',
  headers: {
    'Cookie': cookie_header(cookies),
    'Accept': 'application/json',
  },
  redirect: 'follow',
  timeout_ms: 15_000,
});

Technical Analysis

Network.getCookies returns cookies applicable to any supplied URL. Including https://accounts.google.com/ causes the Skill to retrieve Google Account authentication cookies in addition to cookies needed for Flow.

The code then reduces every cookie to a plain name/value map. Domain, host-only, path, expirati ...[truncated 1756 chars]

Remediation
View remediation

Remediation Suggestions

  • Remove https://accounts.google.com/ from the cookie query.
  • Prefer the existing same-origin browser fetch for session acquisition so Chrome enforces cookie domain, path, and security attributes.
  • If exporting cookies is unavoidable, retain only an explicit allowlist proven necessary for labs.google.
  • Preserve cookie domain and path metadata rather than using a global Record<string, string>.
  • Never concatenate cookies from multiple origins into one manually constructed header.
  • Avoid extracting or retaining the OAuth token if UI automation does not require it.
  • Document the exact credential scope and require explicit informed consent before exporting browser credentials.

T09 · Insecure Skill Coding Practices

Error
Location
scripts/flow-webapi/utils/cookie-file.ts:36
Finding

Google OAuth Token and Browser Cookies Stored in Insecure Plaintext File

Content
View full analysis

Vulnerability Details

File Location: scripts/flow-webapi/utils/cookie-file.ts:36-52
Vulnerability Type: Insecure storage of sensitive authentication material
Risk Level: High

Vulnerable Code

ts
export async function write_cookie_file(
  accessToken: string,
  cookies: CookieMap,
  p: string = resolveFlowWebCookiePath(),
  source?: string,
): Promise<void> {
  const dir = path.dirname(p);
  await mkdir(dir, { recursive: true });

  const payload: FlowCookieFileData = {
    version: 1,
    updatedAt: new Date().toISOString(),
    accessToken,
    cookies,
    source,
  };
  await writeFile(p, JSON.stringify(payload, null, 2), 'utf8');
}

Technical Analysis

The Skill writes a reusable OAuth bearer token and browser cookies to an unencrypted JSON file. writeFile is not supplied with a restrictive mode such as 0o600, and the containing directory is created without an explicit 0o700 mode.

Default permissions depend on the process umask and may allow other local users to read the file. If the destination already exists with unsafe permissions, the function does not repair them. The user-controllable --cookie-path option can also direct the secrets to a shared, synchronized, backed-up, or otherwise inappropriate location.

The implementation does not validate file ownership or guard against symbolic-link destinations.

Attack Path

  1. The user authenticates successfully.
  2. The Skill serializes the OAuth token and cookies into cookies.json or a caller-selected path.
  3. The file inherits default or pre-existing filesystem permissions.
  4. Another local process, user, backup service, or synchronized application reads the file.
  5. The stolen bearer token or cookies are replayed against services where they remain valid.

Impact Assessment

An attacker who reads the cache obtains reusable Google authentication material. The resulting access depends ...[truncated 322 chars]

Remediation
View remediation

Remediation Suggestions

Prefer a platform credential manager, such as macOS Keychain, Windows Credential Manager, or a Linux Secret Service implementation.

If file storage is unavoidable:

  • Create the containing directory with mode 0o700.
  • Create or atomically replace the credential file with mode 0o600.
  • Verify that the destination is owned by the current user.
  • Reject symbolic links and non-regular files.
  • Repair unsafe permissions on existing credential files before reading or writing them.
  • Restrict or validate custom credential paths.
  • Store only the minimum Flow-specific authentication state.
  • Implement expiration and secure deletion for stale credentials.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:27
Finding

Automatic Execution of an Unpinned Registry Package Through npx

Content
View full analysis

Vulnerability Details

File Location: SKILL.md:27-29, SKILL.md:127-130, and scripts/main.ts:18-33
Vulnerability Type: Unpinned runtime dependency and supply-chain exposure
Risk Level: Medium

Vulnerable Code

SKILL.md defines an automatic registry fallback:

md
1. `{baseDir}` = directory containing this `SKILL.md`
2. Script path = `{baseDir}/scripts/main.ts`
3. `${BUN_X}` = `bun` if installed, else `npx -y bun`

The runtime preflight repeats that behavior:

bash
command -v bun >/dev/null && echo "BUN" || command -v npx >/dev/null && echo "NPX_BUN" || echo "MISSING"

The generated usage commands also instruct users to run an unpinned package:

ts
function formatScriptCommand(fallback: string): string {
  const raw = process.argv[1];
  const displayPath = raw
    ? (() => {
        const relative = path.relative(process.cwd(), raw);
        return relative && !relative.startsWith('..') ? relative : raw;
      })()
    : fallback;
  const quotedPath = displayPath.includes(' ')
    ? `"${displayPath.replace(/"/g, '\\"')}"`
    : displayPath;
  return `npx -y bun ${quotedPath}`;
}

Technical Analysis

When Bun is not installed, the documented workflow invokes npx -y bun without an exact version, lockfile, or integrity verification. This permits npm registry state to determine which package contents execute at runtime.

The -y option suppresses confirmation, making registry code execution automatic. A malicious package release, package-account compromise, registry compromise, or incompatible future version could execute code before the reviewed Skill entry point runs.

The audit found no evidence that the current dependency is intentionally malicious. The vulnerability is the mutable and unverified execution path.

Attack Path

  1. Bun is absent from the system while npx is available.
  2. The Agent follow ...[truncated 759 chars]
Remediation
View remediation

Remediation Suggestions

  • Require a trusted, preinstalled Bun runtime instead of installing it automatically.
  • If an automated fallback is essential, pin an exact reviewed version.
  • Verify the downloaded artifact using a trusted checksum or signature.
  • Install dependencies during a controlled setup phase rather than during normal Skill execution.
  • Remove -y so unexpected package installation is not silently accepted.
  • Document the expected runtime version and trusted installation source.

SkillSpector

Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (25)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

This mismatch is security-relevant because the skill is presented as image-generation UI automation, yet the finding indicates it also handles authentication material by extracting OAuth tokens, reading cookies for Google domains, attaching to Chrome debugging, and persisting credentials. Hidden credential access materially changes the trust boundary and could expose sensitive session data far beyond what a user would reasonably expect from an image-generation skill.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

This mismatch is security-relevant because the skill is presented as image-generation UI automation, yet the finding indicates it also handles authentication material by extracting OAuth tokens, reading cookies for Google domains, attaching to Chrome debugging, and persisting credentials. Hidden credential access materially changes the trust boundary and could expose sensitive session data far beyond what a user would reasonably expect from an image-generation skill.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

This mismatch is security-relevant because the skill is presented as image-generation UI automation, yet the finding indicates it also handles authentication material by extracting OAuth tokens, reading cookies for Google domains, attaching to Chrome debugging, and persisting credentials. Hidden credential access materially changes the trust boundary and could expose sensitive session data far beyond what a user would reasonably expect from an image-generation skill.

Content

No source excerpt is available for this finding.

Ae1

High
Category
analysis-evasion
Confidence
100% confidence
Finding

Referenced artifact was not completely inspected

Content

Scanner excerpt · SKILL.md (reported line 27)May include surrounding context.

md
1. `{baseDir}` = directory containing this `SKILL.md`

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · scripts/flow-webapi/utils/get-auth-token.ts (reported line 11)May include surrounding context.

ts
import { load_browser_auth, type FlowAuthResult } from './load-browser-cookies.js';

/**
 * Try to refresh the access token using the session API with cookies.
 */
async function refresh_token_via_session(cookies: CookieMap, verbose: boolean): Promise<string | null> {
  try {

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · scripts/flow-webapi/utils/get-auth-token.ts (reported line 50)May include surrounding context.

ts
import { load_browser_auth, type FlowAuthResult } from './load-browser-cookies.js';

/**
 * Try to refresh the access token using the session API with cookies.
 */
async function refresh_token_via_session(cookies: CookieMap, verbose: boolean): Promise<string | null> {
  try {

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · scripts/flow-webapi/utils/get-auth-token.ts (reported line 91)May include surrounding context.

ts
import { load_browser_auth, type FlowAuthResult } from './load-browser-cookies.js';

/**
 * Try to refresh the access token using the session API with cookies.
 */
async function refresh_token_via_session(cookies: CookieMap, verbose: boolean): Promise<string | null> {
  try {

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · scripts/flow-webapi/utils/load-browser-cookies.ts (reported line 372)May include surrounding context.

ts
import { load_browser_auth, type FlowAuthResult } from './load-browser-cookies.js';

/**
 * Try to refresh the access token using the session API with cookies.
 */
async function refresh_token_via_session(cookies: CookieMap, verbose: boolean): Promise<string | null> {
  try {

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

This branch reuses a cached OAuth access token without validating its freshness beyond a string prefix check. If the token cache file is exposed, stale, or tampered with, the code may continue operating with sensitive bearer credentials from disk, increasing the risk of credential misuse and reducing assurance that the token is still tied to an intended session.

Content

Scanner excerpt · scripts/flow-webapi/utils/get-auth-token.ts (reported line 73)May include surrounding context.

ts
// Use cached token as-is (may still be valid)
      if (cached.accessToken.startsWith('ya29.')) {
        if (verbose) logger.debug('Using cached access token (could not refresh, may still be valid)');
        return { accessToken: cached.accessToken, cookies: cached.cookies };
      }
    }

Credential Access

High
Category
Privilege Escalation
Confidence
99% confidence
Finding

The function is explicitly designed to extract an OAuth access token from page internals or authenticated session APIs in the browser context. This is credential access behavior: it bypasses normal delegated auth boundaries and programmatically captures reusable bearer credentials from the user's browser session.

Content

Scanner excerpt · scripts/flow-webapi/utils/load-browser-cookies.ts (reported line 223)May include surrounding context.

ts
};

/**
 * Extract the OAuth access token from the Flow page.
 * Tries: __NEXT_DATA__ script tag → /fx/api/auth/session API
 */
async function extract_flow_token(

Credential Access

High
Category
Privilege Escalation
Confidence
91% confidence
Finding

The log/context here confirms successful extraction of an access token from NEXT_DATA, which indicates the application is reading sensitive credentials from page-rendered session state. Any component with access to this routine can obtain a bearer token that may grant direct API access as the signed-in user.

Content

Scanner excerpt · scripts/flow-webapi/utils/load-browser-cookies.ts (reported line 252)May include surrounding context.

ts
);
    const token = result?.result?.value;
    if (typeof token === 'string' && token.startsWith('ya29.')) {
      if (verbose) logger.debug('Access token extracted from __NEXT_DATA__');
      return token;
    }
  } catch (e) {

Credential Access

High
Category
Privilege Escalation
Confidence
94% confidence
Finding

This fallback extracts the token by executing fetch('/fx/api/auth/session', { credentials: 'include' }) inside the authenticated page, then reading the returned access token. That converts an in-browser authenticated session into a reusable external credential, materially increasing account-takeover and API-abuse risk if the token is leaked.

Content

Scanner excerpt · scripts/flow-webapi/utils/load-browser-cookies.ts (reported line 272)May include surrounding context.

ts
);
    const token = result?.result?.value;
    if (typeof token === 'string' && token.startsWith('ya29.')) {
      if (verbose) logger.debug('Access token extracted from /fx/api/auth/session');
      return token;
    }
  } catch (e) {

Credential Access

High
Category
Privilege Escalation
Confidence
98% confidence
Finding

At this point the code collects cookies for labs.google and accounts.google.com and then attempts to extract an access token from the same session. Combining cookies and bearer tokens provides multiple paths to impersonate the user and broadens the blast radius if the collected secrets are mishandled.

Content

Scanner excerpt · scripts/flow-webapi/utils/load-browser-cookies.ts (reported line 351)May include surrounding context.

ts
if (c?.name && typeof c.value === 'string') m[c.name] = c.value;
      }

      // Try to extract access token
      const token = await extract_flow_token(cdp, sessionId, verbose);
      if (token) {
        // Only close the tab if we created it

Credential Access

High
Category
Privilege Escalation
Confidence
97% confidence
Finding

Returning the access token and cookies from this helper makes credential material available to any caller in the codebase, enabling lateral misuse beyond the narrow browser-automation purpose. This increases the chance of accidental logging, serialization, exfiltration, or reuse by other components.

Content

Scanner excerpt · scripts/flow-webapi/utils/load-browser-cookies.ts (reported line 363)May include surrounding context.

ts
return { accessToken: token, cookies: m };
      }

      if (verbose) logger.debug('No valid access token yet, retrying...');
    }

    // Clean up tab on timeout (only if we created it)

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
94% confidence
Finding

The skill instructs the agent to use shell commands, inspect environment variables, access local files, and make network requests, but it does not declare any tool scope such as permissions or allowed-tools. This creates a governance gap where powerful capabilities are implicitly required without transparent restriction, increasing the chance of over-broad execution or abuse if the skill is invoked unexpectedly.

Content

No source excerpt is available for this finding.

Rp1

Medium
Category
MCP Rug Pull
Confidence
97% confidence
Finding

Using npx -y bun pulls and executes a package at runtime without a pinned version, making execution dependent on whatever is currently published upstream. That introduces a software supply-chain risk: a compromised or replaced package version could run arbitrary code on the host with the skill's privileges.

Content

No source excerpt is available for this finding.

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
75% confidence
Finding

Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Content

Scanner excerpt · SKILL.md (reported line 43)May include surrounding context.

md
**Flow**:
1. Check if consent file exists with `accepted: true` and `disclaimerVersion: "1.0"`
2. If valid consent exists → print warning with `acceptedAt` date, proceed
3. If no consent → show disclaimer, ask user via `AskUserQuestion`:
   - "Yes, I accept" → create consent file with ISO timestamp, proceed
   - "No, I decline" → output decline message, stop
4. Consent file format: `{"version":1,"accepted":true,"acceptedAt":"<ISO>","disclaimerVersion":"1.0"}`

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill instructs the agent to manually click 新建项目, which assumes a Chinese-language Google Flow interface. This is a natural-language locale constraint, and the document does not offer a language choice or explain why a Chinese UI is required.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
88% confidence
Finding

The client obtains an OAuth access token and browser cookies, then reuses them to drive an authenticated browser session. Even though this is likely intended to support the Flow integration, accessing credential and session material increases the blast radius if the skill is compromised, logs sensitive values elsewhere, or is invoked without the user fully understanding that their browser auth state is being consumed.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The code explicitly opens the '/zh/' Flow URL and later relies on Chinese UI strings such as '新建项目', '横向', '纵向', and '创建'. This embeds a locale choice into the skill behavior without presenting a language option or documenting an explicit region-specific constraint in this file.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
89% confidence
Finding

This code automatically navigates the browser to the Flow site and clicks the UI control to create a new project, which changes remote account state. Although logging exists for some later steps, there is no explicit disclosure or confirmation around the project-creation action itself in this file.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The code persists a Google access token and browser cookies to disk in plaintext JSON without setting restrictive file permissions, encryption, or any lifecycle controls. In the context of a browser automation skill for Google Flow, these values can enable account/session hijacking if another local user, malware, backups, logs, or synced storage can access the file.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

This code extracts a Google OAuth access token and browser cookies from a live Chrome session, then persists them to disk via write_cookie_file(). Those credentials can allow reuse of the victim's authenticated session outside the browser, and storing them on disk increases the risk of theft by other local processes, later exfiltration, or accidental disclosure.

Content

No source excerpt is available for this finding.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding

npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Low
Category
Not specified by scanner
Confidence
80% confidence
Finding

The manifest describes a skill for generating images through Google Flow browser UI automation. This helper resolves proxy settings from multiple environment variables, including a generic agent/browser proxy variable, which introduces environment-driven network routing behavior not mentioned in the skill's stated purpose.

Content

No source excerpt is available for this finding.

Static analysis

Detected: suspicious.dangerous_exec, suspicious.env_credential_access, suspicious.exposed_secret_literal

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/flow-webapi/utils/load-browser-cookies.ts:152

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/flow-webapi/utils/paths.ts:36

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
scripts/flow-webapi/utils/http.ts:41

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
scripts/flow-webapi/utils/load-browser-cookies.ts:97

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
scripts/flow-webapi/client.ts:55

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
scripts/flow-webapi/utils/get-auth-token.ts:74

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
scripts/flow-webapi/utils/load-browser-cookies.ts:388