@runuai/host 0.7.1 → 0.8.1

package/lib/agent-cli.ts

@@ -239,6 +239,41 @@ async function main() {
       out(action + " #" + t.shortId + ": " + t.text);
       break;
     }
+    case "preview add": {
+      const name = pos[0] || flags.name;
+      const port = Number(pos[1] || flags.port);
+      if (!name || !Number.isInteger(port)) { console.error("uai: preview add <name> <containerPort>"); process.exit(1); }
+      const r = await api("POST", "/api/agent/previews", { name, containerPort: port });
+      out("preview '" + r.name + "' on port " + r.containerPort + " — enable it in the task's preview menu to get a URL");
+      break;
+    }
+    case "project create": {
+      const name = flags.name || pos.join(" ");
+      if (!name || !flags.repo) { console.error("uai: project create --name <n> --repo <git-url> [--prompt <p>]"); process.exit(1); }
+      const p = (await api("POST", "/api/agent/projects", { name, repoUrl: flags.repo, defaultPrompt: flags.prompt || undefined })).project;
+      out("created project " + p.slug + " (" + p.id + ")");
+      break;
+    }
+    case "task search": {
+      const q = pos.join(" ") || flags.q || "";
+      if (!q) { console.error("uai: task search <query>"); process.exit(1); }
+      const hits = (await api("GET", "/api/agent/history?q=" + encodeURIComponent(q))).messages || [];
+      if (!hits.length) { out("no matches in your past tasks"); break; }
+      out(hits.map((h) => "[" + h.taskName + "] @" + h.author + ": " + h.snippet).join("\\n"));
+      break;
+    }
+    case "task read": {
+      const id = pos[0] || flags.id;
+      if (!id) { console.error("uai: task read <taskId>  (see 'uai task history')"); process.exit(1); }
+      const chat = await api("GET", "/api/agent/history?taskId=" + encodeURIComponent(id));
+      out("# " + chat.taskName + "\\n" + (chat.messages || []).map((m) => "@" + m.author + ": " + m.snippet).join("\\n"));
+      break;
+    }
+    case "task history": {
+      const tasks = (await api("GET", "/api/agent/history")).tasks || [];
+      out(tasks.length ? tasks.map((t) => t.taskId + "  " + t.taskName + " (" + t.status + ")").join("\\n") : "no past tasks");
+      break;
+    }
     case "whoami ": case "whoami undefined": out({ apiUrl: API_URL }); break;
     case "react heart": case "react check": case "react x": {
       const r = await api("POST", "/api/agent/react", { emoji: action, msg: flags.msg || undefined });
@@ -258,6 +293,11 @@ async function main() {
         "  uai todo list",
         "  uai todo add <text>",
         "  uai todo claim|done|reopen|unclaim <#id>",
+        "  uai preview add <name> <containerPort>",
+        "  uai project create --name <n> --repo <git-url> [--prompt <p>]",
+        "  uai task search <query>            (your own past tasks)",
+        "  uai task history                   (list your past tasks)",
+        "  uai task read <taskId>             (full chat of a past task you were on)",
         "  uai react <heart|check|x> [--msg #id]   (no --msg = the message you were last handed)",
         "  uai whoami",
       ].join("\\n"));

package/lib/github-tokens.ts

@@ -56,6 +56,11 @@ export function onConnectSet(frame: GhConnectSet): { ok: boolean; error?: string
       .onConflictDoUpdate({ target: schema.githubTokens.userId, set: fields })
       .run();
     notifyGithubChange();
+    // A reconnect must reach ALREADY-RUNNING containers, not just new tasks:
+    // each container's gh config is written once, at task setup, so a fresh
+    // grant otherwise sits unused until /retry-gh. Re-inject into the user's
+    // live tasks now. Fire-and-forget — never blocks the token store.
+    reinjectRunningTasks(frame.userId);
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : "store failed" };
@@ -170,6 +175,20 @@ function activeTaskIdsForUser(userId: string): string[] {
     .map((r) => r.taskId);
 }
 
