@saadnvd1/agent-os 0.3.794 → 0.3.799

package/lib/schedules/store.ts

@@ -298,7 +298,7 @@ function validate(
   if (
     !oneOff &&
     (input.kind === "task" || input.kind === "session") &&
-    minGapMinutes(cron, timezone) < MIN_GAP_MINUTES
+    minGapMinutes(cron, timezone, Date.now(), MIN_GAP_MINUTES) < MIN_GAP_MINUTES
   )
     throw new Error(
       "A task or session schedule runs at most once an hour; for more often, post to the orchestrator"
@@ -309,7 +309,8 @@ function validate(
   if (
     !oneOff &&
     (message || agentCheckIn) &&
-    minGapMinutes(cron, timezone) < MESSAGE_MIN_GAP_MINUTES
+    minGapMinutes(cron, timezone, Date.now(), MESSAGE_MIN_GAP_MINUTES) <
+      MESSAGE_MIN_GAP_MINUTES
   )
     throw new Error(
       `A message schedule runs at most every ${MESSAGE_MIN_GAP_MINUTES} minutes`

package/lib/security/demo.ts

@@ -150,6 +150,8 @@ const READS = [
   "demo",
   // The changelog: a static file, no agent.
   "whats-new",
+  // Tip of the Day: reading is a static file plus two settings.
+  "tips",
 ].map(route);
 
 // The only writes, each a database write and nothing more in demo mode:

package/lib/tasks/finish.ts

@@ -88,17 +88,17 @@ async function cleanup(
   forgetPR(session.id);
 }
 
-// Sign-offs between `gh pr merge` and the database knowing it, so the
-// watcher doesn't read our own merge as one done on GitHub.
-export const signingOff = new Set<string>();
-
 // What happens after a merge: restack anything stacked on it, then remove the
 // session, worktree and branch. Kept per task so Land and done can wait for
 // it; on globalThis because the watcher's merges run in server.ts and done in
-// a route bundle, which load this module separately.
+// a route bundle, which load this module separately. lib/busy.ts counts both.
 const g = globalThis as unknown as {
   __agentosAfterMerge?: Map<string, Promise<void>>;
+  __agentosSigningOff?: Set<string>;
 };
+// Sign-offs between `gh pr merge` and the database knowing it, so the
+// watcher doesn't read our own merge as one done on GitHub.
+export const signingOff: Set<string> = (g.__agentosSigningOff ??= new Set());
 const afterMerge: Map<string, Promise<void>> = (g.__agentosAfterMerge ??=
   new Map());
 

package/lib/tips/conditions.ts

@@ -0,0 +1,38 @@
+import { readConnect } from "@/lib/connect/config";
+import { listBookmarks } from "@/lib/bookmarks/store";
+import { listRecipes } from "@/lib/recipes/store";
+import { listSchedules } from "@/lib/schedules/store";
+import { listDevices } from "@/lib/security/devices";
+import { listGroups } from "@/lib/session-groups/store";
+import { listSharedLinks } from "@/lib/share/store";
+import type { Condition, Tip } from "./schema";
+
+const CHECKS: Record<Condition, () => boolean> = {
+  "no-paired-device": () => listDevices().length === 0,
+  "no-push-device": () => !listDevices().some((d) => d.push.enabled),
+  "connect-not-linked": () => !readConnect().ok,
+  "connect-linked": () => {
+    const c = readConnect();
+    return c.ok && c.enabled;
+  },
+  "no-schedules": () => listSchedules().length === 0,
+  "no-recipes": () => listRecipes().length === 0,
+  "no-shares": () => listSharedLinks().length === 0,
+  "no-groups": () => listGroups().length === 0,
+  "no-bookmarks": () =>
+    listBookmarks({ workspace: "all", limit: 1 }).bookmarks.length === 0,
+};
+
+/** Whether the tip applies now; a check that throws counts as no. */
+export function tipApplies(
+  tip: Pick<Tip, "when">,
+  checks: Record<string, () => boolean> = CHECKS
+): boolean {
+  return (tip.when ?? []).every((c) => {
+    try {
+      return checks[c]?.() ?? false;
+    } catch {
+      return false;
+    }
+  });
+}

package/lib/tips/index.ts

@@ -0,0 +1,2 @@
+export { markSeen, setTipsOff, tipsView } from "./view";
+export type { ClientTip, Media, Tip, TipsView } from "./schema";

package/lib/tips/load.ts

@@ -0,0 +1,26 @@
+import fs from "fs";
+import path from "path";
+import { fileSchema, type Tip } from "./schema";
+
+export const TIPS_FILE = "content/tips.json";
+
+let cached: { file: string; mtime: number; tips: Tip[] } | null = null;
+
+/** Every tip that isn't retired. A missing or unreadable file is empty. */
+export function loadTips(root: string = process.cwd()): Tip[] {
+  const file = path.join(root, TIPS_FILE);
+  try {
+    const mtime = fs.statSync(file).mtimeMs;
+    if (cached?.file === file && cached.mtime === mtime) return cached.tips;
+    const parsed = fileSchema.safeParse(
+      JSON.parse(fs.readFileSync(file, "utf-8"))
+    );
+    const tips = parsed.success
+      ? parsed.data.tips.filter((t) => !t.hidden)
+      : [];
+    cached = { file, mtime, tips };
+    return tips;
+  } catch {
+    return [];
+  }
+}

package/lib/tips/media.ts

@@ -0,0 +1,101 @@
+import fs from "fs";
+import path from "path";
+import { fileSchema, type Media, type MediaBrief, type Tip } from "./schema";
+
+export const MEDIA_DIR = "public/tips";
+export const BUDGET = {
+  still: 90 * 1024,
+  clip: 500 * 1024,
+  poster: 40 * 1024,
+  total: 6 * 1024 * 1024,
+  clipSeconds: 8,
+  width: 768,
+} as const;
+
+/** The files a media value points at, as names inside public/tips. */
+export function mediaFiles(m: Media): { name: string; max: number }[] {
+  const name = (src: string) => path.basename(src);
+  return m.kind === "image"
+    ? [
+        { name: name(m.src), max: BUDGET.still },
+        ...(m.srcDark ? [{ name: name(m.srcDark), max: BUDGET.still }] : []),
+      ]
+    : [
+        { name: name(m.src), max: BUDGET.clip },
+        { name: name(m.poster), max: BUDGET.poster },
+      ];
+}
+
+export interface ManifestRow {
+  id: string;
+  title: string;
+  kind: MediaBrief["kind"];
+  shot: string;
+  theme: NonNullable<MediaBrief["theme"]>;
+  guide?: string;
+  target: { width: number; maxBytes: number; maxSeconds?: number };
+  dest: string;
+}
+
+/** What Luna still has to make: tips with a brief and no media yet. */
+export function manifest(tips: Tip[]): ManifestRow[] {
+  return tips
+    .filter((t) => t.mediaBrief && !t.media)
+    .map((t) => {
+      const b = t.mediaBrief!;
+      const clip = b.kind === "clip";
+      return {
+        id: t.id,
+        title: t.title,
+        kind: b.kind,
+        shot: b.shot,
+        theme: b.theme ?? (clip ? "dark" : "both"),
+        ...(t.guide && { guide: t.guide.file }),
+        target: {
+          width: BUDGET.width,
+          maxBytes: clip ? BUDGET.clip : BUDGET.still,
+          ...(clip && { maxSeconds: BUDGET.clipSeconds }),
+        },
+        dest: `${MEDIA_DIR}/${t.id}.${clip ? "mp4" : "webp"}`,
+      };
+    });
+}
+
+/**
+ * Copies the finished files from `from` into `root`/public/tips and writes each
+ * tip's `media` (dropping its brief). Throws before changing anything if an id
+ * is unknown, a file is missing, or a file is over its budget.
+ */
+export function applyHandback(
+  root: string,
+  from: string,
+  handback: Record<string, Media>
+): string[] {
+  const file = path.join(root, "content/tips.json");
+  const parsed = fileSchema.parse(JSON.parse(fs.readFileSync(file, "utf-8")));
+  const copies: [string, string][] = [];
+  for (const [id, media] of Object.entries(handback)) {
+    if (!parsed.tips.some((t) => t.id === id))
+      throw new Error(`Unknown tip "${id}"`);
+    for (const { name, max } of mediaFiles(media)) {
+      const src = path.join(from, name);
+      if (!fs.existsSync(src)) throw new Error(`${id}: ${name} is missing`);
+      const size = fs.statSync(src).size;
+      if (size > max)
+        throw new Error(`${id}: ${name} is ${size} bytes, over ${max}`);
+      copies.push([src, path.join(root, MEDIA_DIR, name)]);
+    }
+    if (media.kind === "video" && media.durationMs > BUDGET.clipSeconds * 1000)
+      throw new Error(`${id}: clip is longer than ${BUDGET.clipSeconds}s`);
+  }
+  fs.mkdirSync(path.join(root, MEDIA_DIR), { recursive: true });
+  for (const [a, b] of copies) fs.copyFileSync(a, b);
+  const tips = parsed.tips.map((t) => {
+    const media = handback[t.id];
+    if (!media) return t;
+    const { mediaBrief: _brief, ...rest } = t;
+    return { ...rest, media };
+  });
+  fs.writeFileSync(file, JSON.stringify({ ...parsed, tips }, null, 2) + "\n");
+  return Object.keys(handback);
+}

package/lib/tips/pick.ts

@@ -0,0 +1,35 @@
+import type { Tip } from "./schema";
+
+export interface Pinned {
+  day: string;
+  id: string;
+  read: boolean;
+}
+
+/** Newest first; tips added the same day keep the order they have in the file. */
+export const orderDeck = <T extends Pick<Tip, "id" | "added">>(
+  tips: T[]
+): T[] =>
+  [...tips].sort((a, b) =>
+    a.added === b.added ? 0 : a.added < b.added ? 1 : -1
+  );
+
+/**
+ * The tip for `day`: the one already chosen today while it still applies,
+ * else the first the user hasn't seen, else (all seen) the one seen longest ago.
+ */
+export function pickToday(o: {
+  deck: { id: string }[];
+  seen: Record<string, string>;
+  pinned: Pinned | null;
+  day: string;
+}): Pinned | null {
+  const { deck, seen, pinned, day } = o;
+  if (!deck.length) return null;
+  if (pinned?.day === day && deck.some((t) => t.id === pinned.id))
+    return pinned;
+  const fresh = deck.find((t) => !seen[t.id]);
+  if (fresh) return { day, id: fresh.id, read: false };
+  const oldest = deck.reduce((a, b) => (seen[b.id] < seen[a.id] ? b : a));
+  return { day, id: oldest.id, read: false };
+}

package/lib/tips/schema.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+
+export const CONDITIONS = [
+  "no-paired-device",
+  "no-push-device",
+  "connect-not-linked",
+  "connect-linked",
+  "no-schedules",
+  "no-recipes",
+  "no-shares",
+  "no-groups",
+  "no-bookmarks",
+] as const;
+export type Condition = (typeof CONDITIONS)[number];
+
+const media = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("image"),
+    src: z.string().startsWith("/tips/"),
+    srcDark: z.string().startsWith("/tips/").optional(),
+    alt: z.string().min(1).max(200),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+  }),
+  z.object({
+    kind: z.literal("video"),
+    src: z.string().startsWith("/tips/"),
+    poster: z.string().startsWith("/tips/"),
+    alt: z.string().min(1).max(200),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    durationMs: z.number().int().positive(),
+  }),
+]);
+export type Media = z.infer<typeof media>;
+
+const mediaBrief = z.object({
+  kind: z.enum(["screenshot", "crop", "clip"]),
+  shot: z.string().min(1).max(300),
+  theme: z.enum(["light", "dark", "both"]).optional(),
+});
+export type MediaBrief = z.infer<typeof mediaBrief>;
+
+export const tipSchema = z.object({
+  id: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  title: z.string().min(1).max(60),
+  body: z.string().min(1).max(240),
+  guide: z
+    .object({
+      file: z.string().regex(/^[a-z0-9-]+$/),
+      anchor: z.string().optional(),
+    })
+    .optional(),
+  when: z.array(z.enum(CONDITIONS)).optional(),
+  added: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  hidden: z.boolean().optional(),
+  media: media.optional(),
+  mediaBrief: mediaBrief.optional(),
+});
+export type Tip = z.infer<typeof tipSchema>;
+
+export const fileSchema = z.object({
+  v: z.literal(1),
+  tips: z.array(tipSchema),
+});
+
+/** What a client gets: the guide resolved to a link, the brief left out. */
+export interface ClientTip {
+  id: string;
+  title: string;
+  body: string;
+  url?: string;
+  media?: Media;
+}
+
+export interface TipsView {
+  off: boolean;
+  /** Setup isn't finished: the button works but shows no dot. */
+  quiet: boolean;
+  today: { id: string; read: boolean } | null;
+  deck: ClientTip[];
+}

