@ebowwa/codespaces-types 1.1.0 → 1.2.0

package/runtime/api.ts

@@ -0,0 +1,857 @@
+/**
+ * Zod schemas for API request/response validation
+ */
+
+import { GLMModelSchema } from "./glm.js";
+
+import { z } from "zod";
+
+/**
+ * Environment ID validation
+ */
+export const EnvironmentIdSchema = z
+  .string()
+  .transform((val) => parseInt(val, 10))
+  .pipe(z.number().int().positive("Environment ID must be a positive integer"));
+
+/**
+ * Create Environment Request
+ */
+export const 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(),
+});
+
+/**
+ * Update Metadata Request
+ */
+export const 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(),
+});
+
+/**
+ * Update Activity Request
+ */
+export const 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(),
+});
+
+/**
+ * Update Plugins Request
+ */
+export const UpdatePluginsRequestSchema = z.object({
+  plugins: z
+    .record(
+      z.string(),
+      z.object({
+        enabled: z.boolean(),
+        config: z.record(z.string(), z.any()).optional(),
+      }),
+    )
+    .optional(),
+});
+
+/**
+ * SSH Connection Request
+ */
+export const SSHConnectionRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+});
+
+/**
+ * SSH Test Request
+ */
+export const 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(),
+});
+
+/**
+ * SSH Fingerprint Request
+ */
+export const 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(),
+});
+
+/**
+ * Terminal Create Session Request
+ */
+export const 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(),
+});
+
+/**
+ * Terminal Resize Request
+ */
+export const 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),
+});
+
+/**
+ * SCP Upload Request
+ */
+export const 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(),
+});
+
+/**
+ * SCP Download Request
+ */
+export const 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(),
+});
+
+/**
+ * Files List Request
+ */
+export const FilesListRequestSchema = z.object({
+  host: z.string().min(1, "Host is required"),
+  user: z.string().default("root").optional(),
+  path: z.string().default(".").optional(),
+});
+
+/**
+ * Files Preview Request
+ */
+export const 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"),
+});
+
+/**
+ * SSH Key ID validation
+ */
+export const SSHKeyIdSchema = z
+  .string()
+  .transform((val) => parseInt(val, 10))
+  .pipe(z.number().int().positive("SSH Key ID must be a positive integer"));
+
+/**
+ * Create SSH Key Request
+ */
+export const 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(),
+});
+
+/**
+ * AI Generate Request
+ */
+export const AIGenerateRequestSchema = z.object({
+  prompt: z.string().min(1, "Prompt is required"),
+  model: z.string().optional(), // Generic string for any AI provider
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional(),
+});
+
+/**
+ * AI Chat Request
+ */
+export const AIChatRequestSchema = z.object({
+  messages: z.array(z.any()).min(1, "At least one message is required"),
+  model: z.string().optional(), // Generic string for any AI provider
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional(),
+});
+
+/**
+ * AI Suggest Name Request
+ */
+export const AISuggestNameRequestSchema = z.object({
+  project: z.string().optional(),
+  description: z.string().optional(),
+});
+
+/**
+ * AI Suggest Server Type Request
+ */
+export const AISuggestServerTypeRequestSchema = z.object({
+  workload: z.string().min(1, "Workload description is required"),
+});
+
+/**
+ * AI Analyze Resources Request
+ */
+export const AIAnalyzeResourcesRequestSchema = z.object({
+  cpu: z.number().min(0).max(100),
+  memory: z.number().min(0).max(100),
+  disk: z.number().min(0).max(100),
+});
+
+/**
+ * AI Troubleshoot SSH Request
+ */
+export const AITroubleshootSSHRequestSchema = z.object({
+  error: z.string().min(1, "Error message is required"),
+});
+
+/**
+ * AI Suggest Actions Request
+ */
+export const AISuggestActionsRequestSchema = z.object({
+  status: z.string().min(1, "Status is required"),
+  age: z.string().optional(),
+});
+
+/**
+ * AI Status Message Request
+ */
+export const AIStatusMessageRequestSchema = z.object({
+  status: z.string().min(1, "Status is required"),
+  name: z.string().min(1, "Name is required"),
+});
+
+/**
+ * Metrics Query Schema (for query parameters)
+ */
+export const 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)),
+});
+
+/**
+ * Insert Metric Request
+ */
+export const 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(),
+});
+
+/**
+ * AI Analyze Historical Request
+ */
+export const AIAnalyzeHistoricalRequestSchema = z.object({
+  environmentId: z.number().int().positive(),
+  hours: z.number().int().positive().max(8760).default(24),
+});
+
+/**
+ * Type exports for TypeScript inference
+ */
+export type CreateEnvironmentRequest = z.infer<
+  typeof CreateEnvironmentRequestSchema
+>;
+export type UpdateMetadataRequest = z.infer<typeof UpdateMetadataRequestSchema>;
+export type UpdateActivityRequest = z.infer<typeof UpdateActivityRequestSchema>;
+export type UpdatePluginsRequest = z.infer<typeof UpdatePluginsRequestSchema>;
+export type SSHConnectionRequest = z.infer<typeof SSHConnectionRequestSchema>;
+export type SSHTestRequest = z.infer<typeof SSHTestRequestSchema>;
+export type SSHFingerprintRequest = z.infer<typeof SSHFingerprintRequestSchema>;
+export type SCPUploadRequest = z.infer<typeof SCPUploadRequestSchema>;
+export type SCPDownloadRequest = z.infer<typeof SCPDownloadRequestSchema>;
+export type FilesListRequest = z.infer<typeof FilesListRequestSchema>;
+export type FilesPreviewRequest = z.infer<typeof FilesPreviewRequestSchema>;
+export type AIGenerateRequest = z.infer<typeof AIGenerateRequestSchema>;
+export type AIChatRequest = z.infer<typeof AIChatRequestSchema>;
+export type AISuggestNameRequest = z.infer<typeof AISuggestNameRequestSchema>;
+export type AISuggestServerTypeRequest = z.infer<
+  typeof AISuggestServerTypeRequestSchema
+>;
+export type AIAnalyzeResourcesRequest = z.infer<
+  typeof AIAnalyzeResourcesRequestSchema
+>;
+export type AITroubleshootSSHRequest = z.infer<
+  typeof AITroubleshootSSHRequestSchema
+>;
+export type AISuggestActionsRequest = z.infer<
+  typeof AISuggestActionsRequestSchema
+>;
+export type AIStatusMessageRequest = z.infer<
+  typeof AIStatusMessageRequestSchema
+>;
+export type InsertMetricRequest = z.infer<typeof InsertMetricRequestSchema>;
+export type AIAnalyzeHistoricalRequest = z.infer<
+  typeof AIAnalyzeHistoricalRequestSchema
+>;
+export type TerminalCreateSession = z.infer<typeof TerminalCreateSessionSchema>;
+export type TerminalResize = z.infer<typeof TerminalResizeSchema>;
+export type SSHKeyId = z.infer<typeof SSHKeyIdSchema>;
+export type CreateSSHKeyRequest = z.infer<typeof CreateSSHKeyRequestSchema>;
+
+/**
+ * Seed Install Request
+ */
+export const SeedInstallRequestSchema = z.object({
+  environmentId: z.string().min(1, "Environment ID is required"),
+  autoConfirm: z.boolean().default(true).optional(),
+});
+
+/**
+ * Seed Install Response (partial - actual response includes more fields)
+ */
+export const SeedInstallResponseSchema = z.object({
+  success: z.boolean(),
+  cloned: z.boolean(),
+  setupRun: z.boolean(),
+  seedPath: z.string(),
+  error: z.string().optional(),
+  output: z.array(z.string()),
+});
+
+/**
+ * Seed Status Response
+ */
+export const SeedStatusResponseSchema = z.object({
+  installed: z.boolean(),
+  setupComplete: z.boolean(),
+  version: z.string().optional(),
+  branch: z.string().optional(),
+});
+
+/**
+ * Login Commands Response
+ */
+export const LoginCommandsResponseSchema = z.object({
+  ssh: z.string(),
+  web: z.string(),
+  claude: z.string(),
+  quick: z.string(),
+});
+
+export type SeedInstallRequest = z.infer<typeof SeedInstallRequestSchema>;
+export type SeedInstallResponse = z.infer<typeof SeedInstallResponseSchema>;
+export type SeedStatusResponse = z.infer<typeof SeedStatusResponseSchema>;
+export type LoginCommandsResponse = z.infer<typeof LoginCommandsResponseSchema>;
+
+// ============================================
+// Volume Schemas
+// ============================================
+
+/**
+ * Volume ID validation
+ */
+export const VolumeIdSchema = z
+  .string()
+  .transform((val) => parseInt(val, 10))
+  .pipe(z.number().int().positive("Volume ID must be a positive integer"));
+
+/**
+ * Create Volume Request
+ */
+export const 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(), // Server ID to attach to
+  location: z.string().optional(), // Location if not attaching to server
+  automount: z.boolean().default(true).optional(),
+  format: z.enum(["ext4", "xfs"]).optional(),
+  labels: z.record(z.string(), z.any()).optional(),
+});
+
+/**
+ * Update Volume Request
+ */
+export const UpdateVolumeRequestSchema = z.object({
+  name: z.string().min(1).max(64).optional(),
+  labels: z.record(z.string(), z.any()).optional(),
+});
+
+/**
+ * Attach Volume Request
+ */
+export const 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(),
+});
+
+/**
+ * Detach Volume Request
+ */
+export const DetachVolumeRequestSchema = z.object({
+  volumeId: z.number().int().positive("Volume ID is required"),
+});
+
+/**
+ * Resize Volume Request
+ */
+export const 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"),
+});
+
+/**
+ * Volume Protection Request
+ */
+export const VolumeProtectionRequestSchema = z.object({
+  delete: z.boolean(),
+});
+
+/**
+ * Volume Price Query
+ */
+export const 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"),
+});
+
+export type VolumeId = z.infer<typeof VolumeIdSchema>;
+export type CreateVolumeRequest = z.infer<typeof CreateVolumeRequestSchema>;
+export type UpdateVolumeRequest = z.infer<typeof UpdateVolumeRequestSchema>;
+export type AttachVolumeRequest = z.infer<typeof AttachVolumeRequestSchema>;
+export type DetachVolumeRequest = z.infer<typeof DetachVolumeRequestSchema>;
+export type ResizeVolumeRequest = z.infer<typeof ResizeVolumeRequestSchema>;
+export type VolumeProtectionRequest = z.infer<typeof VolumeProtectionRequestSchema>;
+export type VolumePriceQuery = z.infer<typeof VolumePriceQuerySchema>;
+
+// ============================================
+// Tmux Session Management Schemas
+// ============================================
+
+/**
+ * Tmux Send Command Request
+ */
+export const 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(),
+});
+
+/**
+ * Tmux Split Pane Request
+ */
+export const TmuxSplitPaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  direction: z.enum(["h", "v"]).default("v"),
+  command: z.string().optional(),
+});
+
+/**
+ * Tmux List Windows Request
+ */
+export const TmuxListWindowsSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+});
+
+/**
+ * Tmux List Panes Request
+ */
+export const TmuxListPanesSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  windowIndex: z.string().default("0").optional(),
+});
+
+/**
+ * Tmux Capture Pane Request
+ */
+export const TmuxCapturePaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  paneIndex: z.string().default("0").optional(),
+});
+
+/**
+ * Tmux Get History Request
+ */
+export const 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(),
+});
+
+/**
+ * Tmux Switch Window Request
+ */
+export const TmuxSwitchWindowSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  windowIndex: z.string().min(1, "Window index is required"),
+});
+
+/**
+ * Tmux Switch Pane Request
+ */
+export const TmuxSwitchPaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  paneIndex: z.string().min(1, "Pane index is required"),
+});
+
+/**
+ * Tmux Rename Window Request
+ */
+export const 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),
+});
+
+/**
+ * Tmux Kill Pane Request
+ */
+export const TmuxKillPaneSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  paneIndex: z.string().min(1, "Pane index is required"),
+});
+
+/**
+ * Tmux Detailed Info Request
+ */
+export const TmuxDetailedInfoSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+});
+
+export type TmuxSendCommand = z.infer<typeof TmuxSendCommandSchema>;
+export type TmuxSplitPane = z.infer<typeof TmuxSplitPaneSchema>;
+export type TmuxListWindows = z.infer<typeof TmuxListWindowsSchema>;
+export type TmuxListPanes = z.infer<typeof TmuxListPanesSchema>;
+export type TmuxCapturePane = z.infer<typeof TmuxCapturePaneSchema>;
+export type TmuxGetHistory = z.infer<typeof TmuxGetHistorySchema>;
+export type TmuxSwitchWindow = z.infer<typeof TmuxSwitchWindowSchema>;
+export type TmuxSwitchPane = z.infer<typeof TmuxSwitchPaneSchema>;
+export type TmuxRenameWindow = z.infer<typeof TmuxRenameWindowSchema>;
+export type TmuxKillPane = z.infer<typeof TmuxKillPaneSchema>;
+export type TmuxDetailedInfo = z.infer<typeof TmuxDetailedInfoSchema>;
+
+// ============================================
+// Multi-Node Tmux Manager Schemas
+// ============================================
+
+/**
+ * Tmux Manager Add Node Request
+ */
+export const 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(),
+});
+
+/**
+ * Tmux Manager Create Session Request
+ */
+export const 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(),
+});
+
+/**
+ * Tmux Manager Attach Session Request
+ */
+export const TmuxManagerAttachSessionSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().optional(),
+});
+
+/**
+ * Tmux Manager Kill Session Request
+ */
+export const TmuxManagerKillSessionSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+});
+
+/**
+ * Tmux Manager Send Command Request
+ */
+export const 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"),
+});
+
+/**
+ * Tmux Manager Batch Send Command Request
+ */
+export const 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),
+});
+
+/**
+ * Tmux Manager Split Pane Request
+ */
+export const 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"),
+});
+
+/**
+ * Tmux Manager Capture Pane Request
+ */
+export const 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"),
+});
+
+/**
+ * Tmux Manager Get History Request
+ */
+export const 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),
+});
+
+/**
+ * Tmux Manager List Windows Request
+ */
+export const TmuxManagerListWindowsSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+});
+
+/**
+ * Tmux Manager List Panes Request
+ */
+export const 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"),
+});
+
+/**
+ * Tmux Manager Switch Window Request
+ */
+export const 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"),
+});
+
+/**
+ * Tmux Manager Switch Pane Request
+ */
+export const 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"),
+});
+
+/**
+ * Tmux Manager Rename Window Request
+ */
+export const 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),
+});
+
+/**
+ * Tmux Manager Kill Pane Request
+ */
+export const 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"),
+});
+
+/**
+ * Tmux Manager Cleanup Old Sessions Request
+ */
+export const TmuxManagerCleanupOldSessionsSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  ageLimitMs: z.number().int().positive().default(30 * 24 * 60 * 60 * 1000), // 30 days
+});
+
+/**
+ * Tmux Manager Detailed Session Request
+ */
+export const TmuxManagerDetailedSessionSchema = z.object({
+  nodeId: z.string().min(1, "Node ID is required"),
+  sessionName: z.string().min(1, "Session name is required"),
+});
+
+/**
+ * Tmux Manager List Sessions Query
+ */
+export const 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(),
+});
+
+export type TmuxManagerAddNode = z.infer<typeof TmuxManagerAddNodeSchema>;
+export type TmuxManagerCreateSession = z.infer<typeof TmuxManagerCreateSessionSchema>;
+export type TmuxManagerAttachSession = z.infer<typeof TmuxManagerAttachSessionSchema>;
+export type TmuxManagerKillSession = z.infer<typeof TmuxManagerKillSessionSchema>;
+export type TmuxManagerSendCommand = z.infer<typeof TmuxManagerSendCommandSchema>;
+export type TmuxManagerBatchSendCommand = z.infer<typeof TmuxManagerBatchSendCommandSchema>;
+export type TmuxManagerSplitPane = z.infer<typeof TmuxManagerSplitPaneSchema>;
+export type TmuxManagerCapturePane = z.infer<typeof TmuxManagerCapturePaneSchema>;
+export type TmuxManagerGetHistory = z.infer<typeof TmuxManagerGetHistorySchema>;
+export type TmuxManagerListWindows = z.infer<typeof TmuxManagerListWindowsSchema>;
+export type TmuxManagerListPanes = z.infer<typeof TmuxManagerListPanesSchema>;
+export type TmuxManagerSwitchWindow = z.infer<typeof TmuxManagerSwitchWindowSchema>;
+export type TmuxManagerSwitchPane = z.infer<typeof TmuxManagerSwitchPaneSchema>;
+export type TmuxManagerRenameWindow = z.infer<typeof TmuxManagerRenameWindowSchema>;
+export type TmuxManagerKillPane = z.infer<typeof TmuxManagerKillPaneSchema>;
+export type TmuxManagerCleanupOldSessions = z.infer<typeof TmuxManagerCleanupOldSessionsSchema>;
+export type TmuxManagerDetailedSession = z.infer<typeof TmuxManagerDetailedSessionSchema>;
+export type TmuxManagerListSessionsQuery = z.infer<typeof TmuxManagerListSessionsQuerySchema>;
+
+// ============================================
+// Activities Schemas
+// ============================================
+
+/**
+ * Add Activity Request
+ */
+export const 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(),
+});
+
+/**
+ * Activities Query Schema (for query parameters)
+ */
+export const 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(),
+});
+
+/**
+ * Cleanup Activities Request
+ */
+export const CleanupActivitiesRequestSchema = z.object({
+  environmentId: z.string().optional(),
+  keepHours: z
+    .number()
+    .int()
+    .positive()
+    .default(720) // 30 days
+    .optional(),
+});
+
+export type AddActivityRequest = z.infer<typeof AddActivityRequestSchema>;
+export type ActivitiesQueryParams = z.infer<typeof ActivitiesQueryParamsSchema>;
+export type CleanupActivitiesRequest = z.infer<typeof CleanupActivitiesRequestSchema>;