idlewatch 0.1.4 → 0.1.6

package/README.md

@@ -17,7 +17,7 @@ npx idlewatch quickstart
 npx idlewatch --dry-run
 ```
 
-`quickstart` is the happy path: create an API key on idlewatch.com/api, run the wizard, pick a device name + metrics, and IdleWatch saves local config before sending a first sample. By default, quickstart will try to install Rust/Cargo automatically if needed so it can launch the ratatui onboarding flow. Use `idlewatch quickstart --no-tui` to skip the TUI and stay on the plain text setup path without installing Cargo.
+`quickstart` is the happy path: create an API key on idlewatch.com/api, run the wizard, pick a device name + metrics, and IdleWatch saves local config before sending a first sample. It prefers a bundled TUI binary when available, otherwise falls back to a local Cargo build only on developer machines that already have Cargo installed. Use `idlewatch quickstart --no-tui` to skip the TUI and stay on the plain text setup path.
 
 ## CLI options
 
@@ -57,6 +57,8 @@ Use `gpuSource` + `gpuConfidence` in dashboards to decide whether to trust value
 npx idlewatch quickstart
 ```
 
+`idlewatch` is the primary package/command name. `idlewatch-skill` still works as a compatibility alias, but treat it as legacy in user-facing docs.
+
 The wizard keeps setup small:
 - asks for a **device name**
 - asks for your **API key** from `idlewatch.com/api`

package/bin/idlewatch-agent.js

