@vibesdotdev/config 0.0.1

package/src/environment/current.ts

@@ -0,0 +1,108 @@
+/**
+ * Environment Catalog & Selection
+ *
+ * Manages the catalog of known environments (local, staging, production, etc.)
+ * and persists the user's current selection via the config manifest system.
+ *
+ * Uses ConfigManifest (runtime-resolved storage adapter) instead of raw fs.
+ * Storage adapter selection is runtime-resolved per scope.
+ */
+
+import { ConfigManifest } from '../manifest/config-manifest.ts';
+
+import type { EnvironmentCatalogEntry, CurrentEnvironmentConfig } from './schemas/current.schema.ts';
+
+export type { EnvironmentTier, EnvironmentCatalogEntry, CurrentEnvironmentConfig } from './schemas/current.schema.ts';
+
+/**
+ * Get the environment config manifest.
+ * Lazily instantiated; safe to call multiple times.
+ */
+function getManifest(): ConfigManifest<{ currentEnvironment?: string; catalog: EnvironmentCatalogEntry[] }> {
+	return ConfigManifest.fromId('environment');
+}
+
+/** Load all known environments from persistent storage. */
+export async function loadEnvironmentCatalog(): Promise<EnvironmentCatalogEntry[]> {
+	const manifest = getManifest();
+	const data = await manifest.load();
+	return data?.catalog ?? [];
+}
+
+/** Resolve the currently-selected environment configuration. */
+export async function resolveCurrentEnvironmentConfig(): Promise<CurrentEnvironmentConfig> {
+	const manifest = getManifest();
+	const data = await manifest.load();
+	const selected = data?.currentEnvironment;
+	const catalog = data?.catalog ?? [];
+
+	if (selected && catalog.length > 0) {
+		const entry = catalog.find((e) => (e.id ?? e.name) === selected);
+		if (entry) {
+			return {
+				id: entry.id ?? entry.name,
+				name: entry.name,
+				apiUrl: entry.apiUrl,
+				tier: entry.tier
+			};
+		}
+	}
+
+	// Default to local
+	return { id: 'local', name: 'local', apiUrl: 'http://localhost:5173', tier: 'local' };
+}
+
+/** Persist an environment selection (single entry). */
+export async function saveEnvironmentSelection(entry: EnvironmentCatalogEntry): Promise<void> {
+	const manifest = getManifest();
+	const data = (await manifest.load()) ?? { catalog: [] };
+	const id = entry.id ?? entry.name;
+	const idx = data.catalog.findIndex((e) => (e.id ?? e.name) === id);
+	if (idx >= 0) {
+		data.catalog[idx] = entry;
+	} else {
+		data.catalog.push(entry);
+	}
+	await manifest.save(data);
+}
+
+/** Load the name/id of the currently-selected environment. */
+export async function loadCurrentEnvironmentSelection(): Promise<string | null> {
+	const manifest = getManifest();
+	const data = await manifest.load();
+	return data?.currentEnvironment ?? null;
+}
+
+/** Persist the currently-selected environment name/id. */
+export async function saveCurrentEnvironmentSelection(id: string): Promise<void> {
+	const manifest = getManifest();
+	const data = (await manifest.load()) ?? { catalog: [] };
+	data.currentEnvironment = id;
+	await manifest.save(data);
+}
+
+/** Persist the full environment catalog. */
+export async function saveEnvironmentCatalog(catalog: EnvironmentCatalogEntry[]): Promise<void> {
+	const manifest = getManifest();
+	const data = (await manifest.load()) ?? { catalog: [] };
+	data.catalog = catalog;
+	await manifest.save(data);
+}
+
+import type { EnvironmentDescriptor } from './kinds/environment.schema';
+
+/**
+ * Resolve the configured environment descriptor from a list of candidates.
+ *
+ * Checks the persisted current environment selection and returns the matching
+ * descriptor from the candidates list.
+ */
+export async function resolveConfiguredEnvironmentDescriptor(
+	candidates: EnvironmentDescriptor[]
+): Promise<EnvironmentDescriptor | undefined> {
+	if (candidates.length === 0) return undefined;
+
+	const currentConfig = await resolveCurrentEnvironmentConfig();
+	const configured = candidates.find((d) => d.id === currentConfig.id);
+	return configured;
+}

