@veris-ai/daytona-opencode 0.1.0

package/.opencode/plugin/daytona/core/session-manager.ts

@@ -0,0 +1,471 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Manages Daytona sandbox sessions and persists session-sandbox mappings
+ * Stores data per-project in ~/.local/share/opencode/storage/daytona/{projectId}.json
+ */
+
+// The Veris fork's entire diff to this file is the module named below.
+//
+// @veris-ai/daytona re-exports all of @daytona/sdk and overrides only
+// `Daytona`, so every `new Daytona({ apiKey })` in this file now returns a
+// client whose create() also registers the Veris snapshot, provisions a twin,
+// sets the domain allowlist, and waits for veris-proxy to bind — and whose
+// get() rehydrates that surface on reconnect. The sandboxes handed back carry
+// `.veris` for receipts, and their delete() removes the twin as well.
+//
+// DaytonaNotFoundError and DaytonaValidationError below are the SAME class
+// objects @daytona/sdk exports (it is a peer dependency of @veris-ai/daytona),
+// so the `instanceof` checks further down keep working — including against
+// errors raised in tools/bash.ts, which still imports from '@daytona/sdk'.
+import {
+  Daytona,
+  DaytonaNotFoundError,
+  DaytonaValidationError,
+  type CreateSandboxFromSnapshotParams,
+  type Sandbox,
+} from '@veris-ai/daytona'
+import { logger } from './logger'
+import type { SessionSandboxMap, SandboxInfo, SessionInfo } from './types'
+import { SessionGitManager } from '../git/session-git-manager'
+import { DaytonaSandboxGitManager } from '../git/sandbox-git-manager'
+import { ProjectDataStorage } from './project-data-storage'
+import type { PluginInput } from '@opencode-ai/plugin'
+import { toast } from './toast'
+
+export class DaytonaSessionManager {
+  private readonly apiKey: string
+  private readonly dataStorage: ProjectDataStorage
+  private sessionSandboxes: SessionSandboxMap
+  // Sessions whose sandbox teardown has begun. getSandbox creates sandboxes on demand,
+  // so without this tombstone a sync queued behind a deletion would resurrect a fresh
+  // sandbox for a session that no longer exists (invisible, billed, never cleaned up).
+  private readonly deletingSessions = new Set<string>()
+  private readonly deletionPromises = new Map<string, Promise<boolean>>()
+  private currentProjectId?: string
+  public readonly repoPath: string
+  /** Snapshot new sandboxes are created from; undefined uses Daytona's default snapshot. */
+  public readonly snapshot?: string
+
+  constructor(apiKey: string, storageDir: string, repoPath: string, snapshot?: string) {
+    this.apiKey = apiKey
+    this.dataStorage = new ProjectDataStorage(storageDir)
+    this.repoPath = repoPath
+    this.snapshot = snapshot?.trim() || undefined
+    this.sessionSandboxes = new Map()
+  }
+
+  /**
+   * Check if a sandbox is fully initialized (has process property)
+   */
+  private isFullyInitialized(sandbox: Sandbox | SandboxInfo | undefined): sandbox is Sandbox {
+    return sandbox !== undefined && 'process' in sandbox
+  }
+
+  /**
+   * Check if a sandbox is partially initialized (has id but not process)
+   */
+  private isPartiallyInitialized(sandbox: Sandbox | SandboxInfo | undefined): sandbox is SandboxInfo {
+    return sandbox !== undefined && 'id' in sandbox && !('process' in sandbox)
+  }
+
+  /**
+   * Load sessions for a specific project into memory
+   */
+  private loadProjectSessions(projectId: string): void {
+    const projectData = this.dataStorage.load(projectId)
+    if (projectData) {
+      for (const [sessionId, sessionInfo] of Object.entries(projectData.sessions)) {
+        this.sessionSandboxes.set(sessionId, { id: sessionInfo.sandboxId })
+      }
+      logger.info(`Loaded ${Object.keys(projectData.sessions).length} sessions for project ${projectId}`)
+    }
+  }
+
+  /**
+   * Set the current project context
+   */
+  setProjectContext(projectId: string): void {
+    if (this.currentProjectId !== projectId) {
+      this.currentProjectId = projectId
+      this.sessionSandboxes.clear()
+      this.loadProjectSessions(projectId)
+    }
+  }
+
+  /**
+   * Get branch number for a sandbox
+   */
+  getBranchNumberForSandbox(projectId: string, sandboxId: string): number | undefined {
+    return this.dataStorage.getBranchNumberForSandbox(projectId, sandboxId)
+  }
+
+  /**
+   * Get or create a sandbox for the given session ID
+   */
+  async getSandbox(sessionId: string, projectId: string, worktree: string, pluginCtx?: PluginInput): Promise<Sandbox> {
+    if (pluginCtx?.client?.tui) {
+      toast.initialize(pluginCtx.client.tui)
+    }
+    if (this.deletingSessions.has(sessionId)) {
+      throw new Error(`Session ${sessionId} is deleted; not creating a new sandbox for it.`)
+    }
+    if (!this.apiKey) {
+      logger.error('DAYTONA_API_KEY is not set. Cannot create or retrieve sandbox.')
+      toast.show({
+        title: 'Sandbox error',
+        message: 'DAYTONA_API_KEY is not set. Please set the environment variable to use Daytona sandboxes.',
+        variant: 'error',
+      })
+      throw new Error('DAYTONA_API_KEY is not set. Please set the environment variable to use Daytona sandboxes.')
+    }
+    // Veris coordinates get the same treatment as the Daytona key, and for the
+    // same reason: this is the first tool call of a session, and a legible
+    // message here is the difference between "set one env var" and a stack
+    // trace out of sandbox creation.
+    //
+    // Deliberately fatal rather than degrading to a plain Daytona sandbox. A
+    // sandbox without a twin reaches the REAL vendor, and an agent cannot tell
+    // the difference — so an unset key has to stop the session, not quietly
+    // change what it is doing.
+    for (const [name, hint] of [
+      ['VERIS_API_KEY', 'Get one at https://studio.veris.ai'],
+      ['VERIS_ENVIRONMENT_ID', 'A Veris environment decides which vendor services your twin gets'],
+    ] as const) {
+      if (process.env[name]) continue
+      const message = `${name} is not set, so this sandbox would reach real vendor APIs. ${hint}.`
+      logger.error(message)
+      toast.show({ title: 'Veris not configured', message, variant: 'error' })
+      throw new Error(message)
+    }
+
+    // Load project sessions if needed
+    this.setProjectContext(projectId)
+
+    const existing = this.sessionSandboxes.get(sessionId)
+
+    // If we have a fully initialized sandbox, reuse it
+    if (this.isFullyInitialized(existing)) {
+      // Refresh sandbox state and ensure it's running
+      await existing.refreshData()
+      if (existing.state !== 'started') {
+        logger.info(`Starting sandbox ${existing.id} (current state: ${existing.state})`)
+        await existing.start()
+      }
+      this.ensureNotDeleted(sessionId)
+      this.dataStorage.updateSession(projectId, worktree, sessionId, existing.id)
+      return existing
+    }
+
+    // If we have a sandboxId but not a full sandbox object, reconnect to it
+    if (this.isPartiallyInitialized(existing)) {
+      try {
+        logger.info(`Reconnecting to existing sandbox: ${existing.id}`)
+        const daytona = new Daytona({ apiKey: this.apiKey })
+        const reconnectStart = Date.now()
+        logger.info(`Daytona get begin sandboxId=${existing.id}`)
+        const sandbox = await daytona.get(existing.id)
+        logger.info(`Daytona get done sandboxId=${existing.id} in ${Date.now() - reconnectStart}ms`)
+        logger.info(`Starting sandbox begin sandboxId=${sandbox.id}`)
+        await sandbox.start()
+        logger.info(`Starting sandbox done sandboxId=${sandbox.id} in ${Date.now() - reconnectStart}ms`)
+        this.ensureNotDeleted(sessionId)
+        this.sessionSandboxes.set(sessionId, sandbox)
+        // Preserve branch number if it exists for this sandbox
+        let branchNumber = this.dataStorage.getBranchNumberForSandbox(projectId, sandbox.id)
+        if (!branchNumber) {
+          try {
+            branchNumber = SessionGitManager.allocateAndReserveBranchNumber(worktree)
+          } catch {
+            // No local git repo (or git unavailable) shouldn't block sandbox usage.
+            branchNumber = undefined
+          }
+        }
+        this.dataStorage.updateSession(projectId, worktree, sessionId, sandbox.id, branchNumber)
+        toast.show({
+          title: 'Sandbox connected',
+          message: `Connected to existing sandbox.`,
+          variant: 'info',
+        })
+
+        // Even if git syncing is disabled, ensure the project directory exists in the sandbox.
+        if (!branchNumber) {
+          try {
+            await new DaytonaSandboxGitManager(sandbox, this.repoPath).ensureDirectory()
+          } catch (err) {
+            logger.warn(`Failed to ensure sandbox project directory exists: ${err}`)
+          }
+        }
+
+        return sandbox
+      } catch (err) {
+        // Only treat 404 as "sandbox is confirmed gone" — clear the mapping and fall through
+        // to create a replacement. For transient errors (network, auth, timeout, provisioning),
+        // preserve the mapping and propagate so the caller can retry later without losing the
+        // session→sandbox binding and its branchNumber.
+        if (err instanceof DaytonaNotFoundError) {
+          logger.error(`Sandbox ${existing.id} no longer exists; creating a replacement.`)
+          this.sessionSandboxes.delete(sessionId)
+          this.dataStorage.removeSession(projectId, worktree, sessionId)
+        } else {
+          logger.error(`Failed to reconnect to sandbox ${existing.id}: ${err}`)
+          throw err
+        }
+      }
+    }
+
+    // If not in cache/storage for this project, try to recover from other projects and migrate.
+    if (!existing) {
+      const migrated = this.dataStorage.getSession(projectId, worktree, sessionId)
+      if (migrated?.sandboxId) {
+        logger.info(`Recovered session ${sessionId} for project ${projectId} (migrated from another project)`)
+        this.sessionSandboxes.set(sessionId, { id: migrated.sandboxId })
+        // Re-run getSandbox to go through the normal reconnect path.
+        return this.getSandbox(sessionId, projectId, worktree, pluginCtx)
+      }
+    }
+
+    // Otherwise, create a new sandbox
+    logger.info(`Creating new sandbox for session: ${sessionId} in project: ${projectId}`)
+    const daytona = new Daytona({ apiKey: this.apiKey })
+    // Omit the key entirely when unset so Daytona applies its default snapshot.
+    const createParams: CreateSandboxFromSnapshotParams = this.snapshot ? { snapshot: this.snapshot } : {}
+    const createStart = Date.now()
+    logger.info(`Daytona create begin sessionId=${sessionId} snapshot=${this.snapshot ?? '(default)'}`)
+    const waitingLog = setTimeout(() => {
+      logger.warn(`Daytona create still waiting after ${Date.now() - createStart}ms (sessionId=${sessionId})`)
+    }, 15_000)
+    const sandbox = await daytona
+      .create(createParams)
+      .catch((err: unknown) => {
+        // Only blame the snapshot when the request itself was rejected. The create
+        // params contain nothing but the snapshot name, so a validation error means
+        // Daytona refused that name (empirically: "Snapshot <name> not found" is a
+        // DaytonaValidationError). Auth, network, quota, and timeout failures are
+        // unrelated to DAYTONA_SNAPSHOT and propagate unattributed, as before.
+        if (this.snapshot && err instanceof DaytonaValidationError) {
+          logger.error(`Failed to create sandbox from snapshot '${this.snapshot}': ${err}`)
+          toast.show({
+            title: 'Sandbox error',
+            message: `Verify DAYTONA_SNAPSHOT names an available snapshot: ${err.message}`,
+            variant: 'error',
+          })
+        }
+        throw err
+      })
+      .finally(() => clearTimeout(waitingLog))
+    logger.info(`Daytona create done sessionId=${sessionId} sandboxId=${sandbox.id} in ${Date.now() - createStart}ms`)
+    if (this.deletingSessions.has(sessionId)) {
+      // The session was deleted while creation was in flight. The fresh sandbox is not
+      // registered anywhere, so nothing else will ever clean it up - discard it here.
+      logger.warn(`Session ${sessionId} was deleted during sandbox creation; discarding sandbox ${sandbox.id}`)
+      try {
+        await sandbox.delete()
+      } catch (err) {
+        logger.error(`Failed to discard sandbox ${sandbox.id} for deleted session ${sessionId}: ${err}`)
+        throw new Error(
+          `Session ${sessionId} is deleted and discarding newly created sandbox ${sandbox.id} failed; if it still exists, delete it from the Daytona dashboard.`,
+        )
+      }
+      throw new Error(`Session ${sessionId} is deleted; the newly created sandbox was discarded.`)
+    }
+    this.sessionSandboxes.set(sessionId, sandbox)
+
+    // Get or assign branch number for this sandbox
+    let branchNumber = this.dataStorage.getBranchNumberForSandbox(projectId, sandbox.id)
+
+    if (!branchNumber) {
+      try {
+        branchNumber = SessionGitManager.allocateAndReserveBranchNumber(worktree)
+      } catch (err: any) {
+        logger.warn(`allocateAndReserveBranchNumber failed sessionId=${sessionId}: ${err}`)
+        // No local git repo (or git unavailable) shouldn't block sandbox usage.
+        branchNumber = undefined
+      }
+    }
+
+    this.dataStorage.updateSession(projectId, worktree, sessionId, sandbox.id, branchNumber)
+    logger.info(
+      `Sandbox created successfully: ${sandbox.id}${branchNumber ? ` with branch number ${branchNumber}` : ''}`,
+    )
+
+    // Initialize git repo in the sandbox and sync with host
+    try {
+      if (branchNumber) {
+        const sessionGit = new SessionGitManager(sandbox, this.repoPath, worktree, branchNumber)
+        await sessionGit.initializeAndSync(pluginCtx)
+      } else {
+        // Git disabled; still ensure the directory exists so tools can operate.
+        await new DaytonaSandboxGitManager(sandbox, this.repoPath).ensureDirectory()
+      }
+    } catch (err: any) {
+      logger.error(`Failed to initialize git repo or push local changes in sandbox: ${err}`)
+      toast.show({
+        title: 'Git error',
+        message: err?.message || 'Failed to initialize git repo in sandbox.',
+        variant: 'error',
+      })
+    }
+    // Deletion may have raced the initialization awaits above; the mapping was already
+    // registered, so the delete flow owns (and removes) the sandbox itself - returning
+    // it would hand callers a destroyed sandbox that fails confusingly on first use.
+    this.ensureNotDeleted(sessionId)
+    toast.show({
+      title: 'Sandbox created',
+      message: `Created new sandbox for session.`,
+      variant: 'success',
+    })
+    return sandbox
+  }
+
+  /**
+   * Delete the sandbox associated with the given session ID
+   */
+  async deleteSandbox(sessionId: string, projectId: string): Promise<boolean> {
+    // Concurrent deletes share one promise: a second teardown racing the first would
+    // observe the already-deleted sandbox, throw, and wrongly clear the tombstone.
+    const inFlight = this.deletionPromises.get(sessionId)
+    if (inFlight) return inFlight
+
+    // Tombstone first, removed again on failure: while set, no code path may create or
+    // reconnect a sandbox for this session. Kept after success on purpose - the session
+    // is gone, and any late event for it must no-op instead of resurrecting a sandbox.
+    this.deletingSessions.add(sessionId)
+    const run = (async () => {
+      try {
+        return await this.deleteSandboxInner(sessionId, projectId)
+      } catch (err) {
+        this.deletingSessions.delete(sessionId)
+        throw err
+      } finally {
+        this.deletionPromises.delete(sessionId)
+      }
+    })()
+    this.deletionPromises.set(sessionId, run)
+    return run
+  }
+
+  private async deleteSandboxInner(sessionId: string, projectId: string): Promise<boolean> {
+    await SessionGitManager.waitForPendingSync(sessionId)
+
+    let sandbox = this.sessionSandboxes.get(sessionId)
+
+    // Read-only lookup so deleting never migrates sessions or rewrites project metadata.
+    const stored = this.dataStorage.findSession(sessionId)
+
+    let sandboxGone = false
+
+    // If not in cache, try to load from storage and reconnect
+    if (!sandbox || this.isPartiallyInitialized(sandbox)) {
+      if (stored?.session.sandboxId) {
+        const daytona = new Daytona({ apiKey: this.apiKey })
+        try {
+          sandbox = await daytona.get(stored.session.sandboxId)
+          this.sessionSandboxes.set(sessionId, sandbox)
+        } catch (err) {
+          if (err instanceof DaytonaNotFoundError) {
+            sandboxGone = true
+            logger.warn(`Sandbox ${stored.session.sandboxId} no longer exists; clearing stale mapping.`)
+          } else {
+            // Non-404: we cannot confirm the sandbox is gone. Surface the error so the
+            // event handler shows a "Delete failed" toast instead of silently reporting
+            // success while leaving a running sandbox on the Daytona account.
+            logger.error(`Failed to reconnect to sandbox ${stored.session.sandboxId}: ${err}`)
+            throw err
+          }
+        }
+      } else {
+        sandboxGone = true
+      }
+    }
+
+    // Delete the sandbox if we have a fully initialized one
+    let deleted = false
+    if (this.isFullyInitialized(sandbox)) {
+      // Final sync and deletion run as ONE queue entry, so a sync enqueued between the
+      // wait above and this point is drained first, and nothing can slot in between
+      // pulling the last changes and destroying the sandbox.
+      const target = sandbox
+      await SessionGitManager.enqueueSessionSync(sessionId, async () => {
+        await this.syncBeforeDelete(target, stored)
+        logger.info(`Removing sandbox for session: ${sessionId}`)
+        await target.delete()
+      })
+      deleted = true
+      sandboxGone = true
+      logger.info(`Sandbox deleted successfully.`)
+    } else {
+      logger.warn(`No sandbox found for session: ${sessionId}`)
+    }
+
+    // Clear the local mapping when the sandbox is gone (deleted or already absent) so a
+    // stale entry can't cause repeated reconnect failures. Preserve it on transient errors.
+    if (sandboxGone) {
+      this.sessionSandboxes.delete(sessionId)
+      const cleanupProjectId = stored?.projectId ?? projectId
+      const cleanupWorktree = stored?.worktree ?? this.dataStorage.load(projectId)?.worktree ?? ''
+      this.dataStorage.removeSession(cleanupProjectId, cleanupWorktree, sessionId)
+    }
+
+    return deleted
+  }
+
+  /**
+   * Pull not-yet-synced sandbox changes into the local repo before the sandbox is
+   * destroyed. Throws — aborting deletion so the sandbox is preserved — when unsynced
+   * changes cannot be pulled, including when the local repository itself is no longer
+   * accessible (a silent skip there would destroy the only copy of the work). A sandbox
+   * that is not running is deleted without being started: anything in it was either
+   * synced while it ran or is abandoned by the explicit delete.
+   *
+   * Runs inside the session's sync queue; it must NOT enqueue (that would deadlock).
+   */
+  private async syncBeforeDelete(sandbox: Sandbox, stored: { worktree: string; session: SessionInfo } | undefined) {
+    const branchNumber = stored?.session.branchNumber
+    if (!branchNumber || !stored?.worktree) return
+    await sandbox.refreshData()
+    if (sandbox.state !== 'started') return
+    const sessionGit = new SessionGitManager(sandbox, this.repoPath, stored.worktree, branchNumber)
+    if (!sessionGit.hasLocalRepo()) {
+      throw new Error(
+        `Local repository at ${stored.worktree} is not accessible, so unsynced sandbox changes cannot be pulled; the sandbox was not deleted. Restore the repository or delete the sandbox from the Daytona dashboard.`,
+      )
+    }
+    try {
+      await sessionGit.autoCommitAndPull()
+    } catch (err: any) {
+      throw new Error(
+        `Sandbox has changes that could not be synced to the local repository; the sandbox was not deleted. ${err?.message ?? err}`,
+      )
+    }
+  }
+
+  /**
+   * Read-only check for a session→sandbox mapping (memory or storage); never creates,
+   * migrates, or connects.
+   */
+  hasSandbox(sessionId: string, projectId: string): boolean {
+    if (this.deletingSessions.has(sessionId)) return false
+    this.setProjectContext(projectId)
+    if (this.sessionSandboxes.has(sessionId)) return true
+    return this.dataStorage.findSession(sessionId) !== undefined
+  }
+
+  isSessionDeleting(sessionId: string): boolean {
+    return this.deletingSessions.has(sessionId)
+  }
+
+  /**
+   * Guard for registration points that follow an await: deletion may have started (and
+   * finished) while a sandbox was being refreshed or reconnected, and persisting the
+   * mapping afterwards would resurrect state for a session that no longer exists.
+   */
+  private ensureNotDeleted(sessionId: string): void {
+    if (this.deletingSessions.has(sessionId)) {
+      throw new Error(`Session ${sessionId} was deleted while its sandbox was being prepared.`)
+    }
+  }
+}

