onbuzz 4.6.4 → 4.7.1

package/bin/cli.js

@@ -17,10 +17,18 @@ import { dirname, join } from 'path';
 import { spawn } from 'child_process';
 import { readFileSync } from 'fs';
 import http from 'http';
+import { runUpdateCheck } from '../src/utilities/updateNotifier.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Fire the update-notifier check as soon as the process starts. The
+// helper is non-blocking (it schedules a background fetch and reads
+// from a tiny on-disk cache for the next run) and silently skips
+// every failure mode — missing dep, no network, kill-switch env,
+// not-globally-installed. Worst case: the banner just doesn't appear.
+runUpdateCheck().catch(() => { /* never propagate */ });
+
 // Default configuration
 const DEFAULT_PORT = 8080;
 // Use 127.0.0.1 instead of 'localhost' to avoid IPv6 issues in WSL2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "4.6.4",
+  "version": "4.7.1",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/scripts/debug-balance-probe.mjs

@@ -0,0 +1,35 @@
+// Standalone replica of accountRoutes.proxyToBackend, to figure out
+// why the in-process call fails while my curl/node-fetch from the
+// same machine succeed. Run with: node scripts/debug-balance-probe.mjs
+import { readFileSync } from 'fs';
+
+const cfg = JSON.parse(readFileSync('config/default.json', 'utf8'));
+const baseUrl = (cfg.backend?.baseUrl || 'https://autopilot-api.azurewebsites.net').replace(/\/$/, '');
+
+// Pull JWT from the running server (same path /api/auth/status uses).
+const jwt = await (await fetch('http://localhost:8080/api/auth/status')).json().then(d => d.jwt);
+console.log('Using JWT len:', jwt?.length, 'against baseUrl:', baseUrl);
+console.log();
+
+async function proxyLike(path) {
+  const url = `${baseUrl}${path}`;
+  const t0 = Date.now();
+  try {
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${jwt}`,
+        'Content-Type': 'application/json',
+      },
+    });
+    const text = await res.text();
+    let parsed; try { parsed = JSON.parse(text); } catch { parsed = { raw: text.slice(0, 200) }; }
+    console.log(`${path}: status=${res.status} ms=${Date.now() - t0} body=${JSON.stringify(parsed).slice(0, 200)}`);
+  } catch (err) {
+    console.log(`${path}: ERR ${err.message}`);
+  }
+}
+
+for (const p of ['/subscription/status', '/account/profile', '/auth/me', '/auth/apikeys']) {
+  await proxyLike(p);
+}

package/src/__tests__/autoUpdateConfig.test.js

@@ -0,0 +1,80 @@
+/**
+ * Tripwire: the auto-update feature requires three things in
+ * package.json that are easy to lose in a dep refresh:
+ *
+ *   1. `update-notifier` in `dependencies` — drives the npm-CLI
+ *      banner. Missing → dynamic import in updateNotifier.js
+ *      silently no-ops (good fail-safe, but the banner disappears
+ *      without any louder signal).
+ *   2. `electron-updater` in `optionalDependencies` — drives the
+ *      Electron in-app update dialog. Missing → autoUpdate.js
+ *      silently no-ops.
+ *   3. `build.publish` config — pointed at the GitHub Releases the
+ *      Electron updater reads `latest.yml` from. Missing → the
+ *      packaged Electron app never sees updates even when
+ *      `electron-updater` is installed.
+ *
+ * Each is a silent failure on its own. Together they make the
+ * feature look "shipped" but actually inert. This test forces a
+ * loud CI signal when any of the three goes missing.
+ *
+ * If you INTENTIONALLY remove auto-update, change this test in the
+ * same commit and explain why in the diff. Don't just delete it.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, '..', '..');
+const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8'));
+
+describe('package.json — auto-update presence', () => {
+  test('update-notifier is in dependencies (CLI banner)', () => {
+    expect(pkg.dependencies).toBeDefined();
+    expect(pkg.dependencies['update-notifier']).toBeTruthy();
+  });
+
+  test('electron-updater is in optionalDependencies (Electron build only)', () => {
+    expect(pkg.optionalDependencies?.['electron-updater']).toBeTruthy();
+  });
+
+  test('electron-builder has a publish provider configured', () => {
+    expect(pkg.build).toBeDefined();
+    const publishField = pkg.build.publish;
+    expect(Array.isArray(publishField) || (publishField && typeof publishField === 'object')).toBe(true);
+    const entries = Array.isArray(publishField) ? publishField : [publishField];
+    expect(entries.length).toBeGreaterThan(0);
+    for (const entry of entries) {
+      expect(entry.provider).toBeTruthy();
+    }
+  });
+
+  test('GitHub publish target points at a real owner+repo (not the boilerplate `your-org`/`your-repo`)', () => {
+    const entries = Array.isArray(pkg.build.publish) ? pkg.build.publish : [pkg.build.publish];
+    const github = entries.find(e => e.provider === 'github');
+    if (!github) return;        // other providers (S3, etc.) are fine
+    expect(github.owner).toBeTruthy();
+    expect(github.repo).toBeTruthy();
+    // Common copy-paste placeholders.
+    expect(github.owner).not.toMatch(/^(your-org|TODO|placeholder)$/i);
+    expect(github.repo).not.toMatch(/^(your-repo|TODO|placeholder)$/i);
+  });
+
+  test('update-notifier source file exists and is referenced by the CLI entry point', () => {
+    // Tripwire against accidental file deletion. The runtime is
+    // tolerant of missing dependencies (dynamic import), but if the
+    // wrapper FILE goes missing the import line crashes.
+    expect(() => readFileSync(join(REPO_ROOT, 'src/utilities/updateNotifier.js'), 'utf8')).not.toThrow();
+    const cliEntry = readFileSync(join(REPO_ROOT, 'bin/cli.js'), 'utf8');
+    expect(cliEntry).toMatch(/from\s+['"]\.\.\/src\/utilities\/updateNotifier\.js['"]/);
+  });
+
+  test('electron autoUpdate source file exists and is referenced by electron/main.js', () => {
+    expect(() => readFileSync(join(REPO_ROOT, 'electron/autoUpdate.js'), 'utf8')).not.toThrow();
+    const mainEntry = readFileSync(join(REPO_ROOT, 'electron/main.js'), 'utf8');
+    expect(mainEntry).toMatch(/from\s+['"]\.\/autoUpdate\.js['"]/);
+  });
+});

package/src/__tests__/releaseWorkflow.test.js

@@ -0,0 +1,72 @@
+/**
+ * Tripwire: the npm-publish workflow must NOT re-introduce
+ * `javascript-obfuscator` or any other source-modifying step that
+ * would defeat the explicit decision in commit removing obfuscation.
+ *
+ * If you genuinely want to bring obfuscation back, change this test
+ * AND record the rationale in the workflow's leading comment block.
+ * Don't just delete the test.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, '..', '..');
+const WORKFLOWS_DIR = join(REPO_ROOT, '.github', 'workflows');
+
+const FORBIDDEN_IN_PUBLISH = [
+  'javascript-obfuscator',
+  'javascript_obfuscator',
+];
+
+describe('release workflows — obfuscation absence', () => {
+  test('publish-npm-trusted.yml contains no obfuscator install or invocation', () => {
+    const yaml = readFileSync(join(WORKFLOWS_DIR, 'publish-npm-trusted.yml'), 'utf8');
+    for (const needle of FORBIDDEN_IN_PUBLISH) {
+      // Tolerate the literal mention inside a comment block that
+      // documents the removal — but not in any other context.
+      const lines = yaml.split('\n');
+      const offending = lines
+        .map((line, idx) => ({ line, idx }))
+        .filter(({ line }) => line.includes(needle))
+        .filter(({ line }) => !/^\s*#/.test(line) && !/^\s*\/\//.test(line));
+      expect(offending).toEqual([]);
+    }
+  });
+
+  test('workflow YAML is syntactically valid (no orphaned steps)', () => {
+    const yaml = readFileSync(join(WORKFLOWS_DIR, 'publish-npm-trusted.yml'), 'utf8');
+    // We don't bundle a YAML parser into the CLI repo; a structural
+    // smoke test is enough to catch the most common form of breakage
+    // (deleting a step without removing the leading `- name:`).
+    const stepCount = (yaml.match(/^\s{4,6}- name:/gm) || []).length;
+    expect(stepCount).toBeGreaterThan(5);
+    // Each top-level step name should be followed by either `run:` or `uses:`
+    const lines = yaml.split('\n');
+    let pendingStepLine = null;
+    for (let i = 0; i < lines.length; i++) {
+      if (/^\s{4,6}- name:/.test(lines[i])) {
+        pendingStepLine = i;
+      } else if (pendingStepLine != null && /^\s{6,8}(run|uses):/.test(lines[i])) {
+        pendingStepLine = null;
+      } else if (pendingStepLine != null && /^\s{4,6}- /.test(lines[i])) {
+        throw new Error(`step at line ${pendingStepLine + 1} has no run/uses`);
+      }
+    }
+  });
+
+  test('every yml file in .github/workflows parses (basic balance check)', () => {
+    const files = readdirSync(WORKFLOWS_DIR).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+    expect(files.length).toBeGreaterThan(0);
+    for (const f of files) {
+      const yaml = readFileSync(join(WORKFLOWS_DIR, f), 'utf8');
+      // Naive but useful: every workflow should have `jobs:` and at
+      // least one step.
+      expect(yaml).toMatch(/^jobs:/m);
+      expect(yaml).toMatch(/^\s+steps:/m);
+    }
+  });
+});

package/src/core/__tests__/messageProcessor.sourceHeader.test.js

@@ -102,7 +102,12 @@ describe('MessageProcessor — source header injection', () => {
     expect(queued.role).toBe('user');
   });
 
-  test('Telegram private message → Telegram > DM attribution', async () => {
+  test('Telegram private message → collapsed "from Telegram" header (no user/DM noise)', async () => {
+    // Telegram private chats have exactly one human; the full
+    // "Message by alice ... > DM" header is bloat that pushes content
+    // out of the agent's context window. We collapse it to a 2-word
+    // prefix instead. Group chats keep the full attribution — see
+    // messageSource.test.js for the group case.
     const source = createTelegramSource({
       message_id: 1,
       chat: { id: 42, type: 'private' },
@@ -115,7 +120,7 @@ describe('MessageProcessor — source header injection', () => {
     });
 
     const [, queued] = agentPool.addUserMessage.mock.calls[0];
-    expect(queued.content).toBe('(Message by alice from Telegram > DM)\nstatus?');
+    expect(queued.content).toBe('(from Telegram)\nstatus?');
     expect(queued.source).toBe(source);
   });
 

package/src/index.js

@@ -705,6 +705,22 @@ class LoxiaApplication {
         this.telegramService.setAgentPool(this.agentPool);
         this.telegramService.setWebSocketManager(webServer);
         if (this.flowExecutor) this.telegramService.setFlowExecutor(this.flowExecutor);
+        // Backend URL + platform API key are needed for the voice-note
+        // → /llm/transcribe path. Without these, voice messages return
+        // a friendly "voice not configured" message and the user is
+        // told to type instead. Both come from the same sources the
+        // rest of the CLI's /api/* proxy code uses.
+        const backendBaseUrl = this.config?.backend?.baseUrl
+          || webServer?.config?.backend?.baseUrl
+          || null;
+        if (backendBaseUrl) this.telegramService.setBackendBaseUrl(backendBaseUrl);
+        // Pass a getter (not a snapshotted value) so the key is
+        // re-resolved on every transcribe call. This lets the user
+        // sign in AFTER boot — voice notes start working immediately
+        // without restarting the server.
+        this.telegramService.setPlatformApiKey(
+          () => this.apiKeyManager?.getKeysForRequest?.(null, { platformProvided: true })?.loxiaApiKey || null
+        );
         // Let the scheduler query bridge-state per agent so it can inject
         // the <external> routing guidance into system prompts only when the
         // agent is actually addressable from Telegram.