package/src/environment/environment.config.descriptor.ts

@@ -0,0 +1,60 @@
+/**
+ * Environment Config Manifest Descriptor
+ *
+ * Declares configuration options for the environment module.
+ * Used to store user preferences like currentEnvironment.
+ * Auto-discovered by the runtime.
+ */
+
+import type { ConfigManifestDescriptor } from '@vibesdotdev/config/schemas/config-manifest-descriptor';
+import { EnvironmentPreferencesSchema } from './environment.config.schema';
+
+const descriptor: ConfigManifestDescriptor = {
+	kind: 'config/manifest',
+	id: 'environment',
+	name: 'Environment Settings',
+	description: 'Environment module configuration',
+
+	customTables: false,
+	version: 1,
+	internal: false,
+
+	// Storage configuration
+	namespace: 'environment',
+	schema: EnvironmentPreferencesSchema,
+	allowedAdapters: ['storage.localdb'],
+	scope: 'global',
+
+	// Config tier and classification
+	tier: 'user',
+	category: 'system',
+
+	// Field metadata for UI
+	fields: {
+		currentEnvironment: {
+			ui: {
+				label: 'Current Environment',
+				description: 'The environment to use for API calls',
+				component: 'select'
+			}
+		},
+		catalog: {
+			ui: {
+				label: 'Environment Catalog',
+				description: 'List of configured environments',
+				component: 'list'
+			}
+		}
+	},
+
+	// Navigation
+	navigation: {
+		page: 'settings',
+		section: 'environment',
+		order: 10
+	},
+
+	enabled: true
+};
+
+export default descriptor;

package/src/environment/environment.config.schema.ts

@@ -0,0 +1,24 @@
+import * as z from 'zod/v4';
+
+export const EnvironmentTierSchema = z.enum(['local', 'dev', 'staging', 'production']);
+
+export const EnvironmentCatalogEntrySchema = z.object({
+	id: z.string().optional(),
+	name: z.string(),
+	apiUrl: z.string().url(),
+	tier: EnvironmentTierSchema.optional(),
+	description: z.string().optional(),
+	isDefault: z.boolean().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	variables: z.record(z.string(), z.string()).optional(),
+	databaseUrl: z.string().optional(),
+	secrets: z.record(z.string(), z.string()).optional()
+});
+
+export const EnvironmentPreferencesSchema = z.object({
+	currentEnvironment: z.string().optional(),
+	catalog: z.array(EnvironmentCatalogEntrySchema).optional().default([])
+});
+
+export type EnvironmentPreferences = z.infer<typeof EnvironmentPreferencesSchema>;
+export type EnvironmentCatalogEntry = z.infer<typeof EnvironmentCatalogEntrySchema>;

package/src/environment/environment.local.descriptor.ts

@@ -0,0 +1,45 @@
+/**
+ * Local Environment Descriptor
+ *
+ * Built-in local development environment (http://localhost:5173).
+ * Default in development builds; staging is default for compiled/production builds.
+ * Auto-discovered by the runtime.
+ */
+
+import type { EnvironmentDescriptor } from './kinds/environment.schema';
+
+const descriptor: EnvironmentDescriptor = {
+	kind: 'config/environment',
+	id: 'local',
+	name: 'Local',
+	description: 'Local development environment (*.vibes.local)',
+	apiUrl: 'http://localhost:5173',
+	apiUrlEnvVar: 'VIBES_API_URL',
+	apps: {
+		home: 'https://vibes.local',
+		ai: 'https://ai.vibes.local',
+		// tools merged into ai — kept as alias for backward compat
+		tools: 'https://ai.vibes.local',
+		account: 'https://account.vibes.local',
+		auth: 'https://auth.vibes.local',
+		platform: 'https://platform.vibes.local',
+		chat: 'https://chat.vibes.local',
+		system: 'https://system.vibes.local',
+		workbench: 'https://workbench.vibes.local',
+		creative: 'https://creative.vibes.local',
+		knowledge: 'https://knowledge.vibes.local',
+		runnable: 'https://runnable.vibes.local',
+		bridge: 'https://bridge.vibes.local',
+		docs: 'https://docs.vibes.local',
+		app: 'https://app.vibes.local',
+		casework: 'https://maplewood.vibes.local',
+		conjure: 'https://conjure.vibes.local',
+		assets: 'https://assets.vibes.local',
+		template: 'https://template.vibes.local',
+		vibesos: 'https://os.vibes.local'
+	},
+	isDefault: false,
+	enabled: true
+};
+
+export default descriptor;

