@tasksai/install 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# @tasksai/install
+
+Official installer CLI for TasksAI MCP verticals.
+
+Users normally run this through a product-specific GitHub manifest, for example:
+
+```bash
+npx @tasksai/install lawtasksai --source https://github.com/laudoluxDev/lawtasksai-mcp
+```
+
+The installer:
+
+- verifies the official vertical manifest
+- installs the local MCP runtime
+- connects the user's TasksAI account through browser approval when available
+- stores credentials outside MCP client config
+- configures supported MCP clients
+- runs a local health check
+
+TasksAI servers handle authentication, credits, catalog/search metadata, and
+licensed skill delivery. TasksAI does not process user task content.

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@tasksai/install",
+  "version": "0.1.0",
+  "description": "Shared TasksAI MCP installer CLI",
+  "type": "module",
+  "bin": {
+    "tasksai-install": "src/index.js"
+  },
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "installer",
+    "tasksai",
+    "lawtasksai"
+  ],
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/laudoluxDev/tasksai-mcp.git",
+    "directory": "packages/installer"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check": "node --check src/index.js"
+  }
+}

package/src/index.js

@@ -0,0 +1,638 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import https from "node:https";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { spawnSync } from "node:child_process";
+import { stdin as input, stdout as output } from "node:process";
+
+const INSTALLER_VERSION = "0.1.0";
+const DEFAULT_SOURCES = {
+  lawtasksai: "https://github.com/laudoluxDev/lawtasksai-mcp",
+  priorauthai: "https://github.com/laudoluxDev/priorauthai-mcp"
+};
+
+const CLIENTS = {
+  "claude-desktop": {
+    id: "claude-desktop",
+    displayName: "Claude Desktop",
+    configPath() {
+      if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+      }
+      if (process.platform === "win32") {
+        return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+      }
+      return path.join(os.homedir(), ".config", "Claude", "claude_desktop_config.json");
+    }
+  },
+  cursor: {
+    id: "cursor",
+    displayName: "Cursor",
+    configPath() {
+      return path.join(os.homedir(), ".cursor", "mcp.json");
+    }
+  },
+  windsurf: {
+    id: "windsurf",
+    displayName: "Windsurf",
+    configPath() {
+      return path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
+    }
+  }
+};
+
+main().catch((error) => {
+  console.error(formatError(error));
+  process.exit(1);
+});
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (!options.productId) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (options.command === "doctor") {
+    await doctor(options);
+    return;
+  }
+
+  if (options.command === "update") {
+    await install(options, { updateOnly: true });
+    return;
+  }
+
+  if (options.command === "uninstall") {
+    await uninstall(options);
+    return;
+  }
+
+  await install(options);
+}
+
+function parseArgs(argv) {
+  const options = {
+    productId: null,
+    command: "install",
+    source: null,
+    ref: "main",
+    client: "claude-desktop",
+    auth: "browser",
+    noBrowser: false,
+    yes: false,
+    skipPythonDeps: false
+  };
+
+  const positionals = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--source") options.source = argv[++i];
+    else if (arg === "--ref") options.ref = argv[++i];
+    else if (arg === "--client") options.client = argv[++i];
+    else if (arg === "--auth") options.auth = argv[++i];
+    else if (arg === "--no-browser") options.noBrowser = true;
+    else if (arg === "--yes" || arg === "-y") options.yes = true;
+    else if (arg === "--skip-python-deps") options.skipPythonDeps = true;
+    else if (arg === "--help" || arg === "-h") {
+      printUsage();
+      process.exit(0);
+    } else if (arg.startsWith("--")) {
+      throw new Error(`Unsupported option: ${arg}`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+
+  options.productId = positionals[0] || null;
+  if (positionals[1]) options.command = positionals[1];
+  if (!["install", "doctor", "update", "uninstall"].includes(options.command)) {
+    throw new Error(`Unsupported command: ${options.command}`);
+  }
+  if (!["browser", "license-key"].includes(options.auth)) {
+    throw new Error(`Unsupported auth mode: ${options.auth}. Supported modes: browser, license-key`);
+  }
+  options.source ||= DEFAULT_SOURCES[options.productId];
+  if (!options.source) {
+    throw new Error(`No default source is known for product: ${options.productId}`);
+  }
+  return options;
+}
+
+function printUsage() {
+  console.log(`Usage:
+  tasksai-install <product-id> [install] [--source <repo-url>] [--ref <branch>] [--client claude-desktop|cursor|windsurf|all] [--auth browser|license-key]
+  tasksai-install <product-id> doctor [--client claude-desktop|cursor|windsurf|all]
+  tasksai-install <product-id> update
+  tasksai-install <product-id> uninstall [--client claude-desktop|cursor|windsurf|all]
+
+Examples:
+  tasksai-install lawtasksai --source https://github.com/laudoluxDev/lawtasksai-mcp
+  tasksai-install lawtasksai doctor
+`);
+}
+
+async function install(options, { updateOnly = false } = {}) {
+  const source = parseSource(options.source, options.ref);
+  const manifest = await loadJson(source, "agent-install.json");
+  const vertical = await loadJson(source, "vertical.json");
+  verifySource({ options, source, manifest, vertical });
+
+  const installDir = getInstallDir(options.productId);
+  const runtimeDir = path.join(installDir, "runtime");
+  const vendorDir = path.join(installDir, "python");
+  await fsp.mkdir(runtimeDir, { recursive: true });
+  await fsp.mkdir(path.join(installDir, "logs"), { recursive: true });
+  await logEvent(installDir, "install_start", {
+    productId: options.productId,
+    source: source.repoUrl,
+    client: options.client,
+    updateOnly
+  });
+
+  await writeJson(path.join(installDir, "agent-install.json"), manifest);
+  await writeJson(path.join(installDir, "vertical.json"), vertical);
+  await downloadRuntime(source, runtimeDir);
+
+  if (!options.skipPythonDeps) {
+    installPythonDeps(runtimeDir, vendorDir);
+  }
+
+  const licenseKey = await resolveLicenseKey(options, vertical, installDir);
+  const envEntries = {
+    TASKSAI_LICENSE_KEY: licenseKey,
+    LAWTASKSAI_LICENSE_KEY: licenseKey,
+    TASKSAI_PRODUCT_ID: vertical.product_id,
+    TASKSAI_API_BASE: vertical.api_base_url,
+    LAWTASKSAI_API_BASE: vertical.api_base_url
+  };
+  await writeEnvFile(path.join(installDir, ".env"), envEntries);
+  await writeEnvFile(path.join(runtimeDir, ".env"), envEntries);
+
+  if (updateOnly) {
+    await logEvent(installDir, "update_complete", { productId: options.productId });
+    console.log(`${vertical.display_name} runtime updated at ${installDir}`);
+    return;
+  }
+
+  const clients = resolveClients(options.client);
+  for (const client of clients) {
+    await configureMcpClient({ client, vertical, installDir, runtimeDir, vendorDir });
+  }
+
+  await doctor(options, { quietSuccess: true });
+  await logEvent(installDir, "install_complete", {
+    productId: options.productId,
+    clients: clients.map((client) => client.id)
+  });
+  console.log(`${vertical.display_name} is installed. Restart ${clients.map((client) => client.displayName).join(", ")} to see the tools.`);
+  console.log(`After restart, ask: "${vertical.first_prompt}"`);
+}
+
+async function doctor(options, { quietSuccess = false } = {}) {
+  const installDir = getInstallDir(options.productId);
+  const verticalPath = path.join(installDir, "vertical.json");
+  const envPath = path.join(installDir, ".env");
+  const serverPath = path.join(installDir, "runtime", "server.py");
+  const clients = resolveClients(options.client);
+
+  const problems = [];
+  if (!fs.existsSync(verticalPath)) problems.push(`Missing ${verticalPath}`);
+  if (!fs.existsSync(envPath)) problems.push(`Missing ${envPath}`);
+  if (!fs.existsSync(serverPath)) problems.push(`Missing ${serverPath}`);
+  const vertical = fs.existsSync(verticalPath) ? await readJson(verticalPath) : { product_id: options.productId };
+
+  for (const client of clients) {
+    const configPath = client.configPath();
+    if (fs.existsSync(configPath)) {
+      const config = await readJson(configPath);
+      if (!config.mcpServers?.[vertical.product_id]) {
+        problems.push(`${client.displayName} config does not contain mcpServers.${vertical.product_id}`);
+      }
+    } else {
+      problems.push(`${client.displayName} config not found at ${configPath}`);
+    }
+  }
+
+  if (problems.length) {
+    throw new Error(`TasksAI doctor found issues:\n- ${problems.join("\n- ")}`);
+  }
+
+  await logEvent(installDir, "doctor_passed", {
+    productId: options.productId,
+    clients: clients.map((client) => client.id)
+  });
+  if (!quietSuccess) console.log("TasksAI doctor passed.");
+}
+
+async function uninstall(options) {
+  const installDir = getInstallDir(options.productId);
+  const clients = resolveClients(options.client);
+
+  for (const client of clients) {
+    const configPath = client.configPath();
+    if (!fs.existsSync(configPath)) {
+      console.log(`${client.displayName} config not found; nothing to remove.`);
+      continue;
+    }
+
+    await withLock(`${configPath}.lock`, async () => {
+      const config = await readJson(configPath);
+      const key = options.productId;
+      if (!config.mcpServers?.[key]) {
+        console.log(`${client.displayName} does not have a ${key} MCP entry.`);
+        return;
+      }
+      await backupFile(configPath);
+      delete config.mcpServers[key];
+      await atomicWriteJson(configPath, config);
+    });
+
+    console.log(`${options.productId} was removed from ${client.displayName}.`);
+  }
+
+  await logEvent(installDir, "uninstall_complete", {
+    productId: options.productId,
+    clients: clients.map((client) => client.id)
+  });
+}
+
+async function configureMcpClient({ client, vertical, installDir, runtimeDir, vendorDir }) {
+  const configPath = client.configPath();
+  await fsp.mkdir(path.dirname(configPath), { recursive: true });
+
+  await withLock(`${configPath}.lock`, async () => {
+    const config = fs.existsSync(configPath) ? await readJson(configPath) : {};
+    if (!config.mcpServers || typeof config.mcpServers !== "object") config.mcpServers = {};
+
+    await backupFile(configPath);
+    config.mcpServers[vertical.product_id] = {
+      command: "python3",
+      args: [path.join(runtimeDir, "server.py")],
+      env: {
+        TASKSAI_PRODUCT_ID: vertical.product_id,
+        TASKSAI_API_BASE: vertical.api_base_url,
+        TASKSAI_CLIENT: client.id,
+        PYTHONPATH: vendorDir,
+        DOTENV_PATH: path.join(installDir, ".env")
+      }
+    };
+
+    await atomicWriteJson(configPath, config);
+  });
+}
+
+function resolveClients(clientOption) {
+  if (clientOption === "all") {
+    return Object.values(CLIENTS);
+  }
+  const client = CLIENTS[clientOption];
+  if (!client) {
+    throw new Error(`Unsupported client: ${clientOption}. Supported clients: ${Object.keys(CLIENTS).join(", ")}, all`);
+  }
+  return [client];
+}
+
+async function downloadRuntime(source, runtimeDir) {
+  const serverText = await loadText(source, "server.py");
+  const requirementsText = await loadText(source, "requirements.txt");
+  await fsp.writeFile(path.join(runtimeDir, "server.py"), serverText, "utf8");
+  await fsp.writeFile(path.join(runtimeDir, "requirements.txt"), requirementsText, "utf8");
+}
+
+function installPythonDeps(runtimeDir, vendorDir) {
+  const python = findPython();
+  if (!python) throw new Error("Python 3 is required but was not found on PATH.");
+  fs.mkdirSync(vendorDir, { recursive: true });
+  const result = spawnSync(python, [
+    "-m",
+    "pip",
+    "install",
+    "--upgrade",
+    "--target",
+    vendorDir,
+    "-r",
+    path.join(runtimeDir, "requirements.txt")
+  ], { stdio: "inherit" });
+  if (result.status !== 0) {
+    throw new Error("Python dependency installation failed.");
+  }
+}
+
+function findPython() {
+  for (const candidate of ["python3", "python"]) {
+    const result = spawnSync(candidate, ["--version"], { encoding: "utf8" });
+    if (result.status === 0 && /Python 3\./.test(`${result.stdout}${result.stderr}`)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+async function resolveLicenseKey(options, vertical, installDir) {
+  const envNames = ["TASKSAI_LICENSE_KEY", "LAWTASKSAI_LICENSE_KEY"];
+  for (const name of envNames) {
+    if (process.env[name]) return process.env[name].trim();
+  }
+
+  const envPath = path.join(installDir, ".env");
+  if (fs.existsSync(envPath)) {
+    const existing = await fsp.readFile(envPath, "utf8");
+    for (const name of envNames) {
+      const match = existing.match(new RegExp(`^${name}=(.+)$`, "m"));
+      if (match?.[1]) return match[1].trim();
+    }
+  }
+
+  if (!process.stdin.isTTY) {
+    throw new Error(`No license key found. Set TASKSAI_LICENSE_KEY before installing ${vertical.display_name}.`);
+  }
+
+  if (options.auth === "browser" && !process.env.TASKSAI_DISABLE_BROWSER_AUTH) {
+    try {
+      const browserKey = await resolveLicenseKeyWithBrowser(vertical, options);
+      if (browserKey) return browserKey;
+    } catch (error) {
+      console.log(`Browser connection was not completed: ${redact(error.message)}`);
+      console.log("Falling back to license-key entry.");
+    }
+  }
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = await rl.question(`Enter your ${vertical.display_name} license key: `);
+    if (!answer.trim()) throw new Error("No license key provided.");
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+
+async function resolveLicenseKeyWithBrowser(vertical, options) {
+  const apiBase = (vertical.api_base_url || "").replace(/\/$/, "");
+  if (!apiBase) throw new Error("No API base URL is configured for browser connection.");
+
+  const started = await postJson(`${apiBase}/v1/mcp/connect/start`, {
+    product_id: vertical.product_id,
+    client_name: options.client
+  });
+
+  console.log("");
+  console.log(`Connect your ${vertical.display_name} account in the browser.`);
+  console.log(`Code: ${started.user_code}`);
+  console.log(`URL:  ${started.verification_url}`);
+  console.log("");
+  if (!options.noBrowser) {
+    openExternalUrl(started.verification_url);
+  }
+  console.log("Waiting for browser approval. Press Ctrl+C to cancel.");
+
+  const intervalMs = Math.max(1, Number(started.interval || 2)) * 1000;
+  const expiresAt = Date.now() + Math.max(30, Number(started.expires_in || 600)) * 1000;
+
+  while (Date.now() < expiresAt) {
+    await delay(intervalMs);
+    try {
+      const token = await postJson(`${apiBase}/v1/mcp/connect/token`, {
+        device_code: started.device_code
+      });
+      if (token.license_key) {
+        console.log(`${vertical.display_name} account connected.`);
+        return token.license_key;
+      }
+    } catch (error) {
+      if (error.statusCode === 428 || /authorization_pending/.test(error.message)) {
+        continue;
+      }
+      throw error;
+    }
+  }
+
+  throw new Error("Browser approval timed out.");
+}
+
+function verifySource({ options, source, manifest, vertical }) {
+  if (manifest.product_id !== options.productId) {
+    throw new Error(`Manifest product_id ${manifest.product_id} does not match requested product ${options.productId}.`);
+  }
+  if (vertical.product_id !== options.productId) {
+    throw new Error(`Vertical product_id ${vertical.product_id} does not match requested product ${options.productId}.`);
+  }
+  if (manifest.official_package !== "@tasksai/install") {
+    throw new Error(`Unexpected installer package: ${manifest.official_package}`);
+  }
+  if (source.kind === "github" && manifest.official_github_repo !== source.repoUrl) {
+    throw new Error(`Source repo ${source.repoUrl} does not match manifest official repo ${manifest.official_github_repo}.`);
+  }
+  if (!manifest.official_domain || !vertical.website_url?.includes(manifest.official_domain)) {
+    throw new Error("Manifest official domain does not match vertical website URL.");
+  }
+  const npxInstaller = getNpxInstaller(manifest);
+  const command = npxInstaller?.command;
+  const args = npxInstaller?.args || [];
+  if (command !== "npx" || !Array.isArray(args) || args[0] !== "@tasksai/install") {
+    throw new Error("Manifest installer command is not the approved @tasksai/install npx command.");
+  }
+}
+
+function getNpxInstaller(manifest) {
+  if (manifest.installer?.npx) return manifest.installer.npx;
+  return manifest.installer;
+}
+
+function parseSource(source, ref) {
+  if (source.startsWith("file://")) {
+    return { kind: "file", root: source.slice("file://".length), ref, repoUrl: source };
+  }
+  if (source.startsWith("/") || source.startsWith(".")) {
+    return { kind: "file", root: path.resolve(source), ref, repoUrl: source };
+  }
+  const match = source.match(/^https:\/\/github\.com\/([^/]+)\/([^/#?]+)(?:[/?#].*)?$/);
+  if (!match) throw new Error(`Unsupported source URL: ${source}`);
+  const [, owner, repo] = match;
+  return {
+    kind: "github",
+    owner,
+    repo,
+    ref,
+    repoUrl: `https://github.com/${owner}/${repo}`
+  };
+}
+
+async function loadJson(source, filePath) {
+  return JSON.parse(await loadText(source, filePath));
+}
+
+async function loadText(source, filePath) {
+  if (source.kind === "file") {
+    return fsp.readFile(path.join(source.root, filePath), "utf8");
+  }
+  const rawUrl = `https://raw.githubusercontent.com/${source.owner}/${source.repo}/${encodeURIComponent(source.ref)}/${filePath}`;
+  return fetchText(rawUrl);
+}
+
+function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { "User-Agent": `tasksai-install/${INSTALLER_VERSION}` } }, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        fetchText(response.headers.location).then(resolve, reject);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        reject(new Error(`GET ${url} failed with HTTP ${response.statusCode}`));
+        response.resume();
+        return;
+      }
+      let body = "";
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => {
+        body += chunk;
+      });
+      response.on("end", () => resolve(body));
+    }).on("error", reject);
+  });
+}
+
+function postJson(url, body) {
+  const payload = JSON.stringify(body || {});
+  return new Promise((resolve, reject) => {
+    const request = https.request(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+        "User-Agent": `tasksai-install/${INSTALLER_VERSION}`
+      }
+    }, (response) => {
+      let responseBody = "";
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => {
+        responseBody += chunk;
+      });
+      response.on("end", () => {
+        let data = {};
+        if (responseBody) {
+          try {
+            data = JSON.parse(responseBody);
+          } catch {
+            data = { detail: responseBody };
+          }
+        }
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+          const detail = typeof data.detail === "string" ? data.detail : `HTTP ${response.statusCode}`;
+          const error = new Error(detail);
+          error.statusCode = response.statusCode;
+          reject(error);
+          return;
+        }
+        resolve(data);
+      });
+    });
+    request.on("error", reject);
+    request.write(payload);
+    request.end();
+  });
+}
+
+function openExternalUrl(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawnSync(command, args, { stdio: "ignore", detached: true });
+}
+
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+function getInstallDir(productId) {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "TasksAI", productId);
+  }
+  if (process.platform === "win32") {
+    return path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "TasksAI", productId);
+  }
+  return path.join(os.homedir(), ".local", "share", "TasksAI", productId);
+}
+
+async function withLock(lockPath, callback) {
+  let handle;
+  try {
+    handle = await fsp.open(lockPath, "wx");
+    await handle.writeFile(String(process.pid));
+    return await callback();
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new Error(`Another TasksAI installer is already editing this config (${lockPath}).`);
+    }
+    throw error;
+  } finally {
+    if (handle) await handle.close();
+    await fsp.rm(lockPath, { force: true });
+  }
+}
+
+async function backupFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "").replace("T", "-");
+  const backupPath = `${filePath}.tasksai-backup-${stamp}`;
+  await fsp.copyFile(filePath, backupPath);
+  return backupPath;
+}
+
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await fsp.readFile(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`${filePath} could not be read as JSON. No changes were made. ${error.message}`);
+  }
+}
+
+async function writeJson(filePath, value) {
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWriteJson(filePath, value);
+}
+
+async function atomicWriteJson(filePath, value) {
+  const text = `${JSON.stringify(value, null, 2)}\n`;
+  JSON.parse(text);
+  const tmpPath = `${filePath}.tmp-${process.pid}`;
+  await fsp.writeFile(tmpPath, text, { encoding: "utf8", mode: 0o600 });
+  await fsp.rename(tmpPath, filePath);
+}
+
+async function writeEnvFile(filePath, entries) {
+  const lines = Object.entries(entries).map(([key, value]) => `${key}=${String(value).replace(/\n/g, "")}`);
+  await fsp.writeFile(filePath, `${lines.join("\n")}\n`, { encoding: "utf8", mode: 0o600 });
+}
+
+async function logEvent(installDir, event, details = {}) {
+  const logDir = path.join(installDir, "logs");
+  await fsp.mkdir(logDir, { recursive: true });
+  const entry = {
+    timestamp: new Date().toISOString(),
+    installerVersion: INSTALLER_VERSION,
+    event,
+    details
+  };
+  const line = `${redact(JSON.stringify(entry))}\n`;
+  await fsp.appendFile(path.join(logDir, "installer.log"), line, "utf8");
+}
+
+function formatError(error) {
+  const message = error?.message || String(error);
+  return `TasksAI installer failed: ${redact(message)}`;
+}
+
+function redact(text) {
+  return String(text)
+    .replace(/\b[a-z]{2,4}_[A-Za-z0-9_-]{8,}\b/g, (match) => `${match.split("_")[0]}_[REDACTED]`)
+    .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]")
+    .replace(/gh[opsu]_[A-Za-z0-9_]+/g, "gh_[REDACTED]");
+}