@cardstack/boxel-cli 0.1.3 → 0.1.4

package/src/lib/checkpoint-manager.ts

@@ -364,41 +364,46 @@ export class CheckpointManager {
       });
 
     return Promise.all(
-      lines.map(async (line) => {
-        const [hash, shortHash, subject, dateStr] = line.split('|');
-
-        const isMajor = subject.includes('[MAJOR]');
-        const source = subject.includes('[local]')
-          ? ('local' as const)
-          : subject.includes('[remote]')
-            ? ('remote' as const)
-            : ('manual' as const);
-
-        const message = subject
-          .replace(/\[(MAJOR|minor)\]\s*/i, '')
-          .replace(/\[(local|remote|manual)\]\s*/i, '');
-
-        const stats = await this.getCommitStats(hash);
-
-        const milestoneName = milestones.get(hash);
-        const isMilestone = !!milestoneName;
-
-        return {
-          hash,
-          shortHash,
-          message,
-          description: '',
-          date: new Date(dateStr),
-          isMajor,
-          source,
-          isMilestone,
-          milestoneName,
-          ...stats,
-        };
-      }),
+      lines.map((line) => this.parseCheckpointLine(line, milestones)),
     );
   }
 
+  private async parseCheckpointLine(
+    line: string,
+    milestones: Map<string, string>,
+  ): Promise<Checkpoint> {
+    const [hash, shortHash, subject, dateStr] = line.split('|');
+
+    const isMajor = subject.includes('[MAJOR]');
+    const source = subject.includes('[local]')
+      ? ('local' as const)
+      : subject.includes('[remote]')
+        ? ('remote' as const)
+        : ('manual' as const);
+
+    const message = subject
+      .replace(/\[(MAJOR|minor)\]\s*/i, '')
+      .replace(/\[(local|remote|manual)\]\s*/i, '');
+
+    const stats = await this.getCommitStats(hash);
+
+    const milestoneName = milestones.get(hash);
+    const isMilestone = !!milestoneName;
+
+    return {
+      hash,
+      shortHash,
+      message,
+      description: '',
+      date: new Date(dateStr),
+      isMajor,
+      source,
+      isMilestone,
+      milestoneName,
+      ...stats,
+    };
+  }
+
   private async getCommitStats(hash: string): Promise<{
     filesChanged: number;
     insertions: number;
@@ -575,8 +580,36 @@ export class CheckpointManager {
   }
 
   async getMilestones(): Promise<Checkpoint[]> {
-    const all = await this.getCheckpoints(100);
-    return all.filter((cp) => cp.isMilestone);
+    if (!(await this.isInitialized())) {
+      return [];
+    }
+    const milestones = await this.getAllMilestones();
+    if (milestones.size === 0) {
+      return [];
+    }
+
+    // Enumerate from the milestone tags directly so the result is complete
+    // regardless of how deep the tagged checkpoints sit in history. `--no-walk`
+    // limits `git log` to just the listed commits — no traversal, no implicit
+    // cap.
+    const format = '%H|%h|%s|%aI|%an';
+    const log = await this.git(
+      'log',
+      '--no-walk',
+      `--format=${format}`,
+      ...milestones.keys(),
+    );
+
+    if (!log.trim()) {
+      return [];
+    }
+
+    return Promise.all(
+      log
+        .trim()
+        .split('\n')
+        .map((line) => this.parseCheckpointLine(line, milestones)),
+    );
   }
 
   private git(...args: string[]): Promise<string> {

package/src/lib/profile-manager.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import jwt from 'jsonwebtoken';
 import { FG_YELLOW, FG_CYAN, FG_MAGENTA, DIM, BOLD, RESET } from './colors';
 import {
   matrixLogin,
@@ -16,6 +17,31 @@ import type { RealmAuthenticator } from './realm-authenticator';
 const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.boxel-cli');
 const PROFILES_FILENAME = 'profiles.json';
 
+/**
+ * Tokens issued by the realm server carry a 7-day TTL. Re-mint when
+ * there's less than a day left so a long-running operation (or a
+ * downstream consumer that bakes the token into a static header, like
+ * opencode's passthrough provider) doesn't get a 401 mid-flight.
+ *
+ * Decode-only — we don't verify the signature; the realm server does
+ * that on every request. We only care about the `exp` claim.
+ */
+const SERVER_TOKEN_EXPIRY_SAFETY_MARGIN_SEC = 86400; // 1 day
+
+function isJwtNearExpiry(
+  token: string,
+  safetyMarginSec = SERVER_TOKEN_EXPIRY_SAFETY_MARGIN_SEC,
+): boolean {
+  // Tokens are cached verbatim from the realm server's `Authorization`
+  // response header, so they're prefixed with `Bearer ` — strip it before
+  // decoding or jsonwebtoken returns null and we'd refresh on every call.
+  let raw = token.replace(/^Bearer\s+/i, '');
+  let decoded = jwt.decode(raw) as { exp?: number } | null;
+  if (!decoded?.exp) return true; // unparseable / missing exp → treat as expired
+  let nowSec = Math.floor(Date.now() / 1000);
+  return decoded.exp - nowSec < safetyMarginSec;
+}
+
 export const NO_ACTIVE_PROFILE_ERROR =
   'No active profile. Run `boxel profile add` to create one.';
 
@@ -371,7 +397,7 @@ export class ProfileManager implements RealmAuthenticator {
 
   async getOrRefreshServerToken(): Promise<string> {
     let cached = this.getRealmServerToken();
-    if (cached) {
+    if (cached && !isJwtNearExpiry(cached)) {
       return cached;
     }
     let matrixAuth = await this.loginToMatrix();

package/src/lib/realm-sync-base.ts

@@ -125,11 +125,13 @@ export abstract class RealmSyncBase {
     try {
       const url = this.buildDirectoryUrl(dir);
 
-      const response = await this.authenticator.authedRealmFetch(url, {
-        headers: {
-          Accept: 'application/vnd.api+json',
-        },
-      });
+      const response = await this.remoteLimit(() =>
+        this.authenticator.authedRealmFetch(url, {
+          headers: {
+            Accept: 'application/vnd.api+json',
+          },
+        }),
+      );
 
       if (!response.ok) {
         if (response.status === 404) {
@@ -167,10 +169,10 @@ export abstract class RealmSyncBase {
               }
               return [] as Array<[string, boolean]>;
             } else {
-              return this.remoteLimit(async () => {
+              return (async () => {
                 const subdirFiles = await this.getRemoteFileList(entryPath);
                 return Array.from(subdirFiles.entries());
-              });
+              })();
             }
           }),
         );

package/src/lib/watch-lock.ts

@@ -17,7 +17,7 @@ function lockPath(localDir: string): string {
   return path.join(localDir, LOCK_FILE);
 }
 
-function isProcessAlive(pid: number): boolean {
+export function isProcessAlive(pid: number): boolean {
   try {
     process.kill(pid, 0);
     return true;

package/src/lib/watch-process-registry.ts

@@ -0,0 +1,85 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { isProcessAlive } from './watch-lock';
+
+export interface RegisteredProcess {
+  pid: number;
+  workspace: string;
+  startedAt: string;
+}
+
+interface Registry {
+  processes: RegisteredProcess[];
+}
+
+function registryDir(): string {
+  return path.join(os.homedir(), '.boxel-cli');
+}
+
+function registryFile(): string {
+  return path.join(registryDir(), 'watch-processes.json');
+}
+
+async function readRegistry(): Promise<Registry> {
+  try {
+    const raw = await fs.readFile(registryFile(), 'utf8');
+    const parsed = JSON.parse(raw) as Partial<Registry>;
+    if (!Array.isArray(parsed?.processes)) {
+      return { processes: [] };
+    }
+    const processes = parsed.processes.filter(
+      (entry): entry is RegisteredProcess =>
+        typeof entry?.pid === 'number' &&
+        typeof entry?.workspace === 'string' &&
+        typeof entry?.startedAt === 'string',
+    );
+    return { processes };
+  } catch {
+    return { processes: [] };
+  }
+}
+
+async function writeRegistry(registry: Registry): Promise<void> {
+  await fs.mkdir(registryDir(), { recursive: true });
+  const target = registryFile();
+  const tmp = `${target}.${process.pid}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify(registry, null, 2) + '\n');
+  await fs.rename(tmp, target);
+}
+
+async function pruneDead(): Promise<Registry> {
+  const registry = await readRegistry();
+  const alive = registry.processes.filter((entry) => isProcessAlive(entry.pid));
+  if (alive.length !== registry.processes.length) {
+    await writeRegistry({ processes: alive });
+  }
+  return { processes: alive };
+}
+
+export async function registerProcess(workspace: string): Promise<void> {
+  const registry = await pruneDead();
+  const withoutCurrent = registry.processes.filter(
+    (entry) => entry.pid !== process.pid,
+  );
+  withoutCurrent.push({
+    pid: process.pid,
+    workspace,
+    startedAt: new Date().toISOString(),
+  });
+  await writeRegistry({ processes: withoutCurrent });
+}
+
+export async function unregisterCurrentProcess(): Promise<void> {
+  const registry = await readRegistry();
+  const next = registry.processes.filter((entry) => entry.pid !== process.pid);
+  if (next.length === registry.processes.length) {
+    return;
+  }
+  await writeRegistry({ processes: next });
+}
+
+export async function listRegisteredProcesses(): Promise<RegisteredProcess[]> {
+  const registry = await pruneDead();
+  return registry.processes;
+}