@runuai/host 0.9.61 → 0.9.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.61",
+  "version": "0.9.63",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",

package/scripts/agent/task-up.sh

@@ -83,6 +83,10 @@ project_env_json=$(printf '%s' "$project_env_json" | jq -c '.')
 task_dir="$UAI_WORKSPACE_ROOT/tasks/$task_id"
 task_workspace="$task_dir/workspace"
 task_uai_dir="$task_dir/.uai"
+# Agents are told to save browser screenshots and other artifacts under
+# /workspace/.uai/attachments/, but nothing created the directory — every
+# first browser_take_screenshot hit ENOENT (found by an agent in the first
+# apple-container task, 2026-08-24). Created with the .uai dir below.
 projects_root="$UAI_WORKSPACE_ROOT/projects"
 compose_project=$(compose_project_for_task "$task_id")
 app_container=$(app_container_for_task "$task_id")
@@ -1279,7 +1283,7 @@ done < <(jq -c '.[]' <<<"$projects_json")
 # uid-501 macOS host. The sanitizer above repairs its rewritten control files
 # on every later resume.
 step "WORKTREE_FAILED" "share task files with container"
-mkdir -p "$task_uai_dir"
+mkdir -p "$task_uai_dir" "$task_uai_dir/attachments"
 # The shared group may be a broad host group (for example macOS `staff`). Keep
 # its writable leaves behind host-only parents; Docker bind-mounts the exact
 # workspace/repository roots, so node does not need host-path traversal here.
@@ -1327,7 +1331,7 @@ fi
 
 step "RENDER_FAILED" "generate compose"
 
-mkdir -p "$task_uai_dir"
+mkdir -p "$task_uai_dir" "$task_uai_dir/attachments"
 
 STANDARD_CONTAINER_DIR="${UAI_STANDARD_CONTAINER_ASSETS_DIR:-$SCRIPT_DIR/../../images/standard/container}"
 if ! STANDARD_CONTAINER_DIR=$(cd "$STANDARD_CONTAINER_DIR" && pwd -P); then

package/src/index.ts

@@ -168,7 +168,68 @@ export const hostEvents: HostEventStream = {
   },
 };
 
