@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/lsp.ts

@@ -0,0 +1,367 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface CompletionContext {
+  triggerCharacter?: string;
+  triggerKind: number;
+}
+export const CompletionContext = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    triggerCharacter: S.optional(S.String),
+    triggerKind: S.Number,
+  }),
+).annotate({
+  identifier: "CompletionContext",
+}) as any as S.Schema<CompletionContext>;
+
+export interface LspPosition {
+  character: number;
+  line: number;
+}
+export const LspPosition = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    character: S.Number,
+    line: S.Number,
+  }),
+).annotate({ identifier: "LspPosition" }) as any as S.Schema<LspPosition>;
+
+export interface CompletionsRequest {
+  context?: CompletionContext;
+  languageId: string;
+  pathToProject: string;
+  position: LspPosition;
+  uri: string;
+}
+export const CompletionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    context: S.optional(CompletionContext),
+    languageId: S.String,
+    pathToProject: S.String,
+    position: LspPosition,
+    uri: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/lsp/completions", code: 200 })),
+).annotate({
+  identifier: "CompletionsRequest",
+}) as any as S.Schema<CompletionsRequest>;
+
+export interface CompletionItem {
+  detail?: string;
+  documentation?: unknown;
+  filterText?: string;
+  insertText?: string;
+  kind?: number;
+  label: string;
+  sortText?: string;
+}
+export const CompletionItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    detail: S.optional(S.String),
+    documentation: S.optional(S.Unknown),
+    filterText: S.optional(S.String),
+    insertText: S.optional(S.String),
+    kind: S.optional(S.Number),
+    label: S.String,
+    sortText: S.optional(S.String),
+  }),
+).annotate({ identifier: "CompletionItem" }) as any as S.Schema<CompletionItem>;
+
+export type CompletionListItemsList = Array<CompletionItem>;
+export const CompletionListItemsList = /*@__PURE__*/ S.Array(
+  CompletionItem,
+) as any as S.Schema<CompletionListItemsList>;
+
+export interface CompletionList {
+  isIncomplete: boolean;
+  items: CompletionListItemsList;
+}
+export const CompletionList = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    isIncomplete: S.Boolean,
+    items: CompletionListItemsList,
+  }),
+).annotate({ identifier: "CompletionList" }) as any as S.Schema<CompletionList>;
+
+export interface DidCloseRequest {
+  languageId: string;
+  pathToProject: string;
+  uri: string;
+}
+export const DidCloseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    languageId: S.String,
+    pathToProject: S.String,
+    uri: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/lsp/did-close", code: 200 })),
+).annotate({
+  identifier: "DidCloseRequest",
+}) as any as S.Schema<DidCloseRequest>;
+
+export interface DidCloseResponse {}
+export const DidCloseResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DidCloseResponse",
+}) as any as S.Schema<DidCloseResponse>;
+
+export interface DidOpenRequest {
+  languageId: string;
+  pathToProject: string;
+  uri: string;
+}
+export const DidOpenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    languageId: S.String,
+    pathToProject: S.String,
+    uri: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/lsp/did-open", code: 200 })),
+).annotate({ identifier: "DidOpenRequest" }) as any as S.Schema<DidOpenRequest>;
+
+export interface DidOpenResponse {}
+export const DidOpenResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DidOpenResponse",
+}) as any as S.Schema<DidOpenResponse>;
+
+export interface DocumentSymbolsRequest {
+  /** Language ID (e.g., python, typescript) */
+  languageId: string;
+  /** Path to project */
+  pathToProject: string;
+  /** Document URI */
+  uri: string;
+}
+export const DocumentSymbolsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    languageId: S.String.pipe(T.Query()),
+    pathToProject: S.String.pipe(T.Query()),
+    uri: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/lsp/document-symbols", code: 200 })),
+).annotate({
+  identifier: "DocumentSymbolsRequest",
+}) as any as S.Schema<DocumentSymbolsRequest>;
+
+export interface LspRange {
+  end: LspPosition;
+  start: LspPosition;
+}
+export const LspRange = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    end: LspPosition,
+    start: LspPosition,
+  }),
+).annotate({ identifier: "LspRange" }) as any as S.Schema<LspRange>;
+
+export interface LspLocation {
+  range: LspRange;
+  uri: string;
+}
+export const LspLocation = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    range: LspRange,
+    uri: S.String,
+  }),
+).annotate({ identifier: "LspLocation" }) as any as S.Schema<LspLocation>;
+
+export interface LspSymbol {
+  kind: number;
+  location: LspLocation;
+  name: string;
+}
+export const LspSymbol = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kind: S.Number,
+    location: LspLocation,
+    name: S.String,
+  }),
+).annotate({ identifier: "LspSymbol" }) as any as S.Schema<LspSymbol>;
+
+export type DocumentSymbolsResponseBodyList = Array<LspSymbol>;
+export const DocumentSymbolsResponseBodyList = /*@__PURE__*/ S.Array(
+  LspSymbol,
+) as any as S.Schema<DocumentSymbolsResponseBodyList>;
+
+export type DocumentSymbolsResponse = DocumentSymbolsResponseBodyList;
+export const DocumentSymbolsResponse = /*@__PURE__*/ S.suspend(() =>
+  DocumentSymbolsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DocumentSymbolsResponse",
+}) as any as S.Schema<DocumentSymbolsResponse>;
+
+export interface StartRequest {
+  languageId: string;
+  pathToProject: string;
+}
+export const StartRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    languageId: S.String,
+    pathToProject: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/lsp/start", code: 200 })),
+).annotate({ identifier: "StartRequest" }) as any as S.Schema<StartRequest>;
+
+export interface StartResponse {}
+export const StartResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({ identifier: "StartResponse" }) as any as S.Schema<StartResponse>;
+
+export interface StopRequest {
+  languageId: string;
+  pathToProject: string;
+}
+export const StopRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    languageId: S.String,
+    pathToProject: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/lsp/stop", code: 200 })),
+).annotate({ identifier: "StopRequest" }) as any as S.Schema<StopRequest>;
+
+export interface StopResponse {}
+export const StopResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({ identifier: "StopResponse" }) as any as S.Schema<StopResponse>;
+
+export interface WorkspaceSymbolsRequest {
+  /** Search query */
+  query: string;
+  /** Language ID (e.g., python, typescript) */
+  languageId: string;
+  /** Path to project */
+  pathToProject: string;
+}
+export const WorkspaceSymbolsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    query: S.String.pipe(T.Query()),
+    languageId: S.String.pipe(T.Query()),
+    pathToProject: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/lsp/workspacesymbols", code: 200 })),
+).annotate({
+  identifier: "WorkspaceSymbolsRequest",
+}) as any as S.Schema<WorkspaceSymbolsRequest>;
+
+export type WorkspaceSymbolsResponseBodyList = Array<LspSymbol>;
+export const WorkspaceSymbolsResponseBodyList = /*@__PURE__*/ S.Array(
+  LspSymbol,
+) as any as S.Schema<WorkspaceSymbolsResponseBodyList>;
+
+export type WorkspaceSymbolsResponse = WorkspaceSymbolsResponseBodyList;
+export const WorkspaceSymbolsResponse = /*@__PURE__*/ S.suspend(() =>
+  WorkspaceSymbolsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "WorkspaceSymbolsResponse",
+}) as any as S.Schema<WorkspaceSymbolsResponse>;
+
+export type CompletionsError = DaytonaOpError;
+/** Get code completions Get code completion suggestions from the LSP server */
+export const completions: API.OperationMethod<
+  CompletionsRequest,
+  CompletionList,
+  CompletionsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CompletionsRequest,
+  output: CompletionList,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DidCloseError = DaytonaOpError;
+/** Notify document closed Notify the LSP server that a document has been closed */
+export const didClose: API.OperationMethod<
+  DidCloseRequest,
+  DidCloseResponse,
+  DidCloseError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DidCloseRequest,
+  output: DidCloseResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DidOpenError = DaytonaOpError;
+/** Notify document opened Notify the LSP server that a document has been opened */
+export const didOpen: API.OperationMethod<
+  DidOpenRequest,
+  DidOpenResponse,
+  DidOpenError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DidOpenRequest,
+  output: DidOpenResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DocumentSymbolsError = DaytonaOpError;
+/** Get document symbols Get symbols (functions, classes, etc.) from a document */
+export const documentSymbols: API.OperationMethod<
+  DocumentSymbolsRequest,
+  DocumentSymbolsResponse,
+  DocumentSymbolsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DocumentSymbolsRequest,
+  output: DocumentSymbolsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StartError = DaytonaOpError;
+/** Start LSP server Start a Language Server Protocol server for the specified language */
+export const start: API.OperationMethod<
+  StartRequest,
+  StartResponse,
+  StartError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StartRequest,
+  output: StartResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StopError = DaytonaOpError;
+/** Stop LSP server Stop a Language Server Protocol server */
+export const stop: API.OperationMethod<
+  StopRequest,
+  StopResponse,
+  StopError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StopRequest,
+  output: StopResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type WorkspaceSymbolsError = DaytonaOpError;
+/** Get workspace symbols Search for symbols across the entire workspace */
+export const workspaceSymbols: API.OperationMethod<
+  WorkspaceSymbolsRequest,
+  WorkspaceSymbolsResponse,
+  WorkspaceSymbolsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: WorkspaceSymbolsRequest,
+  output: WorkspaceSymbolsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/object_storage.ts

