withruntime 0.11.1 → 0.12.0

package/dist/blaxel/index.d.ts

@@ -1,11 +1,11 @@
 import { type Config } from "./client.js";
-export { SandboxInstance, DEFAULT_IMAGE, DEFAULT_MEMORY, MEMORY_PER_VCPU, durationMs, imageRef, lifetimeOf, networkRules, type SandboxListQuery, type SandboxForkOptions, type SandboxArchiveOptions, } from "./sandbox.js";
+export { SandboxInstance, DEFAULT_IMAGE, DEFAULT_MEMORY, MEMORY_PER_VCPU, durationMs, imageRef, lifetimeOf, networkRules, type SandboxListQuery, type SandboxForkOptions, type SandboxArchiveOptions, MAX_CREATION_TIMEOUT_SECONDS, type SandboxCreateOptions, } from "./sandbox.js";
 export { CodeInterpreter } from "./interpreter.js";
 export { SandboxFileSystem, retryOnTransient, type File, type FileWithContent, type Subdirectory, type Directory, type SuccessResponse, type FindMatch, type FindResponse, type FuzzySearchMatch, type FuzzySearchResponse, type ContentSearchMatch, type ContentSearchResponse, type CopyResponse, type WatchEvent, type SandboxFilesystemFile, type FilesystemSearchOptions, type FilesystemFindOptions, type FilesystemGrepOptions, } from "./filesystem.js";
 export { SandboxProcess, type ProcessRequest, type ProcessResponse, type ProcessRequestWithLog, type ProcessResponseWithLog, type PostProcessResponse, type GetProcessResponse, type GetProcessByIdentifierResponse, type DeleteProcessByIdentifierResponse, type DeleteProcessByIdentifierKillResponse, type ProcessLogs, } from "./process.js";
 export { SandboxPreview, SandboxPreviews, SandboxPreviewToken, SandboxPreviewTokens, type Preview, type PreviewMetadata, type PreviewSpec, type PreviewToken, } from "./preview.js";
 export { Snapshot, SandboxSnapshotsResource, type Env, type SandboxSnapshot, type SandboxSnapshotSource, type SandboxSnapshotSpec, type SandboxForkResponse, type SandboxRestoreResponse, type SnapshotCreateConfiguration, type SnapshotForkOptions, type SnapshotListQuery, } from "./snapshot.js";
-export { ResponseError, SandboxGatewayError, isGatewayError, isGatewayTimeout, CredentialsError, NotSupportedError, } from "./errors.js";
+export { ResponseError, SandboxCreationTimeoutError, isCreationTimeoutError, SandboxGatewayError, isGatewayError, isGatewayTimeout, CredentialsError, NotSupportedError, } from "./errors.js";
 export { createPaginatedList, unwrapListData, type PaginatedList, type PaginatedListMeta, type ListResponse, type CursorPaginationQuery, type AutoPagingEachCallback, type AutoPagingToArrayOptions, } from "./pagination.js";
 export { normalizePorts, normalizeEnvs, normalizeVolumes, type Status, type Port, type EnvVar, type ExpirationPolicy, type SandboxLifecycle, type SandboxNetwork, type VolumeBinding, type VolumeAttachment, type Metadata, type SandboxRuntime, type SandboxSpec, type CoreEvent, type Sandbox, type SandboxConfiguration, type SandboxCreateConfiguration, type SandboxUpdateMetadata, type SandboxUpdateNetwork, type SessionCreateOptions, type SessionWithToken, } from "./types.js";
 export { initialize, type Config, type WithRuntime, type RuntimeOptions } from "./client.js";

package/dist/blaxel/index.js

@@ -4,20 +4,20 @@
  *   import { SandboxInstance } from "withruntime/blaxel"; // was: from "@blaxel/core"
  *
  * and set RUNTIME_API_KEY, or run `npx withruntime login` once. A Blaxel key
- * (BL_API_KEY) is never sent anywhere. Every name `@blaxel/core` 0.3.23
+ * (BL_API_KEY) is never sent anywhere. Every name `@blaxel/core` 0.3.25
  * exports can be imported; what Runtime cannot do the way Blaxel does throws
  * NotSupportedError, naming what to use. */
 import { RuntimeError } from "../errors.js";
 import { initialize } from "./client.js";
 import { NotSupportedError } from "./errors.js";
 import { CODEGEN, DRIVES, SCHEDULES, SYSTEM, unsupportedExport } from "./unsupported.js";
