@pellux/goodvibes-tui 0.19.23 → 0.19.25

package/src/cli/parser.ts

@@ -0,0 +1,367 @@
+import type {
+  GoodVibesCliCommand,
+  GoodVibesCliFlags,
+  GoodVibesCliOutputFormat,
+  GoodVibesCliParseResult,
+} from './types.ts';
+
+const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
+  tui: 'tui',
+  app: 'tui',
+  run: 'run',
+  exec: 'run',
+  e: 'run',
+  serve: 'serve',
+  daemon: 'serve',
+  server: 'serve',
+  web: 'web',
+  status: 'status',
+  doctor: 'doctor',
+  onboarding: 'onboarding',
+  setup: 'onboarding',
+  models: 'models',
+  model: 'models',
+  providers: 'providers',
+  provider: 'providers',
+  auth: 'auth',
+  subscription: 'subscription',
+  subscriptions: 'subscription',
+  secrets: 'secrets',
+  secret: 'secrets',
+  sessions: 'sessions',
+  session: 'sessions',
+  tasks: 'tasks',
+  task: 'tasks',
+  pair: 'pair',
+  qrcode: 'pair',
+  qr: 'pair',
+  surfaces: 'surfaces',
+  surface: 'surfaces',
+  listener: 'listener',
+  'http-listener': 'listener',
+  webhook: 'listener',
+  'control-plane': 'control-plane',
+  controlplane: 'control-plane',
+  cp: 'control-plane',
+  bundle: 'bundle',
+  bundles: 'bundle',
+  remote: 'remote',
+  bridge: 'bridge',
+  completion: 'completion',
+  completions: 'completion',
+  help: 'help',
+  version: 'version',
+};
+
+function createDefaultFlags(): GoodVibesCliFlags {
+  return {
+    provider: undefined,
+    model: undefined,
+    daemonHome: undefined,
+    workingDir: undefined,
+    help: false,
+    version: false,
+    prompt: undefined,
+    print: false,
+    outputFormat: 'text',
+    configOverrides: [],
+    enableFeatures: [],
+    disableFeatures: [],
+    noAltScreen: false,
+    port: undefined,
+    hostname: undefined,
+    open: false,
+    continueLast: false,
+    resume: undefined,
+    session: undefined,
+    fork: false,
+    rawOutput: false,
+    acceptRawOutputRisk: false,
+  };
+}
+
+function splitOption(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),
+  };
+}
+
+function getValue(
+  argv: readonly string[],
+  index: number,
+  inlineValue: string | undefined,
+  optionName: string,
+  errors: string[],
+): { readonly value: string | undefined; readonly nextIndex: number } {
+  if (inlineValue !== undefined) return { value: inlineValue, nextIndex: index };
+  const next = argv[index + 1];
+  if (next === undefined || (next.startsWith('-') && next !== '-')) {
+    errors.push(`${optionName} requires a value.`);
+    return { value: undefined, nextIndex: index };
+  }
+  return { value: next, nextIndex: index + 1 };
+}
+
+function getOptionalValue(
+  argv: readonly string[],
+  index: number,
+  inlineValue: string | undefined,
+): { readonly value: string | undefined; readonly nextIndex: number } {
+  if (inlineValue !== undefined) return { value: inlineValue, nextIndex: index };
+  const next = argv[index + 1];
+  if (next === undefined || next.startsWith('-')) return { value: undefined, nextIndex: index };
+  return { value: next, nextIndex: index + 1 };
+}
+
+function parsePort(value: string | undefined, optionName: string, errors: string[]): number | undefined {
+  if (value === undefined) return undefined;
+  if (!/^\d+$/.test(value)) {
+    errors.push(`${optionName} must be a port number from 1 to 65535.`);
+    return undefined;
+  }
+  const port = Number.parseInt(value, 10);
+  if (port < 1 || port > 65535) {
+    errors.push(`${optionName} must be a port number from 1 to 65535.`);
+    return undefined;
+  }
+  return port;
+}
+
+function normalizeOutputFormat(value: string | undefined, errors: string[]): GoodVibesCliOutputFormat {
+  if (value === 'text' || value === 'json' || value === 'stream-json') return value;
+  errors.push('--output-format must be one of: text, json, stream-json.');
+  return 'text';
+}
+
+function inferProviderFromModel(model: string, currentProvider: string | undefined): string | undefined {
+  if (currentProvider !== undefined) return currentProvider;
+  if (model.includes(':')) return model.split(':')[0];
+  if (model.includes('/')) return model.split('/')[0];
+  return undefined;
+}
+
+function withFlag<K extends keyof GoodVibesCliFlags>(
+  flags: GoodVibesCliFlags,
+  key: K,
+  value: GoodVibesCliFlags[K],
+): GoodVibesCliFlags {
+  return { ...flags, [key]: value };
+}
+
+function appendFlagArray<K extends 'configOverrides' | 'enableFeatures' | 'disableFeatures'>(
+  flags: GoodVibesCliFlags,
+  key: K,
+  value: string,
+): GoodVibesCliFlags {
+  return {
+    ...flags,
+    [key]: [...flags[key], value],
+  };
+}
+
+export function parseGoodVibesCli(
+  argv: readonly string[],
+  binary = 'goodvibes',
+): GoodVibesCliParseResult {
+  let flags = createDefaultFlags();
+  let command: GoodVibesCliCommand = 'tui';
+  let rawCommand: string | undefined;
+  const commandArgs: string[] = [];
+  const positionals: string[] = [];
+  const errors: string[] = [];
+  let sawCommand = false;
+  let passthrough = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index]!;
+
+    if (passthrough) {
+      if (sawCommand) commandArgs.push(token);
+      else positionals.push(token);
+      continue;
+    }
+
+    if (token === '--') {
+      passthrough = true;
+      continue;
+    }
+
+    if (!token.startsWith('-') || token === '-') {
+      if (!sawCommand) {
+        const normalized = COMMAND_ALIASES[token.toLowerCase()];
+        if (normalized) {
+          command = normalized;
+          rawCommand = token;
+          sawCommand = true;
+          continue;
+        }
+      }
+      positionals.push(token);
+      if (sawCommand) commandArgs.push(token);
+      continue;
+    }
+
+    const { name, value: inlineValue } = splitOption(token);
+
+    if (name === '--help' || name === '-h') {
+      flags = withFlag(flags, 'help', true);
+      continue;
+    }
+    if (name === '--version' || name === '-v') {
+      flags = withFlag(flags, 'version', true);
+      continue;
+    }
+    if (name === '--print') {
+      flags = withFlag(flags, 'print', true);
+      if (!sawCommand) command = 'run';
+      continue;
+    }
+    if (name === '--json') {
+      flags = withFlag(flags, 'outputFormat', 'json');
+      continue;
+    }
+    if (name === '--no-alt-screen') {
+      flags = withFlag(flags, 'noAltScreen', true);
+      continue;
+    }
+    if (name === '--open') {
+      flags = withFlag(flags, 'open', true);
+      continue;
+    }
+    if (name === '--continue') {
+      flags = withFlag(flags, 'continueLast', true);
+      continue;
+    }
+    if (name === '--fork') {
+      flags = withFlag(flags, 'fork', true);
+      continue;
+    }
+    if (name === '--raw-output') {
+      flags = withFlag(flags, 'rawOutput', true);
+      continue;
+    }
+    if (name === '--accept-raw-output-risk') {
+      flags = withFlag(flags, 'acceptRawOutputRisk', true);
+      continue;
+    }
+
+    if (name === '--provider') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = withFlag(flags, 'provider', consumed.value);
+      continue;
+    }
+    if (name === '--model' || name === '-m') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) {
+        flags = withFlag(flags, 'model', consumed.value);
+        flags = withFlag(flags, 'provider', inferProviderFromModel(consumed.value, flags.provider));
+      }
+      continue;
+    }
+    if (name === '--daemon-home') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = withFlag(flags, 'daemonHome', consumed.value);
+      continue;
+    }
+    if (name === '--working-dir' || name === '--cd' || name === '-C') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = withFlag(flags, 'workingDir', consumed.value);
+      continue;
+    }
+    if (name === '--prompt' || name === '-p') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) {
+        flags = withFlag(flags, 'prompt', consumed.value);
+        if (!sawCommand) command = 'run';
+      }
+      continue;
+    }
+    if (name === '--output-format' || name === '--output' || name === '-o') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      flags = withFlag(flags, 'outputFormat', normalizeOutputFormat(consumed.value, errors));
+      continue;
+    }
+    if (name === '--config') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = appendFlagArray(flags, 'configOverrides', consumed.value);
+      continue;
+    }
+    if (name === '-c') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = appendFlagArray(flags, 'configOverrides', consumed.value);
+      continue;
+    }
+    if (name === '--enable') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = appendFlagArray(flags, 'enableFeatures', consumed.value);
+      continue;
+    }
+    if (name === '--disable') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = appendFlagArray(flags, 'disableFeatures', consumed.value);
+      continue;
+    }
+    if (name === '--port') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      flags = withFlag(flags, 'port', parsePort(consumed.value, name, errors));
+      continue;
+    }
+    if (name === '--hostname' || name === '--host') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = withFlag(flags, 'hostname', consumed.value);
+      continue;
+    }
+    if (name === '--resume' || name === '-r') {
+      const consumed = getOptionalValue(argv, index, inlineValue);
+      index = consumed.nextIndex;
+      flags = withFlag(flags, 'resume', consumed.value ?? 'latest');
+      continue;
+    }
+    if (name === '--session' || name === '-s') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = withFlag(flags, 'session', consumed.value);
+      continue;
+    }
+
+    if (sawCommand) {
+      commandArgs.push(token);
+      continue;
+    }
+
+    errors.push(`Unknown option: ${name}`);
+  }
+
+  if (flags.prompt === undefined && (command === 'run' || flags.print) && positionals.length > 0) {
+    flags = withFlag(flags, 'prompt', positionals.join(' '));
+  }
+
+  if (rawCommand !== undefined && command === 'unknown') {
+    errors.push(`Unknown command: ${rawCommand}`);
+  }
+
+  return {
+    binary,
+    command,
+    rawCommand,
+    commandArgs,
+    positionals,
+    flags,
+    errors,
+  };
+}

