snow-flow 10.0.200 → 10.0.202

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.200",
+  "version": "10.0.202",
   "name": "snow-flow",
   "description": "Snow-Flow - ServiceNow Multi-Agent Development Framework powered by AI",
   "license": "Elastic-2.0",

package/src/servicenow/servicenow-mcp-unified/shared/auth.ts

@@ -123,7 +123,12 @@ export class ServiceNowAuthManager {
     const accessToken = await this.getAccessToken(context)
 
     if (!accessToken) {
-      throw new Error("Failed to obtain access token. Please verify ServiceNow credentials and run: snow-flow auth login")
+      throw new Error(
+        "Failed to obtain access token. This can happen when:\n" +
+        "• Your ServiceNow instance is hibernating — open it in a browser to wake it up\n" +
+        "• Your credentials have expired — run: snow-flow auth login\n" +
+        "• Your OAuth client ID/secret are incorrect"
+      )
     }
 
     // Determine correct Authorization header format
@@ -171,6 +176,19 @@ export class ServiceNowAuthManager {
         return response
       },
       async (error) => {
+        const status = error.response?.status
+
+        // Detect hibernating instance (502/503 from proxy or ServiceNow itself)
+        if (status === 502 || status === 503) {
+          const err = new Error(
+            `ServiceNow instance is hibernating or starting up (HTTP ${status}). ` +
+            `Open ${context.instanceUrl} in your browser to wake it up, then wait 1-2 minutes and try again.`
+          )
+          ;(err as any).response = error.response
+          ;(err as any).isHibernating = true
+          throw err
+        }
+
         // Check if the error response has ServiceNow error structure
         if (error.response?.data?.error) {
           const snowError = error.response.data.error

package/src/servicenow/servicenow-mcp-unified/tools/connectors/snow_check_health.ts

@@ -39,6 +39,37 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
       status: responseTime < 1000 ? "good" : responseTime < 3000 ? "fair" : "slow",
     })
   } catch (error: any) {
+    const msg = error.message || ""
+    const status = error.response?.status
+
+    // Detect hibernating instance
+    if (
+      status === 502 || status === 503
+      || msg.includes("ECONNREFUSED")
+      || msg.includes("ETIMEDOUT")
+      || msg.includes("socket hang up")
+      || (msg.includes("Failed to obtain access token") && !msg.includes("Invalid credentials"))
+    ) {
+      return createErrorResult(
+        `ServiceNow instance appears to be hibernating or starting up.\n\n` +
+        `Developer instances automatically hibernate after periods of inactivity. ` +
+        `To wake it up:\n` +
+        `1. Open your instance URL in a browser: ${context.instanceUrl}\n` +
+        `2. Wait 1-2 minutes for it to fully start\n` +
+        `3. Try this command again\n\n` +
+        `Technical detail: ${status ? `HTTP ${status}` : msg}`
+      )
+    }
+
+    // Detect auth issues separately
+    if (msg.includes("Failed to obtain access token") || status === 401) {
+      return createErrorResult(
+        `Authentication failed. Your access token may be expired.\n\n` +
+        `Run: snow-flow auth login\n\n` +
+        `If you've already logged in, check: snow-flow auth status`
+      )
+    }
+
     return createErrorResult(error.message)
   }
 }

package/src/tool/registry.ts

@@ -28,6 +28,7 @@ import { Truncate } from "./truncation"
 import { PlanExitTool, PlanEnterTool } from "./plan"
 import { ReviewEnterTool, ReviewExitTool } from "./review"
 import { ApplyPatchTool } from "./apply_patch"
+import { Auth } from "@/auth"
 
 export namespace ToolRegistry {
   const log = Log.create({ service: "tool.registry" })
@@ -99,6 +100,9 @@ export namespace ToolRegistry {
     const custom = await state().then((x) => x.custom)
     const config = await Config.get()
 
+    // Check if the user has the code-review feature (enterprise subscription)
+    const hasCodeReview = await hasFeature("code-review")
+
     return [
       InvalidTool,
       ...(["app", "cli", "desktop"].includes(Flag.OPENCODE_CLIENT) ? [QuestionTool] : []),
@@ -118,11 +122,23 @@ export namespace ToolRegistry {
       ApplyPatchTool,
       ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
       ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
-      ...(Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool, ReviewEnterTool, ReviewExitTool] : []),
+      ...(Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool] : []),
+      ...(Flag.OPENCODE_CLIENT === "cli" && hasCodeReview ? [ReviewEnterTool, ReviewExitTool] : []),
       ...custom,
     ]
   }
 