-export { SandboxInstance, DEFAULT_IMAGE, DEFAULT_MEMORY, MEMORY_PER_VCPU, durationMs, imageRef, lifetimeOf, networkRules, } from "./sandbox.js";
+export { SandboxInstance, DEFAULT_IMAGE, DEFAULT_MEMORY, MEMORY_PER_VCPU, durationMs, imageRef, lifetimeOf, networkRules, MAX_CREATION_TIMEOUT_SECONDS, } from "./sandbox.js";
 export { CodeInterpreter } from "./interpreter.js";
 export { SandboxFileSystem, retryOnTransient, } from "./filesystem.js";
 export { SandboxProcess, } from "./process.js";
 export { SandboxPreview, SandboxPreviews, SandboxPreviewToken, SandboxPreviewTokens, } from "./preview.js";
 export { Snapshot, SandboxSnapshotsResource, } from "./snapshot.js";
-export { ResponseError, SandboxGatewayError, isGatewayError, isGatewayTimeout, CredentialsError, NotSupportedError, } from "./errors.js";
+export { ResponseError, SandboxCreationTimeoutError, isCreationTimeoutError, SandboxGatewayError, isGatewayError, isGatewayTimeout, CredentialsError, NotSupportedError, } from "./errors.js";
 export { createPaginatedList, unwrapListData, } from "./pagination.js";
 export { normalizePorts, normalizeEnvs, normalizeVolumes, } from "./types.js";
 export { initialize } from "./client.js";
@@ -88,7 +88,7 @@ const MODELS = "Call your model provider's SDK directly; Runtime does not proxy
 const TOOLS = "Give your agent Runtime's sandbox tools: `import { tools } from \"withruntime/tools\"`, or Runtime's MCP server (`npx withruntime mcp`).";
 const MCP = "Serve MCP from a sandbox and share its port with sandbox.previews.create, or use Runtime's own MCP server (`npx withruntime mcp`).";
 const JOBS = "Run the batch as processes in sandboxes: SandboxInstance.create, then sandbox.process.exec for each task.";
-const IMAGES = "Build a Runtime image and create sandboxes from it by name: `npx withruntime image build --dockerfile Dockerfile --name <image>` or runtime.images.build({ name, dockerfile | image }).";
+const IMAGES = "Build a Runtime image and create sandboxes from it by name: `npx withruntime images build --dockerfile Dockerfile --name <image>` or runtime.images.build({ name, dockerfile | image }).";
 const VOLUMES = 'Use Runtime volumes: runtime.volumes.create({ name }) (`import { Runtime } from "withruntime"`), then pass volumes: [{ name, mountPath }] at create.';
 const HOSTING = "Serve it from a sandbox and share its port with sandbox.previews.create.";
 const TELEMETRY = "Send your own traces; Runtime exports sandbox metrics and events with runtime.otel (OpenTelemetry).";

package/dist/blaxel/interpreter.d.ts

