@saadnvd1/agent-os 0.3.611 → 0.3.613

package/components/Pane/MobileViewPicker.test.ts

@@ -0,0 +1,92 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { describe, expect, it, vi } from "vitest";
+import { MobileViewPicker, mobileViews } from "./MobileViewPicker";
+
+// Radix dispatches CustomEvents; the node global is not jsdom's.
+Object.defineProperty(globalThis, "CustomEvent", {
+  value: (window as unknown as { CustomEvent: unknown }).CustomEvent,
+  configurable: true,
+});
+
+const all = {
+  isLocalSession: true,
+  hasLog: true,
+  isConductor: true,
+  workerCount: 3,
+};
+
+describe("mobileViews", () => {
+  it("lists every view, Artifacts included", () => {
+    expect(mobileViews(all).map((v) => v.label)).toEqual([
+      "Chat",
+      "Files",
+      "Git",
+      "Artifacts",
+      "Log",
+      "Workers",
+    ]);
+    expect(mobileViews(all).at(-1)?.count).toBe(3);
+  });
+
+  it("hides views that do not apply", () => {
+    expect(
+      mobileViews({
+        isLocalSession: false,
+        isConductor: false,
+        workerCount: 0,
+      }).map((v) => v.label)
+    ).toEqual(["Chat", "Artifacts"]);
+  });
+});
+
+describe("MobileViewPicker", () => {
+  async function open(viewMode: "terminal" | "artifacts", onChange = vi.fn()) {
+    const el = document.createElement("div");
+    document.body.appendChild(el);
+    const root = createRoot(el);
+    await act(async () => {
+      root.render(
+        createElement(MobileViewPicker, {
+          ...all,
+          viewMode,
+          onViewModeChange: onChange,
+        })
+      );
+    });
+    const trigger = el.querySelector("button") as HTMLButtonElement;
+    await act(async () => {
+      trigger.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true })
+      );
+    });
+    return { trigger, onChange };
+  }
+
+  it("shows the current view and lists all views in the menu", async () => {
+    const { trigger } = await open("artifacts");
+    expect(trigger.textContent).toContain("Artifacts");
+    const items = [...document.querySelectorAll('[role="menuitem"]')];
+    expect(items.map((i) => i.textContent)).toEqual([
+      "Chat",
+      "Files",
+      "Git",
+      "Artifacts",
+      "Log",
+      "Workers3",
+    ]);
+    expect(items[3].getAttribute("aria-current")).toBe("true");
+  });
+
+  it("selecting an item calls the view-change handler", async () => {
+    const { onChange } = await open("terminal");
+    const log = [...document.querySelectorAll('[role="menuitem"]')].find((i) =>
+      i.textContent?.startsWith("Log")
+    ) as HTMLElement;
+    await act(async () => {
+      log.click();
+    });
+    expect(onChange).toHaveBeenCalledWith("log");
+  });
+});

package/components/Pane/MobileViewPicker.tsx