@@ -374,6 +374,10 @@ if (quickstartRequested) {
   try {
     const result = await runEnrollmentWizard({ noTui: args.has('--no-tui') })
 
+    if (!result?.outputEnvFile || !fs.existsSync(result.outputEnvFile)) {
+      throw new Error(`setup_did_not_write_env_file:${result?.outputEnvFile || 'unknown'}`)
+    }
+
     const enrolledEnv = parseEnvFileToObject(result.outputEnvFile)
     const onceRun = spawnSync(process.execPath, [process.argv[1], '--once'], {
       stdio: 'inherit',
@@ -395,7 +399,13 @@ if (quickstartRequested) {
     console.error('Or rerun: idlewatch quickstart')
     process.exit(onceRun.status ?? 1)
   } catch (err) {
-    console.error(`Enrollment failed: ${err.message}`)
+    if (String(err?.message || '') === 'setup_cancelled') {
+      console.error('Enrollment cancelled before saving config.')
+    } else if (String(err?.message || '').startsWith('setup_did_not_write_env_file:')) {
+      console.error(`Enrollment failed: setup did not save idlewatch.env (${String(err.message).split(':').slice(1).join(':')}).`)
+    } else {
+      console.error(`Enrollment failed: ${err.message}`)
+    }
     process.exit(1)
   }
 }
@@ -624,9 +634,13 @@ if (firebaseConfigError) {
   process.exit(1)
 }
 
-if (!appReady && !(CLOUD_INGEST_URL && CLOUD_API_KEY)) {
+const hasAnyFirebaseConfig = Boolean(PROJECT_ID || CREDS_FILE || CREDS_JSON || CREDS_B64 || FIRESTORE_EMULATOR_HOST)
+const hasCloudConfig = Boolean(CLOUD_INGEST_URL && CLOUD_API_KEY)
+const shouldWarnAboutMissingPublishConfig = !appReady && !hasCloudConfig && !DRY_RUN && !hasAnyFirebaseConfig
+
+if (shouldWarnAboutMissingPublishConfig) {
   console.error(
-    'Firebase is not configured. Running without Firebase writes. Set FIREBASE_PROJECT_ID + FIREBASE_SERVICE_ACCOUNT_FILE (preferred, or FIREBASE_SERVICE_ACCOUNT_JSON / FIREBASE_SERVICE_ACCOUNT_B64), use FIREBASE_PROJECT_ID + FIRESTORE_EMULATOR_HOST for emulator writes, or run idlewatch quickstart to link cloud ingest.'
+    'No publish target is configured yet. Running in local-only mode. Run idlewatch quickstart to link cloud ingest, or configure Firebase/emulator mode if you need that path.'
   )
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idlewatch",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Host telemetry collector for IdleWatch",
   "type": "module",
   "files": [
@@ -9,6 +9,7 @@
     "scripts",
     "skill",
     "tui/src",
+    "tui/bin",
     "tui/Cargo.toml",
     "tui/Cargo.lock",
     "README.md",

package/src/enrollment.js

@@ -10,6 +10,24 @@ function defaultConfigDir() {
   return path.join(os.homedir(), '.idlewatch')
 }
 
+function machineName() {
+  if (process.platform === 'darwin') {
+    const macName = spawnSync('scutil', ['--get', 'ComputerName'], { encoding: 'utf8' })
+    if (macName.status === 0) {
+      const value = String(macName.stdout || '').trim()
+      if (value) return value
+    }
+  }
+
+  const hostName = String(os.hostname() || '').trim()
+  if (hostName) return hostName
+
+  const envHost = String(process.env.HOSTNAME || '').trim()
+  if (envHost) return envHost
+
+  return 'IdleWatch Device'
+}
+
 function ensureDir(dirPath) {
   fs.mkdirSync(dirPath, { recursive: true })
 }
@@ -80,12 +98,12 @@ function looksLikeCloudApiKey(value) {
   return /^iwk_[A-Za-z0-9_-]{20,}$/.test(String(value || '').trim())
 }
 
-function normalizeDeviceName(raw, fallback = os.hostname()) {
+function normalizeDeviceName(raw, fallback = machineName()) {
   const value = String(raw || '').trim().replace(/\s+/g, ' ')
   return value || fallback
 }
 
-function sanitizeDeviceId(raw, fallback = os.hostname()) {
+function sanitizeDeviceId(raw, fallback = machineName()) {
   const base = normalizeDeviceName(raw, fallback).toLowerCase()
   const sanitized = base
     .replace(/[^a-z0-9._-]+/g, '-')
@@ -99,43 +117,47 @@ function cargoAvailable() {
   return cargoProbe.status === 0
 }
 
-function installRustToolchain() {
-  if (cargoAvailable()) return { ok: true, installed: false }
-  if (process.env.IDLEWATCH_DISABLE_RUST_INSTALL === '1') return { ok: false, reason: 'install-disabled' }
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return { ok: false, reason: 'non-tty' }
-  if (!['darwin', 'linux'].includes(process.platform)) return { ok: false, reason: `unsupported-platform:${process.platform}` }
+function bundledTuiBinaryPath() {
+  const platform = process.platform
+  const arch = process.arch
+  const ext = platform === 'win32' ? '.exe' : ''
+  return path.join(PACKAGE_ROOT, 'tui', 'bin', `${platform}-${arch}`, `idlewatch-setup${ext}`)
+}
+
+function tryBundledRustTui({ configDir, outputEnvFile }) {
+  const binPath = bundledTuiBinaryPath()
+  if (!fs.existsSync(binPath)) return { ok: false, reason: 'bundled-binary-missing', binPath }
+
+  try {
+    fs.chmodSync(binPath, 0o755)
+  } catch {
+    // best effort
+  }
 
-  console.log('IdleWatch TUI needs Rust/Cargo. Installing rustup + Cargo now...')
-  const install = spawnSync('sh', ['-c', 'curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y'], {
+  const run = spawnSync(binPath, [], {
     stdio: 'inherit',
     env: {
       ...process.env,
-      CARGO_HOME: process.env.CARGO_HOME || path.join(os.homedir(), '.cargo'),
-      RUSTUP_HOME: process.env.RUSTUP_HOME || path.join(os.homedir(), '.rustup')
+      IDLEWATCH_ENROLL_CONFIG_DIR: configDir,
+      IDLEWATCH_ENROLL_OUTPUT_ENV_FILE: outputEnvFile
     }
   })
 
-  if (install.status !== 0) return { ok: false, reason: `rustup-install-failed:${install.status ?? 'unknown'}` }
-
-  const cargoBinDir = path.join(process.env.CARGO_HOME || path.join(os.homedir(), '.cargo'), 'bin')
-  if (!process.env.PATH?.split(path.delimiter).includes(cargoBinDir)) {
-    process.env.PATH = `${cargoBinDir}${path.delimiter}${process.env.PATH || ''}`
-  }
-
-  return cargoAvailable() ? { ok: true, installed: true } : { ok: false, reason: 'cargo-still-missing' }
+  if (run.status === 0) return { ok: true, binPath }
+  return { ok: false, reason: `bundled-binary-failed:${run.status ?? 'unknown'}`, binPath }
 }
 
-function tryRustTui({ configDir, outputEnvFile, autoInstallRust = true }) {
+function tryRustTui({ configDir, outputEnvFile }) {
   const disabled = process.env.IDLEWATCH_DISABLE_RUST_TUI === '1'
   if (disabled) return { ok: false, reason: 'disabled' }
 
+  const bundled = tryBundledRustTui({ configDir, outputEnvFile })
+  if (bundled.ok) return bundled
+
   if (!cargoAvailable()) {
-    if (autoInstallRust) {
-      const installResult = installRustToolchain()
-      if (!installResult.ok) return { ok: false, reason: installResult.reason || 'cargo-missing' }
-    } else {
-      return { ok: false, reason: 'cargo-missing' }
-    }
+    return bundled.reason === 'bundled-binary-missing'
+      ? { ok: false, reason: 'bundled-binary-missing-and-cargo-missing', binPath: bundled.binPath }
+      : { ok: false, reason: 'cargo-missing' }
   }
 
   const manifestPath = path.join(PACKAGE_ROOT, 'tui', 'Cargo.toml')
@@ -170,7 +192,7 @@ export async function runEnrollmentWizard(options = {}) {
   let mode = options.mode || process.env.IDLEWATCH_ENROLL_MODE || null
   let cloudApiKey = normalizeCloudApiKey(options.cloudApiKey || process.env.IDLEWATCH_CLOUD_API_KEY || null)
   let cloudIngestUrl = options.cloudIngestUrl || process.env.IDLEWATCH_CLOUD_INGEST_URL || 'https://api.idlewatch.com/api/ingest'
-  let deviceName = normalizeDeviceName(options.deviceName || process.env.IDLEWATCH_DEVICE_NAME || os.hostname())
+  let deviceName = normalizeDeviceName(options.deviceName || process.env.IDLEWATCH_DEVICE_NAME || machineName())
 
   const availableMonitorTargets = detectAvailableMonitorTargets()
   let monitorTargets = normalizeMonitorTargets(
@@ -179,7 +201,7 @@ export async function runEnrollmentWizard(options = {}) {
   )
 
   if (!nonInteractive && !noTui) {
-    const tuiResult = tryRustTui({ configDir, outputEnvFile, autoInstallRust: true })
+    const tuiResult = tryRustTui({ configDir, outputEnvFile })
     if (tuiResult.ok) {
       return {
         mode: 'tui',
@@ -188,7 +210,9 @@ export async function runEnrollmentWizard(options = {}) {
       }
     }
 
-    if (!['disabled', 'cargo-missing'].includes(tuiResult.reason || '')) {
+    if (tuiResult.reason === 'bundled-binary-missing-and-cargo-missing') {
+      console.warn('IdleWatch TUI is not bundled for this platform and Cargo is not installed. Falling back to text setup. Use --no-tui to skip this check.')
+    } else if (!['disabled', 'cargo-missing', 'bundled-binary-missing'].includes(tuiResult.reason || '')) {
       console.warn(`IdleWatch TUI unavailable (${tuiResult.reason || 'unknown'}). Falling back to text setup.`)
     }
   }
@@ -223,7 +247,7 @@ export async function runEnrollmentWizard(options = {}) {
     monitorTargets = normalizeMonitorTargets(monitorInput || suggested, availableMonitorTargets)
   }
 
-  const safeDeviceId = sanitizeDeviceId(options.deviceId || process.env.IDLEWATCH_DEVICE_ID || deviceName, os.hostname())
+  const safeDeviceId = sanitizeDeviceId(options.deviceId || process.env.IDLEWATCH_DEVICE_ID || deviceName, machineName())
   const localLogPath = path.join(configDir, 'logs', `${safeDeviceId}-metrics.ndjson`)
   const localCachePath = path.join(configDir, 'cache', `${safeDeviceId}-openclaw-last-good.json`)
 

package/tui/src/main.rs

@@ -70,6 +70,34 @@ fn command_exists(cmd: &str, args: &[&str]) -> bool {
         .unwrap_or(false)
 }
 
+fn machine_name() -> String {
+    if cfg!(target_os = "macos") {
+        if let Ok(output) = Command::new("scutil").args(["--get", "ComputerName"]).output() {
+            if output.status.success() {
+                let name = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                if !name.is_empty() {
+                    return name;
+                }
+            }
+        }
+    }
+
+    if let Ok(output) = Command::new("hostname").output() {
+        if output.status.success() {
+            let name = String::from_utf8_lossy(&output.stdout).trim().to_string();
+            if !name.is_empty() {
+                return name;
+            }
+        }
+    }
+
+    std::env::var("HOSTNAME")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .unwrap_or_else(|| "IdleWatch Device".to_string())
+}
+
 fn parse_env_file(path: &Path) -> ExistingConfig {
     let mut config = ExistingConfig::default();
     let Ok(raw) = fs::read_to_string(path) else {
@@ -443,7 +471,7 @@ fn main() -> Result<()> {
     let env_file = std::env::var("IDLEWATCH_ENROLL_OUTPUT_ENV_FILE")
         .map(PathBuf::from)
         .unwrap_or_else(|_| config_dir.join("idlewatch.env"));
-    let host = sanitize_host(&std::env::var("HOSTNAME").unwrap_or_else(|_| "host".to_string()));
+    let host = sanitize_host(&machine_name());
     let existing = parse_env_file(&env_file);
 
     enable_raw_mode()?;
@@ -464,7 +492,7 @@ fn main() -> Result<()> {
                     KeyCode::Char('q') | KeyCode::Esc => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                        return Ok(());
+                        return Err(anyhow!("setup_cancelled"));
                     }
                     _ => {}
                 }
@@ -503,7 +531,7 @@ fn main() -> Result<()> {
                     KeyCode::Char('q') | KeyCode::Esc => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                        return Ok(());
+                        return Err(anyhow!("setup_cancelled"));
                     }
                     _ => {}
                 }
@@ -545,7 +573,7 @@ fn main() -> Result<()> {
                     KeyCode::Char('q') | KeyCode::Esc => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                        return Ok(());
+                        return Err(anyhow!("setup_cancelled"));
                     }
                     KeyCode::Char(c) => {
                         device_name_input.push(c);
@@ -592,7 +620,7 @@ fn main() -> Result<()> {
                         KeyCode::Char('q') | KeyCode::Esc => {
                             disable_raw_mode()?;
                             execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                            return Ok(());
+                            return Err(anyhow!("setup_cancelled"));
                         }
                         KeyCode::Char(c) => {
                             cloud_api_key_input.push(c);