npm - @circuitwall/jarela - Versions diffs - 1.3.0 → 1.4.1 - Mend

@circuitwall/jarela 1.3.0 → 1.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (102) hide show

package/lib/api/page-capture.test.ts CHANGED Viewed

@@ -307,3 +307,61 @@ describe("handlePageCapture — response shape", () => {
     });
   });
 });
+describe("handlePageCapture — screenshot attachment", () => {
+  // 1x1 transparent PNG, base64-encoded (no data: prefix).
+  const tinyPng =
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+  it("rejects screenshot with invalid base64", async () => {
+    const res = await handlePageCapture(makeReq({ ...validBody, screenshot: "not base64!!" }));
+    expect(res.status).toBe(400);
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+  it("rejects screenshot exceeding the size cap", async () => {
+    const huge = "A".repeat(4_000_001);
+    const res = await handlePageCapture(makeReq({ ...validBody, screenshot: huge }));
+    expect(res.status).toBe(400);
+  });
+  it("persists user message as a JSON ContentPart[] with text + image when screenshot is present", async () => {
+    const res = await handlePageCapture(makeReq({ ...validBody, screenshot: tinyPng }));
+    expect(res.status).toBe(200);
+    const stored = addMessageMock.mock.calls[0][2] as string;
+    const parsed = JSON.parse(stored) as Array<{ type: string; text?: string; media_type?: string; data?: string }>;
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed).toHaveLength(2);
+    expect(parsed[0]).toMatchObject({ type: "text" });
+    expect(parsed[0].text).toContain("Captured from");
+    expect(parsed[0].text).toContain("Screenshot attached.");
+    expect(parsed[1]).toEqual({ type: "image", media_type: "image/png", data: tinyPng });
+  });
+  it("forwards the screenshot as a vision attachment to the silent observer run", async () => {
+    await handlePageCapture(makeReq({ ...validBody, screenshot: tinyPng }));
+    expect(runAgentTurnMock).toHaveBeenCalledWith(expect.objectContaining({
+      attachments: [{ type: "image", media_type: "image/png", data: tinyPng }],
+    }));
+  });
+  it("honors a custom screenshotMediaType", async () => {
+    await handlePageCapture(makeReq({ ...validBody, screenshot: tinyPng, screenshotMediaType: "image/jpeg" }));
+    const stored = addMessageMock.mock.calls[0][2] as string;
+    const parsed = JSON.parse(stored) as Array<{ type: string; media_type?: string }>;
+    expect(parsed[1].media_type).toBe("image/jpeg");
+  });
+  it("keeps the legacy string-content path when no screenshot is sent", async () => {
+    await handlePageCapture(makeReq(validBody));
+    const stored = addMessageMock.mock.calls[0][2] as string;
+    // Not JSON-parseable as an array — it's the legacy plaintext body.
+    expect(() => JSON.parse(stored)).toThrow();
+    expect(stored).toContain("Captured from");
+    expect(stored).not.toContain("Screenshot attached.");
+    expect(runAgentTurnMock).toHaveBeenCalledWith(expect.objectContaining({
+      attachments: undefined,
+    }));
+  });
+});

package/lib/api/page-capture.ts CHANGED Viewed

@@ -13,12 +13,18 @@ import {
 } from "@/lib/stores/agent-configs";
 import { publish } from "@/lib/notifications/bus";
 import { runAgentTurn } from "@/lib/agents/agent-turn";
+import type { ContentPart } from "@/lib/tools/types";
 // 100KB UTF-8 cap on captured text. The LLM context window is the real
 // constraint; this cap exists to keep a runaway "<body>" pick from
 // trashing the conversation. See ADR-0018.
 export const MAX_TEXT_BYTES = 100_000;
+// Hard cap on the inline element screenshot (base64 chars). 4 MB of
+// base64 ≈ 3 MB decoded — generous for a single cropped element while
+// still bounding the SQLite row and the LLM vision payload.
+export const MAX_SCREENSHOT_B64 = 4_000_000;
 // Preamble prepended to the LLM call for the silent observer run.
 // The captured content is already persisted in the DB — this wrapper
 // instructs the agent to observe without replying, matching bridge
@@ -37,6 +43,13 @@ const Body = z.object({
   tagName: z.string().max(64).optional(),
   text: z.string(),
   capturedAt: z.string().datetime(),
+  // Optional base64-encoded PNG of just the picked element (no data: URL
+  // prefix). The content script crops `chrome.tabs.captureVisibleTab`
+  // to the element bounding box before sending. When present, it is
+  // attached to the persisted user message as an image ContentPart so
+  // the chat UI renders it inline and vision-capable agents can see it.
+  screenshot: z.string().regex(/^[A-Za-z0-9+/=]+$/).max(MAX_SCREENSHOT_B64).optional(),
+  screenshotMediaType: z.string().regex(/^image\/[a-z0-9.+-]+$/).max(64).optional(),
 });
 function truncateUtf8(s: string, maxBytes: number): { text: string; truncated: boolean; originalBytes: number } {
@@ -102,12 +115,14 @@ function composeBody(args: {
   text: string;
   truncated: boolean;
   originalBytes: number;
+  hasScreenshot?: boolean;
 }): string {
   const heading = args.title
     ? `📎 Captured from [${args.title}](${args.url})`
     : `📎 Captured from <${args.url}>`;
   const lines = [heading];
   if (args.selector) lines.push(`Element: \`${args.selector}\``);
+  if (args.hasScreenshot) lines.push("Screenshot attached.");
   if (args.truncated) {
     lines.push(`> ⚠ Truncated to ${MAX_TEXT_BYTES.toLocaleString()} bytes (original was ${args.originalBytes.toLocaleString()} bytes)`);
   }
@@ -158,9 +173,23 @@ export async function handlePageCapture(req: Request): Promise<Response> {
     text,
     truncated,
     originalBytes,
+    hasScreenshot: Boolean(input.screenshot),
   });
-  const msg = addMessage(thread_id, "user", messageBody, undefined, "page_capture");
+  // When a screenshot is included, persist the user turn as a multipart
+  // ContentPart[] (text + image) — that's the same shape the chat UI and
+  // agent runner expect for inline images, so the picture renders in the
+  // bubble on reload and vision-capable models can see it on the silent
+  // observer turn. Without a screenshot we keep the legacy string body
+  // to avoid touching messages that never had an image.
+  const screenshotPart: ContentPart | null = input.screenshot
+    ? { type: "image", media_type: input.screenshotMediaType ?? "image/png", data: input.screenshot }
+    : null;
+  const storedContent: string = screenshotPart
+    ? JSON.stringify([{ type: "text", text: messageBody }, screenshotPart] satisfies ContentPart[])
+    : messageBody;
+  const msg = addMessage(thread_id, "user", storedContent, undefined, "page_capture");
   // Fire a silent observer run so the agent ingests the captured context
   // without being forced to reply — matching bridge silent/observer mode.
@@ -170,6 +199,7 @@ export async function handlePageCapture(req: Request): Promise<Response> {
     thread_id,
     queue_source: "extension",
     message: `${SILENT_CAPTURE_PREAMBLE}\n\n${messageBody}`,
+    attachments: screenshotPart ? [screenshotPart] : undefined,
     user_category: "page_capture",
     assistant_category: "page_capture",
     silent: true,

package/lib/documents/remote/github.ts CHANGED Viewed

@@ -216,10 +216,23 @@ async function runGithubPullsIndexer(source: DocumentSourceRow): Promise<GithubI
       if (Number.isFinite(sinceMs) && Number.isFinite(updatedMs) && updatedMs <= sinceMs) break outer;
       try {
-        const [comments, reviews] = await Promise.all([
+        // allSettled so a failed comments fetch doesn't also discard
+        // the reviews (and vice versa); we still index what we have and
+        // count the partial as an error.
+        const [commentsRes, reviewsRes] = await Promise.allSettled([
           listIssueComments(auth, cfg.owner, cfg.repo, pr.number),
           listReviews(auth, cfg.owner, cfg.repo, pr.number),
         ]);
+        const comments = commentsRes.status === "fulfilled" ? commentsRes.value : [];
+        const reviews = reviewsRes.status === "fulfilled" ? reviewsRes.value : [];
+        if (commentsRes.status === "rejected") {
+          stats.errors++;
+          console.warn(`[github-indexer] pr#${pr.number} comments failed:`, commentsRes.reason);
+        }
+        if (reviewsRes.status === "rejected") {
+          stats.errors++;
+          console.warn(`[github-indexer] pr#${pr.number} reviews failed:`, reviewsRes.reason);
+        }
         const text = flattenPull(pr, comments, reviews);
         const res = await upsertRemoteDocument(source.id, {
           path: `github-pull://${cfg.owner}/${cfg.repo}/${pr.number}`,
@@ -229,8 +242,9 @@ async function runGithubPullsIndexer(source: DocumentSourceRow): Promise<GithubI
         });
         applyUpsert(stats, res);
         if (updated && (!highWater || updated > highWater)) highWater = updated;
-      } catch {
+      } catch (err) {
         stats.errors++;
+        console.warn(`[github-indexer] pr#${pr.number} upsert failed:`, err);
       }
     }
     if (pulls.length < PR_PAGE_LIMIT) break;

package/lib/documents/remote/mail.ts CHANGED Viewed

@@ -182,7 +182,10 @@ async function indexGmailMail(row: DocumentSourceRow): Promise<RemoteIndexStats>
     const batch = list.messages ?? [];
     if (batch.length === 0) break;
-    const results = await Promise.all(batch.slice(0, limit).map(async (entry) => {
+    // Use allSettled so a single 404/transient 5xx on one message
+    // doesn't bin the whole page (and stall the cursor on the next
+    // run). Failures get counted into stats.errors instead.
+    const settled = await Promise.allSettled(batch.slice(0, limit).map(async (entry) => {
       const msg = await googleFetch(
         auth,
         "Gmail",
@@ -212,10 +215,16 @@ async function indexGmailMail(row: DocumentSourceRow): Promise<RemoteIndexStats>
       });
     }));
-    for (const [index, item] of results.entries()) {
+    for (const [index, outcome] of settled.entries()) {
       const id = batch[index]?.id ?? "";
       if (id) keep.add(`gmail://${id}`);
       stats.scanned++;
+      if (outcome.status === "rejected") {
+        stats.errors++;
+        console.warn(`[mail-indexer] message ${id} failed:`, outcome.reason);
+        continue;
+      }
+      const item = outcome.value;
       stats.added += item.status === "added" ? 1 : 0;
       stats.updated += item.status === "updated" ? 1 : 0;
       stats.unchanged += item.status === "unchanged" ? 1 : 0;

package/lib/lifecycle/shutdown.ts CHANGED Viewed

@@ -131,6 +131,15 @@ async function runShutdown(): Promise<void> {
     console.error("[jarela] waiting for runs failed:", err);
   }
+  // 4b. Stop the async-tool-results sweeper. Holds a setInterval that
+  //     would otherwise keep the event loop alive past closeDb().
+  try {
+    const { stopAsyncResults } = await import("@/lib/tools/async-results");
+    stopAsyncResults();
+  } catch (err) {
+    console.error("[jarela] stopping async-results sweeper failed:", err);
+  }
   // 5. Close the DB. WAL is checkpointed so the next boot is fast and we
   //    leave no stale -shm/-wal sidecars on disk.
   try {

package/lib/providers/github-copilot-auth.ts CHANGED Viewed

@@ -44,6 +44,7 @@ export async function startDeviceFlow(): Promise<DeviceCodeResponse> {
       "User-Agent": "Jarela/1.0",
     },
     body: JSON.stringify({ client_id: COPILOT_CLIENT_ID, scope: SCOPE }),
+    signal: AbortSignal.timeout(30_000),
   });
   if (!res.ok) {
     const body = await res.text().catch(() => res.statusText);
@@ -69,6 +70,7 @@ export async function pollDeviceFlow(device_code: string): Promise<PollResult> {
       device_code,
       grant_type: "urn:ietf:params:oauth:grant-type:device_code",
     }),
+    signal: AbortSignal.timeout(30_000),
   });
   if (!res.ok) {
     return { status: "error", error: `HTTP ${res.status}` };

package/lib/providers/github-copilot.ts CHANGED Viewed

@@ -53,6 +53,7 @@ async function getCopilotToken(pat: string): Promise<string> {
       Authorization: `token ${pat}`,
       "User-Agent": "Jarela/1.0",
     },
+    signal: AbortSignal.timeout(30_000),
   });
   if (!res.ok) {

package/lib/tools/async-results.ts CHANGED Viewed

@@ -57,6 +57,17 @@ function ensureSweeper(): void {
   (sweeper as unknown as { unref?: () => void }).unref?.();
 }
+/**
+ * Tear down the sweeper. Called from the shutdown drain so the timer
+ * isn't keeping the event loop alive past close-time. Idempotent.
+ */
+export function stopAsyncResults(): void {
+  if (sweeper) {
+    clearInterval(sweeper);
+    sweeper = null;
+  }
+}
 /**
  * Carve out a slot for a new async tool call and return its key.
  * The key is opaque and URL-safe — the agent treats it as a token.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@circuitwall/jarela",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Jarela — local chat interface for LangGraph agents (multi-provider, single-process, SQLite-backed).",
   "license": "Apache-2.0",
   "author": "Andrew Ge Wu",
@@ -100,6 +100,7 @@
     "test:live:isolated:full": "node scripts/live-test-isolated.mjs --llm",
     "test:e2e": "playwright test",
     "test:e2e:ui": "playwright test --ui",
+    "promo:record": "node scripts/promo-record.mjs",
     "release:docker": "node scripts/release-docker.mjs",
     "release:docker:dry": "node scripts/release-docker.mjs --dry-run"
   },

package/scripts/install-to-system.ps1 CHANGED Viewed

@@ -245,8 +245,8 @@ $settings = New-ScheduledTaskSettingsSet `
   -StartWhenAvailable `
   -Hidden `
   -ExecutionTimeLimit (New-TimeSpan -Seconds 0) `
-  -RestartInterval (New-TimeSpan -Minutes 1) `
-  -RestartCount 999 `
+  -RestartInterval (New-TimeSpan -Minutes 5) `
+  -RestartCount 3 `
   -MultipleInstances IgnoreNew
 $task = New-ScheduledTask `

package/scripts/installed-launcher.ps1 CHANGED Viewed

@@ -120,41 +120,105 @@ $env:PORT     = "$Port"
 $env:HOSTNAME = '127.0.0.1'
 $env:NODE_ENV = 'production'
-# Separate files for the node child's stdout/stderr. The launcher writes its
-# own supervisor messages to $LogFile; Start-Process cannot share that handle
-# with a child or it fails silently on Windows ("file is in use").
+# Separate files for the node child's stdout/stderr. We append (>>) instead
+# of truncating each spawn so a crash-and-respawn cycle keeps the prior
+# stderr lines around for diagnosis.
 $ServerOut = Join-Path $LogDir 'server.out.log'
 $ServerErr = Join-Path $LogDir 'server.err.log'
+# Spawn node and reliably capture stdout/stderr to files. Background:
+# `Start-Process -NoNewWindow -RedirectStandardOutput X -RedirectStandardError Y`
+# silently drops both streams when the parent chain is wscript -> powershell
+# (i.e. when there is no console attached to the PowerShell host). Under that
+# setup, server.out.log / server.err.log stay 0 bytes forever, hiding crash
+# reasons. Switching to a raw `[System.Diagnostics.Process]` with async
+# `BeginOutputReadLine`/`BeginErrorReadLine` event handlers works regardless
+# of console attachment because the read loop runs on a .NET worker thread.
+function Start-NodeChild([string]$nodeExe, [string]$workDir, [string]$outFile, [string]$errFile) {
+  $psi = New-Object System.Diagnostics.ProcessStartInfo
+  $psi.FileName               = $nodeExe
+  $psi.Arguments              = 'server.js'
+  $psi.WorkingDirectory       = $workDir
+  $psi.UseShellExecute        = $false
+  $psi.RedirectStandardOutput = $true
+  $psi.RedirectStandardError  = $true
+  $psi.CreateNoWindow         = $true
+  # Env (PORT, HOSTNAME, NODE_ENV set above) is inherited by default.
+  $proc = New-Object System.Diagnostics.Process
+  $proc.StartInfo           = $psi
+  $proc.EnableRaisingEvents = $true
+  # StreamWriters with AutoFlush=true so every line lands on disk immediately.
+  $outFs = [System.IO.File]::Open($outFile, [System.IO.FileMode]::Append, [System.IO.FileAccess]::Write, [System.IO.FileShare]::Read)
+  $errFs = [System.IO.File]::Open($errFile, [System.IO.FileMode]::Append, [System.IO.FileAccess]::Write, [System.IO.FileShare]::Read)
+  $outSw = New-Object System.IO.StreamWriter($outFs, [System.Text.Encoding]::UTF8)
+  $errSw = New-Object System.IO.StreamWriter($errFs, [System.Text.Encoding]::UTF8)
+  $outSw.AutoFlush = $true
+  $errSw.AutoFlush = $true
+  $outEvent = Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -MessageData $outSw -Action {
+    if ($EventArgs.Data -ne $null) { $Event.MessageData.WriteLine($EventArgs.Data) }
+  }
+  $errEvent = Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -MessageData $errSw -Action {
+    if ($EventArgs.Data -ne $null) { $Event.MessageData.WriteLine($EventArgs.Data) }
+  }
+  if (-not $proc.Start()) { return $null }
+  $proc.BeginOutputReadLine()
+  $proc.BeginErrorReadLine()
+  return [PSCustomObject]@{
+    Process    = $proc
+    OutWriter  = $outSw
+    ErrWriter  = $errSw
+    OutFs      = $outFs
+    ErrFs      = $errFs
+    OutEvent   = $outEvent
+    ErrEvent   = $errEvent
+  }
+}
 # Supervisor loop: respawn server.js if it exits. Bail after too many rapid
-# restarts so Task Scheduler can retry the whole task.
+# restarts (3 in 60s) so Task Scheduler can decide. With an encrypted master
+# key, every restart costs the user a manual PIN entry, so we prefer to fail
+# loudly rather than churn silently.
 $restartCount = 0
 $windowStart  = Get-Date
 while ($true) {
   Write-Log "Starting 'node server.js' on http://127.0.0.1:$Port (out=$ServerOut)"
-  $proc = Start-Process -FilePath $node `
-            -ArgumentList 'server.js' `
-            -WorkingDirectory $InstallDir `
-            -NoNewWindow `
-            -PassThru `
-            -RedirectStandardOutput $ServerOut `
-            -RedirectStandardError  $ServerErr
-  if (-not $proc) {
-    Write-Log "FATAL: Start-Process returned null for node server.js"
+  $child = Start-NodeChild -nodeExe $node -workDir $InstallDir -outFile $ServerOut -errFile $ServerErr
+  if (-not $child -or -not $child.Process) {
+    Write-Log "FATAL: failed to start node server.js"
     Start-Sleep -Seconds 5
     exit 1
   }
-  Write-Log "spawned node PID $($proc.Id)"
-  Wait-ProcessExit $proc.Id
-  Write-Log "server.js exited (PID $($proc.Id))"
+  $childPid = $child.Process.Id
+  Write-Log "spawned node PID $childPid"
+  Wait-ProcessExit $childPid
+  $exitCode = $null
+  try { $exitCode = $child.Process.ExitCode } catch {}
+  # Drain remaining async reads, then unregister handlers and close files.
+  try { $child.Process.WaitForExit() } catch {}
+  try { Unregister-Event -SourceIdentifier $child.OutEvent.Name -ErrorAction SilentlyContinue } catch {}
+  try { Unregister-Event -SourceIdentifier $child.ErrEvent.Name -ErrorAction SilentlyContinue } catch {}
+  try { $child.OutWriter.Dispose() } catch {}
+  try { $child.ErrWriter.Dispose() } catch {}
+  try { $child.OutFs.Dispose() }    catch {}
+  try { $child.ErrFs.Dispose() }    catch {}
+  try { $child.Process.Dispose() }  catch {}
+  Write-Log "server.js exited (PID $childPid, exit=$exitCode)"
   if (((Get-Date) - $windowStart).TotalSeconds -gt 60) {
     $restartCount = 0
     $windowStart  = Get-Date
   }
   $restartCount++
-  if ($restartCount -ge 5) {
+  if ($restartCount -ge 3) {
     Write-Log "Too many rapid restarts ($restartCount in <60s). Exiting; Task Scheduler will retry."
     exit 1
   }