@ebowwa/codespaces-types 1.1.0 → 1.2.0

package/compile/resources.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Shared resource parsing utilities
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCPU = parseCPU;
+exports.parseMemory = parseMemory;
+exports.parseDisk = parseDisk;
+exports.parseGPU = parseGPU;
+exports.parseResources = parseResources;
+/**
+ * Parse CPU usage from raw output with validation
+ */
+function parseCPU(raw) {
+    if (!raw || typeof raw !== 'string') {
+        return 0;
+    }
+    var num = parseFloat(raw);
+    if (isNaN(num)) {
+        console.warn('Invalid CPU value:', raw);
+        return 0;
+    }
+    return Math.round(num * 10) / 10;
+}
+/**
+ * Parse memory usage from raw output with validation
+ * Returns: { percent, used, total }
+ */
+function parseMemory(raw) {
+    if (!raw || typeof raw !== 'string') {
+        return { percent: 0, used: '0 GB', total: '0 GB' };
+    }
+    var parts = raw.split(/\s+/);
+    if (parts.length < 3) {
+        console.warn('Invalid memory output:', raw);
+        return { percent: 0, used: '0 GB', total: '0 GB' };
+    }
+    return {
+        percent: Math.round(parseFloat(parts[0]) * 10) / 10,
+        used: "".concat((parseFloat(parts[1]) || 0).toFixed(1), " GB"),
+        total: "".concat((parseFloat(parts[2]) || 0).toFixed(1), " GB"),
+    };
+}
+/**
+ * Parse disk usage from raw output with validation
+ * Handles formats like "4% 2.8G 75G" -> adds space before unit
+ */
+function parseDisk(raw) {
+    var _a;
+    if (!raw || typeof raw !== 'string') {
+        return { percent: 0, used: '0 GB', total: '0 GB' };
+    }
+    var parts = raw.split(/\s+/);
+    var percent = parseFloat(((_a = parts[0]) === null || _a === void 0 ? void 0 : _a.replace('%', '')) || '0') || 0;
+    // Format "2.8G" -> "2.8 GB" for consistency
+    var formatSize = function (size) {
+        if (size.endsWith('G') || size.endsWith('M') || size.endsWith('K')) {
+            return size.replace(/([GMK])$/, ' $1B');
+        }
+        return size;
+    };
+    return {
+        percent: Math.round(percent),
+        used: formatSize(parts[1] || '0 GB'),
+        total: formatSize(parts[2] || '0 GB'),
+    };
+}
+/**
+ * Parse GPU usage from raw output with validation
+ * Returns undefined if no GPU present
+ */
+function parseGPU(raw) {
+    if (!raw || raw === 'NOGPU' || raw === '0' || !raw.trim()) {
+        return undefined;
+    }
+    var parts = raw.split(',').map(function (s) { return s.trim(); });
+    if (parts.length < 3) {
+        console.warn('Invalid GPU output:', raw);
+        return undefined;
+    }
+    // nvidia-smi returns values in MB, convert to GB
+    return {
+        gpuPercent: parseFloat(parts[0]) || 0,
+        gpuMemoryUsed: "".concat((parseFloat(parts[1]) / 1024).toFixed(1), " GB"),
+        gpuMemoryTotal: "".concat((parseFloat(parts[2]) / 1024).toFixed(1), " GB"),
+    };
+}
+/**
+ * Parse all resources from raw command outputs
+ */
+function parseResources(raw) {
+    var cpu = parseCPU(raw.cpu);
+    var memory = parseMemory(raw.memory);
+    var disk = parseDisk(raw.disk);
+    var gpu = parseGPU(raw.gpu);
+    return __assign({ 
+        // Raw values for metrics storage
+        cpu: cpu, memory: memory.percent, disk: disk.percent, gpu: raw.gpu, network: raw.network, loadavg: raw.loadavg, processes: raw.processes, connections: raw.connections, ports: raw.ports, 
+        // Parsed values for API response
+        cpuPercent: cpu, memoryPercent: memory.percent, memoryUsed: memory.used, memoryTotal: memory.total, diskPercent: disk.percent, diskUsed: disk.used, diskTotal: disk.total }, (gpu && {
+        gpuPercent: gpu.gpuPercent,
+        gpuMemoryUsed: gpu.gpuMemoryUsed,
+        gpuMemoryTotal: gpu.gpuMemoryTotal,
+    }));
+}

