@madarco/agentbox 0.5.0 → 0.6.0

package/dist/{chunk-PXUBE5KS.js → chunk-HTTKML3C.js}

@@ -8,12 +8,14 @@ import {
   removeContainer,
   sanitizeMnemonic,
   volumeExists
-} from "./chunk-RFC5F5HR.js";
+} from "./chunk-HHMWQNLF.js";
 
-// ../../packages/sandbox-docker/dist/chunk-LGNJND37.js
+// ../../packages/sandbox-docker/dist/chunk-SRQIM7LG.js
+import { spawnSync } from "child_process";
 import { mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from "fs/promises";
 import { homedir, tmpdir } from "os";
 import { join, relative } from "path";
+import { setTimeout as delay } from "timers/promises";
 import { execa } from "execa";
 import { randomBytes } from "crypto";
 import { execa as execa2 } from "execa";
@@ -25,6 +27,7 @@ import { mkdir as mkdir2, readdir as readdir3, rm as rm2, stat as stat3 } from "
 import { homedir as homedir2, platform } from "os";
 import { join as join3, resolve } from "path";
 import { stat as stat4 } from "fs/promises";
+import { execa as execa5 } from "execa";
 import { spawn } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 import { existsSync, openSync } from "fs";
@@ -32,7 +35,7 @@ import { mkdir as mkdir3, readFile as readFile2, unlink, writeFile as writeFile2
 import { request as httpRequest } from "http";
 import { homedir as homedir3 } from "os";
 import { dirname, join as join4, resolve as resolve2 } from "path";
-import { setTimeout as delay } from "timers/promises";
+import { setTimeout as delay2 } from "timers/promises";
 import { fileURLToPath } from "url";
 
 // ../../packages/relay/dist/index.js
@@ -42,7 +45,7 @@ var RELAY_NETWORK_NAME = "agentbox-net";
 var RELAY_IMAGE_REF = "agentbox/relay:dev";
 var MAX_BODY_BYTES = 1024 * 1024;
 
-// ../../packages/sandbox-docker/dist/chunk-LGNJND37.js
+// ../../packages/sandbox-docker/dist/chunk-SRQIM7LG.js
 function isHostPathHookCommand(command, hostHome) {
   if (typeof command !== "string" || command.length === 0) return false;
   if (hostHome.length === 0) return false;
@@ -79,6 +82,27 @@ function filterHostHooks(data, hostHome) {
   }
   return { data: clone, removedCommands };
 }
+function trustWorkspace(data, workspacePath) {
+  const clone = structuredClone(data);
+  if (clone === null || typeof clone !== "object" || Array.isArray(clone)) {
+    return { data: clone, trusted: false };
+  }
+  if (workspacePath.length === 0) return { data: clone, trusted: false };
+  const obj = clone;
+  if (obj.projects === null || typeof obj.projects !== "object" || Array.isArray(obj.projects)) {
+    obj.projects = {};
+  }
+  const projects = obj.projects;
+  const existing = projects[workspacePath];
+  const entry = existing !== null && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+  if (entry.hasTrustDialogAccepted === true) {
+    projects[workspacePath] = entry;
+    return { data: clone, trusted: false };
+  }
+  entry.hasTrustDialogAccepted = true;
+  projects[workspacePath] = entry;
+  return { data: clone, trusted: true };
+}
 function addProjectAlias(data, fromPath, toPath) {
   const clone = structuredClone(data);
   if (clone === null || typeof clone !== "object" || Array.isArray(clone)) {
@@ -105,17 +129,17 @@ function addProjectAlias(data, fromPath, toPath) {
   }
   return { data: clone, aliased: true };
 }
-function clearInstallMethod(data) {
+function setInstallMethodNative(data) {
   const clone = structuredClone(data);
   if (clone === null || typeof clone !== "object" || Array.isArray(clone)) {
-    return { data: clone, cleared: false };
+    return { data: clone, applied: false };
   }
   const obj = clone;
-  if (Object.prototype.hasOwnProperty.call(obj, "installMethod")) {
-    delete obj.installMethod;
-    return { data: clone, cleared: true };
-  }
-  return { data: clone, cleared: false };
+  const changed = obj.installMethod !== "native" || obj.autoUpdates !== false || obj.autoUpdatesProtectedForNative !== true;
+  obj.installMethod = "native";
+  obj.autoUpdates = false;
+  obj.autoUpdatesProtectedForNative = true;
+  return { data: clone, applied: changed };
 }
 var SKILL_EXCLUDE_PREFIXES = ["agentbox-"];
 var CONTAINER_PLUGINS_PREFIX = "/home/vscode/.claude/plugins/";
@@ -189,6 +213,24 @@ function mergeInstalledPlugins(hostJson, boxJson, opts) {
     (host, merged) => ({ ...host, plugins: merged })
   );
 }
+function referencedPluginVersionKeys(installedPluginsJson) {
+  const keys = /* @__PURE__ */ new Set();
+  if (!isPlainObject(installedPluginsJson)) return keys;
+  const plugins = installedPluginsJson["plugins"];
+  if (!isPlainObject(plugins)) return keys;
+  for (const entries of Object.values(plugins)) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (!isPlainObject(entry)) continue;
+      const installPath = entry["installPath"];
+      if (typeof installPath !== "string") continue;
+      const segments = installPath.split("/").filter((s) => s.length > 0);
+      if (segments.length < 3) continue;
+      keys.add(segments.slice(-3).join("/"));
+    }
+  }
+  return keys;
+}
 var SHARED_CLAUDE_VOLUME = "agentbox-claude-config";
 var DEFAULT_CLAUDE_SESSION = "claude";
 var CONTAINER_CLAUDE_DIR = "/home/vscode/.claude";
@@ -210,6 +252,14 @@ async function pathExists(p) {
     return false;
   }
 }
