meshy-node 0.10.3 → 0.10.5

package/main.cjs

@@ -131632,6 +131632,8 @@ function formatHelp(command) {
       "      --reset                Ignore remembered startup options and prompt again",
       "      --disable-auth         Disable bearer auth for this run",
       "      --qr-code              Render a mobile connection QR for the node DevTunnel URL",
+      "      --enable-ghc-tunnel    Enable the GitHub Copilot Tunnel without prompting",
+      "      --disable-ghc-tunnel   Disable the GitHub Copilot Tunnel without prompting",
       "  -h, --help                 Show this help"
     ].join("\n");
   }
@@ -131664,6 +131666,8 @@ function formatHelp(command) {
     "      --reset                Ignore remembered startup options and prompt again",
     "      --disable-auth         Disable bearer auth for this run",
     "      --qr-code              Render a mobile connection QR for the node DevTunnel URL",
+    "      --enable-ghc-tunnel    Enable the GitHub Copilot Tunnel without prompting",
+    "      --disable-ghc-tunnel   Disable the GitHub Copilot Tunnel without prompting",
     "  -h, --help                 Show this help"
   ].join("\n");
 }
@@ -131750,6 +131754,12 @@ function parseArgs(argv) {
       case "--qr-code":
         result.qrCode = true;
         break;
+      case "--enable-ghc-tunnel":
+        result.ghcTunnel = true;
+        break;
+      case "--disable-ghc-tunnel":
+        result.ghcTunnel = false;
+        break;
       default:
         if (!arg.startsWith("-") && !result.command && isKnownCommand(arg)) {
           result.command = arg;
@@ -132242,7 +132252,7 @@ function formatBanner(info) {
   const lines = [
     `Node:      ${info.name}`,
     `Role:      ${info.role} (term ${info.term})`,
-    `Endpoint:  ${info.endpoint}`,
+    `Node URL:  ${info.endpoint}`,
     `Dashboard: http://localhost:${info.port}`
   ];
   if (info.dashboardOrigin) {
@@ -148093,6 +148103,12 @@ function parseRuntimeRestartStartArgs(value) {
     }
     startArgs.qrCode = value.qrCode;
   }
+  if (value.ghcTunnel !== void 0) {
+    if (typeof value.ghcTunnel !== "boolean") {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime restart ghcTunnel must be a boolean", 400);
+    }
+    startArgs.ghcTunnel = value.ghcTunnel;
+  }
   return Object.keys(startArgs).length > 0 ? startArgs : void 0;
 }
 function parseOptionalString(value, key2) {
@@ -148119,6 +148135,9 @@ var DEFAULT_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_STARTUP_TIMEOUT_MS = 15 * 60 * 1e3;
 var DEFAULT_STOP_TIMEOUT_MS = 3e3;
 var GHC_TUNNEL_ARGS = ["-y", "ghc-tunnel@latest", "-d"];
+var GHC_TUNNEL_SETUP_ARGS = ["-y", "ghc-tunnel@latest", "--setup", "-d"];
+var GHC_TUNNEL_READY_PATTERN = /GitHub Copilot API Proxy/i;
+var GHC_TUNNEL_API_PATTERN = /^\s*(OpenAI API|Responses API|Anthropic API)\b/im;
 var trackedTunnels = /* @__PURE__ */ new Map();
 function createTail() {
   return { text: "", observedBytes: 0, truncated: false };
@@ -148191,11 +148210,8 @@ function tunnelArgs() {
 function windowsShellQuote(value) {
   return /[\s&()^|<>"]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
 }
-function createCopilotTunnelSpawnInvocation(host, port, platform6 = process.platform) {
-  void host;
-  void port;
+function buildNpxInvocation(displayArgs, platform6) {
   const displayCommand = tunnelCommand(platform6);
-  const displayArgs = tunnelArgs();
   if (platform6 !== "win32") return { command: displayCommand, args: displayArgs, displayCommand, displayArgs };
   return {
     command: "cmd.exe",
@@ -148204,6 +148220,14 @@ function createCopilotTunnelSpawnInvocation(host, port, platform6 = process.plat
     displayArgs
   };
 }
+function createCopilotTunnelSpawnInvocation(host, port, platform6 = process.platform) {
+  void host;
+  void port;
+  return buildNpxInvocation(tunnelArgs(), platform6);
+}
+function createCopilotTunnelSetupInvocation(platform6 = process.platform) {
+  return buildNpxInvocation([...GHC_TUNNEL_SETUP_ARGS], platform6);
+}
 function checkTcpPort(host, port, timeoutMs) {
   return new Promise((resolve24) => {
     const socket = import_node_net.default.createConnection({ host, port });
@@ -148244,6 +148268,9 @@ function parseGithubDeviceFlow(output) {
     ...expires ? { expiresInSeconds: Number(expires) } : {}
   };
 }
+function hasGithubCopilotTunnelReadyOutput(output) {
+  return GHC_TUNNEL_READY_PATTERN.test(output) && GHC_TUNNEL_API_PATTERN.test(output);
+}
 function buildResult(options) {
   const available = options.available ?? (options.status === "already-running" || options.status === "available");
   return {
@@ -148429,8 +148456,11 @@ async function enableGithubCopilotTunnel(options = {}) {
 ${stderr.text}`) ?? auth;
     publish2(auth ? "auth-required" : "starting");
   };
-  child.stdout?.on("data", (chunk) => handleOutput(stdout, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
-  child.stderr?.on("data", (chunk) => handleOutput(stderr, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
+  const stdoutListener = (chunk) => handleOutput(stdout, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  const stderrListener = (chunk) => handleOutput(stderr, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  const drainListener = (_chunk) => void 0;
+  child.stdout?.on("data", stdoutListener);
+  child.stderr?.on("data", stderrListener);
   child.once("error", (err) => {
     childState.spawnError = err instanceof Error ? err : new Error(String(err));
   });
@@ -148439,11 +148469,21 @@ ${stderr.text}`) ?? auth;
     if (trackedTunnels.get(key2) === child) trackedTunnels.delete(key2);
   });
   publish2("starting");
+  const releaseStartupOutputCapture = () => {
+    child.stdout?.unref?.();
+    child.stderr?.unref?.();
+    if (options.captureOutputAfterReady !== false) return;
+    child.stdout?.removeListener?.("data", stdoutListener);
+    child.stderr?.removeListener?.("data", stderrListener);
+    child.stdout?.on("data", drainListener);
+    child.stderr?.on("data", drainListener);
+  };
   const deadline = Date.now() + startupTimeoutMs;
   while (Date.now() < deadline) {
     if (await portChecker(host, port, portCheckTimeoutMs)) {
       trackedTunnels.set(key2, child);
       child.unref?.();
+      releaseStartupOutputCapture();
       return buildResult({ host, port, command, args, pid, status: "available", stdout, stderr, auth });
     }
     if (childState.spawnError) {
@@ -148458,6 +148498,72 @@ ${stderr.text}`) ?? auth;
   await terminateChildProcess(child, stopTimeoutMs);
   return buildResult({ host, port, command, args, pid, status: "failed", stdout, stderr, auth, detail: `Timed out waiting for port ${port}` });
 }
+async function runGithubCopilotTunnelSetup(options = {}) {
+  const host = DEFAULT_HOST;
+  const port = DEFAULT_PORT;
+  const invocation = createCopilotTunnelSetupInvocation();
+  const command = invocation.displayCommand;
+  const args = invocation.displayArgs;
+  const stdout = createTail();
+  const stderr = createTail();
+  const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
+  let auth = null;
+  const child = (options.spawnSetup ?? defaultSpawnTunnel)(invocation.command, invocation.args, {
+    cwd: options.cwd ?? process.cwd(),
+    shell: false,
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const pid = typeof child.pid === "number" ? child.pid : null;
+  const publish2 = (status, detail) => {
+    options.onProgress?.(buildResult({ host, port, command, args, pid, status, stdout, stderr, auth, detail }));
+  };
+  let settled = false;
+  let resolveResult;
+  const releaseSetupOutputCapture = () => {
+    child.stdout?.unref?.();
+    child.stderr?.unref?.();
+    child.stdout?.removeListener?.("data", stdoutListener);
+    child.stderr?.removeListener?.("data", stderrListener);
+    child.unref?.();
+  };
+  const settle = (result) => {
+    if (settled) return;
+    settled = true;
+    resolveResult?.(result);
+  };
+  const handleOutput = (target, chunk) => {
+    appendTail(target, chunk, outputLimitBytes);
+    auth = parseGithubDeviceFlow(`${stdout.text}
+${stderr.text}`) ?? auth;
+    publish2(auth ? "auth-required" : "starting");
+    if (options.resolveOnReadyOutput && hasGithubCopilotTunnelReadyOutput(`${stdout.text}
+${stderr.text}`)) {
+      releaseSetupOutputCapture();
+      settle(buildResult({ host, port, command, args, pid, status: "available", available: true, stdout, stderr, auth }));
+    }
+  };
+  const stdoutListener = (chunk) => handleOutput(stdout, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  const stderrListener = (chunk) => handleOutput(stderr, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  child.stdout?.on("data", stdoutListener);
+  child.stderr?.on("data", stderrListener);
+  publish2("starting");
+  return new Promise((resolve24) => {
+    resolveResult = resolve24;
+    child.once("error", (err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      settle(buildResult({ host, port, command, args, pid, status: "failed", available: false, stdout, stderr, auth, detail: message }));
+    });
+    child.once("close", (code4, signal) => {
+      if (code4 === 0) {
+        settle(buildResult({ host, port, command, args, pid, status: "available", available: true, stdout, stderr, auth }));
+        return;
+      }
+      const detail = `ghc-tunnel --setup exited with code ${code4 ?? "null"}${signal ? ` (${signal})` : ""}`;
+      settle(buildResult({ host, port, command, args, pid, status: "failed", available: false, stdout, stderr, auth, detail }));
+    });
+  });
+}
 
 // ../../packages/api/src/node/node-operation-service.ts
 var LEADER_REPORT_RETRY_MS = 5e3;
@@ -180150,10 +180256,27 @@ var path34 = __toESM(require("path"), 1);
 var readline = __toESM(require("readline/promises"), 1);
 var import_node_child_process13 = require("child_process");
 var STARTUP_REQUIREMENTS = ["az", "devtunnel", "claude", "codex", "copilot"];
+var GITHUB_AUTH_STATUS_ARGS = ["auth", "status", "--hostname", "github.com"];
+var GITHUB_AUTH_LOGIN_ARGS = [
+  "auth",
+  "login",
+  "--hostname",
+  "github.com",
+  "--web",
+  "--git-protocol",
+  "https",
+  "--skip-ssh-key"
+];
+var COPILOT_TUNNEL_PORT2 = 8314;
 function writeLine(stream, message = "") {
   stream.write(`${message}
 `);
 }
+var ANSI = { reset: "\x1B[0m", bold: "\x1B[1m", cyan: "\x1B[36m", green: "\x1B[32m", amber: "\x1B[33m", red: "\x1B[31m" };
+function highlight(label, message) {
+  const color2 = { info: "bold", success: "green", warning: "amber", error: "red", accent: "cyan" }[label];
+  return `${ANSI[color2]}${message}${ANSI.reset}`;
+}
 function shouldPromptForStartupTools() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
@@ -180265,10 +180388,13 @@ function buildLoginCommand(requirement) {
   if (requirement === "az") {
     return { command: "az", args: ["login"] };
   }
+  if (requirement === "copilot") {
+    return { command: "gh", args: [...GITHUB_AUTH_LOGIN_ARGS] };
+  }
   return { command: "devtunnel", args: ["user", "login"] };
 }
 function isAuthenticated(requirement, commandRunner) {
-  const command = requirement === "az" ? { command: "az", args: ["account", "show"] } : { command: "devtunnel", args: ["user", "show"] };
+  const command = requirement === "az" ? { command: "az", args: ["account", "show"] } : requirement === "copilot" ? { command: "gh", args: [...GITHUB_AUTH_STATUS_ARGS] } : { command: "devtunnel", args: ["user", "show"] };
   const result = commandRunner(command.command, command.args, false);
   if (!result.ok) {
     return false;
@@ -180284,7 +180410,7 @@ function isRequirementSatisfied(requirement, status) {
   if (!status || status.installed !== true || status.status !== "ok") {
     return false;
   }
-  if (requirement === "az" || requirement === "devtunnel") {
+  if (requirement === "az" || requirement === "devtunnel" || requirement === "copilot") {
     return status.authenticated === true;
   }
   return true;
@@ -180293,12 +180419,214 @@ function sleep4(ms) {
   return new Promise((resolve24) => setTimeout(resolve24, ms));
 }
 function areCachedAuthRequirementsCurrent(commandRunner) {
-  return isAuthenticated("az", commandRunner) && isAuthenticated("devtunnel", commandRunner);
+  return isAuthenticated("az", commandRunner) && isAuthenticated("devtunnel", commandRunner) && isAuthenticated("copilot", commandRunner);
 }
 function resolveStartupRequirementsMetadata(storagePath) {
   const metadata = readStartupMetadataFile(storagePath).startupRequirements;
   return metadata && typeof metadata === "object" ? metadata : {};
 }
+function persistCopilotTunnelPreference(storagePath, metadata, enabled2, now) {
+  metadata.copilotTunnel = { enabled: enabled2, updatedAt: now.toISOString() };
+  const metadataFile = readStartupMetadataFile(storagePath);
+  metadataFile.startupRequirements = {
+    ...metadataFile.startupRequirements ?? {},
+    ...metadata
+  };
+  writeStartupMetadataFile(storagePath, metadataFile);
+  return metadata;
+}
+async function ensureOptionalCopilotTunnel(options) {
+  if (!isRequirementSatisfied("copilot", options.metadata.components?.copilot)) {
+    return;
+  }
+  const status = await checkGithubCopilotTunnel({
+    portChecker: options.startupOptions.copilotTunnelPortChecker,
+    portCheckTimeoutMs: options.startupOptions.copilotTunnelPortCheckTimeoutMs
+  });
+  if (status.available) {
+    if (options.startupOptions.copilotTunnelEnabled !== void 0) {
+      persistCopilotTunnelPreference(options.storagePath, options.metadata, options.startupOptions.copilotTunnelEnabled, options.now);
+    }
+    writeLine(options.stdout, highlight("success", `GitHub Copilot Tunnel already available on port ${COPILOT_TUNNEL_PORT2}; skipping setup.`));
+    return;
+  }
+  const preference = options.startupOptions.copilotTunnelEnabled ?? options.metadata.copilotTunnel?.enabled;
+  if (preference === false) {
+    persistCopilotTunnelPreference(options.storagePath, options.metadata, false, options.now);
+    writeLine(options.stdout, highlight("info", "GitHub Copilot Tunnel disabled by startup preference."));
+    return;
+  }
+  if (preference === true) {
+    persistCopilotTunnelPreference(options.storagePath, options.metadata, true, options.now);
+    await options.releasePrompt();
+    const auth2 = await ensureRequirementAuthenticated(
+      "copilot",
+      options.getAsk,
+      options.commandRunner,
+      options.stdout,
+      options.stderr,
+      options.releasePrompt,
+      options.authPollIntervalMs,
+      options.authPollTimeoutMs
+    );
+    if (!auth2.authenticated) {
+      writeLine(options.stderr, highlight("error", "GitHub Copilot Tunnel requires GitHub authentication; skipping tunnel setup."));
+      return;
+    }
+    writeLine(options.stdout, highlight("accent", "Configuring GitHub Copilot Tunnel..."));
+    await runCopilotTunnel(options);
+    return;
+  }
+  const ask = options.getAsk();
+  if (!ask) {
+    writeLine(options.stdout, highlight("warning", `GitHub Copilot Tunnel is optional. Start in a TTY to enable the local proxy on port ${COPILOT_TUNNEL_PORT2}.`));
+    return;
+  }
+  writeLine(options.stdout);
+  writeLine(options.stdout, highlight("info", "Enable GitHub Copilot Tunnel?"));
+  writeLine(
+    options.stdout,
+    highlight("warning", "This will configure Claude Code and Codex to use the GitHub Copilot model provider, then start a local proxy on port 8314. You may be asked to sign in to GitHub with a device code.")
+  );
+  if (!await confirm(ask, "Enable GitHub Copilot Tunnel?")) {
+    persistCopilotTunnelPreference(options.storagePath, options.metadata, false, options.now);
+    return;
+  }
+  persistCopilotTunnelPreference(options.storagePath, options.metadata, true, options.now);
+  await options.releasePrompt();
+  const auth = await ensureRequirementAuthenticated(
+    "copilot",
+    options.getAsk,
+    options.commandRunner,
+    options.stdout,
+    options.stderr,
+    options.releasePrompt,
+    options.authPollIntervalMs,
+    options.authPollTimeoutMs
+  );
+  if (!auth.authenticated) {
+    writeLine(options.stderr, highlight("error", "GitHub Copilot Tunnel requires GitHub authentication; skipping tunnel setup."));
+    return;
+  }
+  writeLine(options.stdout, highlight("accent", "Configuring GitHub Copilot Tunnel..."));
+  await runCopilotTunnel(options);
+}
+var COPILOT_TUNNEL_KEY_INFO_PATTERN = /GitHub Copilot API Proxy|^\s*(Dashboard|OpenAI API|Responses API|Anthropic API)\b/i;
+var COPILOT_TUNNEL_API_INFO_PATTERN = /^\s*(OpenAI API|Responses API|Anthropic API)\b/i;
+function extractCopilotTunnelKeyInfo(output) {
+  return output.split(/\r?\n/).map((line) => line.replace(/\s+$/, "")).filter((line) => line.trim() !== "" && COPILOT_TUNNEL_KEY_INFO_PATTERN.test(line));
+}
+function hasCopilotTunnelApiInfo(lines) {
+  return lines.some((line) => COPILOT_TUNNEL_API_INFO_PATTERN.test(line));
+}
+async function runCopilotTunnel(options) {
+  let lastAuthCode;
+  let reportedKeyInfo = false;
+  let reportedWaitingForAuth = false;
+  let releaseStartupWait;
+  const startupWait = new Promise((resolve24) => {
+    releaseStartupWait = resolve24;
+  });
+  const reportTunnelKeyInfo = (tunnel) => {
+    if (reportedKeyInfo) return false;
+    const keyInfo = extractCopilotTunnelKeyInfo(`${tunnel.stdout}
+${tunnel.stderr}`);
+    const pidSuffix = tunnel.pid ? ` (pid ${tunnel.pid})` : "";
+    if (keyInfo.length > 0 && hasCopilotTunnelApiInfo(keyInfo)) {
+      reportedKeyInfo = true;
+      writeLine(options.stdout, `GitHub Copilot Tunnel is ready${pidSuffix}:`);
+      for (const line of keyInfo) writeLine(options.stdout, `  ${line.trim()}`);
+      return true;
+    }
+    return false;
+  };
+  const reportTunnelReady = (tunnel) => {
+    if (reportTunnelKeyInfo(tunnel)) return true;
+    if (!tunnel.available) return false;
+    reportedKeyInfo = true;
+    const pidSuffix = tunnel.pid ? ` (pid ${tunnel.pid})` : "";
+    writeLine(options.stdout, `GitHub Copilot Tunnel is available on port ${tunnel.port}${pidSuffix}.`);
+    return true;
+  };
+  const reportTunnelFailure = (tunnel) => {
+    if (tunnel.available || tunnel.status === "auth-required") return;
+    writeLine(options.stderr, tunnel.detail ?? "GitHub Copilot Tunnel failed to start.");
+  };
+  const surfaceDeviceLogin = (update, releaseOnAuth) => {
+    if (update.status === "auth-required" && update.auth && update.auth.code !== lastAuthCode) {
+      lastAuthCode = update.auth.code;
+      writeLine(options.stdout);
+      writeLine(options.stdout, "GitHub sign-in required to enable the Copilot tunnel.");
+      writeLine(options.stdout, `Open ${update.auth.url} and enter the device code below.`);
+      writeLine(options.stdout, `Device code: ${update.auth.code}`);
+      writeLine(options.stdout, "Waiting for you to finish signing in...");
+      if (releaseOnAuth && !reportedWaitingForAuth) {
+        reportedWaitingForAuth = true;
+        writeLine(options.stdout, "GitHub Copilot Tunnel is waiting for GitHub sign-in; Meshy startup will continue.");
+      }
+      if (releaseOnAuth) releaseStartupWait?.();
+      return;
+    }
+    if (reportTunnelKeyInfo(update)) {
+      releaseStartupWait?.();
+    }
+  };
+  const waitForSetup = async () => {
+    const setupPromise = runGithubCopilotTunnelSetup({
+      resolveOnReadyOutput: true,
+      spawnSetup: options.startupOptions.copilotTunnelSetupSpawn,
+      onProgress: (update) => surfaceDeviceLogin(update, false)
+    });
+    const firstSetupResult = await Promise.race([
+      setupPromise.then((setup) => ({ kind: "result", setup })),
+      startupWait.then(() => ({ kind: "started-proxy" }))
+    ]);
+    if (firstSetupResult.kind === "started-proxy") {
+      void setupPromise.then((setup) => {
+        if (!reportedKeyInfo && !setup.ok) reportTunnelFailure(setup);
+      }).catch((err) => {
+        if (!reportedKeyInfo) writeLine(options.stderr, `GitHub Copilot Tunnel setup failed: ${err instanceof Error ? err.message : String(err)}`);
+      });
+      return "started-proxy";
+    }
+    if (!firstSetupResult.setup.ok) {
+      writeLine(options.stderr, firstSetupResult.setup.detail ?? "GitHub Copilot Tunnel setup failed.");
+      return "failed";
+    }
+    return reportTunnelKeyInfo(firstSetupResult.setup) ? "started-proxy" : "completed";
+  };
+  try {
+    const setupStatus = await waitForSetup();
+    if (setupStatus !== "completed") {
+      return;
+    }
+    writeLine(options.stdout, "Waiting for ghc-tunnel to launch...");
+    const tunnelPromise = enableGithubCopilotTunnel({
+      captureOutputAfterReady: false,
+      portChecker: options.startupOptions.copilotTunnelPortChecker,
+      portCheckTimeoutMs: options.startupOptions.copilotTunnelPortCheckTimeoutMs,
+      pollIntervalMs: options.startupOptions.copilotTunnelPollIntervalMs,
+      spawnTunnel: options.startupOptions.copilotTunnelSpawn,
+      startupTimeoutMs: options.startupOptions.copilotTunnelStartupTimeoutMs,
+      onProgress: (update) => surfaceDeviceLogin(update, true)
+    });
+    const firstResult = await Promise.race([
+      tunnelPromise.then((tunnel) => ({ kind: "result", tunnel })),
+      startupWait.then(() => ({ kind: "progress" }))
+    ]);
+    if (firstResult.kind === "result") {
+      if (!reportTunnelReady(firstResult.tunnel)) reportTunnelFailure(firstResult.tunnel);
+      return;
+    }
+    void tunnelPromise.then((tunnel) => {
+      if (!reportTunnelReady(tunnel)) reportTunnelFailure(tunnel);
+    }).catch((err) => {
+      writeLine(options.stderr, `GitHub Copilot Tunnel failed to start: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  } catch (err) {
+    writeLine(options.stderr, `GitHub Copilot Tunnel failed to start: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 function shouldSkipStartupRequirementsCheck(storagePath, now = /* @__PURE__ */ new Date()) {
   const metadata = resolveStartupRequirementsMetadata(storagePath);
   if (metadata.lastCheckedOn !== formatLocalDate2(now)) {
@@ -180366,12 +180694,6 @@ async function ensureStartupRequirements(storagePath, options = {}) {
   const commandRunner = options.commandRunner ?? createDefaultCommandRunner(platform6);
   const authPollIntervalMs = options.authPollIntervalMs ?? 1e3;
   const authPollTimeoutMs = options.authPollTimeoutMs ?? 12e4;
-  if (shouldSkipStartupRequirementsCheck(storagePath, now) && areCachedAuthRequirementsCurrent(commandRunner)) {
-    return {
-      skipped: true,
-      metadata: resolveStartupRequirementsMetadata(storagePath)
-    };
-  }
   const promptSessionFactory = options.promptSessionFactory ?? createPromptSession;
   let promptSession;
   const getAsk = () => {
@@ -180384,6 +180706,26 @@ async function ensureStartupRequirements(storagePath, options = {}) {
     promptSession = void 0;
     await current.close();
   };
+  if (shouldSkipStartupRequirementsCheck(storagePath, now) && areCachedAuthRequirementsCurrent(commandRunner)) {
+    const metadata2 = resolveStartupRequirementsMetadata(storagePath);
+    await ensureOptionalCopilotTunnel({
+      storagePath,
+      metadata: metadata2,
+      now,
+      getAsk,
+      releasePrompt,
+      commandRunner,
+      stdout,
+      stderr,
+      startupOptions: options,
+      authPollIntervalMs,
+      authPollTimeoutMs
+    });
+    return {
+      skipped: true,
+      metadata: metadata2
+    };
+  }
   const checkedAt = now.toISOString();
   const checkedOn = formatLocalDate2(now);
   const components = {};
@@ -180406,7 +180748,7 @@ async function ensureStartupRequirements(storagePath, options = {}) {
         };
         continue;
       }
-      if (requirement === "az" || requirement === "devtunnel") {
+      if (requirement === "az" || requirement === "devtunnel" || requirement === "copilot") {
         const authResult = await ensureRequirementAuthenticated(
           requirement,
           getAsk,
@@ -180442,6 +180784,19 @@ async function ensureStartupRequirements(storagePath, options = {}) {
   };
   metadataFile.startupRequirements = metadata;
   writeStartupMetadataFile(storagePath, metadataFile);
+  await ensureOptionalCopilotTunnel({
+    storagePath,
+    metadata,
+    now,
+    getAsk,
+    releasePrompt,
+    commandRunner,
+    stdout,
+    stderr,
+    startupOptions: options,
+    authPollIntervalMs,
+    authPollTimeoutMs
+  });
   return {
     skipped: false,
     metadata
@@ -181525,6 +181880,8 @@ function formatStartArgs(args) {
   if (args.config) result.push("--config", args.config);
   if (args.disableAuth) result.push("--disable-auth");
   if (args.qrCode) result.push("--qr-code");
+  if (args.ghcTunnel === true) result.push("--enable-ghc-tunnel");
+  if (args.ghcTunnel === false) result.push("--disable-ghc-tunnel");
   return result;
 }
 function detectRuntimeRestartMode(env4 = process.env, entryPath = process.argv[1]) {
@@ -190450,7 +190807,7 @@ function createNodeTelemetry(config2, logger33, baseDimensions) {
       createAzureTelemetryService({ connectionString: config2.connectionString, baseDimensions }),
       { logger: telemetryLogger }
     );
-    telemetryLogger.info("Telemetry initialized [succeeded]");
+    telemetryLogger.info("Telemetry initialized [succeeded]. Meshy collects sanitized operational telemetry such as runtime details, feature usage, task lifecycle events, and API route metrics. Prompts, transcripts, request bodies, bearer tokens, raw paths, and raw stack traces are not collected.");
     return telemetry;
   } catch {
     telemetryLogger.warn("Telemetry initialized [failed]");
@@ -190578,7 +190935,9 @@ async function startNode(args) {
     });
     telemetry.trackEvent("startup.started");
     terminalWriter.line("Checking startup requirements (az, devtunnel, claude, codex, copilot)...");
-    const startupRequirements = await ensureNpxStartupTools(config2.storage.path);
+    const startupRequirements = await ensureNpxStartupTools(config2.storage.path, {
+      copilotTunnelEnabled: hydratedArgs.args.ghcTunnel
+    });
     telemetry.trackEvent("startup.preflight.completed", startupRequirementDimensions(startupRequirements));
     terminalWriter.line(
       startupRequirements.skipped ? "Startup requirements already verified today; skipping checks." : "Startup requirements check complete."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meshy-node",
-  "version": "0.10.3",
+  "version": "0.10.5",
   "private": false,
   "description": "Standalone Meshy node package with bundled runtime and dashboard assets.",
   "type": "commonjs",

package/runtime-metadata.json

@@ -1,14 +1,14 @@
 {
   "packageName": "meshy-node",
-  "packageVersion": "0.10.3",
+  "packageVersion": "0.10.5",
   "packages": {
     "workspace": {
       "name": "meshy",
-      "version": "0.10.3"
+      "version": "0.10.5"
     },
     "node": {
       "name": "meshy-node",
-      "version": "0.10.3"
+      "version": "0.10.5"
     },
     "core": {
       "name": "@meshy/core",
@@ -26,6 +26,6 @@
   "repository": {
     "url": "https://github.com/gim-home/meshy",
     "branch": "main",
-    "commit": "58bcf4c"
+    "commit": "2b58f22"
   }
 }