package/compile/resources.ts

@@ -0,0 +1,157 @@
+/**
+ * Shared resource parsing utilities
+ */
+
+import { z } from 'zod'
+
+/**
+ * Parse CPU usage from raw output with validation
+ */
+export function parseCPU(raw: string | undefined): number {
+  if (!raw || typeof raw !== 'string') {
+    return 0
+  }
+  const num = parseFloat(raw)
+  if (isNaN(num)) {
+    console.warn('Invalid CPU value:', raw)
+    return 0
+  }
+  return Math.round(num * 10) / 10
+}
+
+/**
+ * Parse memory usage from raw output with validation
+ * Returns: { percent, used, total }
+ */
+export function parseMemory(raw: string | undefined): { percent: number; used: string; total: string } {
+  if (!raw || typeof raw !== 'string') {
+    return { percent: 0, used: '0 GB', total: '0 GB' }
+  }
+  const parts = raw.split(/\s+/)
+  if (parts.length < 3) {
+    console.warn('Invalid memory output:', raw)
+    return { percent: 0, used: '0 GB', total: '0 GB' }
+  }
+
+  return {
+    percent: Math.round(parseFloat(parts[0]) * 10) / 10,
+    used: `${(parseFloat(parts[1]) || 0).toFixed(1)} GB`,
+    total: `${(parseFloat(parts[2]) || 0).toFixed(1)} GB`,
+  }
+}
+
+/**
+ * Parse disk usage from raw output with validation
+ * Handles formats like "4% 2.8G 75G" -> adds space before unit
+ */
+export function parseDisk(raw: string | undefined): { percent: number; used: string; total: string } {
+  if (!raw || typeof raw !== 'string') {
+    return { percent: 0, used: '0 GB', total: '0 GB' }
+  }
+  const parts = raw.split(/\s+/)
+  const percent = parseFloat(parts[0]?.replace('%', '') || '0') || 0
+
+  // Format "2.8G" -> "2.8 GB" for consistency
+  const formatSize = (size: string): string => {
+    if (size.endsWith('G') || size.endsWith('M') || size.endsWith('K')) {
+      return size.replace(/([GMK])$/, ' $1B')
+    }
+    return size
+  }
+
+  return {
+    percent: Math.round(percent),
+    used: formatSize(parts[1] || '0 GB'),
+    total: formatSize(parts[2] || '0 GB'),
+  }
+}
+
+/**
+ * Parse GPU usage from raw output with validation
+ * Returns undefined if no GPU present
+ */
+export function parseGPU(raw: string | undefined): { gpuPercent: number; gpuMemoryUsed: string; gpuMemoryTotal: string } | undefined {
+  if (!raw || raw === 'NOGPU' || raw === '0' || !raw.trim()) {
+    return undefined
+  }
+
+  const parts = raw.split(',').map(s => s.trim())
+  if (parts.length < 3) {
+    console.warn('Invalid GPU output:', raw)
+    return undefined
+  }
+
+  // nvidia-smi returns values in MB, convert to GB
+  return {
+    gpuPercent: parseFloat(parts[0]) || 0,
+    gpuMemoryUsed: `${(parseFloat(parts[1]) / 1024).toFixed(1)} GB`,
+    gpuMemoryTotal: `${(parseFloat(parts[2]) / 1024).toFixed(1)} GB`,
+  }
+}
+
+/**
+ * Parse all resources from raw command outputs
+ */
+export function parseResources(raw: {
+  cpu?: string
+  memory?: string
+  disk?: string
+  gpu?: string
+  network?: string
+  loadavg?: string
+  processes?: string
+  connections?: string
+  ports?: string
+}): {
+  cpu: number
+  memory: number
+  disk: number
+  gpu?: string
+  network?: string
+  loadavg?: string
+  processes?: string
+  connections?: string
+  ports?: string
+  cpuPercent: number
+  memoryPercent: number
+  memoryUsed: string
+  memoryTotal: string
+  diskPercent: number
+  diskUsed: string
+  diskTotal: string
+  gpuPercent?: number
+  gpuMemoryUsed?: string
+  gpuMemoryTotal?: string
+} {
+  const cpu = parseCPU(raw.cpu)
+  const memory = parseMemory(raw.memory)
+  const disk = parseDisk(raw.disk)
+  const gpu = parseGPU(raw.gpu)
+
+  return {
+    // Raw values for metrics storage
+    cpu,
+    memory: memory.percent,
+    disk: disk.percent,
+    gpu: raw.gpu,
+    network: raw.network,
+    loadavg: raw.loadavg,
+    processes: raw.processes,
+    connections: raw.connections,
+    ports: raw.ports,
+
+    // Parsed values for API response
+    cpuPercent: cpu,
+    memoryPercent: memory.percent,
+    memoryUsed: memory.used,
+    memoryTotal: memory.total,
+    diskPercent: disk.percent,
+    diskUsed: disk.used,
+    diskTotal: disk.total,
+    ...(gpu && {
+      gpuPercent: gpu.gpuPercent,
+      gpuMemoryUsed: gpu.gpuMemoryUsed,
+      gpuMemoryTotal: gpu.gpuMemoryTotal,
+    }),
+  }
+}

