privateer-agent 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privateer-agent",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Privateer — a provider-agnostic terminal coding agent. Bring your own model (OpenRouter, Anthropic, OpenAI, Ollama, NEAR AI).",
   "type": "module",
   "license": "MIT",

package/src/components/App.tsx

@@ -25,7 +25,7 @@ import { loadMcpServers, connectMcpServers, type McpConnection } from "../mcp/cl
 import { hasStoredAuth, clearStoredAuth } from "../mcp/oauth.ts";
 import { TodoPanel } from "./TodoPanel.tsx";
 import { exec } from "../tools/exec.ts";
-import { resolveAttachments, chipFor } from "../util/images.ts";
+import { resolveAttachments, chipFor, mediaModality } from "../util/images.ts";
 import type { Attachment } from "../util/images.ts";
 import { AttachmentStore } from "../util/attachmentStore.ts";
 import type { Entry, ToolEntry, Row } from "./types.ts";
@@ -203,6 +203,9 @@ export function App({
   // rewrote to chips in the buffer text. Each turn claims the ones whose chip
   // survives into its submitted text, so the base64 still rides along.
   const pendingImagesRef = useRef<Attachment[]>([]);
+  // Files received from the app over the relay, awaiting the next remote prompt to
+  // ride along with (mirrors how drag/paste stages into pendingImagesRef).
+  const pendingRemoteAttachmentsRef = useRef<{ name: string; mediaType: string; base64: string }[]>([]);
   // Session-lifetime checkpoint store (survives model/style switches) for /rewind,
   // plus a live mirror of the committed transcript length for checkpointing. Bound to
   // the session's on-disk checkpoint dir so /rewind survives a restart-and-resume; a
@@ -457,13 +460,53 @@ export function App({
   // remote prompt queues/dispatches against the current `busy`, never a stale one.
   handleInputRef.current = (value, opts) => handleInput(value, opts);
 
+  // Fold any files the app sent over the relay into a remote prompt. Binary kinds
+  // (image/pdf/…) become "[Kind #n]" chips backed by staged bytes that runTurn's
+  // liveAttachments filter then claims; text-like kinds are decoded and inlined as a
+  // fenced block. Returns the augmented prompt, or null when there's nothing to run
+  // (no text and no files). Mirrors the drag/paste staging into pendingImagesRef.
+  function consumeRemoteAttachments(text: string): string | null {
+    const files = pendingRemoteAttachmentsRef.current;
+    pendingRemoteAttachmentsRef.current = [];
+    if (files.length === 0) return text.trim() ? text : null;
+
+    const chips: string[] = [];
+    const inlined: string[] = [];
+    const maxInline = config.router?.inlineTextMaxBytes ?? 65_536;
+    for (const f of files) {
+      const modality = mediaModality(f.mediaType);
+      if (modality) {
+        const n = (imageSeqRef.current += 1);
+        const att: Attachment = { data: f.base64, mediaType: f.mediaType, modality, path: f.name, n };
+        pendingImagesRef.current.push(att);
+        chips.push(chipFor(att));
+      } else {
+        let body = "";
+        try { body = Buffer.from(f.base64, "base64").toString("utf8"); } catch { body = ""; }
+        if (body.length > maxInline) body = body.slice(0, maxInline) + `\n… (truncated, ${body.length - maxInline} more chars)`;
+        inlined.push(`\n\n${f.name}:\n\`\`\`\n${body}\n\`\`\``);
+      }
+    }
+    const head = text.trim();
+    const chipLine = chips.length ? (head ? " " : "") + chips.join(" ") : "";
+    const composed = `${head}${chipLine}${inlined.join("")}`.trim();
+    return composed.length ? composed : null;
+  }
+
   // Open/close the relay when /remote-access is toggled. The client is owned here
   // (mirrors mcpRef) and torn down on disable/unmount. On teardown we resolve any
   // parked approvals to "deny" so a dropped controller can't wedge a turn.
   useEffect(() => {
     if (!remoteEnabled) return;
     const client = new RelayClient({
-      onPrompt: (text) => handleInputRef.current(text, { remote: true }),
+      onPrompt: (text) => {
+        const merged = consumeRemoteAttachments(text);
+        if (merged) handleInputRef.current(merged, { remote: true });
+      },
+      onAttachment: (file) => {
+        pendingRemoteAttachmentsRef.current.push(file);
+        append({ kind: "notice", text: `📎 received ${file.name} from app` });
+      },
       onInterrupt: () => abortRef.current?.abort(),
       onApprovalResponse: (id, decision) => {
         const entry = pendingApprovalsRef.current.get(id);
@@ -1313,6 +1356,7 @@ export function App({
           custom={statusText || undefined}
           zdr={zdr}
           tee={tee}
+          remote={remoteEnabled}
         />
 
         {picking ? (

package/src/components/Banner.tsx

@@ -4,6 +4,7 @@ import { Box, Text } from "ink";
 import { VERSION } from "../version.ts";
 import { theme } from "./theme.ts";
 import { WELCOME } from "./figures.ts";
+import { currentUser } from "../auth/privateer.ts";
 
 // Collapse the user's home directory to ~ for a compact path display.
 function shortenPath(cwd: string): string {
@@ -13,6 +14,17 @@ function shortenPath(cwd: string): string {
     : cwd;
 }
 
+// The Privateer account this terminal is signed into: email accounts show the
+// email; wallet accounts (no email) show the first few characters of the Solana
+// public key. Returns null when running unauthenticated (BYO key, no account).
+function accountLabel(): string | null {
+  const user = currentUser();
+  if (!user) return null;
+  if (user.email) return user.email;
+  if (user.solanaPublicKey) return user.solanaPublicKey.slice(0, 6) + "…";
+  return null;
+}
+
 // Anchor motif rendered in ASCII — the Privateer mark (ring, stock, shank, flukes).
 const ANCHOR = [
   "    .-.    ",
@@ -24,6 +36,7 @@ const ANCHOR = [
 ];
 
 export function Banner({ model }: { model: string }) {
+  const account = accountLabel();
   return (
     <Box flexDirection="column">
       <Box
@@ -45,6 +58,11 @@ export function Banner({ model }: { model: string }) {
             {WELCOME} PRIVATEER
           </Text>
           <Text color={theme.dim}>bring your own model · v{VERSION}</Text>
+          {account && (
+            <Text color={theme.dim}>
+              connected as <Text color={theme.accent}>{account}</Text>
+            </Text>
+          )}
           <Text> </Text>
           <Text>
             model <Text color={theme.accent}>{model}</Text>

package/src/components/StatusBar.tsx

@@ -2,7 +2,7 @@ import React from "react";
 import { Box, Text } from "ink";
 import { basename } from "node:path";
 import { theme, POSTURE_COLOR } from "./theme.ts";
-import { SHIELD } from "./figures.ts";
+import { SHIELD, DOT } from "./figures.ts";
 import { useTerminalWidth } from "./useTerminalWidth.ts";
 import { type UsageTotals } from "../engine/events.ts";
 import type { ZdrState } from "./useZdrShield.ts";
@@ -30,6 +30,14 @@ function TeeBadge({ tee }: { tee?: TeeState }) {
   return <Text color={theme.dim}>{`${SHIELD} TEE? · `}</Text>;
 }
 
+// Remote-access badge: a green "● remote" segment shown while /remote-access is on,
+// signalling the Privateer app can drive this terminal (send prompts / approve its
+// tool calls). Nothing at all when remote access is off.
+function RemoteBadge({ remote }: { remote?: boolean }) {
+  if (!remote) return null;
+  return <Text color={theme.success}>{`${DOT} remote · `}</Text>;
+}
+
 // Compact token count: 100, 1k, 1m, 1b — one decimal place above 1k, trimmed of
 // trailing ".0", so 1500 → "1.5k" and 2000 → "2k".
 export function formatTokens(n: number): string {
@@ -86,6 +94,7 @@ export function StatusBar(props: {
   custom?: string; // settings-driven status line; overrides the default when set
   zdr?: ZdrState; // OpenRouter ZDR posture for the selected model (default line only)
   tee?: TeeState; // NEAR AI TEE attestation posture for the selected model (default line only)
+  remote?: boolean; // /remote-access is on — the app can drive this terminal (default line only)
 }) {
   // Stay clear of the right edge (parent paddingX={1} plus a 2-col safety gap) so
   // the line never reaches the final column and the terminal never reflows it.
@@ -109,6 +118,7 @@ export function StatusBar(props: {
       <Text wrap="truncate-end">
         <ZdrBadge zdr={props.zdr} />
         <TeeBadge tee={props.tee} />
+        <RemoteBadge remote={props.remote} />
         <Text color={theme.accent}>⚓ privateer</Text>
         {diag ? <Text color={theme.dim}>{` [${diag}]`}</Text> : null}
         <Text color={theme.dim}> (shift+tab to cycle)</Text>

package/src/components/figures.ts

@@ -10,4 +10,5 @@ export const POINTER = "❯"; // selection pointer in menus and the prompt caret
 export const FAST_FORWARD = "⏵⏵"; // marks an "on" permission mode below the prompt
 export const PAUSE = "⏸"; // marks plan mode (paused execution) below the prompt
 export const SHIELD = "⛉"; // U+26C9 — OpenRouter ZDR posture marker in the status bar
+export const DOT = "●"; // U+25CF — "live" marker; the remote-access badge in the status bar
 export const DOWN = "↓"; // U+2193 — output tokens streaming down from the model (spinner)

package/src/remote/relayClient.ts

@@ -58,11 +58,19 @@ export interface RelayCallbacks {
   onApprovalResponse: (id: string, decision: "allow" | "deny") => void;
   // A controller attached — push a transcript snapshot so it can catch up.
   onControllerAttached: () => void;
+  // A file finished transferring from the app (reassembled from chunks). Held to
+  // ride along with the next remote prompt.
+  onAttachment: (file: { name: string; mediaType: string; base64: string }) => void;
   // Surface a one-line status/notice in the TUI.
   onStatus?: (text: string) => void;
 }
 
 const RECONNECT_MS = 3000;
+// File-transfer ceilings for app→CLI attachments. The app enforces its own caps
+// before sending; these are a defensive backstop so a controller can't exhaust
+// memory with a lying `size` or a flood of concurrent transfers.
+const MAX_ATTACH_BYTES = 10 * 1024 * 1024; // 10 MB per file
+const MAX_INFLIGHT_ATTACH = 8; // simultaneous transfers
 // Coalesce streaming deltas so we don't emit one WS frame per token.
 const TEXT_FLUSH_MS = 60;
 
@@ -120,6 +128,12 @@ export class RelayClient {
   // Stable for this process so reconnects keep the same terminal identity.
   private readonly termId = randomUUID();
   private readonly label = terminalLabel();
+  // In-progress file transfers from the app, keyed by the controller's attachment
+  // id. Reassembled from attach_begin/chunk/end frames, then handed to onAttachment.
+  private readonly incoming = new Map<
+    string,
+    { name: string; mediaType: string; chunks: string[]; received: number }
+  >();
 
   constructor(private readonly cb: RelayCallbacks) {}
 
@@ -134,6 +148,7 @@ export class RelayClient {
     if (this.flushTimer) { clearTimeout(this.flushTimer); this.flushTimer = undefined; }
     this.bufKind = null;
     this.buf = "";
+    this.incoming.clear();
     try { this.ws?.close(); } catch (_) { /* ignore */ }
     this.ws = null;
   }
@@ -205,7 +220,17 @@ export class RelayClient {
   }
 
   private handle(data: WebSocket.RawData): void {
-    let frame: { type?: string; text?: string; id?: string; decision?: string };
+    let frame: {
+      type?: string;
+      text?: string;
+      id?: string;
+      decision?: string;
+      name?: string;
+      mediaType?: string;
+      size?: number;
+      seq?: number;
+      data?: string;
+    };
     try {
       frame = JSON.parse(data.toString());
     } catch (_) {
@@ -214,7 +239,10 @@ export class RelayClient {
     this.debug(`recv ${frame.type}`);
     switch (frame.type) {
       case "prompt":
-        if (typeof frame.text === "string" && frame.text.trim()) this.cb.onPrompt(frame.text);
+        // Forward even an empty/whitespace prompt: a file-only send carries no text,
+        // and the app folds any pending attachments in on the prompt frame. App.tsx
+        // no-ops a blank prompt that has no attachments, so this stays safe.
+        if (typeof frame.text === "string") this.cb.onPrompt(frame.text);
         break;
       case "interrupt":
         this.cb.onInterrupt();
@@ -225,7 +253,62 @@ export class RelayClient {
       case "controller_attached":
         this.cb.onControllerAttached();
         break;
+      case "attach_begin":
+        this.beginAttachment(frame);
+        break;
+      case "attach_chunk":
+        this.appendAttachmentChunk(frame);
+        break;
+      case "attach_end":
+        this.endAttachment(frame);
+        break;
+    }
+  }
+
+  // ── app → agent file transfer (chunked) ─────────────────────────────────────
+  // Files are streamed as attach_begin → attach_chunk* → attach_end so each WS
+  // frame stays under the relay's 256 KB cap. We reassemble here and hand the
+  // completed file up via onAttachment; App.tsx folds it into the next prompt.
+
+  private beginAttachment(frame: { id?: string; name?: string; mediaType?: string; size?: number }): void {
+    const { id } = frame;
+    if (!id || typeof frame.name !== "string" || typeof frame.mediaType !== "string") return;
+    if (this.incoming.size >= MAX_INFLIGHT_ATTACH) {
+      this.cb.onStatus?.(`Dropped attachment "${frame.name}" — too many transfers in flight.`);
+      return;
     }
+    if (typeof frame.size === "number" && frame.size > MAX_ATTACH_BYTES) {
+      this.cb.onStatus?.(`Dropped attachment "${frame.name}" — exceeds ${Math.round(MAX_ATTACH_BYTES / (1024 * 1024))} MB.`);
+      return;
+    }
+    this.incoming.set(id, { name: frame.name, mediaType: frame.mediaType, chunks: [], received: 0 });
+  }
+
+  private appendAttachmentChunk(frame: { id?: string; data?: string }): void {
+    const { id } = frame;
+    if (!id || typeof frame.data !== "string") return;
+    const entry = this.incoming.get(id);
+    if (!entry) return; // begin was dropped or never seen
+    entry.received += frame.data.length;
+    // base64 inflates by ~4/3, so received*0.75 ≈ decoded bytes. Bound it in case
+    // `size` was absent or lied at begin time.
+    if (entry.received * 0.75 > MAX_ATTACH_BYTES + 64 * 1024) {
+      this.incoming.delete(id);
+      this.cb.onStatus?.(`Dropped attachment "${entry.name}" — stream exceeded size limit.`);
+      return;
+    }
+    entry.chunks.push(frame.data);
+  }
+
+  private endAttachment(frame: { id?: string }): void {
+    const { id } = frame;
+    if (!id) return;
+    const entry = this.incoming.get(id);
+    if (!entry) return;
+    this.incoming.delete(id);
+    const base64 = entry.chunks.join("");
+    if (!base64) return;
+    this.cb.onAttachment({ name: entry.name, mediaType: entry.mediaType, base64 });
   }
 
   private rawSend(frame: unknown): void {

package/src/util/images.ts

@@ -26,6 +26,19 @@ const MEDIA_TYPES: Record<string, { mediaType: string; modality: Modality }> = {
   ".mkv": { mediaType: "video/x-matroska", modality: "video" },
 };
 
+// Classify a media type into one of our binary modalities, or null when it's a
+// text-like file that should be inlined as plain text rather than attached. Used by
+// the relay path (App.tsx) to decide what to do with a file received from the app:
+// a null result means "decode and inline the text"; otherwise it's a binary
+// attachment the model reads directly.
+export function mediaModality(mediaType: string): Modality | null {
+  if (mediaType.startsWith("image/")) return "image";
+  if (mediaType === "application/pdf") return "document";
+  if (mediaType.startsWith("audio/")) return "audio";
+  if (mediaType.startsWith("video/")) return "video";
+  return null;
+}
+
 // Magic-byte checks per media type, used to reject placeholder/corrupt files at capture
 // time. The motivating case: macOS delivers a drag from a screenshot thumbnail as a
 // *file promise*, so the terminal's …/T/drop-XXXXXX/ file can be a 4-byte stub holding