@veris-ai/daytona 0.3.0 → 0.4.0

package/dist/provision.d.ts

@@ -1,100 +0,0 @@
-export interface ProvisionOptions {
-    /** The twin to attach to. Required: a provisioned box is only useful pointed
-     *  at a twin the caller already made. */
-    sandbox: string;
-    /** Daytona image or snapshot to create the sandbox from. Unset: Daytona's default. */
-    image?: string;
-    snapshot?: string;
-    /** KEY=VALUE pairs set as sandbox environment variables. */
-    env: Record<string, string>;
-}
-/**
- * Idle minutes before Daytona stops the sandbox.
- *
- * Nothing deletes a provisioned box for the caller, so these two intervals are
- * the only thing standing between an abandoned box and a bill. Daytona's own
- * default is 15 minutes of no API activity; 30 is deliberately more generous,
- * because a caller here is installing dependencies and running a suite between
- * our calls and a box stopped underneath them is worse than half an hour of
- * idle compute.
- */
-export declare const AUTO_STOP_MINUTES = 30;
-/**
- * Minutes after the sandbox stops before Daytona deletes it.
- *
- * Daytona disables auto-delete by default, so a stopped box keeps its disk (and
- * its cost) forever. An hour is long enough to come back and look at a box that
- * stopped while you were at lunch, short enough that forgetting one is cheap.
- */
-export declare const AUTO_DELETE_MINUTES = 60;
-/**
- * Wall-clock life of a provisioned sandbox, in minutes.
- *
- * The hard backstop under the two intervals above: it destroys the box whatever
- * state it is in. Four hours fits a long install and a long suite with room to
- * spare, and bounds a box that was never torn down. It does NOT move the twin's
- * TTL — provision always attaches, and the twin's life was decided when whoever
- * created it said so.
- */
-export declare const PROVISION_TTL_MINUTES = 240;
-/** What `provision` prints on stdout. One object, nothing else there. */
-export interface ProvisionResult {
-    /** The Daytona sandbox id — what `veris-daytona teardown` takes. */
-    daytonaSandboxId: string;
-    /** The Veris twin's id. NOT the Daytona one; the receipt is read from this. */
-    verisSandboxId: string;
-    /** The Veris environment the twin belongs to. */
-    verisEnvironmentId: string;
-    /** Whether deleting the sandbox also deletes the twin. Always false here:
-     *  provision attaches to a twin the caller made, so the caller keeps it. */
-    ownsTwin: boolean;
-    /** An empty directory in the sandbox to put code in and run commands from. */
-    workDir: string;
-    /** The CA bundle inside the sandbox: the public roots plus the Veris CA. */
-    caBundlePath: string;
-    /** The CA trust variables. Export these on EVERY command — Daytona overwrites
-     *  the well-known ones inside the sandbox with its own CA file, which cannot
-     *  verify the gateway's certificates. */
-    trustEnv: Record<string, string>;
-    /** The same variables as one line of shell `export`s, to prefix a command
-     *  with when you have no env map to fill. */
-    trustPrelude: string;
-    /** Run this INSIDE the sandbox after installing dependencies, to append the
-     *  Veris CA to the CA bundles SDKs ship with them. */
-    patchBundledCasCommand: string;
-    /** How to get code into the box. Daytona's own CLI has no upload, copy or
-     *  sync command and its `ssh` takes no remote command, so a caller who does
-     *  not know this verb exists has no route in short of writing an SDK script. */
-    pushCommand: string;
-    /** How to run one command in the box with trustEnv already exported and its
-     *  output streaming. `daytona exec` can set no variables at all. */
-    execCommand: string;
-    /** The twin's service names — what `--require-service` would name. */
-    services: string[];
-    /** When Daytona destroys the sandbox regardless of state. */
-    expiresAt: string;
-    /** Idle minutes before Daytona stops the sandbox. */
-    autoStopMinutes: number;
-    /** Minutes after stopping before Daytona deletes it. */
-    autoDeleteMinutes: number;
-}
-export declare const PROVISION_USAGE = "usage: veris-daytona provision --sandbox <twin-id> [options]\n\nCreates a Daytona sandbox whose vendor API calls are answered by an existing\nVeris twin, and stops there: nothing is uploaded, nothing is run, nothing is\ndeleted. One JSON object is printed on stdout; progress goes to stderr.\n\n  --sandbox <twin-id>       the Veris twin to attach to (required)\n  --image <name>            Daytona image to run in (default: Daytona's default snapshot)\n  --snapshot <name>         Daytona snapshot to run in\n  --env KEY=VALUE           set as a sandbox environment variable (repeatable)\n\nneeds: DAYTONA_API_KEY, and a Veris key: VERIS_API_KEY, or the profile\n`veris login` saved in ~/.veris/twin.yaml (VERIS_PROFILE picks one; the\nenvironment variable wins when both exist). No VERIS_ENVIRONMENT_ID \u2014 the\nenvironment comes from the twin. A Daytona key without delete:sandboxes still\nprovisions, with a warning that teardown will be refused.\n\nthe JSON on stdout:\n  daytonaSandboxId        the Daytona sandbox id; `veris-daytona teardown` takes it\n  verisSandboxId          the Veris twin's id \u2014 NOT the Daytona one\n  verisEnvironmentId      the environment the twin belongs to\n  ownsTwin                false: the twin is yours, and teardown leaves it alone\n  workDir                 an empty directory to put code in and run commands from\n  caBundlePath            the CA bundle inside the sandbox (public roots + the Veris CA)\n  trustEnv                the CA variables, as a map \u2014 export them on EVERY command\n  trustPrelude            the same variables as one line of shell `export`s\n  patchBundledCasCommand  run it inside the sandbox after installing dependencies\n  pushCommand             how to get code in \u2014 the Daytona CLI cannot upload\n  execCommand             how to run one command in there, trustEnv already applied\n  services                the twin's service names\n  expiresAt               when Daytona destroys the sandbox whatever state it is in\n  autoStopMinutes         idle minutes before Daytona stops it\n  autoDeleteMinutes       minutes after stopping before Daytona deletes it\n\nGetting code in: the Daytona CLI has no upload, copy or sync command, its `ssh`\ntakes no remote command, and `--context` is a build context on `create` only \u2014\nso `veris-daytona push <daytonaSandboxId>` is the route. It tars the current\ndirectory into workDir. `veris-daytona exec <daytonaSandboxId> -- <command>`\nthen runs a command in there with trustEnv already exported and its output\nstreaming, neither of which `daytona exec` can do.\n\nData-plane variables (DATABASE_URL and the like) are already set inside the\nsandbox, so a command run in there inherits them.\n\nThe sandbox stops after 30 idle minutes, is deleted 60 minutes after\nit stops, and is destroyed at 240 minutes old whatever state it is in \u2014 nothing\nhere deletes it for you. The twin's own TTL is whatever created it.\n\nexit code: 0 when the sandbox is up and the canary answered; 2 otherwise.";
-/** Parse everything after `provision`. Pure; throws UsageError with a human message. */
-export declare function parseProvisionArgs(argv: readonly string[]): ProvisionOptions;
-/**
- * The JSON object, from the handful of facts only a live create() knows.
- *
- * Everything else in it is derived here rather than in cli.ts, so the shape a
- * caller parses is decided in one pure place and tested without an account.
- */
-export declare function provisionResult(facts: {
-    daytonaSandboxId: string;
-    verisSandboxId: string;
-    verisEnvironmentId: string;
-    workDir: string;
-    trustEnv: Record<string, string>;
-    services: string[];
-    expiresAt: string;
-}): ProvisionResult;
-/** The one line of stdout. Indented, because a human reads this too. */
-export declare function provisionJson(result: ProvisionResult): string;

