@ebowwa/codespaces-types 0.1.0 → 1.0.0

package/dist/runtime/database.d.ts

@@ -0,0 +1,376 @@
+/**
+ * Zod schemas for database operations validation
+ */
+import { z } from "zod";
+/**
+ * Active port schema
+ */
+export declare const ActivePortSchema: z.ZodObject<{
+    port: z.ZodNumber;
+    protocol: z.ZodEnum<["tcp", "udp"]>;
+    service: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<["open", "closed", "filtered"]>;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    protocol: "tcp" | "udp";
+    state: "open" | "closed" | "filtered";
+    service?: string | undefined;
+}, {
+    port: number;
+    protocol: "tcp" | "udp";
+    state: "open" | "closed" | "filtered";
+    service?: string | undefined;
+}>;
+/**
+ * Environment metadata schema for database operations
+ */
+export declare const EnvironmentMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    purpose: z.ZodOptional<z.ZodString>;
+    environmentType: z.ZodOptional<z.ZodEnum<["development", "staging", "production", "testing"]>>;
+    hoursActive: z.ZodOptional<z.ZodNumber>;
+    lastActive: z.ZodOptional<z.ZodString>;
+    activePorts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        port: z.ZodNumber;
+        protocol: z.ZodEnum<["tcp", "udp"]>;
+        service: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<["open", "closed", "filtered"]>;
+    }, "strip", z.ZodTypeAny, {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }, {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }>, "many">>;
+    sshKeyPath: z.ZodOptional<z.ZodString>;
+    bootstrapStatus: z.ZodOptional<z.ZodEnum<["bootstrapping", "ready", "failed"]>>;
+    permissions: z.ZodOptional<z.ZodObject<{
+        seedConfig: z.ZodOptional<z.ZodObject<{
+            sourceEnvironmentId: z.ZodOptional<z.ZodString>;
+            dependencySnapshot: z.ZodOptional<z.ZodString>;
+            setupScript: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            sourceEnvironmentId?: string | undefined;
+            dependencySnapshot?: string | undefined;
+            setupScript?: string | undefined;
+        }, {
+            sourceEnvironmentId?: string | undefined;
+            dependencySnapshot?: string | undefined;
+            setupScript?: string | undefined;
+        }>>;
+        logins: z.ZodOptional<z.ZodObject<{
+            github: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodBoolean;
+                username: z.ZodOptional<z.ZodString>;
+                tokenScopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            }, {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            }>>;
+            doppler: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodBoolean;
+                project: z.ZodOptional<z.ZodString>;
+                config: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            }, {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            }>>;
+            tailscale: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodBoolean;
+                authKey: z.ZodOptional<z.ZodString>;
+                hostname: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            }, {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            github?: {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            } | undefined;
+            doppler?: {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            } | undefined;
+            tailscale?: {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            } | undefined;
+        }, {
+            github?: {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            } | undefined;
+            doppler?: {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            } | undefined;
+            tailscale?: {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            } | undefined;
+        }>>;
+        vpns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["wireguard", "openvpn", "tailscale"]>;
+            config: z.ZodString;
+            connected: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            type: "tailscale" | "wireguard" | "openvpn";
+            name: string;
+            config: string;
+            connected: boolean;
+        }, {
+            type: "tailscale" | "wireguard" | "openvpn";
+            name: string;
+            config: string;
+            connected: boolean;
+        }>, "many">>;
+        plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        plugins?: Record<string, any> | undefined;
+        seedConfig?: {
+            sourceEnvironmentId?: string | undefined;
+            dependencySnapshot?: string | undefined;
+            setupScript?: string | undefined;
+        } | undefined;
+        logins?: {
+            github?: {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            } | undefined;
+            doppler?: {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            } | undefined;
+            tailscale?: {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            } | undefined;
+        } | undefined;
+        vpns?: {
+            type: "tailscale" | "wireguard" | "openvpn";
+            name: string;
+            config: string;
+            connected: boolean;
+        }[] | undefined;
+    }, {
+        plugins?: Record<string, any> | undefined;
+        seedConfig?: {
+            sourceEnvironmentId?: string | undefined;
+            dependencySnapshot?: string | undefined;
+            setupScript?: string | undefined;
+        } | undefined;
+        logins?: {
+            github?: {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            } | undefined;
+            doppler?: {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            } | undefined;
+            tailscale?: {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            } | undefined;
+        } | undefined;
+        vpns?: {
+            type: "tailscale" | "wireguard" | "openvpn";
+            name: string;
+            config: string;
+            connected: boolean;
+        }[] | undefined;
+    }>>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description?: string | undefined;
+    project?: string | undefined;
+    owner?: string | undefined;
+    purpose?: string | undefined;
+    environmentType?: "development" | "staging" | "production" | "testing" | undefined;
+    hoursActive?: number | undefined;
+    lastActive?: string | undefined;
+    activePorts?: {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }[] | undefined;
+    sshKeyPath?: string | undefined;
+    bootstrapStatus?: "bootstrapping" | "ready" | "failed" | undefined;
+    permissions?: {
+        plugins?: Record<string, any> | undefined;
+        seedConfig?: {
+            sourceEnvironmentId?: string | undefined;
+            dependencySnapshot?: string | undefined;
+            setupScript?: string | undefined;
+        } | undefined;
+        logins?: {
+            github?: {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            } | undefined;
+            doppler?: {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            } | undefined;
+            tailscale?: {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            } | undefined;
+        } | undefined;
+        vpns?: {
+            type: "tailscale" | "wireguard" | "openvpn";
+            name: string;
+            config: string;
+            connected: boolean;
+        }[] | undefined;
+    } | undefined;
+    updatedAt?: string | undefined;
+}, {
+    id: string;
+    description?: string | undefined;
+    project?: string | undefined;
+    owner?: string | undefined;
+    purpose?: string | undefined;
+    environmentType?: "development" | "staging" | "production" | "testing" | undefined;
+    hoursActive?: number | undefined;
+    lastActive?: string | undefined;
+    activePorts?: {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }[] | undefined;
+    sshKeyPath?: string | undefined;
+    bootstrapStatus?: "bootstrapping" | "ready" | "failed" | undefined;
+    permissions?: {
+        plugins?: Record<string, any> | undefined;
+        seedConfig?: {
+            sourceEnvironmentId?: string | undefined;
+            dependencySnapshot?: string | undefined;
+            setupScript?: string | undefined;
+        } | undefined;
+        logins?: {
+            github?: {
+                enabled: boolean;
+                username?: string | undefined;
+                tokenScopes?: string[] | undefined;
+            } | undefined;
+            doppler?: {
+                enabled: boolean;
+                project?: string | undefined;
+                config?: string | undefined;
+            } | undefined;
+            tailscale?: {
+                enabled: boolean;
+                authKey?: string | undefined;
+                hostname?: string | undefined;
+            } | undefined;
+        } | undefined;
+        vpns?: {
+            type: "tailscale" | "wireguard" | "openvpn";
+            name: string;
+            config: string;
+            connected: boolean;
+        }[] | undefined;
+    } | undefined;
+    updatedAt?: string | undefined;
+}>;
+/**
+ * Activity update schema
+ */
+export declare const ActivityUpdateSchema: z.ZodObject<{
+    hoursActive: z.ZodOptional<z.ZodNumber>;
+    lastActive: z.ZodOptional<z.ZodString>;
+    activePorts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        port: z.ZodNumber;
+        protocol: z.ZodEnum<["tcp", "udp"]>;
+        service: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<["open", "closed", "filtered"]>;
+    }, "strip", z.ZodTypeAny, {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }, {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    hoursActive?: number | undefined;
+    lastActive?: string | undefined;
+    activePorts?: {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }[] | undefined;
+}, {
+    hoursActive?: number | undefined;
+    lastActive?: string | undefined;
+    activePorts?: {
+        port: number;
+        protocol: "tcp" | "udp";
+        state: "open" | "closed" | "filtered";
+        service?: string | undefined;
+    }[] | undefined;
+}>;
+/**
+ * Plugins update schema
+ */
+export declare const PluginsUpdateSchema: z.ZodObject<{
+    plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    plugins?: Record<string, any> | undefined;
+}, {
+    plugins?: Record<string, any> | undefined;
+}>;
+/**
+ * Type exports for TypeScript inference
+ */
+export type EnvironmentMetadataInput = z.infer<typeof EnvironmentMetadataSchema>;
+export type ActivityUpdateInput = z.infer<typeof ActivityUpdateSchema>;
+export type PluginsUpdateInput = z.infer<typeof PluginsUpdateSchema>;
+//# sourceMappingURL=database.d.ts.map

