@openparachute/vault 0.1.0 → 0.2.0

package/src/systemd.ts

@@ -6,28 +6,33 @@
  */
 
 import { homedir } from "os";
-import { join, resolve } from "path";
+import { join } from "path";
 import { writeFile, mkdir, unlink } from "fs/promises";
 import { existsSync } from "fs";
 import { $ } from "bun";
-import { CONFIG_DIR, ENV_PATH, LOG_PATH, ERR_PATH } from "./config.ts";
+import { CONFIG_DIR, LOG_PATH, ERR_PATH } from "./config.ts";
+import { WRAPPER_PATH, writeDaemonWrapper } from "./daemon.ts";
 
 const SERVICE_NAME = "parachute-vault";
 const SERVICE_DIR = join(homedir(), ".config", "systemd", "user");
 const SERVICE_PATH = join(SERVICE_DIR, `${SERVICE_NAME}.service`);
 
-function generateUnit(serverPath: string, bunPath: string): string {
+/**
+ * systemd unit invokes the shared start.sh wrapper. Env + server path
+ * resolution lives in the wrapper (see daemon.ts) — keeping systemd and
+ * launchd aligned on a single source of truth.
+ */
+export function generateUnit(): string {
   return `[Unit]
 Description=Parachute Vault
 After=network.target
 
 [Service]
 Type=simple
-WorkingDirectory=${resolve(serverPath, "..")}
-ExecStart=${bunPath} ${serverPath}
+WorkingDirectory=${CONFIG_DIR}
+ExecStart=/bin/bash ${WRAPPER_PATH}
 Restart=on-failure
 RestartSec=5
-EnvironmentFile=${ENV_PATH}
 StandardOutput=append:${LOG_PATH}
 StandardError=append:${ERR_PATH}
 
@@ -36,12 +41,11 @@ WantedBy=default.target
 `;
 }
 
-export async function installSystemdService(): Promise<void> {
-  const serverPath = resolve(import.meta.dir, "server.ts");
-  const bunPath = (await $`which bun`.text()).trim();
+export async function installSystemdService(): Promise<{ serverPath: string }> {
+  const { serverPath } = await writeDaemonWrapper();
 
   await mkdir(SERVICE_DIR, { recursive: true });
-  await writeFile(SERVICE_PATH, generateUnit(serverPath, bunPath));
+  await writeFile(SERVICE_PATH, generateUnit());
 
   // Enable lingering so user services run without login session
   try {
@@ -52,7 +56,10 @@ export async function installSystemdService(): Promise<void> {
 
   await $`systemctl --user daemon-reload`.quiet();
   await $`systemctl --user enable ${SERVICE_NAME}`.quiet();
-  await $`systemctl --user start ${SERVICE_NAME}`.quiet();
+  // Idempotent: `restart` works whether or not the service was running.
+  await $`systemctl --user restart ${SERVICE_NAME}`.quiet();
+
+  return { serverPath };
 }
 
 export async function uninstallSystemdService(): Promise<void> {

package/src/triggers.test.ts

@@ -97,13 +97,13 @@ describe("buildPredicate", () => {
   });
 });
 
-describe("registerTriggers — dispatch modes", () => {
+describe("registerTriggers — dispatch modes", async () => {
   let webhookServer: ReturnType<typeof Bun.serve>;
   let webhookPort: number;
   let lastRequest: { method: string; url: string; headers: Headers; body: unknown; formData?: FormData } | null = null;
   let webhookHandler: (req: Request) => Response | Promise<Response>;
 
-  beforeAll(() => {
+  beforeAll(async () => {
     webhookHandler = () => Response.json({});
     webhookServer = Bun.serve({
       hostname: "127.0.0.1",
@@ -224,7 +224,7 @@ describe("registerTriggers — dispatch modes", () => {
     expect((file as File).name).toBe("recording.wav");
 
     // Verify note content was updated
-    const updated = store.getNote("n2");
+    const updated = await store.getNote("n2");
     expect(updated?.content).toBe("transcribed content");
 
     // Cleanup
@@ -272,12 +272,12 @@ describe("registerTriggers — dispatch modes", () => {
     expect(body.input).toBe("Hello world");
 
     // Verify attachment was created
-    const attachments = store.getAttachments("n3");
+    const attachments = await store.getAttachments("n3");
     expect(attachments.length).toBe(1);
     expect(attachments[0].mimeType).toBe("audio/ogg");
 
     // Verify metadata includes provider info
-    const updated = store.getNote("n3");
+    const updated = await store.getNote("n3");
     const meta = updated?.metadata as Record<string, unknown>;
     expect(meta.tts_provider).toBe("kokoro");
     expect(meta.tts_voice).toBe("af_heart");
@@ -307,7 +307,7 @@ describe("registerTriggers — dispatch modes", () => {
     await hooks.dispatch("created", note, store);
     await new Promise(r => setTimeout(r, 50));
 
-    const updated = store.getNote("n4");
+    const updated = await store.getNote("n4");
     const meta = updated?.metadata as Record<string, unknown>;
     expect(meta.skip_test_skipped_reason).toBe("no audio attachment found");
   });
@@ -330,7 +330,7 @@ describe("registerTriggers — dispatch modes", () => {
     await hooks.dispatch("created", note, store);
     await new Promise(r => setTimeout(r, 50));
 
-    const updated = store.getNote("n5");
+    const updated = await store.getNote("n5");
     const meta = updated?.metadata as Record<string, unknown>;
     expect(meta.empty_test_skipped_reason).toBe("note has no content to synthesize");
   });

package/src/triggers.ts

@@ -313,7 +313,7 @@ export function registerTriggers(
 
         // Phase 1: claim
         try {
-          store.updateNote(note.id, {
+          await store.updateNote(note.id, {
             metadata: { ...existingMeta, [pendingKey]: pendingAt },
             skipUpdatedAt: true,
           });
@@ -324,7 +324,7 @@ export function registerTriggers(
 
         // Fire the webhook using the configured send mode
         let webhookResult: WebhookResponse;
-        const attachments = store.getAttachments(note.id);
+        const attachments = await store.getAttachments(note.id);
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeout);
         try {
@@ -358,7 +358,7 @@ export function registerTriggers(
         // trigger an infinite webhook loop on every update.
         if (webhookResult.skipped_reason) {
           try {
-            store.updateNote(note.id, {
+            await store.updateNote(note.id, {
               metadata: {
                 ...existingMeta,
                 [pendingKey]: undefined,
@@ -378,16 +378,16 @@ export function registerTriggers(
           // Add attachments first
           if (webhookResult.attachments?.length) {
             for (const att of webhookResult.attachments) {
-              store.addAttachment(note.id, att.path, att.mimeType, att.meta);
+              await store.addAttachment(note.id, att.path, att.mimeType, att.meta);
             }
           }
 
           // Read fresh metadata to avoid clobbering concurrent edits
-          const fresh = store.getNote(note.id);
+          const fresh = await store.getNote(note.id);
           const freshMeta = (fresh?.metadata as Record<string, unknown> | undefined) ?? existingMeta;
           const { [pendingKey]: _drop, ...restMeta } = freshMeta;
 
-          store.updateNote(note.id, {
+          await store.updateNote(note.id, {
             ...(webhookResult.content !== undefined ? { content: webhookResult.content } : {}),
             metadata: {
               ...restMeta,

package/src/vault-store.ts

@@ -38,10 +38,27 @@ export function getVaultNameForStore(store: SqliteStore): string | undefined {
   return storeToVault.get(store);
 }
 
-/** Close all open stores. */
-export function closeAllStores(): void {
+/**
+ * Close all open stores. When `silent` is true, swallow errors from
+ * `db.close()` — used by test cleanup where the underlying DB files may
+ * already be gone.
+ */
+export function closeAllStores(silent = false): void {
   for (const [, store] of stores) {
-    store.db.close();
+    if (silent) {
+      try { store.db.close(); } catch {}
+    } else {
+      store.db.close();
+    }
   }
   stores.clear();
 }
+
+/**
+ * Test-only: close and clear all cached stores. Used between tests that
+ * swap `PARACHUTE_HOME` out from under the cache, which would otherwise
+ * hold handles to DBs whose files no longer exist.
+ */
+export function clearVaultStoreCache(): void {
+  closeAllStores(true);
+}