@runuai/host 0.2.6 → 0.2.8

package/db/migrations/0007_host_github_token_kind.sql

@@ -0,0 +1,7 @@
+-- ADR-033: non-expiring per-host tokens. `kind` distinguishes the stored token:
+--   'refresh' (legacy, ADR-027) → refresh_token_ct holds a refresh token; the
+--             host exchanges it for short-lived access tokens.
+--   'access'  (ADR-033)         → refresh_token_ct holds a long-lived, non-
+--             expiring access token; injected directly, no exchange/refresh.
+-- Existing rows default to 'refresh' (their current semantics).
+ALTER TABLE `host_github_tokens` ADD `kind` text DEFAULT 'refresh' NOT NULL;

package/db/migrations/meta/_journal.json

@@ -50,6 +50,13 @@
       "when": 1779900007000,
       "tag": "0006_host_project_env",
       "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "6",
+      "when": 1779900008000,
+      "tag": "0007_host_github_token_kind",
+      "breakpoints": true
     }
   ]
 }

package/db/schema.ts

@@ -62,9 +62,13 @@ export type NewHostEventRow = typeof hostEvents.$inferInsert;
 export const githubTokens = sqliteTable("host_github_tokens", {
   userId: text("user_id").primaryKey(),
   installationId: integer("installation_id").notNull(),
+  // ADR-033: holds a long-lived ACCESS token when kind="access", or a refresh
+  // token when kind="refresh" (legacy ADR-027). Encrypted at rest either way.
   refreshTokenCt: blob("refresh_token_ct").notNull(),
   refreshTokenNonce: blob("refresh_token_nonce").notNull(),
   refreshTokenExpiresAt: integer("refresh_token_expires_at"),
+  // "access" (non-expiring, ADR-033) | "refresh" (expiring, ADR-027).
+  kind: text("kind").notNull().default("refresh"),
   updatedAt: integer("updated_at").notNull(),
 });
 

package/lib/github-tokens.ts

@@ -26,56 +26,101 @@ type GhConnectSet = Extract<CloudToHost, { kind: "gh.connect.set" }>;
 
 // --- token store ------------------------------------------------------------
 
-/** Encrypt + persist the user's refresh token (gh.connect.set handler). */
+/**
+ * Encrypt + persist the user's token (gh.connect.set handler). ADR-033: a
+ * non-expiring grant carries `accessToken` (stored kind="access", injected
+ * directly); a legacy expiring grant carries `refreshToken` (kind="refresh",
+ * exchanged per task). Exactly one is present.
+ */
 export function onConnectSet(frame: GhConnectSet): { ok: boolean; error?: string } {
   try {
     // Fresh grant — a cached access token from the previous grant may be
     // revoked; drop it so the next mint exchanges against the new token.
     clearAccessCache(frame.userId);
-    const sealed = sealAesGcm(frame.refreshToken);
+    const token = frame.accessToken ?? frame.refreshToken;
+    if (!token) return { ok: false, error: "gh.connect.set carried no token" };
+    const kind = frame.accessToken ? "access" : "refresh";
+    const sealed = sealAesGcm(token);
     const now = Date.now();
+    const fields = {
+      installationId: frame.installationId,
+      refreshTokenCt: sealed.ct,
+      refreshTokenNonce: sealed.nonce,
+      refreshTokenExpiresAt: frame.refreshTokenExpiresAt ?? null,
+      kind,
+      updatedAt: now,
+    };
     getDb()
       .insert(schema.githubTokens)
-      .values({
-        userId: frame.userId,
-        installationId: frame.installationId,
-        refreshTokenCt: sealed.ct,
-        refreshTokenNonce: sealed.nonce,
-        refreshTokenExpiresAt: frame.refreshTokenExpiresAt ?? null,
-        updatedAt: now,
-      })
-      .onConflictDoUpdate({
-        target: schema.githubTokens.userId,
-        set: {
-          installationId: frame.installationId,
-          refreshTokenCt: sealed.ct,
-          refreshTokenNonce: sealed.nonce,
-          refreshTokenExpiresAt: frame.refreshTokenExpiresAt ?? null,
-          updatedAt: now,
-        },
-      })
+      .values({ userId: frame.userId, ...fields })
+      .onConflictDoUpdate({ target: schema.githubTokens.userId, set: fields })
       .run();
+    notifyGithubChange();
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : "store failed" };
   }
 }
 
