replicas-cli 0.3.103 → 0.3.104

package/dist/index.cjs

@@ -7363,9 +7363,9 @@ var require_dist = __commonJS({
 
 // src/index.ts
 var import_config20 = require("dotenv/config");
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 var import_commander = require("commander");
-var import_chalk31 = __toESM(require("chalk"));
+var import_chalk32 = __toESM(require("chalk"));
 
 // ../shared/src/urls.ts
 var DEFAULT_WEB_APP_URL = "https://app.replicas.dev";
@@ -22611,9 +22611,9 @@ var EXT_TO_LANGUAGE = {
 function detectLanguageByPath(filePath) {
   const dot = filePath.lastIndexOf(".");
   if (dot === -1) {
-    const basename = filePath.split("/").pop() ?? "";
-    if (basename === "Dockerfile") return "dockerfile";
-    if (basename === "Makefile") return "makefile";
+    const basename2 = filePath.split("/").pop() ?? "";
+    if (basename2 === "Dockerfile") return "dockerfile";
+    if (basename2 === "Makefile") return "makefile";
     return null;
   }
   const ext = filePath.slice(dot).toLowerCase();
@@ -24964,8 +24964,103 @@ var GITLAB_ABILITY = {
   referenceFile: { name: "GITLAB.md", content: REFERENCE5 }
 };
 
+// ../shared/src/routes/compute.ts
+var COMPUTE_SANDBOX_KINDS = ["gpu"];
+var GPU_TYPES = ["T4", "L4", "A10G", "L40S", "A100", "A100-80GB", "H100", "H200", "B200"];
+var DEFAULT_GPU_TYPE = "L4";
+var DEFAULT_GPU_IMAGE = "pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime";
+var COMPUTE_SANDBOX_WORKDIR = "/workspace";
+var COMPUTE_SANDBOX_LIMITS = {
+  maxActivePerWorkspace: 3,
+  maxActivePerOrganization: 10,
+  maxGpuCount: 8,
+  maxPorts: 5,
+  defaultTimeoutMinutes: 60,
+  maxTimeoutMinutes: 24 * 60,
+  defaultIdleTimeoutMinutes: 10,
+  maxIdleTimeoutMinutes: 60,
+  maxTransferBytes: 1024 ** 3
+};
+var computeEnvSchema = external_exports.record(external_exports.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), external_exports.string().max(32768)).refine((env) => Object.keys(env).length <= 64, "At most 64 environment variables are allowed");
+var createComputeSandboxRequestSchema = external_exports.object({
+  kind: external_exports.enum(COMPUTE_SANDBOX_KINDS),
+  gpu: external_exports.string().trim().optional(),
+  image: external_exports.string().trim().min(1).max(256).regex(/^\S+$/, "Image must not contain whitespace").optional(),
+  timeoutMinutes: external_exports.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTimeoutMinutes).optional(),
+  idleTimeoutMinutes: external_exports.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxIdleTimeoutMinutes).optional(),
+  ports: external_exports.array(external_exports.number().int().min(1).max(65535)).max(COMPUTE_SANDBOX_LIMITS.maxPorts).optional(),
+  env: computeEnvSchema.optional()
+});
+var computeExecRequestSchema = external_exports.object({
+  command: external_exports.string().min(1).max(1e5),
+  workdir: external_exports.string().min(1).max(4096).optional(),
+  env: computeEnvSchema.optional(),
+  detach: external_exports.boolean().optional()
+});
+
+// ../shared/src/default-skills/replicas-agent/abilities/gpu.ts
+var SECTION6 = `### GPU sandboxes
+Run GPU workloads (training, inference, CUDA builds, rendering) on cloud GPU sandboxes with \`replicas gpu\`. The workspace itself has no GPU.
+
+**Reference:** \`references/GPU.md\`
+
+Use this when:
+- A task needs a GPU: training or fine-tuning, model inference, CUDA code, benchmarks, or GPU rendering
+- You need to verify GPU code actually runs instead of only writing it`;
+var REFERENCE6 = `# GPU sandboxes
+
+\`replicas gpu\` starts cloud GPU sandboxes and runs commands in them. It is authenticated automatically, and usage is billed at cost to the organization, so stop sandboxes when you are done.
+
+## One-shot runs
+
+\`\`\`bash
+replicas gpu run --gpu H100 --pull outputs -- python train.py
+\`\`\`
+
+This starts a sandbox, copies the current directory to \`${COMPUTE_SANDBOX_WORKDIR}\` (git repositories honor \`.gitignore\`), streams the command's output, copies \`${COMPUTE_SANDBOX_WORKDIR}/outputs\` back to \`./outputs\`, stops the sandbox, and exits with the command's exit code. Add \`--keep\` to leave it running.
+
+## Interactive sessions
+
+\`\`\`bash
+replicas gpu create --gpu A100-80GB --timeout 3h   # waits until running
+replicas gpu push                                  # . -> ${COMPUTE_SANDBOX_WORKDIR}
+replicas gpu exec -- nvidia-smi
+replicas gpu exec -- pip install -r requirements.txt
+replicas gpu exec --detach -- python train.py      # prints a job ID
+replicas gpu logs <jobId> -f                       # streams until the job exits
+replicas gpu pull ${COMPUTE_SANDBOX_WORKDIR}/checkpoints ./
+replicas gpu delete
+\`\`\`
+
+- Commands run with \`sh -c\` in \`${COMPUTE_SANDBOX_WORKDIR}\`; quote shell operators: \`replicas gpu exec -- "cd src && make"\`.
+- \`--sandbox <id>\` picks a sandbox when more than one is running; \`replicas gpu list\` shows them.
+- Use \`--detach\` and \`logs -f\` for anything longer than a few minutes. A foreground \`exec\` dies with its connection.
+- \`--port 8000\` on create exposes a container port as a public HTTPS URL (shown by \`list\`).
+- \`--env KEY=value\` passes secrets such as \`HF_TOKEN\`; never bake them into files you push.
+
+## Choosing hardware and images
+
+- GPUs: ${GPU_TYPES.join(", ")} (default ${DEFAULT_GPU_TYPE}). Add a count for multi-GPU, e.g. \`H100:4\` (max ${COMPUTE_SANDBOX_LIMITS.maxGpuCount}). Pick the smallest GPU that fits: T4/L4 for small models and smoke tests, A100/H100 for real training.
+- Default image: \`${DEFAULT_GPU_IMAGE}\`. Pass any public registry image with \`--image\`; the first start of a new image takes a few minutes to pull.
+- The sandbox has internet access. Download datasets and weights inside it rather than pushing them; pushes and pulls are capped at ${COMPUTE_SANDBOX_LIMITS.maxTransferBytes / 1024 ** 3} GiB.
+
+## Limits
+
+- ${COMPUTE_SANDBOX_LIMITS.maxActivePerWorkspace} running sandboxes per workspace and ${COMPUTE_SANDBOX_LIMITS.maxActivePerOrganization} per organization
+- Lifetime 1 hour by default, up to 24 hours with \`--timeout\`
+- Sandboxes stop after 10 minutes with no running command (\`--idle-timeout\`, up to 1 hour)
+- Sandboxes stop when this workspace sleeps, is archived, or is deleted, and their files are lost; pull results before finishing
+`;
+var GPU_ABILITY = {
+  label: "GPU sandboxes",
+  description: "Run training, inference, and other GPU workloads on cloud GPUs with `replicas gpu`.",
+  bullet: "- Running GPU workloads (training, inference, CUDA, rendering) on cloud GPU sandboxes with `replicas gpu`",
+  section: SECTION6,
+  referenceFile: { name: "GPU.md", content: REFERENCE6 }
+};
+
 // ../shared/src/default-skills/replicas-agent/abilities/linear.ts
-var SECTION6 = `### Linear
+var SECTION7 = `### Linear
 Create tickets, fetch issues, update state, add comments, and search through \`replicas.linear.graphql\` in \`@replicas/sdk\`. This works without a Linear MCP server and refreshes authentication automatically.
 
 **Reference:** \`references/LINEAR.md\`
@@ -24976,7 +25071,7 @@ Use this when:
 - You need to update an issue's state or add a comment
 - You need to search Linear issues
 - A Linear request failed with an authentication error`;
-var REFERENCE6 = `# Linear Integration
+var REFERENCE7 = `# Linear Integration
 
 Use \`@replicas/sdk\`; never request or handle a Linear OAuth token. Replicas refreshes the organization credential behind the gateway.
 
@@ -25069,12 +25164,12 @@ var LINEAR_ABILITY = {
   label: "Linear",
   description: "Create tickets, fetch issues, comment, and update state through @replicas/sdk.",
   bullet: "- Interacting with Linear (creating tickets, fetching issues including any linear.app link the user shares, updating state, commenting, or troubleshooting authentication): use replicas.linear.graphql from @replicas/sdk, which refreshes tokens automatically and needs no Linear MCP server. Read references/LINEAR.md before treating a rejected workspace token as a disconnected integration.",
-  section: SECTION6,
-  referenceFile: { name: "LINEAR.md", content: REFERENCE6 }
+  section: SECTION7,
+  referenceFile: { name: "LINEAR.md", content: REFERENCE7 }
 };
 
 // ../shared/src/default-skills/replicas-agent/abilities/media.ts
-var SECTION7 = `### Media
+var SECTION8 = `### Media
 Deliver screenshots, GIFs, screen recordings, generated diagrams, audio clips, and self-contained HTML pages to the Replicas dashboard and, when applicable, inline in the destination workflow.
 
 **Reference:** \`references/MEDIA.md\`
@@ -25086,7 +25181,7 @@ Use this when:
 - You produce a self-contained HTML report that should be linked from a pull request
 - You record video output (browser automation, screen capture) \u2014 including the recommended aspect ratio and FPS
 - You need to embed media in a Slack/Linear/GitHub/GitLab message AND keep a referenceable copy in the Replicas dashboard`;
-var REFERENCE7 = `# Media (Screenshots, GIFs, Recordings, Audio, HTML)
+var REFERENCE8 = `# Media (Screenshots, GIFs, Recordings, Audio, HTML)
 
 This is the single source of truth for delivering screenshots, GIFs, screen recordings, generated diagrams, audio clips, and self-contained HTML pages through Replicas and external surfaces (Slack, Linear, GitHub, GitLab).
 
@@ -25466,12 +25561,12 @@ var MEDIA_ABILITY = {
   label: "Media",
   description: "Deliver media to Replicas and destination workflows with inline uploads.",
   bullet: "- Producing or showing the user any media \u2014 screenshots, screen recordings, generated images or diagrams, audio clips, or HTML recap pages \u2014 including in your Replicas chat reply, PR descriptions/comments, and other external platforms. Paste the printed `![\u2026](\u2026)` embeds in your chat reply, never only dashboard links, and upload the file itself to Slack, Linear, or GitLab. To show motion, turn the recording into a short GIF with `replicas media gif` instead of a grid of frames",
-  section: SECTION7,
-  referenceFile: { name: "MEDIA.md", content: REFERENCE7 }
+  section: SECTION8,
+  referenceFile: { name: "MEDIA.md", content: REFERENCE8 }
 };
 
 // ../shared/src/default-skills/replicas-agent/abilities/previews.ts
-var SECTION8 = `### Previews
+var SECTION9 = `### Previews
 Expose locally running services (web apps, APIs, databases) as public preview URLs so humans can interact with them directly.
 
 **Reference:** \`references/PREVIEWS.md\`
@@ -25481,7 +25576,7 @@ Use this when:
 - The task involves UI work that benefits from human review
 - You are verifying frontend/backend integrations visually
 - You need a URL for OAuth redirects, GitHub App callbacks, or webhooks (never the sandbox's \`*.e2b.app\` address)`;
-var REFERENCE8 = `# Preview URLs
+var REFERENCE9 = `# Preview URLs
 
 When you run services on ports \u2014 such as a web app, API server, or database \u2014 humans may want to interact with them directly. You can expose your locally running services as public preview URLs.
 
@@ -25570,12 +25665,12 @@ var PREVIEWS_ABILITY = {
   label: "Previews",
   description: "Expose locally running services on public preview URLs for humans.",
   bullet: "- Creating preview URLs for locally running services, including OAuth redirect, app callback, and webhook URLs (never a raw `*.e2b.app` address)",
-  section: SECTION8,
-  referenceFile: { name: "PREVIEWS.md", content: REFERENCE8 }
+  section: SECTION9,
+  referenceFile: { name: "PREVIEWS.md", content: REFERENCE9 }
 };
 
 // ../shared/src/default-skills/replicas-agent/abilities/plugins.ts
-var SECTION9 = `### Plugins
+var SECTION10 = `### Plugins
 Discover and execute installed marketplace tools through the workspace-scoped TypeScript SDK.
 
 **Reference:** \`references/PLUGINS.md\`
@@ -25594,7 +25689,7 @@ Use this when:
 - The user asks to read, triage, label, or draft replies to LinkedIn messages through Kondo
 - The user asks to query Sazabi logs, investigate Sazabi issues, or ask the Sazabi agent about production
 - The user asks to analyze text with Pangram`;
-var REFERENCE9 = `# Plugins
+var REFERENCE10 = `# Plugins
 
 Plugins are TypeScript libraries, not MCP servers. Import \`@replicas/sdk\`; Replicas authenticates the workspace and selects the most specific environment the workspace inherits from, then Global. Provider credentials, sessions, and project keys are never exposed.
 
@@ -25800,12 +25895,12 @@ var PLUGINS_ABILITY = {
   label: "Plugins",
   description: "Use installed marketplace tools through @replicas/sdk.",
   bullet: "- Interacting with installed marketplace plugins through TypeScript",
-  section: SECTION9,
-  referenceFile: { name: "PLUGINS.md", content: REFERENCE9 }
+  section: SECTION10,
+  referenceFile: { name: "PLUGINS.md", content: REFERENCE10 }
 };
 
 // ../shared/src/default-skills/replicas-agent/abilities/replicas.ts
-var SECTION10 = `### Replicas (in-workspace CLI)
+var SECTION11 = `### Replicas (in-workspace CLI)
 Take action *with* Replicas itself \u2014 manage automations, environments (variables, files), repos, and \`replicas.json\` config \u2014 using the pre-installed, pre-authenticated \`replicas\` CLI.
 
 **Reference:** \`references/REPLICAS.md\`
@@ -25817,7 +25912,7 @@ Use this when:
 - The user asks "what envs / repos / automations do I have?"
 - The user asks you to scaffold a \`replicas.json\` / \`replicas.yaml\` in a repo
 - You need to run a long-lived service (dev server, daemon) \u2014 always use \`replicas service start\` so it survives workspace sleep/wake`;
-var REFERENCE10 = `# Replicas (in-workspace CLI)
+var REFERENCE11 = `# Replicas (in-workspace CLI)
 
 This guide covers how to take action *with* Replicas itself from inside a Replicas workspace \u2014 managing automations, environments (and their variables/files), repos, previews, and the user's \`replicas.json\` config \u2014 using the pre-installed \`replicas\` CLI.
 
@@ -26078,13 +26173,13 @@ var REPLICAS_ABILITY = {
   description: "Teach the agent about Replicas itself \u2014 automations, environments, the in-workspace CLI.",
   // No bullet — help_instructions covers the `replicas` CLI surface in detail.
   bullet: "",
-  section: SECTION10,
-  referenceFile: { name: "REPLICAS.md", content: REFERENCE10 },
+  section: SECTION11,
+  referenceFile: { name: "REPLICAS.md", content: REFERENCE11 },
   locked: true
 };
 
 // ../shared/src/default-skills/replicas-agent/abilities/sentry.ts
-var SECTION11 = `### Sentry
+var SECTION12 = `### Sentry
 Read issues and project data through the workspace-scoped TypeScript SDK.
 
 **Reference:** \`references/SENTRY.md\`
@@ -26093,7 +26188,7 @@ Use this when:
 - A user shares a sentry.io link
 - You need to inspect Sentry projects or issues
 - A user asks for error-monitoring context outside a webhook-triggered task`;
-var REFERENCE11 = `# Sentry Integration
+var REFERENCE12 = `# Sentry Integration
 
 Use \`@replicas/sdk\`; never request or read a Sentry token. Sentry access is organization-scoped and read-only.
 
@@ -26122,8 +26217,8 @@ var SENTRY_ABILITY = {
   label: "Sentry",
   description: "Read Sentry projects and issues through @replicas/sdk.",
   bullet: "- Interacting with Sentry (reading projects, issues, and error context, including any sentry.io link the user shares): use replicas.sentry.request from @replicas/sdk. Read references/SENTRY.md to turn an issue link into API paths.",
-  section: SECTION11,
-  referenceFile: { name: "SENTRY.md", content: REFERENCE11 }
+  section: SECTION12,
+  referenceFile: { name: "SENTRY.md", content: REFERENCE12 }
 };
 
 // ../shared/src/memory.ts
@@ -26131,11 +26226,11 @@ var HISTORY_ROOT = `${SANDBOX_PATHS.REPLICAS_DIR}/history`;
 var HISTORY_INDEX_FILENAME = "INDEX.md";
 
 // ../shared/src/default-skills/replicas-agent/abilities/session-history.ts
-var SECTION12 = `### Session history
+var SECTION13 = `### Session history
 Search past agent sessions in this organization when the user refers to prior work, a date, a teammate's session, or "last time".
 
 **Reference:** \`references/SESSION-HISTORY.md\``;
-var REFERENCE12 = `# Session history
+var REFERENCE13 = `# Session history
 
 Past sessions are installed under \`${HISTORY_ROOT}\`:
 
@@ -26164,8 +26259,8 @@ var SESSION_HISTORY_ABILITY = {
   label: "Session history",
   description: "Search past agent sessions in this organization.",
   bullet: "",
-  section: SECTION12,
-  referenceFile: { name: "SESSION-HISTORY.md", content: REFERENCE12 },
+  section: SECTION13,
+  referenceFile: { name: "SESSION-HISTORY.md", content: REFERENCE13 },
   locked: true
 };
 
@@ -26176,7 +26271,7 @@ var SLACK_BLOCK_KIT_GUIDANCE = "Use Block Kit whenever structure or a link would
 var SLACK_PR_BUTTON_GUIDANCE = 'The first time you share a given pull request or merge request link in a thread \u2014 the message announcing you opened it \u2014 attach a button for it: send `blocks` alongside `text` \u2014 a `section` block holding your message as `mrkdwn`, then an `actions` block with one element per newly shared link, `{"type": "button", "style": "primary", "text": {"type": "plain_text", "text": "View PR"}, "url": "<pr url>", "action_id": "view_pr"}`. Later messages about a pull request you already linked in this thread keep the link in the sentence and get no button, and never re-post a button for a link someone already has. Label it "View MR" for GitLab, and if there are several give each button a unique `action_id` and name its repository in the label ("View PR \xB7 web"). Always keep `text` populated with the same message \u2014 Slack uses it for notifications and fallback \u2014 and keep the link in the sentence too.';
 
 // ../shared/src/default-skills/replicas-agent/abilities/slack.ts
-var SECTION13 = `### Slack
+var SECTION14 = `### Slack
 Send messages, read threads, search conversations, and transfer files through the workspace-scoped TypeScript SDK.
 
 **Reference:** \`references/SLACK.md\`
@@ -26186,7 +26281,7 @@ Use this when:
 - You need to read or search Slack conversations
 - You need to download a file attached to a Slack message
 - You encounter a Slack message link and need its full thread`;
-var REFERENCE13 = `# Slack Integration
+var REFERENCE14 = `# Slack Integration
 
 Use \`@replicas/sdk\`; never read or send a Slack token directly. The SDK calls Replicas, which selects only this workspace's organization connection.
 
@@ -26264,8 +26359,8 @@ var SLACK_ABILITY = {
   label: "Slack",
   description: "Send messages, read threads, search, and transfer files through @replicas/sdk.",
   bullet: "- Interacting with Slack (listing channels, sending messages, reading threads, or searching): use replicas.slack.call from @replicas/sdk. Read references/SLACK.md; no Slack MCP server or provider token in the VM is required.",
-  section: SECTION13,
-  referenceFile: { name: "SLACK.md", content: REFERENCE13 }
+  section: SECTION14,
+  referenceFile: { name: "SLACK.md", content: REFERENCE14 }
 };
 
 // ../shared/src/default-skills/replicas-agent/registry.ts
@@ -26277,6 +26372,7 @@ var REPLICAS_AGENT_ABILITY_REGISTRY = {
   environment_setup: ENVIRONMENT_SETUP_ABILITY,
   github: GITHUB_ABILITY,
   gitlab: GITLAB_ABILITY,
+  gpu: GPU_ABILITY,
   linear: LINEAR_ABILITY,
   media: MEDIA_ABILITY,
   plugins: PLUGINS_ABILITY,
@@ -28669,7 +28765,7 @@ var headlessAgentRequestSchema = external_exports.object({
 });
 
 // ../shared/src/cli-version.ts
-var CLI_VERSION = "0.3.103";
+var CLI_VERSION = "0.3.104";
 
 // ../shared/src/version.ts
 function compareVersions(v1, v2) {
@@ -29931,7 +30027,7 @@ async function apiKeyLoginCommand(key) {
 }
 async function loginCommand() {
   const state = generateState();
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let authTimeout;
     let hasHandledCallback = false;
     let lastRedirectUrl = null;
@@ -30081,7 +30177,7 @@ async function loginCommand() {
           setImmediate(() => {
             server.closeAllConnections?.();
             server.close();
-            resolve2();
+            resolve3();
           });
         } catch (error52) {
           const errorUrl = `${WEB_APP_URL}/cli-login/error?message=${encodeURIComponent("Failed to verify authentication.")}`;
@@ -30321,7 +30417,7 @@ function buildSSHArgs(token, host, proxyCommand, localForward) {
   ];
 }
 async function connectSSH(token, host, proxyCommand, localForward) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const ssh = (0, import_child_process.spawn)("ssh", buildSSHArgs(token, host, proxyCommand, localForward), {
       stdio: "inherit"
     });
@@ -30329,7 +30425,7 @@ async function connectSSH(token, host, proxyCommand, localForward) {
       if (localForward && code) {
         reject(new Error(`SSH tunnel exited with code ${code}`));
       } else {
-        resolve2();
+        resolve3();
       }
     });
     ssh.on("error", reject);
@@ -30827,7 +30923,7 @@ async function exchangeCodeForTokens(code, codeVerifier) {
   };
 }
 function startCallbackServer(expectedState, codeVerifier, save) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const server = import_http2.default.createServer(async (req, res) => {
       try {
         if (!req.url) {
@@ -30871,7 +30967,7 @@ function startCallbackServer(expectedState, codeVerifier, save) {
             res.writeHead(302, { "Location": completionUrl });
             res.end();
             server.close();
-            resolve2();
+            resolve3();
           } catch (tokenError) {
             const errorMessage = encodeURIComponent(tokenError instanceof Error ? tokenError.message : "Unknown error");
             res.writeHead(302, { "Location": `${WEB_APP_URL2}/codex/oauth/error?message=${errorMessage}` });
@@ -30905,7 +31001,7 @@ async function runCodexOAuthFlow(totalSteps, save) {
   const state = generateState2();
   const authUrl = buildAuthorizationUrl(pkce.codeChallenge, state);
   const tokensPromise = startCallbackServer(state, pkce.codeVerifier, save);
-  await new Promise((resolve2) => setTimeout(resolve2, 500));
+  await new Promise((resolve3) => setTimeout(resolve3, 500));
   renderAuthFlowStep(1, totalSteps, "Approve access in your browser");
   await openForApproval("auth.openai.com", authUrl);
   renderAuthFlowDetail("waiting for sign-in\u2026");
@@ -31053,10 +31149,10 @@ async function promptForAuthorizationCode() {
   process.stdin.setRawMode(false);
   process.stdin.resume();
   const rl = import_readline.default.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
-    rl.on("close", () => resolve2(""));
+  return new Promise((resolve3) => {
+    rl.on("close", () => resolve3(""));
     rl.question(import_chalk15.default.gray("       Paste code here: "), (answer) => {
-      resolve2(answer.trim());
+      resolve3(answer.trim());
       rl.close();
     });
   });
@@ -31203,7 +31299,7 @@ async function runMuseOAuthFlow(totalSteps) {
   const deadline = Date.now() + (typeof device.expires_in === "number" ? device.expires_in : 900) * 1e3;
   let intervalMs = Math.max(1, typeof device.interval === "number" ? device.interval : 5) * 1e3;
   while (Date.now() < deadline) {
-    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, intervalMs));
     const response = await post("/oidc/device/token/", new URLSearchParams({
       grant_type: "urn:ietf:params:oauth:grant-type:device_code",
       device_code: device.device_code,
@@ -32861,7 +32957,7 @@ async function environmentSetupWaitVariablesCommand(options) {
   Waiting up to ${formatDuration(timeoutMs)} for: ${blocking(before).map((request) => request.key).join(", ")}`));
     const deadline = Date.now() + timeoutMs;
     while (blocking(run2.variable_requests).length > 0 && Date.now() < deadline) {
-      await new Promise((resolve2) => setTimeout(resolve2, ENVIRONMENT_SETUP_VARIABLE_WAIT.pollMs));
+      await new Promise((resolve3) => setTimeout(resolve3, ENVIRONMENT_SETUP_VARIABLE_WAIT.pollMs));
       run2 = (await fetchCurrentRun()).run;
     }
   }
@@ -33755,19 +33851,22 @@ async function agentRequest(path8, options) {
   if (!config3) {
     throw new Error("Agent mode config not found");
   }
-  const isFormData = options?.body instanceof FormData;
+  const rawBody = options?.body;
+  const isFormData = rawBody instanceof FormData;
+  const isStream = rawBody instanceof ReadableStream;
   const headers = {
     "Authorization": `Bearer ${config3.engine_secret}`,
     "X-Workspace-Id": config3.workspace_id,
     // FormData sets its own multipart Content-Type with boundary.
-    ...isFormData ? {} : { "Content-Type": "application/json" },
+    ...isFormData ? {} : { "Content-Type": isStream ? "application/octet-stream" : "application/json" },
     ...options?.headers || {}
   };
-  const body = options?.body === void 0 ? void 0 : isFormData ? options.body : JSON.stringify(options.body);
+  const body = rawBody === void 0 ? void 0 : rawBody instanceof FormData || rawBody instanceof ReadableStream ? rawBody : JSON.stringify(rawBody);
   const response = await fetch(`${MONOLITH_URL}${path8}`, {
     ...options,
     headers,
-    body
+    body,
+    ...isStream ? { duplex: "half" } : {}
   });
   if (!response.ok) {
     const error51 = await response.json().catch(() => ({ error: "Request failed" }));
@@ -34139,27 +34238,247 @@ async function mediaGifCommand(input, options) {
   );
 }
 
-// src/commands/history.ts
+// src/commands/gpu.ts
+var import_chalk28 = __toESM(require("chalk"));
+var import_node_child_process2 = require("child_process");
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
+var BASE = "/v1/engine/compute/sandboxes";
+var CREATE_POLL_INTERVAL_MS = 3e3;
+var CREATE_WAIT_TIMEOUT_MS = 25 * 6e4;
+function parseMinutes(value, flag) {
+  if (value === void 0) return void 0;
+  const match = value.trim().match(/^(\d+)(m|h)?$/);
+  if (!match) throw new Error(`${flag} must be minutes or a duration like 30m or 2h`);
+  return Number(match[1]) * (match[2] === "h" ? 60 : 1);
+}
+function parseEnv(values) {
+  return values?.length ? parseKeyValuePairs(values) : void 0;
+}
+function describe3(sandbox) {
+  console.log(`${import_chalk28.default.bold(sandbox.id)}  ${sandbox.status}  ${sandbox.gpu ?? "no GPU"}  ${sandbox.image}`);
+  console.log(import_chalk28.default.gray(`  expires ${new Date(sandbox.expiresAt).toLocaleString()}`));
+  for (const tunnel of sandbox.tunnels) console.log(`  port ${tunnel.port}: ${tunnel.url}`);
+  if (sandbox.error) console.log(import_chalk28.default.red(`  ${sandbox.error}`));
+}
+async function resolveSandboxId(options) {
+  if (options.sandbox) return options.sandbox;
+  const { sandboxes } = await agentFetch(BASE);
+  if (sandboxes.length === 1) return sandboxes[0].id;
+  if (sandboxes.length === 0) throw new Error('No GPU sandbox is running. Start one with "replicas gpu create".');
+  throw new Error(`Several GPU sandboxes are running; pick one with --sandbox: ${sandboxes.map((sandbox) => sandbox.id).join(", ")}`);
+}
+async function createSandbox(options) {
+  const request = {
+    kind: "gpu",
+    gpu: options.gpu,
+    image: options.image,
+    timeoutMinutes: parseMinutes(options.timeout, "--timeout"),
+    idleTimeoutMinutes: parseMinutes(options.idleTimeout, "--idle-timeout"),
+    ports: options.port?.map(parsePort),
+    env: parseEnv(options.env)
+  };
+  let { sandbox } = await agentFetch(BASE, { method: "POST", body: request });
+  if (options.wait === false) return sandbox;
+  process.stderr.write(import_chalk28.default.gray(`Starting ${sandbox.gpu} sandbox ${sandbox.id} (a new image can take a few minutes to pull)...
+`));
+  const deadline = Date.now() + CREATE_WAIT_TIMEOUT_MS;
+  while (sandbox.status === "creating") {
+    if (Date.now() > deadline) throw new Error(`GPU sandbox ${sandbox.id} is still starting; check it with "replicas gpu list"`);
+    await new Promise((done) => setTimeout(done, CREATE_POLL_INTERVAL_MS));
+    ({ sandbox } = await agentFetch(`${BASE}/${sandbox.id}`));
+  }
+  if (sandbox.status !== "running") throw new Error(`GPU sandbox failed to start: ${sandbox.error ?? "it stopped while starting"}`);
+  return sandbox;
+}
+async function gpuCreateCommand(options) {
+  output(await createSandbox(options), describe3);
+}
+async function gpuListCommand() {
+  const { sandboxes } = await agentFetch(BASE);
+  output(sandboxes, (list2) => {
+    if (list2.length === 0) console.log("No GPU sandboxes are running.");
+    list2.forEach(describe3);
+  });
+}
+async function gpuDeleteCommand(id, options) {
+  const sandboxId = id ?? await resolveSandboxId(options);
+  await agentRequest(`${BASE}/${sandboxId}`, { method: "DELETE" });
+  outputSuccess(`Stopped GPU sandbox ${sandboxId}`);
+}
+async function streamOutput(response) {
+  if (!response.body) throw new Error("Empty response from the GPU sandbox");
+  const decoder2 = new TextDecoder();
+  let buffer = "";
+  let exit;
+  const handle = (line) => {
+    if (!line.trim()) return;
+    const event = JSON.parse(line);
+    if (event.type === "stdout") (isJsonMode() ? process.stderr : process.stdout).write(event.data);
+    else if (event.type === "stderr") process.stderr.write(event.data);
+    else if (event.type === "error") throw new Error(event.message);
+    else if (event.type === "exit") exit = { exitCode: event.exitCode };
+  };
+  for await (const chunk of import_node_stream.Readable.fromWeb(response.body)) {
+    buffer += decoder2.decode(chunk, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    lines.forEach(handle);
+  }
+  handle(buffer + decoder2.decode());
+  if (!exit) {
+    throw new Error('Lost the connection to the GPU sandbox; the command may still be running. Use --detach and "replicas gpu logs -f" for long jobs.');
+  }
+  return exit.exitCode;
+}
+async function exec(sandboxId, command, options) {
+  return agentRequest(`${BASE}/${sandboxId}/exec`, {
+    method: "POST",
+    body: { command, workdir: options.workdir, env: parseEnv(options.env), detach: options.detach }
+  });
+}
+async function gpuExecCommand(command, options) {
+  if (command.length === 0) throw new Error("Pass a command after --, e.g. replicas gpu exec -- nvidia-smi");
+  const sandboxId = await resolveSandboxId(options);
+  const response = await exec(sandboxId, command.join(" "), options);
+  if (options.detach) {
+    const { jobId } = await response.json();
+    output({ jobId, sandboxId }, () => {
+      console.log(`Started job ${import_chalk28.default.bold(jobId)} in ${sandboxId}`);
+      console.log(import_chalk28.default.gray(`Follow it with: replicas gpu logs ${jobId} -f`));
+    });
+    return;
+  }
+  const exitCode = await streamOutput(response);
+  process.exitCode = exitCode ?? 1;
+  if (isJsonMode()) output({ sandboxId, exitCode }, () => {
+  });
+}
+async function gpuLogsCommand(jobId, options) {
+  const sandboxId = await resolveSandboxId(options);
+  const response = await agentRequest(`${BASE}/${sandboxId}/jobs/${jobId}/logs${options.follow ? "?follow=true" : ""}`);
+  const exitCode = await streamOutput(response);
+  if (isJsonMode()) {
+    if (options.follow && exitCode !== null) process.exitCode = exitCode;
+    output({ jobId, sandboxId, running: exitCode === null, exitCode }, () => {
+    });
+    return;
+  }
+  if (exitCode === null) {
+    process.stderr.write(import_chalk28.default.gray(`
+Job ${jobId} is still running.
+`));
+    return;
+  }
+  if (options.follow) process.exitCode = exitCode;
+  process.stderr.write(import_chalk28.default.gray(`
+Job ${jobId} exited with code ${exitCode}.
+`));
+}
+function assertTransferSize(bytes, localPath) {
+  if (bytes > COMPUTE_SANDBOX_LIMITS.maxTransferBytes) {
+    throw new Error(`${localPath} is larger than ${COMPUTE_SANDBOX_LIMITS.maxTransferBytes / 1024 ** 3} GiB. Download large datasets and weights inside the sandbox instead (it has internet access).`);
+  }
+}
+function archive(localPath) {
+  const path8 = (0, import_node_path2.resolve)(localPath);
+  if (!(0, import_node_fs2.existsSync)(path8)) throw new Error(`${path8} does not exist`);
+  if (!(0, import_node_fs2.statSync)(path8).isDirectory()) {
+    assertTransferSize((0, import_node_fs2.statSync)(path8).size, localPath);
+    return (0, import_node_child_process2.spawn)("tar", ["-czf", "-", "-C", (0, import_node_path2.dirname)(path8), (0, import_node_path2.basename)(path8)], { stdio: ["ignore", "pipe", "pipe"] });
+  }
+  const listed = (0, import_node_child_process2.spawnSync)("git", ["-C", path8, "ls-files", "-co", "--exclude-standard", "-z"], { maxBuffer: 256 * 1024 * 1024 });
+  if (listed.status !== 0) {
+    const du = (0, import_node_child_process2.spawnSync)("du", ["-sk", "--exclude=.git", "--exclude=node_modules", path8]);
+    assertTransferSize(Number(du.stdout.toString().split("	")[0]) * 1024, localPath);
+    return (0, import_node_child_process2.spawn)("tar", ["-czf", "-", "-C", path8, "--exclude=.git", "--exclude=node_modules", "."], { stdio: ["ignore", "pipe", "pipe"] });
+  }
+  const files = listed.stdout.toString().split("\0").filter((file2) => file2 && (0, import_node_fs2.existsSync)((0, import_node_path2.join)(path8, file2)));
+  assertTransferSize(files.reduce((total, file2) => total + (0, import_node_fs2.statSync)((0, import_node_path2.join)(path8, file2)).size, 0), localPath);
+  const child = (0, import_node_child_process2.spawn)("tar", ["-czf", "-", "-C", path8, "--null", "-T", "-"], { stdio: ["pipe", "pipe", "pipe"] });
+  child.stdin.end(files.map((file2) => `${file2}\0`).join(""));
+  return child;
+}
+async function push(sandboxId, localPath, remotePath) {
+  const tar = archive(localPath);
+  let stderr = "";
+  tar.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const exited = new Promise((done) => tar.on("close", done));
+  await agentRequest(`${BASE}/${sandboxId}/files?path=${encodeURIComponent(remotePath)}`, {
+    method: "PUT",
+    body: import_node_stream.Readable.toWeb(tar.stdout)
+  });
+  if (await exited !== 0) throw new Error(`Archiving ${localPath} failed: ${stderr.trim()}`);
+}
+async function gpuPushCommand(localPath = ".", remotePath = COMPUTE_SANDBOX_WORKDIR, options = {}) {
+  const sandboxId = await resolveSandboxId(options);
+  await push(sandboxId, localPath, remotePath);
+  outputSuccess(`Copied ${localPath} to ${remotePath} in ${sandboxId}`);
+}
+async function pull(sandboxId, remotePath, localPath) {
+  const response = await agentRequest(`${BASE}/${sandboxId}/files?path=${encodeURIComponent(remotePath)}`);
+  (0, import_node_fs2.mkdirSync)(localPath, { recursive: true });
+  const tar = (0, import_node_child_process2.spawn)("tar", ["-xzf", "-", "-C", localPath], { stdio: ["pipe", "ignore", "pipe"] });
+  let stderr = "";
+  tar.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const exited = new Promise((done) => tar.on("close", done));
+  await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(response.body), tar.stdin);
+  if (await exited !== 0) throw new Error(`Extracting ${remotePath} failed: ${stderr.trim()}`);
+}
+async function gpuPullCommand(remotePath, localPath = ".", options = {}) {
+  const sandboxId = await resolveSandboxId(options);
+  await pull(sandboxId, remotePath, localPath);
+  outputSuccess(`Copied ${remotePath} from ${sandboxId} into ${localPath}`);
+}
+async function gpuRunCommand(command, options) {
+  if (command.length === 0) throw new Error("Pass a command after --, e.g. replicas gpu run -- python train.py");
+  const { env, ...createOptions } = options;
+  const sandbox = await createSandbox({ ...createOptions, wait: true });
+  try {
+    process.stderr.write(import_chalk28.default.gray(`Copying ${process.cwd()} to ${COMPUTE_SANDBOX_WORKDIR}...
+`));
+    await push(sandbox.id, ".", COMPUTE_SANDBOX_WORKDIR);
+    const exitCode = await streamOutput(await exec(sandbox.id, command.join(" "), { env }));
+    for (const remotePath of options.pull ?? []) {
+      await pull(sandbox.id, remotePath.startsWith("/") ? remotePath : `${COMPUTE_SANDBOX_WORKDIR}/${remotePath}`, ".");
+    }
+    process.exitCode = exitCode ?? 1;
+    if (isJsonMode()) output({ sandboxId: sandbox.id, exitCode }, () => {
+    });
+  } finally {
+    if (options.keep) process.stderr.write(import_chalk28.default.gray(`Kept GPU sandbox ${sandbox.id} running.
+`));
+    else await agentRequest(`${BASE}/${sandbox.id}`, { method: "DELETE" });
+  }
+}
+
+// src/commands/history.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
 async function historyTranscriptCommand(name) {
   const session = name.trim().replace(/\.md$/, "");
   if (!/^[a-zA-Z0-9-]+$/.test(session)) {
     throw new Error(`Invalid session name '${name}'. Use the name from INDEX.md, e.g. 2026-01-31-<id>`);
   }
   const response = await agentRequest(`/v1/engine/history/transcripts/${session}`);
-  const dir = (0, import_node_path2.join)(HISTORY_ROOT, "transcripts");
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
-  const file2 = (0, import_node_path2.join)(dir, `${session}.jsonl`);
-  (0, import_node_fs2.writeFileSync)(file2, Buffer.from(await response.arrayBuffer()));
+  const dir = (0, import_node_path3.join)(HISTORY_ROOT, "transcripts");
+  (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+  const file2 = (0, import_node_path3.join)(dir, `${session}.jsonl`);
+  (0, import_node_fs3.writeFileSync)(file2, Buffer.from(await response.arrayBuffer()));
   output({ path: file2 }, () => console.log(file2));
 }
 
 // src/commands/skills.ts
-var import_node_fs3 = require("fs");
-var import_chalk28 = __toESM(require("chalk"));
+var import_node_fs4 = require("fs");
+var import_chalk29 = __toESM(require("chalk"));
 async function skillsSuggestCommand(file2, options) {
-  const body = { content: (0, import_node_fs3.readFileSync)(file2, "utf-8"), title: options.title };
+  const body = { content: (0, import_node_fs4.readFileSync)(file2, "utf-8"), title: options.title };
   const { id, name, update } = await agentFetch("/v1/learned-skills/suggestions", {
     method: "POST",
     body
@@ -34174,12 +34493,12 @@ async function skillsSuggestCommand(file2, options) {
 async function skillsListCommand() {
   output(await orgAuthenticatedFetch("/v1/learned-skills"), ({ skills: skills2, suggestions }) => {
     for (const skill of skills2) console.log(`${skill.id}	${skill.name}	${skill.title}`);
-    if (suggestions.length > 0) console.log(import_chalk28.default.gray(`${suggestions.length} pending suggestion(s) to review in the dashboard.`));
+    if (suggestions.length > 0) console.log(import_chalk29.default.gray(`${suggestions.length} pending suggestion(s) to review in the dashboard.`));
   });
 }
 async function skillsCreateCommand(file2, options) {
-  const body = { content: (0, import_node_fs3.readFileSync)(file2, "utf-8"), title: options.title };
-  output(await orgAuthenticatedFetch("/v1/learned-skills", { method: "POST", body }), ({ id, name }) => console.log(import_chalk28.default.green(`Saved learning '${name}' (${id})`)));
+  const body = { content: (0, import_node_fs4.readFileSync)(file2, "utf-8"), title: options.title };
+  output(await orgAuthenticatedFetch("/v1/learned-skills", { method: "POST", body }), ({ id, name }) => console.log(import_chalk29.default.green(`Saved learning '${name}' (${id})`)));
 }
 async function skillsUpdateCommand(id, options) {
   const { skills: skills2 } = await orgAuthenticatedFetch("/v1/learned-skills");
@@ -34187,9 +34506,9 @@ async function skillsUpdateCommand(id, options) {
   if (!existing) throw new Error(`Learning not found: ${id}`);
   const body = {
     title: options.title ?? existing.title,
-    content: options.file ? (0, import_node_fs3.readFileSync)(options.file, "utf-8") : existing.content
+    content: options.file ? (0, import_node_fs4.readFileSync)(options.file, "utf-8") : existing.content
   };
-  output(await orgAuthenticatedFetch(`/v1/learned-skills/${existing.id}`, { method: "PUT", body }), ({ name }) => console.log(import_chalk28.default.green(`Updated learning '${name}'`)));
+  output(await orgAuthenticatedFetch(`/v1/learned-skills/${existing.id}`, { method: "PUT", body }), ({ name }) => console.log(import_chalk29.default.green(`Updated learning '${name}'`)));
 }
 async function skillsDeleteCommand(id) {
   await orgAuthenticatedFetch(`/v1/learned-skills/${id}`, { method: "DELETE" });
@@ -34197,7 +34516,7 @@ async function skillsDeleteCommand(id) {
 }
 
 // src/commands/slack.ts
-var import_chalk29 = __toESM(require("chalk"));
+var import_chalk30 = __toESM(require("chalk"));
 function getThreadOptions(options) {
   const channelId = options.channel || process.env.REPLICAS_SLACK_CHANNEL_ID || process.env.SLACK_CHANNEL_ID;
   const threadTs = options.threadTs || process.env.REPLICAS_SLACK_THREAD_TS || process.env.SLACK_THREAD_TS;
@@ -34215,10 +34534,10 @@ async function attachThread(request) {
     body: request
   });
   output(response, ({ thread, workspace }) => {
-    console.log(import_chalk29.default.green("Slack thread attached."));
-    console.log(import_chalk29.default.gray(`  Channel: ${thread.channel_id}`));
-    console.log(import_chalk29.default.gray(`  Thread: ${thread.thread_ts}`));
-    console.log(import_chalk29.default.gray(`  Workspace: ${workspace.name} (${workspace.id})`));
+    console.log(import_chalk30.default.green("Slack thread attached."));
+    console.log(import_chalk30.default.gray(`  Channel: ${thread.channel_id}`));
+    console.log(import_chalk30.default.gray(`  Thread: ${thread.thread_ts}`));
+    console.log(import_chalk30.default.gray(`  Workspace: ${workspace.name} (${workspace.id})`));
   });
 }
 async function slackThreadAttachCommand(options) {
@@ -34248,12 +34567,12 @@ async function slackThreadSwitchCommand(workspace, options) {
 }
 
 // src/commands/service.ts
-var import_chalk30 = __toESM(require("chalk"));
-var import_node_child_process2 = require("child_process");
-var import_node_fs4 = require("fs");
+var import_chalk31 = __toESM(require("chalk"));
+var import_node_child_process3 = require("child_process");
+var import_node_fs5 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path3 = require("path");
-var SERVICES_DIR = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".replicas", "services");
+var import_node_path4 = require("path");
+var SERVICES_DIR = (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".replicas", "services");
 var NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 function isValidServiceName(name) {
   return NAME_PATTERN.test(name);
@@ -34264,7 +34583,7 @@ function tailLines(content, lines) {
   return all.slice(-lines).join("\n").trim();
 }
 function statePath(name) {
-  return (0, import_node_path3.join)(SERVICES_DIR, `${name}.json`);
+  return (0, import_node_path4.join)(SERVICES_DIR, `${name}.json`);
 }
 function isServiceState(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -34274,7 +34593,7 @@ function isServiceState(value) {
 function readState(name) {
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs4.readFileSync)(statePath(name), "utf-8"));
+    parsed = JSON.parse((0, import_node_fs5.readFileSync)(statePath(name), "utf-8"));
   } catch {
     return null;
   }
@@ -34308,7 +34627,7 @@ async function killServiceGroup(pid) {
 }
 function tailLog(logFile, lines) {
   try {
-    return tailLines((0, import_node_fs4.readFileSync)(logFile, "utf-8"), lines);
+    return tailLines((0, import_node_fs5.readFileSync)(logFile, "utf-8"), lines);
   } catch {
     return "";
   }
@@ -34326,20 +34645,20 @@ async function serviceStartCommand(name, commandParts, options) {
     console.log(`Stopping existing "${name}" (pid ${existing.pid}) before restart`);
     await killServiceGroup(existing.pid);
   }
-  (0, import_node_fs4.mkdirSync)(SERVICES_DIR, { recursive: true });
-  const cwd = (0, import_node_path3.resolve)(options.cwd ?? process.cwd());
-  const logFile = (0, import_node_path3.join)(SERVICES_DIR, `${name}.log`);
-  const logFd = (0, import_node_fs4.openSync)(logFile, "a");
-  (0, import_node_fs4.writeFileSync)(logFd, `
+  (0, import_node_fs5.mkdirSync)(SERVICES_DIR, { recursive: true });
+  const cwd = (0, import_node_path4.resolve)(options.cwd ?? process.cwd());
+  const logFile = (0, import_node_path4.join)(SERVICES_DIR, `${name}.log`);
+  const logFd = (0, import_node_fs5.openSync)(logFile, "a");
+  (0, import_node_fs5.writeFileSync)(logFd, `
 === [replicas service] "${name}" started ${(/* @__PURE__ */ new Date()).toISOString()} in ${cwd}: ${command} ===
 `);
-  const child = (0, import_node_child_process2.spawn)("bash", ["-lc", command], {
+  const child = (0, import_node_child_process3.spawn)("bash", ["-lc", command], {
     cwd,
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: process.env
   });
-  (0, import_node_fs4.closeSync)(logFd);
+  (0, import_node_fs5.closeSync)(logFd);
   if (child.pid === void 0) {
     throw new Error("Failed to spawn service process");
   }
@@ -34352,11 +34671,11 @@ async function serviceStartCommand(name, commandParts, options) {
     logFile,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  (0, import_node_fs4.writeFileSync)(statePath(name), JSON.stringify(state, null, 2));
+  (0, import_node_fs5.writeFileSync)(statePath(name), JSON.stringify(state, null, 2));
   await sleep(1e3);
   if (!isRunning(child.pid)) {
     const logs = tailLog(logFile, 20);
-    (0, import_node_fs4.rmSync)(statePath(name), { force: true });
+    (0, import_node_fs5.rmSync)(statePath(name), { force: true });
     throw new Error(`Service "${name}" exited immediately.${logs ? `
 
 Last log output:
@@ -34374,7 +34693,7 @@ async function serviceStopCommand(name) {
   }
   const wasRunning = isRunning(state.pid);
   if (wasRunning) await killServiceGroup(state.pid);
-  (0, import_node_fs4.rmSync)(statePath(name), { force: true });
+  (0, import_node_fs5.rmSync)(statePath(name), { force: true });
   output({ name, pid: state.pid, was_running: wasRunning }, () => {
     console.log(wasRunning ? `Stopped "${name}" (pid ${state.pid})` : `Service "${name}" was not running`);
   });
@@ -34382,7 +34701,7 @@ async function serviceStopCommand(name) {
 async function serviceListCommand() {
   let entries;
   try {
-    entries = (0, import_node_fs4.readdirSync)(SERVICES_DIR).filter((f) => f.endsWith(".json"));
+    entries = (0, import_node_fs5.readdirSync)(SERVICES_DIR).filter((f) => f.endsWith(".json"));
   } catch {
     entries = [];
   }
@@ -34393,7 +34712,7 @@ async function serviceListCommand() {
       return;
     }
     for (const service of services) {
-      const status = service.running ? import_chalk30.default.green("running") : import_chalk30.default.red("stopped");
+      const status = service.running ? import_chalk31.default.green("running") : import_chalk31.default.red("stopped");
       console.log(`${service.name}  ${status}  pid ${service.pid}  started ${service.startedAt}`);
       console.log(`  command: ${service.command}  (cwd: ${service.cwd})`);
       console.log(`  logs: ${service.logFile}`);
@@ -34672,6 +34991,16 @@ if (isAgentMode()) {
   media.command("share <mediaId>").description("Rotate an image's public forge URL, or create one for video or audio media").action(run(mediaShareCommand));
   media.command("revoke <mediaId>").description("Revoke the public forge URL for uploaded media").action(run(mediaRevokeCommand));
   media.command("delete <mediaId>").description("Permanently delete media uploaded by this workspace").action(run(mediaDeleteCommand));
+  const gpu = program.command("gpu").description("Run commands on cloud GPU sandboxes (billed at cost to your organization)");
+  const addCreateOptions = (command) => command.option("-g, --gpu <type>", `GPU type with an optional count: ${GPU_TYPES.join(", ")}, e.g. H100:2 (default ${DEFAULT_GPU_TYPE})`).option("-i, --image <image>", `Public registry image (default ${DEFAULT_GPU_IMAGE})`).option("-t, --timeout <duration>", "Maximum lifetime, e.g. 90m or 4h (default 1h, max 24h)").option("--idle-timeout <duration>", "Stop after this long with no running command (default 10m, max 1h)").option("-p, --port <port>", "Expose a container port as a public HTTPS URL (repeatable)", collect, []).option("-e, --env <KEY=value>", "Environment variable for the sandbox (repeatable)", collect, []);
+  addCreateOptions(gpu.command("create")).description("Start a GPU sandbox and wait until it is running").option("--no-wait", "Return while the sandbox is still starting").action(run(gpuCreateCommand));
+  gpu.command("list").description("List the running GPU sandboxes of this workspace").action(run(gpuListCommand));
+  gpu.command("exec [command...]").description("Run a shell command in a GPU sandbox and stream its output: replicas gpu exec -- python train.py").option("-s, --sandbox <id>", "Sandbox ID (defaults to the only running sandbox)").option("-w, --workdir <dir>", `Working directory (default ${COMPUTE_SANDBOX_WORKDIR})`).option("-e, --env <KEY=value>", "Environment variable for the command (repeatable)", collect, []).option("-d, --detach", 'Run in the background and print a job ID for "replicas gpu logs"').action(run(gpuExecCommand));
+  gpu.command("logs <jobId>").description("Print the output of a detached job").option("-s, --sandbox <id>", "Sandbox ID (defaults to the only running sandbox)").option("-f, --follow", "Stream until the job exits and exit with its code").action(run(gpuLogsCommand));
+  gpu.command("push [local] [remote]").description(`Copy a local file or directory into a GPU sandbox (default . to ${COMPUTE_SANDBOX_WORKDIR}); git repositories honor .gitignore`).option("-s, --sandbox <id>", "Sandbox ID (defaults to the only running sandbox)").action(run(gpuPushCommand));
+  gpu.command("pull <remote> [local]").description("Copy a file or directory out of a GPU sandbox into a local directory (default .)").option("-s, --sandbox <id>", "Sandbox ID (defaults to the only running sandbox)").action(run(gpuPullCommand));
+  addCreateOptions(gpu.command("run [command...]")).description("Start a GPU sandbox, copy the current directory in, run a command, then stop it: replicas gpu run --gpu H100 -- python train.py").option("--pull <path>", `Copy a path (relative to ${COMPUTE_SANDBOX_WORKDIR}) back into the current directory afterwards (repeatable)`, collect, []).option("--keep", "Keep the sandbox running afterwards").action(run(gpuRunCommand));
+  gpu.command("delete [id]").description("Stop a GPU sandbox").option("-s, --sandbox <id>", "Sandbox ID (defaults to the only running sandbox)").action(run(gpuDeleteCommand));
   program.command("history").description("Read past session history").command("transcript <name>").description("Download the full transcript of a session in INDEX.md and print its path").action(run(historyTranscriptCommand));
   skills.command("suggest <file>").description("Suggest saving a SKILL.md as an organization skill; the user reviews it before it is saved").requiredOption("--title <text>", 'Short title shown to the user, e.g. "Always use Conventional Commits"').action(run(skillsSuggestCommand));
   program.command("computer").description("Drive the workspace Linux desktop through replicas-computer");
@@ -34684,6 +35013,7 @@ if (isAgentMode()) {
     "preview",
     "service",
     "media",
+    "gpu",
     "history",
     "skills",
     "slack",
@@ -34721,9 +35051,9 @@ if (isAgentMode()) {
 }
 async function main() {
   if (process.argv[2] === "computer" && isAgentMode()) {
-    const result = (0, import_node_child_process3.spawnSync)("replicas-computer", process.argv.slice(3), { stdio: "inherit" });
+    const result = (0, import_node_child_process4.spawnSync)("replicas-computer", process.argv.slice(3), { stdio: "inherit" });
     if (result.error) {
-      console.error(import_chalk31.default.red(`
+      console.error(import_chalk32.default.red(`
 \u2717 replicas-computer is unavailable in this workspace image
 `));
       process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-cli",
-  "version": "0.3.103",
+  "version": "0.3.104",
   "description": "CLI for managing Replicas workspaces - SSH into cloud dev environments with automatic port forwarding",
   "main": "dist/index.cjs",
   "bin": {