package/compile/schemas/resources.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Zod schemas for resource parsing validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsedResourcesSchema = exports.RawResourcesInputSchema = exports.GPUOutputSchema = exports.DiskOutputSchema = exports.MemoryOutputSchema = exports.CPUOutputSchema = void 0;
+var zod_1 = require("zod");
+/**
+ * CPU output validation schema
+ */
+exports.CPUOutputSchema = zod_1.z
+    .string()
+    .transform(function (val) {
+    var num = parseFloat(val);
+    if (isNaN(num))
+        throw new Error('Invalid CPU value');
+    return Math.round(num * 10) / 10;
+})
+    .pipe(zod_1.z.number().min(0).max(100));
+/**
+ * Memory output validation schema
+ */
+exports.MemoryOutputSchema = zod_1.z
+    .string()
+    .transform(function (val) {
+    var parts = val.split(/\s+/);
+    if (parts.length < 3)
+        throw new Error('Invalid memory output');
+    return {
+        percent: Math.round(parseFloat(parts[0]) * 10) / 10,
+        used: "".concat((parseFloat(parts[1]) || 0).toFixed(1), " GB"),
+        total: "".concat((parseFloat(parts[2]) || 0).toFixed(1), " GB"),
+    };
+})
+    .pipe(zod_1.z.object({
+    percent: zod_1.z.number().min(0).max(100),
+    used: zod_1.z.string(),
+    total: zod_1.z.string(),
+}));
+/**
+ * Disk output validation schema
+ */
+exports.DiskOutputSchema = zod_1.z
+    .string()
+    .transform(function (val) {
+    var _a;
+    var parts = val.split(/\s+/);
+    var percent = parseFloat(((_a = parts[0]) === null || _a === void 0 ? void 0 : _a.replace('%', '')) || '0') || 0;
+    var formatSize = function (size) {
+        if (size.endsWith('G') || size.endsWith('M') || size.endsWith('K')) {
+            return size.replace(/([GMK])$/, ' $1B');
+        }
+        return size;
+    };
+    return {
+        percent: Math.round(percent),
+        used: formatSize(parts[1] || '0 GB'),
+        total: formatSize(parts[2] || '0 GB'),
+    };
+})
+    .pipe(zod_1.z.object({
+    percent: zod_1.z.number().min(0).max(100),
+    used: zod_1.z.string(),
+    total: zod_1.z.string(),
+}));
+/**
+ * GPU output validation schema
+ */
+exports.GPUOutputSchema = zod_1.z
+    .string()
+    .transform(function (val) {
+    if (val === 'NOGPU' || val === '0' || !val.trim()) {
+        return null;
+    }
+    var parts = val.split(',').map(function (s) { return s.trim(); });
+    if (parts.length < 3) {
+        return null;
+    }
+    return {
+        gpuPercent: parseFloat(parts[0]) || 0,
+        gpuMemoryUsed: "".concat((parseFloat(parts[1]) / 1024).toFixed(1), " GB"),
+        gpuMemoryTotal: "".concat((parseFloat(parts[2]) / 1024).toFixed(1), " GB"),
+    };
+})
+    .pipe(zod_1.z
+    .object({
+    gpuPercent: zod_1.z.number().min(0).max(100),
+    gpuMemoryUsed: zod_1.z.string(),
+    gpuMemoryTotal: zod_1.z.string(),
+})
+    .nullable());
+/**
+ * Raw resources input schema
+ */
+exports.RawResourcesInputSchema = zod_1.z.object({
+    cpu: zod_1.z.string(),
+    memory: zod_1.z.string(),
+    disk: zod_1.z.string(),
+    gpu: zod_1.z.string(),
+    network: zod_1.z.string().optional(),
+    loadavg: zod_1.z.string().optional(),
+    processes: zod_1.z.string().optional(),
+    connections: zod_1.z.string().optional(),
+});
+/**
+ * Parsed resources output schema
+ */
+exports.ParsedResourcesSchema = zod_1.z.object({
+    cpu: zod_1.z.number().min(0).max(100),
+    memory: zod_1.z.number().min(0).max(100),
+    disk: zod_1.z.number().min(0).max(100),
+    gpu: zod_1.z.string().optional(),
+    network: zod_1.z.string().optional(),
+    loadavg: zod_1.z.string().optional(),
+    processes: zod_1.z.string().optional(),
+    connections: zod_1.z.string().optional(),
+    cpuPercent: zod_1.z.number().min(0).max(100),
+    memoryPercent: zod_1.z.number().min(0).max(100),
+    memoryUsed: zod_1.z.string(),
+    memoryTotal: zod_1.z.string(),
+    diskPercent: zod_1.z.number().min(0).max(100),
+    diskUsed: zod_1.z.string(),
+    diskTotal: zod_1.z.string(),
+    gpuPercent: zod_1.z.number().min(0).max(100).optional(),
+    gpuMemoryUsed: zod_1.z.string().optional(),
+    gpuMemoryTotal: zod_1.z.string().optional(),
+});

