@openparachute/vault 0.1.0

package/src/config-triggers.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, afterEach } from "bun:test";
+import { writeFileSync, mkdirSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// We test the parsing by writing a config file and reading it back
+// using the real readGlobalConfig/writeGlobalConfig functions.
+// To avoid touching the real config, we override PARACHUTE_HOME.
+
+const testDir = join(tmpdir(), `vault-trigger-test-${Date.now()}`);
+
+// Must set env before importing config module
+process.env.PARACHUTE_HOME = testDir;
+
+// Dynamic import after env is set
+const { readGlobalConfig, writeGlobalConfig } = await import("./config.ts");
+
+afterEach(() => {
+  if (existsSync(testDir)) {
+    rmSync(testDir, { recursive: true, force: true });
+  }
+});
+
+describe("trigger config round-trip", () => {
+  it("writes and reads triggers", () => {
+    mkdirSync(testDir, { recursive: true });
+    writeGlobalConfig({
+      port: 1940,
+      triggers: [
+        {
+          name: "tts-reader",
+          events: ["created", "updated"],
+          when: {
+            tags: ["reader"],
+            has_content: true,
+            missing_metadata: ["audio_rendered_at", "audio_pending_at"],
+          },
+          action: {
+            webhook: "http://localhost:8080/tts",
+            timeout: 30000,
+          },
+        },
+        {
+          name: "transcribe-capture",
+          when: {
+            tags: ["capture"],
+            has_content: false,
+          },
+          action: {
+            webhook: "http://localhost:8080/transcribe",
+          },
+        },
+      ],
+    });
+
+    const config = readGlobalConfig();
+    expect(config.triggers).toBeDefined();
+    expect(config.triggers!.length).toBe(2);
+
+    const tts = config.triggers![0];
+    expect(tts.name).toBe("tts-reader");
+    expect(tts.events).toEqual(["created", "updated"]);
+    expect(tts.when.tags).toEqual(["reader"]);
+    expect(tts.when.has_content).toBe(true);
+    expect(tts.when.missing_metadata).toEqual(["audio_rendered_at", "audio_pending_at"]);
+    expect(tts.action.webhook).toBe("http://localhost:8080/tts");
+    expect(tts.action.timeout).toBe(30000);
+
+    const transcribe = config.triggers![1];
+    expect(transcribe.name).toBe("transcribe-capture");
+    expect(transcribe.when.tags).toEqual(["capture"]);
+    expect(transcribe.when.has_content).toBe(false);
+    expect(transcribe.action.webhook).toBe("http://localhost:8080/transcribe");
+    expect(transcribe.action.timeout).toBeUndefined();
+  });
+
+  it("handles config with no triggers", () => {
+    mkdirSync(testDir, { recursive: true });
+    writeGlobalConfig({ port: 1940 });
+    const config = readGlobalConfig();
+    expect(config.triggers).toBeUndefined();
+  });
+});

package/src/config.test.ts

@@ -0,0 +1,125 @@
+import { describe, test, expect } from "bun:test";
+import {
+  writeVaultConfig,
+  readVaultConfig,
+  generateApiKey,
+  hashKey,
+  verifyKey,
+} from "./config.ts";
+import type { VaultConfig } from "./config.ts";
+
+describe("config", () => {
+  test("generates and verifies API keys", () => {
+    const { fullKey, keyId } = generateApiKey();
+    expect(fullKey).toMatch(/^pvk_/);
+    expect(keyId).toMatch(/^k_/);
+
+    const hash = hashKey(fullKey);
+    expect(hash).toMatch(/^sha256:/);
+    expect(verifyKey(fullKey, hash)).toBe(true);
+    expect(verifyKey("wrong_key_here_1234567890123456", hash)).toBe(false);
+  });
+
+  test("round-trips vault config", () => {
+    const config: VaultConfig = {
+      name: "testvault",
+      description: "A test vault for testing",
+      api_keys: [
+        {
+          id: "k_abc123",
+          label: "default",
+          scope: "write",
+          key_hash: "sha256:fakehash",
+          created_at: "2026-01-01T00:00:00.000Z",
+        },
+      ],
+      created_at: "2026-01-01T00:00:00.000Z",
+    };
+
+    writeVaultConfig(config);
+
+    const loaded = readVaultConfig("testvault");
+    expect(loaded).not.toBeNull();
+    expect(loaded!.name).toBe("testvault");
+    expect(loaded!.description).toBe("A test vault for testing");
+    expect(loaded!.api_keys.length).toBe(1);
+    expect(loaded!.api_keys[0].id).toBe("k_abc123");
+  });
+
+  test("round-trips tag_schemas in vault config", () => {
+    const config: VaultConfig = {
+      name: "testvault",
+      api_keys: [
+        {
+          id: "k_abc123",
+          label: "default",
+          scope: "write",
+          key_hash: "sha256:fakehash",
+          created_at: "2026-01-01T00:00:00.000Z",
+        },
+      ],
+      created_at: "2026-01-01T00:00:00.000Z",
+      tag_schemas: {
+        person: {
+          description: "A person in Aaron's life",
+          fields: {
+            first_appeared: {
+              type: "string",
+              description: "When this person first appeared",
+            },
+            relationship: {
+              type: "string",
+              description: "How they relate to Aaron",
+            },
+          },
+        },
+        project: {
+          description: "A project",
+          fields: {
+            status: {
+              type: "string",
+              enum: ["active", "completed", "abandoned"],
+              description: "Current project status",
+            },
+          },
+        },
+        "summary/monthly": {
+          description: "Monthly summary note",
+        },
+      },
+    };
+
+    writeVaultConfig(config);
+
+    const loaded = readVaultConfig("testvault");
+    expect(loaded).not.toBeNull();
+    expect(loaded!.tag_schemas).toBeDefined();
+
+    const person = loaded!.tag_schemas!.person;
+    expect(person.description).toBe("A person in Aaron's life");
+    expect(person.fields!.first_appeared.type).toBe("string");
+    expect(person.fields!.first_appeared.description).toBe("When this person first appeared");
+    expect(person.fields!.relationship.type).toBe("string");
+
+    const project = loaded!.tag_schemas!.project;
+    expect(project.fields!.status.enum).toEqual(["active", "completed", "abandoned"]);
+
+    const monthly = loaded!.tag_schemas!["summary/monthly"];
+    expect(monthly.description).toBe("Monthly summary note");
+    expect(monthly.fields).toBeUndefined();
+  });
+
+  test("vault config without tag_schemas loads cleanly", () => {
+    const config: VaultConfig = {
+      name: "testvault",
+      api_keys: [],
+      created_at: "2026-01-01T00:00:00.000Z",
+    };
+
+    writeVaultConfig(config);
+
+    const loaded = readVaultConfig("testvault");
+    expect(loaded).not.toBeNull();
+    expect(loaded!.tag_schemas).toBeUndefined();
+  });
+});