+/** Set by main.ts at boot: the drain-then-supervisor-respawn used for
+ * staged activation. A hook (not an import) because main imports this
+ * module. */
+let managedHostRestartHook: (() => void) | null = null;
+export function setManagedHostRestartHook(hook: () => void): void {
+  managedHostRestartHook = hook;
+}
+
 export const hostCommands: HostCommands = {
+  async hostUpdate(ctx) {
+    logCommand(ctx, "hostUpdate");
+    try {
+      const { updateManagedRuntime } = await import("../lib/managed-runtime");
+      const outcome = await updateManagedRuntime();
+      if (outcome.status === "not-managed") {
+        return {
+          ok: false,
+          code: HostErrorCode.Internal,
+          message:
+            "this host is not a managed install — update it where it runs",
+          retryable: false,
+        };
+      }
+      if (outcome.status === "deferred") {
+        // A rollback hold is an operator verdict that the newer release is
+        // unsafe on this host; a remote click must not override it.
+        return {
+          ok: true,
+          value: { version: outcome.version, staged: false, deferred: true },
+        };
+      }
+      if (outcome.status === "current") {
+        return { ok: true, value: { version: outcome.version, staged: false } };
+      }
+      managedHostRestartHook?.();
+      return { ok: true, value: { version: outcome.version, staged: true } };
+    } catch (error) {
+      return {
+        ok: false,
+        code: HostErrorCode.Internal,
+        message: `update failed: ${
+          error instanceof Error ? error.message : "unknown error"
+        }`,
+        retryable: true,
+      };
+    }
+  },
+  async hostRestart(ctx) {
+    logCommand(ctx, "hostRestart");
+    if (!managedHostRestartHook) {
+      return {
+        ok: false,
+        code: HostErrorCode.Internal,
+        message: "restart is unavailable in this process",
+        retryable: false,
+      };
+    }
+    // The result frame flushes before exit: shutdown drains in-flight
+    // commands (this one included) before the process terminates.
+    managedHostRestartHook();
+    return { ok: true, value: undefined };
+  },
   async taskUp(ctx, input) {
     logCommand(ctx, "taskUp", input.task.id);
     const admissionFailure = managedMaintenanceUnavailable();

package/src/main.ts

@@ -161,7 +161,7 @@ import {
   onAgentClisReady,
   standardRuntimes,
 } from "../lib/standard-image";
-import { hostCommands, hostEvents } from "./index";
+import { hostCommands, hostEvents, setManagedHostRestartHook } from "./index";
 import { EventOutbox, transmitEventOutbox } from "./event-outbox";
 import {
   HostErrorCode,
@@ -171,6 +171,7 @@ import {
   GITHUB_REPOSITORY_ACCESS_PROTOCOL_FEATURE,
   HOST_MAINTENANCE_READINESS_PROTOCOL_FEATURE,
   HOST_CONFIG_PROTOCOL_FEATURE,
+  HOST_REMOTE_LIFECYCLE_PROTOCOL_FEATURE,
   HOST_ENGINE_ACCOUNTS_PROTOCOL_FEATURE,
   HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
   HOST_ENGINE_LOGIN_PROTOCOL_FEATURE,
@@ -567,6 +568,7 @@ function buildCapabilities(): HostCapabilities {
       HOST_LOGS_PROTOCOL_FEATURE,
       HOST_ENGINE_LOGIN_PROTOCOL_FEATURE,
       HOST_CONFIG_PROTOCOL_FEATURE,
+      HOST_REMOTE_LIFECYCLE_PROTOCOL_FEATURE,
       HOST_ENGINE_ACCOUNTS_PROTOCOL_FEATURE,
       HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
       // The echo adapter cannot execute the in-task CLI. Advertising typed
@@ -2284,6 +2286,10 @@ async function dispatchCommand(
         expectString(args, 1),
         expectNumberArg(args, 2),
       );
+    case "hostUpdate":
+      return hostCommands.hostUpdate(ctx);
+    case "hostRestart":
+      return hostCommands.hostRestart(ctx);
     case "engineAccountRemove": {
       // ADR-116: mirror the local API's post-mutation behavior — the cloud's
       // account list self-heals through the capability re-advertisement.
@@ -3263,6 +3269,8 @@ export function requestManagedHostRestart(): void {
   shutdownExitCode = MANAGED_UPDATE_RESTART_EXIT_CODE;
   requestShutdown("SIGTERM");
 }
+// Remote hostUpdate/hostRestart commands reuse the exact activation restart.
+setManagedHostRestartHook(requestManagedHostRestart);
 
 /** Automatic host updates wait only for in-flight work to drain. Running
  * tasks are deliberately not counted: durable sessions survive the service

package/src/protocol.ts

@@ -86,6 +86,9 @@ export const MCP_GATEWAY_HEALTH_PROTOCOL_FEATURE = "mcp-gateway-health-v1";
 export const HOST_LOGS_PROTOCOL_FEATURE = "host-logs-v1";
 export const HOST_ENGINE_LOGIN_PROTOCOL_FEATURE = "host-engine-login-v1";
 export const HOST_CONFIG_PROTOCOL_FEATURE = "host-config-v1";
+/** Remote update/restart over the bridge (owner-gated cloud routes). */
+export const HOST_REMOTE_LIFECYCLE_PROTOCOL_FEATURE =
+  "host-remote-lifecycle-v1";
 /** ADR-116: labeled engine accounts on the cloud host page — account list in
  * capabilities, account-targeted login (`label` on engine.login.start), and
  * the engineAccountRemove command. */
@@ -1250,7 +1253,26 @@ export type FilesOpValue =
   | { dataBase64: string; size: number; eof: boolean } // read
   | Record<string, never>; // write / mkdir / delete
 
+export interface HostUpdateOutcome {
+  version: string;
+  /** True when a newer signed release was staged and the host is about to
+   * drain-restart into it; false when it was already current. */
+  staged: boolean;
+  /** Set when a rollback hold deferred the update (operator ran a rollback;
+   * remote updates respect that verdict). */
+  deferred?: boolean;
+}
+
 export interface HostCommands {
+  /**
+   * Stage a signed update from the release feed and drain-restart into it.
+   * Managed installs only; the host verifies the signature itself, so the
+   * remote trigger adds no trust surface. The reconnect on the new version
+   * is the real confirmation.
+   */
+  hostUpdate(ctx: CommandContext): Promise<HostCommandResult<HostUpdateOutcome>>;
+  /** Drain in-flight work, then let the service supervisor respawn the host. */
+  hostRestart(ctx: CommandContext): Promise<HostCommandResult<void>>;
   taskUp(
     ctx: CommandContext,
     input: TaskLaunchInput,