@pellux/goodvibes-tui 1.27.1 → 2.0.2

package/src/cli/config-overrides.ts

@@ -1,267 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import type { ConfigKey, ConfigManager, ConfigSetting, GoodVibesConfig } from '../config/index.ts';
-import { CONFIG_SCHEMA, ConfigError } from '../config/index.ts';
-import { featureEnablementWrite, getFeatureSetting } from '../runtime/feature-settings.ts';
-import type { GoodVibesCliCommand, GoodVibesCliFlags } from './types.ts';
-import { RUNTIME_ENDPOINT_CONFIG_KEYS, hostModeForHostname } from './endpoints.ts';
-import type { RuntimeEndpointId } from './endpoints.ts';
-
-const CONFIG_SCHEMA_BY_KEY = new Map<string, ConfigSetting>(
-  CONFIG_SCHEMA.map((setting) => [setting.key, setting]),
-);
-
-function parseConfigOverrideValue(value: string): unknown {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return '';
-  try {
-    return JSON.parse(trimmed) as unknown;
-  } catch {
-    if (trimmed === 'true') return true;
-    if (trimmed === 'false') return false;
-    if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) return Number(trimmed);
-    return value;
-  }
-}
-
-function getRuntimeConfig(configManager: ConfigManager): GoodVibesConfig {
-  const mutable = configManager as unknown as { config?: GoodVibesConfig };
-  if (!mutable.config || typeof mutable.config !== 'object') {
-    throw new ConfigError('ConfigManager runtime config is not available for CLI overrides.');
-  }
-  return mutable.config;
-}
-
-function validateConfigValue(setting: ConfigSetting, value: unknown): void {
-  if (setting.type === 'boolean' && typeof value !== 'boolean') {
-    throw new ConfigError(`Invalid value for ${setting.key}: expected boolean.`);
-  }
-  if (setting.type === 'number' && (typeof value !== 'number' || !Number.isFinite(value))) {
-    throw new ConfigError(`Invalid value for ${setting.key}: expected number.`);
-  }
-  if (setting.type === 'string' && typeof value !== 'string') {
-    throw new ConfigError(`Invalid value for ${setting.key}: expected string.`);
-  }
-  if (setting.type === 'enum' && setting.enumValues && !setting.enumValues.includes(String(value))) {
-    throw new ConfigError(`Invalid value for ${setting.key}: "${String(value)}". Allowed: ${setting.enumValues.join(', ')}`);
-  }
-  if (setting.validate && !setting.validate(value)) {
-    throw new ConfigError(`Invalid value for ${setting.key}: ${String(value)}`);
-  }
-}
-
-function setNestedConfigValue(config: GoodVibesConfig, key: ConfigKey, value: unknown): void {
-  const parts = key.split('.');
-  let cursor: unknown = config;
-  for (const part of parts.slice(0, -1)) {
-    if (cursor == null || typeof cursor !== 'object' || !(part in cursor)) {
-      throw new ConfigError(`Invalid config path: section '${part}' does not exist`);
-    }
-    cursor = (cursor as Record<string, unknown>)[part];
-  }
-  if (cursor == null || typeof cursor !== 'object') {
-    throw new ConfigError(`Invalid config path: section '${parts.slice(0, -1).join('.')}' does not exist`);
-  }
-  (cursor as Record<string, unknown>)[parts[parts.length - 1]!] = value;
-}
-
-/**
- * Typed accessor for the SDK's private file paths on ConfigManager.
- *
- * SDK coupling: configPath and projectConfigPath are declared `private readonly`
- * in the SDK's ConfigManager (see manager.d.ts — configPath, projectConfigPath). No public accessors exist
- * as of the SDK version pinned in this project. This cast is the narrowest
- * possible workaround. SDK public-accessor request: see HANDOFF-FROM-TUI-SESSION-20260611.md,
- * Item 6 area. If the SDK ever exposes getConfigPath()/getProjectConfigPath(), replace
- * this cast with those calls and remove this comment.
- *
- * Fail-open: if the cast produces undefined (SDK internal rename), the paths are
- * treated as absent and the default is applied safely.
- */
-function getPersistedPaths(configManager: ConfigManager): { configPath: string | undefined; projectConfigPath: string | undefined } {
-  const manager = configManager as unknown as { configPath?: string; projectConfigPath?: string };
-  return {
-    configPath: typeof manager.configPath === 'string' ? manager.configPath : undefined,
-    projectConfigPath: typeof manager.projectConfigPath === 'string' ? manager.projectConfigPath : undefined,
-  };
-}
-
-/**
- * Returns true if the given dot-path key is explicitly present anywhere
- * in the provided raw JSON object.
- */
-function isKeyPresentInRaw(raw: Record<string, unknown>, key: ConfigKey): boolean {
-  const parts = key.split('.');
-  let cursor: unknown = raw;
-  for (const part of parts) {
-    if (cursor == null || typeof cursor !== 'object' || !(part in (cursor as object))) {
-      return false;
-    }
-    cursor = (cursor as Record<string, unknown>)[part];
-  }
-  return true;
-}
-
-/**
- * Apply a TUI default to a config key, but ONLY if the user has not explicitly
- * set the key in EITHER their global OR project persisted settings files.
- * Reads the raw settings JSON from disk (bypasses the in-memory merged config)
- * so a user's explicit `false` in either file is never silently overridden at startup.
- *
- * Each settings file is read independently: a parse failure on one file
- * contributes nothing but does NOT prevent the other file from being checked.
- * The default is applied only when the key is absent from every readable file
- * (e.g. new install, both files missing, or both unparseable).
- */
-export function applyRuntimeConfigDefault(configManager: ConfigManager, key: ConfigKey, defaultValue: unknown): void {
-  const { configPath, projectConfigPath } = getPersistedPaths(configManager);
-  // Check each settings file independently. A read/parse failure on one path
-  // contributes nothing but must not prevent the other path from being checked.
-  for (const filePath of [configPath, projectConfigPath]) {
-    if (typeof filePath !== 'string' || !existsSync(filePath)) continue;
-    try {
-      const raw = JSON.parse(readFileSync(filePath, 'utf-8')) as Record<string, unknown>;
-      if (isKeyPresentInRaw(raw, key)) {
-        // Key is explicitly set in this persisted config — respect the user's value.
-        return;
-      }
-    } catch {
-      // Unreadable or malformed JSON — this file contributes nothing; continue to next.
-    }
-  }
-  applyRuntimeConfigValue(configManager, key, defaultValue);
-}
-
-/**
- * Every TUI-side config default applied at startup, in one place. Currently:
- * show token speed ON (the SDK schema default is false). applyRuntimeConfigDefault
- * reads the global + project settings files and only applies the default
- * in-memory when the key is absent from both (e.g. a new install); an explicit
- * user value is respected. No disk write.
- */
-export function applyTuiRuntimeConfigDefaults(configManager: ConfigManager): void {
-  applyRuntimeConfigDefault(configManager, 'display.showTokenSpeed', true);
-}
-
-/**
- * Applies the persisted `behavior.hitlMode` config value to the live mode
- * manager at startup, ignoring unset or unrecognized values. Extracted from
- * main() verbatim (a plain move, no behavior change).
- */
-export function applyConfiguredHitlMode(
-  configManager: ConfigManager,
-  modeManager: { setHITLMode(mode: 'quiet' | 'balanced' | 'operator'): void },
-): void {
-  const hitlMode = configManager.get('behavior.hitlMode');
-  if (hitlMode === 'quiet' || hitlMode === 'balanced' || hitlMode === 'operator') {
-    modeManager.setHITLMode(hitlMode);
-  }
-}
-
-export function applyRuntimeConfigValue(configManager: ConfigManager, key: ConfigKey, value: unknown): void {
-  const setting = CONFIG_SCHEMA_BY_KEY.get(key);
-  if (!setting) {
-    throw new ConfigError(`Unknown config key: ${key}`);
-  }
-  validateConfigValue(setting, value);
-  setNestedConfigValue(getRuntimeConfig(configManager), key, value);
-}
-
-export function applyRuntimeConfigOverrides(
-  configManager: ConfigManager,
-  overrides: readonly string[],
-): readonly string[] {
-  const errors: string[] = [];
-  for (const override of overrides) {
-    const index = override.indexOf('=');
-    if (index <= 0) {
-      errors.push(`Invalid --config override "${override}". Expected key=value.`);
-      continue;
-    }
-    const key = override.slice(0, index) as ConfigKey;
-    const rawValue = override.slice(index + 1);
-    try {
-      applyRuntimeConfigValue(configManager, key, parseConfigOverrideValue(rawValue));
-    } catch (error) {
-      errors.push(error instanceof Error ? `Invalid --config ${override}: ${error.message}` : `Invalid --config ${override}`);
-    }
-  }
-  return errors;
-}
-
-/**
- * Session-only feature overrides (--enable-feature / --disable-feature).
- * Each feature is switched through its real domain settings key (e.g.
- * sandbox.enabled, behavior.compactionStrategy) in the runtime config layer;
- * features without an off position (constant capabilities on non-boolean
- * keys) and unknown ids are reported as errors rather than silently ignored.
- */
-export function applyRuntimeFeatureFlagOverrides(
-  configManager: ConfigManager,
-  options: {
-    readonly enableFeatures: readonly string[];
-    readonly disableFeatures: readonly string[];
-  },
-): readonly string[] {
-  if (options.enableFeatures.length === 0 && options.disableFeatures.length === 0) return [];
-  const config = getRuntimeConfig(configManager);
-  const errors: string[] = [];
-  const apply = (feature: string, enabled: boolean, flagName: string): void => {
-    const write = featureEnablementWrite(feature, enabled);
-    if (!write) {
-      errors.push(getFeatureSetting(feature)
-        ? `${flagName} ${feature}: this capability has no ${enabled ? 'on' : 'off'} switch (its domain settings govern it directly).`
-        : `${flagName} ${feature}: unknown feature id.`);
-      return;
-    }
-    setNestedConfigValue(config, write.key, write.value);
-  };
-  for (const feature of options.enableFeatures) apply(feature, true, '--enable-feature');
-  for (const feature of options.disableFeatures) apply(feature, false, '--disable-feature');
-  return errors;
-}
-
-export function applyRuntimeEndpointFlagOverrides(
-  configManager: ConfigManager,
-  endpoint: RuntimeEndpointId,
-  flags: Pick<GoodVibesCliFlags, 'hostname' | 'port'>,
-): readonly string[] {
-  const keys = RUNTIME_ENDPOINT_CONFIG_KEYS[endpoint];
-  const errors: string[] = [];
-
-  if (flags.hostname !== undefined) {
-    try {
-      applyRuntimeConfigValue(configManager, keys.hostMode, hostModeForHostname(flags.hostname));
-      applyRuntimeConfigValue(configManager, keys.host, flags.hostname);
-    } catch (error) {
-      errors.push(error instanceof Error
-        ? `Invalid --hostname ${flags.hostname}: ${error.message}`
-        : `Invalid --hostname ${flags.hostname}`);
-    }
-  }
-
-  if (flags.port !== undefined) {
-    try {
-      applyRuntimeConfigValue(configManager, keys.port, flags.port);
-    } catch (error) {
-      errors.push(error instanceof Error
-        ? `Invalid --port ${flags.port}: ${error.message}`
-        : `Invalid --port ${flags.port}`);
-    }
-  }
-
-  return errors;
-}
-
-export function applyRuntimeCommandEndpointFlagOverrides(
-  configManager: ConfigManager,
-  command: GoodVibesCliCommand,
-  flags: Pick<GoodVibesCliFlags, 'hostname' | 'port'>,
-): readonly string[] {
-  if (flags.hostname === undefined && flags.port === undefined) return [];
-  if (command === 'web') return applyRuntimeEndpointFlagOverrides(configManager, 'web', flags);
-  if (command === 'listener') return applyRuntimeEndpointFlagOverrides(configManager, 'httpListener', flags);
-  if (command === 'control-plane' || command === 'pair' || command === 'serve') {
-    return applyRuntimeEndpointFlagOverrides(configManager, 'controlPlane', flags);
-  }
-  return [];
-}