package/dist/runtime/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../runtime/database.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAK3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8DpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;EAE9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,yBAAyB,CACjC,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/runtime/database.js

@@ -0,0 +1,91 @@
+/**
+ * Zod schemas for database operations validation
+ */
+import { z } from "zod";
+/**
+ * Active port schema
+ */
+export const ActivePortSchema = z.object({
+    port: z.number().int().min(1).max(65535),
+    protocol: z.enum(["tcp", "udp"]),
+    service: z.string().optional(),
+    state: z.enum(["open", "closed", "filtered"]),
+});
+/**
+ * Environment metadata schema for database operations
+ */
+export const EnvironmentMetadataSchema = z.object({
+    id: z.string(),
+    description: z.string().optional(),
+    project: z.string().optional(),
+    owner: z.string().optional(),
+    purpose: z.string().optional(),
+    environmentType: z
+        .enum(["development", "staging", "production", "testing"])
+        .optional(),
+    hoursActive: z.number().min(0).optional(),
+    lastActive: z.string().datetime().optional(),
+    activePorts: z.array(ActivePortSchema).optional(),
+    sshKeyPath: z.string().optional(), // Path to SSH private key for terminal connections
+    bootstrapStatus: z.enum(["bootstrapping", "ready", "failed"]).optional(), // Cloud-init bootstrap status
+    permissions: z
+        .object({
+        seedConfig: z
+            .object({
+            sourceEnvironmentId: z.string().optional(),
+            dependencySnapshot: z.string().optional(),
+            setupScript: z.string().optional(),
+        })
+            .optional(),
+        logins: z
+            .object({
+            github: z
+                .object({
+                enabled: z.boolean(),
+                username: z.string().optional(),
+                tokenScopes: z.array(z.string()).optional(),
+            })
+                .optional(),
+            doppler: z
+                .object({
+                enabled: z.boolean(),
+                project: z.string().optional(),
+                config: z.string().optional(),
+            })
+                .optional(),
+            tailscale: z
+                .object({
+                enabled: z.boolean(),
+                authKey: z.string().optional(),
+                hostname: z.string().optional(),
+            })
+                .optional(),
+        })
+            .optional(),
+        vpns: z
+            .array(z.object({
+            name: z.string(),
+            type: z.enum(["wireguard", "openvpn", "tailscale"]),
+            config: z.string(),
+            connected: z.boolean(),
+        }))
+            .optional(),
+        plugins: z.record(z.string(), z.any()).optional(),
+    })
+        .optional(),
+    updatedAt: z.string().datetime().optional(),
+});
+/**
+ * Activity update schema
+ */
+export const ActivityUpdateSchema = z.object({
+    hoursActive: z.number().min(0).optional(),
+    lastActive: z.string().datetime().optional(),
+    activePorts: z.array(ActivePortSchema).optional(),
+});
+/**
+ * Plugins update schema
+ */
+export const PluginsUpdateSchema = z.object({
+    plugins: z.record(z.string(), z.any()).optional(),
+});