package/src/environment/environment.plugin.ts

@@ -0,0 +1,31 @@
+/**
+ * Environment Runtime Plugin
+ *
+ * Registers the config/environment kind for named environment configurations.
+ * Environment descriptors and config manifest are auto-discovered.
+ */
+
+import { createRuntimePlugin } from '@vibesdotdev/runtime';
+import { environmentKind } from './kinds';
+import localEnvironmentDescriptor from './environment.local.descriptor';
+import stagingEnvironmentDescriptor from './environment.staging.descriptor';
+import productionEnvironmentDescriptor from './environment.production.descriptor';
+import environmentConfigDescriptor from './environment.config.descriptor';
+
+export default createRuntimePlugin({
+	id: 'environment',
+	name: 'Environment',
+	description: 'Named environment configurations for API targeting',
+
+	// Depends on config for the config/manifest kind
+	dependencies: ['config'],
+
+	kinds: [environmentKind],
+
+	descriptors: [
+		localEnvironmentDescriptor,
+		stagingEnvironmentDescriptor,
+		productionEnvironmentDescriptor,
+		environmentConfigDescriptor
+	]
+});

package/src/environment/environment.production.descriptor.ts

@@ -0,0 +1,40 @@
+/**
+ * Production Environment Descriptor
+ *
+ * Built-in production environment (vibes.dev).
+ * Auto-discovered by the runtime.
+ */
+
+import type { EnvironmentDescriptor } from './kinds/environment.schema';
+
+const descriptor: EnvironmentDescriptor = {
+	kind: 'config/environment',
+	id: 'production',
+	name: 'Production',
+	description: 'Production environment (vibes.dev)',
+	apiUrl: 'https://vibes.dev',
+	apiUrlEnvVar: 'PRODUCTION_API_URL',
+	apps: {
+		home: 'https://vibes.dev',
+		ai: 'https://ai.vibes.dev',
+		// tools merged into ai — kept as alias for backward compat
+		tools: 'https://ai.vibes.dev',
+		account: 'https://account.vibes.dev',
+		auth: 'https://auth.vibes.dev',
+		platform: 'https://platform.vibes.dev',
+		chat: 'https://chat.vibes.dev',
+		system: 'https://system.vibes.dev',
+		workbench: 'https://workbench.vibes.dev',
+		creative: 'https://creative.vibes.dev',
+		knowledge: 'https://knowledge.vibes.dev',
+		runnable: 'https://runnable.vibes.dev',
+		bridge: 'https://bridge.vibes.dev',
+		docs: 'https://docs.vibes.dev',
+		app: 'https://app.vibes.dev',
+		casework: 'https://maplewood.vibes.dev'
+	},
+	isDefault: false,
+	enabled: true
+};
+
+export default descriptor;

package/src/environment/environment.staging.descriptor.ts

