@pellux/goodvibes-tui 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.23.0] — 2026-06-12
+
+Third best-in-class program release: provider failover on the turn path, the context/compaction surface completed, the E20 export track closed, and the renderer pinned by golden frames. Every change passed independent review before commit.
+
+### Features
+- Added turn-path provider failover with bounded same-turn retries: the fallback chain is walked with a per-turn visited set, duplicate user messages are prevented by a message-count snapshot and rollback, synthetic models are never failed into, and retries preserve the original content and options.
+- Added /compact preview and after-notice: a clearly labelled estimate before compaction and the real before/after message and token figures from the compaction event when it completes.
+- Added /compact-history: lists past compaction events; restore is list-only until the SDK exposes a snapshot/restore API, and the output says so plainly.
+- Added /keep: pin text into session memory; pinned entries flow into the compaction handoff on both manual and auto-compact paths, with honest session-only wording (named /keep because /pin belongs to model favorites).
+- Added /channel: routes, delivery, status, and policy snapshots for the omnichannel substrate, with --json on every subcommand.
+- Added inbound event narration: GitHub, Slack, ntfy, and webhook events emit a transcript line naming the surface and event before agent dispatch, with self-narration guarded for companion and internal sources.
+
+### Fixes
+- Fixed a command registration collision between the new session-memory pin and the model-favorites /pin by naming the new command /keep.
+- Deflaked the websocket reconnect test with a deadline poll in place of a fixed sleep.
+
+### Internal
+- Architecture gate now detects import cycles (Tarjan SCC over the import graph, proven against an injected scratch cycle) and enforces 8 directional layer rules; the conversation and system-message-router cycle is genuinely broken via the runtime barrel.
+- Auth listener behavior pinned by 18 live tests: default login rate limit (five 401s then 429), proxy-spoofing posture, and empty-password handling.
+- Golden-frame harness pins four renderer surfaces with committed snapshots: regeneration is byte-for-byte stable, a missing golden fails instead of regenerating, and GOODVIBES_UPDATE_GOLDENS=1 is the only write path.
+- CLI management helpers deduplicated into management-utils with openBrowser extracted to a shared utility.
+
 ## [0.22.0] — 2026-06-12
 
 Second best-in-class program release: the backlog tail, the providers/failover track opened, and the release pipeline made fully honest. Every change passed independent review at 10/10 before commit.

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.22.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.23.0-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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",

package/src/cli/management-commands.ts

@@ -10,7 +10,7 @@ import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platfo
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import { classifyBindPosture, isNetworkFacing } from './network-posture.ts';
 import type { CliCommandRuntime } from './types.ts';
