@vibesdotdev/config 0.0.1

package/src/browser/index.ts

@@ -0,0 +1,86 @@
+export { ConfigManifest } from '../manifest/index.ts';
+export type {
+	ConfigTier,
+	StorageAdapterType,
+	StorageScope,
+	ConfigSurface,
+	HardwareContext,
+	EnvironmentContext,
+	ConfigContext,
+	ConfigRule,
+	ConfigFieldRule,
+	ConfigContextRule,
+	ConfigAndRule,
+	ConfigOrRule,
+	ConfigNotRule,
+	ConfigFunctionRule,
+	FieldComponent,
+	FieldWidth,
+	FieldUI,
+	FieldOption,
+	FieldAccess,
+	FieldRules,
+	FieldDefaults,
+	ConfigFieldMeta,
+	ConfigFieldGroup,
+	ManifestStorage,
+	ManifestContext,
+	ConfigManifest as ConfigManifestInterface,
+	InferConfigType,
+	FieldPaths
+} from '../manifest/index.ts';
+export {
+	configTierSchema,
+	storageAdapterSchema,
+	storageScopeSchema,
+	configSurfaceSchema,
+	hardwareContextSchema,
+	environmentContextSchema,
+	fieldComponentSchema,
+	fieldWidthSchema,
+	fieldUISchema,
+	fieldOptionSchema,
+	fieldAccessSchema,
+	fieldRulesSchema,
+	fieldDefaultsSchema,
+	configFieldMetaSchema,
+	configFieldGroupSchema,
+	manifestStorageSchema,
+	manifestContextSchema,
+	configManifestMetaSchema,
+	configRuleSchema,
+	createConfigManifest,
+	ManifestBuilder,
+	inputField,
+	textareaField,
+	numberField,
+	booleanField,
+	selectField,
+	radioField,
+	sliderField,
+	secretField,
+	jsonField,
+	option,
+	optionsFromEnum,
+	defaults,
+	whenField,
+	whenContext,
+	allOf,
+	anyOf,
+	not
+} from '../manifest/index.ts';
+export type {
+	ListColumn,
+	ListViewConfig,
+	ListAction,
+	FormViewConfig,
+	DetailViewConfig,
+	DetailSection,
+	DeleteConfig,
+	DetectionConfig,
+	CRUDConfig,
+	RecordManifest,
+	CRUDPageProps
+} from '../crud/index.ts';
+export { isRecordManifest, hasNestedRoutings } from '../crud/index.ts';
+export type { BaseRecord, CRUDViewMode, FormStep } from '../crud/index.ts';

package/src/cli/settings.descriptor.ts

@@ -0,0 +1,23 @@
+/**
+ * Settings CLI Command Descriptor
+ *
+ * Launches the Settings TUI editor via `vibes settings`.
+ */
+
+import type { CLICommandAssetDescriptor } from './types.ts';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'settings',
+	name: 'settings',
+	description: 'Open the configuration editor',
+	group: 'settings',
+
+	tuiAppId: 'config.settings',
+
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/cli/types.ts

@@ -0,0 +1,59 @@
+/**
+ * CLI Descriptor Types (local definitions)
+ *
+ * These types are defined locally because the CLI module hasn't been
+ * migrated to the monorepo yet. They mirror the shapes from the CLI
+ * module's descriptor schemas.
+ */
+
+import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
+
+export interface CLIGroupAssetDescriptor extends RuntimeDescriptor {
+	kind: 'cli/group';
+	name: string;
+	description: string;
+	parent?: string;
+	aliases?: string[];
+	surfaces?: ('cli' | 'web' | 'worker' | 'bridge')[];
+	internal?: boolean;
+	order?: number;
+	logBuffer?: {
+		enabled?: boolean;
+		sinks?: string[];
+		fallbackToStdout?: boolean;
+	};
+}
+
+export interface CLICommandAssetDescriptor extends RuntimeDescriptor {
+	kind: 'cli/command';
+	name: string;
+	description: string;
+	group: string;
+	arguments?: {
+		name: string;
+		description: string;
+		required?: boolean;
+		variadic?: boolean;
+		default?: unknown;
+	}[];
+	options?: {
+		flags: string;
+		description: string;
+		default?: unknown;
+		choices?: string[];
+	}[];
+	aliases?: string[];
+	surfaces?: ('cli' | 'web' | 'worker' | 'bridge')[];
+	internal?: boolean;
+	examples?: {
+		command: string;
+		description: string;
+	}[];
+	order?: number;
+	tuiAppId?: string;
+	logBuffer?: {
+		enabled?: boolean;
+		sinks?: string[];
+		fallbackToStdout?: boolean;
+	};
+}

