snow-flow 10.0.67 → 10.0.68

package/package.json

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

package/src/cli/cmd/tui/app.tsx

@@ -38,6 +38,7 @@ import { ArgsProvider, useArgs, type Args } from "./context/args"
 import open from "open"
 import { writeHeapSnapshot } from "v8"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
+import { Config } from "@/config/config"
 
 async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
   // can't set raw mode if not a TTY
@@ -634,6 +635,26 @@ function App() {
         dialog.clear()
       },
     },
+    {
+      title: kv.get("telemetry_enabled", true) ? "Disable anonymous telemetry" : "Enable anonymous telemetry",
+      value: "app.toggle.telemetry",
+      category: "System",
+      slash: {
+        name: "telemetry",
+      },
+      onSelect: async (dialog) => {
+        const enabled = kv.get("telemetry_enabled", true)
+        kv.set("telemetry_enabled", !enabled)
+        await Config.updateGlobal({ telemetry: !enabled }).catch(() => {})
+        toast.show({
+          message: enabled
+            ? "Telemetry disabled. Takes effect next session."
+            : "Telemetry enabled. Thank you!",
+          variant: "info",
+        })
+        dialog.clear()
+      },
+    },
   ])
 
   createEffect(() => {

package/src/config/config.ts

@@ -1301,6 +1301,10 @@ export namespace Config {
           url: z.string().optional().describe("Enterprise URL"),
         })
         .optional(),
+      telemetry: z
+        .boolean()
+        .optional()
+        .describe("Enable anonymous usage telemetry (default: true). Set to false to disable."),
       compaction: z
         .object({
           auto: z.boolean().optional().describe("Enable automatic compaction when context is full (default: true)"),

package/src/flag/flag.ts

@@ -27,6 +27,7 @@ export namespace Flag {
   export const OPENCODE_DISABLE_DEFAULT_PLUGINS = truthyBoth("DISABLE_DEFAULT_PLUGINS")
   export const OPENCODE_DISABLE_LSP_DOWNLOAD = truthyBoth("DISABLE_LSP_DOWNLOAD")
   export const OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthyBoth("ENABLE_EXPERIMENTAL_MODELS")
+  export const OPENCODE_TELEMETRY_DISABLED = truthyBoth("TELEMETRY_DISABLED")
   export const OPENCODE_DISABLE_AUTOCOMPACT = truthyBoth("DISABLE_AUTOCOMPACT")
   export const OPENCODE_DISABLE_MODELS_FETCH = truthyBoth("DISABLE_MODELS_FETCH")
   export const OPENCODE_DISABLE_CLAUDE_CODE = truthyBoth("DISABLE_CLAUDE_CODE")

package/src/session/prompt.ts

@@ -45,7 +45,7 @@ import { LLM } from "./llm"
 import { iife } from "@/util/iife"
 import { Shell } from "@/shell/shell"
 import { Truncate } from "@/tool/truncation"
-import { UsageReporter, ActivityReporter } from "@/usage"
+import { UsageReporter, ActivityReporter, AnonymousTelemetry } from "@/usage"
 
 // @ts-ignore
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -156,6 +156,7 @@ export namespace SessionPrompt {
     // Initialize TUI usage reporting (lazy, no-op if no enterprise auth)
     UsageReporter.init()
     ActivityReporter.init()
+    AnonymousTelemetry.init()
 
     const message = await createUserMessage(input)
     await Session.touch(input.sessionID)

package/src/usage/anonymous-telemetry.ts

@@ -0,0 +1,118 @@
+import { Instance } from "@/project/instance"
+import { Bus } from "@/bus"
+import { MessageV2 } from "@/session/message-v2"
+import { Log } from "@/util/log"
+import { Installation } from "@/installation"
+import { Flag } from "@/flag/flag"
+import { Config } from "@/config/config"
+import { machineIdSync } from "node-machine-id"
+
+const log = Log.create({ service: "usage.anonymous-telemetry" })
+
+const PORTAL_URL = process.env.SNOW_FLOW_PORTAL_URL || "https://portal.snow-flow.dev"
+
+function isDisabled(): boolean {
+  // 1. Standard DO_NOT_TRACK convention (consoledonottrack.com)
+  const dnt = process.env.DO_NOT_TRACK?.toLowerCase()
+  if (dnt === "1" || dnt === "true") return true
+
+  // 2. Snow-Flow specific env vars
+  if (Flag.OPENCODE_TELEMETRY_DISABLED) return true
+
+  // 3. CI environments
+  const ci = process.env.CI?.toLowerCase()
+  if (ci === "true" || ci === "1") return true
+
+  return false
+}
+
+function getMachineId(): string | undefined {
+  try {
+    return machineIdSync()
+  } catch {
+    return undefined
+  }
+}
+
+export namespace AnonymousTelemetry {
+  const state = Instance.state(
+    () => {
+      // Check env-based opt-out first (sync, before any subscriptions)
+      if (isDisabled()) {
+        log.info("anonymous telemetry disabled (env)")
+        return { disabled: true as const, unsubs: [] as (() => void)[], startTime: 0, messageCount: 0 }
+      }
+
+      const machineId = getMachineId()
+      if (!machineId) {
+        log.info("anonymous telemetry disabled (no machine id)")
+        return { disabled: true as const, unsubs: [] as (() => void)[], startTime: 0, messageCount: 0 }
+      }
+
+      let messageCount = 0
+      const startTime = Date.now()
+
+      const unsubs = [
+        Bus.subscribe(MessageV2.Event.Updated, (event) => {
+          if (event.properties.info.role === "user") {
+            messageCount++
+          }
+        }),
+      ]
+
+      // Check config-based opt-out (async)
+      Config.get().then((config) => {
+        if (config.telemetry === false) {
+          log.info("anonymous telemetry disabled (config)")
+          for (const unsub of unsubs) unsub()
+          unsubs.length = 0
+        } else {
+          log.info("anonymous telemetry active")
+        }
+      }).catch(() => {
+        // Config not available yet — keep telemetry active
+        log.info("anonymous telemetry active (config unavailable)")
+      })
+
+      return { disabled: false as const, unsubs, startTime, machineId, get messageCount() { return messageCount } }
+    },
+    async (current) => {
+      for (const unsub of current.unsubs) unsub()
+
+      if (current.disabled) return
+
+      const sessionDurationSec = Math.round((Date.now() - current.startTime) / 1000)
+
+      // Check config opt-out before sending
+      const config = await Config.get().catch(() => undefined)
+      if (config?.telemetry === false) return
+
+      const payload = {
+        machineId: current.machineId,
+        version: Installation.VERSION,
+        channel: Installation.CHANNEL,
+        os: process.platform,
+        arch: process.arch,
+        sessionDurationSec,
+        messageCount: current.messageCount,
+        timestamp: Date.now(),
+      }
+
+      try {
+        await fetch(`${PORTAL_URL}/api/telemetry/ping`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+          signal: AbortSignal.timeout(5_000),
+        })
+      } catch {
+        // Fire-and-forget: network errors expected when offline
+      }
+    },
+  )
+
+  /** Initialize the anonymous telemetry reporter. Call once per Instance lifecycle. */
+  export function init() {
+    state()
+  }
+}

package/src/usage/index.ts

@@ -1,2 +1,3 @@
 export { UsageReporter } from "./reporter"
 export { ActivityReporter } from "./activity-reporter"
+export { AnonymousTelemetry } from "./anonymous-telemetry"