@@ -0,0 +1,75 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetPushAccessRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetPushAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/object-storage/push-access", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetPushAccessRequest",
+}) as any as S.Schema<GetPushAccessRequest>;
+
+export interface StorageAccessDto {
+  /** Access key for storage authentication */
+  accessKey: string;
+  /** Secret key for storage authentication */
+  secret: string | Redacted.Redacted<string>;
+  /** Session token for storage authentication */
+  sessionToken: string | Redacted.Redacted<string>;
+  /** Storage URL */
+  storageUrl: string;
+  /** Organization ID */
+  organizationId: string;
+  /** S3 bucket name */
+  bucket: string;
+  /** Region for the storage backend (e.g. "us-east-2") */
+  region: string;
+}
+export const StorageAccessDto = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    accessKey: S.String,
+    secret: S.String.pipe(T.SensitiveValue({})),
+    sessionToken: S.String.pipe(T.SensitiveValue({})),
+    storageUrl: S.String,
+    organizationId: S.String,
+    bucket: S.String,
+    region: S.String,
+  }),
+).annotate({
+  identifier: "StorageAccessDto",
+}) as any as S.Schema<StorageAccessDto>;
+
+export type GetPushAccessError = DaytonaOpError;
+/** Get temporary storage access for pushing objects */
+export const getPushAccess: API.OperationMethod<
+  GetPushAccessRequest,
+  StorageAccessDto,
+  GetPushAccessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetPushAccessRequest,
+  output: StorageAccessDto,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));