@vibesdotdev/config 0.0.1

package/src/services/manifest-utils.ts

@@ -0,0 +1,119 @@
+/**
+ * Manifest Utilities
+ *
+ * Runtime-based utilities for looking up and working with config manifests.
+ * Replaces the legacy registry/manifests.js functions.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { ConfigManifest } from '../manifest/types.ts';
+import type { RecordManifest } from '../crud/types.ts';
+
+import type { AnyManifest } from './schemas/manifest-utils.schema.ts';
+
+export type { AnyManifest } from './schemas/manifest-utils.schema.ts';
+
+/**
+ * Get a manifest by ID from the runtime
+ */
+export function getManifest(id: string): AnyManifest | null {
+	try {
+		const runtime = getVibesRuntime();
+		const descriptors = runtime.query('config/manifest').descriptors();
+		return (descriptors.find((d) => d.id === id) as unknown as AnyManifest) ?? null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get all registered manifest IDs
+ */
+export function getAllManifestIds(): string[] {
+	try {
+		const runtime = getVibesRuntime();
+		const descriptors = runtime.query('config/manifest').descriptors();
+		return descriptors.map((d) => d.id);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Get all registered manifests
+ */
+export function getAllManifests(): AnyManifest[] {
+	try {
+		const runtime = getVibesRuntime();
+		const descriptors = runtime.query('config/manifest').descriptors();
+		return descriptors as unknown as AnyManifest[];
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Check if a manifest is a ConfigManifest (single-object config)
+ */
+export function isConfigManifest(manifest: unknown): manifest is ConfigManifest {
+	if (!manifest || typeof manifest !== 'object') return false;
+	const m = manifest as Record<string, unknown>;
+	return (
+		typeof m.id === 'string' &&
+		typeof m.schema === 'object' &&
+		m.schema !== null &&
+		typeof m.fields === 'object' &&
+		m.fields !== null &&
+		!('crud' in m) // RecordManifests have crud config
+	);
+}
+
+/**
+ * Check if a manifest is a RecordManifest (CRUD list)
+ */
+export function isRecordManifest(manifest: unknown): manifest is RecordManifest {
+	if (!manifest || typeof manifest !== 'object') return false;
+	const m = manifest as Record<string, unknown>;
+	return (
+		typeof m.id === 'string' &&
+		typeof m.schema === 'object' &&
+		m.schema !== null &&
+		'crud' in m &&
+		typeof m.crud === 'object' &&
+		m.crud !== null
+	);
+}
+
+/**
+ * Get manifests by surface
+ */
+export function getManifestsForSurface(surface: string): AnyManifest[] {
+	return getAllManifests().filter((m) => {
+		if (!m.context?.surfaces) return true; // No surface restriction
+		const surfaces = m.context.surfaces as readonly string[];
+		return surfaces.includes(surface);
+	});
+}
+
+/**
+ * Get manifests by navigation page
+ */
+export function getManifestsForPage(page: string): AnyManifest[] {
+	return getAllManifests().filter((m) => m.navigation?.page === page);
+}
+
+/**
+ * Get manifests by navigation section
+ */
+export function getManifestsForSection(page: string, section: string): AnyManifest[] {
+	return getAllManifests().filter(
+		(m) => m.navigation?.page === page && m.navigation?.section === section
+	);
+}
+
+/**
+ * Get manifests by category
+ */
+export function getManifestsByCategory(category: string): AnyManifest[] {
+	return getAllManifests().filter((m) => m.category === category);
+}

package/src/services/schemas/config-accessor.schema.ts

@@ -0,0 +1,11 @@
+import type { ConfigManifest, ConfigContext } from '../../manifest/types.ts';
+
+export interface ConfigAccessor<T> {
+	get(): T | null;
+	setField<K extends keyof T>(field: K, value: T[K]): void;
+	setFields(fields: Partial<T>): void;
+	subscribe(callback: (values: T | null) => void): () => void;
+	save(): Promise<void>;
+	reload(): Promise<void>;
+	isDirty(): boolean;
+}

package/src/services/schemas/encryption.schema.ts

@@ -0,0 +1,23 @@
+export interface EncryptedValue {
+	ciphertext: string;
+	iv: string;
+	salt: string;
+	tag: string;
+	algorithm: string;
+	iterations: number;
+}
+
+export interface SerializedEncryptedValue {
+	v: 1;
+	ct: string;
+	iv: string;
+	s: string;
+	t: string;
+	a: string;
+	i: number;
+}
+
+export interface EncryptionOptions {
+	salt?: Buffer;
+	iv?: Buffer;
+}

package/src/services/schemas/manifest-utils.schema.ts

@@ -0,0 +1,4 @@
+import type { ConfigManifest } from '../../manifest/types.ts';
+import type { RecordManifest } from '../../crud/types.ts';
+
+export type AnyManifest = ConfigManifest | RecordManifest;

package/src/settings/assemble.ts

@@ -0,0 +1,46 @@
+/**
+ * Settings Assembly
+ *
+ * Builds the global Settings layout at runtime by concatenating every
+ * `settings/section` descriptor registered with the runtime. Config does
+ * not own the section list; each owning module contributes its own.
+ */
+
+import type { SettingsSectionDescriptor } from './settings-section.schema.ts';
+
+/** Minimum surface a runtime accessor must expose for assembly. */
+export interface SettingsSectionRuntime {
+	assets(kind: 'settings/section'): {
+		descriptors(): SettingsSectionDescriptor[];
+	};
+}
+
+const DEFAULT_ORDER = 100;
+
+/**
+ * Returns every registered Settings section, filtered to `enabled !== false`
+ * and sorted by `order` (ascending; unset → 100). Pure: callers may safely
+ * pass the result to a UI without further sorting.
+ */
+export function assembleSettingsSections(
+	runtime: SettingsSectionRuntime
+): SettingsSectionDescriptor[] {
+	const descriptors = runtime.assets('settings/section').descriptors();
+	return descriptors
+		.filter((d) => d.enabled !== false)
+		.slice()
+		.sort((a, b) => (a.order ?? DEFAULT_ORDER) - (b.order ?? DEFAULT_ORDER));
+}
+
+/**
+ * Resolve the section a given `config/manifest` ID participates in (if any).
+ *
+ * Returns the first section whose `manifests[]` contains the given id, in
+ * assembled order. Returns `undefined` when no section claims it.
+ */
+export function findSectionForManifest(
+	runtime: SettingsSectionRuntime,
+	manifestId: string
+): SettingsSectionDescriptor | undefined {
+	return assembleSettingsSections(runtime).find((s) => s.manifests.includes(manifestId));
+}

package/src/settings/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Settings — runtime-first global settings layout.
+ *
+ * Each owning module registers one `settings/section` descriptor naming the
+ * manifests it owns. Surfaces (TUI/web) assemble the global Settings UI by
+ * sorting all registered descriptors. Config never enumerates sections.
+ */
+
+export {
+	SettingsSectionDescriptorSchema,
+	isSettingsSectionDescriptor,
+	type SettingsSectionDescriptor
+} from './settings-section.schema.ts';
+
+export {
+	assembleSettingsSections,
+	findSectionForManifest,
+	type SettingsSectionRuntime
+} from './assemble.ts';

package/src/settings/settings-section.schema.ts

@@ -0,0 +1,84 @@
+/**
+ * Settings Section Descriptor
+ *
+ * Pure-data runtime descriptor: each module's plugin registers one or more
+ * `settings/section` descriptors and the assembled global Settings UI is the
+ * sorted concatenation of every registered contribution.
+ *
+ * Config never enumerates which sections exist. The owning module owns its
+ * own section — including which manifests appear in it.
+ *
+ * @example
+ * ```ts
+ * // In packages/ai/src/ai.plugin.ts
+ * import type { SettingsSectionDescriptor } from '@vibesdotdev/config/settings';
+ *
+ * const aiSettingsSection: SettingsSectionDescriptor = {
+ *   kind: 'settings/section',
+ *   id: 'ai',
+ *   label: 'AI',
+ *   icon: '🤖',
+ *   description: 'AI providers, agents, and model configuration',
+ *   order: 10,
+ *   manifests: ['ai.core', 'ai.providers', 'tools.agents']
+ * };
+ *
+ * // Registered through the plugin's descriptors[] array.
+ * ```
+ */
+
+import * as z from 'zod/v4';
+
+/**
+ * Zod schema for a contributed Settings section.
+ */
+export const SettingsSectionDescriptorSchema = z.object({
+	kind: z.literal('settings/section'),
+
+	/** Stable identifier for the section (e.g., 'ai', 'chat', 'knowledge'). */
+	id: z.string().min(1),
+
+	/** Display label. */
+	label: z.string().min(1),
+
+	/** Optional icon (string token resolved by the surface). */
+	icon: z.string().optional(),
+
+	/** Longer description shown alongside the section header. */
+	description: z.string().optional(),
+
+	/**
+	 * Sort order within the global Settings UI. Lower numbers render first.
+	 * Unset → defaults to 100 during assembly.
+	 */
+	order: z.number().optional(),
+
+	/**
+	 * IDs of `config/manifest` descriptors that appear in this section.
+	 * The surface resolves each manifest through the runtime; this list is
+	 * just the section-to-manifest mapping.
+	 */
+	manifests: z.array(z.string().min(1)),
+
+	/** Whether the section can be collapsed in the UI. */
+	collapsible: z.boolean().optional(),
+
+	/** Default collapsed state (only meaningful when collapsible is true). */
+	defaultCollapsed: z.boolean().optional(),
+
+	/** Optional descriptor tags for filtering. */
+	tags: z.array(z.string()).optional(),
+
+	/**
+	 * When false, the section is registered but excluded from assembly.
+	 * Allows feature-flag gating without removing the descriptor.
+	 */
+	enabled: z.boolean().optional()
+});
+
+export type SettingsSectionDescriptor = z.infer<typeof SettingsSectionDescriptorSchema>;
+
+/** Type guard for runtime queries. */
+export function isSettingsSectionDescriptor(value: unknown): value is SettingsSectionDescriptor {
+	return SettingsSectionDescriptorSchema.safeParse(value).success;
+}

package/src/storage/adapter.ts

@@ -0,0 +1,12 @@
+/**
+ * Config Storage Adapter Interface
+ *
+ * Type definitions for storage adapters that implement ConfigStorageClient.
+ * Concrete implementations may use LocalDB, file-based storage, or other backends.
+ */
+
+import type { ConfigStorageClient, ConfigValue } from './types.ts';
+import type { ConfigScope } from './schemas.ts';
+
+export type { ConfigStorageClient, ConfigValue };
+export type { ConfigScope };

package/src/storage/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Config Storage Module
+ *
+ * Unified configuration storage types and schemas.
+ */
+
+export {
+	type ConfigScope,
+	type ConfigValueType,
+	type EnvironmentTier,
+	type CredentialsInput,
+	type ConfigInput,
+	type EnvironmentInput,
+	type CredentialsRow,
+	type ConfigRow,
+	type EnvironmentRow,
+	type ConfigDocumentRow,
+	type ConfigDocumentInput,
+	type CredentialsRecord,
+	type ConfigRecord,
+	type EnvironmentRecord,
+	type ConfigDocumentContent,
+	type ConfigDocumentRecord,
+	type ConfigDocumentHistoryRow,
+	type ConfigDocumentHistoryRecord,
+	configScopeSchema,
+	configValueTypeSchema,
+	environmentTierSchema,
+	credentialsInputSchema,
+	configInputSchema,
+	environmentInputSchema,
+	configDocumentRowSchema,
+	configDocumentInputSchema,
+	credentialsRowSchema,
+	credentialsRecordSchema,
+	configRowSchema,
+	configRecordSchema,
+	environmentRowSchema,
+	environmentRecordSchema,
+	configDocumentContentSchema,
+	configDocumentHistoryRowSchema,
+	configDocumentHistoryRecordSchema
+} from './schemas.ts';
+
+export {
+	type ConfigStorageClient,
+	type ConfigValue
+} from './types.ts';

package/src/storage/schemas.ts

@@ -0,0 +1,215 @@
+/**
+ * Config Storage Schemas
+ *
+ * Zod schemas for the LocalDB config tables.
+ * These map directly to the SQL schema in migrations/config/001-initial-schema.sql
+ */
+
+import z from 'zod/v4';
+
+/**
+ * Config scope - where config values apply
+ */
+export const configScopeSchema = z.enum(['global', 'local', 'project']);
+export type ConfigScope = z.infer<typeof configScopeSchema>;
+
+/**
+ * Config value type - how to interpret the stored value
+ */
+export const configValueTypeSchema = z.enum(['string', 'number', 'boolean', 'json']);
+export type ConfigValueType = z.infer<typeof configValueTypeSchema>;
+
+/**
+ * Environment tier
+ */
+export const environmentTierSchema = z.enum(['local', 'dev', 'staging', 'production']);
+export type EnvironmentTier = z.infer<typeof environmentTierSchema>;
+
+/**
+ * Credentials row schema
+ */
+export const credentialsRowSchema = z.object({
+	id: z.string(),
+	environment: z.string(),
+	api_key: z.string().nullable(),
+	session_token: z.string().nullable(),
+	refresh_token: z.string().nullable(),
+	user_id: z.string().nullable(),
+	email: z.string().nullable(),
+	name: z.string().nullable(),
+	expires_at: z.string().nullable(),
+	metadata: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+});
+export type CredentialsRow = z.infer<typeof credentialsRowSchema>;
+
+export const credentialsRecordSchema = z.object({
+	id: z.string(),
+	environment: z.string(),
+	apiKey: z.string().nullable().optional(),
+	sessionToken: z.string().nullable().optional(),
+	refreshToken: z.string().nullable().optional(),
+	userId: z.string().nullable().optional(),
+	email: z.string().nullable().optional(),
+	name: z.string().nullable().optional(),
+	expiresAt: z.string().nullable().optional(),
+	metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+export type CredentialsRecord = z.infer<typeof credentialsRecordSchema>;
+
+/**
+ * Config row schema
+ */
+export const configRowSchema = z.object({
+	id: z.string(),
+	key: z.string(),
+	scope: configScopeSchema,
+	namespace: z.string().nullable(),
+	value: z.string(),
+	value_type: configValueTypeSchema,
+	encrypted: z.literal([0, 1]),
+	metadata: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+});
+export type ConfigRow = z.infer<typeof configRowSchema>;
+
+export const configRecordSchema = z.object({
+	id: z.string(),
+	key: z.string(),
+	scope: configScopeSchema,
+	namespace: z.string().nullable().optional(),
+	value: z.string(),
+	valueType: configValueTypeSchema,
+	encrypted: z.boolean(),
+	metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+export type ConfigRecord = z.infer<typeof configRecordSchema>;
+
+/**
+ * Environment row schema
+ */
+export const environmentRowSchema = z.object({
+	id: z.literal(1),
+	name: z.string(),
+	tier: environmentTierSchema,
+	api_url: z.string(),
+	updated_at: z.string()
+});
+export type EnvironmentRow = z.infer<typeof environmentRowSchema>;
+
+export const environmentRecordSchema = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	tier: environmentTierSchema,
+	apiUrl: z.string(),
+	updatedAt: z.string()
+});
+export type EnvironmentRecord = z.infer<typeof environmentRecordSchema>;
+
+/**
+ * Input schemas for creating/updating
+ */
+export const credentialsInputSchema = z.object({
+	environment: z.string(),
+	apiKey: z.string().optional(),
+	sessionToken: z.string().optional(),
+	refreshToken: z.string().optional(),
+	userId: z.string().optional(),
+	email: z.string().optional(),
+	name: z.string().optional(),
+	expiresAt: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+export type CredentialsInput = z.infer<typeof credentialsInputSchema>;
+
+export const configInputSchema = z.object({
+	key: z.string(),
+	value: z.unknown(),
+	scope: configScopeSchema.default('global'),
+	namespace: z.string().optional(),
+	encrypted: z.boolean().default(false)
+});
+export type ConfigInput = z.infer<typeof configInputSchema>;
+
+export const environmentInputSchema = z.object({
+	name: z.string(),
+	tier: environmentTierSchema,
+	apiUrl: z.url()
+});
+export type EnvironmentInput = z.infer<typeof environmentInputSchema>;
+
+/**
+ * Config document row schema
+ */
+export const configDocumentRowSchema = z.object({
+	id: z.string(),
+	scope: configScopeSchema,
+	namespace: z.string().nullable(),
+	content: z.string(),
+	version: z.number(),
+	encrypted: z.literal([0, 1]),
+	created_at: z.string(),
+	updated_at: z.string()
+});
+export type ConfigDocumentRow = z.infer<typeof configDocumentRowSchema>;
+
+export const configDocumentContentSchema = z.union([
+	z.string(),
+	z.record(z.string(), z.unknown())
+]);
+export type ConfigDocumentContent = z.infer<typeof configDocumentContentSchema>;
+
+export const configDocumentRecordSchema = z.object({
+	id: z.string(),
+	scope: configScopeSchema,
+	namespace: z.string().nullable().optional(),
+	content: configDocumentContentSchema,
+	version: z.number(),
+	encrypted: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+export type ConfigDocumentRecord = z.infer<typeof configDocumentRecordSchema>;
+
+/**
+ * Config document history row schema
+ */
+export const configDocumentHistoryRowSchema = z.object({
+	id: z.string(),
+	document_id: z.string(),
+	content: z.string(),
+	version: z.number(),
+	changed_by: z.string().nullable(),
+	change_reason: z.string().nullable(),
+	created_at: z.string()
+});
+export type ConfigDocumentHistoryRow = z.infer<typeof configDocumentHistoryRowSchema>;
+
+export const configDocumentHistoryRecordSchema = z.object({
+	id: z.string(),
+	documentId: z.string(),
+	content: configDocumentContentSchema,
+	version: z.number(),
+	changedBy: z.string().nullable().optional(),
+	changeReason: z.string().nullable().optional(),
+	createdAt: z.string()
+});
+export type ConfigDocumentHistoryRecord = z.infer<typeof configDocumentHistoryRecordSchema>;
+
+/**
+ * Config document input schema
+ */
+export const configDocumentInputSchema = z.object({
+	scope: configScopeSchema,
+	namespace: z.string().nullable().default(null),
+	content: z.record(z.string(), z.unknown()),
+	encrypted: z.boolean().default(false),
+	changeReason: z.string().optional()
+});
+export type ConfigDocumentInput = z.infer<typeof configDocumentInputSchema>;

package/src/storage/types.ts

@@ -0,0 +1,88 @@
+/**
+ * Config Storage Types
+ *
+ * Shared type definitions for configuration storage.
+ */
+
+export type ConfigValue =
+	| string
+	| number
+	| boolean
+	| null
+	| { [key: string]: ConfigValue }
+	| ConfigValue[];
+
+export interface CLIConfig {
+	version: string;
+	activeEnvironment?: string;
+	[key: string]: ConfigValue | undefined;
+}
+
+export interface EnvironmentConfig {
+	id: string;
+	name: string;
+	apiUrl: string;
+	[key: string]: ConfigValue;
+}
+
+export interface StoredCredentials {
+	id: string;
+	environment: string;
+	apiKey?: string;
+	sessionToken?: string;
+	refreshToken?: string;
+	userId?: string;
+	email?: string;
+	name?: string;
+	expiresAt?: string;
+	metadata?: Record<string, ConfigValue>;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface ConfigEntry {
+	scope: string;
+	key: string;
+	value: ConfigValue;
+	valueType?: string;
+	encrypted?: boolean;
+	metadata?: Record<string, ConfigValue>;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface ConfigQuery {
+	scope?: string;
+	namespace?: string;
+	limit?: number;
+	offset?: number;
+}
+
+/**
+ * Storage interface for CLI configuration
+ * Uses browser-compatible storage APIs that work in both Node.js and browser contexts
+ */
+export interface ConfigStorageClient {
+	getConfig(): Promise<CLIConfig | null>;
+	setConfig(config: CLIConfig): Promise<void>;
+
+	getCurrentEnvironment(): Promise<EnvironmentConfig | null>;
+	setCurrentEnvironment(env: EnvironmentConfig): Promise<void>;
+	getAllEnvironments(): Promise<EnvironmentConfig[]>;
+	setEnvironment(env: EnvironmentConfig): Promise<void>;
+	deleteEnvironment(id: string): Promise<void>;
+
+	getCredentials(id: string): Promise<StoredCredentials | null>;
+	setCredentials(id: string, credentials: StoredCredentials): Promise<void>;
+	deleteCredentials(id: string): Promise<void>;
+
+	getEntry(scope: string, key: string): Promise<ConfigEntry | null>;
+	setEntry<T extends ConfigValue>(scope: string, key: string, value: T): Promise<void>;
+	deleteEntry(scope: string, key: string): Promise<void>;
+	queryEntries(query: ConfigQuery): Promise<ConfigEntry[]>;
+
+	getNamespace(scope: string): Promise<Record<string, ConfigValue>>;
+	get(key: string, scope?: string): Promise<ConfigValue | null>;
+	set(key: string, value: ConfigValue, scope?: string, encrypted?: boolean): Promise<void>;
+	delete(key: string, scope?: string): Promise<void>;
+}