package/dist/runtime/env.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Zod schemas for environment variable validation
+ */
+import { z } from 'zod';
+/**
+ * Server environment variables schema
+ */
+export declare const ServerEnvSchema: z.ZodObject<{
+    TEMP_UPLOAD_DIR: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    HETZNER_API_TOKEN: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    TEMP_UPLOAD_DIR: string;
+    HETZNER_API_TOKEN?: string | undefined;
+}, {
+    TEMP_UPLOAD_DIR?: string | undefined;
+    HETZNER_API_TOKEN?: string | undefined;
+}>;
+/**
+ * AI client environment variables schema
+ * At least one API key must be provided
+ */
+export declare const AIEnvSchema: z.ZodEffects<z.ZodObject<{
+    Z_AI_API_KEY: z.ZodOptional<z.ZodString>;
+    ZAI_API_KEY: z.ZodOptional<z.ZodString>;
+    GLM_API_KEY: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}, {
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}>, {
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}, {
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}>;
+/**
+ * Full environment variables schema
+ */
+export declare const EnvSchema: z.ZodEffects<z.ZodObject<{
+    TEMP_UPLOAD_DIR: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    HETZNER_API_TOKEN: z.ZodOptional<z.ZodString>;
+    Z_AI_API_KEY: z.ZodOptional<z.ZodString>;
+    ZAI_API_KEY: z.ZodOptional<z.ZodString>;
+    GLM_API_KEY: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    TEMP_UPLOAD_DIR: string;
+    HETZNER_API_TOKEN?: string | undefined;
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}, {
+    TEMP_UPLOAD_DIR?: string | undefined;
+    HETZNER_API_TOKEN?: string | undefined;
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}>, {
+    TEMP_UPLOAD_DIR: string;
+    HETZNER_API_TOKEN?: string | undefined;
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}, {
+    TEMP_UPLOAD_DIR?: string | undefined;
+    HETZNER_API_TOKEN?: string | undefined;
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}>;
+/**
+ * Validate and parse environment variables
+ */
+export declare function validateEnv(env?: Record<string, string | undefined>): z.SafeParseReturnType<{
+    TEMP_UPLOAD_DIR?: string | undefined;
+    HETZNER_API_TOKEN?: string | undefined;
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}, {
+    TEMP_UPLOAD_DIR: string;
+    HETZNER_API_TOKEN?: string | undefined;
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}>;
+/**
+ * Validate and parse server environment variables
+ */
+export declare function validateServerEnv(env?: Record<string, string | undefined>): z.SafeParseReturnType<{
+    TEMP_UPLOAD_DIR?: string | undefined;
+    HETZNER_API_TOKEN?: string | undefined;
+}, {
+    TEMP_UPLOAD_DIR: string;
+    HETZNER_API_TOKEN?: string | undefined;
+}>;
+/**
+ * Validate and parse AI environment variables
+ */
+export declare function validateAIEnv(env?: Record<string, string | undefined>): z.SafeParseReturnType<{
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}, {
+    Z_AI_API_KEY?: string | undefined;
+    ZAI_API_KEY?: string | undefined;
+    GLM_API_KEY?: string | undefined;
+}>;
+/**
+ * Type exports for TypeScript inference
+ */
+export type ServerEnv = z.infer<typeof ServerEnvSchema>;
+export type AIEnv = z.infer<typeof AIEnvSchema>;
+export type Env = z.infer<typeof EnvSchema>;
+//# sourceMappingURL=env.d.ts.map

