@pellux/goodvibes-agent 0.1.83 → 0.1.84

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.84 - 2026-06-01
+
+- 35dbf3d Show live external runtime status
+
+## Unreleased
+
+- Foregrounded live external-runtime reachability, SDK compatibility, operator-token state, and isolated Agent Knowledge readiness in `status`/`doctor` output.
+- Removed the deprecated `actions/cache@v4` setup step so future CI/CD runs avoid Node 20 deprecation annotations from the shared workflow setup action.
+
 ## 0.1.83 - 2026-06-01
 
 - f5099c1 Hide runtime-owned settings from Agent workspace

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.83",
+  "version": "0.1.84",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/cli/entrypoint.ts

@@ -22,6 +22,7 @@ import {
   renderOnboardingCliStatus,
 } from './index.ts';
 import { buildCliServicePosture } from './service-posture.ts';
+import { inspectCliExternalRuntime } from './external-runtime.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { resolveAgentRuntimeProfileHome } from '../agent/runtime-profile.ts';
 
@@ -147,6 +148,10 @@ export async function prepareShellCliRuntime(
       workingDirectory: bootstrapWorkingDir,
       homeDirectory: bootstrapHomeDirectory,
     });
+    const externalRuntime = await inspectCliExternalRuntime({
+      configManager,
+      homeDirectory: bootstrapHomeDirectory,
+    });
     const statusOptions = {
       configManager,
       workingDirectory: bootstrapWorkingDir,
@@ -161,6 +166,7 @@ export async function prepareShellCliRuntime(
         operatorTokenPresent: existsSync(operatorTokenPath),
       },
       service,
+      externalRuntime,
       doctor: cli.command === 'doctor',
       outputFormat: cli.flags.outputFormat,
     };

package/src/cli/external-runtime.ts

