@pellux/goodvibes-tui 1.27.1 → 2.0.1

package/src/runtime/fleet-services.ts

@@ -1,41 +0,0 @@
-/**
- * fleet-services.ts — the shared, archive-aware fleet registry construction,
- * lifted out of services.ts so the composition root stays under the file-size
- * cap. Mirrors the sibling create*Services helpers (durability, code-index,
- * workstream): a single dependency-injected call that services.ts makes once.
- *
- * Also owns the daemon-side observed foreign-agent source: when
- * observeExternalAgents is on (the standalone daemon), externally-launched
- * coding-agent sessions observed read-only on the host fold in as
- * 'observed-external' rows (visibility + steer; never counted against
- * fleet.maxSize, never stopped). The interactive process leaves it off and
- * reads the daemon's snapshot, so it never double-scans. Absence ⇒ a quiet
- * empty set. Mirrors the SDK's own createRuntimeServices wiring.
- */
-import { computeUsageCostUsd, type ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
-import { type ArchivableProcessRegistry } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
-import { ObservedAgentSource } from '@pellux/goodvibes-sdk/platform/runtime/fleet/observed';
-import { createArchivableFleetRegistry, type ProcessRegistryDeps } from '@pellux/goodvibes-terminal-shell';
-
-export interface FleetServicesDeps
-  extends Omit<ProcessRegistryDeps, 'observedAgents' | 'priceUsage'> {
-  /** Turns on the daemon-side observed foreign-agent source (daemon only). */
-  readonly observeExternalAgents?: boolean | undefined;
-  /** Backs the honest pricing resolver folded into priceUsage below. */
-  readonly providerRegistry: Pick<ProviderRegistry, 'resolveModelPricing'>;
-}
-
-export function createFleetServices(
-  deps: FleetServicesDeps,
-): { processRegistry: ArchivableProcessRegistry } {
-  const { observeExternalAgents, providerRegistry, ...registryDeps } = deps;
-  const observedAgents = observeExternalAgents ? new ObservedAgentSource() : undefined;
-  const processRegistry = createArchivableFleetRegistry({
-    ...registryDeps,
-    observedAgents, // Daemon-side observed foreign-agent rows (undefined in the interactive process)
-    // Honest-unpriced through the ONE pricing resolver (manual -> registration -> provider-served
-    // -> catalog -> unknown); unknown/subscription yields null, never $0. Mirrors the SDK composition.
-    priceUsage: (model, usage) => (model ? computeUsageCostUsd(providerRegistry.resolveModelPricing(model), usage) : null),
-  });
-  return { processRegistry };
-}

package/src/runtime/idle-power-services.ts

@@ -1,85 +0,0 @@
-// ---------------------------------------------------------------------------
-// idle-power-services.ts — the idle-time / sleep-ownership / live-turn slice of
-// the runtime composition, extracted from services.ts (file-size hygiene).
-//
-// Mirrors the SDK's own createRuntimeServices wiring: idle-time memory
-// consolidation (learning.consolidation.*), host sleep ownership (power.*), and
-// the per-session live-turn control holder that backs the
-// sessions.toolCalls.cancel / sessions.queuedMessages.* wire verbs. Consolidation
-// receipts ride the SAME attach-time queue every other receipt uses — a run that
-// changed something records a one-line notice into the file-backed
-// feature-announcement store, drained on the next surface attach; a quiet run
-// records nothing.
-// ---------------------------------------------------------------------------
-
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
-import { MemoryConsolidationScheduler } from '@pellux/goodvibes-sdk/platform/state';
-import { SessionLiveTurnControlsHolder } from '@pellux/goodvibes-sdk/platform/control-plane';
-import { PowerManager, wireRuntimePower, createUnavailablePowerSeam } from '@pellux/goodvibes-sdk/platform/power';
-import { FeatureAnnouncementStore, featureAnnouncementsPath } from '@pellux/goodvibes-sdk/platform/runtime/feature-announcements';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/state';
-import { formatConsolidationReceipt } from '../core/consolidation-receipt.ts';
-
-export interface IdlePowerServicesDeps {
-  readonly configManager: ConfigManager;
-  readonly memoryRegistry: MemoryRegistry;
-  readonly runtimeBus: RuntimeEventBus;
-  /** True when no session is busy — the consolidation scheduler's idle gate. */
-  readonly isIdle: () => boolean;
-  /** Sleep-edge checkpoint + a wake catch-up tick (store snapshots). */
-  readonly snapshotTick: () => void;
-  /** Wake catch-up: fire the automation heartbeat. */
-  readonly heartbeat: () => Promise<void>;
-  /**
-   * Host power seam. SDK 1.9.0 makes wireRuntimePower default an absent seam to
-   * the REAL host seam (createHostPowerSeam — which spawns systemd-inhibit and a
-   * dbus-monitor sleep-edge watcher). That spawn is a host-level side effect, so
-   * this fork mirrors the SDK's own createRuntimeServices: when no seam is passed
-   * we default to the NON-spawning unavailable seam, keeping test-constructed
-   * runtimes deterministic. Only the real long-lived compositions (the standalone
-   * daemon and the embedded interactive runtime, which itself IS the daemon) pass
-   * createHostPowerSeam() to opt into live OS keep-awake/idle-inhibit.
-   */
-  readonly powerSeam?: Parameters<typeof wireRuntimePower>[0]['seam'];
-}
-
-export interface IdlePowerServices {
-  readonly memoryConsolidationScheduler: MemoryConsolidationScheduler;
-  readonly powerManager: PowerManager;
-  readonly sessionLiveTurnControls: SessionLiveTurnControlsHolder;
-}
-
-/** Construct (and start) the idle-consolidation scheduler, power manager, and live-turn holder. */
-export function wireIdlePowerAndLiveTurn(deps: IdlePowerServicesDeps): IdlePowerServices {
-  const consolidationReceiptStore = new FeatureAnnouncementStore(featureAnnouncementsPath(deps.configManager));
-  const memoryConsolidationScheduler = new MemoryConsolidationScheduler({
-    memoryRegistry: deps.memoryRegistry,
-    configSource: deps.configManager,
-    isIdle: deps.isIdle,
-    onReceipt: (receipt) => {
-      const text = formatConsolidationReceipt(receipt);
-      if (text) consolidationReceiptStore.record(receipt.runId, text);
-    },
-  });
-  memoryConsolidationScheduler.start();
-  const sessionLiveTurnControls = new SessionLiveTurnControlsHolder();
-  const powerManager = wireRuntimePower({
-    readConfig: (key) => deps.configManager.get(key as Parameters<typeof deps.configManager.get>[0]),
-    writeConfig: (key, value) => deps.configManager.setDynamic(key as Parameters<typeof deps.configManager.setDynamic>[0], value),
-    // Live config subscription: an external edit to power.keepAwake (a settings-
-    // modal toggle, a hand-edited settings file) applies LIVE to the in-process
-    // manager — acquires/releases the inhibitor and lights the chip with no
-    // restart. This is the config-apply path for the EMBEDDED topology + the
-    // local chip; the external daemon is reached separately over the verb.
-    subscribeConfig: (key, cb) => (deps.configManager.subscribe as unknown as (k: string, c: (v: unknown) => void) => () => void)(key, (newValue) => cb(newValue)),
-    runtimeBus: deps.runtimeBus,
-    sleepCheckpoint: deps.snapshotTick,
-    wakeCatchUp: [() => memoryConsolidationScheduler.tick(), deps.snapshotTick, deps.heartbeat],
-    // Non-spawning default (see powerSeam doc above): without an explicit opt-in
-    // the seam is the honest unavailable one, NOT the spawning host seam that
-    // wireRuntimePower would otherwise pick for an undefined seam.
-    seam: deps.powerSeam ?? createUnavailablePowerSeam('runtime services constructed without a host power seam'),
-  });
-  return { memoryConsolidationScheduler, powerManager, sessionLiveTurnControls };
-}

package/src/runtime/mail-composition.ts

@@ -1,65 +0,0 @@
-/**
- * mail-composition.ts
- *
- * The deps that let the platform register this daemon's `email.*` verbs.
- *
- * `calendar.*` and `email.*` are served by the platform now, not by handlers in
- * this repository — those were deleted when the platform gained an
- * implementation the daemon could call. What is left for a product to supply is
- * the wiring, and it is not optional: without `homeDirectory` the calendar
- * composition returns null, without these deps the mail one does, and either way
- * the verbs stay cataloged-but-unhandled while every surface reports the daemon
- * unreachable on a daemon that is working perfectly.
- *
- * Extracted from services.ts rather than living there, because that file sits at
- * the 800-line architecture cap and a composition step is exactly the kind of
- * thing the cap exists to push into a module of its own.
- */
-
-import {
-  withSurfaceEmailConfig,
-  describeSurfaceEmailConfigProblem,
-  describeSenderClaimNeutrally,
-  type EmailServiceDeps,
-  type SurfaceEmailConfigProblem,
-} from '@pellux/goodvibes-sdk/platform/email';
-import { nodeEmailTransport } from '@pellux/goodvibes-sdk/platform/email/node';
-
-/** The narrow slices this composition needs; the real managers satisfy them. */
-interface MailCompositionInput {
-  readonly configManager: { get(key: never): unknown };
-  readonly secretsManager: { get(key: string): Promise<string | null> };
-}
-
-/**
- * Build the mail deps and the not-configured describer that go to
- * `registerGatewayVerbGroups`.
- *
- * The settings come from the daemon's own `surfaces.email.*` keys through
- * `withSurfaceEmailConfig`, so the keys an operator has already set — and that
- * the settings modal now shows — keep working unchanged, and a not-configured
- * answer names the keys THIS operator actually has rather than the ones the
- * service validates internally.
- */
-export function composeMailDeps(input: MailCompositionInput): {
-  readonly emailServiceDeps: EmailServiceDeps;
-  readonly describeEmailConfigProblem: () => Promise<SurfaceEmailConfigProblem | null>;
-} {
-  const getConfig = (key: string): unknown => input.configManager.get(key as never);
-  const emailServiceDeps = withSurfaceEmailConfig({
-    getConfig,
-    secretsManager: input.secretsManager,
-    transport: nodeEmailTransport,
-    // The daemon has no wording of its own for a sender line, so it takes the
-    // platform's rather than growing a second implementation of a rule that is
-    // security-relevant: a From: header is a claim, sender authentication
-    // raises display confidence only, and commandAuthority is the literal
-    // 'none'.
-    describeSenderClaim: describeSenderClaimNeutrally,
-  } as never);
-  return {
-    emailServiceDeps,
-    describeEmailConfigProblem: () =>
-      describeSurfaceEmailConfigProblem(getConfig, input.secretsManager),
-  };
-}

package/src/runtime/memory-fold.ts

@@ -1,55 +0,0 @@
-import { join } from 'node:path';
-import {
-  foldMemoryStores,
-  formatMemoryFoldReport,
-  type LegacyMemorySource,
-  type MemoryEmbeddingProviderRegistry,
-  type MemoryFoldReport,
-  type MemoryStore,
-} from '@pellux/goodvibes-sdk/platform/state';
-
-/**
- * Fold the TUI's legacy per-project memory store into the canonical
- * cross-surface store. Called once at boot AFTER `memoryStore.init()` so records written
- * before unification survive. Id-keyed and idempotent — a re-run imports nothing new and
- * never deletes the legacy file. Returns the report so boot can log what moved.
- */
-export async function foldTuiLegacyMemory(
-  memoryStore: MemoryStore,
-  memoryEmbeddingRegistry: MemoryEmbeddingProviderRegistry,
-  workingDirectory: string,
-): Promise<MemoryFoldReport> {
-  const legacyTuiProject = join(workingDirectory, '.goodvibes', 'tui', 'memory.sqlite');
-  const sources: LegacyMemorySource[] = [
-    { label: `tui:${workingDirectory} (legacy per-project store)`, dbPath: legacyTuiProject },
-  ];
-  return foldMemoryStores(memoryStore, sources, { embeddingRegistry: memoryEmbeddingRegistry });
-}
-
-/** A minimal boot logger seam (matches the SDK logger's info/warn shape). */
-export interface BootFoldLogger {
-  info(message: string, meta?: unknown): void;
-  warn(message: string, meta?: unknown): void;
-}
-
-/**
- * Run the legacy TUI memory fold at boot and surface the report. Never blocks or
- * fails boot: a fold error degrades to a warn and the canonical store serves on.
- * Only logs the report when something actually moved (or a source failed), so a
- * clean boot stays quiet.
- */
-export async function runBootMemoryFold(
-  memoryStore: MemoryStore,
-  memoryEmbeddingRegistry: MemoryEmbeddingProviderRegistry,
-  workingDirectory: string,
-  log: BootFoldLogger,
-): Promise<void> {
-  try {
-    const report = await foldTuiLegacyMemory(memoryStore, memoryEmbeddingRegistry, workingDirectory);
-    if (report.totalImported > 0 || report.failedSources.length > 0) {
-      log.info(`[bootstrap] memory fold: ${formatMemoryFoldReport(report)}`);
-    }
-  } catch (err) {
-    log.warn('memory fold at bootstrap failed (non-fatal; canonical store unaffected)', { err });
-  }
-}

package/src/runtime/operator-token-cleanup.ts

@@ -1,109 +0,0 @@
-/**
- * operator-token-cleanup.ts
- *
- * Shared helper that enumerates the legacy workspace-scoped `operator-tokens.json`
- * locations the TUI has written at various pre-0.21.28 versions. Used by both the
- * in-process bootstrap path (`src/runtime/bootstrap.ts`) and the standalone daemon
- * CLI (`src/daemon/cli.ts`) so stale-token pruning has a single source of
- * truth for where to look.
- *
- * Adding a new legacy location: append to `workspaceOperatorTokenCandidates` and
- * the new path will be inspected on the next daemon boot.
- */
-
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { randomBytes } from 'node:crypto';
-import { dirname, join } from 'node:path';
-import { getOrCreateCompanionToken } from '@pellux/goodvibes-sdk/platform/pairing';
-import type { CompanionPairingResult } from '@pellux/goodvibes-sdk/platform/pairing';
-
-/**
- * Return the list of absolute operator-tokens.json paths the TUI may have written
- * at legacy (pre-0.21.28) workspace-scoped locations under `workingDirectory`.
- *
- * The canonical, current-SDK location is `<daemonHomeDir>/operator-tokens.json`;
- * this helper is strictly for legacy-cleanup candidates.
- */
-export function workspaceOperatorTokenCandidates(workingDirectory: string): readonly string[] {
-  return [
-    join(workingDirectory, '.goodvibes', 'operator-tokens.json'),
-    join(workingDirectory, '.goodvibes', 'tui', 'operator-tokens.json'),
-  ];
-}
-
-/**
- * External-daemon adoption: resolve the operator/companion
- * token this TUI process uses to authenticate with its daemon, honoring
- * `GOODVIBES_DAEMON_TOKEN` as a non-interactive override.
- *
- * Without this override, the only way to make a TUI instance adopt an
- * already-running external daemon that used an out-of-band or explicit token
- * (rather than one derived from `getOrCreateCompanionToken` under a *shared*
- * home directory) was to hand-write `<daemonHomeDir>/operator-tokens.json`
- * before startup — there was no env var or CLI flag equivalent.
- *
- * `GOODVIBES_DAEMON_TOKEN` is already the documented env var `bin/goodvibes-daemon`
- * honors for its own bearer token (see `src/daemon/cli.ts`'s `readDaemonCliTokens`)
- * and the one `src/verification/live-verifier.ts`'s `readDaemonToken` already falls
- * back to when probing a daemon's HTTP surface from the outside. Reusing the same
- * name here means one env var configures both sides of an adopted-daemon setup —
- * start the daemon with `GOODVIBES_DAEMON_TOKEN=<token>` and point the TUI at it
- * with the same `GOODVIBES_DAEMON_TOKEN=<token>` plus
- * `--config controlPlane.host=<host> --config controlPlane.port=<port>` — instead
- * of introducing a second, TUI-only flag.
- *
- * When the override is set and does not already match the on-disk record, the
- * file is rewritten so the override becomes durable for this home directory
- * (an existing peerId is kept when present, so companion-pairing identity does
- * not needlessly churn). Falls back to the existing `getOrCreateCompanionToken`
- * behavior — read the existing file, or mint a fresh random token — when the
- * override is unset.
- *
- * @param explicitToken - Takes precedence over `GOODVIBES_DAEMON_TOKEN` when
- * provided. Used by the onboarding wizard's "connect to an existing daemon"
- * action (a pasted token) so it shares this exact persistence logic with the
- * env-var path instead of duplicating it.
- */
-export function resolveDaemonCompanionToken(daemonHomeDir: string, explicitToken?: string): CompanionPairingResult {
-  const override = explicitToken?.trim() || process.env.GOODVIBES_DAEMON_TOKEN?.trim();
-  if (!override) return getOrCreateCompanionToken('tui', { daemonHomeDir });
-
-  const tokenPath = join(daemonHomeDir, 'operator-tokens.json');
-  let existingPeerId: string | undefined;
-  let existingCreatedAt: number | undefined;
-  if (existsSync(tokenPath)) {
-    try {
-      const record = JSON.parse(readFileSync(tokenPath, 'utf-8')) as {
-        token?: unknown;
-        peerId?: unknown;
-        createdAt?: unknown;
-      };
-      if (typeof record.token === 'string' && record.token === override) {
-        return {
-          token: override,
-          peerId: typeof record.peerId === 'string' ? record.peerId : randomBytes(12).toString('hex'),
-          createdAt: typeof record.createdAt === 'number' ? record.createdAt : Date.now(),
-        };
-      }
-      if (typeof record.peerId === 'string') existingPeerId = record.peerId;
-      if (typeof record.createdAt === 'number') existingCreatedAt = record.createdAt;
-    } catch {
-      // Malformed on-disk record — fall through and rewrite it with the override.
-    }
-  }
-
-  const record: CompanionPairingResult = {
-    token: override,
-    peerId: existingPeerId ?? randomBytes(12).toString('hex'),
-    createdAt: existingCreatedAt ?? Date.now(),
-  };
-  try {
-    mkdirSync(dirname(tokenPath), { recursive: true });
-    writeFileSync(tokenPath, JSON.stringify(record, null, 2), { encoding: 'utf-8', mode: 0o600 });
-    chmodSync(tokenPath, 0o600);
-  } catch {
-    // Best-effort persistence — the override still applies for this process
-    // even if the file could not be written (e.g. a read-only home directory).
-  }
-  return record;
-}