@@ -0,0 +1,25 @@
+/**
+ * Staging Environment Descriptor
+ *
+ * Built-in staging environment (staging.vibes.dev).
+ * Default for compiled/production builds.
+ * Auto-discovered by the runtime.
+ */
+
+import type { EnvironmentDescriptor } from './kinds/environment.schema';
+
+const descriptor: EnvironmentDescriptor = {
+	kind: 'config/environment',
+	id: 'staging',
+	name: 'Staging',
+	description: 'Staging environment (staging.vibes.dev)',
+	apiUrl: 'https://staging.vibes.dev',
+	apiUrlEnvVar: 'STAGING_API_URL',
+	apps: {
+		home: 'https://staging.vibes.dev'
+	},
+	isDefault: false,
+	enabled: true
+};
+
+export default descriptor;

package/src/environment/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Environment Module
+ *
+ * Provides named environment configurations for API targeting.
+ */
+
+// Config schema export
+export {
+	EnvironmentPreferencesSchema,
+	type EnvironmentPreferences
+} from './environment.config.schema';
+export {
+	loadCurrentEnvironmentSelection,
+	loadEnvironmentCatalog,
+	resolveConfiguredEnvironmentDescriptor,
+	resolveCurrentEnvironmentConfig,
+	saveCurrentEnvironmentSelection,
+	saveEnvironmentCatalog,
+	saveEnvironmentSelection,
+	type EnvironmentCatalogEntry,
+	type EnvironmentTier
+} from './current.ts';

package/src/environment/kinds/environment.default.ts

