mandrel 1.57.0

package/.agents/scripts/notify.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+/* node:coverage ignore file */
+
+/**
+ * notify.js
+ *
+ * Single dispatch entry point for runtime notifications across two
+ * independent channels.
+ *
+ * Lifecycle-bus integration (Epic #2172): under the Wave-7+ runtime,
+ * `notify()` is invoked from the `NotifyDispatcher` listener
+ * (`lib/orchestration/lifecycle/listeners/notify-dispatcher.js`),
+ * which subscribes to lifecycle events and maps `event.severity` →
+ * `notify()` payload. Direct inline calls at phase boundaries are no
+ * longer the canonical path — listeners on the bus are. See
+ * [`docs/LIFECYCLE.md`](../docs/LIFECYCLE.md) for the bus contract,
+ * event taxonomy, and the dispatcher's wiring. Direct CLI / library
+ * invocations remain supported for one-shot operator commands and the
+ * structured-comment back-channel.
+ *
+ * Channels:
+ *
+ *   1. GITHUB COMMENT — gated by `notifications.commentEvents` (event
+ *      allowlist). Only dispatches whose `event` name appears in the
+ *      allowlist reach the ticket. @mentions operator on `high` severity;
+ *      on `medium` when `mentionOperator` is set. Callers may pass
+ *      `opts.skipComment: true` to suppress the comment for a single
+ *      dispatch while still firing the webhook (used for structured-
+ *      comment writers that already posted the ticket-side body themselves).
+ *   2. WEBHOOK — gated by `notifications.webhookEvents` (event allowlist).
+ *      Only dispatches whose `event` name appears in the allowlist reach
+ *      the webhook. The webhook channel is curated for the epic narrative
+ *      (% progress + blockers), not the firehose of per-story transitions;
+ *      the default allowlist is the five `epic-*` events. Payload envelope:
+ *      `{ text, severity, event?, level?, ticketId?, epicId?, phase? }` —
+ *      `text` always populated for back-compat with `{text}`-only consumers.
+ *
+ * Each channel filters independently — no fallback chain. Severity is
+ * carried as envelope metadata (so Slack consumers can color-code by it
+ * and high-severity comments still `@mention` the operator) but is no
+ * longer a routing factor for either channel.
+ *
+ * Severity vocabulary: low | medium | high. See `lib/notifications/notifier.js`
+ * for the `eventSeverity()` helper used by ticket-state-transition events.
+ */
+
+import { createHmac } from 'node:crypto';
+import { runAsCli } from './lib/cli-utils.js';
+import { resolveConfig } from './lib/config-resolver.js';
+import { Logger } from './lib/Logger.js';
+import {
+  resolveWebhookUrl,
+  SEVERITY_RANK,
+} from './lib/notifications/notifier.js';
+import { createProvider } from './lib/provider-factory.js';
+
+/** Map notification severity to a `postComment` badge style. */
+const SEVERITY_TO_COMMENT_TYPE = {
+  low: 'progress',
+  medium: 'notification',
+  high: 'friction',
+};
+
+/**
+ * Resolve a channel's event allowlist. Returns a `Set<string>` for O(1)
+ * membership lookups. An absent/empty allowlist suppresses the channel
+ * entirely — there is no implicit fallback to a severity-based gate.
+ */
+function resolveEventAllowlist(notifications, key) {
+  const list = notifications?.[key];
+  if (!Array.isArray(list)) return new Set();
+  return new Set(list.filter((e) => typeof e === 'string' && e));
+}
+
+function buildWebhookPayload({
+  config,
+  ticketId,
+  severity,
+  message,
+  operator,
+  event,
+  level,
+  epicId,
+  phase,
+}) {
+  const cleanMessage = message.replace(operator, '').trim();
+  const repo = config.github?.repo;
+  const numericTicketId = Number.parseInt(ticketId, 10);
+  const prefix = severity === 'high' ? '[Action Required]' : `[${severity}]`;
+  const ticketPart =
+    Number.isFinite(numericTicketId) && numericTicketId > 0
+      ? ` ${repo ? `${repo}#${numericTicketId}` : `#${numericTicketId}`}`
+      : '';
+  const text = `${prefix}${ticketPart}: ${cleanMessage}`;
+
+  // `text` first for back-compat with `{text}`-only consumers (Slack-style
+  // incoming webhooks). Typed fields follow for routable subscribers.
+  const envelope = { text, severity };
+  if (Number.isFinite(numericTicketId) && numericTicketId > 0) {
+    envelope.ticketId = numericTicketId;
+  }
+  if (event) envelope.event = event;
+  if (level) envelope.level = level;
+  if (Number.isFinite(epicId) && epicId > 0) envelope.epicId = epicId;
+  if (phase) envelope.phase = phase;
+  return JSON.stringify(envelope);
+}
+
+async function sendWebhook(url, payloadBody, fetchImpl = globalThis.fetch) {
+  const headers = { 'Content-Type': 'application/json' };
+  const webhookSecret = process.env.WEBHOOK_SECRET;
+  if (webhookSecret) {
+    const signature = createHmac('sha256', webhookSecret)
+      .update(payloadBody)
+      .digest('hex');
+    headers['X-Signature-256'] = `sha256=${signature}`;
+  }
+  try {
+    const res = await fetchImpl(url, {
+      method: 'POST',
+      headers,
+      body: payloadBody,
+    });
+    if (!res.ok) {
+      Logger.warn(
+        `[Notify] Webhook returned ${res.status}: ${await res.text().catch(() => '')}`,
+      );
+    }
+  } catch (err) {
+    Logger.warn(`[Notify] Failed to send webhook: ${err.message}`);
+  }
+}
+
+/**
+ * Dispatch a notification across the two channels.
+ *
+ * @param {number} ticketId - GitHub Issue number to post the notification on.
+ *   Pass 0 (or any non-positive) to skip the GitHub comment and fire the
+ *   webhook only.
+ * @param {{
+ *   severity?: 'low'|'medium'|'high',
+ *   message: string,
+ *   event?: string,
+ *   level?: 'task'|'story'|'wave'|'epic',
+ *   epicId?: number,
+ *   phase?: string,
+ * }} payload - `severity` defaults to `medium` when omitted; it controls
+ *   @mention behavior on the comment channel and is carried as webhook
+ *   envelope metadata, but does not gate either channel. `event` is
+ *   required for any channel to fire — event-less dispatches are no-ops.
+ * @param {{
+ *   config?: object,
+ *   provider?: object,
+ *   webhookUrl?: string|null,
+ *   skipComment?: boolean,
+ *   fetchImpl?: typeof fetch,
+ * }} [opts] - `fetchImpl` is injected into the webhook POST in place of
+ *   `globalThis.fetch`; it defaults to the global, so production callers
+ *   never pass it. Tests inject a fake to assert the request body,
+ *   `X-Signature-256` header, and the 4xx/5xx response branches without a
+ *   live network call or a global monkeypatch.
+ */
+export async function notify(ticketId, payload, opts = {}) {
+  const config = opts.config || resolveConfig();
+  const provider = opts.provider || createProvider(config);
+
+  const { severity = 'medium', message, event, level, epicId, phase } = payload;
+  if (!Object.hasOwn(SEVERITY_RANK, severity)) {
+    throw new Error(
+      `[Notify] Invalid severity "${severity}". Expected: low | medium | high.`,
+    );
+  }
+  const operator = config.github?.operatorHandle || '@operator';
+  const notifications = config.github?.notifications;
+  const commentEvents = resolveEventAllowlist(notifications, 'commentEvents');
+  const webhookEvents = resolveEventAllowlist(notifications, 'webhookEvents');
+
+  const numericId = Number.parseInt(ticketId, 10);
+  const noTicket = Number.isNaN(numericId) || numericId <= 0;
+  const callerSuppressed = opts.skipComment === true;
+  const eventAllowedOnComments = Boolean(event) && commentEvents.has(event);
+  const fireComment = !noTicket && !callerSuppressed && eventAllowedOnComments;
+
+  if (fireComment) {
+    // High always @mentions; medium @mentions when `mentionOperator` is set;
+    // low never @mentions.
+    const mention =
+      severity === 'high' ||
+      (severity === 'medium' && notifications?.mentionOperator);
+    const commentBody = mention ? `${operator} ${message}` : message;
+
+    await provider.postComment(numericId, {
+      body: commentBody,
+      type: SEVERITY_TO_COMMENT_TYPE[severity],
+    });
+  }
+
+  // Webhook channel: gated by event-name allowlist. A dispatch without an
+  // `event` field can never reach the webhook — there is no implicit
+  // category for unlabelled notifications.
+  if (event && webhookEvents.has(event)) {
+    // `opts.webhookUrl === undefined` → resolve from process env.
+    // Explicit `null` or string → caller was explicit; don't resolve.
+    const webhookUrl =
+      opts.webhookUrl === undefined ? resolveWebhookUrl() : opts.webhookUrl;
+    if (webhookUrl) {
+      Logger.info(`[Notify] Firing webhook (${event}) to ${webhookUrl}...`);
+      const payloadBody = buildWebhookPayload({
+        config,
+        ticketId,
+        severity,
+        message,
+        operator,
+        event,
+        level,
+        epicId,
+        phase,
+      });
+      await sendWebhook(webhookUrl, payloadBody, opts.fetchImpl);
+    } else {
+      // Event was on the allowlist but no URL is available — surface this
+      // so the operator notices a missing/empty NOTIFICATION_WEBHOOK_URL
+      // instead of silently dropping the dispatch.
+      Logger.warn(
+        `[Notify] Webhook event (${event}) suppressed — no webhook URL resolved (NOTIFICATION_WEBHOOK_URL unset or empty).`,
+      );
+    }
+  }
+}
+
+export function parseNotifyArgs(args) {
+  if (args.length < 1) {
+    throw new Error(
+      'Usage: node notify.js [TicketId] <Message> [--severity low|medium|high]',
+    );
+  }
+
+  let severity = 'medium';
+  const sevIdx = args.indexOf('--severity');
+  let working = args;
+  if (sevIdx !== -1) {
+    const raw = args[sevIdx + 1];
+    if (!raw || !Object.hasOwn(SEVERITY_RANK, raw)) {
+      throw new Error(
+        '[Notify] --severity requires one of: low | medium | high.',
+      );
+    }
+    severity = raw;
+    working = args.filter((_a, i) => i !== sevIdx && i !== sevIdx + 1);
+  }
+
+  if (working.length === 0) {
+    throw new Error('[Notify] Error: Message is required.');
+  }
+
+  let ticketId = 0;
+  let message = '';
+  const explicitTicketFlag = working.findIndex(
+    (arg) => arg === '--ticket' || arg === '--issue',
+  );
+
+  if (explicitTicketFlag !== -1) {
+    const rawTicketId = working[explicitTicketFlag + 1] ?? '';
+    if (!/^\d+$/.test(rawTicketId)) {
+      throw new Error(
+        '[Notify] Error: --ticket/--issue requires a numeric ID.',
+      );
+    }
+    ticketId = Number.parseInt(rawTicketId, 10);
+    const positional = working.filter(
+      (_arg, idx) =>
+        idx !== explicitTicketFlag && idx !== explicitTicketFlag + 1,
+    );
+    message = positional.join(' ').trim();
+  } else {
+    const firstArg = working[0];
+    const isNumeric = /^\d+$/.test(firstArg);
+
+    if (isNumeric) {
+      ticketId = Number.parseInt(firstArg, 10);
+      message = working.slice(1).join(' ').trim();
+    } else {
+      message = firstArg;
+    }
+  }
+
+  if (!message) {
+    throw new Error('[Notify] Error: Message is required.');
+  }
+
+  return { ticketId, message, severity };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const { ticketId, message, severity } = parseNotifyArgs(args);
+
+  // CLI fires always carry the `operator-message` event so they route
+  // through the same event-name allowlist as the rest of the system.
+  await notify(ticketId, {
+    severity,
+    message,
+    event: 'operator-message',
+  });
+}
+
+runAsCli(import.meta.url, main, { source: 'Notify' });

