@vibedeckx/linux-x64 0.3.33 → 0.3.35

package/dist/bin.js

@@ -186887,7 +186887,8 @@ var mapLocalActivity = (row) => {
       parseActivityTimestamp(row.created_at) ?? 0
     ),
     lastUserMessageAt: row.last_user_message_at,
-    lastCompletedAt: row.last_completed_at
+    lastCompletedAt: row.last_completed_at,
+    favoritedAt: row.favorited_at
   };
 };
 var observeLocalActivity = (consumer, row) => {
@@ -186915,6 +186916,7 @@ var localActivityBase = (kdb, projectId) => {
     "s.updated_at",
     "s.last_user_message_at",
     "s.last_completed_at",
+    "s.favorited_at",
     "checkout.worktree_path",
     "checkout.deleted_at as checkout_deleted_at",
     "checkout.status as checkout_status",
@@ -187196,6 +187198,12 @@ var createAgentSessionRepos = (kdb, h) => ({
       await observeDanglingLocalScope(kdb, consumer, projectId);
       return rows.map(mapLocalActivity);
     },
+    listFavoritedActivityByProject: async (projectId, limit, consumer) => {
+      const rows = await localActivityBase(kdb, projectId).where(visibleLifecycleOf("s")).where("s.favorited_at", "is not", null).orderBy("s.favorited_at", "desc").orderBy("s.id", "desc").limit(limit).execute();
+      rows.forEach((row) => observeLocalActivity(consumer, row));
+      await observeDanglingLocalScope(kdb, consumer, projectId);
+      return rows.map(mapLocalActivity);
+    },
     countRunningByProject: async (projectId) => {
       const row = await kdb.selectFrom("agent_sessions").select(kdb.fn.countAll().as("count")).where("project_id", "=", projectId).where("status", "=", "running").where(visibleLifecycle).executeTakeFirstOrThrow();
       return Number(row.count);
@@ -188166,7 +188174,8 @@ var mapRemoteActivity = (row) => {
     model: row.model,
     lastActiveAt: row.last_active_at,
     lastUserMessageAt: row.last_user_message_at,
-    lastCompletedAt: row.last_completed_at
+    lastCompletedAt: row.last_completed_at,
+    favoritedAt: row.favorited_at
   };
 };
 var observeRemoteActivity = (consumer, row) => {
@@ -188234,6 +188243,7 @@ var remoteActivityBase = (kdb, projectId) => remoteSessionScope(kdb, projectId).
   "c.model",
   "c.last_user_message_at",
   "c.last_completed_at",
+  "c.favorited_at",
   "checkout.worktree_path",
   "checkout.deleted_at as checkout_deleted_at",
   "checkout.status as checkout_status",
@@ -188269,6 +188279,12 @@ var createSearchCacheRepos = (kdb, _h) => ({
       await observeDanglingRemoteActivity(kdb, consumer, projectId);
       return rows.map(mapRemoteActivity);
     },
+    listRemoteSessionFavoritesByProject: async (projectId, limit, consumer) => {
+      const rows = await remoteActivityBase(kdb, projectId).where("c.favorited_at", "is not", null).orderBy("c.favorited_at", "desc").orderBy("c.local_session_id", "asc").limit(limit).execute();
+      rows.forEach((row) => observeRemoteActivity(consumer, row));
+      await observeDanglingRemoteActivity(kdb, consumer, projectId);
+      return rows.map(mapRemoteActivity);
+    },
     countRemoteSessionActivityByProject: async (projectId) => {
       const row = await remoteSessionScope(kdb, projectId).select([
         sql`coalesce(sum(case when c.status = 'running' then 1 else 0 end), 0)`.as("running")
@@ -188450,6 +188466,39 @@ var createSearchCacheRepos = (kdb, _h) => ({
     updateCachedSessionTitle: async (localSessionId, title) => {
       await kdb.updateTable("session_search_cache").set({ title, written_at: Date.now() }).where("local_session_id", "=", localSessionId).execute();
     },
+    // Star write-through. Unlike the title and delete write-throughs this one
+    // may CREATE the row: the remote favorite PATCH has already succeeded on
+    // the worker, so the session provably exists, and the path that lists a
+    // remote's sessions (where the star button lives) binds only a mapping —
+    // no cache row. Before that target's first catalog snapshot there would be
+    // nothing to update and the star would sit invisible, which is the exact
+    // latency this write-through exists to remove. Only starring creates a
+    // row; an unstar with no row has nothing to hide (see noteSessionDeleted).
+    updateCachedSessionFavorited: async (localSessionId, favoritedAt) => {
+      const now3 = Date.now();
+      const updated = await kdb.updateTable("session_search_cache").set({ favorited_at: favoritedAt, written_at: now3 }).where("local_session_id", "=", localSessionId).executeTakeFirst();
+      if (Number(updated?.numUpdatedRows ?? 0) > 0 || favoritedAt === null) return;
+      const mapping = await kdb.selectFrom("remote_session_mappings").select(["project_id", "remote_server_id", "branch"]).where("local_session_id", "=", localSessionId).executeTakeFirst();
+      if (!mapping || mapping.remote_server_id === "local") return;
+      await kdb.insertInto("session_search_cache").values({
+        local_session_id: localSessionId,
+        project_id: mapping.project_id,
+        target_id: mapping.remote_server_id,
+        branch: toDbBranch(mapping.branch),
+        title: null,
+        last_active_at: null,
+        favorited_at: favoritedAt,
+        entry_count: 0,
+        status: "unknown",
+        agent_type: null,
+        model: null,
+        last_user_message_at: null,
+        last_completed_at: null,
+        generation: 0,
+        deleted_at: null,
+        written_at: now3
+      }).onConflict((oc) => oc.column("local_session_id").doUpdateSet({ favorited_at: favoritedAt, written_at: now3 })).execute();
+    },
     // Create write-through: called where a remote session's creation transits
     // the server (UI create proxy, commander spawn, branch-from-history). The
     // written_at stamp keeps the row exempt from snapshot reconciliation until
@@ -240344,7 +240393,7 @@ ${opts.reviewFocus}` : null,
 ## Scope \u2014 the change under review
 
 The reviewed turn changed exactly these files:
-${scope.changedFiles.map((f2) => `- ${f2}`).join("\n")}
+${scope.changedFiles.map((f2) => `- \`${f2}\``).join("\n")}
 
 It starts from commit \`${scope.startHead}\` \u2014 use \`git diff ${scope.startHead} -- <file>\` and \`git log ${scope.startHead}..HEAD\` to see the content.
 
@@ -251385,6 +251434,16 @@ var routes11 = async (fastify2) => {
         `/api/agent-sessions/${remoteInfo.remoteSessionId}/favorite`,
         { favorited }
       );
+      if (result.ok) {
+        try {
+          await fastify2.storage.searchCache.updateCachedSessionFavorited(
+            req.params.sessionId,
+            favorited ? Date.now() : null
+          );
+        } catch (err) {
+          console.error("[API] searchCache.updateCachedSessionFavorited failed:", err);
+        }
+      }
       return reply.code(proxyStatus(result)).send(result.data);
     }
     const session = await fastify2.storage.agentSessions.getById(req.params.sessionId);
@@ -252467,17 +252526,19 @@ var RECENT_SESSION_LIMIT = 8;
 var RECENT_RUN_LIMIT = 5;
 var PRIORITY_TASK_LIMIT = 5;
 var ATTENTION_LIMIT = 10;
+var STARRED_LIMIT = 50;
 var parseDbTimestamp4 = (value) => {
   if (!value) return null;
   const explicitZone = /(?:Z|[+-]\d\d:\d\d)$/i.test(value);
   const parsed = Date.parse(explicitZone ? value : `${value.replace(" ", "T")}Z`);
   return Number.isNaN(parsed) ? null : parsed;
 };
-var mergeActivity = (local, remote, limit) => {
+var mergeBy = (local, remote, limit, rank) => {
   const byId = /* @__PURE__ */ new Map();
   for (const row of [...local, ...remote]) if (!byId.has(row.id)) byId.set(row.id, row);
-  return [...byId.values()].sort((left, right) => (right.lastActiveAt ?? 0) - (left.lastActiveAt ?? 0) || left.id.localeCompare(right.id)).slice(0, limit);
+  return [...byId.values()].sort((left, right) => rank(right) - rank(left) || left.id.localeCompare(right.id)).slice(0, limit);
 };
+var mergeActivity = (local, remote, limit) => mergeBy(local, remote, limit, (row) => row.lastActiveAt ?? 0);
 async function getProjectActivity(storage2, projectId, userId) {
   const [
     recentThreads,
@@ -252487,6 +252548,8 @@ async function getProjectActivity(storage2, projectId, userId) {
     priorityTasks,
     localAttentionSessions,
     remoteAttentionSessions,
+    localStarredSessions,
+    remoteStarredSessions,
     attentionRuns,
     runningSessions,
     runningRuns,
@@ -252500,6 +252563,8 @@ async function getProjectActivity(storage2, projectId, userId) {
     storage2.tasks.listPriorityByProject(projectId, PRIORITY_TASK_LIMIT),
     storage2.agentSessions.listAttentionActivityByProject(projectId, ATTENTION_LIMIT, "project-activity"),
     storage2.searchCache.listRemoteSessionAttentionByProject(projectId, ATTENTION_LIMIT, "project-activity"),
+    storage2.agentSessions.listFavoritedActivityByProject(projectId, STARRED_LIMIT + 1, "project-activity"),
+    storage2.searchCache.listRemoteSessionFavoritesByProject(projectId, STARRED_LIMIT + 1, "project-activity"),
     storage2.scheduledTaskRuns.getAttentionByProject(projectId, ATTENTION_LIMIT),
     storage2.agentSessions.countRunningActivityByProject(projectId),
     storage2.scheduledTaskRuns.countByProjectStatuses(projectId, ["starting", "running"]),
@@ -252516,6 +252581,14 @@ async function getProjectActivity(storage2, projectId, userId) {
     remoteAttentionSessions,
     ATTENTION_LIMIT
   );
+  const starredProbe = mergeBy(
+    localStarredSessions,
+    remoteStarredSessions,
+    STARRED_LIMIT + 1,
+    (row) => row.favoritedAt ?? 0
+  );
+  const starredHasMore = starredProbe.length > STARRED_LIMIT;
+  const starredSessions = starredProbe.slice(0, STARRED_LIMIT);
   const attention = [
     ...attentionSessions.map((session) => ({
       type: "agent_session",
@@ -252540,6 +252613,8 @@ async function getProjectActivity(storage2, projectId, userId) {
   return {
     recentThreads,
     recentAgentSessions,
+    starredSessions,
+    starredHasMore,
     recentScheduleRuns,
     priorityTasks,
     attention,
@@ -263527,6 +263602,10 @@ var MACHINE_KEY_SETTING = "reverse_machine_private_key";
 var RECONNECT_BASE_DELAY_MS = 1e3;
 var RECONNECT_MAX_DELAY_MS = 3e4;
 var NO_PING_TIMEOUT_MS = 4e4;
+var HANDSHAKE_TIMEOUT_MS = 2e4;
+var SUPERVISOR_INTERVAL_MS = 1e4;
+var DIAL_TIMEOUT_MS = 25e3;
+var CLOSING_TIMEOUT_MS = 1e4;
 var AUTH_REJECT_CODES = /* @__PURE__ */ new Set([4001, 4003]);
 var HEALTHY_CONNECTION_MS = 5e3;
 function isTextualContentType(contentType2) {
@@ -263544,7 +263623,13 @@ var ReverseConnectClient = class {
   reconnectAttempt = 0;
   openedAt = null;
   reconnectTimer = null;
-  noPingTimer = null;
+  supervisorTimer = null;
+  /** When the current dial started — the CONNECTING watchdog's reference point. */
+  dialStartedAt = 0;
+  /** Last time the hub said anything on the control socket (a superset of pings). */
+  lastFrameAt = 0;
+  /** First tick that observed CLOSING, so a stalled teardown can be forced. */
+  closingSince = 0;
   shuttingDown = false;
   constructor(localServer, serverUrl, token, localPort) {
     this.localServer = localServer;
@@ -263554,27 +263639,42 @@ var ReverseConnectClient = class {
   }
   connect() {
     if (this.shuttingDown) return;
+    this.startSupervisor();
+    if (this.ws) {
+      console.warn("[ReverseClient] connect() called with a live socket \u2014 discarding the old one");
+      const stale = this.ws;
+      this.ws = null;
+      try {
+        stale.terminate();
+      } catch {
+      }
+    }
     const cleanUrl = this.serverUrl.replace(/\/+$/, "");
     const wsProtocol = cleanUrl.startsWith("https") ? "wss" : "ws";
     const wsUrl = cleanUrl.replace(/^https?/, wsProtocol);
     const connectUrl = `${wsUrl}/api/reverse-connect?token=${encodeURIComponent(this.token)}`;
     console.log(`[ReverseClient] Connecting to ${cleanUrl}...`);
-    this.ws = new wrapper_default(connectUrl, {
-      maxPayload: 11 * 1024 * 1024
-    });
-    this.ws.on("open", () => {
+    this.dialStartedAt = Date.now();
+    this.closingSince = 0;
+    const ws = new wrapper_default(connectUrl, {
+      maxPayload: 11 * 1024 * 1024,
+      handshakeTimeout: HANDSHAKE_TIMEOUT_MS
+    });
+    this.ws = ws;
+    ws.on("open", () => {
       console.log("[ReverseClient] Socket open, awaiting server handshake");
       this.openedAt = Date.now();
-      this.resetNoPingTimer();
+      this.lastFrameAt = Date.now();
       const frame = {
         type: "status",
         ready: true,
         version: readPackageVersion(),
         capabilities: WORKER_CAPABILITY_KEYS
       };
-      this.ws.send(JSON.stringify(frame));
+      ws.send(JSON.stringify(frame));
     });
-    this.ws.on("message", (data) => {
+    ws.on("message", (data) => {
+      this.lastFrameAt = Date.now();
       try {
         const frame = JSON.parse(data.toString());
         this.handleFrame(frame);
@@ -263582,48 +263682,127 @@ var ReverseConnectClient = class {
         console.error("[ReverseClient] Failed to parse frame:", err);
       }
     });
-    this.ws.on("close", (code, reason) => {
+    ws.on("close", (code, reason) => {
       const safeReason = redactSecretForms(reason?.toString() || "", this.token);
-      const rejected = AUTH_REJECT_CODES.has(code);
-      const uptime = this.openedAt === null ? 0 : Date.now() - this.openedAt;
-      if (rejected) {
-        console.error(
-          `[ReverseClient] Server rejected this connection (code=${code}, reason=${safeReason}). ` + (code === 4001 ? "The connect token is no longer valid \u2014 open Settings \u2192 Remote Servers, read the current token, and re-run `vibedeckx connect` with it." : "This machine's identity was refused \u2014 the remote record may belong to another machine or another account.") + " Retrying with backoff, but it will not recover on its own."
-        );
-      } else {
-        console.log(`[ReverseClient] Disconnected (code=${code}, reason=${safeReason})`);
-      }
-      if (!rejected && this.openedAt !== null && uptime >= HEALTHY_CONNECTION_MS) {
-        this.reconnectAttempt = 0;
-      }
-      this.openedAt = null;
-      this.clearNoPingTimer();
-      this.closeAllLocalChannels();
-      void this.localServer.remoteMcpSessionManager?.closeAll("reverse-connect disconnected");
-      this.ws = null;
-      if (!this.shuttingDown) {
-        this.scheduleReconnect();
-      }
+      this.handleDisconnect(ws, `code=${code}, reason=${safeReason}`, code);
     });
-    this.ws.on("error", (err) => {
+    ws.on("error", (err) => {
+      if (ws !== this.ws) return;
       console.error(
         "[ReverseClient] WebSocket error:",
         redactErrorSecret(err, this.token)
       );
     });
   }
+  /**
+   * The single "this connection is over" funnel. Reached from the close event,
+   * from the supervisor declaring a socket dead, or from both in that order —
+   * so it keys on socket identity and schedules at most one reconnect per
+   * connection.
+   */
+  handleDisconnect(ws, reason, code) {
+    if (ws !== null && ws !== this.ws) return;
+    const rejected = code !== void 0 && AUTH_REJECT_CODES.has(code);
+    const uptime = this.openedAt === null ? 0 : Date.now() - this.openedAt;
+    if (rejected) {
+      console.error(
+        `[ReverseClient] Server rejected this connection (${reason}). ` + (code === 4001 ? "The connect token is no longer valid \u2014 open Settings \u2192 Remote Servers, read the current token, and re-run `vibedeckx connect` with it." : "This machine's identity was refused \u2014 the remote record may belong to another machine or another account.") + " Retrying with backoff, but it will not recover on its own."
+      );
+    } else {
+      console.log(`[ReverseClient] Disconnected (${reason})`);
+    }
+    if (!rejected && this.openedAt !== null && uptime >= HEALTHY_CONNECTION_MS) {
+      this.reconnectAttempt = 0;
+    }
+    this.openedAt = null;
+    this.closingSince = 0;
+    this.closeAllLocalChannels();
+    void this.localServer.remoteMcpSessionManager?.closeAll("reverse-connect disconnected");
+    this.ws = null;
+    if (ws) {
+      try {
+        ws.terminate();
+      } catch {
+      }
+    }
+    if (this.shuttingDown) return;
+    if (this.reconnectTimer) return;
+    this.scheduleReconnect();
+  }
+  startSupervisor() {
+    if (this.supervisorTimer) return;
+    this.supervisorTimer = setInterval(() => this.superviseTick(), SUPERVISOR_INTERVAL_MS);
+    this.supervisorTimer.unref?.();
+  }
+  stopSupervisor() {
+    if (!this.supervisorTimer) return;
+    clearInterval(this.supervisorTimer);
+    this.supervisorTimer = null;
+  }
+  /**
+   * Level-triggered recovery: judges the current state against the wall clock
+   * rather than waiting to be armed by an event. That is what survives a dial
+   * that never completes, a close frame the peer never answers, and a host that
+   * was suspended for hours.
+   */
+  superviseTick() {
+    if (this.shuttingDown) return;
+    const now3 = Date.now();
+    const ws = this.ws;
+    if (ws === null) {
+      if (!this.reconnectTimer) {
+        console.warn("[ReverseClient] Supervisor: no socket and no pending reconnect \u2014 self-healing");
+        this.scheduleReconnect();
+      }
+      return;
+    }
+    switch (ws.readyState) {
+      case wrapper_default.CONNECTING: {
+        const stuckFor = now3 - this.dialStartedAt;
+        if (stuckFor > DIAL_TIMEOUT_MS) {
+          console.warn(
+            `[ReverseClient] Supervisor: dial stuck ${Math.round(stuckFor / 1e3)}s with no handshake \u2014 terminating`
+          );
+          this.handleDisconnect(ws, "dial timeout");
+        }
+        break;
+      }
+      case wrapper_default.OPEN: {
+        const silentFor = now3 - this.lastFrameAt;
+        if (silentFor > NO_PING_TIMEOUT_MS) {
+          console.warn(
+            `[ReverseClient] Supervisor: no hub traffic for ${Math.round(silentFor / 1e3)}s \u2014 terminating`
+          );
+          this.handleDisconnect(ws, "no ping timeout");
+        }
+        break;
+      }
+      case wrapper_default.CLOSING: {
+        if (this.closingSince === 0) {
+          this.closingSince = now3;
+        } else if (now3 - this.closingSince > CLOSING_TIMEOUT_MS) {
+          console.warn("[ReverseClient] Supervisor: close handshake stalled \u2014 terminating");
+          this.handleDisconnect(ws, "closing stalled");
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
   shutdown() {
     this.shuttingDown = true;
-    this.clearNoPingTimer();
+    this.stopSupervisor();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
     this.closeAllLocalChannels();
-    if (this.ws && (this.ws.readyState === wrapper_default.OPEN || this.ws.readyState === wrapper_default.CONNECTING)) {
-      this.ws.close(1e3, "Shutdown");
-    }
+    const ws = this.ws;
     this.ws = null;
+    if (ws && (ws.readyState === wrapper_default.OPEN || ws.readyState === wrapper_default.CONNECTING)) {
+      ws.close(1e3, "Shutdown");
+    }
   }
   async handleFrame(frame) {
     switch (frame.type) {
@@ -263796,7 +263975,6 @@ var ReverseConnectClient = class {
     }
   }
   handlePing(frame) {
-    this.resetNoPingTimer();
     const pong = { type: "pong", ts: frame.ts };
     this.sendFrame(pong);
   }
@@ -263819,21 +263997,6 @@ var ReverseConnectClient = class {
       this.connect();
     }, totalDelay);
   }
-  resetNoPingTimer() {
-    this.clearNoPingTimer();
-    this.noPingTimer = setTimeout(() => {
-      console.log(`[ReverseClient] No ping received in ${NO_PING_TIMEOUT_MS / 1e3}s, reconnecting...`);
-      if (this.ws) {
-        this.ws.close(1e3, "No ping timeout");
-      }
-    }, NO_PING_TIMEOUT_MS);
-  }
-  clearNoPingTimer() {
-    if (this.noPingTimer) {
-      clearTimeout(this.noPingTimer);
-      this.noPingTimer = null;
-    }
-  }
   closeAllLocalChannels() {
     for (const [id, ws] of this.localChannels) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"