chore: import upstream snapshot with attribution

apps/sim/tools/daytona/utils.ts

@@ -0,0 +1,128 @@
+import type { DaytonaSandboxSummary } from '@/tools/daytona/types'
+
+export const DAYTONA_API_BASE_URL = 'https://app.daytona.io/api'
+
+export const DAYTONA_TOOLBOX_BASE_URL = 'https://proxy.app.daytona.io/toolbox'
+
+/**
+ * Trims and URL-encodes a sandbox identifier, rejecting empty values so a
+ * blank ID can never resolve to a different API route.
+ */
+export function encodeSandboxId(sandboxId: string): string {
+  const trimmed = sandboxId?.trim()
+  if (!trimmed) {
+    throw new Error('Sandbox ID is required')
+  }
+  return encodeURIComponent(trimmed)
+}
+
+/**
+ * Builds a toolbox API URL for a sandbox-scoped endpoint.
+ */
+export function daytonaToolboxUrl(sandboxId: string, path: string): string {
+  return `${DAYTONA_TOOLBOX_BASE_URL}/${encodeSandboxId(sandboxId)}${path}`
+}
+
+/**
+ * Parses a Daytona API JSON response, tolerating empty bodies (e.g., 204 or
+ * empty 200 responses from lifecycle endpoints).
+ */
+export async function parseDaytonaJson(response: Response): Promise<Record<string, any>> {
+  const text = await response.text()
+  if (!text) return {}
+  try {
+    return JSON.parse(text)
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Extracts a human-readable error message from a Daytona API error response.
+ */
+export async function extractDaytonaError(response: Response, fallback: string): Promise<string> {
+  try {
+    const data = await response.json()
+    if (typeof data?.message === 'string') return data.message
+    if (Array.isArray(data?.message)) return data.message.join(', ')
+    if (typeof data?.error === 'string') return data.error
+  } catch {
+    // Non-JSON error body; fall through to the fallback message
+  }
+  return `${fallback} (status ${response.status})`
+}
+
+/**
+ * Coerces an optional user- or LLM-provided value to a number, treating
+ * empty/missing values as undefined.
+ */
+export function toOptionalNumber(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === '') return undefined
+  const num = Number(value)
+  return Number.isNaN(num) ? undefined : num
+}
+
+/**
+ * Coerces an optional user- or LLM-provided value to a boolean, treating
+ * empty/missing values as undefined.
+ */
+export function toOptionalBoolean(value: unknown): boolean | undefined {
+  if (value === undefined || value === null || value === '') return undefined
+  if (typeof value === 'boolean') return value
+  const normalized = String(value).trim().toLowerCase()
+  if (normalized === 'true') return true
+  if (normalized === 'false') return false
+  return undefined
+}
+
+/**
+ * Maps a raw Daytona sandbox object to the normalized summary shape.
+ */
+export function mapDaytonaSandbox(sandbox: Record<string, any>): DaytonaSandboxSummary {
+  return {
+    id: sandbox.id ?? '',
+    name: sandbox.name ?? '',
+    state: sandbox.state ?? null,
+    snapshot: sandbox.snapshot ?? null,
+    target: sandbox.target ?? null,
+    cpu: sandbox.cpu ?? null,
+    gpu: sandbox.gpu ?? null,
+    memory: sandbox.memory ?? null,
+    disk: sandbox.disk ?? null,
+    labels: sandbox.labels ?? {},
+    public: sandbox.public ?? null,
+    errorReason: sandbox.errorReason ?? null,
+    autoStopInterval: sandbox.autoStopInterval ?? null,
+    createdAt: sandbox.createdAt ?? null,
+    updatedAt: sandbox.updatedAt ?? null,
+  }
+}
+
+/**
+ * Shared output property map for sandbox summary outputs.
+ */
+export const DAYTONA_SANDBOX_OUTPUT_PROPERTIES = {
+  id: { type: 'string', description: 'Sandbox ID' },
+  name: { type: 'string', description: 'Sandbox name' },
+  state: { type: 'string', description: 'Sandbox state (e.g., started, stopped)', optional: true },
+  snapshot: {
+    type: 'string',
+    description: 'Snapshot the sandbox was created from',
+    optional: true,
+  },
+  target: { type: 'string', description: 'Region the sandbox runs in', optional: true },
+  cpu: { type: 'number', description: 'CPU cores allocated', optional: true },
+  gpu: { type: 'number', description: 'GPU units allocated', optional: true },
+  memory: { type: 'number', description: 'Memory allocated in GB', optional: true },
+  disk: { type: 'number', description: 'Disk space allocated in GB', optional: true },
+  labels: { type: 'json', description: 'Labels attached to the sandbox', optional: true },
+  public: { type: 'boolean', description: 'Whether the HTTP preview is public', optional: true },
+  errorReason: { type: 'string', description: 'Error reason if in error state', optional: true },
+  autoStopInterval: {
+    type: 'number',
+    description: 'Auto-stop interval in minutes (0 means disabled)',
+    optional: true,
+  },
+  createdAt: { type: 'string', description: 'Creation timestamp', optional: true },
+  updatedAt: { type: 'string', description: 'Last update timestamp', optional: true },
+} as const