package/compile/schemas/resources.ts

@@ -0,0 +1,144 @@
+/**
+ * Zod schemas for resource parsing validation
+ */
+
+import { z } from 'zod'
+
+/**
+ * CPU output validation schema
+ */
+export const CPUOutputSchema = z
+  .string()
+  .transform((val) => {
+    const num = parseFloat(val)
+    if (isNaN(num)) throw new Error('Invalid CPU value')
+    return Math.round(num * 10) / 10
+  })
+  .pipe(z.number().min(0).max(100))
+
+/**
+ * Memory output validation schema
+ */
+export const MemoryOutputSchema = z
+  .string()
+  .transform((val) => {
+    const parts = val.split(/\s+/)
+    if (parts.length < 3) throw new Error('Invalid memory output')
+    return {
+      percent: Math.round(parseFloat(parts[0]) * 10) / 10,
+      used: `${(parseFloat(parts[1]) || 0).toFixed(1)} GB`,
+      total: `${(parseFloat(parts[2]) || 0).toFixed(1)} GB`,
+    }
+  })
+  .pipe(
+    z.object({
+      percent: z.number().min(0).max(100),
+      used: z.string(),
+      total: z.string(),
+    })
+  )
+
+/**
+ * Disk output validation schema
+ */
+export const DiskOutputSchema = z
+  .string()
+  .transform((val) => {
+    const parts = val.split(/\s+/)
+    const percent = parseFloat(parts[0]?.replace('%', '') || '0') || 0
+
+    const formatSize = (size: string): string => {
+      if (size.endsWith('G') || size.endsWith('M') || size.endsWith('K')) {
+        return size.replace(/([GMK])$/, ' $1B')
+      }
+      return size
+    }
+
+    return {
+      percent: Math.round(percent),
+      used: formatSize(parts[1] || '0 GB'),
+      total: formatSize(parts[2] || '0 GB'),
+    }
+  })
+  .pipe(
+    z.object({
+      percent: z.number().min(0).max(100),
+      used: z.string(),
+      total: z.string(),
+    })
+  )
+
+/**
+ * GPU output validation schema
+ */
+export const GPUOutputSchema = z
+  .string()
+  .transform((val) => {
+    if (val === 'NOGPU' || val === '0' || !val.trim()) {
+      return null
+    }
+
+    const parts = val.split(',').map((s) => s.trim())
+    if (parts.length < 3) {
+      return null
+    }
+
+    return {
+      gpuPercent: parseFloat(parts[0]) || 0,
+      gpuMemoryUsed: `${(parseFloat(parts[1]) / 1024).toFixed(1)} GB`,
+      gpuMemoryTotal: `${(parseFloat(parts[2]) / 1024).toFixed(1)} GB`,
+    }
+  })
+  .pipe(
+    z
+      .object({
+        gpuPercent: z.number().min(0).max(100),
+        gpuMemoryUsed: z.string(),
+        gpuMemoryTotal: z.string(),
+      })
+      .nullable()
+  )
+
+/**
+ * Raw resources input schema
+ */
+export const RawResourcesInputSchema = z.object({
+  cpu: z.string(),
+  memory: z.string(),
+  disk: z.string(),
+  gpu: z.string(),
+  network: z.string().optional(),
+  loadavg: z.string().optional(),
+  processes: z.string().optional(),
+  connections: z.string().optional(),
+})
+
+/**
+ * Parsed resources output schema
+ */
+export const ParsedResourcesSchema = z.object({
+  cpu: z.number().min(0).max(100),
+  memory: z.number().min(0).max(100),
+  disk: z.number().min(0).max(100),
+  gpu: z.string().optional(),
+  network: z.string().optional(),
+  loadavg: z.string().optional(),
+  processes: z.string().optional(),
+  connections: z.string().optional(),
+  cpuPercent: z.number().min(0).max(100),
+  memoryPercent: z.number().min(0).max(100),
+  memoryUsed: z.string(),
+  memoryTotal: z.string(),
+  diskPercent: z.number().min(0).max(100),
+  diskUsed: z.string(),
+  diskTotal: z.string(),
+  gpuPercent: z.number().min(0).max(100).optional(),
+  gpuMemoryUsed: z.string().optional(),
+  gpuMemoryTotal: z.string().optional(),
+})
+
+/**
+ * Type exports for TypeScript inference
+ */
+export type ParsedResources = z.infer<typeof ParsedResourcesSchema>
+export type RawResourcesInput = z.infer<typeof RawResourcesInputSchema>

