@ebowwa/codespaces-types 1.4.0 → 1.4.2

package/runtime/index.js

@@ -1,28 +1,884 @@
-"use strict";
-/**
- * Central export point for all Zod schemas
- *
- * Note: Hetzner schemas are in app/backend/shared/lib/hetzner/schemas.ts
- * to keep them with the Hetzner client implementation.
- */
-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]; } };
+// @bun
+// runtime/api.js
+import { z } from "zod";
+var EnvironmentIdSchema = z.string().transform((val) => parseInt(val, 10)).pipe(z.number().int().positive("Environment ID must be a positive integer"));
+var CreateEnvironmentRequestSchema = z.object({
+  name: z.string().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/, "Name must start with letter/number and contain only letters, numbers, and hyphens"),
+  serverType: z.string().min(1, "Server type is required"),
+  location: z.string().min(1, "Location is required"),
+  sshKeys: z.array(z.string()).optional(),
+  autoInstallSeed: z.boolean().default(false).optional(),
+  metadata: z.object({
+    description: z.string().optional(),
+    project: z.string().optional(),
+    owner: z.string().optional(),
+    purpose: z.string().optional(),
+    environmentType: z.enum(["development", "staging", "production", "testing"]).optional()
+  }).optional()
+});
+var UpdateMetadataRequestSchema = z.object({
+  description: z.string().optional(),
+  project: z.string().optional(),
+  owner: z.string().optional(),
+  purpose: z.string().optional(),
+  environmentType: z.enum(["development", "staging", "production", "testing"]).optional()
+});
+var UpdateActivityRequestSchema = z.object({
+  hoursActive: z.number().min(0).optional(),
+  lastActive: z.string().datetime().optional(),
+  activePorts: z.array(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"])
+  })).optional()
+});
+var UpdatePluginsRequestSchema = z.object({
+  plugins: z.record(z.string(), z.object({
+    enabled: z.boolean(),
+    config: z.record(z.string(), z.any()).optional()
+  })).optional()
+});
+var SSHConnectionRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional()
+});
+var SSHTestRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  port: z.number().int().positive().max(65535).default(22).optional()
+});
+var SSHFingerprintRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  port: z.number().int().positive().max(65535).default(22).optional()
+});
+var TerminalCreateSessionSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  port: z.number().int().positive().max(65535).default(22).optional(),
+  rows: z.number().int().positive().max(200).default(24).optional(),
+  cols: z.number().int().positive().max(500).default(80).optional()
+});
+var TerminalResizeSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  rows: z.number().int().positive().max(200),
+  cols: z.number().int().positive().max(500)
+});
+var SCPUploadRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  source: z.string().min(1, "Source path is required"),
+  destination: z.string().min(1, "Destination path is required"),
+  recursive: z.boolean().default(false).optional(),
+  preserve: z.boolean().default(false).optional()
+});
+var SCPDownloadRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  source: z.string().min(1, "Source path is required"),
+  destination: z.string().min(1, "Destination path is required"),
+  recursive: z.boolean().default(false).optional(),
+  preserve: z.boolean().default(false).optional()
+});
+var FilesListRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  path: z.string().default(".").optional()
+});
+var FilesPreviewRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  path: z.string().min(1, "Path is required")
+});
+var SSHKeyIdSchema = z.string().transform((val) => parseInt(val, 10)).pipe(z.number().int().positive("SSH Key ID must be a positive integer"));
+var CreateSSHKeyRequestSchema = z.object({
+  name: z.string().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/, "Name must start with letter/number and contain only letters, numbers, and hyphens"),
+  public_key: z.string().min(1, "Public key is required"),
+  labels: z.record(z.string(), z.any()).optional()
+});
+var AIGenerateRequestSchema = z.object({
+  prompt: z.string().min(1, "Prompt is required"),
+  model: z.string().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional()
+});
+var AIChatRequestSchema = z.object({
+  messages: z.array(z.any()).min(1, "At least one message is required"),
+  model: z.string().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional()
+});
+var AISuggestNameRequestSchema = z.object({
+  project: z.string().optional(),
+  description: z.string().optional()
+});
+var AISuggestServerTypeRequestSchema = z.object({
+  workload: z.string().min(1, "Workload description is required")
+});
+var AIAnalyzeResourcesRequestSchema = z.object({
+  cpu: z.number().min(0).max(100),
+  memory: z.number().min(0).max(100),
+  disk: z.number().min(0).max(100)
+});
+var AITroubleshootSSHRequestSchema = z.object({
+  error: z.string().min(1, "Error message is required")
+});
+var AISuggestActionsRequestSchema = z.object({
+  status: z.string().min(1, "Status is required"),
+  age: z.string().optional()
+});
+var AIStatusMessageRequestSchema = z.object({
+  status: z.string().min(1, "Status is required"),
+  name: z.string().min(1, "Name is required")
+});
+var MetricsQuerySchema = z.object({
+  hours: z.string().default("24").transform((val) => parseInt(val, 10)).pipe(z.number().int().positive().max(8760)),
+  limit: z.string().default("100").transform((val) => parseInt(val, 10)).pipe(z.number().int().positive().max(1000))
+});
+var InsertMetricRequestSchema = z.object({
+  environmentId: z.number().int().positive(),
+  cpuPercent: z.number().min(0).max(100),
+  memoryPercent: z.number().min(0).max(100),
+  memoryUsed: z.number().min(0),
+  memoryTotal: z.number().min(0),
+  diskPercent: z.number().min(0).max(100),
+  diskUsed: z.number().min(0),
+  diskTotal: z.number().min(0),
+  gpuPercent: z.number().min(0).max(100).optional(),
+  gpuMemoryUsed: z.number().min(0).optional(),
+  gpuMemoryTotal: z.number().min(0).optional()
+});
+var AIAnalyzeHistoricalRequestSchema = z.object({
+  environmentId: z.number().int().positive(),
+  hours: z.number().int().positive().max(8760).default(24)
+});
+var SeedInstallRequestSchema = z.object({
+  environmentId: z.string().min(1, "Environment ID is required"),
+  autoConfirm: z.boolean().default(true).optional()
+});
+var SeedInstallResponseSchema = z.object({
+  success: z.boolean(),
+  cloned: z.boolean(),
+  setupRun: z.boolean(),
+  seedPath: z.string(),
+  error: z.string().optional(),
+  output: z.array(z.string())
+});
+var SeedStatusResponseSchema = z.object({
+  installed: z.boolean(),
+  setupComplete: z.boolean(),
+  version: z.string().optional(),
+  branch: z.string().optional()
+});
+var LoginCommandsResponseSchema = z.object({
+  ssh: z.string(),
+  web: z.string(),
+  claude: z.string(),
+  quick: z.string()
+});
+var VolumeIdSchema = z.string().transform((val) => parseInt(val, 10)).pipe(z.number().int().positive("Volume ID must be a positive integer"));
+var CreateVolumeRequestSchema = z.object({
+  name: z.string().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/, "Name must start with letter/number and contain only letters, numbers, and hyphens"),
+  size: z.number().int().positive("Size must be a positive integer").min(10, "Minimum volume size is 10 GB").max(10240, "Maximum volume size is 10 TB"),
+  server: z.string().optional(),
+  location: z.string().optional(),
+  automount: z.boolean().default(true).optional(),
+  format: z.enum(["ext4", "xfs"]).optional(),
+  labels: z.record(z.string(), z.any()).optional()
+});
+var UpdateVolumeRequestSchema = z.object({
+  name: z.string().min(1).max(64).optional(),
+  labels: z.record(z.string(), z.any()).optional()
+});
+var AttachVolumeRequestSchema = z.object({
+  volumeId: z.number().int().positive("Volume ID is required"),
+  serverId: z.number().int().positive("Server ID is required"),
+  automount: z.boolean().default(true).optional()
+});
+var DetachVolumeRequestSchema = z.object({
+  volumeId: z.number().int().positive("Volume ID is required")
+});
+var ResizeVolumeRequestSchema = z.object({
+  volumeId: z.number().int().positive("Volume ID is required"),
+  size: z.number().int().positive("Size must be a positive integer").min(10, "Minimum volume size is 10 GB").max(10240, "Maximum volume size is 10 TB")
+});
+var VolumeProtectionRequestSchema = z.object({
+  delete: z.boolean()
+});
+var VolumePriceQuerySchema = z.object({
+  size: z.number().int().positive("Size must be a positive integer").min(10, "Minimum volume size is 10 GB").max(10240, "Maximum volume size is 10 TB")
+});
+var TmuxSendCommandSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  command: z.string().min(1, "Command is required"),
+  paneIndex: z.string().default("0").optional()
+});
+var TmuxSplitPaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  direction: z.enum(["h", "v"]).default("v"),
+  command: z.string().optional()
+});
+var TmuxListWindowsSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required")
+});
+var TmuxListPanesSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  windowIndex: z.string().default("0").optional()
+});
+var TmuxCapturePaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  paneIndex: z.string().default("0").optional()
+});
+var TmuxGetHistorySchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  paneIndex: z.string().default("0").optional(),
+  lines: z.number().int().default(-1).optional()
+});
+var TmuxSwitchWindowSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  windowIndex: z.string().min(1, "Window index is required")
+});
+var TmuxSwitchPaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  paneIndex: z.string().min(1, "Pane index is required")
+});
+var TmuxRenameWindowSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  windowIndex: z.string().min(1, "Window index is required"),
+  newName: z.string().min(1, "New name is required").max(64)
+});
+var TmuxKillPaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  paneIndex: z.string().min(1, "Pane index is required")
+});
+var TmuxDetailedInfoSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required")
+});
+var TmuxManagerAddNodeSchema = z.object({
+  id: z.string().min(1, "Node ID is required"),
+  name: z.string().min(1, "Node name is required"),
+  ip: z.string().min(1, "IP address is required"),
+  ipv6: z.string().nullable().optional(),
+  user: z.string().default("root"),
+  port: z.number().int().positive().max(65535).default(22),
+  keyPath: z.string().optional(),
+  status: z.enum(["running", "stopped", "unreachable"]).default("running"),
+  tags: z.array(z.string()).optional(),
+  location: z.string().optional()
+});
+var TmuxManagerCreateSessionSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().optional(),
+  cwd: z.string().optional(),
+  initialCommand: z.string().optional(),
+  layout: z.enum(["even-horizontal", "even-vertical", "main-horizontal", "main-vertical", "tiled"]).optional()
+});
+var TmuxManagerAttachSessionSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().optional()
+});
+var TmuxManagerKillSessionSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required")
+});
+var TmuxManagerSendCommandSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  command: z.string().min(1, "Command is required"),
+  paneIndex: z.string().default("0")
+});
+var TmuxManagerBatchSendCommandSchema = z.object({
+  nodeIds: z.array(z.string().min(1)).min(1, "At least one node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  command: z.string().min(1, "Command is required"),
+  paneIndex: z.string().default("0"),
+  parallel: z.boolean().default(true),
+  continueOnError: z.boolean().default(true),
+  timeout: z.number().int().positive().default(30)
+});
+var TmuxManagerSplitPaneSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  direction: z.enum(["h", "v"]).default("v"),
+  command: z.string().nullable().optional(),
+  windowIndex: z.string().default("0")
+});
+var TmuxManagerCapturePaneSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  paneIndex: z.string().default("0")
+});
+var TmuxManagerGetHistorySchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  paneIndex: z.string().default("0"),
+  lines: z.number().int().default(-1)
+});
+var TmuxManagerListWindowsSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required")
+});
+var TmuxManagerListPanesSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  windowIndex: z.string().default("0")
+});
+var TmuxManagerSwitchWindowSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  windowIndex: z.string().min(1, "Window index is required")
+});
+var TmuxManagerSwitchPaneSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  paneIndex: z.string().min(1, "Pane index is required")
+});
+var TmuxManagerRenameWindowSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  windowIndex: z.string().min(1, "Window index is required"),
+  newName: z.string().min(1, "New name is required").max(64)
+});
+var TmuxManagerKillPaneSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+  paneIndex: z.string().min(1, "Pane index is required")
+});
+var TmuxManagerCleanupOldSessionsSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  ageLimitMs: z.number().int().positive().default(30 * 24 * 60 * 60 * 1000)
+});
+var TmuxManagerDetailedSessionSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required")
+});
+var TmuxManagerListSessionsQuerySchema = z.object({
+  nodeIds: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  detailed: z.boolean().default(false).optional(),
+  includeInactive: z.boolean().default(false).optional()
+});
+var AddActivityRequestSchema = z.object({
+  environmentId: z.string().min(1, "Environment ID is required"),
+  action: z.string().min(1, "Action is required").max(100),
+  environmentName: z.string().min(1, "Environment name is required").max(64),
+  details: z.string().max(1000).optional()
+});
+var ActivitiesQueryParamsSchema = z.object({
+  environmentId: z.string().optional(),
+  limit: z.string().default("100").transform((val) => parseInt(val, 10)).pipe(z.number().int().positive().max(1000)).optional(),
+  hours: z.string().transform((val) => parseInt(val, 10)).pipe(z.number().int().positive()).optional(),
+  since: z.string().datetime().optional(),
+  until: z.string().datetime().optional(),
+  action: z.string().optional()
+});
+var CleanupActivitiesRequestSchema = z.object({
+  environmentId: z.string().optional(),
+  keepHours: z.number().int().positive().default(720).optional()
+});
+// runtime/ai.js
+import { z as z2 } from "zod";
+var ChatMessageRoleSchema = z2.enum(["system", "user", "assistant", "tool"]);
+var ToolCallSchema = z2.object({
+  id: z2.string(),
+  type: z2.literal("function"),
+  function: z2.object({
+    name: z2.string(),
+    arguments: z2.string()
+  })
+});
+var ChatMessageSchema = z2.object({
+  role: ChatMessageRoleSchema,
+  content: z2.string(),
+  tool_calls: z2.array(ToolCallSchema).optional(),
+  tool_call_id: z2.string().optional()
+});
+var TokenUsageSchema = z2.object({
+  promptTokens: z2.number().int().nonnegative(),
+  completionTokens: z2.number().int().nonnegative(),
+  totalTokens: z2.number().int().nonnegative()
+});
+var RawUsageSchema = z2.object({
+  prompt_tokens: z2.number().int().nonnegative(),
+  completion_tokens: z2.number().int().nonnegative(),
+  total_tokens: z2.number().int().nonnegative()
+});
+var BaseAIRequestOptionsSchema = z2.object({
+  model: z2.string().optional(),
+  temperature: z2.number().min(0).max(2).optional(),
+  maxTokens: z2.number().int().positive().optional()
+});
+var ChatCompletionOptionsSchema = BaseAIRequestOptionsSchema.extend({
+  stream: z2.boolean().optional().default(false),
+  timeout: z2.number().int().positive().optional().default(30000),
+  maxRetries: z2.number().int().nonnegative().optional().default(3)
+});
+var AIRequestSchema = BaseAIRequestOptionsSchema.extend({
+  prompt: z2.string(),
+  systemPrompt: z2.string().optional()
+});
+var AIChatModuleRequestSchema = BaseAIRequestOptionsSchema.extend({
+  messages: z2.array(ChatMessageSchema).min(1)
+});
+var LatencyInfoSchema = z2.object({
+  totalMs: z2.number().nonnegative(),
+  formatted: z2.string()
+});
+var RawChoiceSchema = z2.object({
+  index: z2.number().int().nonnegative(),
+  message: z2.object({
+    role: z2.string(),
+    content: z2.string().nullable().optional(),
+    tool_calls: z2.array(ToolCallSchema).optional()
+  }),
+  finish_reason: z2.string().nullable()
+});
+var RawChatCompletionResponseSchema = z2.object({
+  id: z2.string(),
+  object: z2.string(),
+  created: z2.number().int().nonnegative(),
+  model: z2.string(),
+  choices: z2.array(RawChoiceSchema).min(1),
+  usage: RawUsageSchema.optional()
+});
+var ChatCompletionResponseSchema = z2.object({
+  id: z2.string(),
+  object: z2.string(),
+  created: z2.number().int().nonnegative(),
+  model: z2.string(),
+  choices: z2.array(z2.object({
+    index: z2.number().int().nonnegative(),
+    message: z2.object({
+      role: z2.string(),
+      content: z2.string().nullable().optional(),
+      tool_calls: z2.array(ToolCallSchema).optional()
+    }),
+    finish_reason: z2.string().nullable()
+  })).min(1),
+  usage: TokenUsageSchema.optional(),
+  latency: LatencyInfoSchema.optional()
+});
+var AIResponseSchema = z2.object({
+  success: z2.boolean(),
+  content: z2.string().optional(),
+  error: z2.string().optional(),
+  usage: TokenUsageSchema.optional()
+});
+var AIChatResponseSchema = z2.object({
+  success: z2.boolean(),
+  message: z2.string().optional(),
+  usage: TokenUsageSchema.optional(),
+  error: z2.string().optional()
+});
+var StreamDeltaSchema = z2.object({
+  role: z2.string().optional(),
+  content: z2.string().optional()
+});
+var StreamChunkTypeSchema = z2.enum(["text", "done", "error"]);
+var RawStreamChunkSchema = z2.object({
+  id: z2.string(),
+  object: z2.string(),
+  created: z2.number().int().nonnegative(),
+  model: z2.string(),
+  choices: z2.array(z2.object({
+    index: z2.number().int().nonnegative(),
+    delta: StreamDeltaSchema,
+    finish_reason: z2.string().nullable().optional()
+  })).min(1),
+  usage: RawUsageSchema.optional()
+});
+var StreamChunkSchema = z2.object({
+  type: StreamChunkTypeSchema,
+  id: z2.string().optional(),
+  content: z2.string().optional(),
+  finishReason: z2.string().optional(),
+  usage: TokenUsageSchema.optional(),
+  error: z2.string().optional()
+});
+var APIErrorResponseSchema = z2.object({
+  error: z2.object({
+    message: z2.string(),
+    type: z2.string().optional(),
+    code: z2.string().optional()
+  }).optional()
+});
+var ErrorTypeSchema = z2.enum([
+  "timeout",
+  "auth",
+  "rate_limit",
+  "network",
+  "validation",
+  "unknown"
+]);
+function validateChatMessage(data) {
+  return ChatMessageSchema.safeParse(data);
+}
+function validateChatMessages(data) {
+  return z2.array(ChatMessageSchema).min(1).safeParse(data);
+}
+function validateChatCompletionOptions(data) {
+  return ChatCompletionOptionsSchema.safeParse(data);
+}
+function validateRawResponse(data) {
+  return RawChatCompletionResponseSchema.safeParse(data);
+}
+function convertUsage(raw) {
+  const result = RawUsageSchema.safeParse(raw);
+  if (!result.success)
+    return null;
+  return {
+    promptTokens: result.data.prompt_tokens,
+    completionTokens: result.data.completion_tokens,
+    totalTokens: result.data.total_tokens
+  };
+}
+function categorizeError(data) {
+  if (data instanceof Error) {
+    if (data.message.includes("timeout")) {
+      return "timeout";
     }
-    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);
+    if (data.message.includes("unauthorized") || data.message.includes("401")) {
+      return "auth";
+    }
+    if (data.message.includes("rate limit") || data.message.includes("429")) {
+      return "rate_limit";
+    }
+    if (data instanceof TypeError || data.message.includes("fetch")) {
+      return "network";
+    }
+  }
+  const errorResult = APIErrorResponseSchema.safeParse(data);
+  if (errorResult.success && errorResult.data.error) {
+    const errorMsg = errorResult.data.error.message.toLowerCase();
+    if (errorMsg.includes("timeout"))
+      return "timeout";
+    if (errorMsg.includes("unauthorized") || errorMsg.includes("invalid api key") || errorMsg.includes("401"))
+      return "auth";
+    if (errorMsg.includes("rate limit") || errorMsg.includes("429"))
+      return "rate_limit";
+  }
+  return "unknown";
+}
+function parseSSERow(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed === "")
+    return null;
+  if (!trimmed.startsWith("data: "))
+    return null;
+  const data = trimmed.slice(6);
+  if (data === "[DONE]")
+    return data;
+  return data;
+}
+async function* parseSSEStream(response) {
+  if (!response.body) {
+    yield {
+      type: "error",
+      error: "Response body is null"
+    };
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const data = parseSSERow(line);
+        if (!data)
+          continue;
+        if (data === "[DONE]") {
+          yield {
+            type: "done"
+          };
+          return;
+        }
+        try {
+          const raw = JSON.parse(data);
+          const rawChunkResult = RawStreamChunkSchema.safeParse(raw);
+          if (!rawChunkResult.success) {
+            yield {
+              type: "error",
+              error: `Invalid stream chunk: ${rawChunkResult.error.message}`
+            };
+            continue;
+          }
+          const rawChunk = rawChunkResult.data;
+          const delta = rawChunk.choices[0].delta;
+          const usage = rawChunk.usage ? {
+            promptTokens: rawChunk.usage.prompt_tokens,
+            completionTokens: rawChunk.usage.completion_tokens,
+            totalTokens: rawChunk.usage.total_tokens
+          } : undefined;
+          yield {
+            type: "text",
+            id: rawChunk.id,
+            content: delta.content || "",
+            finishReason: rawChunk.choices[0].finish_reason || undefined,
+            usage
+          };
+        } catch (error) {
+          yield {
+            type: "error",
+            error: `Failed to parse stream chunk: ${error instanceof Error ? error.message : String(error)}`
+          };
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+// runtime/database.js
+import { z as z3 } from "zod";
+var ActivePortSchema = z3.object({
+  port: z3.number().int().min(1).max(65535),
+  protocol: z3.enum(["tcp", "udp"]),
+  service: z3.string().optional(),
+  state: z3.enum(["open", "closed", "filtered"])
+});
+var EnvironmentMetadataSchema = z3.object({
+  id: z3.string(),
+  description: z3.string().optional(),
+  project: z3.string().optional(),
+  owner: z3.string().optional(),
+  purpose: z3.string().optional(),
+  environmentType: z3.enum(["development", "staging", "production", "testing"]).optional(),
+  hoursActive: z3.number().min(0).optional(),
+  lastActive: z3.string().datetime().optional(),
+  activePorts: z3.array(ActivePortSchema).optional(),
+  sshKeyPath: z3.string().optional(),
+  bootstrapStatus: z3.enum(["bootstrapping", "ready", "failed"]).optional(),
+  permissions: z3.object({
+    seedConfig: z3.object({
+      sourceEnvironmentId: z3.string().optional(),
+      dependencySnapshot: z3.string().optional(),
+      setupScript: z3.string().optional()
+    }).optional(),
+    logins: z3.object({
+      github: z3.object({
+        enabled: z3.boolean(),
+        username: z3.string().optional(),
+        tokenScopes: z3.array(z3.string()).optional()
+      }).optional(),
+      doppler: z3.object({
+        enabled: z3.boolean(),
+        project: z3.string().optional(),
+        config: z3.string().optional()
+      }).optional(),
+      tailscale: z3.object({
+        enabled: z3.boolean(),
+        authKey: z3.string().optional(),
+        hostname: z3.string().optional()
+      }).optional()
+    }).optional(),
+    vpns: z3.array(z3.object({
+      name: z3.string(),
+      type: z3.enum(["wireguard", "openvpn", "tailscale"]),
+      config: z3.string(),
+      connected: z3.boolean()
+    })).optional(),
+    plugins: z3.record(z3.string(), z3.any()).optional()
+  }).optional(),
+  updatedAt: z3.string().datetime().optional()
+});
+var ActivityUpdateSchema = z3.object({
+  hoursActive: z3.number().min(0).optional(),
+  lastActive: z3.string().datetime().optional(),
+  activePorts: z3.array(ActivePortSchema).optional()
+});
+var PluginsUpdateSchema = z3.object({
+  plugins: z3.record(z3.string(), z3.any()).optional()
+});
+// runtime/env.js
+import { z as z4 } from "zod";
+var ServerEnvSchema = z4.object({
+  TEMP_UPLOAD_DIR: z4.string().optional().default("/tmp/cheapspaces-uploads"),
+  HETZNER_API_TOKEN: z4.string().min(1).optional()
+});
+var AIEnvSchema = z4.object({
+  Z_AI_API_KEY: z4.string().min(1).optional(),
+  ZAI_API_KEY: z4.string().min(1).optional(),
+  GLM_API_KEY: z4.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)"
+});
+var EnvSchema = z4.object({
+  TEMP_UPLOAD_DIR: z4.string().optional().default("/tmp/cheapspaces-uploads"),
+  HETZNER_API_TOKEN: z4.string().min(1).optional(),
+  Z_AI_API_KEY: z4.string().min(1).optional(),
+  ZAI_API_KEY: z4.string().min(1).optional(),
+  GLM_API_KEY: z4.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)"
+});
+function validateEnv(env = process.env) {
+  return EnvSchema.safeParse(env);
+}
+function validateServerEnv(env = process.env) {
+  return ServerEnvSchema.safeParse(env);
+}
+function validateAIEnv(env = process.env) {
+  return AIEnvSchema.safeParse(env);
+}
+// runtime/glm.js
+import { z as z5 } from "zod";
+var GLMModelSchema = z5.enum([
+  "GLM-4.7",
+  "GLM-4.6",
+  "GLM-4.5",
+  "GLM-4.5-air"
+]);
+// runtime/ssh.js
+import { z as z6 } from "zod";
+var SSHOptionsSchema = z6.object({
+  host: z6.string().min(1, "Host is required"),
+  user: z6.string().default("root"),
+  timeout: z6.number().int().positive().default(5),
+  port: z6.number().int().positive().max(65535).default(22),
+  keyPath: z6.string().optional(),
+  password: z6.string().optional()
+});
+var SSHCommandSchema = z6.string().min(1, "Command cannot be empty");
+var SCPOptionsSchema = SSHOptionsSchema.extend({
+  source: z6.string().min(1, "Source is required"),
+  destination: z6.string().min(1, "Destination is required"),
+  recursive: z6.boolean().default(false),
+  preserve: z6.boolean().default(false)
+});
+var FilesListOptionsSchema = z6.object({
+  host: z6.string().min(1, "Host is required"),
+  user: z6.string().default("root"),
+  path: z6.string().default(".")
+});
+var FilePreviewOptionsSchema = z6.object({
+  host: z6.string().min(1, "Host is required"),
+  user: z6.string().default("root"),
+  path: z6.string().min(1, "Path is required")
+});
+export {
+  validateServerEnv,
+  validateRawResponse,
+  validateEnv,
+  validateChatMessages,
+  validateChatMessage,
+  validateChatCompletionOptions,
+  validateAIEnv,
+  parseSSEStream,
+  parseSSERow,
+  convertUsage,
+  categorizeError,
+  VolumeProtectionRequestSchema,
+  VolumePriceQuerySchema,
+  VolumeIdSchema,
+  UpdateVolumeRequestSchema,
+  UpdatePluginsRequestSchema,
+  UpdateMetadataRequestSchema,
+  UpdateActivityRequestSchema,
+  ToolCallSchema,
+  TokenUsageSchema,
+  TmuxSwitchWindowSchema,
+  TmuxSwitchPaneSchema,
+  TmuxSplitPaneSchema,
+  TmuxSendCommandSchema,
+  TmuxRenameWindowSchema,
+  TmuxManagerSwitchWindowSchema,
+  TmuxManagerSwitchPaneSchema,
+  TmuxManagerSplitPaneSchema,
+  TmuxManagerSendCommandSchema,
+  TmuxManagerRenameWindowSchema,
+  TmuxManagerListWindowsSchema,
+  TmuxManagerListSessionsQuerySchema,
+  TmuxManagerListPanesSchema,
+  TmuxManagerKillSessionSchema,
+  TmuxManagerKillPaneSchema,
+  TmuxManagerGetHistorySchema,
+  TmuxManagerDetailedSessionSchema,
+  TmuxManagerCreateSessionSchema,
+  TmuxManagerCleanupOldSessionsSchema,
+  TmuxManagerCapturePaneSchema,
+  TmuxManagerBatchSendCommandSchema,
+  TmuxManagerAttachSessionSchema,
+  TmuxManagerAddNodeSchema,
+  TmuxListWindowsSchema,
+  TmuxListPanesSchema,
+  TmuxKillPaneSchema,
+  TmuxGetHistorySchema,
+  TmuxDetailedInfoSchema,
+  TmuxCapturePaneSchema,
+  TerminalResizeSchema,
+  TerminalCreateSessionSchema,
+  StreamDeltaSchema,
+  StreamChunkTypeSchema,
+  StreamChunkSchema,
+  ServerEnvSchema,
+  SeedStatusResponseSchema,
+  SeedInstallResponseSchema,
+  SeedInstallRequestSchema,
+  SSHTestRequestSchema,
+  SSHOptionsSchema,
+  SSHKeyIdSchema,
+  SSHFingerprintRequestSchema,
+  SSHConnectionRequestSchema,
+  SSHCommandSchema,
+  SCPUploadRequestSchema,
+  SCPOptionsSchema,
+  SCPDownloadRequestSchema,
+  ResizeVolumeRequestSchema,
+  RawUsageSchema,
+  RawStreamChunkSchema,
+  RawChoiceSchema,
+  RawChatCompletionResponseSchema,
+  PluginsUpdateSchema,
+  MetricsQuerySchema,
+  LoginCommandsResponseSchema,
+  LatencyInfoSchema,
+  InsertMetricRequestSchema,
+  GLMModelSchema,
+  FilesPreviewRequestSchema,
+  FilesListRequestSchema,
+  FilesListOptionsSchema,
+  FilePreviewOptionsSchema,
+  ErrorTypeSchema,
+  EnvironmentMetadataSchema,
+  EnvironmentIdSchema,
+  EnvSchema,
+  DetachVolumeRequestSchema,
+  CreateVolumeRequestSchema,
+  CreateSSHKeyRequestSchema,
+  CreateEnvironmentRequestSchema,
+  CleanupActivitiesRequestSchema,
+  ChatMessageSchema,
+  ChatMessageRoleSchema,
+  ChatCompletionResponseSchema,
+  ChatCompletionOptionsSchema,
+  BaseAIRequestOptionsSchema,
+  AttachVolumeRequestSchema,
+  AddActivityRequestSchema,
+  ActivityUpdateSchema,
+  ActivitiesQueryParamsSchema,
+  ActivePortSchema,
+  APIErrorResponseSchema,
+  AITroubleshootSSHRequestSchema,
+  AISuggestServerTypeRequestSchema,
+  AISuggestNameRequestSchema,
+  AISuggestActionsRequestSchema,
+  AIStatusMessageRequestSchema,
+  AIResponseSchema,
+  AIRequestSchema,
+  AIGenerateRequestSchema,
+  AIEnvSchema,
+  AIChatResponseSchema,
+  AIChatRequestSchema,
+  AIChatModuleRequestSchema,
+  AIAnalyzeResourcesRequestSchema,
+  AIAnalyzeHistoricalRequestSchema
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./api.js"), exports);
-__exportStar(require("./ai.js"), exports);
-__exportStar(require("./database.js"), exports);
-__exportStar(require("./env.js"), exports);
-__exportStar(require("./glm.js"), exports);
-__exportStar(require("./ssh.js"), exports);