package/src/client/index.ts

@@ -0,0 +1,169 @@
+/**
+ * Client-side storage helpers for CLI compatibility.
+ *
+ * Provides ConfigStorageClient interface and factory for dev tooling
+ * that previously used @vibesdotdev/cli/app/config/client/storage.
+ */
+
+import type { ConfigValue, CLIConfig, EnvironmentConfig, StoredCredentials, ConfigEntry, ConfigQuery } from '../storage/types.ts';
+import type { ConfigScope } from '../storage/index.ts';
+import type { ConfigStorageClient } from '../storage/index.ts';
+
+export type { ConfigStorageClient, ConfigValue } from '../storage/index.ts';
+export type { CLIConfig, EnvironmentConfig, StoredCredentials, ConfigEntry, ConfigQuery } from '../storage/types.ts';
+
+export {
+	loadStoredEnvironment,
+	loadStoredCredentials,
+	saveStoredEnvironment,
+	saveStoredCredentials
+} from './storage.ts';
+
+/**
+ * ConfigStorageClient stub for dev tooling.
+ *
+ * NOTE: This is a temporary stub for migration compatibility.
+ * Full implementation should use LocalDBConfigStorageAdapter via runtime.
+ * Blocked by python-env/manager.ts dynamic imports (separate mission).
+ */
+export function createConfigStorageClient(): ConfigStorageClient {
+	return new InMemoryConfigStorageClient();
+}
+
+class InMemoryConfigStorageClient implements ConfigStorageClient {
+	private store: Map<string, Map<string, { value: unknown; scope?: string }>> = new Map();
+	private environments: Map<string, EnvironmentConfig> = new Map();
+	private credentials: Map<string, StoredCredentials> = new Map();
+
+	async getConfig(): Promise<CLIConfig | null> {
+		const globalStore = this.store.get('global');
+		if (!globalStore) return null;
+		const config: CLIConfig = { version: '1.0' };
+		for (const [key, entry] of globalStore) {
+			if (entry.scope === undefined) {
+				(config as Record<string, unknown>)[key] = entry.value;
+			}
+		}
+		return config;
+	}
+
+	async setConfig(config: CLIConfig): Promise<void> {
+		if (!this.store.has('global')) {
+			this.store.set('global', new Map());
+		}
+		const globalStore = this.store.get('global')!;
+		for (const [key, value] of Object.entries(config)) {
+			if (key !== 'version') {
+				globalStore.set(key, { value, scope: undefined });
+			}
+		}
+	}
+
+	async getCurrentEnvironment(): Promise<EnvironmentConfig | null> {
+		const active = Array.from(this.environments.values())[0];
+		return active || null;
+	}
+
+	async setCurrentEnvironment(env: EnvironmentConfig): Promise<void> {
+		this.environments.set(env.id, env);
+	}
+
+	async getAllEnvironments(): Promise<EnvironmentConfig[]> {
+		return Array.from(this.environments.values());
+	}
+
+	async setEnvironment(env: EnvironmentConfig): Promise<void> {
+		this.environments.set(env.id, env);
+	}
+
+	async deleteEnvironment(id: string): Promise<void> {
+		this.environments.delete(id);
+	}
+
+	async getCredentials(id: string): Promise<StoredCredentials | null> {
+		return this.credentials.get(id) || null;
+	}
+
+	async setCredentials(id: string, credentials: StoredCredentials): Promise<void> {
+		this.credentials.set(id, credentials);
+	}
+
+	async deleteCredentials(id: string): Promise<void> {
+		this.credentials.delete(id);
+	}
+
+	async getEntry(scope: string, key: string): Promise<ConfigEntry | null> {
+		const scopeStore = this.store.get(scope);
+		if (!scopeStore) return null;
+		const entry = scopeStore.get(key);
+		if (!entry) return null;
+		return {
+			scope,
+			key,
+			value: entry.value as ConfigValue,
+			createdAt: '',
+			updatedAt: ''
+		};
+	}
+
+	async setEntry<T extends ConfigValue>(scope: string, key: string, value: T): Promise<void> {
+		if (!this.store.has(scope)) {
+			this.store.set(scope, new Map());
+		}
+		this.store.get(scope)!.set(key, { value });
+	}
+
+	async deleteEntry(scope: string, key: string): Promise<void> {
+		const scopeStore = this.store.get(scope);
+		if (scopeStore) scopeStore.delete(key);
+	}
+
+	async queryEntries(query: ConfigQuery): Promise<ConfigEntry[]> {
+		const results: ConfigEntry[] = [];
+		const scope = query.scope || 'global';
+		const scopeStore = this.store.get(scope);
+		if (!scopeStore) return results;
+		for (const [key, entry] of scopeStore) {
+			results.push({
+				scope,
+				key,
+				value: entry.value as ConfigValue,
+				createdAt: '',
+				updatedAt: ''
+			});
+		}
+		return results;
+	}
+
+	async getNamespace(scope: string): Promise<Record<string, ConfigValue>> {
+		const scopeStore = this.store.get(scope);
+		if (!scopeStore) return {};
+		const result: Record<string, ConfigValue> = {};
+		for (const [key, entry] of scopeStore) {
+			result[key] = entry.value as ConfigValue;
+		}
+		return result;
+	}
+
+	async get(key: string, scope?: string): Promise<ConfigValue | null> {
+		const effectiveScope = scope || 'global';
+		const scopeStore = this.store.get(effectiveScope);
+		if (!scopeStore) return null;
+		const entry = scopeStore.get(key);
+		return entry ? (entry.value as ConfigValue) : null;
+	}
+
+	async set(key: string, value: ConfigValue, scope?: string, _encrypted?: boolean): Promise<void> {
+		const effectiveScope = scope || 'global';
+		if (!this.store.has(effectiveScope)) {
+			this.store.set(effectiveScope, new Map());
+		}
+		this.store.get(effectiveScope)!.set(key, { value });
+	}
+
+	async delete(key: string, scope?: string): Promise<void> {
+		const effectiveScope = scope || 'global';
+		const scopeStore = this.store.get(effectiveScope);
+		if (scopeStore) scopeStore.delete(key);
+	}
+}