package/{dist/compile → compile}/terminal-websocket.js

@@ -1,13 +1,16 @@
+"use strict";
 /**
  * Shared WebSocket Types for Terminal
  * Used by both server (Bun) and client (browser)
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketCloseCode = void 0;
 /**
  * WebSocket Close Codes
  * Based on RFC 6455 and custom application codes
  * See: https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
  */
-export const WebSocketCloseCode = {
+exports.WebSocketCloseCode = {
     // Standard codes (1000-2999)
     NORMAL_CLOSURE: 1000,
     ENDPOINT_GOING_AWAY: 1001,

package/compile/terminal-websocket.ts

@@ -0,0 +1,133 @@
+/**
+ * Shared WebSocket Types for Terminal
+ * Used by both server (Bun) and client (browser)
+ */
+
+/**
+ * WebSocket Close Codes
+ * Based on RFC 6455 and custom application codes
+ * See: https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
+ */
+export const WebSocketCloseCode = {
+  // Standard codes (1000-2999)
+  NORMAL_CLOSURE: 1000,
+  ENDPOINT_GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNSUPPORTED_DATA: 1003,
+  // 1004-1006 are reserved and should not be used
+  NO_STATUS_RECEIVED: 1005,
+  ABNORMAL_CLOSURE: 1006,
+  INVALID_FRAME_PAYLOAD_DATA: 1007,
+  POLICY_VIOLATION: 1008,
+  MESSAGE_TOO_BIG: 1009,
+  MISSING_MANDATORY_EXTENSION: 1010,
+  INTERNAL_ERROR: 1011,
+  SERVICE_RESTART: 1012,
+  TRY_AGAIN_LATER: 1013,
+
+  // Application-specific codes (3000-4999)
+  // Terminal-specific codes (4000-4099)
+  SESSION_NOT_FOUND: 4001,
+  SESSION_ALREADY_CLOSED: 4002,
+  INVALID_MESSAGE_FORMAT: 4003,
+  AUTHENTICATION_FAILED: 4004,
+  CONNECTION_TIMEOUT: 4005,
+  SESSION_LIMIT_REACHED: 4006,
+  INVALID_HOST: 4007,
+  SSH_CONNECTION_FAILED: 4008,
+  NETWORK_BLOCKED: 4009, // Network is blocking Hetzner/VPS IPs
+} as const;
+
+export type WebSocketCloseCode = typeof WebSocketCloseCode[keyof typeof WebSocketCloseCode];
+
+/**
+ * Incoming WebSocket message types from client to server
+ */
+export type ClientToServerMessage =
+  | ConnectMessage
+  | InputMessage
+  | ResizeMessage
+  | DisconnectMessage;
+
+/**
+ * Outgoing WebSocket message types from server to client
+ */
+export type ServerToClientMessage =
+  | SessionResponse
+  | ProgressResponse
+  | ErrorResponse
+  | OutputMessage;
+
+/**
+ * Connect to a terminal session
+ */
+export interface ConnectMessage {
+  type: "connect";
+  host: string;
+  user?: string;
+  sessionId?: string | null;
+  environmentId?: string;
+}
+
+/**
+ * Send input to terminal
+ */
+export interface InputMessage {
+  type: "input";
+  data: string;
+}
+
+/**
+ * Resize terminal window
+ */
+export interface ResizeMessage {
+  type: "resize";
+  rows: number;
+  cols: number;
+}
+
+/**
+ * Explicitly disconnect from session
+ */
+export interface DisconnectMessage {
+  type: "disconnect";
+  reason?: string;
+}
+
+/**
+ * Session established response
+ */
+export interface SessionResponse {
+  type: "session";
+  sessionId: string;
+  existing: boolean;
+  host: string;
+  user: string;
+}
+
+/**
+ * Progress update during connection
+ */
+export interface ProgressResponse {
+  type: "progress";
+  message: string;
+  status: "info" | "success" | "error" | "warning";
+}
+
+/**
+ * Error message
+ */
+export interface ErrorResponse {
+  type: "error";
+  code: number;
+  message: string;
+  details?: string;
+}
+
+/**
+ * Terminal output (stdout/stderr)
+ */
+export interface OutputMessage {
+  type: "output" | "stderr";
+  data: string;
+}