package/dist/push.d.ts

@@ -1,11 +0,0 @@
-export interface PushOptions {
-    /** The Daytona sandbox id — `provision`'s daytonaSandboxId. Not the twin's. */
-    sandboxId: string;
-    /** Git URL to clone into the sandbox. Unset: the current directory is uploaded. */
-    repo?: string;
-    /** Branch to clone. Only meaningful with --repo. */
-    ref?: string;
-}
-export declare const PUSH_USAGE: string;
-/** Parse everything after `push`. Pure; throws UsageError with a human message. */
-export declare function parsePushArgs(argv: readonly string[]): PushOptions;

package/dist/run.d.ts

@@ -1,87 +0,0 @@
-import type { Receipt } from './receipt';
-export interface RunOptions {
-    /** Git URL to clone into the sandbox. Unset: the current directory is uploaded. */
-    repo?: string;
-    /** Branch to clone. */
-    ref?: string;
-    /** Veris environment. Unset: VERIS_ENVIRONMENT_ID. */
-    environment?: string;
-    /** Attach to an existing twin instead of creating one. It is not deleted afterwards. */
-    sandbox?: string;
-    /** Daytona image or snapshot to create the sandbox from. Unset: Daytona's default. */
-    image?: string;
-    snapshot?: string;
-    /** Shell command run once before the main command (dependency install). */
-    setup?: string;
-    /** Services the receipt must show traffic for. Empty: any service will do. */
-    requireService: string[];
-    /** KEY=VALUE pairs exported to the setup and main commands. */
-    env: Record<string, string>;
-    /** Keep the sandbox and twin after the run, and print how to reach them. */
-    keep: boolean;
-    /** Seconds the main command may run. */
-    timeoutSeconds: number;
-    /** The command itself, everything after `--`. */
-    command: string;
-}
-export declare const DEFAULT_TIMEOUT_SECONDS = 1800;
-export declare const USAGE = "usage: veris-daytona run [options] -- <command>\n\nRuns <command> in a Daytona sandbox whose vendor API calls are answered by a\nVeris twin, then prints what the twin received.\n\n  --repo <url>              git URL to clone into the sandbox (default: upload the current directory)\n  --ref <branch>            branch to clone\n  --environment <id>        Veris environment (default: $VERIS_ENVIRONMENT_ID)\n  --sandbox <twin-id>       attach to an existing twin instead of creating one\n  --image <name>            Daytona image to run in (default: Daytona's default snapshot)\n  --snapshot <name>         Daytona snapshot to run in\n  --setup <cmd>             shell command run first, e.g. 'npm ci' or 'pip install -e .'\n  --require-service <name>  the receipt must show this service (repeatable; default: any)\n  --env KEY=VALUE           exported to the setup and main commands (repeatable)\n  --timeout <seconds>       how long <command> may run (default: 1800)\n  --keep                    leave the sandbox and twin running afterwards\n\nneeds: DAYTONA_API_KEY (with delete:sandboxes, or the sandbox outlives the run),\na Veris key \u2014 VERIS_API_KEY, or the profile `veris login` saved in\n~/.veris/twin.yaml (VERIS_PROFILE picks one) \u2014 and VERIS_ENVIRONMENT_ID (or\n--environment). GITHUB_TOKEN or GH_TOKEN is used for a private --repo.\n\nexit code: the command's; 1 if the twin received nothing (a pass without a receipt is not a pass).";
-export declare class UsageError extends Error {
-}
-/** Parse everything after `run`. Pure; throws UsageError with a human message. */
-export declare function parseRunArgs(argv: readonly string[]): RunOptions;
-/** Quote argv words back into one shell line, leaving plain words alone. */
-export declare function shellJoin(words: readonly string[]): string;
-export interface Verdict {
-    /** The process exit code the run should end with. */
-    exitCode: number;
-    /** One line per reason, for the human. Empty when everything held. */
-    problems: string[];
-}
-/**
- * Decide the exit code from the command's own status and the receipt.
- *
- * A failing command fails the run, receipt or not. A passing command still
- * fails the run when the twin saw nothing, or saw nothing for a service the
- * caller required — that is the case the receipt exists to catch.
- */
-export declare function verdict(commandExitCode: number, receipt: Receipt, requireService: readonly string[]): Verdict;
-/**
- * The receipt as the human sees it.
- *
- * A count the read could not finish prints as "≥N", per service and in the
- * total. The twin's log is read in pages, so a very long run can end at the
- * page budget, and printing that floor as if it were the count would be a
- * wrong number stated confidently — the one thing a receipt must never be.
- */
-export declare function formatReceipt(receipt: Receipt, twinId: string): string;
-/**
- * The directory under the sandbox's own home that every verb puts code in.
- *
- * One name shared by four verbs on purpose: `provision` prints it as workDir,
- * `push` unpacks into it, `exec` runs in it by default, and `run` does all
- * three. A caller chaining provision → push → exec never has to carry the path
- * between the commands, and cannot get it wrong.
- */
-export declare const WORK_SUBDIR = "veris-run";
-/** Directories never worth shipping: rebuilt inside the sandbox, or not source. */
-export declare const UPLOAD_EXCLUDES: readonly string[];
-/** Exit status coreutils `timeout` reports when it had to stop the command. */
-export declare const TIMED_OUT_EXIT = 124;
-/**
- * The one shell line a session runs: cd, exports, then the command under
- * coreutils `timeout` so a hung suite is stopped inside the sandbox. Images
- * without `timeout` run the command bare; the client-side backstop still
- * applies.
- */
-export declare function commandLine(cwd: string, env: Record<string, string>, command: string, timeoutSeconds: number): string;
-export declare function shellQuote(s: string): string;
-/**
- * The environment a command runs with. Daytona overwrites SSL_CERT_FILE,
- * REQUESTS_CA_BUNDLE and CURL_CA_BUNDLE inside the sandbox with its own CA
- * file, which cannot verify the gateway's leaf and cannot be amended (root
- * owned, read-only mount). So the Veris trust variables are exported on every
- * command, where they beat the session's inherited values. The caller's --env
- * comes last and wins.
- */
-export declare function commandEnv(trust: Record<string, string>, user: Record<string, string>): Record<string, string>;