+  /** Check if the user has a specific feature in their enterprise subscription */
+  async function hasFeature(feature: string): Promise<boolean> {
+    try {
+      const auths = await Auth.all()
+      for (const auth of Object.values(auths)) {
+        if (auth.type === "enterprise" && auth.features?.includes(feature)) return true
+      }
+    } catch {}
+    return false
+  }
+
   export async function ids() {
     return all().then((x) => x.map((t) => t.id))
   }

package/src/usage/anonymous-telemetry.ts

@@ -28,6 +28,19 @@ function getMachineId(): string | undefined {
   }
 }
 
+function detectInstallMethod(): string {
+  // Check npm
+  if (process.env.npm_config_user_agent) return "npm"
+  // Check bun
+  if (typeof globalThis.Bun !== "undefined") return "bun"
+  // Check homebrew
+  const execPath = process.execPath || ""
+  if (execPath.includes("Cellar") || execPath.includes("homebrew") || execPath.includes("linuxbrew")) return "brew"
+  // Check standalone binary (no node_modules in path suggests binary distribution)
+  if (!execPath.includes("node_modules") && !execPath.includes("node") && !execPath.includes("bun")) return "binary"
+  return "other"
+}
+
 async function sendPing(payload: Record<string, unknown>): Promise<void> {
   try {
     const response = await fetch(`${PORTAL_URL}/api/telemetry/ping`, {
@@ -63,9 +76,11 @@ export namespace AnonymousTelemetry {
       }
 
       let messageCount = 0
+      let exitReason: "normal" | "error" | "interrupt" = "normal"
       let configDisabled = false
       const startTime = Date.now()
       const sessionId = crypto.randomUUID()
+      const installMethod = detectInstallMethod()
 
       const unsubs = [
         Bus.subscribe(MessageV2.Event.Updated, (event) => {
@@ -73,6 +88,18 @@ export namespace AnonymousTelemetry {
         }),
       ]
 
+      // Track exit reason via process signals
+      const onError = () => {
+        exitReason = "error"
+      }
+      const onInterrupt = () => {
+        exitReason = "interrupt"
+      }
+      process.on("uncaughtException", onError)
+      process.on("unhandledRejection", onError)
+      process.on("SIGINT", onInterrupt)
+      process.on("SIGTERM", onInterrupt)
+
       const basePayload = {
         machineId,
         sessionId,
@@ -80,6 +107,7 @@ export namespace AnonymousTelemetry {
         channel: Installation.CHANNEL,
         os: process.platform,
         arch: process.arch,
+        installMethod,
       }
 
       log.info("anonymous telemetry initializing", { machineId: machineId.slice(0, 8) + "..." })
@@ -111,20 +139,32 @@ export namespace AnonymousTelemetry {
         get messageCount() {
           return messageCount
         },
+        get exitReason() {
+          return exitReason
+        },
         get configDisabled() {
           return configDisabled
         },
+        cleanup() {
+          process.removeListener("uncaughtException", onError)
+          process.removeListener("unhandledRejection", onError)
+          process.removeListener("SIGINT", onInterrupt)
+          process.removeListener("SIGTERM", onInterrupt)
+        },
       }
     },
     async (current) => {
       for (const unsub of current.unsubs) unsub()
       if (current.disabled || current.configDisabled) return
 
+      if ("cleanup" in current) current.cleanup()
+
       const sessionDurationSec = Math.round((Date.now() - current.startTime) / 1000)
 
       await sendPing({
         ...current.basePayload,
         type: "end",
+        exitReason: current.exitReason,
         sessionDurationSec,
         messageCount: current.messageCount,
         timestamp: Date.now(),