package/lib/tips/state.ts

@@ -0,0 +1,26 @@
+import { getSetting, putSetting } from "@/lib/settings-store";
+import type { Pinned } from "./pick";
+
+const OFF = "tips.off";
+const SEEN = "tips.seen";
+const TODAY = "tips.today";
+
+function json<T>(key: string, fallback: T): T {
+  try {
+    const raw = getSetting(key);
+    return raw ? (JSON.parse(raw) as T) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+export const tipsOff = (): boolean => getSetting(OFF) === "1";
+export const setTipsOff = (off: boolean) => putSetting(OFF, off ? "1" : null);
+
+/** Tip id -> the day it was last shown. */
+export const readSeen = () => json<Record<string, string>>(SEEN, {});
+export const writeSeen = (seen: Record<string, string>) =>
+  putSetting(SEEN, JSON.stringify(seen));
+
+export const readPinned = () => json<Pinned | null>(TODAY, null);
+export const writePinned = (p: Pinned) => putSetting(TODAY, JSON.stringify(p));

package/lib/tips/view.ts

@@ -0,0 +1,60 @@
+import { readCompletedAt } from "@/lib/welcome";
+import { tipApplies } from "./conditions";
+import { loadTips } from "./load";
+import { orderDeck, pickToday } from "./pick";
+import type { ClientTip, Tip, TipsView } from "./schema";
+import {
+  readPinned,
+  readSeen,
+  setTipsOff,
+  tipsOff,
+  writePinned,
+  writeSeen,
+} from "./state";
+
+const GUIDES = "https://github.com/saadnvd1/agent-os/blob/main/docs/guides";
+
+export const guideUrl = (g: NonNullable<Tip["guide"]>) =>
+  `${GUIDES}/${g.file}.md${g.anchor ? `#${g.anchor}` : ""}`;
+
+const forClient = ({ id, title, body, guide, media }: Tip): ClientTip => ({
+  id,
+  title,
+  body,
+  ...(guide && { url: guideUrl(guide) }),
+  ...(media && { media }),
+});
+
+export const todayLocal = () => new Date().toLocaleDateString("sv");
+
+/** The tips that apply now, and which one is today's. */
+export function tipsView(day: string = todayLocal()): TipsView {
+  const quiet = readCompletedAt() === null;
+  if (tipsOff()) return { off: true, quiet, today: null, deck: [] };
+  const deck = orderDeck(loadTips().filter((t) => tipApplies(t)));
+  const pinned = readPinned();
+  const today = pickToday({ deck, seen: readSeen(), pinned, day });
+  if (today && (today.id !== pinned?.id || today.day !== pinned?.day))
+    writePinned(today);
+  return {
+    off: false,
+    quiet,
+    today: today && { id: today.id, read: today.read },
+    deck: deck.map(forClient),
+  };
+}
+
+/** Records that these tips were shown; today's one becomes read. */
+export function markSeen(ids: string[], day: string = todayLocal()): void {
+  const known = new Set(loadTips().map((t) => t.id));
+  const seen = Object.fromEntries(
+    Object.entries(readSeen()).filter(([id]) => known.has(id))
+  );
+  for (const id of ids) if (known.has(id)) seen[id] = day;
+  writeSeen(seen);
+  const pinned = readPinned();
+  if (pinned && pinned.day === day && ids.includes(pinned.id) && !pinned.read)
+    writePinned({ ...pinned, read: true });
+}
+
+export { setTipsOff };

package/lib/updates/auto.ts

@@ -0,0 +1,149 @@
+// When an automatic update starts, as one pure decision so it can be tested
+// as a table. lib/updates/run.ts gathers the input and acts on the answer.
+//
+//   1. Switched off, pinned off, deployed by autodeploy, or refused (local
+//      changes, diverged, dev server, no restart command...) → skip, say why.
+//   2. The target is the newest commit on the remote's first-parent line
+//      that has been there `soakMs`, so a bad push can be reverted before an
+//      install takes it, and a busy day of merges can't hold it off. A
+//      commit that was rolled back, or failed to build recently, is passed
+//      over for an older one still newer than what's installed.
+//   3. Nothing a restart would interrupt is in flight (agents working, chat
+//      turns, reviews, task setups, simulator starts, merges, stack
+//      landings, an update or deploy), and has not been for `idleMs`.
+//   4. Once a release has waited `deadlineMs` past its soak, a lull of
+//      `lullMs` is enough. It never interrupts work; it keeps waiting.
+
+import type { UpdateAttempt } from "./banner";
+import { blockFor } from "./history";
+
+export interface Candidate {
+  sha: string;
+  /** Commit time, ms. */
+  at: number;
+}
+
+export interface AutoInput {
+  enabled: boolean;
+  locked: boolean;
+  managed: boolean;
+  refusal: string | null;
+  /** First-parent commits newer than the installed one, newest first. */
+  candidates: Candidate[];
+  attempts: UpdateAttempt[];
+  /** What is working now; empty when nothing is. */
+  busy: string[];
+  /** Since when nothing has been working, as far as anyone watched. */
+  quietSince: number | null;
+  now: number;
+  soakMs: number;
+  idleMs: number;
+  deadlineMs: number;
+  lullMs?: number;
+}
+
+export type AutoDecision =
+  | { action: "start"; to: string }
+  | { action: "wait"; code: AutoWait; text: string; to?: string }
+  | { action: "skip"; code: AutoSkip; text: string };
+
+export type AutoSkip = "off" | "locked" | "managed" | "refused" | "up_to_date";
+export type AutoWait = "soaking" | "blocked" | "busy" | "quiet";
+
+export const LULL_MS = 2 * 60_000;
+
+const short = (sha: string) => sha.slice(0, 7);
+const mins = (ms: number) => Math.max(1, Math.ceil(ms / 60_000));
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+/** The commit to update to, or why there's none yet. */
+export function pickTarget(
+  input: Pick<AutoInput, "candidates" | "attempts" | "now" | "soakMs">
+):
+  | { to: string; eligibleSince: number }
+  | {
+      to?: undefined;
+      code: "soaking" | "blocked";
+      text: string;
+      until?: number;
+    } {
+  const { candidates, attempts, now, soakMs } = input;
+  const soaked = candidates.filter((c) => c.at + soakMs <= now);
+  if (!soaked.length) {
+    const next = Math.min(...candidates.map((c) => c.at + soakMs));
+    return {
+      code: "soaking",
+      text: `A new version came out recently; it updates once it has been out ${plural(mins(soakMs), "minute")}.`,
+      until: next,
+    };
+  }
+  let first: string | null = null;
+  for (const c of soaked) {
+    const block = blockFor(c.sha, attempts, now);
+    if (!block)
+      return {
+        to: c.sha,
+        // The oldest waiting release says how long updates have been put off.
+        eligibleSince: soaked[soaked.length - 1].at + soakMs,
+      };
+    first ??= `${short(c.sha)}: ${block.reason}`;
+  }
+  return {
+    code: "blocked",
+    text: `Not updating to ${first}. Waiting for a newer version.`,
+  };
+}
+
+export function decideAutoUpdate(input: AutoInput): AutoDecision {
+  if (input.locked)
+    return {
+      action: "skip",
+      code: "locked",
+      text: "Automatic updates are turned off by AGENTOS_AUTO_UPDATE.",
+    };
+  if (!input.enabled)
+    return { action: "skip", code: "off", text: "Automatic updates are off." };
+  if (input.managed)
+    return {
+      action: "skip",
+      code: "managed",
+      text: "Updates on this machine are deployed by autodeploy.",
+    };
+  if (input.refusal)
+    return {
+      action: "skip",
+      code: "refused",
+      text: `Automatic updates are paused. ${input.refusal}`,
+    };
+  if (!input.candidates.length)
+    return {
+      action: "skip",
+      code: "up_to_date",
+      text: "AgentOS is up to date.",
+    };
+
+  const target = pickTarget(input);
+  if (!("eligibleSince" in target))
+    return { action: "wait", code: target.code, text: target.text };
+
+  if (input.busy.length)
+    return {
+      action: "wait",
+      code: "busy",
+      to: target.to,
+      text: `Updates when nothing is working (now: ${input.busy.join(", ")}).`,
+    };
+  const late = input.now - target.eligibleSince >= input.deadlineMs;
+  const need = late ? (input.lullMs ?? LULL_MS) : input.idleMs;
+  const quietFor = input.quietSince === null ? 0 : input.now - input.quietSince;
+  if (quietFor < need)
+    return {
+      action: "wait",
+      code: "quiet",
+      to: target.to,
+      text: late
+        ? "Has waited a long time for a quiet moment; updates at the next short lull."
+        : `Updates after everything has been idle for ${plural(mins(input.idleMs), "minute")} (${plural(mins(need - quietFor), "minute")} to go).`,
+    };
+  return { action: "start", to: target.to };
+}