@runuai/host 0.8.20 → 0.8.22

package/lib/agent.ts

@@ -75,6 +75,8 @@ const TaskUpData = z.object({
   worktreePath: z.string(),
   codeServerPort: z.number().int().positive().optional(),
   previewPorts: PreviewPortRuntimesSchema.optional(),
+  /** Degraded start: uai-init failed twice; surfaced as a feed system note. */
+  initWarning: z.string().optional(),
 });
 export type TaskUpResult = z.infer<typeof TaskUpData>;
 

package/lib/git-identity.ts

@@ -3,9 +3,20 @@
  * are authored as the user who created the task, not the image's generic
  * identity. Best-effort, mirrors the SSH setup: a failure logs but never aborts
  * task-up. Name falls back to the email when no display name is known.
+ *
+ * ensureTaskSshIdentity re-asserts the SSH push identity + its DEPENDENT git
+ * config the same way gh tokens are re-asserted at channel ensure — the
+ * one-shot copy at task-up proved fragile (live 2026-07-21: a recreated
+ * container lost the key silently; a later repair restored the key WITHOUT
+ * the config and pushes stayed on HTTPS → 403). Key and config are a unit.
  */
 
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
 import { dockerCli } from "./docker-exec";
+import { env } from "./env";
+import { removeTaskIdentity, writeTaskIdentity } from "./ssh";
 
 const EXEC_TIMEOUT_MS = 10_000;
 
@@ -60,3 +71,90 @@ export async function setupTaskGitIdentity(
   console.log(`[git] task ${taskId}: git identity → ${displayName} <${email}>`);
   return true;
 }
+
+// The key's dependent git config, applied as one unit with the key itself:
+// SSH routing for every GitHub remote (mirrors are born with the project's
+// clone URL, usually https) + SSH commit/tag signing. Same statements as
+// uai-init's key-gated block — which silently self-skips when the key is
+// missing at ITS run time, hence re-applying here.
+const SSH_GIT_CONFIG =
+  'git config --global url."git@github.com:".insteadOf "https://github.com/"' +
+  ' && git config --global core.sshCommand "ssh -o StrictHostKeyChecking=accept-new"' +
+  " && git config --global gpg.format ssh" +
+  " && git config --global user.signingkey /home/node/.ssh/id_ed25519.pub" +
+  " && git config --global commit.gpgsign true" +
+  " && git config --global tag.gpgsign true";
+
+/**
+ * Copy the SSH identity at `keyPath` into the task container and apply its
+ * dependent git config. Every failure is LOGGED with its step — the silent
+ * `|| true` chain this replaces let a missing key masquerade as a GitHub
+ * permissions problem for an entire afternoon.
+ */
+export async function injectSshIdentity(
+  taskId: string,
+  keyPath: string,
+  exec: DockerExec = defaultExec,
+): Promise<boolean> {
+  const container = `task-${taskId}-app-1`;
+  const steps: ReadonlyArray<readonly [string, string[]]> = [
+    ["mkdir ~/.ssh", ["exec", "-u", "root", container, "mkdir", "-p", "/home/node/.ssh"]],
+    ["copy key", ["cp", keyPath, `${container}:/home/node/.ssh/id_ed25519`]],
+    ["copy pubkey", ["cp", `${keyPath}.pub`, `${container}:/home/node/.ssh/id_ed25519.pub`]],
+    [
+      "own + chmod",
+      [
+        "exec", "-u", "root", container, "sh", "-c",
+        "chown -R node:node /home/node/.ssh && chmod 700 /home/node/.ssh && chmod 600 /home/node/.ssh/id_ed25519",
+      ],
+    ],
+    ["ssh routing + signing config", ["exec", "-u", "node", container, "sh", "-c", SSH_GIT_CONFIG]],
+  ];
+  for (const [label, args] of steps) {
+    const res = await exec(args);
+    if (res.status !== 0) {
+      console.warn(
+        `[ssh] task ${taskId}: ${label} failed: ${res.stderr.trim() || `exit ${res.status}`}`,
+      );
+      return false;
+    }
+  }
+  console.log(`[ssh] task ${taskId}: push identity + git SSH config asserted`);
+  return true;
+}
+
+/**
+ * Materialize the task creator's SSH key (operator identity as fallback,
+ * mirroring task-up.sh), inject it + its git config into the container, and
+ * clean the on-disk private key back up. Safe to call on every channel
+ * ensure; a task with no identity anywhere logs once and pushes stay HTTPS.
+ */
+export async function ensureTaskSshIdentity(
+  taskId: string,
+  ownerUserId: string | null | undefined,
+  exec: DockerExec = defaultExec,
+): Promise<boolean> {
+  let keyPath: string | null = null;
+  let perTask = false;
+  const dir = writeTaskIdentity(taskId, ownerUserId);
+  if (dir) {
+    keyPath = resolve(dir, "id_ed25519");
+    perTask = true;
+  } else {
+    const operatorKey = resolve(env.dataDir, "identity", "id_ed25519");
+    if (existsSync(operatorKey)) keyPath = operatorKey;
+  }
+  if (!keyPath) {
+    console.log(
+      `[ssh] task ${taskId}: no SSH identity for owner or operator — git pushes stay on HTTPS`,
+    );
+    return false;
+  }
+  try {
+    return await injectSshIdentity(taskId, keyPath, exec);
+  } finally {
+    // Host hygiene (same as task-up): the materialized private key never
+    // outlives the injection.
+    if (perTask) removeTaskIdentity(taskId);
+  }
+}

