repo="openclaw/openclaw"

months="12"

include_global="0"

script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

repo_root="$(git -C "$script_dir/../../../.." rev-parse --show-toplevel 2>/dev/null || true)"

if [ -z "$repo_root" ]; then

repo_root="$(cd "$script_dir/../../../.." && pwd)"

fi

# shellcheck disable=SC1091

source "$repo_root/scripts/lib/plain-gh.sh"

usage() {

printf 'Usage: %s [--repo owner/repo] [--months N] [--global] <github-login> [login...]\n' "$0"

command -v "$1" >/dev/null 2>&1 || die "missing required command: $1"

}

gh() {

gh_plain "$@"

}

date_utc_relative_months() {

local count="$1"

if date -u -v-"${count}"m +%Y-%m-%dT00:00:00Z >/dev/null 2>&1; then

exit 2

}

need gh

OPENCLAW_GH_BIN="$(resolve_plain_gh_bin)" || die "missing required command: gh"

export OPENCLAW_GH_BIN

need jq

since_ts=$(date_utc_relative_months "$months")

* Usage: node secret-scanning.mjs <command> [options]

*/

import { spawnSync } from "node:child_process";

import crypto from "node:crypto";

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

import { pathToFileURL } from "node:url";

import { spawnPlainGh } from "../../../../scripts/lib/plain-gh.mjs";

const REPO = "openclaw/openclaw";

const REPO_URL = `https://github.com/${REPO}`;

}

function gh(args, { json = true, allowFailure = false } = {}) {

const proc = spawnSync("gh", args, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });

const proc = spawnPlainGh(args, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });

if (proc.status !== 0 && !allowFailure) {

fail(`gh ${args.slice(0, 3).join(" ")} failed:\n${(proc.stderr || proc.stdout || "").trim()}`);

}

*/

import { execFileSync } from "node:child_process";

import process from "node:process";

import { plainGhEnv, resolvePlainGhBin } from "../../../../scripts/lib/plain-gh.mjs";

const runId = process.argv[2];

const repo = process.env.OPENCLAW_RELEASE_REPO || "openclaw/openclaw";

}