package/.opencode/plugin/daytona/core/toast.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Global toast notification singleton
+ * Queues toasts to prevent showing multiple at the same time
+ */
+type ToastVariant = 'success' | 'error' | 'warning' | 'info';
+interface ToastOptions {
+    title: string;
+    message: string;
+    variant?: ToastVariant;
+}
+interface TuiShowToast {
+    showToast: (options: {
+        body: {
+            title: string;
+            message: string;
+            variant: ToastVariant;
+        };
+    }) => void;
+}
+declare class ToastManager {
+    private tui;
+    private queue;
+    private isShowing;
+    /**
+     * Initialize the toast manager with the TUI instance
+     */
+    initialize(tui: TuiShowToast | null | undefined): void;
+    /**
+     * Show a toast notification
+     * If a toast is currently showing, this will be queued
+     */
+    show(options: ToastOptions): void;
+    /**
+     * Process the toast queue, showing one toast at a time
+     */
+    private processQueue;
+    /**
+     * Clear all pending toasts
+     */
+    clear(): void;
+}
+export declare const toast: ToastManager;
+export {};

package/.opencode/plugin/daytona/core/toast.js

@@ -0,0 +1,70 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ToastManager {
+    tui = null;
+    queue = [];
+    isShowing = false;
+    /**
+     * Initialize the toast manager with the TUI instance
+     */
+    initialize(tui) {
+        this.tui = tui || null;
+    }
+    /**
+     * Show a toast notification
+     * If a toast is currently showing, this will be queued
+     */
+    show(options) {
+        const toast = {
+            variant: 'info',
+            ...options,
+        };
+        this.queue.push(toast);
+        this.processQueue();
+    }
+    /**
+     * Process the toast queue, showing one toast at a time
+     */
+    processQueue() {
+        if (this.isShowing || this.queue.length === 0) {
+            return;
+        }
+        if (!this.tui) {
+            // If TUI is not available, clear the queue
+            this.queue = [];
+            return;
+        }
+        this.isShowing = true;
+        const toast = this.queue.shift();
+        try {
+            this.tui.showToast({
+                body: {
+                    title: toast.title,
+                    message: toast.message,
+                    variant: toast.variant || 'info',
+                },
+            });
+        }
+        catch (err) {
+            // If showing fails, continue with next toast
+            console.error('Failed to show toast:', err);
+        }
+        // Wait a bit before showing the next toast to avoid overlap
+        // Most toasts are visible for 2-3 seconds, so we wait 2.5 seconds
+        setTimeout(() => {
+            this.isShowing = false;
+            this.processQueue();
+        }, 2500);
+    }
+    /**
+     * Clear all pending toasts
+     */
+    clear() {
+        this.queue = [];
+    }
+}
+// Export singleton instance
+export const toast = new ToastManager();
+//# sourceMappingURL=toast.js.map

