@vibesdotdev/cli 0.0.1

package/package.json

@@ -0,0 +1,186 @@
+{
+  "name": "@vibesdotdev/cli",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "vibes": "./bin/vibes.ts"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./bootstrap": {
+      "types": "./dist/bootstrap.d.ts",
+      "bun": "./src/bootstrap.ts",
+      "import": "./dist/bootstrap.js",
+      "default": "./dist/bootstrap.js"
+    },
+    "./plugin": {
+      "types": "./dist/cli.plugin.d.ts",
+      "bun": "./src/cli.plugin.ts",
+      "import": "./dist/cli.plugin.js",
+      "default": "./dist/cli.plugin.js"
+    },
+    "./cli.plugin": {
+      "types": "./dist/cli.plugin.d.ts",
+      "bun": "./src/cli.plugin.ts",
+      "import": "./dist/cli.plugin.js",
+      "default": "./dist/cli.plugin.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "bun": "./src/config.ts",
+      "import": "./dist/config.js",
+      "default": "./dist/config.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "bun": "./src/core/index.ts",
+      "import": "./dist/core/index.js",
+      "default": "./dist/core/index.js"
+    },
+    "./cli/runtime/shared/context": {
+      "types": "./dist/core/runtime/shared/context.d.ts",
+      "bun": "./src/core/runtime/shared/context.ts",
+      "import": "./dist/core/runtime/shared/context.js",
+      "default": "./dist/core/runtime/shared/context.js"
+    },
+    "./cli/runtime/shared/options": {
+      "types": "./dist/core/runtime/shared/options.d.ts",
+      "bun": "./src/core/runtime/shared/options.ts",
+      "import": "./dist/core/runtime/shared/options.js",
+      "default": "./dist/core/runtime/shared/options.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "bun": "./src/*.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    },
+    "./*.js": {
+      "types": "./dist/*.d.ts",
+      "bun": "./src/*.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    },
+    "./*/*": {
+      "types": "./dist/*/*.d.ts",
+      "bun": "./src/*/*.ts",
+      "import": "./dist/*/*.js",
+      "default": "./dist/*/*.js"
+    },
+    "./*/*.js": {
+      "types": "./dist/*/*.d.ts",
+      "bun": "./src/*/*.ts",
+      "import": "./dist/*/*.js",
+      "default": "./dist/*/*.js"
+    },
+    "./*/*/*": {
+      "types": "./dist/*/*/*.d.ts",
+      "bun": "./src/*/*/*.ts",
+      "import": "./dist/*/*/*.js",
+      "default": "./dist/*/*/*.js"
+    },
+    "./*/*/*.js": {
+      "types": "./dist/*/*/*.d.ts",
+      "bun": "./src/*/*/*.ts",
+      "import": "./dist/*/*/*.js",
+      "default": "./dist/*/*/*.js"
+    },
+    "./*/*/*/*": {
+      "types": "./dist/*/*/*/*.d.ts",
+      "bun": "./src/*/*/*/*.ts",
+      "import": "./dist/*/*/*/*.js",
+      "default": "./dist/*/*/*/*.js"
+    },
+    "./*/*/*/*.js": {
+      "types": "./dist/*/*/*/*.d.ts",
+      "bun": "./src/*/*/*/*.ts",
+      "import": "./dist/*/*/*/*.js",
+      "default": "./dist/*/*/*/*.js"
+    },
+    "./*/*/*/*/*": {
+      "types": "./dist/*/*/*/*/*.d.ts",
+      "bun": "./src/*/*/*/*/*.ts",
+      "import": "./dist/*/*/*/*/*.js",
+      "default": "./dist/*/*/*/*/*.js"
+    },
+    "./*/*/*/*/*.js": {
+      "types": "./dist/*/*/*/*/*.d.ts",
+      "bun": "./src/*/*/*/*/*.ts",
+      "import": "./dist/*/*/*/*/*.js",
+      "default": "./dist/*/*/*/*/*.js"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vibesdotdev/monorepo.git",
+    "directory": "packages/cli"
+  },
+  "peerDependencies": {
+    "@vibesdotdev/config": "0.0.1",
+    "@vibesdotdev/localdb": "0.0.1",
+    "@vibesdotdev/runtime": "0.0.1",
+    "@vibesdotdev/logging": "0.0.1",
+    "@vibesdotdev/runtime-surface-cli": "0.0.1",
+    "@vibesdotdev/storage": "0.0.1",
+    "@vibesdotdev/tui": "0.0.1"
+  },
+  "dependencies": {
+    "@vibesdotdev/client": "0.1.0",
+    "@vibesdotdev/config": "0.0.1",
+    "@vibesdotdev/localdb": "0.0.1",
+    "@vibesdotdev/logging": "0.0.1",
+    "@vibesdotdev/runtime": "0.0.1",
+    "@vibesdotdev/runtime-bun": "0.0.0",
+    "@vibesdotdev/runtime-environment-bun": "0.0.0",
+    "@vibesdotdev/storage": "0.0.1",
+    "@vibesdotdev/tui": "0.0.1",
+    "commander": "^14.0.3",
+    "yaml": "^2.9.0",
+    "zod": "^4.3.6",
+    "@vibesdotdev/runtime-surface-cli": "0.0.1"
+  },
+  "scripts": {
+    "test": "bun test",
+    "check": "bun --bun tsc -p tsconfig.json --noEmit",
+    "build": "tsc -p tsconfig.json"
+  },
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src",
+    "bin",
+    "README.md",
+    "SPEC.md",
+    "LICENSE",
+    "!src/**/__tests__/**",
+    "!src/**/__stubs__/**",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.spec.ts",
+    "!src/**/*.spec.tsx",
+    "!dist/**/__tests__/**",
+    "!dist/**/__stubs__/**",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.d.ts.map",
+    "!dist/**/*.spec.js",
+    "!dist/**/*.spec.js.map",
+    "!dist/**/*.spec.d.ts",
+    "!dist/**/*.spec.d.ts.map"
+  ],
+  "vibes": {
+    "visibility": "public-framework"
+  }
+}

