run402 2.0.1 → 2.2.0

package/README.md

@@ -143,6 +143,17 @@ run402 deploy apply --manifest run402.deploy.json   # manifest uses secrets.requ
 
 Secret values are write-only. `list` returns keys and timestamps only; deploy manifests should declare dependencies with `secrets.require` and never contain values.
 
+### Jobs
+
+```bash
+run402 jobs submit --file job.json --project prj_...
+run402 jobs get job_abc123 --project prj_...
+run402 jobs logs job_abc123 --project prj_... --tail 100
+run402 jobs cancel job_abc123 --project prj_...
+```
+
+Jobs are fixed platform-managed runners, not arbitrary Docker execution. Submit the gateway-shaped JSON request (`job_type`, `input["input.json"]`, `max_cost_usd_micros`) and the CLI handles the required idempotency header through the SDK.
+
 ### Email
 
 ```bash

package/cli.mjs

@@ -27,6 +27,7 @@ Commands:
   projects    Manage projects (provision, list, query, inspect, delete)
   deploy      Unified deploy operations (requires active tier)
   ci          Link GitHub Actions OIDC deploy bindings
+  jobs        Submit and inspect fixed platform-managed jobs
   functions   Manage serverless functions (deploy, invoke, logs, list, delete)
   secrets     Manage project secrets (set, list, delete)
   assets      Direct-to-S3 asset storage (put, get, ls, rm, sign, diagnose) — up to 5 TiB
@@ -52,6 +53,7 @@ Examples:
   run402 allowance create
   run402 allowance fund
   run402 deploy apply --manifest app.json
+  run402 jobs submit --file job.json
   run402 projects list
   run402 projects sql <project_id> "SELECT * FROM users LIMIT 5"
   run402 functions deploy <project_id> my-fn --file handler.ts
@@ -129,6 +131,11 @@ switch (cmd) {
     await run(sub, rest);
     break;
   }
+  case "jobs": {
+    const { run } = await import("./lib/jobs.mjs");
+    await run(sub, rest);
+    break;
+  }
   case "functions": {
     const { run } = await import("./lib/functions.mjs");
     await run(sub, rest);

package/lib/assets.mjs

@@ -19,20 +19,13 @@
  */
 
 import {
-  createReadStream,
   statSync,
   readFileSync,
-  writeFileSync,
   mkdirSync,
-  chmodSync,
   existsSync,
-  unlinkSync,
-  readdirSync,
   createWriteStream,
 } from "node:fs";
-import { createHash } from "node:crypto";
-import { basename, dirname, join, resolve as resolvePath } from "node:path";
-import { homedir } from "node:os";
+import { basename, dirname, resolve as resolvePath } from "node:path";
 import { pipeline } from "node:stream/promises";
 
 import { resolveProjectId } from "./config.mjs";
@@ -55,10 +48,7 @@ Options:
   --key <dest>        Destination key (put only; defaults to file basename)
   --content-type <mime>  MIME override for blob put (defaults to extension inference)
   --private           Upload as private (not served by CDN; apikey required to read)
-  --immutable         Adds a content-hash suffix to the URL so overwrites produce distinct URLs.
-                      Requires computing SHA-256 over the file (CLI does this automatically).
-  --concurrency N     Concurrent part PUTs (default 4)
-  --no-resume         Start fresh; ignore any cached state
+  --immutable         Append a content-hash suffix to the URL so overwrites produce distinct URLs.
   --json              NDJSON progress events (for agent consumption)
   --prefix <p>        Prefix filter (ls only)
   --limit <n>         Max results (ls only; default 100, max 1000)
@@ -72,6 +62,11 @@ Examples:
   run402 assets ls --project prj_abc123 --prefix images/
   run402 assets rm images/logo.png --project prj_abc123
   run402 assets sign images/logo.png --project prj_abc123 --ttl 600
+
+Note: as of v2.1.0, the CLI delegates to sdk.assets.put which routes through
+the unified-apply hero. The pre-v2.1.0 --concurrency and --no-resume flags
+are still accepted for backward compatibility but are ignored; resume
+semantics now live at the apply-plan level (24h plan TTL).
 `;
 
 const SUB_HELP = {
@@ -89,15 +84,13 @@ Options:
   --content-type <mime>  MIME override; defaults to inferring from the destination key extension
   --private           Upload as private (not served by CDN; apikey required to read)
   --immutable         Append content-hash suffix so overwrites produce distinct URLs
-  --concurrency N     Concurrent part PUTs for multipart uploads (default 4)
-  --no-resume         Ignore any cached resumable-upload state and start fresh
   --json              Emit NDJSON progress events on stdout (for agent consumption)
 
 Examples:
   run402 assets put ./artifact.tgz --project prj_abc123
   run402 assets put ./dist/**/*.png --project prj_abc123 --key assets/
   run402 assets put ./asset --project prj_abc123 --key assets/logo --content-type image/svg+xml
-  run402 assets put huge.bin --project prj_abc123 --immutable --concurrency 8
+  run402 assets put huge.bin --project prj_abc123 --immutable
 `,
   get: `run402 assets get — Download a blob by key
 
@@ -185,10 +178,6 @@ Examples:
 `,
 };
 
-function uploadStateDir() {
-  return join(homedir(), ".run402", "uploads");
-}
-
 function die(msg, exit_code = 1) {
   fail({ code: "BAD_USAGE", message: msg, exit_code });
 }
@@ -255,173 +244,34 @@ function parseContentTypeFlag(name, value) {
   return raw;
 }
 
-async function sha256File(filePath) {
-  const h = createHash("sha256");
-  const stream = createReadStream(filePath);
-  for await (const chunk of stream) h.update(chunk);
-  return h.digest("hex");
-}
-
-function sha256BufferHexAndBase64(body) {
-  const digest = createHash("sha256").update(body).digest();
-  return {
-    hex: digest.toString("hex"),
-    base64: digest.toString("base64"),
-  };
-}
-
-function checksumHeadersForPresignedUrl(url, checksumBase64) {
-  let urlHasChecksum = false;
-  try {
-    urlHasChecksum = new URL(url).searchParams.has("x-amz-checksum-sha256");
-  } catch {
-    urlHasChecksum = false;
-  }
-  return urlHasChecksum ? {} : { "x-amz-checksum-sha256": checksumBase64 };
-}
-
-function loadState(uploadId) {
-  const path = join(uploadStateDir(), `${uploadId}.json`);
-  if (!existsSync(path)) return null;
-  try { return JSON.parse(readFileSync(path, "utf8")); }
-  catch { return null; }
-}
-
-function saveState(state) {
-  const dir = uploadStateDir();
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  chmodSync(dir, 0o700);
-  const diskState = { ...state };
-  delete diskState.parts;
-  const path = join(dir, `${state.upload_id}.json`);
-  writeFileSync(path, JSON.stringify(diskState, null, 2), { mode: 0o600 });
-  chmodSync(path, 0o600);
-}
-
-function removeState(uploadId) {
-  const path = join(uploadStateDir(), `${uploadId}.json`);
-  if (existsSync(path)) unlinkSync(path);
-}
-
-function fileFingerprint(stat) {
-  return {
-    file_size: stat.size,
-    file_mtime_ms: stat.mtimeMs,
-  };
-}
-
-function stateMatchesFile(state, fingerprint) {
-  return state.file_size === fingerprint.file_size &&
-    typeof state.file_mtime_ms === "number" &&
-    state.file_mtime_ms === fingerprint.file_mtime_ms;
-}
-
-function findResumableStateForFile(projectId, localPath, key, fingerprint) {
-  const dir = uploadStateDir();
-  if (!existsSync(dir)) return null;
-  for (const f of readdirSync(dir)) {
-    if (!f.endsWith(".json")) continue;
-    try {
-      const s = JSON.parse(readFileSync(join(dir, f), "utf8"));
-      if (s.project_id === projectId && s.local_path === localPath && s.key === key) {
-        if (stateMatchesFile(s, fingerprint)) return s;
-        removeState(s.upload_id);
-      }
-    } catch { /* ignore */ }
-  }
-  return null;
-}
-
 // ---------------------------------------------------------------------------
 // put
 // ---------------------------------------------------------------------------
 
 async function putOne(projectId, filePath, opts) {
   const stat = statSync(filePath);
-  const size = stat.size;
-  const fingerprint = fileFingerprint(stat);
-  const destKey = computeDestKey(filePath, opts.key);
-  const absLocal = resolvePath(filePath);
-
-  const sha256 = await sha256File(filePath);
-
-  // Attempt to resume
-  let state = opts.resume
-    ? findResumableStateForFile(projectId, absLocal, destKey, fingerprint)
-    : null;
-  let initRes;
-  if (state) {
-    // Re-poll the session; if it's still active, resume. Otherwise start fresh.
-    const poll = await getSdk().assets.getUploadSession(projectId, state.upload_id);
-    if (poll.status === "active") {
-      log(opts, { event: "resume", upload_id: state.upload_id, key: destKey });
-      initRes = {
-        upload_id: state.upload_id,
-        mode: poll.mode ?? state.mode,
-        parts: poll.parts ?? state.parts ?? [],
-        part_count: poll.part_count ?? state.part_count,
-        part_size_bytes: poll.part_size_bytes ?? state.part_size_bytes,
-      };
-    } else {
-      removeState(state.upload_id);
-      state = null;
-    }
+  if (!stat.isFile()) {
+    die(`Not a regular file: ${filePath}`);
   }
+  const destKey = computeDestKey(filePath, opts.key);
 
-  if (!state) {
-    initRes = await getSdk().assets.initUploadSession(projectId, {
-      key: destKey,
-      size_bytes: size,
-      content_type: opts.contentType ?? guessContentType(destKey),
-      visibility: opts.private ? "private" : "public",
-      immutable: opts.immutable,
-      sha256,
-    });
-    state = {
-      upload_id: initRes.upload_id,
-      project_id: projectId,
-      local_path: absLocal,
-      key: destKey,
-      mode: initRes.mode,
-      part_size_bytes: initRes.part_size_bytes,
-      part_count: initRes.part_count,
-      parts: initRes.parts,
-      parts_done: {},
-      sha256,
-      ...fingerprint,
-      started_at: new Date().toISOString(),
-    };
-    if (opts.resume) saveState(state);
-  }
-
-  // Upload parts with concurrency limit. For single-PUT mode part_count=1 and
-  // this loop runs once.
-  const etags = Array(initRes.part_count);
-  for (const pn of Object.keys(state.parts_done || {})) {
-    const pd = state.parts_done[pn];
-    // Legacy resume state stored just the etag string; new code stores
-    // { etag, sha256 }. Normalize on load.
-    etags[parseInt(pn, 10) - 1] = typeof pd === "string" ? { etag: pd, sha256: undefined } : pd;
-  }
-
-  const todo = initRes.parts.filter((p) => !(state.parts_done || {})[String(p.part_number)]);
-  await withConcurrency(todo, opts.concurrency, async (part) => {
-    const { etag, sha256: partSha256 } = await putPart(filePath, part);
-    etags[part.part_number - 1] = { etag, sha256: partSha256 };
-    state.parts_done[String(part.part_number)] = { etag, sha256: partSha256 };
-    if (opts.resume) saveState(state);
-    log(opts, { event: "part", upload_id: state.upload_id, part_number: part.part_number, etag, sha256: partSha256 });
-  });
-
-  // Complete
-  const body = initRes.mode === "multipart"
-    ? { parts: etags.map((e, i) => ({ part_number: i + 1, etag: e.etag, sha256: e.sha256 })) }
-    : {};
-  const result = await getSdk().assets.completeUploadSession(projectId, state.upload_id, body, {
+  // v2.1.0: the legacy /storage/v1/uploads* session API is gone. The CLI
+  // now delegates to `sdk.assets.put`, which routes through the
+  // unified-apply hero (apply/v1/plans -> content/v1/plans -> S3 PUT ->
+  // commit).
+  //
+  // Trade-off vs v2.0.x: resumable uploads via persisted state under
+  // ~/.run402/uploads/ are no longer supported. Resume semantics now live
+  // at the apply-plan level (24h plan TTL); a future CLI redesign can
+  // expose that. The --concurrency and --no-resume flags are accepted but
+  // ignored — the SDK upload paths handle parallelism internally.
+  log(opts, { event: "start", key: destKey, size_bytes: stat.size });
+  const bytes = new Uint8Array(readFileSync(filePath));
+  const result = await getSdk().assets.put(projectId, destKey, { bytes }, {
     contentType: opts.contentType ?? guessContentType(destKey),
+    visibility: opts.private ? "private" : "public",
+    immutable: opts.immutable,
   });
-
-  removeState(state.upload_id);
   log(opts, { event: "done", ...result });
   return result;
 }
@@ -432,40 +282,6 @@ function computeDestKey(filePath, keyOpt) {
   return keyOpt;
 }
 
-async function putPart(filePath, part) {
-  const start = part.byte_start ?? 0;
-  const end = part.byte_end ?? (statSync(filePath).size - 1);
-  const stream = createReadStream(filePath, { start, end });
-  const chunks = [];
-  for await (const c of stream) chunks.push(c);
-  const body = Buffer.concat(chunks);
-  const checksum = sha256BufferHexAndBase64(body);
-
-  const res = await fetch(part.url, {
-    method: "PUT",
-    headers: checksumHeadersForPresignedUrl(part.url, checksum.base64),
-    body,
-  });
-  if (!res.ok) {
-    const errBody = await res.text().catch(() => "");
-    throw new Error(`Part ${part.part_number} PUT failed: ${res.status} ${res.statusText}${errBody ? " — " + errBody.slice(0, 200) : ""}`);
-  }
-  const etag = res.headers.get("etag") ?? "";
-  return { etag, sha256: checksum.hex };
-}
-
-async function withConcurrency(items, limit, worker) {
-  let index = 0;
-  const workerCount = Math.min(limit, items.length);
-  async function runWorker() {
-    while (index < items.length) {
-      const item = items[index++];
-      await worker(item);
-    }
-  }
-  await Promise.all(Array.from({ length: workerCount }, runWorker));
-}
-
 async function put(projectId, argv) {
   const opts = parseArgs(argv);
   opts.project = opts.project || projectId;

package/lib/jobs.mjs

@@ -0,0 +1,308 @@
+import { readFileSync } from "node:fs";
+
+import { getSdk } from "./sdk.mjs";
+import { resolveProjectId } from "./config.mjs";
+import { reportSdkError, fail } from "./sdk-errors.mjs";
+import {
+  assertKnownFlags,
+  flagValue,
+  normalizeArgv,
+  parseIntegerFlag,
+  requirePositionalCount,
+  validateRegularFile,
+} from "./argparse.mjs";
+
+const HELP = `run402 jobs — Submit and inspect fixed platform-managed jobs
+
+Usage:
+  run402 jobs <subcommand> [args...] [options]
+
+Subcommands:
+  submit   --file <path>|--stdin   Submit a managed job request
+  get      <job_id>                Get a job run
+  logs     <job_id>                Read job logs
+  cancel   <job_id>                Cancel a queued or running job
+
+Examples:
+  run402 jobs submit --file job.json
+  cat job.json | run402 jobs submit --stdin --project prj_abc123
+  run402 jobs get job_abc123
+  run402 jobs logs job_abc123 --tail 100
+  run402 jobs cancel job_abc123
+
+Notes:
+  - --project defaults to the active project from 'run402 projects use'
+  - Submit requests must match the gateway jobs API shape
+`;
+
+const SUB_HELP = {
+  submit: `run402 jobs submit — Submit a managed job request
+
+Usage:
+  run402 jobs submit --file <path> [--project <id>]
+  run402 jobs submit --stdin [--project <id>]
+
+Options:
+  --file <path>     Read the JSON submit request from a file
+  --stdin           Read the JSON submit request from stdin
+  --project <id>    Project ID (defaults to the active project)
+
+Example request:
+  {
+    "job_type": "kysigned.fflonk_prove.v0_17_0",
+    "input": { "input.json": {} },
+    "max_cost_usd_micros": 50000
+  }
+`,
+  get: `run402 jobs get — Get a managed job run
+
+Usage:
+  run402 jobs get <job_id> [--project <id>]
+
+Options:
+  --project <id>    Project ID (defaults to the active project)
+`,
+  logs: `run402 jobs logs — Read managed job logs
+
+Usage:
+  run402 jobs logs <job_id> [--project <id>] [--tail <n>] [--since <epoch_ms>]
+
+Options:
+  --project <id>    Project ID (defaults to the active project)
+  --tail <n>        Maximum entries to return (gateway max: 1000)
+  --since <ms>      Only include logs at or after this epoch millisecond timestamp
+`,
+  cancel: `run402 jobs cancel — Cancel a managed job run
+
+Usage:
+  run402 jobs cancel <job_id> [--project <id>]
+
+Options:
+  --project <id>    Project ID (defaults to the active project)
+`,
+};
+
+const PROJECT_FLAGS = ["--project"];
+
+function parseJsonRequest(raw, source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    fail({
+      code: "BAD_JSON",
+      message: `${source} is not valid JSON`,
+      details: {
+        source,
+        parse_error: err instanceof Error ? err.message : String(err),
+      },
+    });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    fail({
+      code: "BAD_JSON",
+      message: `${source} must contain a JSON object`,
+      details: { source },
+    });
+  }
+  return parsed;
+}
+
+async function readStdinText() {
+  if (process.stdin?.isTTY) {
+    fail({
+      code: "BAD_USAGE",
+      message: "Missing JSON request on stdin.",
+      hint: "Pipe a job request JSON object, or use --file <path>.",
+    });
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  if (chunks.length === 0) {
+    fail({
+      code: "BAD_USAGE",
+      message: "Missing JSON request on stdin.",
+      hint: "Pipe a job request JSON object, or use --file <path>.",
+    });
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+async function readSubmitRequest(args) {
+  const file = flagValue(args, "--file");
+  const stdin = args.includes("--stdin");
+  if (file && stdin) {
+    fail({
+      code: "BAD_USAGE",
+      message: "Provide exactly one request source.",
+      hint: "Use either --file <path> or --stdin.",
+    });
+  }
+  if (!file && !stdin) {
+    fail({
+      code: "BAD_USAGE",
+      message: "Missing job request source.",
+      hint: "Use --file <path> or --stdin.",
+    });
+  }
+  if (file) {
+    validateRegularFile(file, "--file");
+    return parseJsonRequest(readFileSync(file, "utf-8"), file);
+  }
+  return parseJsonRequest(await readStdinText(), "stdin");
+}
+
+async function submit(args = []) {
+  const parsed = normalizeArgv(args);
+  const valueFlags = ["--file", "--project"];
+  assertKnownFlags(parsed, ["--file", "--stdin", "--project", "--help", "-h"], valueFlags);
+  requirePositionalCount(parsed, valueFlags, {
+    max: 0,
+    command: "run402 jobs submit",
+  });
+  const projectId = resolveProjectId(flagValue(parsed, "--project"));
+  const request = await readSubmitRequest(parsed);
+
+  try {
+    const result = await getSdk().jobs.submit(projectId, request);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    reportSdkError(err);
+  }
+}
+
+async function get(jobId, args = []) {
+  const parsed = normalizeArgv(args);
+  assertKnownFlags(parsed, ["--project", "--help", "-h"], PROJECT_FLAGS);
+  if (!jobId) {
+    fail({
+      code: "BAD_USAGE",
+      message: "Missing job_id.",
+      hint: "Use `run402 jobs get <job_id>`.",
+    });
+  }
+  requirePositionalCount(parsed, PROJECT_FLAGS, {
+    max: 0,
+    command: "run402 jobs get <job_id>",
+  });
+  const projectId = resolveProjectId(flagValue(parsed, "--project"));
+
+  try {
+    const result = await getSdk().jobs.get(projectId, jobId);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    reportSdkError(err);
+  }
+}
+
+async function logs(jobId, args = []) {
+  const parsed = normalizeArgv(args);
+  const valueFlags = ["--project", "--tail", "--since"];
+  assertKnownFlags(parsed, ["--project", "--tail", "--since", "--help", "-h"], valueFlags);
+  if (!jobId) {
+    fail({
+      code: "BAD_USAGE",
+      message: "Missing job_id.",
+      hint: "Use `run402 jobs logs <job_id>`.",
+    });
+  }
+  requirePositionalCount(parsed, valueFlags, {
+    max: 0,
+    command: "run402 jobs logs <job_id>",
+  });
+  const projectId = resolveProjectId(flagValue(parsed, "--project"));
+  const opts = {};
+  const tail = flagValue(parsed, "--tail");
+  const since = flagValue(parsed, "--since");
+  if (tail !== null) opts.tail = parseIntegerFlag("--tail", tail, { min: 1, max: 1000 });
+  if (since !== null) opts.since = parseIntegerFlag("--since", since, { min: 0 });
+
+  try {
+    const result = await getSdk().jobs.logs(projectId, jobId, opts);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    reportSdkError(err);
+  }
+}
+
+async function cancel(jobId, args = []) {
+  const parsed = normalizeArgv(args);
+  assertKnownFlags(parsed, ["--project", "--help", "-h"], PROJECT_FLAGS);
+  if (!jobId) {
+    fail({
+      code: "BAD_USAGE",
+      message: "Missing job_id.",
+      hint: "Use `run402 jobs cancel <job_id>`.",
+    });
+  }
+  requirePositionalCount(parsed, PROJECT_FLAGS, {
+    max: 0,
+    command: "run402 jobs cancel <job_id>",
+  });
+  const projectId = resolveProjectId(flagValue(parsed, "--project"));
+
+  try {
+    const result = await getSdk().jobs.cancel(projectId, jobId);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    reportSdkError(err);
+  }
+}
+
+function splitJobIdArg(args = [], valueFlags = []) {
+  const flagsWithValues = new Set(valueFlags);
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (flagsWithValues.has(arg)) {
+      i += 1;
+      continue;
+    }
+    if (typeof arg === "string" && arg.startsWith("-")) continue;
+    return {
+      jobId: arg,
+      rest: [...args.slice(0, i), ...args.slice(i + 1)],
+    };
+  }
+  return { jobId: undefined, rest: args };
+}
+
+export async function run(sub, args = []) {
+  if (!sub || sub === "--help" || sub === "-h") {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (Array.isArray(args) && (args.includes("--help") || args.includes("-h"))) {
+    console.log(SUB_HELP[sub] || HELP);
+    process.exit(0);
+  }
+
+  switch (sub) {
+    case "submit":
+      await submit(args);
+      break;
+    case "get": {
+      const parsed = normalizeArgv(args);
+      const { jobId, rest } = splitJobIdArg(parsed, PROJECT_FLAGS);
+      await get(jobId, rest);
+      break;
+    }
+    case "logs": {
+      const parsed = normalizeArgv(args);
+      const { jobId, rest } = splitJobIdArg(parsed, ["--project", "--tail", "--since"]);
+      await logs(jobId, rest);
+      break;
+    }
+    case "cancel": {
+      const parsed = normalizeArgv(args);
+      const { jobId, rest } = splitJobIdArg(parsed, PROJECT_FLAGS);
+      await cancel(jobId, rest);
+      break;
+    }
+    default:
+      console.error(`Unknown subcommand: ${sub}\n`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "run402",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "CLI for Run402 — provision Postgres databases, deploy static sites, generate images, and manage wallets via x402 and MPP micropayments.",
   "type": "module",
   "bin": {

package/sdk/dist/index.d.ts

@@ -26,6 +26,7 @@ import { Contracts } from "./namespaces/contracts.js";
 import { Admin } from "./namespaces/admin.js";
 import { Deploy } from "./namespaces/deploy.js";
 import { Ci } from "./namespaces/ci.js";
+import { Jobs } from "./namespaces/jobs.js";
 import type { ContentSource, FileSet } from "./namespaces/deploy.types.js";
 import { ScopedRun402 } from "./scoped.js";
 export interface Run402Options {
@@ -70,6 +71,7 @@ export declare class Run402 {
      */
     readonly _applyEngine: Deploy;
     readonly ci: Ci;
+    readonly jobs: Jobs;
     constructor(opts: Run402Options);
     /**
      * Return a project-scoped sub-client where every project-id-bearing namespace
@@ -151,6 +153,7 @@ export type { ByteReader } from "./namespaces/deploy.js";
 export type * from "./namespaces/domains.js";
 export type * from "./namespaces/email.js";
 export type * from "./namespaces/functions.types.js";
+export type * from "./namespaces/jobs.js";
 export type * from "./namespaces/projects.types.js";
 export type * from "./namespaces/secrets.js";
 export type * from "./namespaces/sender-domain.js";