package/.opencode/plugin/daytona/core/toast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast.js","sourceRoot":"","sources":["toast.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAmBH,MAAM,YAAY;IACR,GAAG,GAAwB,IAAI,CAAA;IAC/B,KAAK,GAAmB,EAAE,CAAA;IAC1B,SAAS,GAAG,KAAK,CAAA;IAEzB;;OAEG;IACH,UAAU,CAAC,GAAoC;QAC7C,IAAI,CAAC,GAAG,GAAG,GAAG,IAAI,IAAI,CAAA;IACxB,CAAC;IAED;;;OAGG;IACH,IAAI,CAAC,OAAqB;QACxB,MAAM,KAAK,GAAiB;YAC1B,OAAO,EAAE,MAAM;YACf,GAAG,OAAO;SACX,CAAA;QAED,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACtB,IAAI,CAAC,YAAY,EAAE,CAAA;IACrB,CAAC;IAED;;OAEG;IACK,YAAY;QAClB,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,OAAM;QACR,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,2CAA2C;YAC3C,IAAI,CAAC,KAAK,GAAG,EAAE,CAAA;YACf,OAAM;QACR,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAG,CAAA;QAEjC,IAAI,CAAC;YACH,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;gBACjB,IAAI,EAAE;oBACJ,KAAK,EAAE,KAAK,CAAC,KAAK;oBAClB,OAAO,EAAE,KAAK,CAAC,OAAO;oBACtB,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,MAAM;iBACjC;aACF,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,6CAA6C;YAC7C,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAA;QAC7C,CAAC;QAED,4DAA4D;QAC5D,kEAAkE;QAClE,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,SAAS,GAAG,KAAK,CAAA;YACtB,IAAI,CAAC,YAAY,EAAE,CAAA;QACrB,CAAC,EAAE,IAAI,CAAC,CAAA;IACV,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,KAAK,GAAG,EAAE,CAAA;IACjB,CAAC;CACF;AAED,4BAA4B;AAC5B,MAAM,CAAC,MAAM,KAAK,GAAG,IAAI,YAAY,EAAE,CAAA"}