package/dist/teardown.d.ts

@@ -1,52 +0,0 @@
-import type { DaytonaKeyInfo } from './daytona-key';
-export interface TeardownOptions {
-    /** The Daytona sandbox id. Not the twin's. */
-    sandboxId: string;
-}
-export declare const TEARDOWN_USAGE = "usage: veris-daytona teardown <daytona-sandbox-id>\n\nDeletes the Daytona sandbox. The id is the one `veris-daytona provision`\nprinted as daytonaSandboxId \u2014 not the Veris twin's id.\n\nThe twin follows the rule it was created under: one this package created is\ndeleted with the sandbox, one it attached to (`provision`, or `run --sandbox`)\nis yours and is left running. Which of the two happened is printed.\n\nneeds: DAYTONA_API_KEY with the delete:sandboxes permission \u2014 a key made with\n\"write sandboxes\" alone is refused, and the refusal says when Daytona will stop\nand delete the box on its own. To reach a twin that must be deleted, a Veris\nkey too: VERIS_API_KEY, or the profile `veris login` saved.\n\nexit code: 0 when the sandbox is deleted; 1 when there is no such sandbox, or\nthe key may not delete one.";
-/** The facts a refused delete is described from. Intervals are the sandbox's own. */
-export interface RefusedTeardown {
-    /** The Daytona sandbox id. */
-    sandboxId: string;
-    twinId?: string;
-    /** Whether the wrapped delete removed the twin before Daytona refused the
-     *  sandbox — it deletes the twin first, so an owned twin is already gone. */
-    ownsTwin: boolean;
-    /** Daytona's `autoStopInterval`: idle minutes before it stops. 0 is off. */
-    autoStopMinutes?: number;
-    /** Daytona's `autoDeleteInterval`: minutes after stopping before it is
-     *  deleted. 0 is at once; negative or unset is never. */
-    autoDeleteMinutes?: number;
-    /** Daytona's `autoDestroyAt`, when a TTL was set. */
-    expiresAt?: string;
-    /** The key's record, when GET /api/api-keys/current answered. */
-    key?: DaytonaKeyInfo;
-}
-/**
- * Was this Daytona's "you may not" — HTTP 403 — rather than any other failure?
- * Read off the status the SDK stamps rather than a class, so the check holds
- * across the SDK's own renamings (DaytonaAuthorizationError became
- * DaytonaForbiddenError) and for an error that crossed a package boundary.
- */
-export declare function isPermissionDenied(e: unknown): boolean;
-/**
- * What Daytona will do to the box on its own, in one clause: "stops after 30
- * idle minutes and is deleted 60 minutes after it stops, and is destroyed at
- * <time> whatever state it is in". This is the substance of a refusal — the
- * reader's real question is whether the box bills forever, and the answer is
- * on the sandbox object.
- */
-export declare function sandboxBrakes(r: Pick<RefusedTeardown, 'autoStopMinutes' | 'autoDeleteMinutes' | 'expiresAt'>): string;
-/**
- * What `teardown` says when Daytona answered 403.
- *
- * The bare "FAILED Access denied" this replaces named neither the cause nor the
- * consequence. The cause is a key without `delete:sandboxes` — the one
- * permission DELETE /api/sandbox/<id> checks, and one a key made with "write
- * sandboxes" alone does not have. The consequence is a box that is still there
- * and still billing, so the message says exactly when Daytona will stop and
- * delete it by itself, what happened to the twin, and how to delete it sooner.
- */
-export declare function teardownRefusedMessage(r: RefusedTeardown): string;
-/** Parse everything after `teardown`. Pure; throws UsageError with a human message. */
-export declare function parseTeardownArgs(argv: readonly string[]): TeardownOptions;