withruntime 0.11.1 → 0.12.0

package/dist/products/index.js

@@ -3,7 +3,7 @@ import { sandboxDesktop } from "./desktop.js";
 import { sandboxBrowser } from "./browser.js";
 import { sandboxInterpreter } from "./interpreter.js";
 import { sandboxNetwork } from "./network.js";
-import { addresses, domains, network, ports, tunnel } from "./network-products.js";
+import { domains, ips, networks, ports } from "./network-products.js";
 import { sandboxPreviews } from "./previews.js";
 import { referrals } from "./referrals.js";
 import { billing } from "./billing.js";
@@ -50,19 +50,8 @@ export const clientExtensions = {
     sso,
     domains,
     ports,
-    addresses,
-    tunnel,
-    network,
-};
-/** Canonical CLI product names share the existing factory instance. Account
- * commands such as secrets, events and billing retain their current names. */
-export const clientProductAliases = {
-    image: "images",
-    volume: "volumes",
-    job: "jobs",
-    domain: "domains",
-    port: "ports",
-    address: "addresses",
+    ips,
+    networks,
 };
 export const sandboxExtensions = {
     interpreter: sandboxInterpreter,

package/dist/products/jobs.d.ts

@@ -1,7 +1,7 @@
 import { Page } from "../page.js";
 import type { RequestOptions, Transport } from "../transport.js";
 /** A run's sandbox. Every field has a default; a run is a sandbox of this
- * size, on the trial's hours first and then on credit at the sandbox rates. */
+ * size, on the included usage first and then on credit at the sandbox rates. */
 export type JobCompute = {
     region: string;
     vcpu: number;
@@ -53,6 +53,9 @@ export type Job = {
     version: number;
     /** Unix milliseconds, or null when nothing more is scheduled. */
     nextRunAt: number | null;
+    /** When `trigger` asked for a run that has not started yet, in Unix
+     * milliseconds; null otherwise. */
+    runRequestedAt: number | null;
     /** Why the last due run could not start, retried every 30 seconds:
      * `credits` (add credit), `capacity`, `cost_cap` (maxTotalCostMicros or a
      * key's daily limit) or `permission` (the key that made the job lost it). */
@@ -68,6 +71,8 @@ export type JobRun = {
     occurrenceId: string;
     attempt: number;
     scheduledFor: number;
+    /** `manual`: a run `trigger` asked for, and its retries. */
+    trigger: "schedule" | "manual";
     resourceId: string;
     /** `unknown`: the outcome could not be observed (the sandbox stopped under
      * it). It is never retried by itself. */
@@ -159,6 +164,9 @@ export declare const JOB_LIMITS: {
 };
 /** Unix milliseconds from a Date, an ISO time or a number. */
 export declare function jobTime(at: Date | string | number): number;
+/** The API's schedule from what `create` and `reschedule` take: `{ at }`,
+ * `{ cron, timezone? }` or the raw `{ kind: ... }`. */
+export declare function jobSchedule(input: CreateJob["schedule"]): JobSchedule;
 /** The API's job body from `CreateJob`, with every default filled in and the
  * sandbox's size checked before anything is sent. */
 export declare function jobBody(input: CreateJob): Record<string, unknown>;
@@ -168,8 +176,7 @@ export declare function jobBody(input: CreateJob): Record<string, unknown>;
  * request id, and says no retry will change it. */
 export declare function switchedOff(product: string): (error: unknown) => never;
 /** Scheduled jobs: a command run in a fresh sandbox, once or on a cron
- * schedule. Each run is a sandbox, paid for as one: from the free trial's
- * hours first while the run fits the trial's size and count, then from credit
+ * schedule. Each run is a sandbox, paid for as one: from the included usage first while the run fits the limits without credit, then from credit
  * at the sandbox rates, through the same holds and spending limits.
  *
  *   const job = await runtime.jobs.create({
@@ -212,4 +219,13 @@ export declare function jobs(transport: Transport): {
     /** End the job for good and stop any run in progress. A run that already
      * finished keeps its result. Cancelling again answers the same job. */
     cancel: (id: string, options?: RequestOptions) => Promise<Job>;
+    /** Run it now, once, beside its schedule, which does not move. A paused
+     * job runs once and stays paused. While a run is starting or going it is
+     * refused with `run_in_progress`; a cancelled or finished job with
+     * `invalid_state`. The run is in `runs` with `trigger: "manual"`. */
+    trigger: (id: string, options?: RequestOptions) => Promise<Job>;
+    /** A new schedule, in any form `create` takes: `{ cron, timezone? }` or
+     * `{ at }`. The next run is the new schedule's next time; a run going
+     * finishes as it began, and a paused job stays paused. */
+    reschedule: (id: string, schedule: CreateJob["schedule"], options?: RequestOptions) => Promise<Job>;
 };

package/dist/products/jobs.js

@@ -47,25 +47,28 @@ export function jobTime(at) {
         throw invalid(`schedule.at must be a time: a Date, an ISO time such as 2026-10-01T03:00:00Z, or Unix milliseconds; got ${String(at)}.`, "schedule.at");
     return ms;
 }
-/** The API's job body from `CreateJob`, with every default filled in and the
- * sandbox's size checked before anything is sent. */
-export function jobBody(input) {
-    const s = input.schedule;
-    let schedule;
+/** The API's schedule from what `create` and `reschedule` take: `{ at }`,
+ * `{ cron, timezone? }` or the raw `{ kind: ... }`. */
+export function jobSchedule(input) {
+    const s = (input ?? {});
     if (s.kind === "once" || (s.kind === undefined && s.at !== undefined))
-        schedule = { kind: "once", at: jobTime(s.at) };
-    else if (s.kind === "cron" || (s.kind === undefined && s.cron !== undefined)) {
+        return { kind: "once", at: jobTime(s.at) };
+    if (s.kind === "cron" || (s.kind === undefined && s.cron !== undefined)) {
         const expression = String(s.expression ?? s.cron).trim();
         if (expression.split(/\s+/).length !== 5)
             throw invalid(`A cron schedule has five fields, minute hour day-of-month month day-of-week, such as "0 3 * * *"; got "${expression}".`, "schedule.cron");
-        schedule = {
+        return {
             kind: "cron",
             expression,
             ...(s.timezone === undefined ? {} : { timezone: s.timezone }),
         };
     }
-    else
-        throw invalid("schedule takes { at } or { cron }.", "schedule");
+    throw invalid("schedule takes { at } or { cron }.", "schedule");
+}
+/** The API's job body from `CreateJob`, with every default filled in and the
+ * sandbox's size checked before anything is sent. */
+export function jobBody(input) {
+    const schedule = jobSchedule(input.schedule);
     const command = Array.isArray(input.command) ? { argv: input.command } : input.command;
     if (!command?.argv?.length)
         throw invalid('command is an argv array such as ["python3", "job.py"].', "command");
@@ -128,8 +131,7 @@ export function switchedOff(product) {
     };
 }
 /** Scheduled jobs: a command run in a fresh sandbox, once or on a cron
- * schedule. Each run is a sandbox, paid for as one: from the free trial's
- * hours first while the run fits the trial's size and count, then from credit
+ * schedule. Each run is a sandbox, paid for as one: from the included usage first while the run fits the limits without credit, then from credit
  * at the sandbox rates, through the same holds and spending limits.
  *
  *   const job = await runtime.jobs.create({
@@ -187,5 +189,19 @@ export function jobs(transport) {
         /** End the job for good and stop any run in progress. A run that already
          * finished keeps its result. Cancelling again answers the same job. */
         cancel: (id, options) => verb(id, "cancel", options),
+        /** Run it now, once, beside its schedule, which does not move. A paused
+         * job runs once and stays paused. While a run is starting or going it is
+         * refused with `run_in_progress`; a cancelled or finished job with
+         * `invalid_state`. The run is in `runs` with `trigger: "manual"`. */
+        trigger: (id, options) => verb(id, "trigger", options),
+        /** A new schedule, in any form `create` takes: `{ cron, timezone? }` or
+         * `{ at }`. The next run is the new schedule's next time; a run going
+         * finishes as it began, and a paused job stays paused. */
+        reschedule: (id, schedule, options) => t.json({
+            method: "POST",
+            path: `/v1/jobs/${enc(id)}:reschedule`,
+            body: { schedule: jobSchedule(schedule) },
+            ...options,
+        }),
     };
 }

package/dist/products/limits.d.ts

@@ -1,3 +1,4 @@
+import type { Usage } from "../types.js";
 import type { RequestOptions, Transport } from "../transport.js";
 /** What this key may do, and the daily spending limit on its agent. Money is
  * integer microdollars in strings (1,000,000 = $1). */
@@ -14,16 +15,9 @@ export type KeyLimits = {
         remainingMicros: string | null;
         window: "24h";
     };
-    /** The account's free trial time in milliseconds, the same figures as
-     * `usage.get()`, or null when the account has no trial. A trial sandbox
-     * that has not ended holds its whole lease in `reservedMs`;
-     * `availableMs = totalMs - usedMs - reservedMs`. */
-    trial: {
-        totalMs: number;
-        usedMs: number;
-        reservedMs: number;
-        availableMs: number;
-    } | null;
+    /** Machine time the account can still run without credit, the same
+     * figures as `usage.get()`'s `trial`, or null when it has none. */
+    trial: Usage["trial"];
 };
 /** `runtime.limits.get()`: whether this key is read-only, and what its agent
  * may still spend today. An owner sets the limit at

package/dist/products/logs.d.ts

@@ -0,0 +1,245 @@
+import { Page } from "../page.js";
+import type { RequestOptions, Transport } from "../transport.js";
+/** Native logsd hit_json. Nanoseconds stay strings so no precision is lost. */
+export type LogLine = {
+    time: string;
+    timeUnixNano: string;
+    severity: number;
+    severityText: string;
+    body: unknown;
+    labels: Record<string, string>;
+    attributes: Record<string, unknown>;
+    traceId: string | null;
+    spanId: string | null;
+};
+export type LogSearch = {
+    query: string;
+    start?: string;
+    end?: string;
+    limit?: number;
+    direction?: "forward" | "backward";
+    cursor?: string;
+};
+export type LogSearchResult = {
+    lines: LogLine[];
+    next?: string | null;
+    stats: {
+        ms: number;
+        blocks: number;
+        skippedByTime: number;
+        skippedByLabels: number;
+        skippedByWords: number;
+        scanned: number;
+        bytesRead: number;
+    };
+};
+export type TailGap = {
+    gap: true;
+    from: string;
+    to: string;
+};
+export type TailLine = LogLine & {
+    cursor: string;
+    gap?: false;
+};
+export type TailEvent = TailLine | TailGap;
+export type LogQuery = {
+    query: string;
+    time?: string;
+    limit?: number;
+    direction?: "forward" | "backward";
+};
+export type LogRange = Omit<LogQuery, "time"> & {
+    start?: string;
+    end?: string;
+    step?: string;
+    interval?: string;
+};
+export type LokiResult = {
+    status: "success";
+    data: ({
+        resultType: "streams";
+        result: {
+            stream: Record<string, string>;
+            values: [string, string, Record<string, string>?][];
+        }[];
+    } | {
+        resultType: "matrix";
+        result: {
+            metric: Record<string, string>;
+            values: [number, string][];
+        }[];
+    } | {
+        resultType: "vector";
+        result: {
+            metric: Record<string, string>;
+            value: [number, string];
+        }[];
+    } | {
+        resultType: "scalar";
+        result: [number, string];
+    }) & {
+        stats?: Record<string, unknown>;
+    };
+};
+export type LabelResult = {
+    status: "success";
+    data: string[];
+};
+export type ViewInput = {
+    name: string;
+    labels: Record<string, string>;
+    query: string;
+    defaultRange?: string;
+};
+export type SavedView = ViewInput & {
+    id: string;
+    state: string;
+    createdAt: string;
+};
+export type AlertInput = {
+    name: string;
+    labels: Record<string, string>;
+    query: string;
+    condition: string;
+    for: string;
+    actions: Record<string, unknown>[];
+};
+export type Alert = AlertInput & {
+    id: string;
+    state: string;
+    createdAt: string;
+};
+/** OTLP/HTTP JSON; the server validates the signal's complete OTLP schema. */
+export type OtlpLogs = {
+    resourceLogs: Record<string, unknown>[];
+};
+export type OtlpTraces = {
+    resourceSpans: Record<string, unknown>[];
+};
+export type TraceSpan = {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes?: {
+        key: string;
+        value: Record<string, unknown>;
+    }[];
+    status?: {
+        code?: number;
+        message?: string;
+    };
+};
+export type Trace = {
+    resourceSpans: {
+        resource?: {
+            attributes?: {
+                key: string;
+                value: Record<string, unknown>;
+            }[];
+        };
+        scopeSpans: {
+            spans: TraceSpan[];
+        }[];
+    }[];
+};
+export type TraceSearchResult = {
+    traces: {
+        traceID: string;
+        rootServiceName: string;
+        rootTraceName: string;
+        startTimeUnixNano: string;
+        durationMs: number;
+    }[];
+    metrics?: Record<string, unknown>;
+};
+/** Hidden until Logs launches. */
+export declare function logs(t: Transport): {
+    search: (body: LogSearch, options?: RequestOptions) => Promise<LogSearchResult>;
+    pages(input: LogSearch, options?: RequestOptions): AsyncGenerator<LogSearchResult>;
+    /** The record's cursor, not timestamp or text, identifies a line. The
+     * server replays strictly after it. An echoed boundary is ignored; two
+     * identical lines at different record positions are both delivered. */
+    tail(query: string, options?: RequestOptions & {
+        cursor?: string;
+        start?: string;
+        reconnectMs?: number;
+    }): AsyncGenerator<TailEvent>;
+    query: (query: LogQuery, options?: RequestOptions) => Promise<LokiResult>;
+    queryRange: (query: LogRange, options?: RequestOptions) => Promise<LokiResult>;
+    labels: (query?: {
+        start?: string;
+        end?: string;
+    }, options?: RequestOptions) => Promise<LabelResult>;
+    labelValues: (name: string, query?: {
+        start?: string;
+        end?: string;
+    }, options?: RequestOptions) => Promise<LabelResult>;
+    views: {
+        create: (body: ViewInput, options?: RequestOptions) => Promise<SavedView>;
+        get: (id: string, options?: RequestOptions) => Promise<SavedView>;
+        list: (query?: {
+            limit?: number;
+            cursor?: string;
+        }, options?: RequestOptions) => Promise<Page<SavedView>>;
+        update: (id: string, body: Partial<ViewInput>, options?: RequestOptions) => Promise<SavedView>;
+        delete: (id: string, options?: RequestOptions) => Promise<void>;
+    };
+    ingest: (body: OtlpLogs, options?: RequestOptions) => Promise<{
+        partialSuccess?: {
+            rejectedLogRecords?: string;
+            rejectedSpans?: string;
+            errorMessage?: string;
+        };
+    }>;
+};
+export declare function traces(t: Transport): {
+    get: (id: string, options?: RequestOptions) => Promise<Trace>;
+    search: (q: string, options?: RequestOptions) => Promise<TraceSearchResult>;
+    tags: (options?: RequestOptions) => Promise<{
+        tagNames: string[];
+    }>;
+    views: {
+        create: (body: ViewInput, options?: RequestOptions) => Promise<SavedView>;
+        get: (id: string, options?: RequestOptions) => Promise<SavedView>;
+        list: (query?: {
+            limit?: number;
+            cursor?: string;
+        }, options?: RequestOptions) => Promise<Page<SavedView>>;
+        update: (id: string, body: Partial<ViewInput>, options?: RequestOptions) => Promise<SavedView>;
+        delete: (id: string, options?: RequestOptions) => Promise<void>;
+    };
+    ingest: (body: OtlpTraces, options?: RequestOptions) => Promise<{
+        partialSuccess?: {
+            rejectedLogRecords?: string;
+            rejectedSpans?: string;
+            errorMessage?: string;
+        };
+    }>;
+};
+export declare function alerts(t: Transport): {
+    test: (id: string, options?: RequestOptions) => Promise<{
+        firing: boolean;
+        matches: number;
+    }>;
+    silence: (id: string, input: {
+        until: string;
+        reason?: string;
+    }, options?: RequestOptions) => Promise<Alert>;
+    create: (body: AlertInput, options?: RequestOptions) => Promise<Alert>;
+    get: (id: string, options?: RequestOptions) => Promise<Alert>;
+    list: (query?: {
+        limit?: number;
+        cursor?: string;
+    }, options?: RequestOptions) => Promise<Page<Alert>>;
+    update: (id: string, body: Partial<AlertInput>, options?: RequestOptions) => Promise<Alert>;
+    delete: (id: string, options?: RequestOptions) => Promise<void>;
+};
+export type ObservabilityClient = {
+    logs: ReturnType<typeof logs>;
+    traces: ReturnType<typeof traces>;
+    alerts: ReturnType<typeof alerts>;
+};