@saadnvd1/agent-os 0.3.810 → 0.3.817

package/components/Reach/ReachRow.tsx

@@ -0,0 +1,137 @@
+"use client";
+
+import { Loader2, RefreshCw } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { StatusPill } from "@/components/ui/status-pill";
+import { CopyButton } from "@/components/Chat/CopyButton";
+import { useReachQuery, useRecheckReach } from "@/data/reach";
+import type { ReachFinding, ReachReport, ReachStatus } from "@/lib/reach/types";
+import { cn } from "@/lib/utils";
+
+const TONE: Record<ReachStatus, "green" | "amber" | "red"> = {
+  ok: "green",
+  warn: "amber",
+  fail: "red",
+};
+
+// Amber has three stories: only retrying, one way in working, or a warning.
+function pillLabel(report: ReachReport, problems: ReachFinding[]): string {
+  if (report.status === "ok") return "Reachable";
+  if (report.status === "fail") return "Not reachable";
+  if (problems.every((f) => f.needs === "nothing")) return "Reconnecting";
+  return report.url ? "Partly reachable" : "Needs a look";
+}
+
+// A fix is a command when it starts with one; otherwise it's plain advice.
+const isCommand = (fix: string) => /^(agent-os|sudo)( |$)/.test(fix);
+
+function Problem({ f }: { f: ReachFinding }) {
+  return (
+    <li className="flex flex-col gap-1">
+      <p className="text-sm font-medium">{f.title}</p>
+      {f.needs === "nothing" ? (
+        <p className="text-muted-foreground flex items-center gap-1.5 text-xs">
+          <Loader2 className="size-3 animate-spin" />
+          Retrying on its own, nothing to do
+        </p>
+      ) : (
+        <>
+          {f.fix &&
+            (isCommand(f.fix) ? (
+              <code className="bg-background block rounded px-2 py-1 text-xs break-all">
+                {f.fix}
+              </code>
+            ) : (
+              <p className="text-muted-foreground text-xs break-words">
+                {f.fix}
+              </p>
+            ))}
+          {f.guide && (
+            <a
+              href={f.guide}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="text-muted-foreground hover:text-foreground flex min-h-11 w-fit items-center text-xs underline underline-offset-2 sm:min-h-6"
+            >
+              How to fix
+            </a>
+          )}
+        </>
+      )}
+    </li>
+  );
+}
+
+/** Whether other devices can reach this machine, and the fix when they can't. */
+export function ReachRow({
+  enabled = true,
+  className,
+}: {
+  enabled?: boolean;
+  className?: string;
+}) {
+  const { data, isPending, isError } = useReachQuery(enabled);
+  const recheck = useRecheckReach();
+  if (isPending)
+    return (
+      <div
+        className={cn("bg-muted/40 h-16 animate-pulse rounded-lg", className)}
+      />
+    );
+  const problems = data?.findings.filter((f) => f.status !== "ok") ?? [];
+  const pill = data && {
+    tone: TONE[data.status],
+    label: pillLabel(data, problems),
+  };
+  return (
+    <div
+      className={cn(
+        "bg-muted/40 flex flex-col gap-2 rounded-lg px-3 py-2.5",
+        className
+      )}
+    >
+      <div className="flex min-h-11 items-center gap-2 sm:min-h-0">
+        <p className="min-w-0 flex-1 text-sm font-medium">
+          Reachable from other devices
+        </p>
+        {pill && (
+          <StatusPill tone={pill.tone} className="shrink-0 whitespace-nowrap">
+            {pill.label}
+          </StatusPill>
+        )}
+      </div>
+      {isError && (
+        <p className="text-destructive text-xs">Couldn&apos;t run the check.</p>
+      )}
+      {data?.url && (
+        <div className="flex min-w-0 items-center gap-1">
+          <span className="text-foreground min-w-0 flex-1 truncate font-mono text-xs">
+            {data.url}
+          </span>
+          <CopyButton
+            text={data.url}
+            label="Copy link"
+            className="h-11 w-11 shrink-0 md:h-7 md:w-7"
+          />
+        </div>
+      )}
+      {problems.length > 0 && (
+        <ul className="flex flex-col gap-3">
+          {problems.map((f, i) => (
+            <Problem key={`${f.route ?? ""}-${f.cause ?? i}`} f={f} />
+          ))}
+        </ul>
+      )}
+      <Button
+        size="sm"
+        variant="ghost"
+        className="h-11 self-end sm:h-8"
+        disabled={recheck.isPending}
+        onClick={() => recheck.mutate()}
+      >
+        <RefreshCw className={recheck.isPending ? "animate-spin" : ""} />
+        Check again
+      </Button>
+    </div>
+  );
+}

