@hienlh/ppm 0.21.0 → 0.22.1

package/src/shared/codex-daily-guard.ts

@@ -2,6 +2,7 @@ import type { LimitBucket } from "../types/chat.ts";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 const WEEK_DAYS = 7;
+const WORK_DAYS = 5;
 
 export interface DailyGuardState {
   day: number;
@@ -10,18 +11,24 @@ export interface DailyGuardState {
   blocked: boolean;
 }
 
-/** Split a weekly quota into seven daily envelopes. */
+/** Five weekday envelopes, using reset-anchored 24h slots and UTC weekdays on every client. */
 export function dailyGuardState(bucket: LimitBucket | undefined, now = Date.now()): DailyGuardState | null {
   if (!bucket || bucket.windowHours !== 168) return null;
   const resetsAt = new Date(bucket.resetsAt).getTime();
-  if (!Number.isFinite(resetsAt) || resetsAt <= now) return null;
+  if (!Number.isFinite(now) || !Number.isFinite(resetsAt) || resetsAt <= now) return null;
 
   const startedAt = resetsAt - WEEK_DAYS * DAY_MS;
-  const day = Math.min(WEEK_DAYS, Math.max(1, Math.ceil((now - startedAt) / DAY_MS)));
-  const cap = day / WEEK_DAYS;
+  if (now < startedAt) return null;
+  const elapsedSlot = Math.min(WEEK_DAYS - 1, Math.floor((now - startedAt) / DAY_MS));
+  let day = 0;
+  for (let slot = 0; slot <= elapsedSlot; slot++) {
+    const weekday = new Date(startedAt + slot * DAY_MS).getUTCDay();
+    if (weekday !== 0 && weekday !== 6) day++;
+  }
+  const cap = day / WORK_DAYS;
   return { day, cap, used: bucket.utilization, blocked: bucket.utilization >= cap };
 }
 
 export function dailyGuardMessage(state: DailyGuardState): string {
-  return `Daily guard reached: ${Math.round(state.used * 100)}% used; day ${state.day}/7 allows ${Math.round(state.cap * 100)}%. Turn off Daily guard on this account to continue.`;
+  return `Daily guard reached: ${Math.round(state.used * 100)}% used; weekday ${state.day}/5 allows ${Math.round(state.cap * 100)}%. The cap increases on weekdays only. Turn off Daily guard on this account to continue.`;
 }

package/src/shared/remote-desktop-custom-quality.ts

@@ -0,0 +1,117 @@
+/**
+ * RustDesk's "Custom image quality": a bitrate *percentage* and an fps, with the real bitrate
+ * derived from the capture's own resolution. Ported rather than invented, because two parts of
+ * it are counter-intuitive enough that a reasonable guess is wrong:
+ *
+ *  1. **The percentage is not the ratio.** `video_qos.rs:444` reads it back as
+ *     `((q >> 8 & 0xFFF) * 2) / 100.0`, so the ratio is `percent × 2 / 100` — the dialog's
+ *     default **50% means ratio 1.0**, i.e. exactly `base_bitrate`. Reading 50% as ratio 0.5
+ *     (the obvious reading) makes every custom setting half as sharp as the user asked for,
+ *     and nothing reports it: the picture is simply dimmer than the number promises.
+ *  2. **`base_bitrate` is a nearest-preset lookup, not a formula.** `codec.rs:929` finds the
+ *     table row whose *pixel count* is closest to the source's, then scales that row's bitrate
+ *     by the pixel ratio. A plain bits-per-pixel constant does not reproduce it, because the
+ *     table is deliberately non-linear (720p→1000, 1080p→2073, 4K→5000: 4× the pixels of
+ *     1080p for 2.4× the bits).
+ *
+ * The fixed rungs use the same machinery in RustDesk (`Quality::ratio()` → Best 1.5,
+ * Balanced 0.67, Low 0.5); PPM keeps its own absolute-bitrate ladder for those, so only the
+ * custom path needs this.
+ */
+
+/** `RESOLUTION_PRESETS` from `libs/scrap/src/common/codec.rs`, kbps. */
+const RESOLUTION_BITRATE_PRESETS: readonly (readonly [number, number, number])[] = [
+  [640, 480, 400],
+  [800, 600, 500],
+  [1024, 768, 800],
+  [1280, 720, 1000],
+  [1366, 768, 1100],
+  [1440, 900, 1300],
+  [1600, 900, 1500],
+  [1920, 1080, 2073],
+  [2048, 1080, 2200],
+  [2560, 1440, 3000],
+  [3440, 1440, 4000],
+  [3840, 2160, 5000],
+  [7680, 4320, 12000],
+];
+
+/** `kMinQuality` / `kDefaultQuality` / `kMaxQuality` / `kMaxMoreQuality` from `consts.dart`. */
+export const CUSTOM_QUALITY_MIN_PERCENT = 10;
+export const CUSTOM_QUALITY_DEFAULT_PERCENT = 50;
+export const CUSTOM_QUALITY_MAX_PERCENT = 100;
+/** The "More" checkbox raises the ceiling this far — 2000% is ratio 40, which is `BR_MAX`. */
+export const CUSTOM_QUALITY_MAX_MORE_PERCENT = 2000;
+
+/** `kMinFps` / `kDefaultFps` / `kMaxFps`. */
+export const CUSTOM_FPS_MIN = 5;
+export const CUSTOM_FPS_DEFAULT = 30;
+export const CUSTOM_FPS_MAX = 120;
+
+/** `BR_MIN` / `BR_MAX` from `video_qos.rs`. */
+const BR_MIN = 0.2;
+const BR_MAX = 40.0;
+
+/** Nearest-pixel-count preset, scaled by the pixel ratio. See note 2. */
+export function baseBitrateKbps(width: number, height: number): number {
+  const pixels = Math.max(1, Math.round(width) * Math.round(height));
+  let best = RESOLUTION_BITRATE_PRESETS[7]!; // 1080p, the table's own fallback
+  let bestDistance = Infinity;
+  for (const preset of RESOLUTION_BITRATE_PRESETS) {
+    const distance = Math.abs(preset[0] * preset[1] - pixels);
+    if (distance < bestDistance) { bestDistance = distance; best = preset; }
+  }
+  const presetPixels = best[0] * best[1];
+  // Floored at 1: a 0x0 capture (before the first frame) otherwise scales the smallest preset
+  // down to `round(400 / 307200)` = **0**, and ffmpeg refuses a zero bitrate outright rather
+  // than picking something sensible.
+  return Math.max(1, Math.round(best[2] * (pixels / presetPixels)));
+}
+
+/** Percent → bitrate ratio. `percent × 2 / 100`, clamped. See note 1. */
+export function customQualityRatio(percent: number): number {
+  if (!Number.isFinite(percent)) return (CUSTOM_QUALITY_DEFAULT_PERCENT * 2) / 100;
+  return Math.min(Math.max((percent * 2) / 100, BR_MIN), BR_MAX);
+}
+
+/** Clamp any bitrate ratio to RustDesk's own bounds. Named rungs already sit inside them; the
+ *  congestion scaling in `remote-desktop-quality.ts` is what can push one out. */
+export function clampRatio(ratio: number): number {
+  if (!Number.isFinite(ratio)) return BR_MIN;
+  return Math.min(Math.max(ratio, BR_MIN), BR_MAX);
+}
+
+/** The bitrate a ratio really encodes at, for this capture size. Every rung goes through here —
+ *  a named one, a congestion-scaled one and the custom dialog's percentage alike, which is what
+ *  makes "the chosen quality is a ceiling on the ratio" a statement about one number. */
+export function ratioBitrateKbps(ratio: number, width: number, height: number): number {
+  // Floored at 1: the table's smallest row makes `baseBitrateKbps(0, 0)` round to 0, and ffmpeg
+  // refuses a zero bitrate outright.
+  return Math.max(1, Math.round(baseBitrateKbps(width, height) * clampRatio(ratio)));
+}
+
+/** An ffmpeg bitrate string (`-b:v`/`-maxrate`) for a ratio. */
+export function ratioBitrateArg(ratio: number, width: number, height: number): string {
+  return `${ratioBitrateKbps(ratio, width, height)}k`;
+}
+
+/** The bitrate a custom setting really encodes at, for this capture size. */
+export function customBitrateKbps(percent: number, width: number, height: number): number {
+  return ratioBitrateKbps(customQualityRatio(percent), width, height);
+}
+
+/** An ffmpeg bitrate string (`-b:v`/`-maxrate`) for a custom setting. */
+export function customBitrateArg(percent: number, width: number, height: number): string {
+  return `${customBitrateKbps(percent, width, height)}k`;
+}
+
+export function clampCustomQualityPercent(value: unknown, allowMore = false): number {
+  const max = allowMore ? CUSTOM_QUALITY_MAX_MORE_PERCENT : CUSTOM_QUALITY_MAX_PERCENT;
+  if (typeof value !== "number" || !Number.isFinite(value)) return CUSTOM_QUALITY_DEFAULT_PERCENT;
+  return Math.min(Math.max(Math.round(value), CUSTOM_QUALITY_MIN_PERCENT), max);
+}
+
+export function clampCustomFps(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return CUSTOM_FPS_DEFAULT;
+  return Math.min(Math.max(Math.round(value), CUSTOM_FPS_MIN), CUSTOM_FPS_MAX);
+}

package/src/shared/remote-desktop-quality.ts

@@ -0,0 +1,127 @@
+/**
+ * The remote-desktop quality ladder — shared, because both ends need the same table: the
+ * server turns a rung into ffmpeg args, and the client renders the picker and shows which rung
+ * is active. One definition so a label or a rung cannot drift between them.
+ *
+ * This is RustDesk's own set, ported rather than invented: `toolbarImageQuality` in
+ * `flutter/lib/common/widgets/toolbar.dart` builds exactly four radio items — Good image
+ * quality, Balanced, Optimize reaction time, Custom — and `Quality` in
+ * `libs/scrap/src/common/codec.rs` is the matching enum with the three ratios below.
+ *
+ * Two things follow from that, and both are the opposite of what this file used to do:
+ *
+ * 1. **A rung never changes the resolution.** It sets a bitrate ratio, and the stream stays at
+ *    the host's native size. The old ladder capped height per rung (720p on `balanced`), which
+ *    on a 3440x1440 host threw away 4.8x the pixels — and measured, it bought almost nothing:
+ *    720p used 1.17 Mbit/s against 1.26 Mbit/s for native at the same cap, because a desktop is
+ *    mostly static and H.264 spends bits on *change*, not on area. Neither came close to the
+ *    cap it was given, so the downscale was pure loss.
+ * 2. **There is no `auto` rung.** RustDesk has no such menu item because the adaptation is
+ *    always running: the chosen quality is the *maximum* ratio (`video_qos.rs`: "user set image
+ *    quality => update to the maximum ratio of the latest quality") and congestion lowers the
+ *    effective ratio underneath it. A pin that switched adaptation *off* is what made a chosen
+ *    rung flicker forever on a link that could not carry it.
+ *
+ * The *policy* built on top of this (how far the ratio may fall, and when it moves) is server
+ * side only, in `src/services/remote-desktop/remote-desktop-quality.ts`.
+ */
+
+export type QualityPresetId = "best" | "balanced" | "low";
+
+/** One entry of the Image quality menu: a label and the bitrate ratio it asks for. Deliberately
+ *  carries no resolution and no bitrate — the real bitrate depends on the capture size, so it
+ *  can only be resolved once the display is known (`resolveQuality`). */
+export interface QualityRung {
+  id: QualityPresetId;
+  label: string;
+  /** RustDesk's `BR_BEST` / `BR_BALANCED` / `BR_SPEED` from `codec.rs`, unchanged. */
+  ratio: number;
+}
+
+/** What the capture layer needs: a frame rate and an ffmpeg bitrate string. A rung plus a
+ *  capture size resolves to one of these; so does the custom dialog's percentage. */
+export interface QualityPreset {
+  fps: number;
+  /** ffmpeg bitrate string, used for both `-b:v` and `-maxrate`. */
+  bitrate: string;
+}
+
+export const QUALITY_PRESETS: Record<QualityPresetId, QualityRung> = {
+  best: { id: "best", label: "Good image quality", ratio: 1.5 },
+  balanced: { id: "balanced", label: "Balanced", ratio: 0.67 },
+  low: { id: "low", label: "Optimize reaction time", ratio: 0.5 },
+};
+
+/* "Optimize reaction time" is RustDesk's own name for the 0.5 rung and it is now the right one,
+ * where on the old ladder it would have been backwards. There, the low rungs downscaled and the
+ * *high* rungs were the low-latency ones — measured 1440p60 `gap p50=16.6ms` against 720p30
+ * `p50=33.3ms`. With resolution out of the picture the only thing a lower rung changes is how
+ * many bytes have to cross the link per frame, so less really does mean sooner. */
+
+/** RustDesk's menu order, which is best-first — not the worst-to-best order a ladder walks. */
+export const QUALITY_PRESET_ORDER: readonly QualityPresetId[] = ["best", "balanced", "low"];
+
+/** `Quality::default()` in `codec.rs` is `Balanced`. */
+export const DEFAULT_PRESET_ID: QualityPresetId = "balanced";
+
+/** `pub const FPS: u32 = 30` in `video_qos.rs` — what a named rung streams at. Only the custom
+ *  dialog sets a frame rate directly; RustDesk otherwise adapts it, never exposes it. */
+export const DEFAULT_FPS = 30;
+
+/** Coerce whatever came over the wire into a real preset id, or null for garbage.
+ *  `Object.hasOwn`, never `in`: `in` walks the prototype chain, so `"toString"` off the wire
+ *  would pass as a preset id and `QUALITY_PRESETS["toString"]` would hand the capture pipeline
+ *  a *function* where it expected a rung — nonsense ffmpeg args from one client string. */
+export function parsePresetId(value: unknown): QualityPresetId | null {
+  return typeof value === "string" && Object.hasOwn(QUALITY_PRESETS, value)
+    ? value as QualityPresetId
+    : null;
+}
+
+/** What the client can ask for. `custom` only means something together with the two numbers
+ *  from its dialog, which is why it is a separate arm rather than a fourth rung. */
+export type QualityChoice = QualityPresetId | "custom";
+
+/** A custom rung: RustDesk's bitrate percentage + fps, at the host's native resolution — the
+ *  same resolution every named rung uses (see `remote-desktop-custom-quality.ts`). */
+export interface CustomQuality {
+  /** Bitrate percentage; the real bitrate comes from the capture size. */
+  percent: number;
+  fps: number;
+}
+
+/** Coerce a stored/untrusted value into a `QualityChoice`, falling back to the default rung.
+ *  Separate from `parsePresetId` because the persisted device pref may legitimately be
+ *  `"custom"`, and because localStorage is user-writable — a rung read back from it is
+ *  untrusted input exactly like one off the wire, with the same `Object.hasOwn` hazard behind
+ *  it. A pref left over from the old five-rung ladder (`"tiny"`, `"max"`, `"auto"`) parses as
+ *  garbage and lands on the default, which is what should happen to a rung that no longer
+ *  exists. */
+export function parseQualityChoice(value: unknown): QualityChoice {
+  if (value === "custom") return value;
+  return parsePresetId(value) ?? DEFAULT_PRESET_ID;
+}
+
+/** Next value for the mobile toolbar's one-tap-per-hop button, in menu order. A dropdown in the
+ *  thumb zone is worse than a button that cycles.
+ *
+ *  `custom` is deliberately not in the cycle: it only means something together with the two
+ *  numbers from its dialog, so a one-tap button that landed on it would change the stream to
+ *  whatever was last typed there — surprising, and with no visible cause. */
+export function nextQualityChoice(current: QualityChoice): QualityChoice {
+  if (current === "custom") return QUALITY_PRESET_ORDER[0]!;
+  const at = QUALITY_PRESET_ORDER.indexOf(current);
+  return QUALITY_PRESET_ORDER[(at + 1) % QUALITY_PRESET_ORDER.length]!;
+}
+
+/** Compact label for a toolbar button, where the full label does not fit. RustDesk has no such
+ *  button, so these are the shortest thing that still distinguishes the four. */
+const SHORT_LABELS: Record<QualityPresetId, string> = {
+  best: "Good",
+  balanced: "Balanced",
+  low: "Reaction",
+};
+
+export function shortQualityLabel(choice: QualityChoice): string {
+  return choice === "custom" ? "Custom" : SHORT_LABELS[choice];
+}

package/src/types/chat.ts

@@ -50,6 +50,10 @@ export interface AIProvider {
   onToolApproval?: (callback: ToolApprovalHandler) => void;
   abortQuery?(sessionId: string, source?: string): void;
   getMessages?(sessionId: string): Promise<ChatMessage[]>;
+  /** Every message in the transcript, including the segments before each compaction.
+   *  `getMessages` answers with the resumable *conversation*; this answers with the
+   *  whole history. Only the search index asks for it — see `indexSession`. */
+  getFullMessages?(sessionId: string): Promise<ChatMessage[]>;
   listSessionsByDir?(dir: string, opts?: { limit?: number; offset?: number }): Promise<SessionInfo[]>;
   ensureProjectPath?(sessionId: string, path: string): void;
   setForkSource?(sessionId: string, sourceSessionId: string): void;

package/src/types/git.ts

@@ -59,6 +59,24 @@ export interface GitDiffFile {
   content: string;
 }
 
+/**
+ * Both sides of a single-file diff, as whole files.
+ *
+ * `binary` is decided from the bytes, and when it is true both sides come back
+ * **empty**: decoded, a PNG is megabytes of U+FFFD that no one can read and that
+ * JSON has to escape. The viewer asks again with `text=1` ("Open Anyway") when
+ * the user wants them anyway. A null size means the file does not exist on that
+ * side, which is how the binary view tells an added or deleted file from a
+ * changed one.
+ */
+export interface FileFullDiff {
+  original: string;
+  modified: string;
+  binary: boolean;
+  originalSize: number | null;
+  modifiedSize: number | null;
+}
+
 export interface GitWorktree {
   /** Absolute path to the worktree directory */
   path: string;
@@ -79,3 +97,37 @@ export interface GitWorktree {
   /** True if this worktree can be pruned (directory missing/stale) */
   prunable: boolean;
 }
+
+/**
+ * A whole branch's changes against a base, as one list.
+ *
+ * `mergeBase` is the commit every per-file diff has to be opened against — in
+ * three-dot mode it is where the two refs diverged, not `base` itself.
+ */
+export interface BranchDiff {
+  base: string;
+  head: string;
+  mode: "three-dot" | "two-dot";
+  mergeBase: string;
+  /**
+   * `head` resolved to a commit, which is what a file must be opened against.
+   * `head` itself is a ref name and moves: a commit landing between the list
+   * fetch and a file being opened would show the new tip beside counts and a
+   * blob id describing the old one.
+   */
+  headCommit: string;
+  /** Files omitted from `files` because the list hit its cap; 0 when complete. */
+  omitted: number;
+  files: BranchDiffFile[];
+}
+
+export interface BranchDiffFile {
+  path: string;
+  oldPath?: string;
+  status: "A" | "M" | "D" | "R" | "C" | "T";
+  additions: number;
+  deletions: number;
+  binary: boolean;
+  /** Head-side blob id; what a "reviewed" flag is remembered against. */
+  blob: string;
+}