package/src/client/storage.ts

@@ -0,0 +1,76 @@
+/**
+ * Legacy client-side storage helpers for CLI compatibility.
+ *
+ * Credentials have been migrated to the `config/manifest#auth` runtime store;
+ * Environment management uses the environment/current system.
+ *
+ * These exports exist for backward compatibility with CLI code that
+ * previously used @vibesdotdev/cli/app/config/client/storage.
+ */
+
+import { resolveCurrentEnvironmentConfig } from '../environment/current.ts';
+
+export interface StoredCredentials {
+	id?: string;
+	environment?: string;
+	apiKey?: string;
+	sessionToken?: string;
+	refreshToken?: string;
+	userId?: string;
+	email?: string;
+	name?: string;
+	expiresAt?: string;
+	metadata?: Record<string, unknown>;
+	createdAt?: string;
+	updatedAt?: string;
+}
+
+export interface EnvironmentConfig {
+	id?: string;
+	name: string;
+	tier?: string;
+	apiUrl: string;
+	headers?: Record<string, string>;
+}
+
+/**
+ * Load the current stored environment configuration.
+ * Uses the environment system from config/environment/current.
+ */
+export async function loadStoredEnvironment(): Promise<EnvironmentConfig | null> {
+	try {
+		const env = await resolveCurrentEnvironmentConfig();
+		if (!env) return null;
+		return {
+			name: env.name,
+			tier: env.tier ?? 'local',
+			apiUrl: env.apiUrl
+		};
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Load stored credentials for an environment.
+ *
+ * NOTE: The config/manifest system manages credentials through runtime assets.
+ * This function is provided for backward compatibility but may return null
+ * if the credential resolution has been migrated to the runtime system.
+ *
+ * For new code, use: runtime.query('config/manifest').withId('auth').resolve()
+ */
+export async function loadStoredCredentials(
+	_environment?: string
+): Promise<StoredCredentials | null> {
+	return null;
+}
+
+export async function saveStoredEnvironment(env: EnvironmentConfig): Promise<void> {
+}
+
+export async function saveStoredCredentials(
+	credentials: StoredCredentials,
+	environment?: string
+): Promise<void> {
+}

package/src/collection/collection.ts

@@ -0,0 +1,121 @@
+/**
+ * Config Collection Implementation
+ *
+ * Resolves all manifests in a collection and provides unified
+ * load/subscribe/dispose lifecycle. Each manifest is resolved
+ * via the runtime and backed by its own storage adapter.
+ */
+
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type { ConfigManifestDescriptor } from '../schemas/config-manifest-descriptor.ts';
+import type {
+	ConfigCollectionDescriptor,
+	CollectionState,
+	CollectionCallback
+} from '../schemas/collection.ts';
+
+export type { CollectionState, CollectionCallback } from '../schemas/collection.ts';
+
+type ManifestData = Record<string, unknown> | null;
+
+interface ManifestIO<T> {
+	load(): Promise<T | null>;
+	subscribe(cb: (data: T | null) => void): () => void;
+}
+
+/**
+ * ConfigCollection — unified lifecycle for a group of config manifests.
+ *
+ * Constructed with a descriptor and runtime reference. Resolves each
+ * manifest via the runtime query API, then provides:
+ * - `load()` — resolve all manifests and return combined state
+ * - `subscribe(cb)` — subscribe to updates on all manifests
+ * - `dispose()` — clean up all subscriptions
+ */
+export class ConfigCollection {
+	private descriptor: ConfigCollectionDescriptor;
+	private runtime: VibesRuntime;
+	private resolved: Map<string, ManifestIO<Record<string, unknown>>> = new Map();
+	private unsubscribers: (() => void)[] = [];
+
+	constructor(descriptor: ConfigCollectionDescriptor, runtime: VibesRuntime) {
+		this.descriptor = descriptor;
+		this.runtime = runtime;
+	}
+
+	/**
+	 * Resolve all manifests and load their current data.
+	 */
+	async load(): Promise<CollectionState> {
+		const state: CollectionState = { data: {}, errors: [] };
+
+		await Promise.all(
+			this.descriptor.manifests.map(async (manifestId) => {
+				try {
+					const io = await this.runtime
+						.query<ConfigManifestDescriptor, ManifestIO<Record<string, unknown>>>('config/manifest')
+						.withId(manifestId)
+						.resolve();
+					this.resolved.set(manifestId, io);
+					state.data[manifestId] = await io.load().catch(() => null);
+				} catch {
+					state.errors.push(manifestId);
+					state.data[manifestId] = null;
+				}
+			})
+		);
+
+		return state;
+	}
+
+	/**
+	 * Subscribe to updates on all manifests. Calls `cb` with the
+	 * full combined state whenever any manifest changes.
+	 *
+	 * Must call `load()` first to resolve manifests.
+	 */
+	subscribe(cb: CollectionCallback): () => void {
+		const currentData: Record<string, ManifestData> = {};
+
+		// Initialize current data from resolved manifests
+		for (const [id] of this.resolved) {
+			currentData[id] = null;
+		}
+
+		const notify = () => {
+			const errors: string[] = [];
+			for (const id of this.descriptor.manifests) {
+				if (!this.resolved.has(id)) errors.push(id);
+			}
+			cb({ data: { ...currentData }, errors });
+		};
+
+		for (const [id, io] of this.resolved) {
+			const unsub = io.subscribe((data) => {
+				currentData[id] = data;
+				notify();
+			});
+			this.unsubscribers.push(unsub);
+		}
+
+		return () => this.dispose();
+	}
+
+	/**
+	 * Unsubscribe from all manifest subscriptions.
+	 */
+	dispose(): void {
+		for (const unsub of this.unsubscribers) {
+			unsub();
+		}
+		this.unsubscribers = [];
+		this.resolved.clear();
+	}
+
+	/**
+	 * Get the list of manifest IDs in this collection.
+	 */
+	get manifestIds(): readonly string[] {
+		return this.descriptor.manifests;
+	}
+}

package/src/collection/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Config Collection — barrel export
+ */
+
+export { ConfigCollection } from './collection.ts';
+export type { CollectionState, CollectionCallback } from './collection.ts';

package/src/common/index.ts

@@ -0,0 +1,86 @@
+export { ConfigManifest } from '../manifest/index.ts';
+export type {
+	ConfigTier,
+	StorageAdapterType,
+	StorageScope,
+	ConfigSurface,
+	HardwareContext,
+	EnvironmentContext,
+	ConfigContext,
+	ConfigRule,
+	ConfigFieldRule,
+	ConfigContextRule,
+	ConfigAndRule,
+	ConfigOrRule,
+	ConfigNotRule,
+	ConfigFunctionRule,
+	FieldComponent,
+	FieldWidth,
+	FieldUI,
+	FieldOption,
+	FieldAccess,
+	FieldRules,
+	FieldDefaults,
+	ConfigFieldMeta,
+	ConfigFieldGroup,
+	ManifestStorage,
+	ManifestContext,
+	ConfigManifest as ConfigManifestInterface,
+	InferConfigType,
+	FieldPaths
+} from '../manifest/index.ts';
+export {
+	configTierSchema,
+	storageAdapterSchema,
+	storageScopeSchema,
+	configSurfaceSchema,
+	hardwareContextSchema,
+	environmentContextSchema,
+	fieldComponentSchema,
+	fieldWidthSchema,
+	fieldUISchema,
+	fieldOptionSchema,
+	fieldAccessSchema,
+	fieldRulesSchema,
+	fieldDefaultsSchema,
+	configFieldMetaSchema,
+	configFieldGroupSchema,
+	manifestStorageSchema,
+	manifestContextSchema,
+	configManifestMetaSchema,
+	configRuleSchema,
+	createConfigManifest,
+	ManifestBuilder,
+	inputField,
+	textareaField,
+	numberField,
+	booleanField,
+	selectField,
+	radioField,
+	sliderField,
+	secretField,
+	jsonField,
+	option,
+	optionsFromEnum,
+	defaults,
+	whenField,
+	whenContext,
+	allOf,
+	anyOf,
+	not
+} from '../manifest/index.ts';
+export type {
+	ListColumn,
+	ListViewConfig,
+	ListAction,
+	FormViewConfig,
+	DetailViewConfig,
+	DetailSection,
+	DeleteConfig,
+	DetectionConfig,
+	CRUDConfig,
+	RecordManifest,
+	CRUDPageProps
+} from '../crud/index.ts';
+export { isRecordManifest, hasNestedRoutings } from '../crud/index.ts';
+export type { BaseRecord, CRUDViewMode, FormStep } from '../crud/index.ts';

package/src/config.context.descriptor.ts

@@ -0,0 +1,12 @@
+/**
+ * Config Context Descriptor
+ *
+ * Provides configuration storage access.
+ */
+
+import { createContextDescriptor } from '@vibesdotdev/runtime/factory/context';
+
+export default createContextDescriptor({
+	id: 'config/context',
+	description: 'Configuration storage access for project and user settings.'
+});