@pellux/goodvibes-tui 0.19.62 → 0.19.64

package/CHANGELOG.md

@@ -8,6 +8,45 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.64] — 2026-05-05
+
+### Fixed
+- Fixed the packaged platform TUI binaries so the `sqlite-vec` JavaScript wrapper is bundled into the executable instead of being resolved from `/$bunfs/root` at startup.
+- Kept only the platform-native sqlite-vec addon external and shipped beside the binary under `dist/lib/sqlite-vec-<platform>-<arch>/`.
+- Fixed `goodvibes --version` and `goodvibes-daemon --version` for installed wrappers so they report the GoodVibes package version instead of the consuming project's `npm_package_version`.
+- Added release smoke coverage that runs the compiled TUI binary and verifies installed `goodvibes` and `goodvibes-daemon` wrappers so startup/version failures block publication.
+
+### Verified
+- `bun run scripts/build.ts --target linux-x64`
+- `bun run smoke:tui`
+- `bun test src/test/cli/help.test.ts src/test/cli/package-verification.test.ts --timeout 30000`
+- `bun run tsc --noEmit --pretty false`
+- `bun run smoke:daemon`
+- local `npm pack` install smoke with `GOODVIBES_ASSET_SOURCE_DIR=dist`
+- `/home/buzzkill/Projects/goodvibes-tui/dist/goodvibes-linux-x64 --version` from `/home/buzzkill/Projects/ttest1`
+
+---
+
+## [0.19.63] — 2026-05-05
+
+### Changed
+- Made the npm registry install path explicitly Bun-first: `bun add -g @pellux/goodvibes-tui` is now the documented global install command, while `npm install -g` requires Bun to already be installed.
+- Switched the published `goodvibes`, `goodvibes-daemon`, and postinstall entrypoints to Bun.
+- Added a preinstall Bun availability check so npm users get a clear error before postinstall runs.
+- Added package verification coverage for Bun shebangs and the Bun preinstall script.
+- Updated service management so daemon services use the global daemon state directory and resolve packaged/vendored daemon binaries before falling back to source or PATH wrappers.
+- Added mouse-wheel routing for scrollable panels such as the file explorer without stealing normal transcript scrolling.
+
+### Verified
+- `bun test src/test/cli/package-verification.test.ts src/test/cli/service-posture.test.ts src/test/daemon/service-manager.test.ts src/test/cli-flags.test.ts --timeout 30000`
+- `bun run tsc --noEmit --pretty false`
+- `bun run publish:check`
+- `bun run package:install-check`
+- `bun run build`
+- `git diff --check`
+
+---
+
 ## [0.19.62] — 2026-05-05
 
 ### Changed

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.19.62-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.64-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 
@@ -14,13 +14,15 @@ A terminal-native AI coding, operations, automation, knowledge, and integration
 
 ## Start Here
 
-Install from npm:
+GoodVibes is a Bun program. Install Bun first and make sure `bun` is on `PATH`, then install GoodVibes from the npm registry:
 
 ```sh
-npm install -g @pellux/goodvibes-tui
+bun add -g @pellux/goodvibes-tui
 goodvibes
 ```
 