package/src/cli/status.ts

@@ -0,0 +1,112 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
+import type { OnboardingCompletionMarkersState } from '../runtime/onboarding/index.ts';
+import { resolveRuntimeEndpointBinding } from './endpoints.ts';
+
+export interface CliStatusOptions {
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly workingDirectory: string;
+  readonly homeDirectory: string;
+  readonly onboardingMarkers?: OnboardingCompletionMarkersState;
+  readonly auth?: CliAuthStatus;
+  readonly doctor?: boolean;
+}
+
+export interface CliAuthStatus {
+  readonly userStorePath: string;
+  readonly userStorePresent: boolean;
+  readonly bootstrapCredentialPath: string;
+  readonly bootstrapCredentialPresent: boolean;
+  readonly operatorTokenPath: string;
+  readonly operatorTokenPresent: boolean;
+}
+
+function yesNo(value: unknown): string {
+  return value === true ? 'yes' : 'no';
+}
+
+function bindLine(label: string, enabled: unknown, binding: { readonly hostMode: string; readonly host: string; readonly port: number }): string {
+  return `  ${label}: ${yesNo(enabled)} (${binding.hostMode} ${binding.host}:${binding.port})`;
+}
+
+export function renderCliStatus(options: CliStatusOptions): string {
+  const config = options.configManager;
+  const serviceEnabled = config.get('service.enabled');
+  const serviceAutostart = config.get('service.autostart');
+  const restartOnFailure = config.get('service.restartOnFailure');
+  const daemonEnabled = config.get('danger.daemon');
+  const listenerEnabled = config.get('danger.httpListener');
+  const webEnabled = config.get('web.enabled');
+  const controlPlaneEnabled = config.get('controlPlane.enabled');
+  const controlPlaneBinding = resolveRuntimeEndpointBinding(config, 'controlPlane');
+  const httpListenerBinding = resolveRuntimeEndpointBinding(config, 'httpListener');
+  const webBinding = resolveRuntimeEndpointBinding(config, 'web');
+  const marker = options.onboardingMarkers?.effective;
+  const warnings: string[] = [];
+
+  if ((daemonEnabled || controlPlaneEnabled || listenerEnabled || webEnabled) && !serviceEnabled) {
+    warnings.push('server-backed surfaces are enabled but service.enabled is off');
+  }
+  if (serviceEnabled && !serviceAutostart) warnings.push('service.enabled is on but service.autostart is off');
+  if (serviceEnabled && !restartOnFailure) warnings.push('service.enabled is on but service.restartOnFailure is off');
+  if (!marker?.payload) warnings.push('onboarding has not been completed for this user/project');
+
+  const lines = [
+    options.doctor ? 'GoodVibes doctor' : 'GoodVibes status',
+    `  workingDir: ${options.workingDirectory}`,
+    `  homeDir: ${options.homeDirectory}`,
+    '',
+    'Provider:',
+    `  provider: ${String(config.get('provider.provider'))}`,
+    `  model: ${String(config.get('provider.model'))}`,
+    `  reasoning: ${String(config.get('provider.reasoningEffort'))}`,
+    '',
+    'Auth:',
+    `  permissions: ${String(config.get('permissions.mode'))}`,
+    `  secretPolicy: ${String(config.get('storage.secretPolicy'))}`,
+    options.auth
+      ? `  localUsers: ${options.auth.userStorePresent ? 'present' : 'missing'} (${options.auth.userStorePath})`
+      : '  localUsers: unknown',
+    options.auth
+      ? `  bootstrapCredential: ${options.auth.bootstrapCredentialPresent ? 'present' : 'missing'} (${options.auth.bootstrapCredentialPath})`
+      : '  bootstrapCredential: unknown',
+    options.auth
+      ? `  operatorTokens: ${options.auth.operatorTokenPresent ? 'present' : 'missing'} (${options.auth.operatorTokenPath})`
+      : '  operatorTokens: unknown',
+    '',
+    'Service:',
+    `  enabled: ${yesNo(serviceEnabled)}`,
+    `  autostart: ${yesNo(serviceAutostart)}`,
+    `  restartOnFailure: ${yesNo(restartOnFailure)}`,
+    '',
+    'Surfaces:',
+    bindLine('controlPlane', controlPlaneEnabled, controlPlaneBinding),
+    bindLine('httpListener', listenerEnabled, httpListenerBinding),
+    bindLine('web', webEnabled, webBinding),
+    '',
+    'Onboarding:',
+    `  completed: ${marker?.payload ? 'yes' : 'no'}`,
+    `  scope: ${marker?.scope ?? 'none'}`,
+    `  updatedAt: ${marker?.payload ? new Date(marker.payload.updatedAt).toISOString() : 'n/a'}`,
+  ];
+
+  if (options.doctor) {
+    lines.push('', 'Warnings:');
+    if (warnings.length === 0) lines.push('  none');
+    else lines.push(...warnings.map((warning) => `  - ${warning}`));
+  }
+
+  return lines.join('\n');
+}
+
+export function renderOnboardingCliStatus(options: CliStatusOptions): string {
+  const marker = options.onboardingMarkers?.effective;
+  return [
+    'GoodVibes onboarding status',
+    `  completed: ${marker?.payload ? 'yes' : 'no'}`,
+    `  scope: ${marker?.scope ?? 'none'}`,
+    `  source: ${marker?.payload?.source ?? 'n/a'}`,
+    `  mode: ${marker?.payload?.mode ?? 'n/a'}`,
+    `  updatedAt: ${marker?.payload ? new Date(marker.payload.updatedAt).toISOString() : 'n/a'}`,
+    `  workingDir: ${options.workingDirectory}`,
+  ].join('\n');
+}

