@chrysb/alphaclaw 0.4.6-beta.7 → 0.4.6-beta.9

package/lib/server/onboarding/import/secret-detector.js

@@ -0,0 +1,289 @@
+const path = require("path");
+
+const kSecretKeyPatterns = [
+  /token$/i,
+  /^bot_?token$/i,
+  /api_?key$/i,
+  /secret$/i,
+  /password$/i,
+  /private_?key$/i,
+  /credential/i,
+];
+
+const kSafeKeyExclusions = [
+  /^auth_?dir$/i,
+  /^auth_?store$/i,
+  /^auto_?select/i,
+  /^public_?key$/i,
+];
+
+const kValuePrefixes = [
+  { prefix: "sk-", label: "OpenAI/Anthropic/Stripe" },
+  { prefix: "sk-ant-", label: "Anthropic" },
+  { prefix: "sk-proj-", label: "OpenAI project" },
+  { prefix: "ghp_", label: "GitHub classic PAT" },
+  { prefix: "github_pat_", label: "GitHub fine-grained PAT" },
+  { prefix: "ghs_", label: "GitHub App token" },
+  { prefix: "gho_", label: "GitHub OAuth" },
+  { prefix: "xoxb-", label: "Slack bot" },
+  { prefix: "xoxp-", label: "Slack user" },
+  { prefix: "xoxe-", label: "Slack enterprise" },
+  { prefix: "xoxa-", label: "Slack app" },
+  { prefix: "AIza", label: "Google API key" },
+  { prefix: "ya29.", label: "Google OAuth" },
+  { prefix: "AKIA", label: "AWS access key" },
+  { prefix: "ntn_", label: "Notion" },
+  { prefix: "nvapi-", label: "NVIDIA" },
+  { prefix: "r8_", label: "Replicate" },
+  { prefix: "hf_", label: "Hugging Face" },
+  { prefix: "pk_live_", label: "Stripe publishable" },
+  { prefix: "sk_live_", label: "Stripe secret" },
+  { prefix: "pk_test_", label: "Stripe test pub" },
+  { prefix: "sk_test_", label: "Stripe test secret" },
+  { prefix: "whsec_", label: "Stripe webhook" },
+  { prefix: "SG.", label: "SendGrid" },
+  { prefix: "xai-", label: "xAI/Grok" },
+  { prefix: "eyJ", label: "JWT" },
+];
+
+// Explicit config path -> env var name mapping
+const kConfigPathToEnvVar = {
+  "channels.telegram.botToken": "TELEGRAM_BOT_TOKEN",
+  "channels.discord.token": "DISCORD_BOT_TOKEN",
+  "channels.slack.botToken": "SLACK_BOT_TOKEN",
+  "channels.slack.appToken": "SLACK_APP_TOKEN",
+  "channels.googlechat.serviceAccount": "GOOGLE_CHAT_SERVICE_ACCOUNT",
+  "channels.mattermost.botToken": "MATTERMOST_BOT_TOKEN",
+  "channels.mattermost.url": "MATTERMOST_URL",
+  "channels.twitch.accessToken": "OPENCLAW_TWITCH_ACCESS_TOKEN",
+  "models.providers.openai.apiKey": "OPENAI_API_KEY",
+  "models.providers.anthropic.apiKey": "ANTHROPIC_API_KEY",
+  "models.providers.google.apiKey": "GEMINI_API_KEY",
+  "models.providers.openrouter.apiKey": "OPENROUTER_API_KEY",
+  "models.providers.mistral.apiKey": "MISTRAL_API_KEY",
+  "models.providers.groq.apiKey": "GROQ_API_KEY",
+  "models.providers.cerebras.apiKey": "CEREBRAS_API_KEY",
+  "models.providers.voyage.apiKey": "VOYAGE_API_KEY",
+  "tools.web.search.apiKey": "BRAVE_API_KEY",
+  "audio.apiKey": "ELEVENLABS_API_KEY",
+  "talk.apiKey": "ELEVENLABS_API_KEY",
+  "gateway.auth.token": null, // Dropped — set at deploy time
+};
+
+const isSensitiveKey = (key) => {
+  const str = String(key || "");
+  if (kSafeKeyExclusions.some((p) => p.test(str))) return false;
+  return kSecretKeyPatterns.some((p) => p.test(str));
+};
+
+const matchesValuePrefix = (value) => {
+  const str = String(value || "");
+  for (const { prefix, label } of kValuePrefixes) {
+    if (str.startsWith(prefix)) return { matched: true, label };
+  }
+  return { matched: false };
+};
+
+const isLikelyNonSecret = (value) => {
+  const str = String(value || "").trim();
+  if (str.length < 16) return true;
+  if (/^(true|false)$/i.test(str)) return true;
+  if (/^https?:\/\//.test(str) && !str.includes("token") && !str.includes("key")) return true;
+  if (/^[a-z0-9/-]+$/.test(str) && str.includes("/")) return true;
+  return false;
+};
+
+const maskValue = (value) => {
+  const str = String(value || "");
+  if (str.length <= 8) return "****";
+  return str.slice(0, 4) + "****" + str.slice(-4);
+};
+
+const configPathToEnvName = (dotPath) => {
+  if (kConfigPathToEnvVar[dotPath] !== undefined) {
+    return kConfigPathToEnvVar[dotPath];
+  }
+  const lastKey = dotPath.split(".").pop() || "";
+  return lastKey
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .toUpperCase()
+    .replace(/[^A-Z0-9_]/g, "_");
+};
+
+const walkConfig = (obj, parentPath, results) => {
+  if (!obj || typeof obj !== "object") return;
+  for (const [key, value] of Object.entries(obj)) {
+    const dotPath = parentPath ? `${parentPath}.${key}` : key;
+
+    if (typeof value === "string" && value.trim()) {
+      const explicitEnvVar = kConfigPathToEnvVar[dotPath];
+      if (explicitEnvVar !== undefined) {
+        if (explicitEnvVar === null) continue;
+        if (!isAlreadyEnvRef(value)) {
+          results.push({
+            configPath: dotPath,
+            key,
+            value,
+            maskedValue: maskValue(value),
+            suggestedEnvVar: explicitEnvVar,
+            confidence: "high",
+            source: "config-path",
+          });
+        }
+        continue;
+      }
+
+      const prefixMatch = matchesValuePrefix(value);
+      if (prefixMatch.matched) {
+        if (!isAlreadyEnvRef(value)) {
+          results.push({
+            configPath: dotPath,
+            key,
+            value,
+            maskedValue: maskValue(value),
+            suggestedEnvVar: configPathToEnvName(dotPath),
+            confidence: "high",
+            source: "value-prefix",
+            prefixLabel: prefixMatch.label,
+          });
+        }
+        continue;
+      }
+
+      if (isSensitiveKey(key) && !isLikelyNonSecret(value)) {
+        if (!isAlreadyEnvRef(value)) {
+          results.push({
+            configPath: dotPath,
+            key,
+            value,
+            maskedValue: maskValue(value),
+            suggestedEnvVar: configPathToEnvName(dotPath),
+            confidence: "medium",
+            source: "key-name",
+          });
+        }
+      }
+    } else if (typeof value === "object" && value !== null) {
+      walkConfig(value, dotPath, results);
+    }
+  }
+};
+
+const isAlreadyEnvRef = (value) =>
+  /^\$\{[A-Z_][A-Z0-9_]*\}$/.test(String(value || "").trim());
+
+const parseEnvFileSecrets = (content, fileName) => {
+  const results = [];
+  const lines = String(content || "").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    if (!key || !value) continue;
+    results.push({
+      configPath: `${fileName}:${key}`,
+      key,
+      value,
+      maskedValue: maskValue(value),
+      suggestedEnvVar: key,
+      confidence: "high",
+      source: "env-file",
+      fileName,
+    });
+  }
+  return results;
+};
+
+const detectSecrets = ({ fs, baseDir, configFiles = [], envFiles = [] }) => {
+  const secrets = [];
+  const seen = new Set();
+
+  for (const cfgFile of configFiles) {
+    try {
+      const fullPath = path.join(baseDir, cfgFile);
+      const raw = fs.readFileSync(fullPath, "utf8");
+      const cfg = JSON.parse(raw);
+      const configSecrets = [];
+      walkConfig(cfg, "", configSecrets);
+      for (const secret of configSecrets) {
+        const dedupeKey = `${secret.suggestedEnvVar}:${secret.value}`;
+        if (seen.has(dedupeKey)) continue;
+        seen.add(dedupeKey);
+        secrets.push({ ...secret, file: cfgFile });
+      }
+    } catch {}
+  }
+
+  for (const envFile of envFiles) {
+    try {
+      const fullPath = path.join(baseDir, envFile);
+      const content = fs.readFileSync(fullPath, "utf8");
+      const envSecrets = parseEnvFileSecrets(content, envFile);
+      for (const secret of envSecrets) {
+        const dedupeKey = `${secret.suggestedEnvVar}:${secret.value}`;
+        if (seen.has(dedupeKey)) {
+          const existing = secrets.find(
+            (s) => s.suggestedEnvVar === secret.suggestedEnvVar,
+          );
+          if (existing) {
+            existing.duplicateIn = envFile;
+          }
+          continue;
+        }
+        seen.add(dedupeKey);
+        secrets.push({ ...secret, file: envFile });
+      }
+    } catch {}
+  }
+
+  return secrets;
+};
+
+const extractPreFillValues = ({ fs, baseDir, configFiles = [] }) => {
+  const preFill = {};
+  for (const cfgFile of configFiles) {
+    try {
+      const raw = fs.readFileSync(path.join(baseDir, cfgFile), "utf8");
+      const cfg = JSON.parse(raw);
+
+      if (cfg.models?.active) preFill.MODEL_KEY = cfg.models.active;
+
+      const providers = cfg.models?.providers || {};
+      if (providers.anthropic?.apiKey && !isAlreadyEnvRef(providers.anthropic.apiKey)) {
+        preFill.ANTHROPIC_API_KEY = providers.anthropic.apiKey;
+      }
+      if (providers.openai?.apiKey && !isAlreadyEnvRef(providers.openai.apiKey)) {
+        preFill.OPENAI_API_KEY = providers.openai.apiKey;
+      }
+      if (providers.google?.apiKey && !isAlreadyEnvRef(providers.google.apiKey)) {
+        preFill.GEMINI_API_KEY = providers.google.apiKey;
+      }
+
+      const channels = cfg.channels || {};
+      if (channels.telegram?.botToken && !isAlreadyEnvRef(channels.telegram.botToken)) {
+        preFill.TELEGRAM_BOT_TOKEN = channels.telegram.botToken;
+      }
+      if (channels.discord?.token && !isAlreadyEnvRef(channels.discord.token)) {
+        preFill.DISCORD_BOT_TOKEN = channels.discord.token;
+      }
+
+      const braveKey = cfg.tools?.web?.search?.apiKey;
+      if (braveKey && !isAlreadyEnvRef(braveKey)) {
+        preFill.BRAVE_API_KEY = braveKey;
+      }
+    } catch {}
+  }
+  return preFill;
+};
+
+module.exports = {
+  detectSecrets,
+  extractPreFillValues,
+  isSensitiveKey,
+  matchesValuePrefix,
+  maskValue,
+  parseEnvFileSecrets,
+};