@@ -0,0 +1,106 @@
+"use client";
+
+import {
+  Check,
+  ChevronDown,
+  FolderOpen,
+  GitBranch,
+  Package,
+  ScrollText,
+  Terminal as TerminalIcon,
+  Users,
+  type LucideIcon,
+} from "lucide-react";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import type { ViewMode } from "@/contexts/PaneContext";
+
+export interface MobileView {
+  mode: ViewMode;
+  label: string;
+  icon: LucideIcon;
+  count?: number;
+}
+
+export interface MobileViewAvailability {
+  isLocalSession: boolean;
+  hasLog?: boolean;
+  isConductor: boolean;
+  workerCount: number;
+}
+
+// The one list of views on a phone; the picker renders it.
+export function mobileViews({
+  isLocalSession,
+  hasLog,
+  isConductor,
+  workerCount,
+}: MobileViewAvailability): MobileView[] {
+  const views: (MobileView | false)[] = [
+    { mode: "terminal", label: "Chat", icon: TerminalIcon },
+    isLocalSession && { mode: "files", label: "Files", icon: FolderOpen },
+    isLocalSession && { mode: "git", label: "Git", icon: GitBranch },
+    { mode: "artifacts", label: "Artifacts", icon: Package },
+    !!hasLog && { mode: "log", label: "Log", icon: ScrollText },
+    isConductor && {
+      mode: "workers",
+      label: "Workers",
+      icon: Users,
+      count: workerCount,
+    },
+  ];
+  return views.filter((v): v is MobileView => !!v);
+}
+
+export function MobileViewPicker({
+  viewMode,
+  onViewModeChange,
+  ...availability
+}: MobileViewAvailability & {
+  viewMode: ViewMode;
+  onViewModeChange: (mode: ViewMode) => void;
+}) {
+  const views = mobileViews(availability);
+  const current = views.find((v) => v.mode === viewMode) ?? views[0];
+  const CurrentIcon = current.icon;
+
+  return (
+    <DropdownMenu modal={false}>
+      <DropdownMenuTrigger asChild>
+        <button
+          type="button"
+          aria-label={`View: ${current.label}`}
+          onClick={(e) => e.stopPropagation()}
+          className="bg-accent/50 relative flex h-8 shrink-0 items-center gap-1 rounded-md px-2 text-xs after:absolute after:inset-x-0 after:-inset-y-1.5 after:content-['']"
+        >
+          <CurrentIcon className="h-4 w-4" />
+          <span className="max-[359px]:hidden">{current.label}</span>
+          <ChevronDown className="text-muted-foreground h-3 w-3" />
+        </button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="min-w-40">
+        {views.map(({ mode, label, icon: Icon, count }) => (
+          <DropdownMenuItem
+            key={mode}
+            aria-current={mode === current.mode}
+            onSelect={() => onViewModeChange(mode)}
+            className="h-11 gap-2"
+          >
+            <Icon className="h-4 w-4" />
+            <span className="flex-1">{label}</span>
+            {count !== undefined && (
+              <span className="bg-primary/20 text-primary rounded px-1 text-[10px]">
+                {count}
+              </span>
+            )}
+            {mode === current.mode && <Check className="h-4 w-4" />}
+          </DropdownMenuItem>
+        ))}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}

package/lib/chat/events.ts

@@ -68,7 +68,9 @@ export type ChatOriginKind =
   // AgentOS itself: the load monitor, stacks.
   | "system"
   // The reader's own decision, made outside the composer (a plan carried out).
-  | "decision";
+  | "decision"
+  // The reader's phone: a shake report or something shared to AgentOS.
+  | "device";
 
 export interface ChatOrigin {
   kind: ChatOriginKind;

package/lib/chat/origin.ts

@@ -24,7 +24,8 @@ function fromText(text: string): ChatOrigin | null {
   return null;
 }
 
-// What sent a user item, or null when the reader typed it.
+// What sent a user item, or null when the reader typed it. A "device" origin
+// is only ever set by the server (lib/intake), so it is never read from text.
 export function originOf(item: UserItem): ChatOrigin | null {
   if (item.origin) return item.origin;
   if (item.peer)

package/lib/chat/settings.ts

@@ -66,6 +66,12 @@ function visibleCommands(caps: Capabilities): ChatCommand[] {
   );
 }
 
+// The commands already loaded for a session's folder; never loads them.
+export function cachedCommands(session: Session): ChatCommand[] {
+  const caps = registry.caps.get(capsKey(session));
+  return caps ? visibleCommands(caps) : [];
+}
+
 export function emitCapabilities(session: Session, listener?: Listener): void {
   const caps = registry.caps.get(capsKey(session));
   if (!caps) return;

package/lib/config/client-config-types.ts

@@ -26,4 +26,51 @@ export interface ClientConfig {
   taskStates: Record<string, LabelTone>;
   runStatuses: Record<string, LabelTone>;
   runTriggers: Record<string, string>;
+  features: ClientFeatures;
+  intake: IntakeLimits;
+  attachments: { max: number };
+  voice: VoiceLimits;
 }
+
+// Server kill switches for the phone's new sends.
+export interface ClientFeatures {
+  shakeToReport: boolean;
+  shareIntake: boolean;
+  voice: boolean;
+}
+
+export interface IntakeLimits {
+  maxBytes: number;
+  maxFiles: number;
+  maxInlineImages: number;
+  maxNoteChars: number;
+  screenshotMaxEdge: number;
+  logSeconds: number;
+  logMaxLines: number;
+}
+
+export interface VoiceLimits {
+  maxPhrases: number;
+  holdMinMs: number;
+  cancelSlidePx: number;
+  speakMaxChars: number;
+}
+
+export const INTAKE_LIMITS: IntakeLimits = {
+  maxBytes: 25_000_000,
+  maxFiles: 8,
+  maxInlineImages: 2,
+  maxNoteChars: 280,
+  screenshotMaxEdge: 1600,
+  logSeconds: 60,
+  logMaxLines: 200,
+};
+
+export const ATTACHMENT_LIMITS = { max: 8 };
+
+export const VOICE_LIMITS: VoiceLimits = {
+  maxPhrases: 100,
+  holdMinMs: 250,
+  cancelSlidePx: 80,
+  speakMaxChars: 300,
+};

package/lib/config/client-config.ts

@@ -7,12 +7,26 @@ import {
 import { TASK_STATE_LABELS } from "../tasks/state-labels";
 import { cachedCheck } from "../updates/check";
 import {
+  ATTACHMENT_LIMITS,
   CLIENT_CONFIG_VERSION,
+  INTAKE_LIMITS,
+  VOICE_LIMITS,
+  type ClientFeatures,
   type ClientConfig,
 } from "./client-config-types";
 
 const startedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
 
+// Off when its env switch says so, for a server that wants it dark.
+export function featuresNow(): ClientFeatures {
+  const intake = process.env.AGENTOS_INTAKE !== "off";
+  return {
+    shakeToReport: intake,
+    shareIntake: intake,
+    voice: process.env.AGENTOS_VOICE !== "off",
+  };
+}
+
 export function clientConfig(): ClientConfig {
   return {
     v: CLIENT_CONFIG_VERSION,
@@ -24,5 +38,9 @@ export function clientConfig(): ClientConfig {
     taskStates: TASK_STATE_LABELS,
     runStatuses: RUN_STATUS_LABELS,
     runTriggers: RUN_TRIGGER_LABELS,
+    features: featuresNow(),
+    intake: INTAKE_LIMITS,
+    attachments: ATTACHMENT_LIMITS,
+    voice: VOICE_LIMITS,
   };
 }

package/lib/db/index.ts

@@ -3,6 +3,7 @@ import path from "path";
 import fs from "fs";
 import { createSchema } from "./schema";
 import { runMigrations } from "./migrations";
+import { dbPath } from "./path";
 
 // Re-export types and queries
 export * from "./types";
@@ -11,7 +12,7 @@ export * from "./lumifyhub";
 export * from "./lumifyhub-docs";
 export * from "./stacks";
 
-const DB_PATH = process.env.DB_PATH || path.join(process.cwd(), "agent-os.db");
+const DB_PATH = dbPath();
 const LOCK_PATH = DB_PATH + ".init-lock";
 
 // Simple file-based lock for initialization

package/lib/db/path.ts

@@ -0,0 +1,7 @@
+import path from "path";
+
+export const dbPath = (): string =>
+  process.env.DB_PATH || path.join(process.cwd(), "agent-os.db");
+
+// Where AgentOS keeps its own files beside the database.
+export const dataRoot = (): string => path.dirname(path.resolve(dbPath()));

package/lib/intake/intake.ts

@@ -0,0 +1,250 @@
+import fs from "fs";
+import path from "path";
+import { dataRoot } from "../db/path";
+import type { ChatImage } from "../chat/events";
+import { chatState, sendChat } from "../chat/runner";
+import { ensureOrchestrator, getOrchestrator } from "../orchestrator/home";
+import { getWorkspace } from "../workspaces";
+import { INTAKE_LIMITS, MAX_INLINE_IMAGE_BYTES } from "./limits";
+import { buildIntakeMessage, type IntakeMeta } from "./message";
+import { sniff } from "./sniff";
+
+export class IntakeError extends Error {
+  constructor(
+    public status: number,
+    message: string
+  ) {
+    super(message);
+  }
+}
+
+export interface IntakeResult {
+  id: string;
+  sessionId: string | null;
+  delivered: "sent" | "queued";
+  dir: string;
+}
+
+export interface IntakeFile {
+  name: string;
+  data: Buffer;
+}
+
+const ID = /^[A-Za-z0-9-]{8,64}$/;
+const DAY = 86_400_000;
+
+const segment = (s: string) => s.replace(/[^\w-]/g, "_");
+const day = (t: number) => new Date(t).toISOString().slice(0, 10);
+
+const workspaceRoot = (workspaceId: string) =>
+  path.join(dataRoot(), "intake", segment(workspaceId));
+
+/** A phone's filename as one safe path segment. */
+export function safeName(name: string, taken: Set<string>, n: number): string {
+  let base = path.basename(name.replace(/\\/g, "/"));
+  base = base
+    .replace(/[^a-zA-Z0-9.-]/g, "_")
+    .replace(/^\.+/, "")
+    .slice(0, 80);
+  if (!base) base = `file-${n}`;
+  let out = base;
+  for (let i = 2; taken.has(out); i++) {
+    const dot = base.lastIndexOf(".");
+    out =
+      dot > 0 ? `${base.slice(0, dot)}-${i}${base.slice(dot)}` : `${base}-${i}`;
+  }
+  taken.add(out);
+  return out;
+}
+
+function checkMeta(meta: IntakeMeta) {
+  if (!meta || typeof meta !== "object") throw new IntakeError(400, "Bad meta");
+  if (typeof meta.clientId !== "string" || !ID.test(meta.clientId))
+    throw new IntakeError(400, "clientId must be a uuid");
+  if (meta.kind !== "report" && meta.kind !== "share")
+    throw new IntakeError(400, "kind must be report or share");
+  if (meta.note !== undefined) {
+    if (typeof meta.note !== "string") throw new IntakeError(400, "Bad note");
+    if (meta.note.length > INTAKE_LIMITS.maxNoteChars)
+      throw new IntakeError(413, "Note is too long");
+  }
+}
+
+// An earlier request with this clientId, today or just before midnight.
+function existing(
+  workspaceId: string,
+  clientId: string,
+  now: number
+): string | null {
+  for (const t of [now, now - DAY]) {
+    const dir = path.join(workspaceRoot(workspaceId), day(t), clientId);
+    if (fs.existsSync(dir)) return dir;
+  }
+  return null;
+}
+
+function earlier(dir: string, clientId: string, workspaceId: string) {
+  try {
+    return JSON.parse(
+      fs.readFileSync(path.join(dir, "result.json"), "utf8")
+    ) as IntakeResult;
+  } catch {
+    // The first request is still delivering.
+    return {
+      id: clientId,
+      sessionId: getOrchestrator(workspaceId)?.id ?? null,
+      delivered: "queued",
+      dir,
+    } satisfies IntakeResult;
+  }
+}
+
+/** Saves what a phone sent and hands it to the workspace's orchestrator. */
+export async function receiveIntake(input: {
+  workspaceId: string;
+  deviceName: string;
+  meta: IntakeMeta;
+  files: IntakeFile[];
+  now?: number;
+}): Promise<IntakeResult & { duplicate: boolean }> {
+  const { workspaceId, deviceName, meta, files } = input;
+  const now = input.now ?? Date.now();
+  if (!getWorkspace(workspaceId))
+    throw new IntakeError(404, "Unknown workspace");
+  checkMeta(meta);
+  if (files.length > INTAKE_LIMITS.maxFiles)
+    throw new IntakeError(413, "Too many files");
+  const total = files.reduce((n, f) => n + f.data.length, 0);
+  if (total > INTAKE_LIMITS.maxBytes) throw new IntakeError(413, "Too large");
+  const sniffed = files.map((f) => {
+    const kind = sniff(f.data, f.name);
+    if (!kind)
+      throw new IntakeError(415, `Can't take ${path.basename(f.name)}`);
+    return kind;
+  });
+
+  const prior = existing(workspaceId, meta.clientId, now);
+  if (prior)
+    return { ...earlier(prior, meta.clientId, workspaceId), duplicate: true };
+
+  const parent = path.join(workspaceRoot(workspaceId), day(now));
+  const dir = path.join(parent, meta.clientId);
+  fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+  try {
+    fs.mkdirSync(dir, { mode: 0o700 });
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "EEXIST")
+      return { ...earlier(dir, meta.clientId, workspaceId), duplicate: true };
+    throw e;
+  }
+
+  try {
+    const write = (name: string, data: string | Buffer) =>
+      fs.writeFileSync(path.join(dir, name), data, { mode: 0o600 });
+    write(
+      "meta.json",
+      JSON.stringify({ ...meta, deviceName, receivedAt: now }, null, 2)
+    );
+    if (meta.kind === "report")
+      write("report.json", JSON.stringify(meta.report ?? {}, null, 2));
+    const taken = new Set([
+      "meta.json",
+      "report.json",
+      "logs.txt",
+      "result.json",
+    ]);
+    let logs: string | undefined;
+    const saved: { path: string; name: string; i: number }[] = [];
+    files.forEach((f, i) => {
+      if (f.name === "logs.txt" && logs === undefined) {
+        logs = f.data
+          .toString("utf8")
+          .split(/\r?\n/)
+          .slice(-INTAKE_LIMITS.logMaxLines)
+          .join("\n");
+        write("logs.txt", logs);
+        return;
+      }
+      const name = safeName(f.name, taken, i + 1);
+      write(name, f.data);
+      saved.push({ path: path.join(dir, name), name, i });
+    });
+
+    const images: ChatImage[] = saved
+      .filter(
+        (s) =>
+          sniffed[s.i].kind === "image" &&
+          sniffed[s.i].mediaType !== "image/heic" &&
+          files[s.i].data.length <= MAX_INLINE_IMAGE_BYTES
+      )
+      .sort(
+        (a, b) =>
+          Number(/^screenshot/.test(b.name)) -
+          Number(/^screenshot/.test(a.name))
+      )
+      .slice(0, INTAKE_LIMITS.maxInlineImages)
+      .map((s) => ({
+        mediaType: sniffed[s.i].mediaType,
+        data: files[s.i].data.toString("base64"),
+      }));
+
+    const { text, body } = buildIntakeMessage({
+      meta,
+      deviceName,
+      dir,
+      files: saved.map((s) => s.path),
+      logs,
+    });
+    const orchestrator = ensureOrchestrator(workspaceId);
+    const state = chatState(orchestrator.id);
+    const delivered =
+      state === "running" || state === "waiting" ? "queued" : "sent";
+    await sendChat(orchestrator.id, {
+      id: `intake-${meta.clientId}`,
+      text,
+      images: images.length ? images : undefined,
+      queue: true,
+      origin: { kind: "device", label: deviceName, body },
+    });
+    const result: IntakeResult = {
+      id: meta.clientId,
+      sessionId: orchestrator.id,
+      delivered,
+      dir,
+    };
+    write("result.json", JSON.stringify(result));
+    return { ...result, duplicate: false };
+  } catch (e) {
+    // So a retry can deliver it.
+    fs.rmSync(dir, { recursive: true, force: true });
+    throw e;
+  }
+}
+
+/** The request's form, refused once its body passes `max` bytes. */
+export async function cappedFormData(
+  request: Request,
+  max: number
+): Promise<FormData> {
+  const declared = Number(request.headers.get("content-length") ?? 0);
+  if (declared > max) throw new IntakeError(413, "Too large");
+  if (!request.body) throw new IntakeError(400, "No body");
+  let size = 0;
+  const counted = request.body.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      transform(chunk, controller) {
+        size += chunk.byteLength;
+        if (size > max) controller.error(new IntakeError(413, "Too large"));
+        else controller.enqueue(chunk);
+      },
+    })
+  );
+  try {
+    return await new Response(counted, {
+      headers: { "content-type": request.headers.get("content-type") ?? "" },
+    }).formData();
+  } catch (e) {
+    if (e instanceof IntakeError) throw e;
+    throw new IntakeError(size > max ? 413 : 400, "Bad upload");
+  }
+}

package/lib/intake/limits.ts

@@ -0,0 +1,30 @@
+import { INTAKE_LIMITS } from "../config/client-config-types";
+
+export { INTAKE_LIMITS };
+
+export const RATE = { max: 20, windowMs: 10 * 60_000 };
+// Under the 5 MB an image may be once base64'd.
+export const MAX_INLINE_IMAGE_BYTES = 3_750_000;
+export const SHARE_EXCERPT_BYTES = 2048;
+export const MAX_META_BYTES = 64 * 1024;
+export const REPORT_INLINE_MAX = 1500;
+// Multipart framing on top of the files themselves.
+export const BODY_SLACK_BYTES = 1_000_000;
+
+const hits = new Map<string, number[]>();
+
+/** Counts a request against the device; false once it is over the cap. */
+export function takeIntakeSlot(deviceId: string, now = Date.now()): boolean {
+  const recent = (hits.get(deviceId) ?? []).filter(
+    (t) => t > now - RATE.windowMs
+  );
+  if (recent.length >= RATE.max) {
+    hits.set(deviceId, recent);
+    return false;
+  }
+  recent.push(now);
+  hits.set(deviceId, recent);
+  return true;
+}
+
+export const resetIntakeRate = () => hits.clear();