snow-flow 10.0.200 → 10.0.201

package/package.json

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

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(),