@@ -0,0 +1,57 @@
+/**
+ * Default Environment Implementation
+ *
+ * Standard implementation that provides access to environment configuration.
+ */
+
+import type { KindContext, RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/kind';
+import type { EnvironmentDescriptor } from './environment.schema';
+import type { EnvironmentImplementation } from './environment.interface';
+import { readRuntimeEnv } from '../../env.runtime.ts';
+
+export class DefaultEnvironment implements EnvironmentImplementation {
+	readonly id: string;
+	readonly kind = 'config/environment';
+	readonly priority = 0;
+	readonly descriptor: EnvironmentDescriptor;
+	private readonly resolvedApiUrl: string;
+
+	constructor(descriptor: RuntimeDescriptor, _context: KindContext) {
+		this.id = descriptor.id;
+		this.descriptor = descriptor as EnvironmentDescriptor;
+		this.resolvedApiUrl = this.resolveApiUrl(this.descriptor);
+	}
+
+	get apiUrl(): string {
+		return this.resolvedApiUrl;
+	}
+
+	getHeader(name: string): string | undefined {
+		return this.descriptor.headers?.[name];
+	}
+
+	getHeaders(): Record<string, string> {
+		return this.descriptor.headers ?? {};
+	}
+
+	getVariable(name: string): string | undefined {
+		return this.descriptor.variables?.[name];
+	}
+
+	getVariables(): Record<string, string> {
+		return this.descriptor.variables ?? {};
+	}
+
+	private resolveApiUrl(descriptor: EnvironmentDescriptor): string {
+		const envVar = descriptor.apiUrlEnvVar;
+		if (!envVar) return descriptor.apiUrl;
+		const envValue = readRuntimeEnv(envVar);
+		if (!envValue || envValue.trim() === '') return descriptor.apiUrl;
+		try {
+			new URL(envValue);
+			return envValue;
+		} catch {
+			return descriptor.apiUrl;
+		}
+	}
+}

package/src/environment/kinds/environment.interface.ts

@@ -0,0 +1,10 @@
+/**
+ * Environment Implementation Interface
+ *
+ * Defines the contract for environment implementations.
+ */
+
+import type { EnvironmentDescriptor } from './environment.schema';
+import type { RuntimeImplementation } from '@vibesdotdev/runtime/schemas/asset';
+
+export type { EnvironmentImplementation } from './schemas/environment.interface.schema.ts';

package/src/environment/kinds/environment.kind.ts

@@ -0,0 +1,69 @@
+/**
+ * Environment Kind Definition
+ *
+ * Registers the config/environment kind for named environment configurations.
+ */
+
+import type { RuntimeKindDescriptor, KindContext, RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/kind';
+import type { RuntimeScope } from '@vibesdotdev/runtime/schemas/scope';
+import { EnvironmentDescriptorSchema, type EnvironmentDescriptor } from './environment.schema';
+import type { EnvironmentImplementation } from './environment.interface';
+import { DefaultEnvironment } from './environment.default';
+import { resolveConfiguredEnvironmentDescriptor } from '../current.ts';
+import { readRuntimeEnv } from '../../env.runtime.ts';
+
+/**
+ * Resolution strategy for environments:
+ * 1. Check config/manifest for user's currentEnvironment preference
+ * 2. Fall back to descriptor marked isDefault
+ * 3. Public consumer CLI binary → 'production' (the public-binary build defines
+ *    `process.env.VIBES_CLI_MODE` as `"public"` via Bun's static substitution; the
+ *    literal expression below is replaced at compile time so the check is a constant
+ *    fold in shipped binaries and a runtime read in source-mode dev runs)
+ * 4. Fall back to 'staging' in compiled/production builds (NODE_ENV === 'production')
+ * 5. Fall back to 'local' environment in development
+ * 6. Fall back to first candidate
+ */
+async function resolveEnvironment(
+	candidates: RuntimeDescriptor[],
+	_scope: RuntimeScope,
+	context: KindContext
+): Promise<EnvironmentDescriptor | undefined> {
+	if (candidates.length === 0) return undefined;
+	const typed = candidates as EnvironmentDescriptor[];
+	if (typed.length === 1) return typed[0];
+
+	void context;
+	const configured = await resolveConfiguredEnvironmentDescriptor(typed);
+	if (configured) return configured;
+
+	// Fall back to descriptor marked as default
+	const defaultEnv = typed.find((d) => d.isDefault);
+	if (defaultEnv) return defaultEnv;
+
+	// Public consumer CLI binary always defaults to production unless overridden above.
+	if (readRuntimeEnv('VIBES_CLI_MODE') === 'public') {
+		const productionEnv = typed.find((d) => d.id === 'production');
+		if (productionEnv) return productionEnv;
+	}
+
+	// In compiled/production builds default to 'staging'; in dev default to 'local'
+	const isProduction = readRuntimeEnv('NODE_ENV') === 'production';
+	const buildDefault = typed.find((d) => d.id === (isProduction ? 'staging' : 'local'));
+	if (buildDefault) return buildDefault;
+
+	// Last resort: first candidate
+	return typed[0];
+}
+
+export const environmentKind: RuntimeKindDescriptor<
+	EnvironmentDescriptor,
+	EnvironmentImplementation,
+	KindContext
+> = {
+	id: 'config/environment',
+	descriptorSchema: EnvironmentDescriptorSchema,
+	defaultImplementation: DefaultEnvironment,
+	resolve: resolveEnvironment,
+	contexts: [] // No direct context deps, uses runtime.query internally
+};

package/src/environment/kinds/environment.schema.ts

@@ -0,0 +1,57 @@
+/**
+ * Environment Descriptor Schema
+ *
+ * Defines the structure for named environment configurations.
+ */
+
+import * as z from 'zod/v4';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
+
+export const EnvironmentDescriptorSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('config/environment'),
+
+	/** Base URL for API calls (the canonical / home origin) */
+	apiUrl: z.string().url(),
+
+	/**
+	 * Per-app origin map. Keys are app IDs (e.g. `'ai'`, `'tools'`, `'account'`,
+	 * `'auth'`, `'platform'`, `'chat'`, `'home'`); values are the full origin URL
+	 * the app is served from in this environment.
+	 *
+	 * Open-shaped on purpose: third-party apps embedding the runtime can add
+	 * their own app IDs. Storage manifests declare `ownerApp: '<id>'` in their
+	 * `adapterConfig['storage.cloud-api']` and the cloud-api adapter composes
+	 * `${apps[ownerApp]}/api/storage/${namespace}` to route reads to the
+	 * owning app's cloud worker.
+	 */
+	apps: z.record(z.string(), z.string().url()).default({}),
+
+	/** Optional environment variable that overrides apiUrl at runtime */
+	apiUrlEnvVar: z.string().optional(),
+
+	/** Whether this is the default environment when no preference is set */
+	isDefault: z.boolean().optional(),
+
+	/** Custom headers to include in API requests */
+	headers: z.record(z.string(), z.string()).optional(),
+
+	/** Environment variables available to tools */
+	variables: z.record(z.string(), z.string()).optional(),
+
+	/** Kubernetes integration */
+	kubernetes: z
+		.object({
+			context: z.string(),
+			namespace: z.string()
+		})
+		.optional(),
+
+	/** SigNoz observability integration */
+	signoz: z
+		.object({
+			endpoint: z.string()
+		})
+		.optional()
+});
+
+export type { EnvironmentDescriptor } from './schemas/environment.schema.ts';