package/src/api/client/factory.ts

@@ -0,0 +1,265 @@
+/**
+ * API client factory - creates configured clients for CLI commands
+ * This is the central service that replaces direct database access
+ * Uses the cfg -> env -> auth hooks system for configuration
+ */
+
+import { getRuntimeEnv } from '@vibesdotdev/runtime';
+import type { RuntimeContext } from '../types.ts';
+import type { APIClientConfig } from '../schemas/types.ts';
+import { apiClientConfigSchema } from '../schemas/common.ts';
+import { VibesClient } from '@vibesdotdev/client/core';
+import type { ClientConfig } from '@vibesdotdev/client/core';
+import { createCLIClient, createHttp2Fetch } from '@vibesdotdev/client/node';
+import { getContext } from '@vibesdotdev/cli/core/runtime/context';
+
+type EnvironmentContext = {
+	name?: string;
+	url?: string;
+	data?: {
+		apiUrl?: string;
+		headers?: Record<string, string>;
+	};
+	headers?: Record<string, string>;
+};
+
+type AuthCredentials = {
+	apiKey?: string;
+	sessionToken?: string;
+	refreshToken?: string;
+	expiresAt?: string;
+};
+
+function getRuntimeEnvironment(context?: RuntimeContext): EnvironmentContext | null {
+	const runtimeCtx = (context as unknown as Record<string, unknown>) ?? {};
+	const environment = (runtimeCtx.environment ?? getContext().environment) as
+		| EnvironmentContext
+		| undefined;
+	return environment ?? null;
+}
+
+async function resolveDebugFlag(context?: RuntimeContext): Promise<boolean> {
+	const runtimeCtx = (context as unknown as Record<string, unknown>) ?? {};
+	const ctxWithConfig = (runtimeCtx.config ? runtimeCtx : getContext()) as {
+		config?: { get: (key: string, scope: string) => Promise<unknown> };
+	};
+
+	if (!ctxWithConfig.config?.get) {
+		return false;
+	}
+
+	try {
+		const debug = await ctxWithConfig.config.get('debug', 'global');
+		return typeof debug === 'boolean' ? debug : false;
+	} catch {
+		return false;
+	}
+}
+
+function buildAuthConfig(
+	credentials: AuthCredentials | null | undefined,
+	baseUrl: string
+): ClientConfig['auth'] {
+	if (!credentials) {
+		return { type: 'none' };
+	}
+
+	if (credentials.apiKey) {
+		return { type: 'apiKey', credentials: credentials.apiKey };
+	}
+
+	if (credentials.sessionToken) {
+		return {
+			type: 'bearer',
+			tokenProvider: async () => credentials.sessionToken ?? null,
+			refreshHandler: async () => {
+				if (!credentials.refreshToken) return null;
+				try {
+					const response = await fetch(`${baseUrl}/api/auth/session`, {
+						method: 'POST',
+						headers: { 'Content-Type': 'application/json' },
+						body: JSON.stringify({ refreshToken: credentials.refreshToken })
+					});
+
+					if (!response.ok) {
+						return null;
+					}
+
+					const data = (await response.json()) as {
+						token?: string;
+						refreshToken?: string;
+					};
+
+					if (!data.token) {
+						return null;
+					}
+
+					return {
+						type: 'bearer',
+						credentials: data.token,
+						tokenProvider: async () => data.token ?? null
+					};
+				} catch {
+					return null;
+				}
+			}
+		};
+	}
+
+	return { type: 'none' };
+}
+
+function applyEnvironmentHeaders(
+	config: ClientConfig,
+	headers: Record<string, string> | undefined
+): ClientConfig {
+	if (!headers || Object.keys(headers).length === 0) {
+		return config;
+	}
+
+	const beforeRequest = async (request: Request): Promise<Request> => {
+		const updated = new Headers(request.headers);
+		for (const [key, value] of Object.entries(headers)) {
+			if (value !== undefined) {
+				updated.set(key, value);
+			}
+		}
+		return new Request(request, { headers: updated });
+	};
+
+	return {
+		...config,
+		hooks: {
+			...config.hooks,
+			beforeRequest
+		}
+	};
+}
+
+/**
+ * Create a configured API client using current environment and auth settings
+ * This is what ALL CLI modules should use instead of direct database access
+ *
+ * Uses the hooks system: cfg -> env -> auth -> api
+ */
+export async function createConfiguredClient(context?: RuntimeContext): Promise<VibesClient> {
+	const runtimeCtx = context ?? (getContext() as RuntimeContext);
+	const environment = getRuntimeEnvironment(runtimeCtx);
+	const credentials = ((runtimeCtx as unknown as Record<string, unknown>)?.authCredentials ??
+		getContext().authCredentials) as AuthCredentials | undefined;
+
+	const resolvedBaseUrl =
+		environment?.data?.apiUrl ??
+		environment?.url ??
+		getRuntimeEnv('VIBES_API_URL');
+
+	const baseUrl = resolvedBaseUrl ?? 'http://localhost:5173';
+	const debug = await resolveDebugFlag(runtimeCtx);
+
+	const initialConfig: ClientConfig = {
+		baseUrl,
+		auth: buildAuthConfig(credentials, baseUrl),
+		debug,
+		fetch: createHttp2Fetch(baseUrl) as typeof fetch
+	};
+
+	const configWithHeaders = applyEnvironmentHeaders(
+		initialConfig,
+		environment?.data?.headers ?? environment?.headers
+	);
+
+	return createCLIClient(configWithHeaders);
+}
+
+/**
+ * Create API client configuration for debugging/inspection
+ */
+export async function createAPIClientConfig(context?: RuntimeContext): Promise<APIClientConfig> {
+	const runtimeCtx = context ?? (getContext() as RuntimeContext);
+	const environment = getRuntimeEnvironment(runtimeCtx);
+
+	if (!environment) {
+		throw new Error('No environment configured');
+	}
+
+	const baseUrl = environment.data?.apiUrl ?? environment.url;
+	if (!baseUrl) {
+		throw new Error('No environment configured');
+	}
+
+	const credentials = ((runtimeCtx as unknown as Record<string, unknown>)?.authCredentials ??
+		getContext().authCredentials) as AuthCredentials | undefined;
+
+	const auth: APIClientConfig['auth'] = credentials?.apiKey
+		? { type: 'apiKey', apiKey: credentials.apiKey }
+		: credentials?.sessionToken
+			? {
+					type: 'session',
+					sessionToken: credentials.sessionToken,
+					refreshToken: credentials.refreshToken ?? undefined
+				}
+			: { type: 'none' };
+
+	const tierCandidate =
+		environment.data && typeof environment.data === 'object'
+			? (environment.data as { tier?: string }).tier
+			: undefined;
+	const tier: APIClientConfig['tier'] =
+		tierCandidate === 'dev' ||
+		tierCandidate === 'staging' ||
+		tierCandidate === 'production' ||
+		tierCandidate === 'local'
+			? tierCandidate
+			: 'local';
+
+	const debug = await resolveDebugFlag(runtimeCtx);
+
+	return apiClientConfigSchema.parse({
+		baseUrl,
+		environment: environment.name ?? 'local',
+		tier,
+		auth,
+		headers: environment.data?.headers ?? environment.headers,
+		timeout: 30000,
+		retries: 3,
+		debug
+	});
+}
+
+/**
+ * Test API connection
+ */
+export async function testAPIConnection(
+	endpoint = '/api/health',
+	context?: RuntimeContext
+): Promise<{
+	success: boolean;
+	status: number;
+	latency: number;
+	error?: string;
+}> {
+	try {
+		const client = await createConfiguredClient(context);
+		const start = Date.now();
+
+		const response = await client.request(endpoint, {
+			method: 'GET',
+			timeout: 10000
+		});
+
+		const latency = Date.now() - start;
+
+		return {
+			success: true,
+			status: 200, // VibesClient abstracts status codes
+			latency
+		};
+	} catch (error) {
+		return {
+			success: false,
+			status: 0,
+			latency: 0,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}

package/src/api/schemas/common.ts

@@ -0,0 +1,50 @@
+import z from 'zod/v4';
+
+/**
+ * API client configuration schemas
+ */
+export const apiClientConfigSchema = z.object({
+	baseUrl: z.url(),
+	environment: z.string(),
+	tier: z.enum(['local', 'dev', 'staging', 'production']),
+	auth: z.discriminatedUnion('type', [
+		z.object({
+			type: z.literal('none')
+		}),
+		z.object({
+			type: z.literal('apiKey'),
+			apiKey: z.string()
+		}),
+		z.object({
+			type: z.literal('session'),
+			sessionToken: z.string(),
+			refreshToken: z.string().optional()
+		})
+	]),
+	headers: z.record(z.string(), z.string()).optional(),
+	timeout: z.number().default(30000),
+	retries: z.number().default(3),
+	debug: z.boolean().default(false)
+});
+
+/**
+ * API client test schemas
+ */
+export const apiTestSchema = z.object({
+	endpoint: z.string().optional(),
+	method: z.enum(['GET', 'POST', 'PUT', 'DELETE']).default('GET'),
+	timeout: z.number().optional()
+});
+
+/**
+ * API connection status schema
+ */
+export const apiConnectionStatusSchema = z.object({
+	connected: z.boolean(),
+	environment: z.string(),
+	baseUrl: z.string(),
+	authType: z.enum(['none', 'apiKey', 'session']),
+	lastChecked: z.iso.datetime(),
+	latency: z.number().optional(),
+	error: z.string().optional()
+});

package/src/api/schemas/types.ts

@@ -0,0 +1,32 @@
+import type { z } from 'zod/v4';
+import type { apiClientConfigSchema, apiTestSchema, apiConnectionStatusSchema } from './common.ts';
+
+export type APIClientConfig = z.infer<typeof apiClientConfigSchema>;
+export type APITestInput = z.infer<typeof apiTestSchema>;
+export type APIConnectionStatus = z.infer<typeof apiConnectionStatusSchema>;
+
+/**
+ * API service result types
+ */
+export interface APITestResult {
+	success: boolean;
+	status: APIConnectionStatus;
+	response?: {
+		status: number;
+		statusText: string;
+		headers: Record<string, string>;
+		data?: unknown;
+	};
+	error?: string;
+}
+
+export interface APIDebugResult {
+	config: APIClientConfig;
+	status: APIConnectionStatus;
+	diagnostics: {
+		environmentResolved: boolean;
+		authResolved: boolean;
+		baseUrlValid: boolean;
+		credentialsValid: boolean;
+	};
+}

package/src/api/services/api.ts

@@ -0,0 +1,129 @@
+/**
+ * API service - provides API testing and debugging commands
+ */
+
+import type { RuntimeContext } from '../types.ts';
+import type {
+	APITestInput,
+	APITestResult,
+	APIDebugResult,
+	APIConnectionStatus
+} from '../schemas/types.ts';
+import { apiTestSchema } from '../schemas/common.ts';
+import { createAPIClientConfig, testAPIConnection } from '../client/factory.ts';
+import { loadStoredCredentials, loadStoredEnvironment } from '@vibesdotdev/config/client';
+
+/**
+ * Execute API test command
+ */
+export async function executeAPITest(
+	input: APITestInput,
+	context: RuntimeContext
+): Promise<APITestResult> {
+	try {
+		const validatedInput = apiTestSchema.parse(input);
+
+		const environment = await loadStoredEnvironment();
+		if (!environment) {
+			throw new Error('No environment configured');
+		}
+
+		const credentials = await loadStoredCredentials(environment.name);
+		let authType: 'none' | 'apiKey' | 'session' = 'none';
+		if (credentials?.apiKey) authType = 'apiKey';
+		else if (credentials?.sessionToken) authType = 'session';
+
+		// Test connection
+		const testResult = await testAPIConnection(validatedInput.endpoint, context);
+
+		const status: APIConnectionStatus = {
+			connected: testResult.success,
+			environment: environment.name,
+			baseUrl: environment.apiUrl,
+			authType,
+			lastChecked: new Date().toISOString(),
+			latency: testResult.latency,
+			error: testResult.error
+		};
+
+		const result: APITestResult = {
+			success: testResult.success,
+			status
+		};
+
+		if (testResult.success) {
+			result.response = {
+				status: testResult.status,
+				statusText: 'OK',
+				headers: {},
+				data: { message: 'Connection successful' }
+			};
+		} else {
+			result.error = testResult.error;
+		}
+
+		return result;
+	} catch (error) {
+		context.logger?.error('Failed to test API', error);
+		throw error;
+	}
+}
+
+/**
+ * Execute API debug command
+ */
+export async function executeAPIDebug(context: RuntimeContext): Promise<APIDebugResult> {
+	try {
+		// Get API client config
+		const config = await createAPIClientConfig(context);
+
+		// Get current environment
+		const environment = await loadStoredEnvironment();
+		const credentials = await loadStoredCredentials(environment?.name);
+
+		// Run diagnostics
+		const diagnostics = {
+			environmentResolved: !!environment,
+			authResolved: !!(credentials?.apiKey || credentials?.sessionToken),
+			baseUrlValid: !!environment?.apiUrl && environment.apiUrl.startsWith('http'),
+			credentialsValid: !!(
+				credentials?.apiKey ||
+				(credentials?.sessionToken && !isTokenExpired(credentials.expiresAt))
+			)
+		};
+
+		// Get connection status
+		const testResult = await testAPIConnection('/api/health', context);
+		const status: APIConnectionStatus = {
+			connected: testResult.success,
+			environment: environment?.name || 'none',
+			baseUrl: environment?.apiUrl || 'none',
+			authType: config.auth.type,
+			lastChecked: new Date().toISOString(),
+			latency: testResult.latency,
+			error: testResult.error
+		};
+
+		return {
+			config,
+			status,
+			diagnostics
+		};
+	} catch (error) {
+		context.logger?.error('Failed to debug API', error);
+		throw error;
+	}
+}
+
+/**
+ * Helper to check if token is expired
+ */
+function isTokenExpired(expiresAt?: string): boolean {
+	if (!expiresAt) return false;
+	try {
+		const expiry = new Date(expiresAt);
+		return expiry.getTime() < Date.now();
+	} catch {
+		return false;
+	}
+}

package/src/api/types.ts

@@ -0,0 +1,12 @@
+/**
+ * API module type exports
+ */
+
+export type { RuntimeContext, UIToolkit } from '../types.ts';
+export type {
+	APIClientConfig,
+	APITestInput,
+	APITestResult,
+	APIDebugResult,
+	APIConnectionStatus
+} from './schemas/types.ts';