@hanzo/runtime 0.0.0-dev

package/src/LspServer.ts

@@ -0,0 +1,245 @@
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CompletionList, LspSymbol, ToolboxApi } from '@daytonaio/api-client'
+import { prefixRelativePath } from './utils/Path'
+
+/**
+ * Supported language server types.
+ */
+export enum LspLanguageId {
+  PYTHON = 'python',
+  TYPESCRIPT = 'typescript',
+  JAVASCRIPT = 'javascript',
+}
+
+/**
+ * Represents a zero-based position within a text document,
+ * specified by line number and character offset.
+ *
+ * @interface
+ * @property {number} line - Zero-based line number in the document
+ * @property {number} character - Zero-based character offset on the line
+ *
+ * @example
+ * const position: Position = {
+ *   line: 10,     // Line 11 (zero-based)
+ *   character: 15  // Character 16 on the line (zero-based)
+ * };
+ */
+export type Position = {
+  /** Zero-based line number */
+  line: number
+  /** Zero-based character offset */
+  character: number
+}
+
+/**
+ * Provides Language Server Protocol functionality for code intelligence to provide
+ * IDE-like features such as code completion, symbol search, and more.
+ *
+ * @property {LspLanguageId} languageId - The language server type (e.g., "typescript")
+ * @property {string} pathToProject - Absolute path to the project root directory
+ * @property {ToolboxApi} toolboxApi - API client for Sandbox operations
+ * @property {SandboxInstance} instance - The Sandbox instance this server belongs to
+ *
+ * @class
+ */
+export class LspServer {
+  constructor(
+    private readonly languageId: LspLanguageId,
+    private readonly pathToProject: string,
+    private readonly toolboxApi: ToolboxApi,
+    private readonly sandboxId: string,
+  ) {
+    if (!Object.values(LspLanguageId).includes(this.languageId)) {
+      throw new Error(
+        `Invalid languageId: ${this.languageId}. Supported values are: ${Object.values(LspLanguageId).join(', ')}`,
+      )
+    }
+  }
+
+  /**
+   * Starts the language server, must be called before using any other LSP functionality.
+   * It initializes the language server for the specified language and project.
+   *
+   * @returns {Promise<void>}
+   *
+   * @example
+   * const lsp = await sandbox.createLspServer('typescript', 'workspace/project');
+   * await lsp.start();  // Initialize the server
+   * // Now ready for LSP operations
+   */
+  public async start(): Promise<void> {
+    await this.toolboxApi.lspStart(this.sandboxId, {
+      languageId: this.languageId,
+      pathToProject: this.pathToProject,
+    })
+  }
+
+  /**
+   * Stops the language server, should be called when the LSP server is no longer needed to
+   * free up system resources.
+   *
+   * @returns {Promise<void>}
+   *
+   * @example
+   * // When done with LSP features
+   * await lsp.stop();  // Clean up resources
+   */
+  public async stop(): Promise<void> {
+    await this.toolboxApi.lspStop(this.sandboxId, {
+      languageId: this.languageId,
+      pathToProject: this.pathToProject,
+    })
+  }
+
+  /**
+   * Notifies the language server that a file has been opened, enabling
+   * language features like diagnostics and completions for that file. The server
+   * will begin tracking the file's contents and providing language features.
+   *
+   * @param {string} path - Path to the opened file. Relative paths are resolved based on the user's
+   * root directory.
+   * @returns {Promise<void>}
+   *
+   * @example
+   * // When opening a file for editing
+   * await lsp.didOpen('workspace/project/src/index.ts');
+   * // Now can get completions, symbols, etc. for this file
+   */
+  public async didOpen(path: string): Promise<void> {
+    await this.toolboxApi.lspDidOpen(this.sandboxId, {
+      languageId: this.languageId,
+      pathToProject: this.pathToProject,
+      uri: 'file://' + prefixRelativePath(this.pathToProject, path),
+    })
+  }
+
+  /**
+   * Notifies the language server that a file has been closed, should be called when a file is closed
+   * in the editor to allow the language server to clean up any resources associated with that file.
+   *
+   * @param {string} path - Path to the closed file. Relative paths are resolved based on the project path
+   * set in the LSP server constructor.
+   * @returns {Promise<void>}
+   *
+   * @example
+   * // When done editing a file
+   * await lsp.didClose('workspace/project/src/index.ts');
+   */
+  public async didClose(path: string): Promise<void> {
+    await this.toolboxApi.lspDidClose(this.sandboxId, {
+      languageId: this.languageId,
+      pathToProject: this.pathToProject,
+      uri: 'file://' + prefixRelativePath(this.pathToProject, path),
+    })
+  }
+
+  /**
+   * Get symbol information (functions, classes, variables, etc.) from a document.
+   *
+   * @param {string} path - Path to the file to get symbols from. Relative paths are resolved based on the project path
+   * set in the LSP server constructor.
+   * @returns {Promise<LspSymbol[]>} List of symbols in the document. Each symbol includes:
+   *                                 - name: The symbol's name
+   *                                 - kind: The symbol's kind (function, class, variable, etc.)
+   *                                 - location: The location of the symbol in the file
+   *
+   * @example
+   * // Get all symbols in a file
+   * const symbols = await lsp.documentSymbols('workspace/project/src/index.ts');
+   * symbols.forEach(symbol => {
+   *   console.log(`${symbol.kind} ${symbol.name}: ${symbol.location}`);
+   * });
+   */
+  public async documentSymbols(path: string): Promise<LspSymbol[]> {
+    const response = await this.toolboxApi.lspDocumentSymbols(
+      this.sandboxId,
+      this.languageId,
+      this.pathToProject,
+      'file://' + prefixRelativePath(this.pathToProject, path),
+    )
+    return response.data
+  }
+
+  /**
+   * Searches for symbols matching the query string across the entire Sandbox.
+   *
+   * @param {string} query - Search query to match against symbol names
+   * @returns {Promise<LspSymbol[]>} List of matching symbols from all files. Each symbol includes:
+   *                                 - name: The symbol's name
+   *                                 - kind: The symbol's kind (function, class, variable, etc.)
+   *                                 - location: The location of the symbol in the file
+   *
+   * @deprecated Use `sandboxSymbols` instead. This method will be removed in a future version.
+   */
+  public async workspaceSymbols(query: string): Promise<LspSymbol[]> {
+    return await this.sandboxSymbols(query)
+  }
+
+  /**
+   * Searches for symbols matching the query string across the entire Sandbox.
+   *
+   * @param {string} query - Search query to match against symbol names
+   * @returns {Promise<LspSymbol[]>} List of matching symbols from all files. Each symbol includes:
+   *                                 - name: The symbol's name
+   *                                 - kind: The symbol's kind (function, class, variable, etc.)
+   *                                 - location: The location of the symbol in the file
+   *
+   * @example
+   * // Search for all symbols containing "User"
+   * const symbols = await lsp.sandboxSymbols('User');
+   * symbols.forEach(symbol => {
+   *   console.log(`${symbol.name} (${symbol.kind}) in ${symbol.location}`);
+   * });
+   */
+  public async sandboxSymbols(query: string): Promise<LspSymbol[]> {
+    const response = await this.toolboxApi.lspWorkspaceSymbols(
+      this.sandboxId,
+      this.languageId,
+      this.pathToProject,
+      query,
+    )
+    return response.data
+  }
+
+  /**
+   * Gets completion suggestions at a position in a file.
+   *
+   * @param {string} path - Path to the file. Relative paths are resolved based on the project path
+   * set in the LSP server constructor.
+   * @param {Position} position - The position in the file where completion was requested
+   * @returns {Promise<CompletionList>} List of completion suggestions. The list includes:
+   *                                    - isIncomplete: Whether more items might be available
+   *                                    - items: List of completion items, each containing:
+   *                                      - label: The text to insert
+   *                                      - kind: The kind of completion
+   *                                      - detail: Additional details about the item
+   *                                      - documentation: Documentation for the item
+   *                                      - sortText: Text used to sort the item in the list
+   *                                      - filterText: Text used to filter the item
+   *                                      - insertText: The actual text to insert (if different from label)
+   *
+   * @example
+   * // Get completions at a specific position
+   * const completions = await lsp.completions('workspace/project/src/index.ts', {
+   *   line: 10,
+   *   character: 15
+   * });
+   * completions.items.forEach(item => {
+   *   console.log(`${item.label} (${item.kind}): ${item.detail}`);
+   * });
+   */
+  public async completions(path: string, position: Position): Promise<CompletionList> {
+    const response = await this.toolboxApi.lspCompletions(this.sandboxId, {
+      languageId: this.languageId,
+      pathToProject: this.pathToProject,
+      uri: 'file://' + prefixRelativePath(this.pathToProject, path),
+      position,
+    })
+    return response.data
+  }
+}