package/lib/orchestrator.ts

@@ -35,7 +35,7 @@ import {
 import { ACTIVE_STATUSES } from "./task-status";
 import { getHostTask, upsertHostTask } from "./runtime-state";
 import { clearRefresh, setupTaskGithub } from "./github-tokens";
-import { setupTaskGitIdentity } from "./git-identity";
+import { ensureTaskSshIdentity, setupTaskGitIdentity } from "./git-identity";
 import { dockerCli } from "./docker-exec";
 import {
   containerSkillFile,
@@ -455,6 +455,11 @@ class Orchestrator {
       void setupTaskGithub(channel.taskId, task.ownerUserId);
     }
 
+    // SSH push identity + its git config, re-asserted like the gh token above
+    // (one-shot at task-up proved fragile — recreated containers lose the key
+    // silently; live 2026-07-21). Best-effort + non-blocking.
+    void ensureTaskSshIdentity(channel.taskId, task.ownerUserId);
+
     // ADR-047: install any package skills (native Claude Agent Skills) into the
     // container BEFORE spawning agents, so they're discoverable on the first
     // turn. Idempotent + best-effort (returns fast when there are none); a slow
@@ -1647,6 +1652,7 @@ async function recoverOneTask(
     if (task.ownerUserId) {
       void setupTaskGithub(task.taskId, task.ownerUserId);
     }
+    void ensureTaskSshIdentity(task.taskId, task.ownerUserId);
     return true;
   }
 
@@ -1686,6 +1692,7 @@ async function recoverOneTask(
   if (task.ownerUserId) {
     void setupTaskGithub(task.taskId, task.ownerUserId);
   }
+  void ensureTaskSshIdentity(task.taskId, task.ownerUserId);
   console.log(
     `[orchestrator] recovery: ${task.taskId} resumed (port ${port ?? "?"})`,
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.20",
+  "version": "0.8.22",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",

package/scripts/agent/task-down.sh

@@ -20,17 +20,23 @@ UAI_TASK_ID="$task_id"
 setup_err_trap
 
 step "TASK_NOT_FOUND" "read task row"
-task_json=$(db_get_task "$task_id")
-# Idempotent: it's fine if the task row is gone — emit success and return.
-if [ "$(jq 'length' <<<"$task_json")" -lt 1 ]; then
-  emit_ok '{"alreadyGone":true}'
-  exit 0
+# Teardown must never depend on bookkeeping: a broken/missing command
+# snapshot (seen live 2026-07-21 cleaning up after a failed task-up —
+# db_get_task errored, the trap reported TASK_NOT_FOUND, and the container
+# survived) still tears the stack down by convention-derived names.
+task_json=$(db_get_task "$task_id" 2>/dev/null) || task_json="[]"
+row_count=$(jq 'length' <<<"$task_json" 2>/dev/null) || row_count=0
+if [ "$row_count" -lt 1 ]; then
+  log "task row unavailable — tearing down by derived names"
+  worktree_path=""
+  compose_project="$(compose_project_for_task "$task_id")"
+  projects_json="[]"
+else
+  worktree_path=$(jq -r '.[0].worktree_path // ""' <<<"$task_json")
+  compose_project=$(jq -r '.[0].compose_project // ""' <<<"$task_json")
+  projects_json=$(db_get_projects_for_task "$task_id" 2>/dev/null) \
+    || projects_json="[]"
 fi
-
-worktree_path=$(jq -r '.[0].worktree_path // ""' <<<"$task_json")
-compose_project=$(jq -r '.[0].compose_project // ""' <<<"$task_json")
-
-projects_json=$(db_get_projects_for_task "$task_id")
 projects_root="$UAI_WORKSPACE_ROOT/projects"
 
 # task_dir falls back to the derived path when the row's worktree_path is

package/scripts/agent/task-up.sh

@@ -532,20 +532,41 @@ docker exec -u root "$app_container" \
 # else the operator identity — see above) into the container, so the agent signs
 # + pushes with the key whose .pub the user registered on GitHub. ADR-027 drops
 # the HTTPS/GH_TOKEN path; uai-init routes every GitHub remote over SSH.
-# Best-effort: signing + SSH push just stay off if the identity is absent.
+# Best-effort: signing + SSH push just stay off if the identity is absent —
+# but every failure is LOGGED (a silent miss here reads as a GitHub
+# permissions problem hours later; live 2026-07-21). The channel-ensure path
+# (ensureTaskSshIdentity) re-asserts all of this on reconnects.
 if [ -f "$uai_identity_key" ]; then
   docker exec -u root "$app_container" \
-    mkdir -p /home/node/.ssh >/dev/null 2>&1 || true
+    mkdir -p /home/node/.ssh >/dev/null 2>&1 \
+    || log "warning: ssh setup: mkdir ~/.ssh failed in $app_container"
   docker cp "$uai_identity_key" \
-    "$app_container":/home/node/.ssh/id_ed25519 >/dev/null 2>&1 || true
+    "$app_container":/home/node/.ssh/id_ed25519 >/dev/null 2>&1 \
+    || log "warning: ssh setup: key copy failed — pushes will fall back to HTTPS"
   docker cp "${uai_identity_key}.pub" \
-    "$app_container":/home/node/.ssh/id_ed25519.pub >/dev/null 2>&1 || true
+    "$app_container":/home/node/.ssh/id_ed25519.pub >/dev/null 2>&1 \
+    || log "warning: ssh setup: pubkey copy failed (signing will be off)"
   docker exec -u root "$app_container" sh -c \
     'chown -R node:node /home/node/.ssh && chmod 700 /home/node/.ssh && chmod 600 /home/node/.ssh/id_ed25519' \
-    >/dev/null 2>&1 || true
+    >/dev/null 2>&1 \
+    || log "warning: ssh setup: chown/chmod failed — key may be unreadable by node"
 fi
 
-docker exec "$app_container" /usr/local/bin/uai-init >/dev/null
+# uai-init (workspace deps + code-server) is re-runnable, and its death must
+# not error a task whose container is already up (graceful degradation): a
+# SIGKILLed exec session (observed live 2026-07-21, exit 137 with no timeout
+# anywhere on this path) used to fail the whole task over a step anyone can
+# re-run. Retry once, then come up DEGRADED with a warning the host surfaces
+# as a system note in the task feed.
+init_warning=""
+if ! docker exec "$app_container" /usr/local/bin/uai-init >/dev/null; then
+  log "warning: uai-init failed — retrying once"
+  sleep 2
+  if ! docker exec "$app_container" /usr/local/bin/uai-init >/dev/null; then
+    init_warning="Workspace init (deps + editor) failed twice — the task is up, but the editor and installed dependencies may be missing. Retry from a task terminal with: /usr/local/bin/uai-init"
+    log "warning: $init_warning"
+  fi
+fi
 
 # -----------------------------------------------------------------------------
 # 7. Discover code-server + preview ports, mark running, unlock.
@@ -588,7 +609,9 @@ emit_ok "$(jq -nc \
   --arg cp "$compose_project" \
   --arg wp "$task_dir" \
   --arg csport "${code_server_port:-}" \
+  --arg iw "${init_warning}" \
   --argjson previewPorts "$preview_ports_runtime_json" \
   '{composeProject:$cp,worktreePath:$wp}
    + (if $csport == "" then {} else {codeServerPort:($csport|tonumber)} end)
+   + (if $iw == "" then {} else {initWarning:$iw} end)
    + {previewPorts:$previewPorts}')"

package/src/index.ts

@@ -123,6 +123,14 @@ export const hostCommands: HostCommands = {
     if (result.ok) {
       recordTaskUpResult(input.task.id, result.value);
       recordHostEvent(input.task.id, "task.started");
+      // Degraded start (uai-init failed twice): the task is up, but say so
+      // in the feed — a silent half-start reads as a broken product.
+      if (result.value.initWarning) {
+        getOrchestrator().emitSystemNote(
+          input.task.id,
+          result.value.initWarning,
+        );
+      }
       // GitHub auth for the container is best-effort (ADR-027) and runs in the
       // background — it must never block or fail task-up. Awaiting it here would
       // couple the command result to a network token-exchange: a slow/hung

package/src/protocol.ts

@@ -93,6 +93,8 @@ export interface TaskUpResult {
   worktreePath: string;
   codeServerPort?: number;
   previewPorts?: Array<{ name: string; hostPort: number }>;
+  /** Degraded start: uai-init failed twice; the task is up without deps/editor. */
+  initWarning?: string;
 }
 
 export interface TaskDownResult {