-/** Delete a user's refresh token + clear their active-task refresh timers. */
-export function onConnectClear(userId: string): void {
-  deleteToken(userId);
-  for (const taskId of activeTaskIdsForUser(userId)) {
-    clearRefresh(taskId);
-    authExpiredHandler?.(taskId, userId, "GitHub disconnected");
+/**
+ * Disconnect GitHub on this host (gh.connect.clear handler). Deletes the token
+ * locally FIRST (so capabilities re-advertise immediately and the UI reflects
+ * removal without waiting on the network), then best-effort revokes it at
+ * GitHub. Whole body is guarded — a fired-and-forgotten failure must never
+ * crash the host (no global unhandledRejection handler).
+ *
+ * ADR-033: only a non-expiring ACCESS token can be revoked by token
+ * (`DELETE /applications/{client_id}/token` matches access tokens only — a
+ * refresh token 404s, which the cloud endpoint would mis-report as success).
+ * Legacy refresh tokens aren't single-token revocable; the short-lived access
+ * tokens they mint expire on their own.
+ */
+export async function onConnectClear(userId: string): Promise<void> {
+  try {
+    const stored = readStoredToken(userId);
+    deleteToken(userId); // fires onGithubChange → re-advertise capabilities
+    for (const taskId of activeTaskIdsForUser(userId)) {
+      clearRefresh(taskId);
+      authExpiredHandler?.(taskId, userId, "GitHub disconnected");
+    }
+    if (stored && stored.kind === "access") {
+      await revokeAtGitHub(stored.token);
+    } else if (stored) {
+      console.warn(
+        `[github] user ${userId}: legacy refresh token cleared locally; cannot single-token revoke at GitHub`,
+      );
+    }
+  } catch (err) {
+    console.warn(
+      `[github] disconnect failed: ${err instanceof Error ? err.message : err}`,
+    );
   }
 }
 
+/** Decrypt the user's stored token + its kind, or null if none. */
+function readStoredToken(
+  userId: string,
+): { token: string; kind: string } | null {
+  const row = getDb()
+    .select()
+    .from(schema.githubTokens)
+    .where(eq(schema.githubTokens.userId, userId))
+    .get();
+  if (!row) return null;
+  const token = openAesGcm(
+    Buffer.from(row.refreshTokenCt as Uint8Array),
+    Buffer.from(row.refreshTokenNonce as Uint8Array),
+  );
+  return { token, kind: row.kind };
+}
+
 export function deleteToken(userId: string): void {
   clearAccessCache(userId);
   getDb()
     .delete(schema.githubTokens)
     .where(eq(schema.githubTokens.userId, userId))
     .run();
+  notifyGithubChange();
 }
 
 export function hasToken(userId: string): boolean {
@@ -88,6 +133,29 @@ export function hasToken(userId: string): boolean {
   );
 }
 
+/** All cloud user ids with a GitHub token on this host (for capabilities). */
+export function connectedUserIds(): string[] {
+  return getDb()
+    .select({ userId: schema.githubTokens.userId })
+    .from(schema.githubTokens)
+    .all()
+    .map((r) => r.userId);
+}
+
+// Fires whenever the set of stored tokens changes (add/remove), so the host
+// can re-advertise capabilities and the UI reflects per-host gh state promptly.
+let githubChangeHandler: (() => void) | null = null;
+export function onGithubChange(fn: (() => void) | null): void {
+  githubChangeHandler = fn;
+}
+function notifyGithubChange(): void {
+  try {
+    githubChangeHandler?.();
+  } catch {
+    /* never let a listener break token handling */
+  }
+}
+
 function activeTaskIdsForUser(userId: string): string[] {
   return getDb()
     .select({ taskId: schema.hostTasks.taskId })
@@ -104,12 +172,43 @@ function activeTaskIdsForUser(userId: string): string[] {
 
 // --- access-token exchange --------------------------------------------------
 
-function exchangeUrl(): string {
+function cloudHttpBase(): string {
   const cloud = process.env.UAI_CLOUD_URL ?? "ws://127.0.0.1:8789/host";
   const u = new URL(cloud);
   const proto =
     u.protocol === "wss:" ? "https:" : u.protocol === "ws:" ? "http:" : u.protocol;
-  return `${proto}//${u.host}/api/github/oauth/exchange`;
+  return `${proto}//${u.host}`;
+}
+
+function exchangeUrl(): string {
+  return `${cloudHttpBase()}/api/github/oauth/exchange`;
+}
+
+/**
+ * Revoke a token at GitHub via the cloud (which holds the App client secret —
+ * the host can't revoke alone). Same host→cloud HTTP pattern as the exchange;
+ * the token transits the cloud transiently, never stored (ADR-015/ADR-033).
+ * Best-effort — callers proceed to delete locally regardless.
+ */
+async function revokeAtGitHub(token: string): Promise<void> {
+  try {
+    const res = await fetch(`${cloudHttpBase()}/api/github/revoke`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-uai-host-token": process.env.UAI_HOST_TOKEN ?? "",
+      },
+      body: JSON.stringify({ token }),
+      signal: AbortSignal.timeout(EXCHANGE_TIMEOUT_MS),
+    });
+    if (!res.ok) {
+      console.warn(`[github] token revoke returned HTTP ${res.status}`);
+    }
+  } catch (err) {
+    console.warn(
+      `[github] token revoke failed (deleting locally anyway): ${err instanceof Error ? err.message : err}`,
+    );
+  }
 }
 
 interface ExchangeResult {
@@ -165,7 +264,23 @@ export function clearAllAccessCache(): void {
 
 export function requestAccessToken(
   userId: string,
-): Promise<{ accessToken: string; expiresAt: number } | null> {
+): Promise<{ accessToken: string; expiresAt: number | null } | null> {
+  // ADR-033 non-expiring path: the stored token IS the access token — return it
+  // directly, no exchange/cache/rotation. `expiresAt: null` ⇒ no refresh.
+  const row = getDb()
+    .select({ kind: schema.githubTokens.kind })
+    .from(schema.githubTokens)
+    .where(eq(schema.githubTokens.userId, userId))
+    .get();
+  if (!row) return Promise.resolve(null);
+  if (row.kind === "access") {
+    const stored = readStoredToken(userId);
+    return Promise.resolve(
+      stored ? { accessToken: stored.token, expiresAt: null } : null,
+    );
+  }
+
+  // Legacy expiring path (ADR-027): cache + in-flight dedupe + exchange.
   const cached = accessCache.get(userId);
   if (cached && cached.expiresAt - Date.now() > ACCESS_CACHE_LEAD_MS) {
     return Promise.resolve(cached);
@@ -327,7 +442,8 @@ async function runRefresh(taskId: string, userId: string): Promise<void> {
       return;
     }
     await injectIntoContainer(taskId, tok.accessToken);
-    scheduleRefresh(taskId, userId, tok.expiresAt);
+    // Only re-schedule for an expiring token; non-expiring needs no refresh.
+    if (tok.expiresAt !== null) scheduleRefresh(taskId, userId, tok.expiresAt);
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     // A revoked / expired refresh token can't recover — drop it to force a
@@ -423,7 +539,7 @@ export interface SetupTaskDeps {
   hasToken?: (userId: string) => boolean;
   requestAccessToken?: (
     userId: string,
-  ) => Promise<{ accessToken: string; expiresAt: number } | null>;
+  ) => Promise<{ accessToken: string; expiresAt: number | null } | null>;
   inject?: (taskId: string, token: string) => void | Promise<void>;
   schedule?: (taskId: string, userId: string, expiresAt: number) => void;
   deleteToken?: (userId: string) => void;
@@ -460,7 +576,8 @@ export async function setupTaskGithub(
       const tok = await _request(userId);
       if (tok) {
         await _inject(taskId, tok.accessToken);
-        _schedule(taskId, userId, tok.expiresAt);
+        // Non-expiring (ADR-033) tokens (expiresAt null) need no refresh timer.
+        if (tok.expiresAt !== null) _schedule(taskId, userId, tok.expiresAt);
         clearGithubRetry(taskId);
         console.log(`[github] task ${taskId}: injected user access token`);
         return true;

package/lib/orchestrator.ts

@@ -741,10 +741,16 @@ export function buildSystemPreamble(
     "",
     `Agents in this channel: ${others}.`,
     "",
+    "The human you're working with is **@you**. When you need their",
+    "input, a decision, or their attention — a question, a blocker, an",
+    "approval, or you've finished and are handing back to them — end your",
+    "message by @-mentioning **@you** (e.g. `@you which approach do you`",
+    "`prefer?` or `@you done — PR is up for review`). That notifies them.",
+    "",
     "An agent only receives a message when it is explicitly @-mentioned",
-    "(or addressed by the human) — so always @-mention the agent you mean.",
-    "There is NO `peer` command and no shared tmux session; hand-offs are",
-    "just @-mentions in your replies.",
+    "(or addressed by the human) — so always @-mention the agent (or @you)",
+    "you mean. There is NO `peer` command and no shared tmux session;",
+    "hand-offs are just @-mentions in your replies.",
     "",
     "Because your input is only what you're addressed, you may be missing",
     "context from messages between the human and the other agents. The full",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "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

@@ -25,8 +25,10 @@ import {
 import { getHostTask } from "../lib/runtime-state";
 import { getOrchestrator } from "../lib/orchestrator";
 import {
+  connectedUserIds,
   onConnectClear,
   onConnectSet,
+  onGithubChange,
   setAuthExpiredHandler,
 } from "../lib/github-tokens";
 import {
@@ -166,6 +168,7 @@ function buildCapabilities(): HostCapabilities {
   return {
     agentKinds: agentKindCapabilities(),
     runtimes: standardRuntimes(),
+    githubUsers: connectedUserIds(),
   };
 }
 
@@ -181,6 +184,9 @@ function sendCapabilities(): void {
 }
 
 onRegistryChange(() => sendCapabilities());
+// Re-advertise when a gh token is added/removed (ADR-033) so the host page's
+// per-host connected state updates promptly.
+onGithubChange(() => sendCapabilities());
 
 function connect(): void {
   if (stopping || fatal) return;
@@ -284,7 +290,15 @@ function connect(): void {
         break;
       }
       case "gh.connect.clear":
-        onConnectClear(frame.userId);
+        // Delete-then-revoke (ADR-033) is async + best-effort; ack immediately
+        // so the UI isn't gated on the GitHub revoke round-trip. The .catch is
+        // a belt over onConnectClear's own try/catch — a fire-and-forget
+        // rejection must never crash the host.
+        void onConnectClear(frame.userId).catch((err) =>
+          console.warn(
+            `[github] connect.clear failed: ${err instanceof Error ? err.message : err}`,
+          ),
+        );
         send(socket, { kind: "gh.connect.ack", userId: frame.userId, ok: true });
         break;
       case "ssh.key.get":
@@ -830,7 +844,9 @@ function parseCloudFrame(data: RawData): CloudToHost | null {
     typeof frame.installationId === "number" &&
     typeof frame.githubLogin === "string" &&
     (frame.targetType === "User" || frame.targetType === "Organization") &&
-    typeof frame.refreshToken === "string"
+    // Exactly one token kind: accessToken (ADR-033) or refreshToken (ADR-027).
+    (typeof frame.accessToken === "string" ||
+      typeof frame.refreshToken === "string")
   ) {
     return {
       kind: "gh.connect.set",
@@ -838,7 +854,10 @@ function parseCloudFrame(data: RawData): CloudToHost | null {
       installationId: frame.installationId,
       githubLogin: frame.githubLogin,
       targetType: frame.targetType,
-      refreshToken: frame.refreshToken,
+      accessToken:
+        typeof frame.accessToken === "string" ? frame.accessToken : undefined,
+      refreshToken:
+        typeof frame.refreshToken === "string" ? frame.refreshToken : undefined,
       refreshTokenExpiresAt:
         typeof frame.refreshTokenExpiresAt === "number"
           ? frame.refreshTokenExpiresAt

package/src/protocol.ts

@@ -68,6 +68,10 @@ export interface HostCapabilities {
     kind: string;
     availableVersions: string[];
   }>;
+  // ADR-033: cloud user ids that currently have a GitHub token ON THIS HOST —
+  // the per-host gh-connected state shown on the host detail page. Re-advertised
+  // whenever a token is added/removed. Optional: older hosts omit it.
+  githubUsers?: string[];
 }
 
 export interface TaskUpResult {
@@ -305,18 +309,25 @@ export type CloudToHost =
   // never responds, so the cloud never sends an ack. (HTTP tunnels only.)
   | { kind: "tunnel.requestEnd"; tunnelId: string }
   | { kind: "tunnel.close"; tunnelId: string; reason?: string }
-  // GitHub App connect lifecycle (ADR-027). The cloud forwards the user's
-  // refresh token to the host, which encrypts + persists it; the per-task
-  // access-token exchange is a host→cloud HTTP POST, not a frame.
+  // GitHub App connect lifecycle (ADR-027 / ADR-033). The cloud forwards the
+  // user's token to the host, which encrypts + persists it. Exactly one token
+  // is present:
+  //   - `accessToken`  → non-expiring per-host token (ADR-033). Injected into
+  //                      containers directly; no exchange, no refresh.
+  //   - `refreshToken` → legacy expiring token (ADR-027). The host exchanges it
+  //                      for short-lived access tokens (host→cloud HTTP POST).
   | {
       kind: "gh.connect.set";
       userId: string;
       installationId: number;
       githubLogin: string;
       targetType: "User" | "Organization";
-      refreshToken: string;
+      accessToken?: string;
+      refreshToken?: string;
       refreshTokenExpiresAt?: number;
     }
+  // Delete the user's token on the host. ADR-033: the host first POSTs the
+  // token to the cloud's /api/github/revoke (kill it at GitHub) before deleting.
   | { kind: "gh.connect.clear"; userId: string }
   // Per-user SSH key lifecycle (ADR-029). Keys are generated + stored on the
   // host; only the public key crosses the bridge (ssh.key.ack). `get` fetches