package/src/ObjectStorage.ts

@@ -0,0 +1,232 @@
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ListObjectsV2Command, S3Client } from '@aws-sdk/client-s3'
+import { Upload } from '@aws-sdk/lib-storage'
+import * as crypto from 'crypto'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as tar from 'tar'
+import { PassThrough } from 'stream'
+import { DaytonaError } from './errors/DaytonaError'
+
+/**
+ * Configuration for the ObjectStorage class.
+ *
+ * @interface
+ * @property {string} endpointUrl - The endpoint URL for the object storage service.
+ * @property {string} accessKeyId - The access key ID for the object storage service.
+ * @property {string} secretAccessKey - The secret access key for the object storage service.
+ * @property {string} [sessionToken] - The session token for the object storage service. Used for temporary credentials.
+ * @property {string} [bucketName] - The name of the bucket to use.
+ */
+export interface ObjectStorageConfig {
+  endpointUrl: string
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+  bucketName?: string
+}
+
+/**
+ * ObjectStorage class for interacting with object storage services.
+ *
+ * @class
+ * @param {ObjectStorageConfig} config - The configuration for the object storage service.
+ */
+export class ObjectStorage {
+  private bucketName: string
+  private s3Client: S3Client
+
+  constructor(config: ObjectStorageConfig) {
+    this.bucketName = config.bucketName || 'daytona-volume-builds'
+    this.s3Client = new S3Client({
+      region: this.extractAwsRegion(config.endpointUrl) || 'us-east-1',
+      endpoint: config.endpointUrl,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+        sessionToken: config.sessionToken,
+      },
+      forcePathStyle: true,
+    })
+  }
+
+  /**
+   * Upload a file or directory to object storage.
+   *
+   * @param {string} path - The path to the file or directory to upload.
+   * @param {string} organizationId - The organization ID to use for the upload.
+   * @param {string} archiveBasePath - The base path to use for the archive.
+   * @returns {Promise<string>} The hash of the uploaded file or directory.
+   */
+  async upload(path: string, organizationId: string, archiveBasePath: string): Promise<string> {
+    if (!fs.existsSync(path)) {
+      const errMsg = `Path does not exist: ${path}`
+      throw new DaytonaError(errMsg)
+    }
+
+    // Compute hash for the path
+    const pathHash = await this.computeHashForPathMd5(path, archiveBasePath)
+
+    // Define the S3 prefix
+    const prefix = `${organizationId}/${pathHash}/`
+    const s3Key = `${prefix}context.tar`
+
+    // Check if it already exists in S3
+    if (await this.folderExistsInS3(prefix)) {
+      return pathHash
+    }
+
+    // Upload to S3
+    await this.uploadAsTar(s3Key, path, archiveBasePath)
+
+    return pathHash
+  }
+
+  /**
+   * Compute a hash for a file or directory.
+   *
+   * @param {string} pathStr - The path to the file or directory to hash.
+   * @param {string} archiveBasePath - The base path to use for the archive.
+   * @returns {Promise<string>} The hash of the file or directory.
+   */
+  private async computeHashForPathMd5(pathStr: string, archiveBasePath: string): Promise<string> {
+    const md5Hasher = crypto.createHash('md5')
+    const absPathStr = path.resolve(pathStr)
+
+    md5Hasher.update(archiveBasePath)
+
+    if (fs.statSync(absPathStr).isFile()) {
+      // For files, hash the content
+      await this.hashFile(absPathStr, md5Hasher)
+    } else {
+      // For directories, recursively hash all files and their paths
+      await this.hashDirectory(absPathStr, pathStr, md5Hasher)
+    }
+
+    return md5Hasher.digest('hex')
+  }
+
+  /**
+   * Recursively hash a directory and its contents.
+   *
+   * @param {string} dirPath - The path to the directory to hash.
+   * @param {string} basePath - The base path to use for the hash.
+   * @param {crypto.Hash} hasher - The hasher to use for the hash.
+   * @returns {Promise<void>} A promise that resolves when the directory has been hashed.
+   */
+  private async hashDirectory(dirPath: string, basePath: string, hasher: crypto.Hash): Promise<void> {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+
+    const hasSubdirs = entries.some((e) => e.isDirectory())
+    const hasFiles = entries.some((e) => e.isFile())
+
+    if (!hasSubdirs && !hasFiles) {
+      // Empty directory
+      const relDir = path.relative(basePath, dirPath)
+      hasher.update(relDir)
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name)
+
+      if (entry.isDirectory()) {
+        await this.hashDirectory(fullPath, basePath, hasher)
+      } else if (entry.isFile()) {
+        const relPath = path.relative(basePath, fullPath)
+        hasher.update(relPath)
+
+        await this.hashFile(fullPath, hasher)
+      }
+    }
+  }
+
+  /**
+   * Hash a file.
+   *
+   * @param {string} filePath - The path to the file to hash.
+   * @param {crypto.Hash} hasher - The hasher to use for the hash.
+   * @returns {Promise<void>} A promise that resolves when the file has been hashed.
+   */
+  private async hashFile(filePath: string, hasher: crypto.Hash): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      const stream = fs.createReadStream(filePath, { highWaterMark: 8192 })
+      stream.on('data', (chunk) => hasher.update(chunk))
+      stream.on('end', resolve)
+      stream.on('error', reject)
+    })
+  }
+
+  /**
+   * Check if a prefix (folder) exists in S3.
+   *
+   * @param {string} prefix - The prefix to check.
+   * @returns {Promise<boolean>} True if the prefix exists, false otherwise.
+   */
+  private async folderExistsInS3(prefix: string): Promise<boolean> {
+    const response = await this.s3Client.send(
+      new ListObjectsV2Command({
+        Bucket: this.bucketName,
+        Prefix: prefix,
+        MaxKeys: 1,
+      }),
+    )
+
+    return !!response.Contents && response.Contents.length > 0
+  }
+
+  /**
+   * Create a tar archive of the specified path and upload it to S3.
+   *
+   * @param {string} s3Key - The key to use for the uploaded file.
+   * @param {string} sourcePath - The path to the file or directory to upload.
+   * @param {string} archiveBasePath - The base path to use for the archive.
+   */
+  private async uploadAsTar(s3Key: string, sourcePath: string, archiveBasePath: string) {
+    sourcePath = path.resolve(sourcePath)
+
+    const normalizedSourcePath = path.normalize(sourcePath)
+    const normalizedArchiveBasePath = path.normalize(archiveBasePath)
+
+    let basePrefix: string
+
+    if (normalizedArchiveBasePath === '.') {
+      // When archiveBasePath is empty (normalized to '.'), use the normalizedSourcePath as cwd and the '.' as target
+      basePrefix = normalizedSourcePath
+    } else {
+      // Normal case: extract the base prefix by removing archiveBasePath from the end
+      basePrefix = normalizedSourcePath.slice(0, normalizedSourcePath.length - normalizedArchiveBasePath.length)
+    }
+
+    const tarStream = tar.create(
+      {
+        cwd: basePrefix,
+        portable: true,
+        gzip: false,
+      },
+      [normalizedArchiveBasePath],
+    )
+
+    const pass = new PassThrough()
+    tarStream.pipe(pass)
+
+    const uploader = new Upload({
+      client: this.s3Client,
+      params: {
+        Bucket: this.bucketName,
+        Key: s3Key,
+        Body: pass,
+      },
+    })
+
+    await uploader.done()
+  }
+
+  private extractAwsRegion(endpoint: string): string | undefined {
+    const match = endpoint.match(/s3[.-]([a-z0-9-]+)\.amazonaws\.com/)
+    return match?.[1]
+  }
+}