package/src/cli/endpoints.ts

@@ -1,109 +0,0 @@
-import type { ConfigKey, ConfigManager } from '../config/index.ts';
-
-export type RuntimeEndpointId = 'controlPlane' | 'httpListener' | 'web';
-export type RuntimeHostMode = 'local' | 'network' | 'custom';
-
-export const RUNTIME_ENDPOINT_DEFAULT_PORTS: Record<RuntimeEndpointId, number> = {
-  controlPlane: 3421,
-  httpListener: 3422,
-  web: 3423,
-};
-
-export const RUNTIME_ENDPOINT_CONFIG_KEYS: Record<RuntimeEndpointId, {
-  readonly hostMode: ConfigKey;
-  readonly host: ConfigKey;
-  readonly port: ConfigKey;
-}> = {
-  controlPlane: {
-    hostMode: 'controlPlane.hostMode',
-    host: 'controlPlane.host',
-    port: 'controlPlane.port',
-  },
-  httpListener: {
-    hostMode: 'httpListener.hostMode',
-    host: 'httpListener.host',
-    port: 'httpListener.port',
-  },
-  web: {
-    hostMode: 'web.hostMode',
-    host: 'web.host',
-    port: 'web.port',
-  },
-};
-
-export interface RuntimeEndpointBinding {
-  readonly hostMode: string;
-  readonly configuredHost: string;
-  readonly host: string;
-  readonly port: number;
-  /**
-   * False when the stored hostMode is not one of the SDK's recognized modes
-   * ('local' | 'network' | 'custom'). The SDK's resolveHostBinding is a switch
-   * with NO default case: an unrecognized mode yields an undefined binding and
-   * the daemon throws in its constructor before ever binding. Displays must
-   * therefore never present the host/port below as a definite binding when
-   * this is false — the fallback values exist only so display code has
-   * something structured to show alongside the warning.
-   */
-  readonly recognized: boolean;
-}
-
-/**
- * THE one display seam for endpoint bindings: every surface that renders a
- * binding as text goes through this, so no surface can present the resolver's
- * loopback fallback as a definite bind for a hostMode the SDK cannot handle
- * (its bind resolver has no default case — the daemon throws before binding).
- * The recognized case renders the familiar `<mode> <host>:<port>`.
- */
-export function formatRuntimeEndpointBinding(binding: RuntimeEndpointBinding): string {
-  if (binding.recognized) {
-    return `${binding.hostMode} ${binding.host}:${binding.port}`;
-  }
-  return `'${binding.hostMode}' — not a recognized host mode (expected local|network|custom); the daemon cannot bind this endpoint until it is corrected`;
-}
-
-export function hostModeForHostname(hostname: string): RuntimeHostMode {
-  const normalized = hostname.toLowerCase();
-  if (normalized === '0.0.0.0' || normalized === '::') return 'network';
-  if (normalized === '127.0.0.1' || normalized === 'localhost' || normalized === '::1') return 'local';
-  return 'custom';
-}
-
-export function resolveRuntimeEndpointBinding(
-  config: Pick<ConfigManager, 'get'>,
-  endpoint: RuntimeEndpointId,
-): RuntimeEndpointBinding {
-  const keys = RUNTIME_ENDPOINT_CONFIG_KEYS[endpoint];
-  const hostMode = String(config.get(keys.hostMode) ?? 'local');
-  const configuredHost = String(config.get(keys.host) ?? '127.0.0.1');
-  // Port coercion is anchored PER ENDPOINT to what the SDK actually does with
-  // the stored value, so a display never disagrees with the machinery:
-  //   - controlPlane / httpListener bind via resolveHostBinding, which is fed
-  //     `Number(raw ?? default)` and applies `customPort || DEFAULT` — a
-  //     stored 0 or non-numeric value collapses to the endpoint default.
-  //   - web has NO resolveHostBinding consumer in the SDK at all; its closest
-  //     machinery (resolveWebPort, which drives tailscale-serve, plus the
-  //     surface registry/announcements) uses bare `Number(raw ?? default)`
-  //     with no || collapse — 0 stays 0 and a non-numeric value stays NaN.
-  //     Collapsing here would make the display assert a port the tailscale/
-  //     announcement machinery is not actually using. (The SDK's web-port
-  //     handling is inconsistent-by-absence — a proper resolveHostBinding-style
-  //     web resolver is an SDK-side fix; until then this mirrors resolveWebPort.)
-  const rawPort = Number(config.get(keys.port) ?? RUNTIME_ENDPOINT_DEFAULT_PORTS[endpoint]);
-  const port = endpoint === 'web' ? rawPort : (rawPort || RUNTIME_ENDPOINT_DEFAULT_PORTS[endpoint]);
-  if (hostMode === 'network') {
-    return { hostMode, configuredHost, host: '0.0.0.0', port, recognized: true };
-  }
-  if (hostMode === 'custom') {
-    return { hostMode, configuredHost, host: configuredHost || '127.0.0.1', port, recognized: true };
-  }
-  if (hostMode === 'local') {
-    return { hostMode, configuredHost, host: '127.0.0.1', port, recognized: true };
-  }
-  // Unrecognized hostMode ('LAN', 'Network', '', a trimmed variant, …): the
-  // SDK bind path has NO default case for this — resolveHostBinding returns
-  // undefined and the daemon throws before binding. There IS no real binding
-  // to display; recognized:false tells callers to warn instead of asserting
-  // the loopback fallback below as fact.
-  return { hostMode, configuredHost, host: '127.0.0.1', port, recognized: false };
-}