package/.opencode/plugin/daytona/core/toast.ts

@@ -0,0 +1,96 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Global toast notification singleton
+ * Queues toasts to prevent showing multiple at the same time
+ */
+
+type ToastVariant = 'success' | 'error' | 'warning' | 'info'
+
+interface ToastOptions {
+  title: string
+  message: string
+  variant?: ToastVariant
+}
+
+interface TuiShowToast {
+  showToast: (options: { body: { title: string; message: string; variant: ToastVariant } }) => void
+}
+
+class ToastManager {
+  private tui: TuiShowToast | null = null
+  private queue: ToastOptions[] = []
+  private isShowing = false
+
+  /**
+   * Initialize the toast manager with the TUI instance
+   */
+  initialize(tui: TuiShowToast | null | undefined): void {
+    this.tui = tui || null
+  }
+
+  /**
+   * Show a toast notification
+   * If a toast is currently showing, this will be queued
+   */
+  show(options: ToastOptions): void {
+    const toast: ToastOptions = {
+      variant: 'info',
+      ...options,
+    }
+
+    this.queue.push(toast)
+    this.processQueue()
+  }
+
+  /**
+   * Process the toast queue, showing one toast at a time
+   */
+  private processQueue(): void {
+    if (this.isShowing || this.queue.length === 0) {
+      return
+    }
+
+    if (!this.tui) {
+      // If TUI is not available, clear the queue
+      this.queue = []
+      return
+    }
+
+    this.isShowing = true
+    const toast = this.queue.shift()!
+
+    try {
+      this.tui.showToast({
+        body: {
+          title: toast.title,
+          message: toast.message,
+          variant: toast.variant || 'info',
+        },
+      })
+    } catch (err) {
+      // If showing fails, continue with next toast
+      console.error('Failed to show toast:', err)
+    }
+
+    // Wait a bit before showing the next toast to avoid overlap
+    // Most toasts are visible for 2-3 seconds, so we wait 2.5 seconds
+    setTimeout(() => {
+      this.isShowing = false
+      this.processQueue()
+    }, 2500)
+  }
+
+  /**
+   * Clear all pending toasts
+   */
+  clear(): void {
+    this.queue = []
+  }
+}
+
+// Export singleton instance
+export const toast = new ToastManager()