function gh(args) {

return execFileSync("gh", args, {

return execFileSync(resolvePlainGhBin(), args, {

encoding: "utf8",

env: plainGhEnv(),

stdio: ["ignore", "pipe", "pipe"],

});

}

"-lc",

[

"set -euo pipefail",

'token="$(gh auth token)"',

'token="$("$OPENCLAW_PLAIN_GH_BIN" auth token)"',

'curl -fsS -H "Authorization: Bearer ${token}" -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" "${OPENCLAW_GITHUB_REST_URL}"',

].join("\n"),

],

{

encoding: "utf8",

env: {

...process.env,

...plainGhEnv(),

OPENCLAW_PLAIN_GH_BIN: resolvePlainGhBin(),

OPENCLAW_GITHUB_REST_URL: `https://api.github.com/repos/${repo}/${pathSuffix}`,

},

maxBuffer: 16 * 1024 * 1024,

// Summarizes GitHub Actions run/job timings for CI analysis.

import { execFileSync } from "node:child_process";

import { parsePositiveInt } from "./lib/numeric-options.mjs";

import { execPlainGh } from "./lib/plain-gh.mjs";

const DEFAULT_GITHUB_REPOSITORY = "openclaw/openclaw";

const RUN_JOBS_PAGE_SIZE = 20;

let lastError;

for (let attempt = 0; attempt <= GH_JSON_RETRY_DELAYS_MS.length; attempt += 1) {

try {

return JSON.parse(

execFileSync(command, args, {

encoding: "utf8",

...options,

}),

);

const stdout =

command === "gh"

? execPlainGh(args, {

encoding: "utf8",

...options,

})

: execFileSync(command, args, {

encoding: "utf8",

...options,

});

return JSON.parse(stdout);

} catch (error) {

lastError = error;

const message = error instanceof Error ? error.message : String(error);

}

function getLatestCiRunId() {

const raw = execFileSync(

"gh",

const raw = execPlainGh(

["run", "list", "--branch", "main", "--workflow", "CI", "--limit", "1", "--json", "databaseId"],

{ encoding: "utf8" },

);

function getLatestMainPushCiRunId() {

const headSha = getRemoteMainSha();

const raw = execFileSync(

"gh",

const raw = execPlainGh(

[

"run",

"list",

}

function listRecentSuccessfulCiRuns(limit) {

const raw = execFileSync(

"gh",

const raw = execPlainGh(

[

"run",

"list",

import { execFileSync, spawnSync } from "node:child_process";

import fs from "node:fs";

import path from "node:path";

function isExecutable(filePath) {

try {

fs.accessSync(filePath, fs.constants.X_OK);

return true;

} catch {

return false;

}

}

function pathEntries(env) {

return String(env.PATH ?? "")

.split(path.delimiter)

.filter(Boolean);

}

export function plainGhEnv(env = process.env) {

const next = { ...env };

delete next.CLICOLOR;

delete next.CLICOLOR_FORCE;

delete next.COLORTERM;

delete next.GH_FORCE_TTY;

next.NO_COLOR = "1";

next.FORCE_COLOR = "0";

next.CLICOLOR = "0";

next.CLICOLOR_FORCE = "0";

return next;

}

export function resolvePlainGhBin(env = process.env) {

if (env.OPENCLAW_GH_BIN) {

if (isExecutable(env.OPENCLAW_GH_BIN)) {

return env.OPENCLAW_GH_BIN;

}

throw new Error(`OPENCLAW_GH_BIN is not executable: ${env.OPENCLAW_GH_BIN}`);

}

for (const candidate of ["/opt/homebrew/bin/gh", "/usr/local/bin/gh"]) {

if (isExecutable(candidate)) {

return candidate;

}

}

const homeBin = env.HOME ? path.join(env.HOME, "bin") : "";

for (const entry of pathEntries(env)) {

if (homeBin && entry === homeBin) {

continue;

}

const candidate = path.join(entry, process.platform === "win32" ? "gh.exe" : "gh");

if (isExecutable(candidate)) {

return candidate;

}

}

for (const entry of pathEntries(env)) {

const candidate = path.join(entry, process.platform === "win32" ? "gh.exe" : "gh");

if (isExecutable(candidate)) {

return candidate;

}

}

throw new Error("missing required command: gh");

}

export function execPlainGh(args, options = {}) {

const env = plainGhEnv(options.env ?? process.env);

const ghBin = resolvePlainGhBin(env);

return execFileSync(ghBin, args, {

...options,

env,

});

}

export function spawnPlainGh(args, options = {}) {

const env = plainGhEnv(options.env ?? process.env);

const ghBin = resolvePlainGhBin(env);

return spawnSync(ghBin, args, {

...options,

env,

});

}

#!/usr/bin/env bash

plain_gh_env() {

env \

-u CLICOLOR \

-u CLICOLOR_FORCE \

-u COLORTERM \

-u GH_FORCE_TTY \

NO_COLOR=1 \

FORCE_COLOR=0 \

CLICOLOR=0 \

CLICOLOR_FORCE=0 \

"$@"

}

resolve_plain_gh_bin() {

if [ -n "${OPENCLAW_GH_BIN:-}" ]; then

if [ -x "$OPENCLAW_GH_BIN" ]; then

printf '%s\n' "$OPENCLAW_GH_BIN"

return 0

fi

printf 'OPENCLAW_GH_BIN is not executable: %s\n' "$OPENCLAW_GH_BIN" >&2

return 1

fi

local candidate

for candidate in /opt/homebrew/bin/gh /usr/local/bin/gh; do

if [ -x "$candidate" ]; then

printf '%s\n' "$candidate"

return 0

fi

done

if candidate=$(PATH="$(plain_gh_search_path)" type -P gh 2>/dev/null); then

printf '%s\n' "$candidate"

return 0

fi

type -P gh 2>/dev/null

}

plain_gh_search_path() {

local path_value="${PATH:-}"

local home_bin="${HOME:-}/bin"

local item

local output=""

local first=true

local path_parts=()

IFS=':' read -r -a path_parts <<<"$path_value"

for item in "${path_parts[@]}"; do

if [ -n "${HOME:-}" ] && [ "$item" = "$home_bin" ]; then

continue

fi

if [ "$first" = "true" ]; then

output="$item"

first=false

else

output="${output}:$item"

fi

done

printf '%s\n' "$output"

}

gh_plain() {

local gh_bin

gh_bin=$(resolve_plain_gh_bin) || return 1

plain_gh_env "$gh_bin" "$@"

}

fi

fi

# shellcheck disable=SC1091

source "$script_parent_dir/lib/plain-gh.sh"

usage() {

cat <<USAGE

Usage:

require_cmds() {

local missing=()

local cmd

for cmd in git gh jq rg pnpm node; do

for cmd in git jq rg pnpm node; do

if ! command -v "$cmd" >/dev/null 2>&1; then

missing+=("$cmd")

fi

done

if ! OPENCLAW_GH_BIN="$(resolve_plain_gh_bin)"; then

missing+=("gh")

else

export OPENCLAW_GH_BIN

fi

if [ "${#missing[@]}" -gt 0 ]; then

echo "Missing required command(s): ${missing[*]}"

exit 1

fi

}

gh() {

gh_plain "$@"

}

# shellcheck disable=SC1091

source "$script_parent_dir/pr-lib/worktree.sh"

# shellcheck disable=SC1091

#!/usr/bin/env node

import { execFileSync } from "node:child_process";

import { mkdirSync, writeFileSync } from "node:fs";

import path from "node:path";

import { isDirectRunUrl } from "./lib/direct-run.mjs";

import { execPlainGh } from "./lib/plain-gh.mjs";

export const SCHEDULED_HOSTED_WORKFLOWS = [

"Blacksmith Testbox",

}

function loadWorkflowRuns(repo, sha) {

const raw = execFileSync(

"gh",

const raw = execPlainGh(

["api", `repos/${repo}/actions/runs?head_sha=${sha}&per_page=100`, "--paginate", "--slurp"],

{ encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },

);

env: {

...process.env,

FAKE_GH_LOG: logPath,

OPENCLAW_GH_BIN: ghPath,

PATH: `${binDir}:${process.env.PATH ?? ""}`,

},

});