@tryarcanist/cli 0.1.80 → 0.1.82

package/dist/index.js

@@ -200,7 +200,7 @@ function validateApiUrl(url) {
 // src/runtime.ts
 import { randomUUID } from "crypto";
 import { createInterface } from "readline/promises";
-var ANSI_CONTROL_SEQUENCE = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+var ANSI_CONTROL_SEQUENCE = /\u001b\[[0-9:;<=>?]*[ -/]*[@-~]/g;
 function getRuntimeOptions(command, options = {}) {
   const globals = command?.optsWithGlobals?.();
   const merged = { ...globals, ...options };
@@ -388,19 +388,31 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/constants/watch.ts
-var MIN_WATCH_POLL_INTERVAL_MS = 1;
-var DEFAULT_WATCH_POLL_INTERVAL_MS = 1e3;
-var WATCH_REPLAY_PAGE_SIZE = 200;
-var WATCH_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "idle",
+// ../../shared/session/phase.ts
+var NON_REPO_SESSION_KINDS = /* @__PURE__ */ new Set(["terminal_bench", "swe_bench_pro", "swe_polybench"]);
+function isRepoSession(sessionKind) {
+  return !sessionKind || !NON_REPO_SESSION_KINDS.has(sessionKind);
+}
+var TERMINAL_PHASES_ARRAY = [
   "completed",
   "blocked",
   "failed",
   "stopped",
-  "stopped_resumable",
   "archived"
-]);
+];
+var TERMINAL_PHASES = new Set(TERMINAL_PHASES_ARRAY);
+function isTerminalPhase(phase, sessionKind) {
+  if (TERMINAL_PHASES.has(phase)) return true;
+  return phase === "idle" && !isRepoSession(sessionKind);
+}
+
+// src/constants/watch.ts
+var MIN_WATCH_POLL_INTERVAL_MS = 1;
+var DEFAULT_WATCH_POLL_INTERVAL_MS = 1e3;
+var WATCH_REPLAY_PAGE_SIZE = 200;
+function isWatchTerminal(phase, sessionKind) {
+  return isTerminalPhase(phase, sessionKind);
+}
 
 // src/uploads.ts
 import { readFile } from "fs/promises";
@@ -434,6 +446,27 @@ function validateUploadedName(name, kind) {
 function trimNamedItems(items) {
   return items.map((item) => ({ ...item, name: item.name.trim() }));
 }
+function validateUploadItems({
+  items,
+  existingNames = [],
+  kind,
+  max,
+  label,
+  normalizeItems,
+  validateItem
+}) {
+  const normalized = normalizeItems ? normalizeItems(items) : [...items];
+  const deduped = deduplicateByName(normalized, existingNames);
+  const capacityError = checkUploadCapacity(existingNames.length, deduped.length, max, label);
+  if (capacityError) return fail(capacityError);
+  for (const item of deduped) {
+    const nameError = validateUploadedName(item.name, kind);
+    if (nameError) return fail(nameError);
+    const itemError = validateItem(item);
+    if (itemError) return fail(itemError);
+  }
+  return ok(deduped);
+}
 function hasNullBytes(content) {
   return content.slice(0, 8192).includes("\0");
 }
@@ -455,22 +488,24 @@ function deduplicateByName(items, existingNames = []) {
   return deduped;
 }
 function validateUploadedFilePayload(files, existingNames = []) {
-  const trimmed = trimNamedItems(files);
-  const deduped = deduplicateByName(trimmed, existingNames);
-  const capacityError = checkUploadCapacity(existingNames.length, deduped.length, MAX_UPLOADED_FILES, "uploaded files");
-  if (capacityError) return fail(capacityError);
-  for (const file of deduped) {
-    const nameError = validateUploadedName(file.name, "file");
-    if (nameError) return fail(nameError);
-    const byteLength = new TextEncoder().encode(file.content).byteLength;
-    if (byteLength > MAX_UPLOADED_FILE_SIZE_BYTES) {
-      return fail(`Uploaded file too large: ${file.name} (${byteLength} bytes, max ${MAX_UPLOADED_FILE_SIZE_BYTES})`);
-    }
-    if (hasNullBytes(file.content)) {
-      return fail(`Binary files are not supported: ${file.name}`);
+  return validateUploadItems({
+    items: files,
+    existingNames,
+    kind: "file",
+    max: MAX_UPLOADED_FILES,
+    label: "uploaded files",
+    normalizeItems: trimNamedItems,
+    validateItem: (file) => {
+      const byteLength = new TextEncoder().encode(file.content).byteLength;
+      if (byteLength > MAX_UPLOADED_FILE_SIZE_BYTES) {
+        return `Uploaded file too large: ${file.name} (${byteLength} bytes, max ${MAX_UPLOADED_FILE_SIZE_BYTES})`;
+      }
+      if (hasNullBytes(file.content)) {
+        return `Binary files are not supported: ${file.name}`;
+      }
+      return null;
     }
-  }
-  return ok(deduped);
+  });
 }
 
 // src/uploads.ts
@@ -938,6 +973,15 @@ function mergeMemoryRefs(ids, rawRefs) {
       const ref = { id };
       if (typeof record.path === "string" && record.path.trim()) ref.path = record.path.trim();
       if (typeof record.title === "string" && record.title.trim()) ref.title = record.title.trim();
+      if (typeof record.selectionRank === "number") ref.selectionRank = record.selectionRank;
+      if (typeof record.selectionScore === "number") ref.selectionScore = record.selectionScore;
+      if (typeof record.reason === "string" && record.reason.trim()) ref.reason = record.reason.trim();
+      if (typeof record.expectedEffect === "string" && record.expectedEffect.trim()) {
+        ref.expectedEffect = record.expectedEffect.trim();
+      }
+      if (typeof record.observedEffect === "string" && record.observedEffect.trim()) {
+        ref.observedEffect = record.observedEffect.trim();
+      }
       byId.set(id, ref);
     }
   }
@@ -1379,6 +1423,20 @@ function formatSessionErrorMessage(error, code) {
 }
 
 // src/utils/session-output.ts
+var VALID_PHASES = /* @__PURE__ */ new Set([
+  "idle",
+  "running",
+  "waiting_for_input",
+  "finalizing",
+  "completed",
+  "blocked",
+  "failed",
+  "stopped",
+  "archived"
+]);
+var VALID_SANDBOX_SUBSTATES = /* @__PURE__ */ new Set(["creating", "reconnecting", "stopping", "none"]);
+var VALID_STOP_MODES = /* @__PURE__ */ new Set(["user", "resumable", "none"]);
+var VALID_FINALIZING_STEPS = /* @__PURE__ */ new Set(["post_execution", "publishing", "none"]);
 function formatDate(value) {
   const date = new Date(value);
   if (Number.isNaN(date.getTime())) return value;
@@ -1578,9 +1636,21 @@ function parseSsePayload(payload) {
   for (const message of messages) {
     const data = message.data ? parseJsonObject(message.data) : {};
     if (message.event === "status") {
+      const phaseRaw = data.phase;
+      const phase = typeof phaseRaw === "string" && VALID_PHASES.has(phaseRaw) ? phaseRaw : null;
       const entry = {
-        status: typeof data.status === "string" ? data.status : "unknown"
+        phase
       };
+      if (typeof data.sandboxSubstate === "string" && VALID_SANDBOX_SUBSTATES.has(data.sandboxSubstate)) {
+        entry.sandboxSubstate = data.sandboxSubstate;
+      }
+      if (typeof data.stopMode === "string" && VALID_STOP_MODES.has(data.stopMode)) {
+        entry.stopMode = data.stopMode;
+      }
+      if (typeof data.finalizingStep === "string" && VALID_FINALIZING_STEPS.has(data.finalizingStep)) {
+        entry.finalizingStep = data.finalizingStep;
+      }
+      if (typeof data.sessionKind === "string") entry.sessionKind = data.sessionKind;
       if (typeof data.title === "string") entry.title = data.title;
       if (typeof data.spawnDurationMs === "number" || data.spawnDurationMs === null) {
         entry.spawnDurationMs = data.spawnDurationMs;
@@ -1711,10 +1781,16 @@ function parseNonNegativeInteger(raw, name, defaultValue) {
   return Number(raw);
 }
 function formatStatusLine(status) {
+  const label = status.phase ?? "unknown";
+  const substate = [];
+  if (status.sandboxSubstate && status.sandboxSubstate !== "none") substate.push(status.sandboxSubstate);
+  if (status.stopMode && status.stopMode !== "none") substate.push(status.stopMode);
+  if (status.finalizingStep && status.finalizingStep !== "none") substate.push(status.finalizingStep);
+  const phaseLabel = substate.length > 0 ? `${label}/${substate.join("/")}` : label;
   const details = [];
   if (status.title) details.push(status.title);
   if (status.spawnDurationMs != null) details.push(`spawn ${(status.spawnDurationMs / 1e3).toFixed(1)}s`);
-  return details.length > 0 ? `[status] ${status.status} | ${details.join(" | ")}` : `[status] ${status.status}`;
+  return details.length > 0 ? `[status] ${phaseLabel} | ${details.join(" | ")}` : `[status] ${phaseLabel}`;
 }
 async function fetchPromptLabels(config, sessionId) {
   const data = await apiFetch(config, `/api/sessions/${sessionId}/prompts`);
@@ -1794,7 +1870,7 @@ async function watchCommand(sessionId, options, command) {
         console.log(rendered.line);
       }
       if (receivedFullPage) continue;
-      if (parsed.status?.status && WATCH_TERMINAL_STATUSES.has(parsed.status.status)) break;
+      if (parsed.status?.phase && isWatchTerminal(parsed.status.phase, parsed.status.sessionKind)) break;
       await sleep(effectivePollIntervalMs);
     }
   } finally {
@@ -1827,12 +1903,13 @@ function buildPromptFailureError(sessionId, prompt, sessionUrl) {
     hint: `Inspect with: arcanist sessions transcript ${sessionId}`
   });
 }
-function extractSessionStatus(payload) {
+function extractSessionLifecycle(payload) {
   const session = payload.session;
-  if (session && typeof session === "object" && typeof session.status === "string") {
-    return String(session.status);
-  }
-  return typeof payload.status === "string" ? payload.status : "unknown";
+  const root = session && typeof session === "object" ? session : payload;
+  const phaseRaw = root.phase;
+  const phase = typeof phaseRaw === "string" && VALID_PHASES.has(phaseRaw) ? phaseRaw : null;
+  const sessionKind = typeof root.sessionKind === "string" ? root.sessionKind : null;
+  return { phase, sessionKind };
 }
 async function fetchCreatedPromptStatus(config, sessionId, promptId) {
   const promptList = await apiFetch(config, `/api/sessions/${sessionId}/prompts`);
@@ -1846,7 +1923,8 @@ async function waitForCreatedPromptToSettle(config, sessionId, promptId, pollInt
       return createdPrompt;
     }
     const sessionPayload = await apiFetch(config, `/api/sessions/${sessionId}`);
-    if (WATCH_TERMINAL_STATUSES.has(extractSessionStatus(sessionPayload))) {
+    const lifecycle = extractSessionLifecycle(sessionPayload);
+    if (lifecycle.phase && isWatchTerminal(lifecycle.phase, lifecycle.sessionKind)) {
       return fetchCreatedPromptStatus(config, sessionId, promptId);
     }
     await sleep(effectivePollIntervalMs);
@@ -2142,17 +2220,38 @@ async function usageCommand(sessionId, options, command) {
 async function stopCommand(sessionId, options = {}, command) {
   const runtime = getRuntimeOptions(command, options);
   const config = requireConfig(runtime);
-  const response = await apiFetch(config, `/api/sessions/${sessionId}/stop`, {
-    method: "POST"
-  });
-  const status = response.status ?? "stopping";
+  let status;
+  try {
+    const response = await apiFetch(config, `/api/sessions/${sessionId}/stop`, {
+      method: "POST"
+    });
+    status = response.status ?? "stopping";
+  } catch (err) {
+    const parsed = parseStopBlocked(err);
+    if (!parsed) throw err;
+    status = parsed.reason;
+  }
   if (isJson(command, options)) {
     writeJson({ sessionId, status });
     return;
   }
-  console.log(
-    status === "already_stopped" ? `Session ${sessionId} is already stopped.` : `Stop requested for session ${sessionId}.`
-  );
+  if (status === "already_stopped") {
+    console.log(`Session ${sessionId} is already stopped.`);
+  } else if (status === "stopping" || status === "stopped") {
+    console.log(`Stop requested for session ${sessionId}.`);
+  } else {
+    console.log(`Session ${sessionId} cannot be stopped from phase=${status}.`);
+  }
+}
+function parseStopBlocked(err) {
+  if (!(err instanceof ApiError) || err.status !== 409) return null;
+  try {
+    const body = JSON.parse(err.body);
+    if (body.error !== "session_not_stoppable") return null;
+    return { reason: body.reason ?? "not_stoppable" };
+  } catch {
+    return null;
+  }
 }
 
 // src/commands/test-creds.ts

package/package.json

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