package/src/cli/tui-startup.ts

@@ -0,0 +1,32 @@
+import type { CommandContext, CommandRegistry } from '../input/command-registry.ts';
+import type { InputHandler } from '../input/handler.ts';
+import { readOnboardingCompletionMarkers } from '../runtime/onboarding/index.ts';
+import type { GoodVibesCliParseResult } from './types.ts';
+
+export function applyInitialTuiCliState(options: {
+  readonly cli: GoodVibesCliParseResult;
+  readonly input: InputHandler;
+  readonly commandRegistry: CommandRegistry;
+  readonly commandContext: CommandContext;
+  readonly shellPaths: Parameters<typeof readOnboardingCompletionMarkers>[0];
+  readonly render: () => void;
+}): void {
+  const { cli, input, commandRegistry, commandContext, shellPaths, render } = options;
+  const onboardingMarkers = readOnboardingCompletionMarkers(shellPaths);
+  if (cli.command === 'onboarding') {
+    input.openOnboardingWizard({ mode: 'edit', reset: true });
+  } else if (cli.command === 'sessions' && cli.commandArgs[0] === 'resume') {
+    const target = cli.commandArgs.slice(1).join(' ').trim();
+    if (target) {
+      void commandRegistry.execute('session', ['resume', target], commandContext).then(() => render());
+    }
+  } else if (!onboardingMarkers.effective?.payload) {
+    input.openOnboardingWizard({ mode: 'new', reset: true });
+  }
+
+  const seededPrompt = cli.flags.prompt ?? (cli.rawCommand === undefined && cli.positionals.length > 0 ? cli.positionals.join(' ') : undefined);
+  if (seededPrompt) {
+    input.prompt = seededPrompt;
+    input.cursorPos = seededPrompt.length;
+  }
+}