@@ -0,0 +1,195 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { SDK_VERSION } from '../version.ts';
+
+type JsonRecord = Record<string, unknown>;
+
+export interface CliExternalRuntimeInspectionOptions {
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly homeDirectory: string;
+  readonly timeoutMs?: number;
+}
+
+export interface CliExternalRuntimeSnapshot {
+  readonly baseUrl: string;
+  readonly statusCode: number | null;
+  readonly reachable: boolean;
+  readonly version: string;
+  readonly expectedVersion: string;
+  readonly compatible: boolean;
+  readonly operatorToken: {
+    readonly present: boolean;
+    readonly path: string;
+  };
+  readonly agentKnowledge: {
+    readonly route: '/api/goodvibes-agent/knowledge/status';
+    readonly ready: boolean;
+    readonly kind: 'ok' | 'auth_required' | 'daemon_unavailable' | 'version_mismatch' | 'route_unavailable' | 'runtime_error';
+    readonly statusCode: number | null;
+  };
+  readonly error: string | null;
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readString(record: JsonRecord | null, key: string): string | null {
+  const value = record?.[key];
+  return typeof value === 'string' ? value : null;
+}
+
+function resolveBaseUrl(configManager: Pick<ConfigManager, 'get'>): string {
+  const host = String(configManager.get('controlPlane.host') ?? '127.0.0.1');
+  const port = Number(configManager.get('controlPlane.port') ?? 3421);
+  return `http://${host}:${Number.isFinite(port) ? port : 3421}`;
+}
+
+function readOperatorToken(homeDirectory: string): { readonly token: string | null; readonly path: string } {
+  const path = join(homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  if (!existsSync(path)) return { token: null, path };
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+    const token = isRecord(parsed) && typeof parsed.token === 'string' ? parsed.token : null;
+    return { token, path };
+  } catch {
+    return { token: null, path };
+  }
+}
+
+async function fetchJson(
+  url: string,
+  token: string | null,
+  timeoutMs: number,
+): Promise<{ readonly ok: boolean; readonly status: number; readonly body: unknown }> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      headers: token ? { authorization: `Bearer ${token}` } : undefined,
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    let body: unknown = text;
+    if (text.trim().length > 0) {
+      try {
+        body = JSON.parse(text) as unknown;
+      } catch {
+        body = text;
+      }
+    }
+    return { ok: response.ok, status: response.status, body };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function inspectCliExternalRuntime(
+  options: CliExternalRuntimeInspectionOptions,
+): Promise<CliExternalRuntimeSnapshot> {
+  const baseUrl = resolveBaseUrl(options.configManager);
+  const token = readOperatorToken(options.homeDirectory);
+  const timeoutMs = options.timeoutMs ?? 1500;
+  const route = '/api/goodvibes-agent/knowledge/status' as const;
+
+  try {
+    const status = await fetchJson(`${baseUrl}/status`, token.token, timeoutMs);
+    const statusRecord = isRecord(status.body) ? status.body : {};
+    const version = readString(statusRecord, 'version') ?? 'unknown';
+    const compatible = status.ok && version === SDK_VERSION;
+
+    if (!status.ok) {
+      return {
+        baseUrl,
+        statusCode: status.status,
+        reachable: false,
+        version,
+        expectedVersion: SDK_VERSION,
+        compatible: false,
+        operatorToken: { present: Boolean(token.token), path: token.path },
+        agentKnowledge: {
+          route,
+          ready: false,
+          kind: status.status === 401 ? 'auth_required' : 'daemon_unavailable',
+          statusCode: status.status,
+        },
+        error: typeof status.body === 'string' ? status.body : `HTTP ${status.status}`,
+      };
+    }
+
+    if (!token.token) {
+      return {
+        baseUrl,
+        statusCode: status.status,
+        reachable: true,
+        version,
+        expectedVersion: SDK_VERSION,
+        compatible,
+        operatorToken: { present: false, path: token.path },
+        agentKnowledge: {
+          route,
+          ready: false,
+          kind: 'auth_required',
+          statusCode: null,
+        },
+        error: null,
+      };
+    }
+
+    if (!compatible) {
+      return {
+        baseUrl,
+        statusCode: status.status,
+        reachable: true,
+        version,
+        expectedVersion: SDK_VERSION,
+        compatible: false,
+        operatorToken: { present: true, path: token.path },
+        agentKnowledge: {
+          route,
+          ready: false,
+          kind: 'version_mismatch',
+          statusCode: null,
+        },
+        error: null,
+      };
+    }
+
+    const knowledge = await fetchJson(`${baseUrl}${route}`, token.token, timeoutMs);
+    return {
+      baseUrl,
+      statusCode: status.status,
+      reachable: true,
+      version,
+      expectedVersion: SDK_VERSION,
+      compatible,
+      operatorToken: { present: true, path: token.path },
+      agentKnowledge: {
+        route,
+        ready: knowledge.ok,
+        kind: knowledge.ok ? 'ok' : knowledge.status === 401 ? 'auth_required' : knowledge.status === 404 ? 'route_unavailable' : 'runtime_error',
+        statusCode: knowledge.status,
+      },
+      error: knowledge.ok ? null : typeof knowledge.body === 'string' ? knowledge.body : `HTTP ${knowledge.status}`,
+    };
+  } catch (error) {
+    return {
+      baseUrl,
+      statusCode: null,
+      reachable: false,
+      version: 'unknown',
+      expectedVersion: SDK_VERSION,
+      compatible: false,
+      operatorToken: { present: Boolean(token.token), path: token.path },
+      agentKnowledge: {
+        route,
+        ready: false,
+        kind: 'daemon_unavailable',
+        statusCode: null,
+      },
+      error: summarizeError(error),
+    };
+  }
+}

package/src/cli/index.ts

@@ -2,6 +2,7 @@ export * from './types.ts';
 export * from './parser.ts';
 export * from './help.ts';
 export * from './status.ts';
+export * from './external-runtime.ts';
 export * from './completion.ts';
 export * from './config-overrides.ts';
 export * from './endpoints.ts';

package/src/cli/status.ts

@@ -4,6 +4,7 @@ import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import { isNetworkFacing } from './network-posture.ts';
 import type { GoodVibesCliOutputFormat } from './types.ts';
 import type { CliServicePosture } from './service-posture.ts';
+import type { CliExternalRuntimeSnapshot } from './external-runtime.ts';
 import { getProviderIdFromModel } from '../config/provider-model.ts';
 
 export interface CliStatusOptions {
@@ -13,6 +14,7 @@ export interface CliStatusOptions {
   readonly onboardingMarkers?: OnboardingCheckMarkersState;
   readonly auth?: CliAuthStatus;
   readonly service?: CliServicePosture;
+  readonly externalRuntime?: CliExternalRuntimeSnapshot;
   readonly doctor?: boolean;
   readonly outputFormat?: GoodVibesCliOutputFormat;
 }
@@ -58,6 +60,7 @@ export interface CliStatusSnapshot {
     readonly restartOnFailure: unknown;
     readonly lifecycle?: CliServicePosture;
   };
+  readonly externalRuntime: CliExternalRuntimeSnapshot | null;
   readonly runtimeEndpoints: {
     readonly controlPlane: ReturnType<typeof resolveRuntimeEndpointBinding> & { readonly enabled: unknown };
     readonly httpListener: ReturnType<typeof resolveRuntimeEndpointBinding> & { readonly enabled: unknown };
@@ -117,6 +120,54 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
 
   const findings: CliDoctorFinding[] = [];
 
+  if (options.externalRuntime) {
+    if (!options.externalRuntime.reachable) {
+      findings.push({
+        id: 'external-runtime-unreachable',
+        area: 'runtime',
+        severity: 'warning',
+        summary: 'External GoodVibes runtime is not reachable.',
+        cause: `Agent could not reach ${options.externalRuntime.baseUrl}${options.externalRuntime.error ? `: ${options.externalRuntime.error}` : '.'}`,
+        impact: 'Companion chat, isolated Agent Knowledge, approvals, automation status, and build delegation cannot work until the external runtime is available.',
+        action: 'Start or repair the runtime-owning GoodVibes TUI/host, then rerun goodvibes-agent status.',
+      });
+    } else if (!options.externalRuntime.compatible) {
+      findings.push({
+        id: 'external-runtime-version-mismatch',
+        area: 'runtime',
+        severity: 'warning',
+        summary: 'External GoodVibes runtime SDK version does not match Agent.',
+        cause: `Runtime reports SDK ${options.externalRuntime.version}; Agent expects ${options.externalRuntime.expectedVersion}.`,
+        impact: 'Agent-only routes, especially isolated Agent Knowledge, may be missing or incompatible.',
+        action: 'Update/restart the runtime-owning GoodVibes TUI/host so /status matches this Agent package SDK pin.',
+      });
+    }
+
+    if (!options.externalRuntime.operatorToken.present) {
+      findings.push({
+        id: 'external-runtime-token-missing',
+        area: 'auth',
+        severity: 'warning',
+        summary: 'External runtime operator token is missing.',
+        cause: `No operator token was found at ${options.externalRuntime.operatorToken.path}.`,
+        impact: 'Agent can inspect only unauthenticated routes and cannot use protected runtime APIs.',
+        action: 'Pair or provision access through the runtime-owning GoodVibes TUI/host, then rerun goodvibes-agent auth.',
+      });
+    }
+
+    if (options.externalRuntime.reachable && options.externalRuntime.operatorToken.present && !options.externalRuntime.agentKnowledge.ready) {
+      findings.push({
+        id: 'agent-knowledge-route-not-ready',
+        area: 'runtime',
+        severity: 'warning',
+        summary: 'Isolated Agent Knowledge route is not ready.',
+        cause: `${options.externalRuntime.agentKnowledge.route} returned ${options.externalRuntime.agentKnowledge.kind}${options.externalRuntime.agentKnowledge.statusCode === null ? '' : ` (${options.externalRuntime.agentKnowledge.statusCode})`}.`,
+        impact: 'Agent Knowledge ask/search will not use any fallback wiki or HomeGraph segment; it will fail closed until the Agent route is available.',
+        action: 'Update/restart the external runtime to the Agent-compatible SDK and verify goodvibes-agent compat.',
+      });
+    }
+  }
+
   if (serverBackedEnabled && !serviceEnabled) {
     findings.push({
       id: 'runtime-ownership-external',
@@ -272,6 +323,7 @@ export function buildCliStatusSnapshot(options: CliStatusOptions): CliStatusSnap
       restartOnFailure: config.get('service.restartOnFailure'),
       ...(options.service ? { lifecycle: options.service } : {}),
     },
+    externalRuntime: options.externalRuntime ?? null,
     runtimeEndpoints: {
       controlPlane: { enabled: config.get('controlPlane.enabled'), ...controlPlaneBinding },
       httpListener: { enabled: config.get('danger.httpListener'), ...httpListenerBinding },
@@ -300,6 +352,7 @@ export function renderCliStatus(options: CliStatusOptions): string {
   const webBinding = snapshot.runtimeEndpoints.web;
   const marker = options.onboardingMarkers?.effective;
   const findings = snapshot.findings;
+  const externalRuntime = snapshot.externalRuntime;
 
   if (options.outputFormat === 'json') return JSON.stringify(snapshot, null, 2);
 
@@ -326,7 +379,21 @@ export function renderCliStatus(options: CliStatusOptions): string {
       ? `  operatorTokens: ${options.auth.operatorTokenPresent ? 'present' : 'missing'} (${options.auth.operatorTokenPath})`
       : '  operatorTokens: unknown',
     '',
-    'External Runtime Connection:',
+    'External Runtime:',
+    ...(externalRuntime ? [
+      `  baseUrl: ${externalRuntime.baseUrl}`,
+      `  reachable: ${yesNo(externalRuntime.reachable)}${externalRuntime.statusCode === null ? '' : ` (HTTP ${externalRuntime.statusCode})`}`,
+      `  sdk: ${externalRuntime.version} expected ${externalRuntime.expectedVersion}`,
+      `  compatible: ${yesNo(externalRuntime.compatible)}`,
+      `  operatorToken: ${externalRuntime.operatorToken.present ? 'present' : 'missing'} (${externalRuntime.operatorToken.path})`,
+      `  Agent Knowledge: ${externalRuntime.agentKnowledge.ready ? 'ready' : `not ready (${externalRuntime.agentKnowledge.kind})`}`,
+      ...(externalRuntime.error ? [`  error: ${externalRuntime.error}`] : []),
+    ] : [
+      '  live check: unavailable',
+    ]),
+    '',
+    'External Runtime Ownership:',
+    `  owner: external GoodVibes runtime host`,
     `  hostConfigEnabled: ${yesNo(serviceEnabled)}`,
     `  hostAutostart: ${yesNo(serviceAutostart)}`,
     `  hostRestartOnFailure: ${yesNo(restartOnFailure)}`,

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.83';
+let _version = '0.1.84';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {