@tryarcanist/cli 0.1.228 → 0.1.230

package/README.md

@@ -362,6 +362,31 @@ arcanist sessions usage abc123
 arcanist sessions usage abc123 --json
 ```
 
+### `arcanist sessions artifacts <session-id>`
+
+Lists the artifacts a session produced (screenshots, videos) as `artifactId`, `kind`, `label`, `filename`, `bytes`, `createdAt`.
+
+```bash
+arcanist sessions artifacts abc123
+arcanist sessions artifacts abc123 --json
+arcanist sessions artifacts abc123 --all -o ./run-evidence
+```
+
+`--all` downloads every artifact for the session instead of listing them, and `-o, --output <dir>` picks the destination directory (default: the current directory). An existing file is never overwritten: if the target name is already taken - by another artifact in the same run or by a file already on disk - the artifact ID is prefixed instead.
+
+JSON mode returns `{artifacts}` for a listing and `{downloaded}` for `--all`, where each entry is `{artifactId, path}`.
+
+### `arcanist sessions artifacts get <session-id> <artifact-id>`
+
+Downloads one artifact and prints the path it wrote.
+
+```bash
+arcanist sessions artifacts get abc123 art-1
+arcanist sessions artifacts get abc123 art-1 -o ./run-evidence
+```
+
+`-o, --output <dir>` picks the destination directory (default: the current directory). An artifact ID that is not in the session exits non-zero. JSON mode returns `{artifactId, path}`.
+
 ### `arcanist repos list`
 
 ```bash

package/dist/index.js

@@ -267,6 +267,9 @@ async function apiFetch(config, path, init) {
 async function apiFetchText(config, path, init) {
   return apiRequest(config, path, init, (res) => res.text());
 }
+async function apiFetchBytes(config, path, init) {
+  return apiRequest(config, path, init, async (res) => new Uint8Array(await res.arrayBuffer()));
+}
 async function resolveBusinessId(config, options) {
   if (options.business && options.business.trim()) return options.business.trim();
   const whoami = await apiFetch(config, "/api/auth/whoami");
@@ -534,7 +537,7 @@ async function readHiddenPrompt(prompt) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     throw new CliError("user", "No interactive terminal available. Re-run with --token-stdin or set ARCANIST_TOKEN.");
   }
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const stdin = process.stdin;
     const inputChars = [];
     let ansiCarry = "";
@@ -550,7 +553,7 @@ async function readHiddenPrompt(prompt) {
       settled = true;
       cleanup();
       process.stdout.write("\n");
-      resolve2(inputChars.join(""));
+      resolve3(inputChars.join(""));
     };
     const fail2 = (error) => {
       if (settled) return;
@@ -678,7 +681,7 @@ var VendorBinaryMissingError = class extends CliError {
   }
 };
 function runVendorLoginProcess(spec) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn(spec.binPath, spec.args, {
       stdio: "inherit",
       env: { ...process.env, ...spec.env }
@@ -692,7 +695,7 @@ function runVendorLoginProcess(spec) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
         return;
       }
       reject(
@@ -806,7 +809,7 @@ function resolveVendorBin(config, optionPath) {
   return optionPath?.trim() || process.env[config.binEnvVar]?.trim() || config.defaultBin;
 }
 function runVendorInstall(config, command) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn2("bash", ["-c", command], { stdio: ["inherit", 2, "inherit"] });
     child.on("error", (err) => {
       reject(
@@ -817,7 +820,7 @@ function runVendorInstall(config, command) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
         return;
       }
       reject(
@@ -1025,7 +1028,7 @@ async function agentSubscriptionLogoutCommand(config, options, command) {
 
 // ../../shared/utils/timing.ts
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/status-poll.ts
@@ -1142,7 +1145,7 @@ async function anubisCommand(prUrl, options = {}, command) {
         config,
         `/api/anubis-runs/status?prUrl=${encodeURIComponent(prUrl)}`
       );
-      if (status.sessionStatus === "active") return null;
+      if (status.sessionStatus === "in_flight") return null;
       assertSameAttempt(trigger.sessionId, status.sessionId, "Anubis");
       return status;
     }
@@ -1153,6 +1156,102 @@ async function anubisCommand(prUrl, options = {}, command) {
   });
 }
 
+// src/commands/artifacts.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join4, resolve as resolve2 } from "path";
+async function fetchArtifacts(config, sessionId) {
+  const payload = await apiFetch(
+    config,
+    `/api/sessions/${encodeURIComponent(sessionId)}/artifacts/list`
+  );
+  return payload.artifacts ?? [];
+}
+function artifactFilename(artifact) {
+  const recorded = artifact.metadata?.filename;
+  const safe = recorded ? sanitizeTerminalText(basename(recorded)) : "";
+  return safe && safe !== "." && safe !== ".." ? safe : `${sanitizeTerminalText(artifact.type)}-${artifact.artifactId}`;
+}
+async function downloadArtifact(config, sessionId, artifact, outputDir, usedNames) {
+  const filename = artifactFilename(artifact);
+  const taken = usedNames.has(filename) || existsSync3(join4(outputDir, filename));
+  const targetName = taken ? `${artifact.artifactId}-${filename}` : filename;
+  usedNames.add(targetName);
+  const bytes = await apiFetchBytes(
+    config,
+    `/api/sessions/${encodeURIComponent(sessionId)}/artifacts/${encodeURIComponent(artifact.artifactId)}/view?filename=${encodeURIComponent(filename)}`
+  );
+  const targetPath = join4(outputDir, targetName);
+  writeFileSync2(targetPath, bytes);
+  return targetPath;
+}
+function resolveOutputDir(output) {
+  const dir = resolve2(output ?? process.cwd());
+  mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+async function listArtifactsCommand(sessionId, options, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const artifacts2 = await fetchArtifacts(config, sessionId);
+  if (options.all) {
+    await downloadAllArtifacts(config, sessionId, artifacts2, options, command);
+    return;
+  }
+  emit(command, options, { artifacts: artifacts2 }, (payload) => {
+    if (payload.artifacts.length === 0) {
+      console.log(`No artifacts for session ${sessionId}.`);
+      return;
+    }
+    console.log(["ARTIFACT ID", "KIND", "LABEL", "FILENAME", "BYTES", "CREATED AT"].join("	"));
+    for (const artifact of payload.artifacts) {
+      console.log(
+        [
+          artifact.artifactId,
+          sanitizeTerminalText(artifact.type),
+          sanitizeTerminalText(artifact.metadata?.label ?? "-"),
+          artifactFilename(artifact),
+          artifact.metadata?.bytes ?? "-",
+          new Date(artifact.createdAt).toISOString()
+        ].join("	")
+      );
+    }
+  });
+}
+async function downloadAllArtifacts(config, sessionId, artifacts2, options, command) {
+  if (artifacts2.length === 0) {
+    emit(command, options, { downloaded: [] }, () => {
+      console.log(`No artifacts for session ${sessionId}.`);
+    });
+    return;
+  }
+  const outputDir = resolveOutputDir(options.output);
+  const usedNames = /* @__PURE__ */ new Set();
+  const downloaded = [];
+  for (const artifact of artifacts2) {
+    const path = await downloadArtifact(config, sessionId, artifact, outputDir, usedNames);
+    downloaded.push({ artifactId: artifact.artifactId, path });
+  }
+  emit(command, options, { downloaded }, (payload) => {
+    for (const entry of payload.downloaded) console.log(entry.path);
+  });
+}
+async function getArtifactCommand(sessionId, artifactId, options, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const artifacts2 = await fetchArtifacts(config, sessionId);
+  const artifact = artifacts2.find((candidate) => candidate.artifactId === artifactId);
+  if (!artifact) {
+    throw new CliError("user", `Artifact ${artifactId} not found in session ${sessionId}.`, {
+      hint: `Run \`arcanist sessions artifacts ${sessionId}\` to list the artifact IDs for this session.`
+    });
+  }
+  const outputDir = resolveOutputDir(options.output);
+  const path = await downloadArtifact(config, sessionId, artifact, outputDir, /* @__PURE__ */ new Set());
+  emit(command, options, { artifactId, path }, (payload) => {
+    console.log(payload.path);
+  });
+}
+
 // src/commands/auth.ts
 async function whoamiCommand(options, command) {
   const { config } = resolveBusinessContext(command, options);
@@ -2147,7 +2246,7 @@ function formatTime(value) {
 
 // src/commands/codex.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var CODEX_SUBSCRIPTION_PATH = "/api/settings/codex-subscription";
 var CODEX_SUBSCRIPTION_AUTH_JSON_PATH = "/api/settings/codex-subscription/auth-json";
 var CODEX_SUBSCRIPTION_ENABLED_PATH = "/api/settings/codex-subscription/enabled";
@@ -2185,7 +2284,7 @@ async function codexLoginCommand(options, command) {
     await runCodexDeviceLogin(codexPath, codexHome);
     let raw;
     try {
-      raw = await readFile2(join4(codexHome, "auth.json"), "utf8");
+      raw = await readFile2(join5(codexHome, "auth.json"), "utf8");
     } catch {
       throw new CliError("user", "Codex login completed but no auth.json was written.", {
         hint: "Verify `codex login --device-auth` succeeds on its own, then re-run `arcanist codex login`."
@@ -2259,7 +2358,7 @@ async function codexLogoutCommand(options, command) {
 
 // src/uploads.ts
 import { readFile as readFile3 } from "fs/promises";
-import { basename, extname } from "path";
+import { basename as basename2, extname } from "path";
 
 // ../../shared/constants/uploads.ts
 var MAX_UPLOADED_FILES = 5;
@@ -2355,11 +2454,11 @@ function validateUploadedFilePayload(files, existingNames = []) {
 async function resolveUploadedFileOptions(files) {
   const paths = normalizeUploadedFileOptions(files);
   if (paths.length === 0) return void 0;
-  const names = paths.map((path) => basename(path));
+  const names = paths.map((path) => basename2(path));
   validateUploadedFileNames(names);
   const uploadedFiles = await Promise.all(
     paths.map(async (path) => {
-      const name = basename(path);
+      const name = basename2(path);
       try {
         return { name, content: await readFile3(path, "utf8") };
       } catch (err) {
@@ -4764,7 +4863,7 @@ async function reviewCommand(prUrl, options = {}, command) {
 }
 
 // src/commands/sandbox.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 
 // ../../shared/sandbox-layer/parser.ts
@@ -5311,7 +5410,7 @@ function assertCleanAndPushed() {
     throw new CliError("user", "Current commit is not pushed; push before building the sandbox layer.");
 }
 function assertManifestExists(path) {
-  if (!existsSync3(path)) throw new CliError("user", `Missing sandbox manifest: ${path}`);
+  if (!existsSync4(path)) throw new CliError("user", `Missing sandbox manifest: ${path}`);
 }
 function repoPath(repo) {
   return `${repo.owner}/${repo.repo}`;
@@ -5528,11 +5627,11 @@ function sourceBody(sourceRepo, manifestPath) {
 }
 async function sandboxInitCommand(options = {}, command) {
   const runtime = getRuntimeOptions(command, options);
-  if (existsSync3(DEFAULT_MANIFEST_PATH)) throw new CliError("conflict", `${DEFAULT_MANIFEST_PATH} already exists`);
+  if (existsSync4(DEFAULT_MANIFEST_PATH)) throw new CliError("conflict", `${DEFAULT_MANIFEST_PATH} already exists`);
   const layerPath = ".arcanist/sandbox.layer.Dockerfile";
-  if (existsSync3(layerPath)) throw new CliError("conflict", `${layerPath} already exists`);
-  mkdirSync2(dirname2(DEFAULT_MANIFEST_PATH), { recursive: true });
-  writeFileSync2(
+  if (existsSync4(layerPath)) throw new CliError("conflict", `${layerPath} already exists`);
+  mkdirSync3(dirname2(DEFAULT_MANIFEST_PATH), { recursive: true });
+  writeFileSync3(
     DEFAULT_MANIFEST_PATH,
     [
       "version: 1",
@@ -5545,7 +5644,7 @@ async function sandboxInitCommand(options = {}, command) {
     ].join("\n"),
     "utf8"
   );
-  writeFileSync2(
+  writeFileSync3(
     layerPath,
     [
       "# Only RUN and ENV instructions are supported.",
@@ -6485,6 +6584,29 @@ Examples:
   arcanist sessions usage <session-id> --json
 `
 ).action((sessionId, options, command) => usageCommand(sessionId, options, command));
+var artifacts = sessions.command("artifacts").description("List or download session artifacts (screenshots, videos)").argument("<session-id>", "Session ID").option("-o, --output <dir>", "Directory to write downloads into; defaults to the current directory").option("--all", "Download every artifact for the session instead of listing them").addHelpText(
+  "after",
+  `
+Examples:
+  arcanist sessions artifacts <session-id>
+  arcanist sessions artifacts <session-id> --json
+  arcanist sessions artifacts <session-id> --all -o ./run-evidence
+
+JSON:
+JSON mode returns {artifacts} for a listing and {downloaded} for --all, where each downloaded entry is {artifactId, path}.
+`
+).action((sessionId, options, command) => listArtifactsCommand(sessionId, options, command));
+artifacts.command("get").description("Download one session artifact by ID").argument("<session-id>", "Session ID").argument("<artifact-id>", "Artifact ID from `arcanist sessions artifacts`").option("-o, --output <dir>", "Directory to write the download into; defaults to the current directory").addHelpText(
+  "after",
+  `
+Examples:
+  arcanist sessions artifacts get <session-id> <artifact-id>
+  arcanist sessions artifacts get <session-id> <artifact-id> -o ./run-evidence
+
+JSON:
+JSON mode returns {artifactId, path}.
+`
+).action((sessionId, artifactId, options, command) => getArtifactCommand(sessionId, artifactId, options, command));
 var repos = program.command("repos").description("Repository discovery commands");
 repos.command("list").description("List accessible repositories").addHelpText(
   "after",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryarcanist/cli",
-  "version": "0.1.228",
+  "version": "0.1.230",
   "description": "CLI for Arcanist — create and manage coding agent sessions",
   "type": "module",
   "bin": {