-import { extractAuthorizationCode, formatJsonOrText, hasCommandFlag, openBrowser, probeTcp, readAuthPaths, runNonInteractiveAgent, urlHostForBindHost, withRuntimeServices, yesNo } from './management.ts';
+import { extractAuthorizationCode, formatJsonOrText, hasCommandFlag, openBrowser, probeTcp, readAuthPaths, runNonInteractiveAgent, urlHostForBindHost, withRuntimeServices, yesNo } from './management-utils.ts';
 
 export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<string> {
   return await withRuntimeServices(runtime, async (services) => {

package/src/cli/management-utils.ts

@@ -0,0 +1,352 @@
+/**
+ * management-utils.ts — shared CLI utility functions.
+ *
+ * Extracted from management.ts to break the import cycle:
+ *   management.ts ↔ management-commands.ts
+ *   management.ts ↔ surface-command.ts
+ *
+ * Both management-commands.ts and surface-command.ts import from here;
+ * management.ts also imports from here (no longer from the child modules
+ * for these utilities).
+ *
+ * No imports from management-commands.ts or surface-command.ts are allowed
+ * in this file — that would recreate the cycle.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { networkInterfaces } from 'node:os';
+import type { ConfigManager, GoodVibesConfig } from '../config/index.ts';
+import { bootstrapRuntime } from '../runtime/bootstrap.ts';
+import { createRuntimeServices } from '../runtime/services.ts';
+import { createRuntimeStore } from '../runtime/store/index.ts';
+import type { RuntimeServices } from '../runtime/services.ts';
+import { RuntimeEventBus, type TurnEvent, createShellPathService } from '@/runtime/index.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { resolveRuntimeEndpointBinding } from './endpoints.ts';
+import { applyRuntimeEndpointFlagOverrides } from './config-overrides.ts';
+import type { RuntimeEndpointId } from './endpoints.ts';
+import type { CliCommandRuntime, GoodVibesCliParseResult } from './types.ts';
+import { openBrowser as _openBrowser } from '../utils/browser.ts';
+
+type Formatter = (value: unknown, text: string) => string;
+
+export function yesNo(value: unknown): string {
+  return value === true ? 'yes' : 'no';
+}
+
+export function formatJsonOrText(cli: GoodVibesCliParseResult): Formatter {
+  return (value, text) => cli.flags.outputFormat === 'json'
+    ? JSON.stringify(value, null, 2)
+    : text;
+}
+
+export function exitCodeForText(output: string): number {
+  if (output.startsWith('Usage:') || output.startsWith('Invalid ')) return 2;
+  if (output.startsWith('Session not found:') || output.startsWith('Unknown task:') || output.startsWith('Task submit failed ')) return 1;
+  if (output.startsWith('No stored ') || output.startsWith('No pending ') || output.startsWith('No model ') || output.startsWith('No provider ') || output.startsWith('No auth ')) return 1;
+  if (output.startsWith('Unknown ')) return 1;
+  if (output === 'Bundle has no config object to import.') return 1;
+  return 0;
+}
+
+export function splitCommandOption(token: string): { readonly name: string; readonly value: string | undefined } {
+  const index = token.indexOf('=');
+  if (index < 0) return { name: token, value: undefined };
+  return { name: token.slice(0, index), value: token.slice(index + 1) };
+}
+
+export function readOptionValue(args: readonly string[], name: string): string | undefined {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    const split = splitCommandOption(token);
+    if (split.name !== name) continue;
+    if (split.value !== undefined) return split.value;
+    const next = args[index + 1];
+    if (next === undefined || next.startsWith('--')) return undefined;
+    return next;
+  }
+  return undefined;
+}
+
+export function readOptionValues(args: readonly string[], name: string): string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    const split = splitCommandOption(token);
+    if (split.name !== name) continue;
+    if (split.value !== undefined) {
+      values.push(split.value);
+      continue;
+    }
+    const next = args[index + 1];
+    if (next !== undefined && !next.startsWith('--')) values.push(next);
+  }
+  return values;
+}
+
+export function hasCommandFlag(args: readonly string[], name: string): boolean {
+  return args.some((arg) => splitCommandOption(arg).name === name);
+}
+
+export function commandValues(args: readonly string[]): string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (!token.startsWith('--')) {
+      values.push(token);
+      continue;
+    }
+    if (!token.includes('=') && args[index + 1] && !args[index + 1]!.startsWith('--')) index += 1;
+  }
+  return values;
+}
+
+export function readPassword(args: readonly string[]): string | null {
+  const explicit = readOptionValue(args, '--password');
+  if (explicit !== undefined) return explicit;
+  if (hasCommandFlag(args, '--password-stdin')) return readFileSync(0, 'utf-8').trimEnd();
+  return process.env.GOODVIBES_AUTH_PASSWORD ?? null;
+}
+
+export function extractAuthorizationCode(input: string): string {
+  try {
+    const url = new URL(input);
+    return url.searchParams.get('code') ?? input;
+  } catch {
+    return input;
+  }
+}
+
+export function isPresentConfigValue(value: unknown): boolean {
+  if (typeof value === 'string') return value.trim().length > 0;
+  return value !== undefined && value !== null && value !== false;
+}
+
+export function getNestedValue(source: unknown, key: string): unknown {
+  let cursor = source;
+  for (const part of key.split('.')) {
+    if (cursor == null || typeof cursor !== 'object') return undefined;
+    cursor = (cursor as Record<string, unknown>)[part];
+  }
+  return cursor;
+}
+
+function getLocalNetworkIp(): string {
+  try {
+    const nets = networkInterfaces();
+    for (const name of Object.keys(nets)) {
+      for (const netInfo of nets[name] ?? []) {
+        if (netInfo.family === 'IPv4' && !netInfo.internal) return netInfo.address;
+      }
+    }
+  } catch {
+    return '127.0.0.1';
+  }
+  return '127.0.0.1';
+}
+
+function connectHostForBindHost(host: string): string {
+  if (host === '0.0.0.0' || host === '::') return '127.0.0.1';
+  return host || '127.0.0.1';
+}
+
+export function urlHostForBindHost(host: string): string {
+  if (host === '0.0.0.0' || host === '::') return getLocalNetworkIp();
+  return host || '127.0.0.1';
+}
+
+export function enableServicePosture(config: ConfigManager): void {
+  config.setDynamic('service.enabled', true);
+  config.setDynamic('service.autostart', true);
+  config.setDynamic('service.restartOnFailure', true);
+}
+
+export function enableEndpointLanDefault(config: ConfigManager, endpoint: RuntimeEndpointId): void {
+  const binding = resolveRuntimeEndpointBinding(config, endpoint);
+  if (binding.hostMode === 'custom') return;
+  if (endpoint === 'controlPlane') {
+    config.setDynamic('controlPlane.hostMode', 'network');
+    config.setDynamic('controlPlane.host', '0.0.0.0');
+    config.setDynamic('controlPlane.allowRemote', true);
+    return;
+  }
+  if (endpoint === 'httpListener') {
+    config.setDynamic('httpListener.hostMode', 'network');
+    config.setDynamic('httpListener.host', '0.0.0.0');
+    return;
+  }
+  config.setDynamic('web.hostMode', 'network');
+  config.setDynamic('web.host', '0.0.0.0');
+}
+
+export function applyTargetEndpointFlagsOrDefault(
+  runtime: CliCommandRuntime,
+  endpoint: RuntimeEndpointId,
+): string | null {
+  const errors = applyRuntimeEndpointFlagOverrides(runtime.configManager, endpoint, runtime.cli.flags);
+  if (errors.length > 0) return errors.join('\n');
+  if (runtime.cli.flags.hostname === undefined) {
+    enableEndpointLanDefault(runtime.configManager, endpoint);
+  }
+  if (endpoint === 'controlPlane') {
+    const binding = resolveRuntimeEndpointBinding(runtime.configManager, endpoint);
+    runtime.configManager.setDynamic('controlPlane.allowRemote', binding.hostMode !== 'local');
+  }
+  return null;
+}
+
+/**
+ * Re-export openBrowser from utils/browser.ts for backward compatibility.
+ * management.ts and management-commands.ts both used to export/import this;
+ * now all callers should prefer importing from utils/browser.ts directly.
+ */
+export { openBrowser } from '../utils/browser.ts';
+
+export async function probeTcp(host: string, port: number, timeoutMs = 750): Promise<boolean> {
+  return await new Promise<boolean>((resolve) => {
+    const socket = net.createConnection({ host: connectHostForBindHost(host), port });
+    const finish = (value: boolean) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+  });
+}
+
+export async function withRuntimeServices<T>(
+  runtime: CliCommandRuntime,
+  fn: (services: RuntimeServices) => Promise<T> | T,
+): Promise<T> {
+  const runtimeBus = new RuntimeEventBus();
+  const runtimeStore = createRuntimeStore();
+  const services = createRuntimeServices({
+    configManager: runtime.configManager,
+    runtimeBus,
+    runtimeStore,
+    workingDir: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+  services.providerRegistry.initModelLimits();
+  services.benchmarkStore.initBenchmarks();
+  services.providerRegistry.initCatalog();
+  try {
+    await services.providerRegistry.ready();
+    return await fn(services);
+  } finally {
+    services.providerRegistry.stopWatching();
+  }
+}
+
+export function readAuthPaths(runtime: CliCommandRuntime) {
+  const shellPaths = createShellPathService({
+    workingDirectory: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+  const userStorePath = shellPaths.resolveUserPath('tui', 'auth-users.json');
+  const bootstrapCredentialPath = shellPaths.resolveUserPath('tui', 'auth-bootstrap.txt');
+  const operatorTokenPath = join(runtime.homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  return {
+    userStorePath,
+    userStorePresent: existsSync(userStorePath),
+    bootstrapCredentialPath,
+    bootstrapCredentialPresent: existsSync(bootstrapCredentialPath),
+    operatorTokenPath,
+    operatorTokenPresent: existsSync(operatorTokenPath),
+  };
+}
+
+export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promise<number> {
+  const prompt = runtime.cli.flags.prompt ?? runtime.cli.positionals.join(' ').trim();
+  if (!prompt) {
+    console.error('Usage: goodvibes run|exec [prompt]');
+    return 2;
+  }
+
+  const outputFormat = runtime.cli.flags.outputFormat;
+  const ctx = await bootstrapRuntime(process.stdout, {
+    configManager: runtime.configManager,
+    workingDir: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+
+  const events: TurnEvent[] = [];
+  let finalResponse = '';
+  let finalError = '';
+  let finalStopReason = '';
+  let exitCode = 0;
+
+  const done = new Promise<void>((resolve) => {
+    const unsubs = [
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'STREAM_DELTA' }>>('STREAM_DELTA', ({ payload }) => {
+        events.push(payload);
+        if (outputFormat === 'stream-json') {
+          process.stdout.write(JSON.stringify({ type: payload.type, content: payload.content, accumulated: payload.accumulated }) + '\n');
+        }
+      }),
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_COMPLETED' }>>('TURN_COMPLETED', ({ payload }) => {
+        events.push(payload);
+        finalResponse = payload.response;
+        finalStopReason = payload.stopReason;
+        for (const unsub of unsubs) unsub();
+        resolve();
+      }),
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_ERROR' }>>('TURN_ERROR', ({ payload }) => {
+        events.push(payload);
+        finalError = payload.error;
+        finalStopReason = payload.stopReason;
+        exitCode = 1;
+        for (const unsub of unsubs) unsub();
+        resolve();
+      }),
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_CANCEL' }>>('TURN_CANCEL', ({ payload }) => {
+        events.push(payload);
+        finalError = payload.reason ?? 'cancelled';
+        finalStopReason = payload.stopReason;
+        exitCode = 130;
+        for (const unsub of unsubs) unsub();
+        resolve();
+      }),
+    ];
+  });
+
+  try {
+    await ctx.orchestrator.handleUserInput(prompt);
+    await done;
+    if (outputFormat === 'json') {
+      process.stdout.write(JSON.stringify({
+        ok: exitCode === 0,
+        response: finalResponse,
+        error: finalError || undefined,
+        stopReason: finalStopReason,
+        sessionId: ctx.runtime.sessionId,
+        model: ctx.runtime.model,
+        provider: ctx.runtime.provider,
+        events: events.length,
+      }, null, 2) + '\n');
+    } else if (outputFormat !== 'stream-json') {
+      process.stdout.write((exitCode === 0 ? finalResponse : finalError) + '\n');
+    } else {
+      process.stdout.write(JSON.stringify({
+        type: exitCode === 0 ? 'TURN_COMPLETED' : 'TURN_ERROR',
+        ok: exitCode === 0,
+        response: finalResponse,
+        error: finalError || undefined,
+        stopReason: finalStopReason,
+      }) + '\n');
+    }
+  } finally {
+    const snapshot = ctx.conversation.toJSON() as Parameters<typeof ctx.shutdown>[0];
+    await ctx.shutdown(snapshot);
+  }
+  return exitCode;
+}
+
+/** @deprecated Use ConfigManager directly. Kept for backward compat with management.ts usages. */
+export type { GoodVibesConfig };