package/dist/runtime/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../runtime/env.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;EAG1B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;EAQpB,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQpB,CAAA;AAEF;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe;;;;;;;;;;;;GAEhF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe;;;;;;GAEtF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe;;;;;;;;GAElF;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAC/C,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/runtime/env.js

@@ -0,0 +1,54 @@
+/**
+ * Zod schemas for environment variable validation
+ */
+import { z } from 'zod';
+/**
+ * Server environment variables schema
+ */
+export const ServerEnvSchema = z.object({
+    TEMP_UPLOAD_DIR: z.string().optional().default('/tmp/cheapspaces-uploads'),
+    HETZNER_API_TOKEN: z.string().min(1).optional(),
+});
+/**
+ * AI client environment variables schema
+ * At least one API key must be provided
+ */
+export const AIEnvSchema = z
+    .object({
+    Z_AI_API_KEY: z.string().min(1).optional(),
+    ZAI_API_KEY: z.string().min(1).optional(),
+    GLM_API_KEY: z.string().min(1).optional(),
+})
+    .refine((data) => data.Z_AI_API_KEY || data.ZAI_API_KEY || data.GLM_API_KEY, {
+    message: 'At least one AI API key must be provided (Z_AI_API_KEY, ZAI_API_KEY, or GLM_API_KEY)',
+});
+/**
+ * Full environment variables schema
+ */
+export const EnvSchema = z.object({
+    TEMP_UPLOAD_DIR: z.string().optional().default('/tmp/cheapspaces-uploads'),
+    HETZNER_API_TOKEN: z.string().min(1).optional(),
+    Z_AI_API_KEY: z.string().min(1).optional(),
+    ZAI_API_KEY: z.string().min(1).optional(),
+    GLM_API_KEY: z.string().min(1).optional(),
+}).refine((data) => data.Z_AI_API_KEY || data.ZAI_API_KEY || data.GLM_API_KEY, {
+    message: 'At least one AI API key must be provided (Z_AI_API_KEY, ZAI_API_KEY, or GLM_API_KEY)',
+});
+/**
+ * Validate and parse environment variables
+ */
+export function validateEnv(env = process.env) {
+    return EnvSchema.safeParse(env);
+}
+/**
+ * Validate and parse server environment variables
+ */
+export function validateServerEnv(env = process.env) {
+    return ServerEnvSchema.safeParse(env);
+}
+/**
+ * Validate and parse AI environment variables
+ */
+export function validateAIEnv(env = process.env) {
+    return AIEnvSchema.safeParse(env);
+}

package/dist/runtime/glm.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Zod schemas for Z.AI GLM API
+ *
+ * Provider-specific schemas for Z.AI (GLM) models.
+ * Generic AI schemas (chat messages, streaming, etc.) are in ./ai.ts
+ */
+import { z } from "zod";
+/**
+ * Available GLM models from Z.AI API
+ */
+export declare const GLMModelSchema: z.ZodEnum<["GLM-4.7", "GLM-4.6", "GLM-4.5", "GLM-4.5-air"]>;
+export type GLMModel = z.infer<typeof GLMModelSchema>;
+declare const _default: {
+    GLMModelSchema: z.ZodEnum<["GLM-4.7", "GLM-4.6", "GLM-4.5", "GLM-4.5-air"]>;
+};
+export default _default;
+//# sourceMappingURL=glm.d.ts.map

package/dist/runtime/glm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glm.d.ts","sourceRoot":"","sources":["../../runtime/glm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,cAAc,6DAKzB,CAAC;AAMH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;;;;AAMtD,wBAEE"}