pi-freeflow 1.44.1 → 1.45.0

package/src/cline-pool.ts

@@ -37,7 +37,57 @@ export const CLINE_POOL_FILE = resolveClinePoolPath();
  * overridden from the backup.
  */
 export const CLINE_POOL_BACKUP_FILE = `${CLINE_POOL_FILE}.bak`;
+export const CLINE_POOL_LOCK_FILE = `${CLINE_POOL_FILE}.lock`;
+const CLINE_LOCK_STALE_MS = 30_000;
 
+export function tryAcquireClineLock(depth = 0): boolean {
+ if (depth >= 3) return false;
+ try {
+  fs.writeFileSync(CLINE_POOL_LOCK_FILE, String(process.pid), { flag: "wx" });
+  return true;
+ } catch (e) {
+  const code = (e as NodeJS.ErrnoException | null)?.code;
+  if (code !== "EEXIST") {
+   return false;
+  }
+  let stale = false;
+  try {
+   stale = Date.now() - fs.statSync(CLINE_POOL_LOCK_FILE).mtimeMs > CLINE_LOCK_STALE_MS;
+  } catch {
+   return tryAcquireClineLock(depth + 1);
+  }
+  if (!stale) {
+   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+   return tryAcquireClineLock(depth + 1);
+  }
+  try {
+   fs.rmSync(CLINE_POOL_LOCK_FILE, { force: true });
+  } catch {
+   return false;
+  }
+  return tryAcquireClineLock(depth + 1);
+ }
+}
+
+export function releaseClineLock(): void {
+ try { fs.rmSync(CLINE_POOL_LOCK_FILE, { force: true }); } catch { }
+}
+
+export function withClineLock<T>(fn: () => T): T {
+ const locked = tryAcquireClineLock();
+ if (!locked) {
+  logWarn("cline pool lock held — proceeding without lock", {
+   lock: CLINE_POOL_LOCK_FILE,
+  });
+ }
+ try {
+  return fn();
+ } finally {
+  if (locked) {
+   releaseClineLock();
+  }
+ }
+}
 /** One saved login slot. The token is only ever sent as an explicit bearer header. */
 export interface ClineAccount {
  slot: string;
@@ -336,8 +386,7 @@ export function keepLargestBackup(raw: string): void {
    backupCount = -1;
   }
   if (count <= backupCount) return;
-  fs.writeFileSync(CLINE_POOL_BACKUP_FILE, raw, { encoding: "utf8", mode: 0o600 });
-  try { fs.chmodSync(CLINE_POOL_BACKUP_FILE, 0o600); } catch { }
+  writeFileAtomic(CLINE_POOL_BACKUP_FILE, raw, { mode: 0o600 });
  } catch { }
 }
 
@@ -367,8 +416,7 @@ export function forgetAccountInBackup(removed: ClineAccount): void {
   });
   if (kept.length === doc.accounts.length) return;
   doc.accounts = kept;
-  fs.writeFileSync(CLINE_POOL_BACKUP_FILE, JSON.stringify(doc, null, 2), { encoding: "utf8", mode: 0o600 });
-  try { fs.chmodSync(CLINE_POOL_BACKUP_FILE, 0o600); } catch { }
+  writeFileAtomic(CLINE_POOL_BACKUP_FILE, JSON.stringify(doc, null, 2), { mode: 0o600 });
  } catch { }
 }
 