package/components/Settings/SetupSection.tsx

@@ -3,6 +3,7 @@
 import { Button } from "@/components/ui/button";
 import { HealthList } from "@/components/Welcome/HealthList";
 import { AgentList } from "@/components/Welcome/AgentList";
+import { ReachRow } from "@/components/Reach/ReachRow";
 import { settingsUiActions } from "@/stores/settingsUi";
 import { welcomeUiActions } from "@/stores/welcomeUi";
 
@@ -32,6 +33,7 @@ export function SetupSection() {
       <div className="flex flex-col gap-2">
         <h3 className="text-sm font-medium">Health</h3>
         <HealthList />
+        <ReachRow />
       </div>
       <div className="flex flex-col gap-2">
         <h3 className="text-sm font-medium">Agents on this machine</h3>

package/components/Welcome/ConnectBlock.tsx

@@ -18,6 +18,7 @@ import {
   CONNECT_STATE,
   connectView,
 } from "@/lib/connect/view";
+import { ReachRow } from "@/components/Reach/ReachRow";
 import { Block } from "./Block";
 
 const COMMAND = "agent-os connect";
@@ -155,6 +156,7 @@ export function ConnectBlock() {
             {update.error && (
               <p className="text-destructive text-xs">{update.error.message}</p>
             )}
+            <ReachRow className="mt-2 px-0" />
           </div>
           <Switch
             checked={wanted ?? view.on}

package/content/tips.json

@@ -536,6 +536,16 @@
         "anchor": "whats-new"
       },
       "added": "2026-10-31"
+    },
+    {
+      "id": "reach-check",
+      "title": "Can't reach your machine?",
+      "body": "Run agent-os check on the computer. It names the cause, like a stopped server or Wi-Fi access being off, and the one line that fixes it.",
+      "guide": {
+        "file": "reachability",
+        "anchor": "run-the-check"
+      },
+      "added": "2026-10-31"
     }
   ]
 }

package/content/whats-new.json

@@ -1865,6 +1865,46 @@
       "area": "Updates",
       "text": "Update notices now appear as a small pop-up instead of a bar across the top of the app.",
       "url": "https://github.com/saadnvd1/agent-os/pull/543"
+    },
+    {
+      "id": 544,
+      "date": "2026-10-31",
+      "kind": "new",
+      "area": "AgentOS",
+      "text": "Run agent-os setup to get your phone connected in a few steps, and agent-os check tells you why a device can't reach your computer and how to fix it.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/544"
+    },
+    {
+      "id": 545,
+      "date": "2026-10-31",
+      "kind": "improved",
+      "area": "AgentOS",
+      "text": "The session list loads much faster, especially on a phone.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/545"
+    },
+    {
+      "id": 546,
+      "date": "2026-10-31",
+      "kind": "fixed",
+      "area": "AgentOS",
+      "text": "Session list rows in the installed phone app no longer lose their short task prompt.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/546"
+    },
+    {
+      "id": 547,
+      "date": "2026-10-31",
+      "kind": "fixed",
+      "area": "AgentOS",
+      "text": "The reachability check now tells a stuck AgentOS apart from another program on its port, and setup keeps a copy of a startup file you edited before replacing it.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/547"
+    },
+    {
+      "id": 548,
+      "date": "2026-11-01",
+      "kind": "new",
+      "area": "Chat",
+      "text": "Chats now accept HAR network captures (with logins and cookies hidden), iPhone photos and many more file types.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/548"
     }
   ]
 }

package/data/devices/queries.ts

@@ -3,6 +3,7 @@ import type { ListedDevice } from "@/lib/security/devices";
 import type { NetworkState } from "@/lib/security/network-state";
 import type { PairingOffer } from "@/lib/security/pair-qr";
 import { deviceKeys } from "./keys";
+import { reachKeys } from "../reach";
 import { provePresence } from "../presence";
 
 async function json<T>(res: Response): Promise<T> {
@@ -77,7 +78,11 @@ export function useUpdateNetwork() {
           }),
         })
       ),
-    onSuccess: (data) => queryClient.setQueryData(deviceKeys.network(), data),
+    onSuccess: (data) => {
+      queryClient.setQueryData(deviceKeys.network(), data);
+      // Wi-Fi access or Connect changed: whether devices get in did too.
+      void queryClient.invalidateQueries({ queryKey: reachKeys.all });
+    },
   });
 }
 

package/data/reach/index.ts