package/src/environment/kinds/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Environment Kind Exports
+ */
+
+export { environmentKind } from './environment.kind';
+export { EnvironmentDescriptorSchema, type EnvironmentDescriptor } from './environment.schema';
+export type { EnvironmentImplementation } from './environment.interface';
+export { DefaultEnvironment } from './environment.default';

package/src/environment/kinds/schemas/environment.interface.schema.ts

@@ -0,0 +1,11 @@
+import type { EnvironmentDescriptor } from './environment.schema';
+
+export interface EnvironmentImplementation {
+	readonly id: string;
+	readonly descriptor: EnvironmentDescriptor;
+	readonly apiUrl: string;
+	getHeader(name: string): string | undefined;
+	getHeaders(): Record<string, string>;
+	getVariable(name: string): string | undefined;
+	getVariables(): Record<string, string>;
+}

package/src/environment/kinds/schemas/environment.schema.ts

@@ -0,0 +1,24 @@
+export type EnvironmentDescriptor = {
+	kind: 'config/environment';
+	id: string;
+	name?: string;
+	description?: string;
+	tags?: string[];
+	hardware?: string[];
+	enabled?: boolean;
+	requiredContext?: string[];
+	optionalContext?: string[];
+	apiUrl: string;
+	/**
+	 * Per-app origin map keyed by app ID. Storage manifests use this with
+	 * `adapterConfig['storage.cloud-api'].ownerApp` to route cross-app reads.
+	 * Open-shaped so third-party apps can add their own IDs.
+	 */
+	apps?: Record<string, string>;
+	apiUrlEnvVar?: string;
+	isDefault?: boolean;
+	headers?: Record<string, string>;
+	variables?: Record<string, string>;
+	kubernetes?: { context: string; namespace: string };
+	signoz?: { endpoint: string };
+};

package/src/environment/schemas/current.schema.ts

@@ -0,0 +1,21 @@
+export type EnvironmentTier = 'local' | 'dev' | 'staging' | 'production';
+
+export interface EnvironmentCatalogEntry {
+	id?: string;
+	name: string;
+	apiUrl: string;
+	tier?: EnvironmentTier;
+	description?: string;
+	isDefault?: boolean;
+	headers?: Record<string, string>;
+	variables?: Record<string, string>;
+	databaseUrl?: string;
+	secrets?: Record<string, string>;
+}
+
+export interface CurrentEnvironmentConfig {
+	id: string;
+	name: string;
+	apiUrl: string;
+	tier?: EnvironmentTier;
+}

package/src/environment/schemas/environment.config.schema.ts

@@ -0,0 +1,3 @@
+export type EnvironmentPreferences = {
+	currentEnvironment?: string;
+};

package/src/extensions/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Config Extensions Module
+ *
+ * Surface-specific manifest extensions with lazy component loading.
+ */
+
+// Core types
+export type {
+	ExtensionSurface,
+	LazyComponentLoader,
+	LazyComponentOverride,
+	ManifestSurfaceExtension,
+	LoadedExtension
+} from './types.ts';
+
+// Registry functions
+export {
+	registerExtension,
+	getExtension,
+	hasExtension,
+	loadExtension,
+	getAllExtensionKeys,
+	getExtensionsForSurface,
+	clearExtensionCache,
+	clearAllExtensions
+} from './registry.ts';