package/.agents/scripts/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/.agents/scripts/post-structured-comment.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/* node:coverage ignore file */
+
+/**
+ * post-structured-comment.js — CLI wrapper for structured comment upsert.
+ *
+ * Successor to the retired mandrel MCP tools. See ADR 20260424-702a in docs/decisions.md for the migration table.
+ *
+ * Delegates to `upsertStructuredComment` from `lib/orchestration/ticketing.js`
+ * and emits the `{ success, ticketId, type }` JSON envelope on stdout.
+ *
+ * Usage:
+ *   node .agents/scripts/post-structured-comment.js \
+ *     --ticket <id> --marker <type> --body-file <path> [--provider github]
+ *
+ * Exit codes:
+ *   0 — upsert succeeded
+ *   non-zero — validation or provider failure (error on stderr)
+ */
+
+import fs from 'node:fs/promises';
+import { parseArgs } from 'node:util';
+import { runAsCli } from './lib/cli-utils.js';
+import { resolveConfig } from './lib/config-resolver.js';
+import {
+  assertValidStructuredCommentType,
+  upsertStructuredComment,
+} from './lib/orchestration/ticketing.js';
+import { createProvider } from './lib/provider-factory.js';
+
+const HELP = `Usage: node .agents/scripts/post-structured-comment.js \\
+  --ticket <id> --marker <type> --body-file <path> [--provider github]
+
+Flags:
+  --ticket       GitHub issue number to comment on (required).
+  --marker       Structured-comment type (e.g. progress, friction,
+                 retro, epic-run-state, wave-0-start) (required).
+  --body-file    Path to a file containing the markdown body (required).
+  --provider     Provider name (default: inferred from .agentrc.json github block).
+  --help         Show this message.
+`;
+
+/**
+ * Core: idempotently upsert the structured comment and return the envelope.
+ * Exported so tests can pin input/output parity against direct SDK use
+ * without spawning a subprocess.
+ */
+export async function runPostStructuredComment({
+  ticketId,
+  type,
+  body,
+  provider,
+}) {
+  assertValidStructuredCommentType(type);
+  await upsertStructuredComment(provider, ticketId, type, body);
+  return { success: true, ticketId, type };
+}
+
+export function parseArgv(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      ticket: { type: 'string' },
+      marker: { type: 'string' },
+      'body-file': { type: 'string' },
+      provider: { type: 'string' },
+      help: { type: 'boolean' },
+    },
+    strict: false,
+  });
+  return values;
+}
+
+/**
+ * Pure: validate the required CLI inputs for `post-structured-comment`. The
+ * orchestrator is otherwise too dense to score under the CRAP cap, and these
+ * rules deserve their own targeted tests.
+ *
+ * @param {Record<string, unknown>} values parsed CLI values
+ * @returns {{ ticketId: number, errors: string[] }} `errors` is empty on success.
+ */
+export function validateRequiredArgs(values) {
+  const ticketId = Number.parseInt(values.ticket ?? '', 10);
+  const errors = [];
+  if (!Number.isFinite(ticketId) || ticketId <= 0) {
+    errors.push('--ticket <id> is required.');
+  }
+  if (!values.marker) errors.push('--marker <type> is required.');
+  if (!values['body-file']) errors.push('--body-file <path> is required.');
+  return { ticketId, errors };
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const values = parseArgv(argv);
+
+  if (values.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+
+  const { ticketId, errors } = validateRequiredArgs(values);
+  if (errors.length) {
+    for (const e of errors) {
+      process.stderr.write(`[post-structured-comment] ${e}\n`);
+    }
+    process.stderr.write(HELP);
+    process.exit(2);
+  }
+
+  const body = await fs.readFile(values['body-file'], 'utf8');
+
+  const config = resolveConfig();
+  const effectiveConfig = values.provider
+    ? { ...config, provider: values.provider }
+    : config;
+  const provider = createProvider(effectiveConfig);
+
+  const envelope = await runPostStructuredComment({
+    ticketId,
+    type: values.marker,
+    body,
+    provider,
+  });
+  process.stdout.write(`${JSON.stringify(envelope)}\n`);
+}
+
+runAsCli(import.meta.url, main, { source: 'post-structured-comment' });

package/.agents/scripts/pr-watch-with-update.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * pr-watch-with-update.js — Phase 8 "watch until green" CLI.
+ *
+ * Polls the PR's required checks to a terminal state and auto-recovers
+ * from `mergeStateStatus: BEHIND` (via bounded `gh pr update-branch`
+ * calls) by delegating to the shared `watchPrToTerminal` primitive in
+ * the lifecycle `Watcher` — the SAME loop the listener runs, so the CLI
+ * and the bus path are byte-for-byte equivalent. No lifecycle bus is
+ * created; this is a direct, synchronous watch with a real exit code.
+ *
+ * Contract (Story #3902):
+ *   - Blocks until every required check is terminal (or the poll cap
+ *     fires).
+ *   - Prints the final `{ checkName: outcome }` map to stdout as JSON.
+ *   - Exits 0 only when every required check is green
+ *     (success / neutral / skipped); exits non-zero otherwise (red
+ *     check, timed-out poll cap, or an unresolvable `gh pr checks`
+ *     failure) so the calling workflow can gate on the exit code.
+ *
+ * Usage:
+ *   node .agents/scripts/pr-watch-with-update.js --pr <n> [--repo owner/repo]
+ *     [--max-updates N] [--poll-interval-ms MS] [--max-polls N]
+ */
+import { parseArgs } from 'node:util';
+import { runAsCli } from './lib/cli-utils.js';
+import { Logger } from './lib/Logger.js';
+import { watchPrToTerminal } from './lib/orchestration/lifecycle/listeners/watcher.js';
+
+function parsePositiveInt(raw, fallback) {
+  if (raw == null) return fallback;
+  const n = Number.parseInt(raw, 10);
+  return Number.isInteger(n) && n >= 0 ? n : fallback;
+}
+
+/**
+ * Run the watch loop and resolve to the exit code (0 = all green,
+ * 1 = not green / failed). Exported for tests so the green / red /
+ * BEHIND paths can be exercised with injected `gh` spawns and no
+ * `process.exit`.
+ *
+ * @param {object} opts
+ * @param {number} opts.prNumber
+ * @param {string|null} [opts.repo]
+ * @param {number} [opts.maxUpdates]
+ * @param {number} [opts.pollIntervalMs]
+ * @param {number} [opts.maxPolls]
+ * @param {Function} [opts.ghPrChecksFn]   inject for tests
+ * @param {Function} [opts.ghPrViewFn]     inject for tests
+ * @param {Function} [opts.ghPrUpdateBranchFn] inject for tests
+ * @param {Function} [opts.sleepFn]        inject for tests
+ * @param {object} [opts.logger]
+ * @param {(line: string) => void} [opts.print] stdout sink (default console.log)
+ * @returns {Promise<number>} process exit code.
+ */
+export async function runPrWatch({
+  prNumber,
+  repo = null,
+  maxUpdates,
+  pollIntervalMs,
+  maxPolls,
+  ghPrChecksFn,
+  ghPrViewFn,
+  ghPrUpdateBranchFn,
+  sleepFn,
+  logger = Logger,
+  print = (line) => process.stdout.write(`${line}\n`),
+} = {}) {
+  if (!Number.isInteger(prNumber) || prNumber < 1)
+    throw new TypeError('runPrWatch: --pr requires a positive integer');
+
+  // `gh` accepts a bare PR number or a URL; passing `<repo>#<n>` lets
+  // `gh` resolve the right repository without a URL. When `--repo` is
+  // omitted, `gh` infers the repo from the cwd's remote.
+  const prRef = repo ? `${repo}#${prNumber}` : String(prNumber);
+
+  const result = await watchPrToTerminal({
+    prUrl: prRef,
+    cwd: process.cwd(),
+    maxPolls: parsePositiveInt(maxPolls, 180),
+    maxUpdates: parsePositiveInt(maxUpdates, 3),
+    pollIntervalMs: parsePositiveInt(pollIntervalMs, 10_000),
+    ...(ghPrChecksFn ? { ghPrChecksFn } : {}),
+    ...(ghPrViewFn ? { ghPrViewFn } : {}),
+    ...(ghPrUpdateBranchFn ? { ghPrUpdateBranchFn } : {}),
+    ...(sleepFn ? { sleepFn } : {}),
+    logger,
+  });
+
+  // Always print the final outcomes map so the operator (and the
+  // workflow log) can see exactly which check blocked.
+  print(
+    JSON.stringify({
+      prNumber,
+      checkOutcomes: result.outcomes,
+      requiredChecks: result.requiredChecks,
+      polls: result.polls,
+      updatesApplied: result.updatesApplied,
+      terminal: result.terminal,
+      green: result.green,
+      ...(result.error ? { error: result.error } : {}),
+    }),
+  );
+
+  if (result.error) {
+    logger.error?.(
+      `[pr-watch] could not resolve required checks: ${result.error}`,
+    );
+    return 1;
+  }
+  if (!result.terminal) {
+    logger.error?.(
+      `[pr-watch] poll cap reached before every required check went terminal (polls=${result.polls}).`,
+    );
+    return 1;
+  }
+  if (!result.green) {
+    const red = Object.entries(result.outcomes)
+      .filter(([, v]) => v !== 'success' && v !== 'neutral' && v !== 'skipped')
+      .map(([k, v]) => `${k}=${v}`)
+      .join(', ');
+    logger.error?.(`[pr-watch] required check(s) not green: ${red}`);
+    return 1;
+  }
+  logger.info?.('[pr-watch] all required checks green.');
+  return 0;
+}
+
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      pr: { type: 'string' },
+      repo: { type: 'string' },
+      'max-updates': { type: 'string' },
+      'poll-interval-ms': { type: 'string' },
+      'max-polls': { type: 'string' },
+    },
+    strict: false,
+  });
+  return runPrWatch({
+    prNumber: Number.parseInt(values.pr ?? '', 10),
+    repo: values.repo ?? null,
+    maxUpdates: values['max-updates'],
+    pollIntervalMs: values['poll-interval-ms'],
+    maxPolls: values['max-polls'],
+  });
+}
+
+runAsCli(import.meta.url, main, {
+  source: 'pr-watch-with-update',
+  propagateExitCode: true,
+});