+async function volumeHasClaudeJson(volume, image) {
+  const res = await execa(
+    "docker",
+    ["run", "--rm", "-v", `${volume}:/dst`, image, "sh", "-c", "test -e /dst/_claude.json"],
+    { reject: false }
+  );
+  return res.exitCode === 0;
+}
 async function findBrokenSymlinks(root) {
   const broken = [];
   async function walk(dir) {
@@ -244,6 +294,7 @@ async function ensureClaudeVolume(spec, opts) {
   if (!await pathExists(hostClaude)) return { created, synced: false };
   const hostClaudeJson = join(homedir(), ".claude.json");
   const hasJson = await pathExists(hostClaudeJson);
+  const seedClaudeJson = !await volumeHasClaudeJson(spec.volume, opts.image);
   const hostHome = homedir();
   const hostAgents = join(homedir(), ".agents");
   const hasAgents = await pathExists(hostAgents);
@@ -261,12 +312,13 @@ async function ensureClaudeVolume(spec, opts) {
     "-v",
     `${hostClaude}:/src-claude:ro`
   ];
-  if (hasJson) args.push("-v", `${hostClaudeJson}:/src-claude-json:ro`);
+  if (hasJson && seedClaudeJson) args.push("-v", `${hostClaudeJson}:/src-claude-json:ro`);
   if (hasAgents) args.push("-v", `${hostAgents}:/.agents:ro`);
   const filterDir = await mkdtemp(join(tmpdir(), "agentbox-claude-filter-"));
   let filteredHookCount = 0;
-  let clearedInstallMethod = false;
+  let installMethodFixed = false;
   let aliasedProjectKey = false;
+  let workspaceTrusted = false;
   try {
     const settingsResult = await maybeFilterTo(
       join(hostClaude, "settings.json"),
@@ -274,21 +326,40 @@ async function ensureClaudeVolume(spec, opts) {
       hostHome
     );
     filteredHookCount += settingsResult.removedHooks;
-    if (hasJson) {
+    if (!seedClaudeJson) {
+    } else if (hasJson) {
       const jsonResult = await maybeFilterTo(
         hostClaudeJson,
         join(filterDir, "_claude.json"),
         hostHome,
         {
-          clearInstallMethod: true,
-          aliasProject: opts.hostWorkspace ? { from: opts.hostWorkspace, to: CONTAINER_WORKSPACE } : void 0
+          setInstallMethodNative: true,
+          aliasProject: opts.hostWorkspace ? { from: opts.hostWorkspace, to: CONTAINER_WORKSPACE } : void 0,
+          trustWorkspacePath: CONTAINER_WORKSPACE
         }
       );
       filteredHookCount += jsonResult.removedHooks;
-      clearedInstallMethod = jsonResult.clearedInstallMethod;
+      installMethodFixed = jsonResult.installMethodFixed;
       aliasedProjectKey = jsonResult.aliasedProjectKey;
+      workspaceTrusted = jsonResult.workspaceTrusted;
+    } else {
+      await writeFile(
+        join(filterDir, "_claude.json"),
+        JSON.stringify(
+          {
+            installMethod: "native",
+            autoUpdates: false,
+            autoUpdatesProtectedForNative: true,
+            projects: { [CONTAINER_WORKSPACE]: { hasTrustDialogAccepted: true } }
+          },
+          null,
+          2
+        )
+      );
+      installMethodFixed = true;
+      workspaceTrusted = true;
     }
-    if (filteredHookCount > 0 || clearedInstallMethod || aliasedProjectKey) {
+    if (filteredHookCount > 0 || installMethodFixed || aliasedProjectKey || workspaceTrusted) {
       args.push("-v", `${filterDir}:/src-filter:ro`);
     }
     const brokenSymlinks = await findBrokenSymlinks(hostClaude);
@@ -335,7 +406,14 @@ async function ensureClaudeVolume(spec, opts) {
   } finally {
     await rm(filterDir, { recursive: true, force: true });
   }
-  return { created, synced: true, filteredHookCount, clearedInstallMethod, aliasedProjectKey };
+  return {
+    created,
+    synced: true,
+    filteredHookCount,
+    installMethodFixed,
+    aliasedProjectKey,
+    workspaceTrusted
+  };
 }
 async function seedSetupSkillIntoVolume(volume, image) {
   try {
@@ -349,10 +427,10 @@ async function seedSetupSkillIntoVolume(volume, image) {
       image,
       "sh",
       "-c",
-      // Prints SEEDED only when it actually copies, so the caller can log
-      // accurately. The whole thing is `|| true` so an already-present skill
-      // (or missing image asset) is a clean no-op, never a non-zero exit.
-      `{ [ ! -e /dst/skills/agentbox-setup ] && [ -f ${IN_BOX_SETUP_GUIDE_PATH} ] && mkdir -p /dst/skills/agentbox-setup && cp -a ${IN_BOX_SETUP_GUIDE_PATH} ${SETUP_SKILL_DST} && chown -R 1000:1000 /dst/skills/agentbox-setup && echo SEEDED; } || true`
+      // Always overwrite from the image so an image upgrade propagates. Prints
+      // SEEDED on success; the whole thing is `|| true` so a missing image
+      // asset is a clean no-op, never a non-zero exit.
+      `{ [ -f ${IN_BOX_SETUP_GUIDE_PATH} ] && rm -rf /dst/skills/agentbox-setup && mkdir -p /dst/skills/agentbox-setup && cp -a ${IN_BOX_SETUP_GUIDE_PATH} ${SETUP_SKILL_DST} && chown -R 1000:1000 /dst/skills/agentbox-setup && echo SEEDED; } || true`
     ]);
     return { seeded: stdout.includes("SEEDED") };
   } catch {
@@ -360,19 +438,25 @@ async function seedSetupSkillIntoVolume(volume, image) {
   }
 }
 async function maybeFilterTo(src, dest, hostHome, opts = {}) {
+  const zero = {
+    removedHooks: 0,
+    installMethodFixed: false,
+    aliasedProjectKey: false,
+    workspaceTrusted: false
+  };
   let parsed;
   try {
     parsed = JSON.parse(await readFile(src, "utf8"));
   } catch {
-    return { removedHooks: 0, clearedInstallMethod: false, aliasedProjectKey: false };
+    return zero;
   }
   const filtered = filterHostHooks(parsed, hostHome);
   let working = filtered.data;
-  let cleared = false;
-  if (opts.clearInstallMethod) {
-    const r = clearInstallMethod(working);
+  let installFixed = false;
+  if (opts.setInstallMethodNative) {
+    const r = setInstallMethodNative(working);
     working = r.data;
-    cleared = r.cleared;
+    installFixed = r.applied;
   }
   let aliased = false;
   if (opts.aliasProject) {
@@ -380,14 +464,21 @@ async function maybeFilterTo(src, dest, hostHome, opts = {}) {
     working = r.data;
     aliased = r.aliased;
   }
-  if (filtered.removedCommands.length === 0 && !cleared && !aliased) {
-    return { removedHooks: 0, clearedInstallMethod: false, aliasedProjectKey: false };
+  let trusted = false;
+  if (opts.trustWorkspacePath) {
+    const r = trustWorkspace(working, opts.trustWorkspacePath);
+    working = r.data;
+    trusted = r.trusted;
+  }
+  if (filtered.removedCommands.length === 0 && !installFixed && !aliased && !trusted) {
+    return zero;
   }
   await writeFile(dest, JSON.stringify(working, null, 2));
   return {
     removedHooks: filtered.removedCommands.length,
-    clearedInstallMethod: cleared,
-    aliasedProjectKey: aliased
+    installMethodFixed: installFixed,
+    aliasedProjectKey: aliased,
+    workspaceTrusted: trusted
   };
 }
 var FORWARDED_ENV_KEYS = [
@@ -435,7 +526,18 @@ async function isDir(p) {
     return false;
   }
 }
+async function readReferencedPluginKeys(installedPluginsJsonPath) {
+  try {
+    const raw = await readFile(installedPluginsJsonPath, "utf8");
+    return referencedPluginVersionKeys(JSON.parse(raw));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
 async function scanPluginCacheForRebuild(cacheRoot) {
+  const referenced = await readReferencedPluginKeys(
+    join(cacheRoot, "..", "installed_plugins.json")
+  );
   let marketplaces;
   try {
     marketplaces = await readdir(cacheRoot, { withFileTypes: true });
@@ -462,6 +564,7 @@ async function scanPluginCacheForRebuild(cacheRoot) {
       }
       for (const v of versions) {
         if (!v.isDirectory()) continue;
+        if (referenced.size > 0 && !referenced.has(`${m.name}/${p.name}/${v.name}`)) continue;
         const vPath = join(pPath, v.name);
         if (!await isFile(join(vPath, "package.json"))) continue;
         if (await isFile(join(vPath, PLUGIN_INSTALLED_MARKER))) continue;
@@ -477,13 +580,38 @@ async function resolveClaudeCacheLiveOnHost(volume) {
   if (!await isDir(orbstackVolumePath(volume))) return null;
   return orbstackVolumePath(volume, "plugins", "cache");
 }
+async function readBoxReferencedPluginKeys(container) {
+  const res = await execa(
+    "docker",
+    [
+      "exec",
+      "--user",
+      CONTAINER_USER,
+      container,
+      "cat",
+      `${CONTAINER_CLAUDE_DIR}/plugins/installed_plugins.json`
+    ],
+    { reject: false }
+  );
+  if (res.exitCode !== 0 || !res.stdout) return /* @__PURE__ */ new Set();
+  try {
+    return referencedPluginVersionKeys(JSON.parse(res.stdout));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
 async function rebuildPluginNativeDeps(container, opts = {}) {
   if (opts.volume) {
     const cacheRoot = await resolveClaudeCacheLiveOnHost(opts.volume);
     if (cacheRoot && !await scanPluginCacheForRebuild(cacheRoot)) {
-      return { rebuilt: [], failed: [], skipped: true };
+      return { rebuilt: [], failed: [], pruned: [], prunedBytes: 0, skipped: true };
     }
   }
+  const referenced = await readBoxReferencedPluginKeys(container);
+  const refSetup = referenced.size > 0 ? `cat <<'AGENTBOX_REF_EOF' > "$WORK/referenced"
+${[...referenced].sort().join("\n")}
+AGENTBOX_REF_EOF
+` : "";
   const script = `set -u
 PLUGINS_DIR=/home/vscode/.claude/plugins/cache
 MARKER=${PLUGIN_INSTALLED_MARKER}
@@ -494,7 +622,12 @@ MAX=4
 [ -d "$PLUGINS_DIR" ] || exit 0
 mkdir -p "$NPM_CACHE"
 WORK=$(mktemp -d)
-relkey() { printf '%s' "\${1#$PLUGINS_DIR/}" | tr '/' '_'; }
+${refSetup}relkey() { printf '%s' "\${1#$PLUGINS_DIR/}" | tr '/' '_'; }
+# True when refs are unknown (no file) or $1 (<m>/<p>/<v>) is referenced.
+is_referenced() {
+  [ -s "$WORK/referenced" ] || return 0
+  grep -Fxq "$1" "$WORK/referenced"
+}
 # Run one plugin's install. $1 is frozen by value at call time, so it's safe
 # to read from the backgrounded subshell; the rest are set-once constants.
 do_one() {
@@ -514,10 +647,29 @@ do_one() {
     printf 'FAIL\\n' > "$WORK/$key.res"
   fi
 }
+# Prune pass: every unreferenced (stale) version dir loses its node_modules and
+# our markers. Only runs when installed_plugins.json gave us a reference set.
+if [ -s "$WORK/referenced" ]; then
+  for dir in "$PLUGINS_DIR"/*/*/*/; do
+    [ -d "$dir" ] || continue
+    rel=\${dir%/}; rel=\${rel#$PLUGINS_DIR/}
+    grep -Fxq "$rel" "$WORK/referenced" && continue
+    if [ -d "$dir/node_modules" ]; then
+      bytes=$(du -sb "$dir/node_modules" 2>/dev/null | cut -f1)
+      [ -n "$bytes" ] || bytes=0
+      rm -rf "$dir/node_modules" "$dir/$MARKER" "$dir/$FAILMARKER"
+      echo "PRUNE_OK $rel $bytes"
+    else
+      rm -f "$dir/$MARKER" "$dir/$FAILMARKER"
+    fi
+  done
+fi
 n=0
 for dir in "$PLUGINS_DIR"/*/*/*/; do
   [ -d "$dir" ] || continue
   [ -f "$dir/package.json" ] || continue
+  rel=\${dir%/}; rel=\${rel#$PLUGINS_DIR/}
+  is_referenced "$rel" || continue
   [ -f "$dir/$MARKER" ] && continue
   [ -n "$(find "$dir" -maxdepth 1 -name "$FAILMARKER" -mmin -$BACKOFF_MIN 2>/dev/null)" ] && continue
   echo "REBUILD_START \${dir#$PLUGINS_DIR/}"
@@ -554,6 +706,8 @@ rm -rf "$WORK"
   );
   const rebuilt = [];
   const failed = [];
+  const pruned = [];
+  let prunedBytes = 0;
   const lines = (result.stdout ?? "").split("\n");
   let collectingFail = null;
   for (const line of lines) {
@@ -572,9 +726,19 @@ rm -rf "$WORK"
       rebuilt.push(line.slice("REBUILD_OK ".length));
     } else if (line.startsWith("REBUILD_FAIL ")) {
       collectingFail = { dir: line.slice("REBUILD_FAIL ".length), stderr: [] };
+    } else if (line.startsWith("PRUNE_OK ")) {
+      const rest = line.slice("PRUNE_OK ".length);
+      const sp = rest.lastIndexOf(" ");
+      if (sp > 0) {
+        const dir = rest.slice(0, sp);
+        const bytes = Number(rest.slice(sp + 1));
+        pruned.push(dir);
+        if (Number.isFinite(bytes)) prunedBytes += bytes;
+        opts.onProgress?.(`pruning stale plugin cache ${dir}`);
+      }
     }
   }
-  return { rebuilt, failed, skipped: false };
+  return { rebuilt, failed, pruned, prunedBytes, skipped: false };
 }
 var ClaudeSessionError = class extends Error {
   constructor(message) {
@@ -732,6 +896,63 @@ function buildShellArgv(container) {
   const term = process.env["TERM"] ?? "xterm-256color";
   return ["exec", "-it", "-e", `TERM=${term}`, "--user", CONTAINER_USER, container, "bash", "-l"];
 }
+function buildClaudeLoginRunArgv(opts) {
+  const term = process.env["TERM"] ?? "xterm-256color";
+  return [
+    "run",
+    "-it",
+    "--rm",
+    "-e",
+    `TERM=${term}`,
+    "-e",
+    "DISPLAY=",
+    "-v",
+    `${opts.volume}:${CONTAINER_CLAUDE_DIR}`,
+    "--user",
+    CONTAINER_USER,
+    opts.image,
+    "claude",
+    "auth",
+    "login",
+    ...opts.extraArgs
+  ];
+}
+function runInteractiveClaudeLogin(dockerArgv) {
+  const child = spawnSync("docker", dockerArgv, { stdio: "inherit" });
+  return { exitCode: child.status ?? 1 };
+}
+async function warmUpClaudeCredentials(volume, image, opts = {}) {
+  const MAX_ATTEMPTS = 6;
+  const SLEEP_MS = 5e3;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    opts.onProgress?.(`checking credentials... ${attempt}/${MAX_ATTEMPTS}`);
+    const res = await execa(
+      "docker",
+      [
+        "run",
+        "--rm",
+        "-v",
+        `${volume}:${CONTAINER_CLAUDE_DIR}`,
+        "--user",
+        CONTAINER_USER,
+        "-e",
+        "DISABLE_AUTOUPDATER=1",
+        image,
+        "claude",
+        "--dangerously-skip-permissions",
+        "-p",
+        "ok"
+      ],
+      { reject: false, timeout: 6e4 }
+    );
+    const out = `${res.stdout ?? ""}
+${res.stderr ?? ""}`;
+    const apiError = /API Error|is not supported on this model|"type":\s*"error"/i.test(out);
+    if (res.exitCode === 0 && !apiError) return { warmed: true, attempts: attempt };
+    if (attempt < MAX_ATTEMPTS) await delay(SLEEP_MS);
+  }
+  return { warmed: false, attempts: MAX_ATTEMPTS };
+}
 function formatDetachNotice(ref) {
   return `Session detached. Reattach with: agentbox claude attach ${ref}`;
 }
@@ -1357,8 +1578,10 @@ async function createSnapshot(opts) {
   await Promise.all(toPrune.map((p) => rm2(p, { recursive: true, force: true })));
   return { destination, prunedPaths: toPrune };
 }
+var CTL_DAEMON_LOG = "/var/log/agentbox/ctl-daemon.log";
 async function launchCtlDaemon(container, hostSocketPath, timeoutMs = 3e3) {
-  const result = await execInBox(container, ["agentbox-ctl", "daemon"], {
+  const wrapped = `mkdir -p ${CTL_DAEMON_LOG.replace(/\/[^/]*$/, "")} && exec agentbox-ctl daemon >>${CTL_DAEMON_LOG} 2>&1`;
+  const result = await execInBox(container, ["sh", "-c", wrapped], {
     user: "vscode",
     detach: true
   });
@@ -1383,6 +1606,23 @@ async function pathExists2(p) {
     return false;
   }
 }
+async function ensureHomeOwnedByVscode(container) {
+  await execa5(
+    "docker",
+    [
+      "exec",
+      "--user",
+      "root",
+      container,
+      "chown",
+      "-R",
+      "--from=root",
+      "vscode:vscode",
+      "/home/vscode"
+    ],
+    { reject: false }
+  );
+}
 var STATE_DIR = join4(homedir3(), ".agentbox");
 var PID_FILE = join4(STATE_DIR, "relay.pid");
 var LOG_FILE = join4(STATE_DIR, "relay.log");
@@ -1411,7 +1651,7 @@ async function ensureRelay(opts = {}) {
   if (existingPid !== null && await processAlive(existingPid)) {
     for (let i = 0; i < 10; i++) {
       if (await pingHealthz(300)) return ENDPOINT;
-      await delay(200);
+      await delay2(200);
     }
     log(`relay pid ${String(existingPid)} alive but /healthz unresponsive \u2014 proceeding anyway`);
     return ENDPOINT;
@@ -1445,7 +1685,7 @@ async function ensureRelay(opts = {}) {
       log(`relay reachable on ${ENDPOINT.hostUrl}`);
       return ENDPOINT;
     }
-    await delay(200);
+    await delay2(200);
   }
   throw new Error(
     `relay did not become reachable on ${ENDPOINT.hostUrl} within 5s; see ${LOG_FILE}`
@@ -1501,7 +1741,7 @@ async function stopRelay() {
   }
   for (let i = 0; i < 20; i++) {
     if (!await processAlive(pid)) break;
-    await delay(100);
+    await delay2(100);
   }
   if (await processAlive(pid)) {
     try {
@@ -1624,6 +1864,26 @@ async function forgetBoxFromRelay(boxId) {
   } catch {
   }
 }
+async function setRelayNotice(boxId, kind, message, ttlMs) {
+  try {
+    const body = await adminPostForJson("/admin/notices/set", {
+      boxId,
+      kind,
+      message,
+      ...typeof ttlMs === "number" ? { ttlMs } : {}
+    });
+    const id = body?.id;
+    return typeof id === "string" && id.length > 0 ? id : null;
+  } catch {
+    return null;
+  }
+}
+async function clearRelayNotice(boxId, id) {
+  try {
+    await adminPost("/admin/notices/clear", { boxId, id });
+  } catch {
+  }
+}
 async function adminPost(path, body) {
   const json = JSON.stringify(body);
   await new Promise((resolveP, rejectP) => {
@@ -1662,6 +1922,49 @@ async function adminPost(path, body) {
     req.end();
   });
 }
+async function adminPostForJson(path, body) {
+  const json = JSON.stringify(body);
+  return new Promise((resolveP, rejectP) => {
+    const req = httpRequest(
+      {
+        host: "127.0.0.1",
+        port: PORT,
+        method: "POST",
+        path,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(json).toString()
+        },
+        timeout: 3e3
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const status = res.statusCode ?? 0;
+          if (status < 200 || status >= 300) {
+            rejectP(new Error(`relay ${path} \u2192 ${String(status)}`));
+            return;
+          }
+          const text = Buffer.concat(chunks).toString("utf8");
+          try {
+            resolveP(text.length > 0 ? JSON.parse(text) : {});
+          } catch (err) {
+            rejectP(err instanceof Error ? err : new Error(String(err)));
+          }
+        });
+        res.on("error", rejectP);
+      }
+    );
+    req.on("error", rejectP);
+    req.on("timeout", () => {
+      req.destroy();
+      rejectP(new Error(`relay ${path} timeout`));
+    });
+    req.write(json);
+    req.end();
+  });
+}
 async function rehydrateRelayRegistry(boxes) {
   for (const b of boxes) {
     if (!b.relayToken) continue;
@@ -1782,8 +2085,8 @@ async function ensureAgentboxTasksFile(container, services, opts = {}) {
   return { status: "wrote" };
 }
 async function writeFileInBox(container, path, content) {
-  const { execa: execa5 } = await import("execa");
-  const result = await execa5(
+  const { execa: execa6 } = await import("execa");
+  const result = await execa6(
     "docker",
     ["exec", "-i", "--user", "vscode", container, "sh", "-c", `cat > ${shellQuote(path)}`],
     { input: content, reject: false }
@@ -2296,6 +2599,9 @@ export {
   buildClaudeAttachArgv,
   buildClaudeDashboardAttachArgv,
   buildShellArgv,
+  buildClaudeLoginRunArgv,
+  runInteractiveClaudeLogin,
+  warmUpClaudeCredentials,
   formatDetachNotice,
   claudeSessionInfo,
   pullClaudeExtras,
@@ -2320,12 +2626,15 @@ export {
   snapshotPathFor,
   createSnapshot,
   launchCtlDaemon,
+  ensureHomeOwnedByVscode,
   ensureRelay,
   stopRelay,
   getRelayStatus,
   generateRelayToken,
   registerBoxWithRelay,
   forgetBoxFromRelay,
+  setRelayNotice,
+  clearRelayNotice,
   rehydrateRelayRegistry,
   ideProfile,
   SHARED_VSCODE_EXTENSIONS_VOLUME,
@@ -2343,4 +2652,4 @@ export {
   ConfigError,
   loadConfig
 };
-//# sourceMappingURL=chunk-PXUBE5KS.js.map
+//# sourceMappingURL=chunk-HTTKML3C.js.map