package/src/cli/types.ts

@@ -0,0 +1,63 @@
+export type GoodVibesCliCommand =
+  | 'tui'
+  | 'run'
+  | 'serve'
+  | 'web'
+  | 'status'
+  | 'doctor'
+  | 'onboarding'
+  | 'models'
+  | 'providers'
+  | 'auth'
+  | 'subscription'
+  | 'secrets'
+  | 'sessions'
+  | 'tasks'
+  | 'pair'
+  | 'surfaces'
+  | 'listener'
+  | 'control-plane'
+  | 'bundle'
+  | 'remote'
+  | 'bridge'
+  | 'completion'
+  | 'help'
+  | 'version'
+  | 'unknown';
+
+export type GoodVibesCliOutputFormat = 'text' | 'json' | 'stream-json';
+
+export interface GoodVibesCliFlags {
+  readonly provider: string | undefined;
+  readonly model: string | undefined;
+  readonly daemonHome: string | undefined;
+  readonly workingDir: string | undefined;
+  readonly help: boolean;
+  readonly version: boolean;
+  readonly prompt: string | undefined;
+  readonly print: boolean;
+  readonly outputFormat: GoodVibesCliOutputFormat;
+  readonly configOverrides: readonly string[];
+  readonly enableFeatures: readonly string[];
+  readonly disableFeatures: readonly string[];
+  readonly noAltScreen: boolean;
+  readonly port: number | undefined;
+  readonly hostname: string | undefined;
+  readonly open: boolean;
+  readonly continueLast: boolean;
+  readonly resume: string | undefined;
+  readonly session: string | undefined;
+  readonly fork: boolean;
+  readonly rawOutput: boolean;
+  readonly acceptRawOutputRisk: boolean;
+}
+
+export interface GoodVibesCliParseResult {
+  readonly binary: string;
+  readonly command: GoodVibesCliCommand;
+  readonly rawCommand: string | undefined;
+  readonly commandArgs: readonly string[];
+  readonly positionals: readonly string[];
+  readonly flags: GoodVibesCliFlags;
+  readonly errors: readonly string[];
+}