@@ -1,4 +1,4 @@
-import { SandboxInstance } from "./sandbox.js";
+import { SandboxInstance, type SandboxCreateOptions } from "./sandbox.js";
 import type { Port, Sandbox as SandboxModel, SandboxCreateConfiguration, SandboxLifecycle } from "./types.js";
 declare class OutputMessage {
     text: string;
@@ -45,10 +45,7 @@ export declare class CodeInterpreter extends SandboxInstance {
     static readonly Context: typeof Context;
     /** Blaxel's defaults for a code interpreter: its image, port 8888, and
      * deletion after 30 idle minutes (a paused sandbox kept one day). */
-    static create<T extends typeof SandboxInstance>(this: T, sandbox?: SandboxCreateConfiguration | SandboxModel | Record<string, unknown> | null, options?: {
-        safe?: boolean;
-        createIfNotExist?: boolean;
-    }): Promise<InstanceType<T>>;
+    static create<T extends typeof SandboxInstance>(this: T, sandbox?: SandboxCreateConfiguration | SandboxModel | Record<string, unknown> | null, options?: SandboxCreateOptions): Promise<InstanceType<T>>;
     get _jupyterUrl(): string;
     /** Runs code in a stateful context. Errors in the code come back in
      * `execution.error`; a run past `timeout` seconds (default 60, 0 for none)

package/dist/blaxel/sandbox.d.ts

@@ -40,6 +40,18 @@ export type SandboxArchiveOptions = {
     maxWait?: number;
     interval?: number;
 };
+/** The longest creation `timeout` Blaxel accepts, in seconds. */
+export declare const MAX_CREATION_TIMEOUT_SECONDS = 50;
+/** Options of SandboxInstance.create / createIfNotExists, as Blaxel's. */
+export type SandboxCreateOptions = {
+    /** List `/` once it runs, and delete it if that fails. */
+    safe?: boolean;
+    /** Answer the sandbox already holding the name instead of a 409. */
+    createIfNotExist?: boolean;
+    /** Give up after this many whole seconds (1 to 50): the sandbox is deleted
+     * and the call rejects with SandboxCreationTimeoutError. */
+    timeout?: number;
+};
 /** What a create asked for that no label keeps: shown by `spec` in the
  * client that created the sandbox. */
 type Asked = {
@@ -127,16 +139,12 @@ export declare class SandboxInstance {
     get expiresIn(): number | undefined;
     /** Creates a sandbox and answers once it runs. Blaxel's defaults: the base
      * image (Runtime's stock image) and 4096 MB, with vCPUs at one per 2048 MB.
-     * Funding is left to Runtime: the free trial while the account has trial
-     * time, then prepaid credit. A name another live sandbox holds is refused
+     * Funding is left to Runtime: the included usage first, then prepaid credit. A name another live sandbox holds is refused
      * with a 409, as in Blaxel. */
-    static create<T extends typeof SandboxInstance>(this: T, sandbox?: SandboxCreateConfiguration | SandboxModel, { createIfNotExist }?: {
-        safe?: boolean;
-        createIfNotExist?: boolean;
-    }): Promise<InstanceType<T>>;
+    static create<T extends typeof SandboxInstance>(this: T, sandbox?: SandboxCreateConfiguration | SandboxModel, options?: SandboxCreateOptions): Promise<InstanceType<T>>;
     /** The named sandbox, or a new one when no live sandbox has the name.
      * Runtime settles a race between two callers: both get the same sandbox. */
-    static createIfNotExists<T extends typeof SandboxInstance>(this: T, sandbox: SandboxCreateConfiguration | SandboxModel): Promise<InstanceType<T>>;
+    static createIfNotExists<T extends typeof SandboxInstance>(this: T, sandbox: SandboxCreateConfiguration | SandboxModel, options?: Omit<SandboxCreateOptions, "createIfNotExist">): Promise<InstanceType<T>>;
     /** The live sandbox with this name (or Runtime id). It is not woken: the
      * next call wakes it. */
     static get<T extends typeof SandboxInstance>(this: T, sandboxName: string, options?: RuntimeOptions): Promise<InstanceType<T>>;

package/dist/blaxel/sandbox.js

@@ -1,7 +1,7 @@
 import { RuntimeError } from "../errors.js";
 import { clientFor, defaultRegion, } from "./client.js";
 import { checkEnvNames, envFileCommand, envFileLines, parseProcessLine, toRuntimePath, } from "./context.js";
-import { codeOf, guard, NotSupportedError, responseError, translate } from "./errors.js";
+import { codeOf, guard, NotSupportedError, responseError, SandboxCreationTimeoutError, translate, } from "./errors.js";
 import { SandboxFileSystem } from "./filesystem.js";
 import { ARCHIVED, DISPLAY_NAME, EXTERNAL_ID, IDLE_PAUSE, LABEL, findByExternalId, findSandbox, LEASE_SECONDS, ownLabels, STANDBY, userLabels, whenNameFree, } from "./lookup.js";
 import { paginate } from "./pagination.js";
@@ -38,6 +38,56 @@ const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const DAY_MS = 86_400_000;
 /** The lease is renewed in the background once this little of it is left. */
 const RENEW_BELOW_MS = 10 * 60_000;
+/** The longest creation `timeout` Blaxel accepts, in seconds. */
+export const MAX_CREATION_TIMEOUT_SECONDS = 50;
+/** Blaxel's own check of `timeout`, with its words. */
+function creationTimeout({ timeout }) {
+    if (timeout === undefined)
+        return undefined;
+    if (!Number.isInteger(timeout) || timeout < 1 || timeout > MAX_CREATION_TIMEOUT_SECONDS)
+        throw new Error(`SandboxInstance.create: 'timeout' must be a whole number of seconds between 1 and ${MAX_CREATION_TIMEOUT_SECONDS}, got ${timeout}.`);
+    return timeout;
+}
+/** A create that must be running within `timeout` seconds of the call, the
+ * wait for capacity included. One that is not is deleted, so the name is
+ * free again, and the call rejects with SandboxCreationTimeoutError. */
+async function createWithin(client, input, timeout) {
+    const deadline = performance.now() + timeout * 1000;
+    const runtime = await guard(() => whenNameFree(client, () => client.sandboxes.create({ ...input, wait: false }, { waitForCapacityMs: timeout * 1000 })));
+    // A sandbox the name already had is the caller's, whatever its state: it is
+    // answered as it is, as without a timeout, and never deleted here.
+    if (runtime.state === "running" || runtime.info.reused)
+        return runtime;
+    const left = deadline - performance.now();
+    if (left > 0)
+        try {
+            await runtime.waitFor("running", {
+                timeoutSeconds: Math.max(1, Math.ceil(left / 1000)),
+                timeoutMs: Math.ceil(left) + 5_000,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof RuntimeError && error.code === "timeout")) {
+                await runtime.delete().catch(() => undefined);
+                throw translate(error);
+            }
+        }
+    // waitFor updated the state TypeScript narrowed above.
+    const state = runtime.state;
+    if (state === "running")
+        return runtime;
+    await runtime.delete().catch(() => undefined);
+    if (state !== "starting")
+        throw translate(new RuntimeError({
+            message: `Sandbox ${runtime.id} is ${runtime.state}, not running.`,
+            code: "start_failed",
+            status: 0,
+            hint: "Create it again; SandboxInstance.get(name) reads why it stopped.",
+        }));
+    throw new SandboxCreationTimeoutError(input.name, timeout, {
+        message: `It was still starting after ${timeout}s.`,
+    });
+}
 /** The labels a new sandbox carries: the caller's, and under `blaxel/` what
  * Blaxel keeps and Runtime has no field for, so any client (the Python
  * adapter too) reads the same `spec`. */
@@ -212,7 +262,7 @@ async function resolveImage(client, image) {
     if (found && found.state === "ready")
         return { image: found.id };
     const feature = `The image ${image}, which is not a Runtime image`;
-    const alternative = `Build it as a Runtime image named ${name}: \`npx withruntime image build --dockerfile Dockerfile --name ${name} -t ${name}:${tag}\`. The code can keep "${image}": the adapter starts from ${name}:${tag}.`;
+    const alternative = `Build it as a Runtime image named ${name}: \`npx withruntime images build --dockerfile Dockerfile --name ${name} -t ${name}:${tag}\`. The code can keep "${image}": the adapter starts from ${name}:${tag}.`;
     throw new NotSupportedError(feature, alternative, `${feature}, is not supported on Runtime. ${alternative}`);
 }
 /** Blaxel volumes (by name) as Runtime volumes. */
@@ -228,7 +278,7 @@ async function resolveVolumes(client, volumes) {
     return Promise.all(volumes.map(async (volume) => {
         const found = (await guard(() => client.volumes.list({ name: volume.name }))).data[0];
         if (!found)
-            throw new NotSupportedError(`The volume ${volume.name}, which is not a Runtime volume`, `Create it first: runtime.volumes.create({ name: "${volume.name}" }) or \`npx withruntime volume create --name ${volume.name}\`.`);
+            throw new NotSupportedError(`The volume ${volume.name}, which is not a Runtime volume`, `Create it first: runtime.volumes.create({ name: "${volume.name}" }) or \`npx withruntime volumes create --name ${volume.name}\`.`);
         return { volumeId: found.id, path: toRuntimePath(volume.mountPath) };
     }));
 }
@@ -523,10 +573,11 @@ export class SandboxInstance {
     // ---- create, get, list ---------------------------------------------------
     /** Creates a sandbox and answers once it runs. Blaxel's defaults: the base
      * image (Runtime's stock image) and 4096 MB, with vCPUs at one per 2048 MB.
-     * Funding is left to Runtime: the free trial while the account has trial
-     * time, then prepaid credit. A name another live sandbox holds is refused
+     * Funding is left to Runtime: the included usage first, then prepaid credit. A name another live sandbox holds is refused
      * with a 409, as in Blaxel. */
-    static async create(sandbox, { createIfNotExist = false } = {}) {
+    static async create(sandbox, options = {}) {
+        const { createIfNotExist = false, safe = false } = options;
+        const timeout = creationTimeout(options);
         const config = configOf(sandbox);
         const region = config.region || defaultRegion();
         checkRegion(region);
@@ -560,7 +611,9 @@ export class SandboxInstance {
             ...(createIfNotExist && config.name ? { getOrCreate: true } : {}),
             ...config.withruntime?.create,
         };
-        const runtime = await guard(() => whenNameFree(client, () => client.sandboxes.create(input)));
+        const runtime = timeout === undefined
+            ? await guard(() => whenNameFree(client, () => client.sandboxes.create(input)))
+            : await createWithin(client, input, timeout);
         const asked = {
             ...(Object.keys(envs).length ? { envs } : {}),
             ...(config.network ? { network: config.network } : {}),
@@ -572,6 +625,8 @@ export class SandboxInstance {
         const instance = new this({ runtime, client, asked });
         try {
             await instance.#setUp(envs, lifetime.days);
+            if (safe)
+                await instance.fs.ls("/");
         }
         catch (error) {
             await runtime.stop({ wait: false }).catch(() => undefined);
@@ -581,8 +636,8 @@ export class SandboxInstance {
     }
     /** The named sandbox, or a new one when no live sandbox has the name.
      * Runtime settles a race between two callers: both get the same sandbox. */
-    static async createIfNotExists(sandbox) {
-        return this.create(sandbox, { createIfNotExist: true });
+    static async createIfNotExists(sandbox, options = {}) {
+        return this.create(sandbox, { ...options, createIfNotExist: true });
     }
     /** The live sandbox with this name (or Runtime id). It is not woken: the
      * next call wakes it. */

package/dist/blaxel/snapshot.d.ts

@@ -71,6 +71,10 @@ export declare function appendEnvs(runtime: RuntimeSandbox, envs: Record<string,
 export declare function startFromSnapshot(client: Runtime, snapshotId: string, name: string, labels: Record<string, string>, envs: Record<string, string>): Promise<RuntimeSandbox>;
 declare function refuseApplication(options?: {
     targetType?: string;
+    port?: number;
+    traffic?: number;
+    customDomain?: string;
+    prefix?: string;
 }): void;
 /** A snapshot, as Blaxel's Snapshot class. */
 export declare class Snapshot {

package/dist/blaxel/snapshot.js

@@ -63,6 +63,10 @@ export async function startFromSnapshot(client, snapshotId, name, labels, envs)
 function refuseApplication(options = {}) {
     if (options.targetType === "application")
         throw new NotSupportedError("Forking into an application", "Fork into a sandbox and share its port with sandbox.previews.create.");
+    // Blaxel's application-fork routing: a sandbox fork has no use for them.
+    for (const key of ["port", "traffic", "customDomain", "prefix"])
+        if (options[key] !== undefined)
+            throw new NotSupportedError(`A fork's ${key}`, "Fork without it, then share a port of the copy with sandbox.previews.create({ metadata: { name }, spec: { port } }).");
 }
 /** A snapshot, as Blaxel's Snapshot class. */
 export class Snapshot {

package/dist/cli/logs.d.ts

@@ -0,0 +1,21 @@
+import type { ObservabilityClient } from "../products/logs.js";
+type Product = "logs" | "traces" | "alerts";
+type Args = {
+    positional: string[];
+    flags: Map<string, string[]>;
+};
+type Out = {
+    json: boolean;
+    tty?: boolean;
+    drain?: () => Promise<void>;
+    write(text: string): void;
+    error(text: string): void;
+};
+export declare const LOGS_HELP = "runtime logs tail <selector|app> [--since 1h] [--grep text] [--json] [--raw]\nruntime logs query '<LogQL>' [--from <time>] [--to <time>] [--limit <n>]\nruntime logs labels | values <label>\nruntime logs views ls|get|create|update|delete [id] [--body '<JSON>']\nruntime traces get <id> | search '<TraceQL>' | tags\nruntime traces views ls|get|create|update|delete [id] [--body '<JSON>']\nruntime logs ingest --body '<OTLP JSON>'\nruntime traces ingest --body '<OTLP JSON>'\nruntime alerts ls|get|create|update|delete|test|silence [id]\n  create/update: --body '<JSON: name, labels, query, condition, for, actions>'\n  silence: --until <RFC3339> [--reason <text>]\nEvery command takes --json. Writes take --idempotency-key <key>.\nOn a terminal, control characters in logs show as \\uXXXX; --raw prints them as written.";
+/** Same parsed argument and output ports as the existing CLI. No registration
+ * occurs here: the launch owner supplies a client only after launch. */
+export declare function logsProductCommand(product: Product, argv: string[], args: Args, out: Out, client: () => Promise<ObservabilityClient>, options?: {
+    signal?: AbortSignal;
+    now?: number;
+}): Promise<number>;
+export {};

package/dist/cli/logs.js

@@ -0,0 +1,188 @@
+import { RuntimeError } from "../errors.js";
+import { terminalSafe } from "../terminal.js";
+export const LOGS_HELP = `runtime logs tail <selector|app> [--since 1h] [--grep text] [--json] [--raw]
+runtime logs query '<LogQL>' [--from <time>] [--to <time>] [--limit <n>]
+runtime logs labels | values <label>
+runtime logs views ls|get|create|update|delete [id] [--body '<JSON>']
+runtime traces get <id> | search '<TraceQL>' | tags
+runtime traces views ls|get|create|update|delete [id] [--body '<JSON>']
+runtime logs ingest --body '<OTLP JSON>'
+runtime traces ingest --body '<OTLP JSON>'
+runtime alerts ls|get|create|update|delete|test|silence [id]
+  create/update: --body '<JSON: name, labels, query, condition, for, actions>'
+  silence: --until <RFC3339> [--reason <text>]
+Every command takes --json. Writes take --idempotency-key <key>.
+On a terminal, control characters in logs show as \\uXXXX; --raw prints them as written.`;
+const usage = (message) => new RuntimeError({ code: "usage", status: 0, message, hint: LOGS_HELP });
+function since(text, now) {
+    const match = /^(\d+)(s|m|h|d)$/.exec(text);
+    if (!match)
+        throw usage("Use --since with seconds, minutes, hours or days, such as 1h.");
+    const factors = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+    const at = now - Number(match[1]) * factors[match[2]];
+    if (!Number.isSafeInteger(at) || at < 0)
+        throw usage("--since is outside the supported time range.");
+    return new Date(at).toISOString();
+}
+/** Same parsed argument and output ports as the existing CLI. No registration
+ * occurs here: the launch owner supplies a client only after launch. */
+export async function logsProductCommand(product, argv, args, out, client, options = {}) {
+    const verb = argv[0];
+    const rest = args.positional.slice(1);
+    const flag = (name) => args.flags.get(name)?.at(-1);
+    const json = out.json || flag("json") === "true";
+    // On a terminal, what customers' programs wrote is shown escaped, JSON
+    // included (an escape is still valid JSON); --raw prints it as it is.
+    const safe = (text) => (out.tty && flag("raw") !== "true" ? terminalSafe(text) : text);
+    const lines = (text) => text.split("\n").map(safe).join("\n");
+    const print = (value, text) => out.write(json ? safe(JSON.stringify(value)) : lines(text ?? JSON.stringify(value, null, 2)));
+    const need = (value, name) => {
+        if (!value)
+            throw usage(`Give ${name}.`);
+        return value;
+    };
+    const body = () => {
+        try {
+            const value = JSON.parse(need(flag("body"), "--body with a JSON object"));
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                throw usage("--body must be a JSON object.");
+            return value;
+        }
+        catch (error) {
+            if (error instanceof RuntimeError)
+                throw error;
+            throw usage("--body is not valid JSON.");
+        }
+    };
+    const request = {
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(flag("idempotency-key") ? { idempotencyKey: flag("idempotency-key") } : {}),
+    };
+    if (!verb || verb === "help" || verb === "--help") {
+        print({ usage: LOGS_HELP }, LOGS_HELP);
+        return 0;
+    }
+    const runtime = await client();
+    if ((product === "logs" || product === "traces") && verb === "views") {
+        const views = runtime[product].views;
+        const action = need(rest[0], "a views command");
+        if (action === "ls") {
+            const result = await views.list({}, request);
+            print({ data: result.data, nextCursor: result.nextCursor });
+        }
+        else if (action === "create")
+            print(await views.create(body(), request));
+        else {
+            const id = need(rest[1], "a view id");
+            if (action === "get")
+                print(await views.get(id, request));
+            else if (action === "update")
+                print(await views.update(id, body(), request));
+            else if (action === "delete") {
+                await views.delete(id, request);
+                print({ deleted: id });
+            }
+            else
+                throw usage(`Unknown views command: ${action}.`);
+        }
+        return 0;
+    }
+    if ((product === "logs" || product === "traces") && verb === "ingest") {
+        const input = body();
+        if (product === "logs") {
+            if (!Array.isArray(input.resourceLogs))
+                throw usage("OTLP logs need resourceLogs.");
+            const resourceLogs = input.resourceLogs;
+            print(await runtime.logs.ingest({ resourceLogs }, request));
+        }
+        else {
+            if (!Array.isArray(input.resourceSpans))
+                throw usage("OTLP spans need resourceSpans.");
+            const resourceSpans = input.resourceSpans;
+            print(await runtime.traces.ingest({ resourceSpans }, request));
+        }
+        return 0;
+    }
+    if (product === "logs") {
+        if (verb === "tail") {
+            const selector = need(rest[0], "a selector or app name");
+            let query = selector.trim().startsWith("{") ? selector : `{app=${JSON.stringify(selector)}}`;
+            if (flag("grep") !== undefined)
+                query += ` |= ${JSON.stringify(flag("grep"))}`;
+            for await (const event of runtime.logs.tail(query, {
+                ...request,
+                ...(flag("since") ? { start: since(flag("since"), options.now ?? Date.now()) } : {}),
+            })) {
+                if (json)
+                    out.write(safe(JSON.stringify(event)));
+                else if (event.gap) {
+                    const text = safe(`Logs expired between ${event.from} and ${event.to}; continuing from retained logs.`);
+                    out.write(out.tty ? `\x1b[2m${text}\x1b[0m` : text);
+                }
+                else {
+                    const time = safe(event.time);
+                    const text = safe(typeof event.body === "string" ? event.body : JSON.stringify(event.body));
+                    out.write(`${out.tty ? `\x1b[2m${time}\x1b[0m` : time} ${safe(event.severityText)} ${text}`);
+                }
+                await out.drain?.();
+            }
+        }
+        else if (verb === "query") {
+            const limit = flag("limit") === undefined ? undefined : Number(flag("limit"));
+            if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 1))
+                throw usage("--limit must be a positive integer.");
+            print(await runtime.logs.queryRange({
+                query: need(rest[0], "a LogQL query"),
+                ...(flag("from") ? { start: flag("from") } : {}),
+                ...(flag("to") ? { end: flag("to") } : {}),
+                ...(limit !== undefined ? { limit } : {}),
+            }, request));
+        }
+        else if (verb === "labels")
+            print(await runtime.logs.labels({}, request));
+        else if (verb === "values")
+            print(await runtime.logs.labelValues(need(rest[0], "a label name"), {}, request));
+        else
+            throw usage(`Unknown logs command: ${verb}.`);
+    }
+    else if (product === "traces") {
+        if (verb === "get")
+            print(await runtime.traces.get(need(rest[0], "a trace id"), request));
+        else if (verb === "search")
+            print(await runtime.traces.search(need(rest[0], "a TraceQL query"), request));
+        else if (verb === "tags")
+            print(await runtime.traces.tags(request));
+        else
+            throw usage(`Unknown traces command: ${verb}.`);
+    }
+    else {
+        if (verb === "ls") {
+            const result = await runtime.alerts.list({}, request);
+            print({ data: result.data, nextCursor: result.nextCursor });
+        }
+        else if (verb === "create")
+            print(await runtime.alerts.create(body(), request));
+        else {
+            const id = need(rest[0], "an alert id");
+            if (verb === "get")
+                print(await runtime.alerts.get(id, request));
+            else if (verb === "update")
+                print(await runtime.alerts.update(id, body(), request));
+            else if (verb === "delete") {
+                await runtime.alerts.delete(id, request);
+                print({ deleted: id });
+            }
+            else if (verb === "test")
+                print(await runtime.alerts.test(id, request));
+            else if (verb === "silence") {
+                const until = need(flag("until"), "--until with an RFC3339 time");
+                if (!/T.*(?:Z|[+-]\d\d:\d\d)$/.test(until) || !Number.isFinite(Date.parse(until)))
+                    throw usage("--until must be an RFC3339 time with timezone.");
+                print(await runtime.alerts.silence(id, { until, ...(flag("reason") ? { reason: flag("reason") } : {}) }, request));
+            }
+            else
+                throw usage(`Unknown alerts command: ${verb}.`);
+        }
+    }
+    return 0;
+}

package/dist/cli/logs.test.d.ts

@@ -0,0 +1 @@
+export {};