@@ -424,19 +472,23 @@ export function redactedToken(token: string): string {
  * slot that no longer exists is left alone rather than resurrected.
  */
 export function patchAccountOnDisk(slot: string, patch: Partial<ClineAccount>): void {
- const live = readPoolFile();
- const target = live.accounts.find((a) => a.slot === slot);
- if (!target) return;
- Object.assign(target, patch);
- savePool(live);
+ withClineLock(() => {
+  const live = readPoolFile();
+  const target = live.accounts.find((a) => a.slot === slot);
+  if (!target) return;
+  Object.assign(target, patch);
+  savePool(live);
+ });
 }
 
 /** Record which slot served a turn, without clobbering concurrent edits. */
 export function markActiveSlotOnDisk(slot: string): void {
- const live = readPoolFile();
- if (!live.accounts.some((a) => a.slot === slot)) return;
- live.activeSlot = slot;
- savePool(live);
+ withClineLock(() => {
+  const live = readPoolFile();
+  if (!live.accounts.some((a) => a.slot === slot)) return;
+  live.activeSlot = slot;
+  savePool(live);
+ });
 }
 
 /**
@@ -448,19 +500,21 @@ export function markActiveSlotOnDisk(slot: string): void {
  * resurrected. The row carries counters only — never token or identity.
  */
 export function recordClineUsageOnDisk(slot: string, modelId: string): void {
- const cleanSlot = (slot || "").trim();
- if (!cleanSlot) return;
- const live = readPoolFile();
- if (!live.accounts.some((a) => a.slot === cleanSlot)) return;
- const prev = live.usage?.[cleanSlot];
- const served = typeof prev?.served === "number" && Number.isFinite(prev.served) && prev.served >= 0
-  ? Math.floor(prev.served) + 1
-  : 1;
- live.usage = {
-  ...(live.usage ?? {}),
-  [cleanSlot]: { served, lastAt: Date.now(), lastModel: (modelId || "").trim() },
- };
- savePool(live);
+ withClineLock(() => {
+  const cleanSlot = (slot || "").trim();
+  if (!cleanSlot) return;
+  const live = readPoolFile();
+  if (!live.accounts.some((a) => a.slot === cleanSlot)) return;
+  const prev = live.usage?.[cleanSlot];
+  const served = typeof prev?.served === "number" && Number.isFinite(prev.served) && prev.served >= 0
+   ? Math.floor(prev.served) + 1
+   : 1;
+  live.usage = {
+   ...(live.usage ?? {}),
+   [cleanSlot]: { served, lastAt: Date.now(), lastModel: (modelId || "").trim() },
+  };
+  savePool(live);
+ });
 }
 
 /** The reset still in force for one slot+requested model, or null when free. */
@@ -477,30 +531,32 @@ export function activeLimitFor(pool: ClinePoolState, slot: string, model: string
  * would revert a login added or removed while the request was in flight.
  */
 export function recordLimitOnDisk(slot: string, model: string, resetAt: number): void {
- if (!model) return;
- const live = readPoolFile();
- if (!live.accounts.some((a) => a.slot === slot)) return;
- const known = live.limits?.[slot]?.[model];
- // Keep the later of the two: a fresh report must not shorten a window that is
- // already known, and repeating the same reset writes nothing.
- if (typeof known === "number" && known >= resetAt) return;
- const limits = live.limits ?? {};
- limits[slot] = { ...(limits[slot] ?? {}), [model]: resetAt };
- live.limits = limits;
- savePool(live);
+ withClineLock(() => {
+  if (!model) return;
+  const live = readPoolFile();
+  if (!live.accounts.some((a) => a.slot === slot)) return;
+  const known = live.limits?.[slot]?.[model];
+  if (typeof known === "number" && known >= resetAt) return;
+  const limits = live.limits ?? {};
+  limits[slot] = { ...(limits[slot] ?? {}), [model]: resetAt };
+  live.limits = limits;
+  savePool(live);
+ });
 }
 
 /** Drop one slot+model limit once that slot serves the model again. */
 export function clearLimitOnDisk(slot: string, model: string): void {
- if (!model) return;
- const live = readPoolFile();
- const limits = live.limits;
- const forSlot = limits?.[slot];
- if (!limits || !forSlot || typeof forSlot[model] !== "number") return;
- delete forSlot[model];
- if (Object.keys(forSlot).length === 0) delete limits[slot];
- if (Object.keys(limits).length === 0) delete live.limits;
- savePool(live);
+ withClineLock(() => {
+  if (!model) return;
+  const live = readPoolFile();
+  const limits = live.limits;
+  const forSlot = limits?.[slot];
+  if (!limits || !forSlot || typeof forSlot[model] !== "number") return;
+  delete forSlot[model];
+  if (Object.keys(forSlot).length === 0) delete limits[slot];
+  if (Object.keys(limits).length === 0) delete live.limits;
+  savePool(live);
+ });
 }
 
 /**
@@ -551,91 +607,85 @@ export function addAccount(
  token: string,
  extras?: { refreshToken?: string; expiresAt?: number; accountId?: string; email?: string },
 ): ClinePoolState {
- const cleanSlot = (slot || "").trim();
- if (!cleanSlot) throw new Error("Cline slot name cannot be empty");
- if (cleanSlot.length > 64) throw new Error("Cline slot name is too long (max 64 characters)");
- const cleanToken = (token || "").trim();
- if (!cleanToken.startsWith("workos:") && !isWorkosJwt(cleanToken) && !cleanToken.startsWith("clp_")) throw new Error("Cline token must be a workos: login grant or a clp_ API key");
- const pool = loadPool();
- const existing = pool.accounts.find((a) => a.slot === cleanSlot);
- const duplicate = findClineAccountSlot(pool, { token: cleanToken, accountId: extras?.accountId, email: extras?.email }, cleanSlot);
- if (duplicate) {
-  const who = extras?.email?.trim() || existing?.email?.trim() || "this account";
-  throw new Error(`That Cline account (${who}) is already saved as [${duplicate}] — log in with a different account, or use /freeflow cline logout ${duplicate} first`);
- }
- if (existing) {
-  existing.token = cleanToken;
-  // A fresh login is proof the grant works again: a quarantine recorded
-  // against the credential it replaces must never outlive it.
-  delete existing.deadUntil;
-  if (extras?.refreshToken) existing.refreshToken = extras.refreshToken;
-  if (extras?.expiresAt !== undefined) {
-   if (Number.isFinite(extras.expiresAt) && extras.expiresAt > 0) existing.expiresAt = extras.expiresAt;
-   else delete existing.expiresAt;
-  }
-  if (extras?.accountId !== undefined) {
-   if (extras.accountId.trim()) existing.accountId = extras.accountId.trim();
-   else delete existing.accountId;
+ return withClineLock(() => {
+  const cleanSlot = (slot || "").trim();
+  if (!cleanSlot) throw new Error("Cline slot name cannot be empty");
+  if (cleanSlot.length > 64) throw new Error("Cline slot name is too long (max 64 characters)");
+  const cleanToken = (token || "").trim();
+  if (!cleanToken.startsWith("workos:") && !isWorkosJwt(cleanToken) && !cleanToken.startsWith("clp_")) throw new Error("Cline token must be a workos: login grant or a clp_ API key");
+  const pool = loadPool();
+  const existing = pool.accounts.find((a) => a.slot === cleanSlot);
+  const duplicate = findClineAccountSlot(pool, { token: cleanToken, accountId: extras?.accountId, email: extras?.email }, cleanSlot);
+  if (duplicate) {
+   const who = extras?.email?.trim() || existing?.email?.trim() || "this account";
+   throw new Error(`That Cline account (${who}) is already saved as [${duplicate}] — log in with a different account, or use /freeflow cline logout ${duplicate} first`);
   }
-  if (extras?.email !== undefined) {
-   if (extras.email.trim()) existing.email = extras.email.trim();
-   else delete existing.email;
-  }
- } else {
-  pool.accounts.push({
-   slot: cleanSlot,
-   token: cleanToken,
-   addedAt: new Date().toISOString(),
-   ...(extras?.refreshToken ? { refreshToken: extras.refreshToken } : {}),
-   ...(extras?.expiresAt !== undefined && Number.isFinite(extras.expiresAt) && extras.expiresAt > 0
-    ? { expiresAt: extras.expiresAt }
-    : {}),
-   ...(extras?.accountId?.trim() ? { accountId: extras.accountId.trim() } : {}),
-   ...(extras?.email?.trim() ? { email: extras.email.trim() } : {}),
-  });
- }
- if (!pool.activeSlot) pool.activeSlot = cleanSlot;
- // A save that never reached the disk must not report success: the caller
- // prints "ready to use" on the strength of this return, and the login would
- // vanish on the next read. The write helper already logged the cause.
- if (!savePool(pool)) {
-  // Re-read the way the relay deploy path does before blaming the write.
-  let landed = false;
-  try {
-   landed = loadPool().accounts.some((a) => a.slot === cleanSlot && a.token === cleanToken);
-  } catch {
-   landed = false;
+  if (existing) {
+   existing.token = cleanToken;
+   delete existing.deadUntil;
+   if (extras?.refreshToken) existing.refreshToken = extras.refreshToken;
+   if (extras?.expiresAt !== undefined) {
+    if (Number.isFinite(extras.expiresAt) && extras.expiresAt > 0) existing.expiresAt = extras.expiresAt;
+    else delete existing.expiresAt;
+   }
+   if (extras?.accountId !== undefined) {
+    if (extras.accountId.trim()) existing.accountId = extras.accountId.trim();
+    else delete existing.accountId;
+   }
+   if (extras?.email !== undefined) {
+    if (extras.email.trim()) existing.email = extras.email.trim();
+    else delete existing.email;
+   }
+  } else {
+   pool.accounts.push({
+    slot: cleanSlot,
+    token: cleanToken,
+    addedAt: new Date().toISOString(),
+    ...(extras?.refreshToken ? { refreshToken: extras.refreshToken } : {}),
+    ...(extras?.expiresAt !== undefined && Number.isFinite(extras.expiresAt) && extras.expiresAt > 0
+     ? { expiresAt: extras.expiresAt }
+     : {}),
+    ...(extras?.accountId?.trim() ? { accountId: extras.accountId.trim() } : {}),
+    ...(extras?.email?.trim() ? { email: extras.email.trim() } : {}),
+   });
   }
-  if (!landed) {
-   throw new Error(
-    `Cline login [${cleanSlot}] could not be saved to ${CLINE_POOL_FILE} — check that the directory is writable and log in again`,
-   );
+  if (!pool.activeSlot) pool.activeSlot = cleanSlot;
+  if (!savePool(pool)) {
+   let landed = false;
+   try {
+    landed = loadPool().accounts.some((a) => a.slot === cleanSlot && a.token === cleanToken);
+   } catch {
+    landed = false;
+   }
+   if (!landed) {
+    throw new Error(
+     `Cline login [${cleanSlot}] could not be saved to ${CLINE_POOL_FILE} — check that the directory is writable and log in again`,
+    );
+   }
   }
- }
- return clonePool(pool);
+  return clonePool(pool);
+ });
 }
 
 /** Drop one login slot. Returns false when the slot was not saved. */
 export function removeAccount(slot: string): boolean {
- const cleanSlot = (slot || "").trim();
- const pool = loadPool();
- const idx = pool.accounts.findIndex((a) => a.slot === cleanSlot);
- if (idx < 0) return false;
- const [removed] = pool.accounts.splice(idx, 1);
- if (pool.usage?.[cleanSlot] !== undefined) {
-  delete pool.usage[cleanSlot];
-  if (Object.keys(pool.usage).length === 0) delete pool.usage;
- }
- // A cap belongs to the login that hit it: keeping it would outlive the slot
- // it names and key a later login of the same name into a stale window.
- if (pool.limits?.[cleanSlot] !== undefined) {
-  delete pool.limits[cleanSlot];
-  if (Object.keys(pool.limits).length === 0) delete pool.limits;
- }
- if (pool.activeSlot === cleanSlot) pool.activeSlot = pool.accounts[0]?.slot;
- savePool(pool);
- // A logout is explicit: the removed grant must not survive in the recovery
- // copy, or losing the main file would sign that account back in.
- forgetAccountInBackup(removed);
- return true;
+ return withClineLock(() => {
+  const cleanSlot = (slot || "").trim();
+  const pool = loadPool();
+  const idx = pool.accounts.findIndex((a) => a.slot === cleanSlot);
+  if (idx < 0) return false;
+  const [removed] = pool.accounts.splice(idx, 1);
+  if (pool.usage?.[cleanSlot] !== undefined) {
+   delete pool.usage[cleanSlot];
+   if (Object.keys(pool.usage).length === 0) delete pool.usage;
+  }
+  if (pool.limits?.[cleanSlot] !== undefined) {
+   delete pool.limits[cleanSlot];
+   if (Object.keys(pool.limits).length === 0) delete pool.limits;
+  }
+  if (pool.activeSlot === cleanSlot) pool.activeSlot = pool.accounts[0]?.slot;
+  savePool(pool);
+  forgetAccountInBackup(removed);
+  return true;
+ });
 }

package/src/cline-roll.ts

@@ -323,6 +323,8 @@ export function isClineTokenStale(account: ClineAccount, skewMs = CLINE_REFRESH_
  return Date.now() + skewMs >= account.expiresAt;
 }
 
+const refreshInFlight = new Map<string, Promise<boolean | null>>();
+
 /**
  * Refresh outcome for one slot: fresh tokens applied and persisted (`true`),
  * dead grant with nothing to keep (`false`), or a transient fault where the
@@ -334,47 +336,73 @@ export async function refreshAccountInPlace(
 ): Promise<boolean | null> {
  const current = account.refreshToken;
  if (!current) return null;
- let fresh: ClineRefreshResult | null;
- try {
-  fresh = await refreshImpl(current);
- } catch (e) {
-  logWarn("cline slot refresh failed — keeping stale bearer", { slot: account.slot });
-  void e;
-  return null;
+ if (refreshInFlight.has(account.slot)) {
+  const result = await refreshInFlight.get(account.slot)!;
+  const pool = loadPool();
+  const refreshed = pool.accounts.find((a) => a.slot === account.slot);
+  if (refreshed) {
+   account.token = refreshed.token;
+   if (refreshed.refreshToken) account.refreshToken = refreshed.refreshToken;
+   if (typeof refreshed.expiresAt === "number") {
+    account.expiresAt = refreshed.expiresAt;
+   } else {
+    delete account.expiresAt;
+   }
+   if (refreshed.accountId) account.accountId = refreshed.accountId;
+   if (refreshed.email) account.email = refreshed.email;
+   if (refreshed.deadUntil) account.deadUntil = refreshed.deadUntil;
+  }
+  return result;
  }
- const freshToken = fresh !== null && typeof fresh.token === "string" ? fresh.token.trim() : "";
- if (fresh === null || !freshToken || (!freshToken.startsWith("workos:") && !isWorkosJwt(freshToken) && !freshToken.startsWith("clp_"))) {
-  // Cline rejected the grant outright: park the slot on disk so the next
-  // turns skip it instead of re-paying a refresh that cannot succeed. The
-  // credential stays in the pool — a fresh login into the slot clears this —
-  // and the cooldown ends the pause on its own.
-  account.deadUntil = Date.now() + CLINE_DEAD_GRANT_COOLDOWN_MS;
-  logWarn("cline slot refresh rejected — quarantining slot", {
-   slot: account.slot,
-   forMs: CLINE_DEAD_GRANT_COOLDOWN_MS,
+ const promise = (async (): Promise<boolean | null> => {
+  let fresh: ClineRefreshResult | null;
+  try {
+   fresh = await refreshImpl(current);
+  } catch (e) {
+   logWarn("cline slot refresh failed — keeping stale bearer", { slot: account.slot });
+   void e;
+   return null;
+  }
+  const freshToken = fresh !== null && typeof fresh.token === "string" ? fresh.token.trim() : "";
+  if (fresh === null || !freshToken || (!freshToken.startsWith("workos:") && !isWorkosJwt(freshToken) && !freshToken.startsWith("clp_"))) {
+   // Cline rejected the grant outright: park the slot on disk so the next
+   // turns skip it instead of re-paying a refresh that cannot succeed. The
+   // credential stays in the pool — a fresh login into the slot clears this —
+   // and the cooldown ends the pause on its own.
+   account.deadUntil = Date.now() + CLINE_DEAD_GRANT_COOLDOWN_MS;
+   logWarn("cline slot refresh rejected — quarantining slot", {
+    slot: account.slot,
+    forMs: CLINE_DEAD_GRANT_COOLDOWN_MS,
+   });
+   patchAccountOnDisk(account.slot, { deadUntil: account.deadUntil });
+   return false;
+  }
+  account.token = freshToken;
+  if (fresh.refreshToken) account.refreshToken = fresh.refreshToken;
+  if (typeof fresh.expiresAt === "number" && Number.isFinite(fresh.expiresAt) && fresh.expiresAt > 0) {
+   account.expiresAt = fresh.expiresAt;
+  } else {
+   delete account.expiresAt;
+  }
+  if (fresh.accountId?.trim()) account.accountId = fresh.accountId.trim();
+  if (fresh.email?.trim()) account.email = fresh.email.trim();
+  // Persist only the refreshed fields: the snapshot this request holds may
+  // predate a login added or removed in the host process.
+  patchAccountOnDisk(account.slot, {
+   token: account.token,
+   ...(account.refreshToken ? { refreshToken: account.refreshToken } : {}),
+   expiresAt: account.expiresAt,
+   ...(account.accountId ? { accountId: account.accountId } : {}),
+   ...(account.email ? { email: account.email } : {}),
   });
-  patchAccountOnDisk(account.slot, { deadUntil: account.deadUntil });
-  return false;
- }
- account.token = freshToken;
- if (fresh.refreshToken) account.refreshToken = fresh.refreshToken;
- if (typeof fresh.expiresAt === "number" && Number.isFinite(fresh.expiresAt) && fresh.expiresAt > 0) {
-  account.expiresAt = fresh.expiresAt;
- } else {
-  delete account.expiresAt;
+  return true;
+ })();
+ refreshInFlight.set(account.slot, promise);
+ try {
+  return await promise;
+ } finally {
+  refreshInFlight.delete(account.slot);
  }
- if (fresh.accountId?.trim()) account.accountId = fresh.accountId.trim();
- if (fresh.email?.trim()) account.email = fresh.email.trim();
- // Persist only the refreshed fields: the snapshot this request holds may
- // predate a login added or removed in the host process.
- patchAccountOnDisk(account.slot, {
-  token: account.token,
-  ...(account.refreshToken ? { refreshToken: account.refreshToken } : {}),
-  expiresAt: account.expiresAt,
-  ...(account.accountId ? { accountId: account.accountId } : {}),
-  ...(account.email ? { email: account.email } : {}),
- });
- return true;
 }
 
 /**
@@ -532,6 +560,11 @@ export async function rollChat(opts: ClineRollOpts): Promise<ClineRollResult> {
     refreshedThisSlot = true;
     res = await attempt(account.token);
     if (!res) continue;
+    if (res.status === 200 && res.headers.get("content-type")?.includes("text/event-stream")) {
+     const peek = await peekStreamForInStreamError(res);
+     res = peek.res;
+     if (peek.inStreamError) inStreamLimitText = peek.errorText;
+    }
     kind = mapClineError(res.status);
     if (kind === "ok" || kind === "client") return await succeed(res, kind);
    } else if (outcome === false) {

package/src/commands-relay.ts

@@ -201,7 +201,7 @@ export function showList(ctx: ExtensionContext, getRelayState: () => RelayState)
 export async function removeRelayMenu(ctx: ExtensionContext, act: Pick<RelayActionContext, "applyRelayState" | "persist" | "getRelayState">): Promise<void> {
  const relayState = act.getRelayState();
  const removable = relayState.relays.filter(
-  (r) => r.url !== relayState.url,
+  (r) => relayState.relays.length === 1 || r.url !== relayState.url,
  );
  if (!removable.length) {
   ctx.ui.notify(
@@ -718,7 +718,7 @@ export async function handleRelaySubcommand(
     ctx.ui.notify(`Relay '${target}' not in saved list`, "warning");
     return true;
    }
-   if (matched.url === relayState.url) {
+   if (matched.url === relayState.url && relayState.relays.length > 1) {
     ctx.ui.notify(
      "Cannot remove the active relay — switch to another relay first",
      "warning",

package/src/commands-startup.ts

@@ -237,7 +237,10 @@ export function uninstallStartupHook(opts?: {
    return { ok: true, changed: false, undo: plan.command, detail: `already removed — no unit file at ${plan.filePath}` };
   }
   try {
-   execSync(`systemctl --user disable ${STARTUP_SERVICE_NAME}`, { timeout: 10_000, stdio: "ignore" });
+   startupHookRunner(`systemctl --user disable ${STARTUP_SERVICE_NAME}`);
+  } catch { }
+  try {
+   startupHookRunner("systemctl --user daemon-reload");
   } catch { }
   fs.rmSync(plan.filePath, { force: true });
   return { ok: true, changed: true, undo: plan.command, detail: `removed ${plan.filePath} (re-install: ${plan.command})` };

package/src/commands.ts

@@ -5,7 +5,7 @@
  */
 
 import path from "node:path";
-import { getClientPort } from "./client.ts";
+import { ensureDaemon as ensureClientDaemon, getClientPort, stopHeartbeat } from "./client.ts";
 import { refreshCatalog, setAliveCatalog } from "./catalog.ts";
 import { DATA_DIR_ENV, DEBUG_STATE_FILE, HOST, LOG_FILE, PORT, RELAY_STATE_FILE, ZEN_TRANSPORT_ENV } from "./config.ts";
 import { getCachedUpdate, isLinkedInstall } from "./update-checker.ts";
@@ -144,7 +144,7 @@ export {
  */
 export function updateStatusBar(ui?: ExtensionUIContext): void {
  if (!ui) return;
- ui.setStatus("freeflow", formatRelayStatusLabel(getActiveRelayState()) ?? undefined);
+ ui.setStatus?.("freeflow", formatRelayStatusLabel(getActiveRelayState()) ?? undefined);
 }
 
 let deployProbeRetries = 5;
@@ -253,7 +253,8 @@ export function validateDeployProjectName(
  */
 let updateStepRunner = spawnWithProgress;
 let attachedPortResolver = (): number => getClientPort() || PORT;
-let attachedPortKiller = (port: number): Promise<unknown> => killPortHolder(port);
+let attachedPortKiller: (port: number) => Promise<unknown> = killPortHolder;
+let daemonEnsurer: () => Promise<unknown> = ensureClientDaemon;
 
 /** Test seam for the /freeflow update restart path (null restores the real deps). */
 export function _setUpdateRestartDepsForTest(
@@ -261,11 +262,13 @@ export function _setUpdateRestartDepsForTest(
   runUpdateStep?: (cmd: string, args: string[], ctx: ExtensionContext) => Promise<number>;
   resolveAttachedPort?: () => number;
   killAttachedPort?: (port: number) => Promise<unknown>;
+  ensureDaemon?: () => Promise<unknown>;
  } | null,
 ): void {
  updateStepRunner = opts?.runUpdateStep ?? spawnWithProgress;
  attachedPortResolver = opts?.resolveAttachedPort ?? ((): number => getClientPort() || PORT);
- attachedPortKiller = opts?.killAttachedPort ?? ((port: number): Promise<unknown> => killPortHolder(port));
+ attachedPortKiller = opts?.killAttachedPort ?? killPortHolder;
+ daemonEnsurer = opts?.ensureDaemon ?? ensureClientDaemon;
 }
 
 export function createCommandSpec(
@@ -430,7 +433,7 @@ export function createCommandSpec(
      }
     }
 
-    ctx.ui.setStatus("freeflow", `deploying ${platform} relay…`);
+ ctx.ui.setStatus?.("freeflow", `deploying ${platform} relay…`);
     try {
      const deployer =
       platform === "cloudflare"
@@ -639,6 +642,22 @@ export function createCommandSpec(
     } catch {
      ctx.ui.notify("Daemon not running or not reachable", "warning");
     }
+    try { await stopHeartbeat(); } catch { }
+   } else if (sub === "restart") {
+    const port = getClientPort() || PORT;
+    try {
+     await fetch(`http://${HOST}:${port}/_shutdown`, {
+      method: "POST",
+      headers: tokenAuthHeaders(),
+      signal: AbortSignal.timeout(1500),
+     });
+    } catch { }
+    try {
+     await ensureClientDaemon();
+     ctx.ui.notify("Proxy daemon restarted", "info");
+    } catch (e) {
+     ctx.ui.notify(`Restart failed: ${(e as Error).message}`, "error");
+    }
    } else if (sub === "autoupdate" || (sub === "update" && rest.trim().toLowerCase().startsWith("auto"))) {
     const arg = sub === "autoupdate"
      ? rest.trim().toLowerCase()
@@ -718,6 +737,7 @@ export function createCommandSpec(
          // Restart the daemon that is actually attached — a walked port must
          // not leave the old build serving after a successful update.
          try { await attachedPortKiller(attachedPortResolver()); } catch { }
+         try { await daemonEnsurer(); } catch { }
          ctx.ui.notify(`Updated to ${latest} and restarted proxy daemon`, "info");
         } else {
          ctx.ui.notify(
@@ -792,7 +812,9 @@ export function createCommandSpec(
      let count = 25;
      const rawTokens = rawRest ? rawRest.split(/\s+/) : [];
      const isFollow = rawTokens.includes("--follow") || rawTokens.includes("-f");
-
+     if (!isFollow) {
+      stopLogsFollow();
+     }
      if (sub === "trace" && rawRest) {
       filterReqId = rawTokens.filter((t) => t !== "--follow" && t !== "-f")[0] || null;
      } else if (rawRest) {