@openparachute/vault 0.2.4 → 0.3.0

package/src/triggers.test.ts

@@ -129,7 +129,11 @@ describe("registerTriggers — dispatch modes", async () => {
     webhookServer?.stop(true);
   });
 
-  function makeMockStore(note: Note, attachments: Attachment[] = []): Store {
+  function makeMockStore(
+    note: Note,
+    attachments: Attachment[] = [],
+    contextNotesByTag: Record<string, Note[]> = {},
+  ): Store {
     const notes = new Map<string, Note>();
     notes.set(note.id, { ...note });
     const attachmentStore = new Map<string, Attachment[]>();
@@ -153,6 +157,14 @@ describe("registerTriggers — dispatch modes", async () => {
         attachmentStore.set(noteId, existing);
         return att;
       },
+      queryNotes: async ({ tags, excludeTags }: { tags?: string[]; excludeTags?: string[] }) => {
+        const tag = tags?.[0];
+        if (!tag) return [];
+        const pool = contextNotesByTag[tag] ?? [];
+        if (!excludeTags?.length) return pool;
+        const excluded = new Set(excludeTags);
+        return pool.filter((n) => !(n.tags ?? []).some((t) => excluded.has(t)));
+      },
     } as unknown as Store;
   }
 
@@ -334,6 +346,184 @@ describe("registerTriggers — dispatch modes", async () => {
     const meta = updated?.metadata as Record<string, unknown>;
     expect(meta.empty_test_skipped_reason).toBe("note has no content to synthesize");
   });
+
+  it("send=attachment with include_context attaches context JSON part", async () => {
+    const hooks = new HookRegistry();
+    const note = makeNote({ id: "ctx1", content: "", tags: ["capture"] });
+
+    const tmpDir = `/tmp/trigger-ctx-att-${Date.now()}`;
+    const { mkdirSync, writeFileSync, rmSync } = await import("fs");
+    mkdirSync(`${tmpDir}/2026-04-11`, { recursive: true });
+    writeFileSync(`${tmpDir}/2026-04-11/recording.wav`, Buffer.from("fake-wav"));
+
+    const attachment: Attachment = {
+      id: "att-c1",
+      noteId: "ctx1",
+      path: "2026-04-11/recording.wav",
+      mimeType: "audio/wav",
+      createdAt: "2025-01-01T00:00:00Z",
+    };
+
+    const person = makeNote({
+      id: "p1",
+      path: "People/Aaron.md",
+      tags: ["person"],
+      metadata: { summary: "founder", aliases: ["AG"], secret: "nope" },
+    });
+    const project = makeNote({
+      id: "pj1",
+      path: "Projects/Lens.md",
+      tags: ["project"],
+      metadata: { summary: "note app" },
+    });
+    const store = makeMockStore(note, [attachment], { person: [person], project: [project] });
+
+    const originalAssetsDir = process.env.ASSETS_DIR;
+    process.env.ASSETS_DIR = tmpDir;
+
+    webhookHandler = () => Response.json({ text: "transcribed" });
+
+    registerTriggers(hooks, [{
+      name: "ctx_attachment_test",
+      when: { tags: ["capture"], has_content: false },
+      action: {
+        webhook: `http://127.0.0.1:${webhookPort}/transcribe`,
+        send: "attachment",
+        include_context: [
+          { tag: "person", include_metadata: ["summary", "aliases"] },
+          { tag: "project", include_metadata: ["summary"] },
+        ],
+      },
+    }], { error: () => {}, info: () => {} });
+
+    await hooks.dispatch("created", note, store);
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(lastRequest?.formData).toBeDefined();
+    const part = lastRequest!.formData!.get("context");
+    expect(part).toBeInstanceOf(Blob);
+    const body = JSON.parse(await (part as Blob).text());
+    expect(body.entries.length).toBe(2);
+    expect(body.entries[0]).toEqual({ name: "Aaron", summary: "founder", aliases: ["AG"] });
+    expect(body.entries[1]).toEqual({ name: "Lens", summary: "note app" });
+    // Non-whitelisted metadata must not leak.
+    expect(body.entries[0].secret).toBeUndefined();
+
+    if (originalAssetsDir) process.env.ASSETS_DIR = originalAssetsDir;
+    else delete process.env.ASSETS_DIR;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("send=attachment without include_context omits context part (no regression)", async () => {
+    const hooks = new HookRegistry();
+    const note = makeNote({ id: "nx", content: "", tags: ["capture"] });
+
+    const tmpDir = `/tmp/trigger-ctx-none-${Date.now()}`;
+    const { mkdirSync, writeFileSync, rmSync } = await import("fs");
+    mkdirSync(`${tmpDir}/2026-04-11`, { recursive: true });
+    writeFileSync(`${tmpDir}/2026-04-11/recording.wav`, Buffer.from("fake-wav"));
+    const attachment: Attachment = {
+      id: "att-x",
+      noteId: "nx",
+      path: "2026-04-11/recording.wav",
+      mimeType: "audio/wav",
+      createdAt: "2025-01-01T00:00:00Z",
+    };
+    const store = makeMockStore(note, [attachment]);
+    const originalAssetsDir = process.env.ASSETS_DIR;
+    process.env.ASSETS_DIR = tmpDir;
+
+    webhookHandler = () => Response.json({ text: "ok" });
+
+    registerTriggers(hooks, [{
+      name: "no_ctx",
+      when: { tags: ["capture"], has_content: false },
+      action: { webhook: `http://127.0.0.1:${webhookPort}/transcribe`, send: "attachment" },
+    }], { error: () => {}, info: () => {} });
+
+    await hooks.dispatch("created", note, store);
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(lastRequest?.formData).toBeDefined();
+    expect(lastRequest!.formData!.get("context")).toBeNull();
+
+    if (originalAssetsDir) process.env.ASSETS_DIR = originalAssetsDir;
+    else delete process.env.ASSETS_DIR;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("send=json with include_context inlines context field", async () => {
+    const hooks = new HookRegistry();
+    const note = makeNote({ id: "j1", content: "hello", tags: ["test"] });
+    const person = makeNote({
+      id: "p1",
+      path: "People/Aaron.md",
+      tags: ["person"],
+      metadata: { summary: "founder" },
+    });
+    const store = makeMockStore(note, [], { person: [person] });
+
+    webhookHandler = () => Response.json({});
+
+    registerTriggers(hooks, [{
+      name: "json_ctx",
+      when: { tags: ["test"] },
+      action: {
+        webhook: `http://127.0.0.1:${webhookPort}/hook`,
+        include_context: [{ tag: "person", include_metadata: ["summary"] }],
+      },
+    }], { error: () => {}, info: () => {} });
+
+    await hooks.dispatch("created", note, store);
+    await new Promise((r) => setTimeout(r, 50));
+
+    const body = lastRequest!.body as Record<string, unknown>;
+    expect(body.context).toBeDefined();
+    const ctx = body.context as { entries: Array<Record<string, unknown>> };
+    expect(ctx.entries).toEqual([{ name: "Aaron", summary: "founder" }]);
+  });
+
+  it("send=content ignores include_context (TTS-out has no use for it)", async () => {
+    const hooks = new HookRegistry();
+    const note = makeNote({ id: "c1", content: "speak", tags: ["reader"] });
+    const person = makeNote({
+      id: "p1",
+      path: "People/Aaron.md",
+      tags: ["person"],
+      metadata: { summary: "founder" },
+    });
+    const store = makeMockStore(note, [], { person: [person] });
+
+    const tmpDir = `/tmp/trigger-ctx-content-${Date.now()}`;
+    const { mkdirSync, rmSync } = await import("fs");
+    mkdirSync(tmpDir, { recursive: true });
+    const originalAssetsDir = process.env.ASSETS_DIR;
+    process.env.ASSETS_DIR = tmpDir;
+
+    webhookHandler = () =>
+      new Response(Buffer.from("audio"), { headers: { "Content-Type": "audio/ogg" } });
+
+    registerTriggers(hooks, [{
+      name: "content_ctx",
+      when: { tags: ["reader"], has_content: true },
+      action: {
+        webhook: `http://127.0.0.1:${webhookPort}/speech`,
+        send: "content",
+        include_context: [{ tag: "person", include_metadata: ["summary"] }],
+      },
+    }], { error: () => {}, info: () => {} });
+
+    await hooks.dispatch("created", note, store);
+    await new Promise((r) => setTimeout(r, 50));
+
+    const body = lastRequest!.body as Record<string, unknown>;
+    expect(body.context).toBeUndefined();
+    expect(body.input).toBe("speak");
+
+    if (originalAssetsDir) process.env.ASSETS_DIR = originalAssetsDir;
+    else delete process.env.ASSETS_DIR;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
 });
 
 describe("registerTriggers — validation", () => {

package/src/triggers.ts

@@ -33,6 +33,7 @@ import type { HookRegistry, HookEvent } from "../core/src/hooks.ts";
 import type { TriggerConfig, TriggerWhen } from "./config.ts";
 import { getVaultNameForStore } from "./vault-store.ts";
 import { assetsDir } from "./routes.ts";
+import { appendContextPart, fetchContextEntries, type ContextPayload } from "./context.ts";
 
 const DEFAULT_TIMEOUT = 60_000;
 
@@ -157,6 +158,7 @@ async function dispatchJson(
   attachments: Attachment[],
   existingMeta: Record<string, unknown>,
   hookEvent: HookEvent | undefined,
+  context: ContextPayload | null,
   signal: AbortSignal,
 ): Promise<DispatchResult> {
   const resp = await fetch(url, {
@@ -175,6 +177,10 @@ async function dispatchJson(
         createdAt: note.createdAt,
         updatedAt: note.updatedAt,
       },
+      // Inline when include_context is configured and matched anything; the
+      // receiver can key off a top-level `context` field without having to
+      // parse multipart.
+      ...(context && context.entries.length ? { context } : {}),
     }),
     signal,
   });
@@ -196,6 +202,7 @@ async function dispatchAttachment(
   note: Note,
   attachments: Attachment[],
   store: Store,
+  context: ContextPayload | null,
   signal: AbortSignal,
 ): Promise<DispatchResult> {
   const assetsRoot = resolveAssetsDir(store);
@@ -210,6 +217,7 @@ async function dispatchAttachment(
 
   const form = new FormData();
   form.append("file", file);
+  if (context) appendContextPart(form, context);
 
   const resp = await fetch(url, { method: "POST", body: form, signal });
   if (!resp.ok) {
@@ -325,20 +333,27 @@ export function registerTriggers(
         // Fire the webhook using the configured send mode
         let webhookResult: WebhookResponse;
         const attachments = await store.getAttachments(note.id);
+        // Pre-fetch context once per fire. Predicate errors are logged and
+        // the fire continues — context is additive, never blocking.
+        const context = trigger.action.include_context?.length
+          ? await fetchContextEntries(store, trigger.action.include_context, logger)
+          : null;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeout);
         try {
           let result: DispatchResult;
           switch (sendMode) {
             case "attachment":
-              result = await dispatchAttachment(trigger.action.webhook, note, attachments, store, controller.signal);
+              result = await dispatchAttachment(trigger.action.webhook, note, attachments, store, context, controller.signal);
               break;
             case "content":
+              // send=content is pure TTS (audio out); vault context makes no
+              // sense here and would confuse the server contract.
               result = await dispatchContent(trigger.action.webhook, note, store, controller.signal);
               break;
             case "json":
             default:
-              result = await dispatchJson(trigger.action.webhook, trigger, note, attachments, existingMeta, hookEvent, controller.signal);
+              result = await dispatchJson(trigger.action.webhook, trigger, note, attachments, existingMeta, hookEvent, context, controller.signal);
               break;
           }
           webhookResult = result.webhookResult;