@hanzo/runtime 0.0.0-dev

package/src/utils/ArtifactParser.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Chart, parseChart } from '../types/Charts'
+import { ExecutionArtifacts } from '../types/ExecuteResponse'
+
+/**
+ * Utility class for parsing artifacts from command output
+ */
+export class ArtifactParser {
+  /**
+   * Parses artifacts from command output text
+   *
+   * @param output - Raw output from command execution
+   * @returns Parsed artifacts including stdout and charts
+   */
+  public static parseArtifacts(output: string): ExecutionArtifacts {
+    const charts: Chart[] = []
+    let stdout = output
+
+    // Split output by lines to find artifact markers
+    const lines = output.split('\n')
+    const artifactLines: string[] = []
+
+    for (const line of lines) {
+      // Look for the artifact marker pattern
+      if (line.startsWith('dtn_artifact_k39fd2:')) {
+        artifactLines.push(line)
+
+        try {
+          const artifactJson = line.substring('dtn_artifact_k39fd2:'.length).trim()
+          const artifactData = JSON.parse(artifactJson)
+
+          if (artifactData.type === 'chart' && artifactData.value) {
+            const chartData = artifactData.value
+            charts.push(parseChart(chartData))
+          }
+        } catch (error) {
+          // Skip invalid artifacts
+          console.warn('Failed to parse artifact:', error)
+        }
+      }
+    }
+
+    // Remove artifact lines from stdout along with their following newlines
+    for (const line of artifactLines) {
+      stdout = stdout.replace(line + '\n', '')
+      stdout = stdout.replace(line, '')
+    }
+
+    return {
+      stdout,
+      charts: charts.length > 0 ? charts : undefined,
+    }
+  }
+}

package/src/utils/Path.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as _path from 'path'
+
+export function prefixRelativePath(prefix: string, path?: string): string {
+  let result = prefix
+
+  if (path) {
+    path = path.trim()
+    if (path === '~') {
+      result = prefix
+    } else if (path.startsWith('~/')) {
+      result = _path.join(prefix, path.slice(2))
+    } else if (_path.isAbsolute(path)) {
+      result = path
+    } else {
+      result = _path.join(prefix, path)
+    }
+  }
+
+  return result
+}

package/src/utils/Stream.ts

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Process a streaming response from a URL. Stream will terminate if the server-side stream
+ * ends or if the shouldTerminate function returns True.
+ *
+ * @param getStream - A function that returns a promise of an AxiosResponse with .data being the stream
+ * @param onChunk - A function to process each chunk of the response
+ * @param shouldTerminate - A function to check if the response should be terminated
+ * @param chunkTimeout - The timeout for each chunk
+ * @param requireConsecutiveTermination - Whether to require two consecutive termination signals
+ * to terminate the stream.
+ */
+export async function processStreamingResponse(
+  getStream: () => Promise<any>, // can return AxiosResponse with .data being the stream
+  onChunk: (chunk: string) => void,
+  shouldTerminate: () => Promise<boolean>,
+  chunkTimeout = 2000,
+  requireConsecutiveTermination = true,
+): Promise<void> {
+  const response = await getStream()
+  const stream = response.data
+
+  let nextChunkPromise: Promise<Buffer | null> | null = null
+  let exitCheckStreak = 0
+  let terminated = false
+
+  const readNext = (): Promise<Buffer | null> => {
+    return new Promise((resolve) => {
+      const onData = (data: Buffer) => {
+        cleanup()
+        resolve(data)
+      }
+      const cleanup = () => {
+        stream.off('data', onData)
+      }
+      stream.once('data', onData)
+    })
+  }
+
+  const terminationPromise = new Promise<void>((resolve, reject) => {
+    stream.on('end', () => {
+      terminated = true
+      resolve()
+    })
+    stream.on('close', () => {
+      terminated = true
+      resolve()
+    })
+    stream.on('error', (err: Error) => {
+      terminated = true
+      reject(err)
+    })
+  })
+
+  const processLoop = async () => {
+    while (!terminated) {
+      if (!nextChunkPromise) {
+        nextChunkPromise = readNext()
+      }
+
+      const timeoutPromise = new Promise<null>((resolve) => setTimeout(() => resolve(null), chunkTimeout))
+      const result = await Promise.race([nextChunkPromise, timeoutPromise])
+
+      if (result instanceof Buffer) {
+        onChunk(result.toString('utf8'))
+        nextChunkPromise = null
+        exitCheckStreak = 0
+      } else {
+        const shouldEnd = await shouldTerminate()
+        if (shouldEnd) {
+          exitCheckStreak += 1
+          if (!requireConsecutiveTermination || exitCheckStreak > 1) {
+            break
+          }
+        } else {
+          exitCheckStreak = 0
+        }
+      }
+    }
+    stream.destroy()
+    stream.removeAllListeners()
+  }
+
+  await Promise.race([processLoop(), terminationPromise])
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "types": ["node"],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "target": "es2022",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"],
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/typedoc.json

@@ -0,0 +1,33 @@
+{
+  "name": "Daytona TypeScript SDK",
+  "includeVersion": true,
+  "readme": "none",
+  "cleanOutputDir": false,
+
+  "$schema": "https://typedoc-plugin-markdown.org/schema.json",
+  "entryPoints": ["./src/*.ts", "./src/errors/*.ts", "./src/types/*.ts"],
+  "exclude": ["src/index.ts"],
+  "out": "../../apps/docs/src/content/docs/typescript-sdk",
+  "excludePrivate": true,
+  "excludeProtected": true,
+  "excludeExternals": true,
+  "excludeNotDocumented": false,
+  "plugin": ["typedoc-plugin-markdown", "./hooks/typedoc-custom.mjs", "typedoc-plugin-merge-modules"],
+  "theme": "markdown",
+  "sort": ["static-first", "alphabetical"],
+  "groupOrder": ["Classes", "Enums", "*"],
+  "disableSources": true,
+
+  "membersWithOwnFile": [],
+  "flattenOutputFiles": true,
+
+  "hidePageHeader": true,
+  "hideBreadcrumbs": true,
+  "hidePageTitle": true,
+  "hideGroupHeadings": true,
+  "useCodeBlocks": true,
+  "expandObjects": true,
+  "expandParameters": true,
+
+  "mergeModulesMergeMode": "module"
+}