@vercel/cli-config 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @vercel/cli-config
+
+Shared utilities for Vercel [global configuration files](https://vercel.com/docs/project-configuration/global-configuration).
+
+This package contains the pure config-path, parsing, defaulting, and file read/write helpers used by packages that need access to global configration.

package/dist/cli-config.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { AuthConfig, GlobalConfig } from './types';
+type WriteConfigFileOptions = {
+    indent?: number | string;
+    mode?: number;
+};
+export declare const defaultGlobalConfig: GlobalConfig;
+export declare function getDefaultAuthConfig(): AuthConfig;
+export declare const defaultAuthConfig: AuthConfig;
+export declare function parseGlobalConfig(value: unknown): GlobalConfig;
+export declare function parseAuthConfig(value: unknown): AuthConfig;
+export declare function readConfigFile<S extends z.ZodType>(configPath: string, schema: S): z.output<S>;
+export declare function writeConfigFile<S extends z.ZodType>(configPath: string, schema: S, config: z.output<S>, options?: WriteConfigFileOptions): void;
+export declare function getGlobalPathConfig(): string;
+export declare function getConfigFilePath(configDir: string): string;
+export declare function getAuthConfigFilePath(configDir: string): string;
+export declare function readGlobalConfigFile(configPath: string): GlobalConfig;
+export declare function writeGlobalConfigFile(configPath: string, config: GlobalConfig): void;
+export declare function readAuthConfigFile(configPath: string): AuthConfig;
+export declare function writeAuthConfigFile(configPath: string, authConfig: AuthConfig): void;
+export {};

package/dist/cli-config.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAuthConfig = exports.defaultGlobalConfig = void 0;
+exports.getDefaultAuthConfig = getDefaultAuthConfig;
+exports.parseGlobalConfig = parseGlobalConfig;
+exports.parseAuthConfig = parseAuthConfig;
+exports.readConfigFile = readConfigFile;
+exports.writeConfigFile = writeConfigFile;
+exports.getGlobalPathConfig = getGlobalPathConfig;
+exports.getConfigFilePath = getConfigFilePath;
+exports.getAuthConfigFilePath = getAuthConfigFilePath;
+exports.readGlobalConfigFile = readGlobalConfigFile;
+exports.writeGlobalConfigFile = writeGlobalConfigFile;
+exports.readAuthConfigFile = readAuthConfigFile;
+exports.writeAuthConfigFile = writeAuthConfigFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = require("node:os");
+const xdg_app_paths_1 = __importDefault(require("xdg-app-paths"));
+const zod_1 = require("zod");
+const schema_1 = require("./schema");
+const DOCS_URL = 'https://vercel.com/docs/projects/project-configuration/global-configuration';
+exports.defaultGlobalConfig = {
+    '// Note': 'This is your Vercel config file. For more information see the global configuration documentation.',
+    '// Docs': `${DOCS_URL}#config.json`,
+};
+function getDefaultAuthConfig() {
+    return {
+        '// Note': 'This is your Vercel credentials file. DO NOT SHARE!',
+        '// Docs': `${DOCS_URL}#auth.json`,
+    };
+}
+exports.defaultAuthConfig = getDefaultAuthConfig();
+function parseGlobalConfig(value) {
+    return schema_1.globalConfigSchema.parse(value);
+}
+function parseAuthConfig(value) {
+    return schema_1.authConfigSchema.parse(value);
+}
+function readJsonFileSync(filePath) {
+    const content = node_fs_1.default.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '');
+    return JSON.parse(content);
+}
+function writeJsonFileSync(filePath, value, options = {}) {
+    const directory = node_path_1.default.dirname(filePath);
+    const tempFilePath = node_path_1.default.join(directory, `.${node_path_1.default.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    const content = `${JSON.stringify(value, null, options.indent ?? 2)}\n`;
+    node_fs_1.default.mkdirSync(directory, { recursive: true });
+    try {
+        node_fs_1.default.writeFileSync(tempFilePath, content, {
+            encoding: 'utf8',
+            mode: options.mode,
+        });
+        node_fs_1.default.renameSync(tempFilePath, filePath);
+    }
+    catch (error) {
+        try {
+            node_fs_1.default.rmSync(tempFilePath, { force: true });
+        }
+        catch {
+            // Best-effort cleanup for failed atomic writes.
+        }
+        throw error;
+    }
+}
+function readConfigFile(configPath, schema) {
+    return schema.parse(readJsonFileSync(configPath));
+}
+function writeConfigFile(configPath, schema, config, options) {
+    const normalizedConfig = zod_1.z.encode(schema, config);
+    writeJsonFileSync(configPath, normalizedConfig, {
+        indent: 2,
+        ...options,
+    });
+}
+function isReadableDirectory(targetPath) {
+    try {
+        return node_fs_1.default.lstatSync(targetPath).isDirectory();
+    }
+    catch (_) {
+        // We don't care which kind of error occured, it isn't a readable directory anyway.
+        return false;
+    }
+}
+function getGlobalPathConfig() {
+    const vercelDirectories = (0, xdg_app_paths_1.default)('com.vercel.cli').dataDirs();
+    const possibleConfigPaths = [
+        ...vercelDirectories, // latest vercel directory
+        node_path_1.default.join((0, node_os_1.homedir)(), '.now'), // legacy config in user's home directory
+        ...(0, xdg_app_paths_1.default)('now').dataDirs(), // legacy XDG directory
+    ];
+    return (possibleConfigPaths.find(configPath => isReadableDirectory(configPath)) ||
+        vercelDirectories[0]);
+}
+function getConfigFilePath(configDir) {
+    return node_path_1.default.join(configDir, 'config.json');
+}
+function getAuthConfigFilePath(configDir) {
+    return node_path_1.default.join(configDir, 'auth.json');
+}
+function readGlobalConfigFile(configPath) {
+    return readConfigFile(configPath, schema_1.globalConfigSchema);
+}
+function writeGlobalConfigFile(configPath, config) {
+    writeConfigFile(configPath, schema_1.globalConfigSchema, config);
+}
+function readAuthConfigFile(configPath) {
+    return readConfigFile(configPath, schema_1.authConfigSchema);
+}
+function writeAuthConfigFile(configPath, authConfig) {
+    if (authConfig.skipWrite) {
+        return;
+    }
+    writeConfigFile(configPath, schema_1.authConfigSchema, authConfig, {
+        mode: 0o600,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './schema';
+export * from './cli-config';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./cli-config"), exports);

package/dist/schema.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Zod schemas for Vercel global config types.
+ *
+ * Types are defined in types.ts (source of truth).
+ * Schemas are generated by ts-to-zod and re-exported here with runtime
+ * passthrough behavior for unrecognized config keys.
+ */
+import type { z } from 'zod';
+import type { AuthConfig, GlobalConfig, GuidanceConfig, TelemetryConfig } from './types';
+export declare const telemetryConfigSchema: z.ZodType<TelemetryConfig>;
+export declare const guidanceConfigSchema: z.ZodType<GuidanceConfig>;
+export declare const globalConfigSchema: z.ZodType<GlobalConfig>;
+export declare const authConfigSchema: z.ZodType<AuthConfig>;

package/dist/schema.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Zod schemas for Vercel global config types.
+ *
+ * Types are defined in types.ts (source of truth).
+ * Schemas are generated by ts-to-zod and re-exported here with runtime
+ * passthrough behavior for unrecognized config keys.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authConfigSchema = exports.globalConfigSchema = exports.guidanceConfigSchema = exports.telemetryConfigSchema = void 0;
+const schema_zod_1 = require("./schema.zod");
+exports.telemetryConfigSchema = schema_zod_1.telemetryConfigSchema.passthrough();
+exports.guidanceConfigSchema = schema_zod_1.guidanceConfigSchema.passthrough();
+exports.globalConfigSchema = schema_zod_1.globalConfigSchema
+    .extend({
+    telemetry: exports.telemetryConfigSchema.optional(),
+    guidance: exports.guidanceConfigSchema.optional(),
+})
+    .passthrough();
+exports.authConfigSchema = schema_zod_1.authConfigSchema.passthrough();

package/dist/schema.zod.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const telemetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const guidanceConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const authConfigSchema: z.ZodObject<{
+    '// Note': z.ZodOptional<z.ZodString>;
+    '// Docs': z.ZodOptional<z.ZodString>;
+    skipWrite: z.ZodOptional<z.ZodBoolean>;
+    token: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    tokenSource: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"flag">, z.ZodLiteral<"env">]>>;
+}, z.core.$strip>;
+export declare const globalConfigSchema: z.ZodObject<{
+    '// Note': z.ZodOptional<z.ZodString>;
+    '// Docs': z.ZodOptional<z.ZodString>;
+    currentTeam: z.ZodOptional<z.ZodString>;
+    api: z.ZodOptional<z.ZodString>;
+    telemetry: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    guidance: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/schema.zod.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalConfigSchema = exports.authConfigSchema = exports.guidanceConfigSchema = exports.telemetryConfigSchema = void 0;
+// Generated by ts-to-zod
+const zod_1 = require("zod");
+exports.telemetryConfigSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().optional(),
+});
+exports.guidanceConfigSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().optional(),
+});
+exports.authConfigSchema = zod_1.z.object({
+    '// Note': zod_1.z.string().optional(),
+    '// Docs': zod_1.z.string().optional(),
+    skipWrite: zod_1.z.boolean().optional(),
+    token: zod_1.z.string().optional(),
+    userId: zod_1.z.string().optional(),
+    refreshToken: zod_1.z.string().optional(),
+    expiresAt: zod_1.z.number().optional(),
+    tokenSource: zod_1.z.union([zod_1.z.literal('flag'), zod_1.z.literal('env')]).optional(),
+});
+exports.globalConfigSchema = zod_1.z.object({
+    '// Note': zod_1.z.string().optional(),
+    '// Docs': zod_1.z.string().optional(),
+    currentTeam: zod_1.z.string().optional(),
+    api: zod_1.z.string().optional(),
+    telemetry: exports.telemetryConfigSchema.optional(),
+    guidance: exports.guidanceConfigSchema.optional(),
+});

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure TypeScript interface definitions for Vercel global config types.
+ *
+ * These interfaces serve as the source of truth for types.
+ * Zod schemas are generated from these using ts-to-zod.
+ */
+export interface TelemetryConfig {
+    enabled?: boolean;
+}
+export interface GuidanceConfig {
+    enabled?: boolean;
+}
+export interface AuthConfig {
+    '// Note'?: string;
+    '// Docs'?: string;
+    skipWrite?: boolean;
+    token?: string;
+    userId?: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    tokenSource?: 'flag' | 'env';
+}
+export interface GlobalConfig {
+    '// Note'?: string;
+    '// Docs'?: string;
+    currentTeam?: string;
+    api?: string;
+    telemetry?: TelemetryConfig;
+    guidance?: GuidanceConfig;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Pure TypeScript interface definitions for Vercel global config types.
+ *
+ * These interfaces serve as the source of truth for types.
+ * Zod schemas are generated from these using ts-to-zod.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vercel/cli-config",
+  "version": "0.1.0",
+  "description": "Shared core utilities for Vercel global configuration",
+  "license": "Apache-2.0",
+  "homepage": "https://vercel.com/docs/projects/project-configuration/global-configuration",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercel/vercel.git",
+    "directory": "packages/cli-config"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "private": false,
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm generate:schemas && tsc",
+    "generate:schemas": "ts-to-zod src/types.ts src/schema.zod.ts",
+    "test": "pnpm test-unit",
+    "test-unit": "pnpm run vitest-run -- test",
+    "vitest-run": "vitest run -c ../../vitest.config.mts",
+    "vitest-unit": "glob --absolute 'test/*.test.ts'",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "zod": "4.1.11",
+    "xdg-app-paths": "5"
+  },
+  "devDependencies": {
+    "@types/node": "20.11.0",
+    "ts-to-zod": "^3",
+    "vite": "7.1.7",
+    "vitest": "2.1.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}