package/src/cli-flags.ts

@@ -1,58 +1,20 @@
-// ---------------------------------------------------------------------------
-// Shared CLI flag parsing for TUI shell and daemon entrypoints.
-// ---------------------------------------------------------------------------
+// Compatibility wrapper for older imports. New CLI code lives in src/cli.
+export type { GoodVibesCliFlags as CliFlags } from './cli/types.ts';
+export {
+  applyRuntimeConfigOverrides,
+  applyRuntimeConfigValue,
+  applyRuntimeCommandEndpointFlagOverrides,
+  applyRuntimeEndpointFlagOverrides,
+  applyRuntimeFeatureFlagOverrides,
+  handleGoodVibesCliCommand,
+  parseGoodVibesCli,
+  renderGoodVibesHelp,
+  renderGoodVibesVersion,
+} from './cli/index.ts';
 
-export type CliFlags = {
-  readonly provider: string | undefined;
-  readonly model: string | undefined;
-  readonly daemonHome: string | undefined;
-  readonly workingDir: string | undefined;
-};
+import { parseGoodVibesCli } from './cli/parser.ts';
+import type { GoodVibesCliFlags } from './cli/types.ts';
 
-/**
- * Parse `--provider` / `--model` / `--daemon-home` / `--working-dir` / `--help` flags from an argv slice.
- *
- * @param argv   - argv array (pass `process.argv.slice(2)`)
- * @param binary - binary name shown in the --help usage line (e.g. "goodvibes" or "goodvibes-daemon")
- */
-export function parseCliFlags(argv: readonly string[], binary = 'goodvibes'): CliFlags {
-  let provider: string | undefined;
-  let model: string | undefined;
-  let daemonHome: string | undefined;
-  let workingDir: string | undefined;
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === '--help' || arg === '-h') {
-      // eslint-disable-next-line no-console
-      console.log([
-        `Usage: ${binary} [options]`,
-        '',
-        'Options:',
-        '  --provider <id>          Override the provider from settings.json at startup',
-        '  --model <registryKey>    Override the model from settings.json at startup',
-        '                           Format: provider:modelId (e.g. inception:mercury-2)',
-        '                           If provider:modelId format is used, --provider is inferred',
-        '  --daemon-home=<path>     Override daemon home (precedence: flag > GOODVIBES_DAEMON_HOME env > ~/.goodvibes/daemon)',
-        '  --working-dir=<path>     Override working directory (precedence: flag > GOODVIBES_WORKING_DIR env > <cwd>)',
-        '  --help, -h               Show this help message',
-      ].join('\n'));
-      process.exit(0);
-    }
-    if (arg === '--provider' && argv[i + 1] !== undefined) {
-      provider = argv[++i];
-    } else if (arg === '--model' && argv[i + 1] !== undefined) {
-      model = argv[++i];
-      // Infer provider from registryKey format (provider:modelId) if --provider not given
-      if (typeof model === 'string' && model.includes(':') && provider === undefined) {
-        provider = model.split(':')[0];
-      }
-    } else if (arg.startsWith('--daemon-home=')) {
-      daemonHome = arg.slice('--daemon-home='.length);
-    } else if (arg.startsWith('--working-dir=')) {
-      workingDir = arg.slice('--working-dir='.length);
-    }
-  }
-
-  return { provider, model, daemonHome, workingDir };
+export function parseCliFlags(argv: readonly string[], binary = 'goodvibes'): GoodVibesCliFlags {
+  return parseGoodVibesCli(argv, binary).flags;
 }

package/src/config/index.ts

@@ -8,7 +8,7 @@
 
 export { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
 export type { DeepReadonly } from '@pellux/goodvibes-sdk/platform/config/manager';
-export type { GoodVibesConfig, ConfigKey, ConfigValue, ConfigSetting, PermissionMode, PermissionAction, PermissionsToolConfig, NotificationsConfig } from '@pellux/goodvibes-sdk/platform/config/schema';
+export type { GoodVibesConfig, ConfigKey, ConfigValue, ConfigSetting, PermissionMode, PermissionAction, PermissionsToolConfig, NotificationsConfig, PersistedFlagState } from '@pellux/goodvibes-sdk/platform/config/schema';
 export { DEFAULT_CONFIG, CONFIG_SCHEMA } from '@pellux/goodvibes-sdk/platform/config/schema';
 export { ConfigError } from '@pellux/goodvibes-sdk/platform/types/errors';