package/.agents/scripts/providers/github/auth.js

@@ -0,0 +1,65 @@
+/**
+ * GitHub Provider — token resolution.
+ *
+ * Hierarchy: GITHUB_TOKEN / GH_TOKEN env → `gh auth token` CLI fallback
+ * → throws with an instructive error. `execSync` is indirected through a
+ * holder so tests can swap it.
+ *
+ * Extracted from `../github.js` in Story #1846 / Task #1855 — see that
+ * Story for the broader split rationale.
+ */
+
+import { execSync as defaultExecSync } from 'node:child_process';
+
+export const execSyncHolder = { impl: defaultExecSync };
+
+export function __setExecSyncForTests(fn) {
+  execSyncHolder.impl = fn ?? defaultExecSync;
+}
+
+/* node:coverage ignore next */
+export function readGhCliToken() {
+  try {
+    const t = execSyncHolder
+      .impl('gh auth token', {
+        encoding: 'utf8',
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+      .trim();
+    return t || null;
+  } catch {
+    // gh CLI not installed or not authenticated.
+    return null;
+  }
+}
+
+const TOKEN_MISSING_ERROR = [
+  '[GitHubProvider] Authentication Failed: No GitHub token found.',
+  '',
+  'To resolve this, choose one of the following:',
+  '  A. (CI/CD / Agent Script) Set the GITHUB_TOKEN or GH_TOKEN environment variable.',
+  '  B. (Local) Run `gh auth login` to authenticate the GitHub CLI.',
+  '',
+  'See .agents/README.md#github-authentication for details.',
+].join('\n');
+
+/* node:coverage ignore next */
+function readEnvToken() {
+  return process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
+}
+
+/* node:coverage ignore next */
+function memoizeEnvToken(token) {
+  if (!process.env.GITHUB_TOKEN) process.env.GITHUB_TOKEN = token;
+}
+
+/* node:coverage ignore next */
+export function resolveToken() {
+  const envToken = readEnvToken();
+  if (envToken) return envToken;
+  const ghToken = readGhCliToken();
+  if (!ghToken) throw new Error(TOKEN_MISSING_ERROR);
+  memoizeEnvToken(ghToken);
+  return ghToken;
+}