package/lib/server/onboarding/index.js

@@ -1,15 +1,21 @@
 const path = require("path");
 const { kSetupDir, kRootDir } = require("../constants");
+const {
+  resolveConfigIncludes,
+  resolveImportedConfigPaths,
+} = require("./import/import-config");
 const { validateOnboardingInput } = require("./validation");
 const {
   ensureGithubRepoAccessible,
   verifyGithubRepoForOnboarding,
+  cloneRepoToTemp,
 } = require("./github");
 const {
   buildOnboardArgs,
   writeSanitizedOpenclawConfig,
 } = require("./openclaw");
 const {
+  ensureOpenclawRuntimeArtifacts,
   installControlUiSkill,
   syncBootstrapPromptFiles,
 } = require("./workspace");
@@ -18,12 +24,148 @@ const {
   installHourlyGitSyncCron,
 } = require("./cron");
 const { migrateManagedInternalFiles } = require("../internal-files-migration");
+const { installGogCliSkill } = require("../gog-skill");
+
+const kPlaceholderEnvValue = "placeholder";
+const kEnvRefPattern = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
+
+const upsertEnvVar = (items, key, value) => {
+  const normalizedKey = String(key || "").trim();
+  if (!normalizedKey) return items;
+  const normalizedValue = String(value || "");
+  const existing = items.find((entry) => entry.key === normalizedKey);
+  if (existing) {
+    existing.value = normalizedValue;
+    return items;
+  }
+  items.push({ key: normalizedKey, value: normalizedValue });
+  return items;
+};
+
+const collectEnvRefs = (value, found = new Set()) => {
+  if (typeof value === "string") {
+    for (const match of value.matchAll(kEnvRefPattern)) {
+      found.add(match[1]);
+    }
+    return found;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry) => collectEnvRefs(entry, found));
+    return found;
+  }
+  if (value && typeof value === "object") {
+    Object.values(value).forEach((entry) => collectEnvRefs(entry, found));
+  }
+  return found;
+};
+
+const getEnvVarValue = (items, key) =>
+  items.find((entry) => entry.key === key)?.value || "";
+
+const buildPlaceholderReview = ({
+  referencedEnvVars,
+  envVars = [],
+  systemVars = new Set(),
+}) => {
+  const vars = Array.from(referencedEnvVars)
+    .filter((envKey) => !systemVars.has(envKey))
+    .sort()
+    .map((envKey) => {
+      const currentValue = String(getEnvVarValue(envVars, envKey) || "").trim();
+      const status =
+        currentValue === kPlaceholderEnvValue
+          ? "placeholder"
+          : currentValue
+            ? "resolved"
+            : "missing";
+      if (status === "resolved") return null;
+      return {
+        key: envKey,
+        status,
+      };
+    })
+    .filter(Boolean);
+  return {
+    found: vars.length > 0,
+    count: vars.length,
+    vars,
+  };
+};
+
+const normalizeImportedConfig = ({ fs, openclawDir }) => {
+  const configPaths = resolveImportedConfigPaths({ fs, openclawDir });
+  for (const configPath of configPaths) {
+    let cfg = null;
+    try {
+      cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (!cfg || typeof cfg !== "object") continue;
+    let changed = false;
+    const currentToken = String(cfg?.gateway?.auth?.token || "").trim();
+    const expectedTokenRef = "${OPENCLAW_GATEWAY_TOKEN}";
+    if (cfg.gateway?.auth && currentToken !== expectedTokenRef) {
+      cfg.gateway = {
+        ...(cfg.gateway || {}),
+        auth: {
+          ...(cfg.gateway.auth || {}),
+          token: expectedTokenRef,
+        },
+      };
+      changed = true;
+    }
+    if (
+      cfg.hooks &&
+      Object.prototype.hasOwnProperty.call(cfg.hooks, "transformsDir")
+    ) {
+      const { transformsDir, ...nextHooks } = cfg.hooks;
+      void transformsDir;
+      cfg.hooks = nextHooks;
+      changed = true;
+    }
+    if (changed) {
+      fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+    }
+  }
+};
+
+const getImportedConfigEnvRefs = ({ fs, openclawDir }) => {
+  const refs = new Set();
+  const configPaths = resolveImportedConfigPaths({ fs, openclawDir });
+  for (const configPath of configPaths) {
+    try {
+      const raw = fs.readFileSync(configPath, "utf8");
+      collectEnvRefs(JSON.parse(raw), refs);
+    } catch {}
+  }
+  return refs;
+};
+
+const getImportedPlaceholderReview = ({
+  fs,
+  openclawDir,
+  envVars = [],
+  systemVars = new Set(),
+  normalizeConfig = false,
+}) => {
+  if (normalizeConfig) {
+    normalizeImportedConfig({ fs, openclawDir });
+  }
+  const referencedEnvVars = getImportedConfigEnvRefs({ fs, openclawDir });
+  return buildPlaceholderReview({
+    referencedEnvVars,
+    envVars,
+    systemVars,
+  });
+};
 
 const createOnboardingService = ({
   fs,
   constants,
   shellCmd,
   gatewayEnv,
+  readEnvFile,
   writeEnvFile,
   reloadEnv,
   resolveGithubRepoUrl,
@@ -39,13 +181,42 @@ const createOnboardingService = ({
   const verifyGithubSetup = async ({
     githubRepoInput,
     githubToken,
+    mode = "new",
     resolveGithubRepoUrl,
   }) => {
     const repoUrl = resolveGithubRepoUrl(githubRepoInput);
-    return verifyGithubRepoForOnboarding({ repoUrl, githubToken });
+    const verification = await verifyGithubRepoForOnboarding({
+      repoUrl,
+      githubToken,
+      mode,
+    });
+    if (!verification.ok) return verification;
+
+    if (
+      mode === "existing" &&
+      verification.repoExists &&
+      !verification.repoIsEmpty
+    ) {
+      const cloneResult = await cloneRepoToTemp({
+        repoUrl,
+        githubToken,
+        shellCmd,
+      });
+      if (!cloneResult.ok) {
+        return { ok: false, status: 400, error: cloneResult.error };
+      }
+      return { ...verification, tempDir: cloneResult.tempDir };
+    }
+
+    return verification;
   };
 
-  const completeOnboarding = async ({ req, vars, modelKey }) => {
+  const completeOnboarding = async ({
+    req,
+    vars,
+    modelKey,
+    importMode = false,
+  }) => {
     const validation = validateOnboardingInput({
       vars,
       modelKey,
@@ -68,14 +239,37 @@ const createOnboardingService = ({
     } = validation.data;
 
     const repoUrl = resolveGithubRepoUrl(githubRepoInput);
-    const varsToSave = [
-      ...vars.filter((v) => v.value && v.key !== "GITHUB_WORKSPACE_REPO"),
-    ];
-    varsToSave.push({ key: "GITHUB_WORKSPACE_REPO", value: repoUrl });
+    const remoteUrl = `https://github.com/${repoUrl}.git`;
+    const existingConfigPresent =
+      importMode && fs.existsSync(`${OPENCLAW_DIR}/openclaw.json`);
+    const existingEnvVars =
+      typeof readEnvFile === "function" ? readEnvFile() : [];
+    const varsToSave = [...existingEnvVars];
+    for (const entry of vars.filter(
+      (item) => item.value && item.key !== "GITHUB_WORKSPACE_REPO",
+    )) {
+      upsertEnvVar(varsToSave, entry.key, entry.value);
+    }
+    upsertEnvVar(varsToSave, "GITHUB_WORKSPACE_REPO", repoUrl);
+    if (importMode && existingConfigPresent) {
+      const systemVars =
+        constants.kSystemVars instanceof Set
+          ? constants.kSystemVars
+          : new Set();
+      const placeholderReview = getImportedPlaceholderReview({
+        fs,
+        openclawDir: OPENCLAW_DIR,
+        envVars: varsToSave,
+        systemVars,
+        normalizeConfig: true,
+      });
+      for (const placeholderVar of placeholderReview.vars) {
+        upsertEnvVar(varsToSave, placeholderVar.key, kPlaceholderEnvValue);
+      }
+    }
     writeEnvFile(varsToSave);
     reloadEnv();
 
-    const remoteUrl = `https://github.com/${repoUrl}.git`;
     const [, repoName] = repoUrl.split("/");
     const repoCheck = await ensureGithubRepoAccessible({
       repoUrl,
@@ -100,12 +294,30 @@ const createOnboardingService = ({
       workspaceDir: WORKSPACE_DIR,
       baseUrl: getBaseUrl(req),
     });
+    ensureOpenclawRuntimeArtifacts({
+      fs,
+      openclawDir: OPENCLAW_DIR,
+    });
+
+    const hadImportedGit = importMode && fs.existsSync(`${OPENCLAW_DIR}/.git`);
+    if (hadImportedGit) {
+      try {
+        fs.rmSync(`${OPENCLAW_DIR}/.git`, { recursive: true, force: true });
+      } catch {}
+    }
 
-    if (!fs.existsSync(`${OPENCLAW_DIR}/.git`)) {
+    if (hadImportedGit || !fs.existsSync(`${OPENCLAW_DIR}/.git`)) {
       await shellCmd(
         `cd ${OPENCLAW_DIR} && git init -b main && git remote add origin "${remoteUrl}" && git config user.email "agent@alphaclaw.md" && git config user.name "AlphaClaw Agent"`,
       );
       console.log("[onboard] Git initialized");
+    } else if (importMode) {
+      // Ensure remote points to the correct URL for imported repos
+      try {
+        await shellCmd(
+          `cd ${OPENCLAW_DIR} && git remote set-url origin "${remoteUrl}" && git config user.email "agent@alphaclaw.md" && git config user.name "AlphaClaw Agent"`,
+        );
+      } catch {}
     }
 
     if (!fs.existsSync(`${OPENCLAW_DIR}/.gitignore`)) {
@@ -115,24 +327,30 @@ const createOnboardingService = ({
       );
     }
 
-    const onboardArgs = buildOnboardArgs({
-      varMap,
-      selectedProvider,
-      hasCodexOauth,
-      workspaceDir: WORKSPACE_DIR,
-    });
-    await shellCmd(
-      `openclaw onboard ${onboardArgs.map((a) => `"${a}"`).join(" ")}`,
-      {
-        env: {
-          ...process.env,
-          OPENCLAW_HOME: kRootDir,
-          OPENCLAW_CONFIG_PATH: `${OPENCLAW_DIR}/openclaw.json`,
+    if (!existingConfigPresent) {
+      const onboardArgs = buildOnboardArgs({
+        varMap,
+        selectedProvider,
+        hasCodexOauth,
+        workspaceDir: WORKSPACE_DIR,
+      });
+      await shellCmd(
+        `openclaw onboard ${onboardArgs.map((a) => `"${a}"`).join(" ")}`,
+        {
+          env: {
+            ...process.env,
+            OPENCLAW_HOME: kRootDir,
+            OPENCLAW_CONFIG_PATH: `${OPENCLAW_DIR}/openclaw.json`,
+          },
+          timeout: 120000,
         },
-        timeout: 120000,
-      },
-    );
-    console.log("[onboard] Onboard complete");
+      );
+      console.log("[onboard] Onboard complete");
+    } else {
+      console.log(
+        "[onboard] Skipped openclaw onboard (existing config present)",
+      );
+    }
 
     await shellCmd(`openclaw models set "${modelKey}"`, {
       env: gatewayEnv(),
@@ -148,7 +366,9 @@ const createOnboardingService = ({
       fs.rmSync(`${WORKSPACE_DIR}/.git`, { recursive: true, force: true });
     } catch {}
 
-    writeSanitizedOpenclawConfig({ fs, openclawDir: OPENCLAW_DIR, varMap });
+    if (!existingConfigPresent) {
+      writeSanitizedOpenclawConfig({ fs, openclawDir: OPENCLAW_DIR, varMap });
+    }
     authProfiles?.syncConfigAuthReferencesForAgent?.();
     ensureGatewayProxyConfig(getBaseUrl(req));
 
@@ -157,6 +377,7 @@ const createOnboardingService = ({
       openclawDir: OPENCLAW_DIR,
       baseUrl: getBaseUrl(req),
     });
+    installGogCliSkill({ fs, openclawDir: OPENCLAW_DIR });
 
     installHourlyGitSyncScript({ fs, openclawDir: OPENCLAW_DIR });
     await installHourlyGitSyncCron({ fs, openclawDir: OPENCLAW_DIR });
@@ -166,7 +387,7 @@ const createOnboardingService = ({
       JSON.stringify(
         {
           onboarded: true,
-          reason: "onboarding_complete",
+          reason: importMode ? "import_complete" : "onboarding_complete",
           markedAt: new Date().toISOString(),
         },
         null,
@@ -175,7 +396,10 @@ const createOnboardingService = ({
     );
 
     try {
-      await shellCmd(`alphaclaw git-sync -m "initial setup"`, {
+      const commitMsg = importMode
+        ? "imported existing setup via AlphaClaw"
+        : "initial setup";
+      await shellCmd(`alphaclaw git-sync -m "${commitMsg}"`, {
         timeout: 30000,
         env: {
           ...process.env,
@@ -194,4 +418,7 @@ const createOnboardingService = ({
   return { completeOnboarding, verifyGithubSetup };
 };
 
-module.exports = { createOnboardingService };
+module.exports = {
+  createOnboardingService,
+  getImportedPlaceholderReview,
+};