+/**
+ * Re-mint + inject a (re)connected token into the user's live tasks — so a
+ * reconnect on Account applies to running containers, not only new tasks. Clear
+ * any armed retry chain first (a fresh grant must not be swallowed by an outage
+ * backoff, and `setupTaskGithub`'s duplicate-chain guard would no-op it) then
+ * run setup fresh. Fire-and-forget per task; best-effort by construction.
+ */
+export function reinjectRunningTasks(userId: string): void {
+  for (const taskId of activeTaskIdsForUser(userId)) {
+    clearRefresh(taskId);
+    void setupTaskGithub(taskId, userId);
+  }
+}
+
 // --- access-token exchange --------------------------------------------------
 
 function cloudHttpBase(): string {
@@ -434,6 +453,37 @@ function isRevokedTokenError(reason: string): boolean {
   return /revoked|invalid_grant|bad_refresh/i.test(reason);
 }
 
+/**
+ * True when the failure names a genuinely bad credential — GitHub answered the
+ * validation with 401/403 ("Bad credentials"), so the token really is wrong and
+ * only a reconnect fixes it. Distinct from a 5xx blip (see below).
+ */
+function isBadCredentialError(reason: string): boolean {
+  return /validating token: HTTP 40[13]\b|Bad credentials|401 Unauthorized|403 Forbidden/i.test(
+    reason,
+  );
+}
+
+/**
+ * True when the failure is a GitHub-side / network blip that a retry will heal
+ * — the API returned 5xx (as happens when `gh auth login` validates the token
+ * against api.github.com during an outage), a rate-limit, or the fetch itself
+ * failed. Such a failure must NOT be surfaced as "authentication expired —
+ * reconnect": the token is fine, GitHub is briefly unavailable. A genuine bad
+ * credential (401/403) is explicitly excluded so it still routes to reconnect.
+ */
+export function isTransientGithubError(reason: string): boolean {
+  if (isBadCredentialError(reason)) return false;
+  return (
+    /HTTP 5\d\d|Service Unavailable|Bad Gateway|Gateway Time-?out|server error|rate limit|too many requests|secondary rate|unavailable|unreachable/i.test(
+      reason,
+    ) ||
+    /\bfetch failed\b|timeout|timed out|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ECONNABORTED|ENOTFOUND|EAI_AGAIN|socket hang up|\bnetwork\b/i.test(
+      reason,
+    )
+  );
+}
+
 async function runRefresh(taskId: string, userId: string): Promise<void> {
   try {
     const tok = await requestAccessToken(userId);
@@ -602,10 +652,16 @@ export async function setupTaskGithub(
       authExpiredHandler?.(taskId, userId, reason);
       return false;
     }
+    // A retry chain already armed for this task means a sibling entry point
+    // (task-up and channel-ensure both call setup) already reported this and
+    // owns recovery — don't post a duplicate note or start a competing chain.
+    // `/retry-gh` clears the chain first, so a manual retry is never swallowed.
+    if (attempt === 0 && retryTimers.has(taskId)) return false;
     // Transient: self-heal with bounded backoff. Post the chat note only on
     // the FIRST failure of a chain — each retry re-enters this catch, and six
     // "gh auth" notes for one outage is noise. Exhaustion posts its own note
-    // (in scheduleGithubRetry).
+    // (in scheduleGithubRetry). The handler classifies the reason (transient
+    // 5xx blip vs. genuine expiry) and words the note accordingly.
     if (attempt === 0) authExpiredHandler?.(taskId, userId, reason);
     scheduleGithubRetry(taskId, userId, attempt, deps);
     return false;

package/lib/orchestrator.ts

@@ -34,7 +34,7 @@ import {
 } from "./agents/types";
 import { ACTIVE_STATUSES } from "./task-status";
 import { getHostTask, upsertHostTask } from "./runtime-state";
-import { setupTaskGithub } from "./github-tokens";
+import { clearRefresh, setupTaskGithub } from "./github-tokens";
 import { setupTaskGitIdentity } from "./git-identity";
 import { dockerCli } from "./docker-exec";
 import {
@@ -571,6 +571,9 @@ class Orchestrator {
       return;
     }
     this.emitSystemNote(taskId, "gh: retrying authentication…");
+    // Cancel any armed auto-retry chain so this manual attempt runs fresh
+    // (setup's duplicate-chain guard would otherwise no-op it).
+    clearRefresh(taskId);
     const ok = await setupTaskGithub(taskId, owner);
     this.emitSystemNote(
       taskId,
@@ -1230,6 +1233,15 @@ export function buildSystemPreamble(
             (agent.permissions?.includes("todo.write")
               ? ", `todo list|add|claim|done`"
               : "") +
+            (agent.permissions?.includes("previews.write")
+              ? ", `preview add <name> <port>`"
+              : "") +
+            (agent.permissions?.includes("projects.write")
+              ? ", `project create --name --repo`"
+              : "") +
+            (agent.permissions?.includes("tasks.history")
+              ? ", `task search <query>` / `task read <id>`"
+              : "") +
             ", `react <heart|check|x> [--msg #id]`.",
           "**Reacting:** `uai react check` is a lightweight ack of the message",
           "you were last handed — use it to acknowledge an instruction or",
@@ -1271,6 +1283,23 @@ export function buildSystemPreamble(
                 "watches the same list in the task UI.",
               ]
             : []),
+          ...(agent.permissions?.includes("tasks.history")
+            ? [
+                "**Your task history:** you can recall your OWN past work —",
+                `\`node ${CONTAINER_CLI_PATH} task search <query>\` searches the`,
+                "chat of every past task you were on (not the human's tasks —",
+                "yours), and `task read <taskId>` pulls a full transcript. Use",
+                "it like a broader memory: before reinventing something, check",
+                "whether you've solved it before.",
+              ]
+            : []),
+          ...(agent.permissions?.includes("previews.write")
+            ? [
+                "**Previews:** started a dev server? `preview add <name>",
+                "<containerPort>` exposes it so the human can open it (they",
+                "enable it from the task's preview menu).",
+              ]
+            : []),
           "",
         ]
       : []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "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/src/main.ts

@@ -26,6 +26,7 @@ import { getHostTask } from "../lib/runtime-state";
 import { getOrchestrator } from "../lib/orchestrator";
 import {
   connectedUserIds,
+  isTransientGithubError,
   onConnectClear,
   onConnectSet,
   onGithubChange,
@@ -135,14 +136,20 @@ interface PausableSource {
 
 console.log(`[host-agent] starting host ${hostId}`);
 migrateHostDb();
-// When a task's GitHub token can't be refreshed (revoked, disconnected,
-// expired), surface it in the task channel so the user can re-grant (ADR-027).
+// Surface a task's GitHub setup failure in its channel (ADR-027). Classify the
+// reason first: a GitHub-side 5xx / network blip (e.g. `gh auth login`
+// validating the token during a github.com outage) is transient and self-heals
+// on the bounded retry — telling the user their auth "expired" and to reconnect
+// would be wrong and alarming. Only a genuine expiry/revocation asks for a
+// reconnect. Both cases keep retrying in the background regardless.
 setAuthExpiredHandler((taskId, _userId, reason) => {
-  getOrchestrator().emitSystemNote(
-    taskId,
-    `gh authentication expired (reason: ${reason}). Reconnect GitHub on ` +
-      `Account, then run /retry-gh in this task to restore.`,
-  );
+  const note = isTransientGithubError(reason)
+    ? `GitHub is temporarily unavailable — ${reason}. Uai is retrying ` +
+      `automatically; no action needed unless this persists (then run ` +
+      `/retry-gh).`
+    : `gh authentication expired (reason: ${reason}). Reconnect GitHub on ` +
+      `Account, then run /retry-gh in this task to restore.`;
+  getOrchestrator().emitSystemNote(taskId, note);
 });
 // Best-effort: build the standard image + asdf volume if missing. Logs and
 // continues on failure (e.g. docker unavailable) so the host still boots.