+`npm install -g @pellux/goodvibes-tui` is also supported, but it does not install Bun for you. The package preinstall check fails with a clear message if `bun` is missing from `PATH`.
+
 Or run from source:
 
 ```sh
@@ -41,7 +43,8 @@ Common entrypoints:
 Release distribution:
 
 - GitHub Releases are the primary distribution path for compiled binaries
-- `npm install -g @pellux/goodvibes-tui` is supported on Linux, macOS, and WSL; the install script downloads the matching TUI and daemon binaries for the current platform
+- `bun add -g @pellux/goodvibes-tui` is the recommended global install path; the package is hosted on the npm registry and Bun installs from that registry directly
+- `npm install -g @pellux/goodvibes-tui` is supported on Linux, macOS, and WSL when Bun is already installed; the preinstall check verifies Bun, and the install script downloads the matching TUI and daemon binaries for the current platform
 - native Windows is not supported; use WSL on Windows
 
 Common paths:

package/bin/goodvibes

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import { accessSync, constants } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';

package/bin/goodvibes-daemon

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import { accessSync, constants } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.62",
+  "version": "0.19.64",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -17,6 +17,7 @@
     "!src/test",
     "!src/**/*.test.ts",
     "!src/**/__tests__",
+    "scripts/check-bun.sh",
     "scripts/postinstall.js",
     "README.md",
     "CHANGELOG.md",
@@ -37,12 +38,14 @@
     "build:daemon:macos-x64": "bun run scripts/build.ts --target daemon-macos-x64",
     "build:daemon:macos-arm64": "bun run scripts/build.ts --target daemon-macos-arm64",
     "smoke:daemon": "bun run scripts/post-build-smoke.ts",
+    "smoke:tui": "bun run scripts/smoke-tui-binary.ts",
     "build:windows": "bun build src/main.ts --compile --target=bun-windows-x64 --outfile dist/goodvibes-windows.exe",
     "build:all-shell": "bun run build:linux-x64 && bun run build:linux-arm64 && bun run build:macos-x64 && bun run build:macos-arm64 && bun run build:windows",
     "test": "bun run scripts/run-tests.ts",
     "version": "bun run scripts/prebuild.ts",
-    "postinstall": "node scripts/postinstall.js",
-    "postbuild": "node scripts/postinstall.js --no-download",
+    "preinstall": "sh scripts/check-bun.sh",
+    "postinstall": "bun scripts/postinstall.js",
+    "postbuild": "bun scripts/postinstall.js --no-download",
     "release": "bun run scripts/release.ts",
     "release:dry": "bun run scripts/release.ts --dry-run",
     "publish:package": "bun run scripts/publish-package.ts",
@@ -54,7 +57,10 @@
     "build:all": "bun run scripts/build.ts --all",
     "perf:check": "bun run scripts/perf-check.ts",
     "architecture:check": "bun run scripts/check-architecture.ts",
+    "audit:home": "bun run scripts/audit-goodvibes-home.ts",
     "foundation:artifacts": "bun run scripts/export-foundation-artifacts.ts",
+    "verification:ledger": "bun run scripts/verification-ledger.ts",
+    "verification:live": "bun run scripts/verify-live.ts",
     "eval:gate": "bun run scripts/eval-gate.ts",
     "eval:gate:verbose": "bun run scripts/eval-gate.ts --verbose",
     "eval:baseline": "bun run scripts/eval-gate.ts --save-baseline"

package/scripts/check-bun.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+set -eu
+
+if ! command -v bun >/dev/null 2>&1; then
+  cat >&2 <<'EOF'
+goodvibes-tui requires Bun.
+
+Install Bun first, then install GoodVibes from the npm registry with:
+
+  bun add -g @pellux/goodvibes-tui
+
+npm install -g @pellux/goodvibes-tui also works, but Bun must already be installed and available on PATH.
+EOF
+  exit 1
+fi
+
+if ! bun --version >/dev/null 2>&1; then
+  echo "goodvibes-tui requires a working Bun executable on PATH." >&2
+  exit 1
+fi

package/scripts/postinstall.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import { chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';

package/src/cli/help.ts

@@ -16,7 +16,6 @@ function readJsonVersion(path: string): string | null {
 export function getPackageVersion(): string {
   const here = dirname(fileURLToPath(import.meta.url));
   return readJsonVersion(join(here, '..', '..', 'package.json'))
-    ?? process.env.npm_package_version
     ?? VERSION;
 }
 

package/src/cli/package-verification.ts

@@ -7,6 +7,7 @@ export interface PackageCliBinVerification {
   readonly target: string;
   readonly exists: boolean;
   readonly executable: boolean;
+  readonly usesBunShebang: boolean;
   readonly hasLocalPlatformBuildFallback: boolean;
   readonly hasLocalBuildFallback: boolean;
   readonly hasVendoredBinaryFallback: boolean;
@@ -35,6 +36,7 @@ const REQUIRED_TARBALL_PATHS = [
   'src/daemon/cli.ts',
   'bin/goodvibes',
   'bin/goodvibes-daemon',
+  'scripts/check-bun.sh',
   'scripts/postinstall.js',
   '.goodvibes/GOODVIBES.md',
 ] as const;
@@ -58,6 +60,7 @@ function verifyBin(root: string, command: typeof REQUIRED_BIN_COMMANDS[number],
     target: target ?? '',
     exists: Boolean(target) && existsSync(binPath),
     executable: Boolean(target) && hasExecutableBit(binPath),
+    usesBunShebang: source.startsWith('#!/usr/bin/env bun'),
     hasLocalPlatformBuildFallback: source.includes("dist', artifactName"),
     hasLocalBuildFallback: source.includes(expectedLocalBuild),
     hasVendoredBinaryFallback: source.includes('vendor'),
@@ -92,6 +95,7 @@ export function verifyPackageCliInstall(root: string): PackageCliVerificationRep
     if (!item.target) issues.push(`package.json bin is missing ${item.command}.`);
     if (!item.exists) issues.push(`bin target does not exist: ${item.command} -> ${item.target}`);
     if (!item.executable) issues.push(`bin target is not executable: ${item.command} -> ${item.target}`);
+    if (!item.usesBunShebang) issues.push(`bin target does not use Bun shebang: ${item.command} -> ${item.target}`);
     if (!item.hasLocalPlatformBuildFallback) issues.push(`bin target lacks local platform dist fallback: ${item.command}`);
     if (!item.hasLocalBuildFallback) issues.push(`bin target lacks local dist fallback: ${item.command}`);
     if (!item.hasVendoredBinaryFallback) issues.push(`bin target lacks vendored binary fallback: ${item.command}`);

package/src/cli/service-command.ts

@@ -1,5 +1,6 @@
+import { mkdirSync } from 'node:fs';
 import type { CliCommandRuntime } from './management.ts';
-import { buildCliServicePosture, createPlatformServiceManager, formatCliServicePosture } from './service-posture.ts';
+import { buildCliServicePosture, createPlatformServiceManager, formatCliServicePosture, getServiceStateRoot } from './service-posture.ts';
 import type { CliCommandOutput } from './types.ts';
 
 function enableServicePosture(runtime: CliCommandRuntime): void {
@@ -21,6 +22,9 @@ export async function handleServiceCommand(runtime: CliCommandRuntime): Promise<
   if (sub === 'install' || sub === 'start' || sub === 'restart' || sub === 'stop' || sub === 'uninstall') {
     const manager = createPlatformServiceManager(runtime);
     if (sub === 'install' || sub === 'start' || sub === 'restart') enableServicePosture(runtime);
+    if (sub === 'install' || sub === 'start' || sub === 'restart') {
+      mkdirSync(getServiceStateRoot(runtime), { recursive: true });
+    }
     const result =
       sub === 'install' ? manager.install()
         : sub === 'start' ? manager.start()

package/src/cli/service-posture.ts

@@ -1,6 +1,7 @@
-import { closeSync, existsSync, openSync, readSync, statSync } from 'node:fs';
+import { accessSync, closeSync, constants, existsSync, openSync, readSync, realpathSync, statSync } from 'node:fs';
 import net from 'node:net';
-import { join } from 'node:path';
+import { basename, delimiter, dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { PlatformServiceManager } from '@pellux/goodvibes-sdk/platform/daemon';
 import type { ManagedServiceStatus } from '@pellux/goodvibes-sdk/platform/daemon';
 import type { ConfigManager } from '../config/index.ts';
@@ -56,6 +57,31 @@ const ENDPOINTS: readonly { readonly id: RuntimeEndpointId; readonly label: stri
   { id: 'web', label: 'web surface', enabledKey: 'web.enabled' },
 ];
 
+const SOURCE_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+export interface DaemonExecutableResolutionOptions {
+  readonly env?: NodeJS.ProcessEnv;
+  readonly argv?: readonly string[];
+  readonly execPath?: string;
+  readonly packageRoot?: string;
+}
+
+export interface DaemonExecutableResolution {
+  readonly command: string;
+  readonly source: 'env' | 'sibling' | 'package' | 'path' | 'fallback';
+  readonly absolute: boolean;
+}
+
+interface ServiceDefinitionOverride {
+  readonly name: string;
+  readonly description: string;
+  readonly workingDirectory: string;
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly env: Readonly<Record<string, string>>;
+  readonly restartOnFailure: boolean;
+}
+
 function connectHostForBindHost(host: string): string {
   if (host === '0.0.0.0' || host === '::') return '127.0.0.1';
   return host || '127.0.0.1';
@@ -76,8 +102,129 @@ async function probeTcp(host: string, port: number, timeoutMs = 750): Promise<bo
   });
 }
 
+function isExecutable(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function platformDaemonArtifactName(platform = process.platform, arch = process.arch): string {
+  if (platform === 'linux' && arch === 'x64') return 'goodvibes-daemon-linux-x64';
+  if (platform === 'linux' && arch === 'arm64') return 'goodvibes-daemon-linux-arm64';
+  if (platform === 'darwin' && arch === 'x64') return 'goodvibes-daemon-macos-x64';
+  if (platform === 'darwin' && arch === 'arm64') return 'goodvibes-daemon-macos-arm64';
+  if (platform === 'win32') return 'goodvibes-daemon-windows.exe';
+  return 'goodvibes-daemon';
+}
+
+function executablePathCandidates(path: string): string[] {
+  if (!path.trim() || !isAbsolute(path)) return [];
+  const dir = dirname(path);
+  const name = basename(path);
+  const artifact = platformDaemonArtifactName();
+  const candidates = [
+    join(dir, 'goodvibes-daemon'),
+    join(dir, artifact),
+  ];
+  if (name.startsWith('goodvibes-') && !name.startsWith('goodvibes-daemon-')) {
+    candidates.push(join(dir, name.replace(/^goodvibes-/, 'goodvibes-daemon-')));
+  }
+  if (name === 'goodvibes') candidates.push(join(dir, 'goodvibes-daemon'));
+  return [...new Set(candidates)];
+}
+
+function resolveCommandFromPath(command: string, pathValue: string | undefined): string | null {
+  const pathEntries = (pathValue ?? '').split(delimiter).filter(Boolean);
+  const extensions = process.platform === 'win32'
+    ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+    : [''];
+  for (const entry of pathEntries) {
+    for (const extension of extensions) {
+      const candidate = join(entry, `${command}${extension}`);
+      if (isExecutable(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function firstExecutable(paths: readonly string[]): string | null {
+  for (const path of paths) {
+    if (isExecutable(path)) return path;
+  }
+  return null;
+}
+
+function packageArtifactForBinWrapper(path: string): string | null {
+  let realPath = path;
+  try {
+    realPath = realpathSync(path);
+  } catch {
+    // Keep the original path if resolving a symlink fails.
+  }
+  if (basename(realPath) !== 'goodvibes-daemon') return null;
+  const binDir = dirname(realPath);
+  if (basename(binDir) !== 'bin') return null;
+  const packageRoot = dirname(binDir);
+  return firstExecutable([
+    join(packageRoot, 'vendor', platformDaemonArtifactName()),
+    join(packageRoot, 'dist', platformDaemonArtifactName()),
+    join(packageRoot, 'dist', 'goodvibes-daemon'),
+  ]);
+}
+
+export function resolveGoodVibesDaemonExecutable(
+  options: DaemonExecutableResolutionOptions = {},
+): DaemonExecutableResolution {
+  const env = options.env ?? process.env;
+  const override = env.GOODVIBES_DAEMON_COMMAND?.trim();
+  if (override) {
+    return { command: override, source: 'env', absolute: isAbsolute(override) };
+  }
+
+  const packageRoot = options.packageRoot ?? SOURCE_PACKAGE_ROOT;
+  const packaged = firstExecutable([
+    join(packageRoot, 'dist', platformDaemonArtifactName()),
+    join(packageRoot, 'dist', 'goodvibes-daemon'),
+    join(packageRoot, 'vendor', platformDaemonArtifactName()),
+    join(packageRoot, 'bin', 'goodvibes-daemon'),
+  ]);
+  if (packaged) return { command: packaged, source: 'package', absolute: true };
+
+  const argv = options.argv ?? process.argv;
+  const execPath = options.execPath ?? process.execPath;
+  const sibling = firstExecutable([
+    ...executablePathCandidates(execPath),
+    ...executablePathCandidates(argv[1] ?? ''),
+  ]);
+  if (sibling) {
+    return {
+      command: packageArtifactForBinWrapper(sibling) ?? sibling,
+      source: 'sibling',
+      absolute: true,
+    };
+  }
+
+  const pathResolved = resolveCommandFromPath('goodvibes-daemon', env.PATH);
+  if (pathResolved) {
+    return {
+      command: packageArtifactForBinWrapper(pathResolved) ?? pathResolved,
+      source: 'path',
+      absolute: true,
+    };
+  }
+
+  return { command: 'goodvibes-daemon', source: 'fallback', absolute: false };
+}
+
+export function getServiceStateRoot(runtime: CliServiceRuntime): string {
+  return join(runtime.homeDirectory, '.goodvibes', 'daemon');
+}
+
 function pidFilePath(runtime: CliServiceRuntime, platform: ManagedServiceStatus['platform']): string {
-  return join(runtime.workingDirectory, '.goodvibes', 'tui', 'service', `${platform}.pid`);
+  return join(getServiceStateRoot(runtime), 'service', `${platform}.pid`);
 }
 
 function readLogPosture(path: string | undefined, tailBytes: number): CliServiceLogPosture {
@@ -122,11 +269,28 @@ function endpointsConflict(a: CliServiceEndpointPosture, b: CliServiceEndpointPo
 }
 
 export function createPlatformServiceManager(runtime: CliServiceRuntime): PlatformServiceManager {
+  const daemonHomeDir = getServiceStateRoot(runtime);
+  const serviceName = String(runtime.configManager.get('service.serviceName') ?? 'goodvibes').trim() || 'goodvibes';
+  const daemonExecutable = resolveGoodVibesDaemonExecutable();
+  const definition: ServiceDefinitionOverride = {
+    name: serviceName,
+    description: 'GoodVibes daemon, control-plane, listener, and web host',
+    workingDirectory: daemonHomeDir,
+    command: daemonExecutable.command,
+    args: [],
+    env: {
+      GOODVIBES_DAEMON_HOME: daemonHomeDir,
+      GOODVIBES_DAEMON_TOKEN: process.env.GOODVIBES_DAEMON_TOKEN ?? '',
+      GOODVIBES_HTTP_TOKEN: process.env.GOODVIBES_HTTP_TOKEN ?? '',
+      NODE_ENV: process.env.NODE_ENV ?? 'production',
+    },
+    restartOnFailure: runtime.configManager.get('service.restartOnFailure') === true,
+  };
   return new PlatformServiceManager(runtime.configManager, {
-    workingDirectory: runtime.workingDirectory,
+    workingDirectory: runtime.homeDirectory,
     homeDirectory: runtime.homeDirectory,
-    surfaceRoot: 'tui',
-    binaryBaseName: 'goodvibes-daemon',
+    surfaceRoot: 'daemon',
+    definitionOverride: definition,
     defaultServiceName: 'goodvibes',
     defaultServiceDescription: 'GoodVibes daemon, control-plane, listener, and web host',
   });