@@ -0,0 +1,33 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { ReachReport } from "@/lib/reach/types";
+
+export const reachKeys = {
+  all: ["reach"] as const,
+};
+
+async function fetchReach(fresh: boolean) {
+  const res = await fetch(fresh ? "/api/reach?fresh" : "/api/reach");
+  if (!res.ok)
+    throw new Error(
+      "Couldn't check whether other devices can reach this machine"
+    );
+  return (await res.json()) as ReachReport;
+}
+
+export function useReachQuery(enabled = true) {
+  return useQuery({
+    queryKey: reachKeys.all,
+    queryFn: () => fetchReach(false),
+    enabled,
+    staleTime: 30_000,
+    refetchOnMount: "always",
+  });
+}
+
+export function useRecheckReach() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: () => fetchReach(true),
+    onSuccess: (report) => client.setQueryData(reachKeys.all, report),
+  });
+}

package/lib/attachments/check.ts

@@ -1,6 +1,6 @@
 import { isText, sniff } from "../intake/sniff";
 import {
-  ATTACHMENT_LIMITS,
+  limitFor,
   tooBigMessage,
   typeFor,
   unsupportedMessage,
@@ -28,10 +28,7 @@ const bad = (name: string): UploadCheck => ({
 export function checkUpload(name: string, data: Buffer): UploadCheck {
   const type = typeFor(name);
   if (!type) return { ok: false, status: 415, error: unsupportedMessage(name) };
-  const limit =
-    type.kind === "image"
-      ? ATTACHMENT_LIMITS.maxImageBytes
-      : ATTACHMENT_LIMITS.maxBytes;
+  const limit = limitFor(type);
   if (data.length > limit)
     return {
       ok: false,

package/lib/attachments/har.ts

@@ -0,0 +1,122 @@
+// A HAR is a browser's network log: it carries live cookies and bearer
+// tokens. On the way in the values of the credential headers and every
+// cookie are replaced; names, URLs, timings, bodies and statuses stay.
+
+export const REDACTED = "[redacted]";
+
+const SECRET_HEADER =
+  /^(cookie|set-cookie|authorization|proxy-authorization)$|api[-_]?key|token|secret|^x-(csrf|xsrf)/i;
+
+interface Pair {
+  name?: unknown;
+  value?: unknown;
+}
+
+interface Message {
+  headers?: Pair[];
+  cookies?: Pair[];
+  status?: number;
+  bodySize?: number;
+  content?: { size?: number };
+}
+
+interface Entry {
+  request?: Message & { method?: string; url?: string };
+  response?: Message;
+  time?: number;
+}
+
+export interface HarResult {
+  json: string;
+  redacted: number;
+  summary: string;
+}
+
+function scrub(list: Pair[] | undefined, always: boolean): number {
+  let n = 0;
+  if (!Array.isArray(list)) return n;
+  for (const p of list) {
+    if (!p || typeof p !== "object" || p.value === REDACTED) continue;
+    if (always || (typeof p.name === "string" && SECRET_HEADER.test(p.name))) {
+      p.value = REDACTED;
+      n++;
+    }
+  }
+  return n;
+}
+
+const hostOf = (url: string) => {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "(unparsed)";
+  }
+};
+
+const top = (counts: Map<string, number>, n: number) =>
+  [...counts].sort((a, b) => b[1] - a[1]).slice(0, n);
+
+function summarize(entries: Entry[]): string {
+  const hosts = new Map<string, number>();
+  const statuses = new Map<string, number>();
+  const rows = entries.map((e) => {
+    const url = e.request?.url ?? "";
+    const status = e.response?.status ?? 0;
+    const host = hostOf(url);
+    hosts.set(host, (hosts.get(host) ?? 0) + 1);
+    const klass = status >= 100 ? `${Math.floor(status / 100)}xx` : "failed";
+    statuses.set(klass, (statuses.get(klass) ?? 0) + 1);
+    const size = Math.max(
+      e.response?.content?.size ?? 0,
+      e.response?.bodySize ?? 0
+    );
+    const line = `${e.request?.method ?? "?"} ${url.slice(0, 160)} -> ${status || "no response"}`;
+    return { line, size, status, time: e.time ?? 0 };
+  });
+  const failing = rows.filter((r) => r.status === 0 || r.status >= 400);
+  const largest = [...rows].sort((a, b) => b.size - a.size).slice(0, 5);
+  const lines = [
+    `HAR summary: ${entries.length} requests, ${hosts.size} hosts.`,
+    `Hosts: ${top(hosts, 8)
+      .map(([h, c]) => `${h} (${c})`)
+      .join(", ")}`,
+    `Status: ${[...statuses]
+      .sort()
+      .map(([k, c]) => `${k} ${c}`)
+      .join(", ")}`,
+    `Largest responses: ${largest.map((r) => `${r.line} [${r.size} B]`).join("; ")}`,
+    failing.length
+      ? `Failing (${failing.length}${failing.length > 8 ? ", first 8" : ""}): ${failing
+          .slice(0, 8)
+          .map((r) => r.line)
+          .join("; ")}`
+      : "Failing: none",
+    "Cookie and auth header values were replaced with [redacted].",
+  ];
+  return lines.join("\n");
+}
+
+/** The HAR with its secrets replaced and a short summary, or null when the text isn't a HAR. */
+export function redactHar(text: string): HarResult | null {
+  let har: { log?: { entries?: Entry[] } };
+  try {
+    har = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  const entries = har?.log?.entries;
+  if (!Array.isArray(entries)) return null;
+  let redacted = 0;
+  for (const e of entries) {
+    for (const m of [e?.request, e?.response]) {
+      if (!m || typeof m !== "object") continue;
+      redacted += scrub(m.headers, false) + scrub(m.cookies, true);
+    }
+  }
+  // Indented, so the agent can grep and read it by line.
+  return {
+    json: JSON.stringify(har, null, 1),
+    redacted,
+    summary: summarize(entries.filter((e) => e && typeof e === "object")),
+  };
+}

package/lib/attachments/message.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import { ATTACHMENT_LIMITS, formatBytes } from "./policy";
+import { summaryPath } from "./store";
 import type { ChatFile } from "./types";
 
 /**
@@ -8,14 +9,35 @@ import type { ChatFile } from "./types";
  * spreadsheet through a script, a docx through pandoc). The chat keeps the
  * plain text and shows the files as chips.
  */
+// Over this, the agent is told to read in parts.
+const LARGE_BYTES = 1_000_000;
+const SUMMARY_CHARS = 3000;
+
+function summaryOf(file: ChatFile): string {
+  try {
+    return fs
+      .readFileSync(summaryPath(file.path), "utf8")
+      .slice(0, SUMMARY_CHARS);
+  } catch {
+    return "";
+  }
+}
+
 export function agentText(text: string, files?: ChatFile[]): string {
   if (!files?.length) return text;
   const list = files
-    .map((f) => `- ${f.path} (${f.mediaType}, ${formatBytes(f.size)})`)
+    .map((f) => {
+      const summary = summaryOf(f);
+      const large = f.size > LARGE_BYTES ? ", large: read it in parts" : "";
+      return (
+        `- ${f.path} (${f.mediaType}, ${formatBytes(f.size)}${large})` +
+        (summary ? `\n${summary.replace(/^/gm, "  ")}` : "")
+      );
+    })
     .join("\n");
   return [
     text,
-    `Attached files, saved on this machine. Open them with your own tools:\n${list}`,
+    `Attached files, saved on this machine. They are never pasted into this message; open them with your own tools (grep or head a big one rather than reading it whole):\n${list}`,
   ]
     .filter(Boolean)
     .join("\n\n");

package/lib/attachments/policy.ts

@@ -8,6 +8,8 @@ export interface AttachmentType {
   ext: string;
   mediaType: string;
   kind: AttachmentKind;
+  // Shown on the chip: what the server does to this type on the way in.
+  note?: string;
 }
 
 const t = (
@@ -34,9 +36,22 @@ export const ATTACHMENT_TYPES: AttachmentType[] = [
   ...t("doc", `${OOXML}.presentationml.presentation`, "pptx"),
   ...t("doc", "application/vnd.oasis.opendocument.text", "odt"),
   ...t("doc", "application/rtf", "rtf"),
-  ...t("text", "text/plain", "txt", "log", "env"),
+  ...t("image", "image/heic", "heic", "heif"),
+  ...t("text", "text/plain", "txt", "log", "out", "err", "env"),
   ...t("text", "text/markdown", "md", "markdown"),
-  ...t("text", "application/json", "json", "jsonl", "ipynb"),
+  ...t("text", "application/json", "json", "jsonl", "ndjson", "ipynb"),
+  {
+    ext: "har",
+    mediaType: "application/json",
+    kind: "text",
+    note: "auth headers redacted",
+  },
+  ...t("text", "text/calendar", "ics"),
+  ...t("text", "message/rfc822", "eml"),
+  ...t("text", "text/vtt", "vtt"),
+  ...t("text", "application/x-subrip", "srt"),
+  // Svg is kept as text so nothing ever renders it.
+  ...t("text", "text/plain", "svg"),
   ...t(
     "text",
     "text/plain",
@@ -67,15 +82,67 @@ export const ATTACHMENT_TYPES: AttachmentType[] = [
     "cs",
     "php",
     "diff",
-    "patch"
+    "patch",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "ini",
+    "conf",
+    "cfg",
+    "properties",
+    "tf",
+    "tfvars",
+    "hcl",
+    "graphql",
+    "gql",
+    "proto",
+    "vue",
+    "svelte",
+    "astro",
+    "dart",
+    "lua",
+    "r",
+    "scala",
+    "ex",
+    "exs",
+    "erl",
+    "zig",
+    "nix",
+    "lock",
+    "sum",
+    "mod",
+    "gitignore",
+    "gitattributes",
+    "dockerignore",
+    "editorconfig"
+  ),
+  // Files that are known by their whole name, matched without a dot.
+  ...t(
+    "text",
+    "text/plain",
+    "dockerfile",
+    "makefile",
+    "gnumakefile",
+    "procfile",
+    "gemfile",
+    "rakefile",
+    "brewfile",
+    "justfile",
+    "env.example",
+    "env.sample",
+    "env.template"
   ),
 ];
 
 export const ATTACHMENT_LIMITS = {
   // Files and images on one message.
   max: 8,
-  // One non-image file.
+  // One document, sheet or PDF.
   maxBytes: 25_000_000,
+  // One text file (logs, HAR captures, code). It is saved to disk and opened
+  // by the agent from its path, never put into the prompt, so it can be big.
+  maxTextBytes: 100_000_000,
   // One image, under the 5 MB a model accepts once base64'd.
   maxImageBytes: 3_750_000,
   // A PDF up to this goes to Claude as a document block; bigger ones, and
@@ -91,13 +158,41 @@ const BY_EXT = new Map(ATTACHMENT_TYPES.map((x) => [x.ext, x]));
 export const extOf = (name: string): string =>
   /\.([A-Za-z0-9]+)$/.exec(name)?.[1].toLowerCase() ?? "";
 
+// "Dockerfile" and ".env.example" have no extension worth the name; they are
+// matched whole, lower-cased and without a leading dot.
+const wholeName = (name: string): string =>
+  (name.split(/[\\/]/).pop() ?? "").toLowerCase().replace(/^\./, "");
+
 export const typeFor = (
   name: string,
   types: AttachmentType[] = ATTACHMENT_TYPES
-): AttachmentType | null =>
-  types === ATTACHMENT_TYPES
-    ? (BY_EXT.get(extOf(name)) ?? null)
-    : (types.find((x) => x.ext === extOf(name)) ?? null);
+): AttachmentType | null => {
+  const ext = extOf(name);
+  const whole = wholeName(name);
+  const find = (key: string) =>
+    types === ATTACHMENT_TYPES
+      ? BY_EXT.get(key)
+      : types.find((x) => x.ext === key);
+  return (ext && find(ext)) || find(whole) || null;
+};
+
+// iPhone photos: no browser or model reads them, so they are converted on
+// intake and kept as files instead of going inline with the message.
+export const isHeic = (name: string) => /^heic|^heif/.test(extOf(name));
+
+/** The byte limit for one file of this type. */
+export const limitFor = (
+  type: AttachmentType,
+  limits: Pick<
+    typeof ATTACHMENT_LIMITS,
+    "maxBytes" | "maxTextBytes" | "maxImageBytes"
+  > = ATTACHMENT_LIMITS
+): number => {
+  if (type.kind === "text") return limits.maxTextBytes;
+  if (type.kind === "image" && !isHeic(`x.${type.ext}`))
+    return limits.maxImageBytes;
+  return limits.maxBytes;
+};
 
 // For <input accept>: every extension, so the picker greys out the rest.
 export const acceptAttr = (types: AttachmentType[] = ATTACHMENT_TYPES) =>
@@ -110,7 +205,7 @@ export const formatBytes = (n: number): string =>
 
 // What a person is told when a file can't be attached.
 export const unsupportedMessage = (name: string): string =>
-  `${name}: this file type can't be attached. Supported: PDF, spreadsheets (xlsx, xls, csv), Word (docx), text, markdown, JSON, code and images.`;
+  `${name}: this file type can't be attached. Supported: images (including HEIC), PDF, spreadsheets (xlsx, xls, csv), Word and PowerPoint, HAR captures, SVG, and text files: logs, markdown, JSON, config, shell scripts, Dockerfile, Makefile and source code.`;
 
 export const tooBigMessage = (name: string, size: number, limit: number) =>
   `${name} is ${formatBytes(size)}; the limit is ${formatBytes(limit)}.`;