@hexis-ai/engram-server 0.12.0 → 0.14.0

package/dist/adapters/memory-key-store.d.ts

@@ -6,13 +6,26 @@ export declare class InMemoryKeyStore implements KeyStore {
     private readonly workspaces;
     private readonly keys;
     private readonly byHash;
+    /** Mirror of engram_workspaces.org_id. Lookup-only — fakes / org-stores
+     *  in tests read this to answer membership queries without re-tracking
+     *  the binding themselves. */
+    private readonly orgIds;
     createWorkspace(input: {
         id?: string;
         name?: string;
         metadata?: Record<string, unknown>;
+        orgId?: string;
     }): Promise<Workspace>;
+    /** Org id stamped on a workspace at creation, or undefined if not org-scoped. */
+    getWorkspaceOrgId(workspaceId: string): string | undefined;
+    /** All (workspaceId, orgId) pairs. Read-only view for fakes. */
+    workspaceOrgBindings(): ReadonlyMap<string, string>;
     getWorkspace(id: string): Promise<Workspace | null>;
     listWorkspaces(): Promise<Workspace[]>;
+    updateWorkspace(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Workspace>;
     deleteWorkspace(id: string): Promise<void>;
     issueKey(workspaceId: string, opts?: {
         name?: string;

package/dist/adapters/memory-key-store.js

@@ -6,6 +6,10 @@ export class InMemoryKeyStore {
     workspaces = new Map();
     keys = new Map();
     byHash = new Map();
+    /** Mirror of engram_workspaces.org_id. Lookup-only — fakes / org-stores
+     *  in tests read this to answer membership queries without re-tracking
+     *  the binding themselves. */
+    orgIds = new Map();
     async createWorkspace(input) {
         const id = resolveWorkspaceId(input);
         const existing = this.workspaces.get(id);
@@ -18,16 +22,39 @@ export class InMemoryKeyStore {
             createdAt: new Date().toISOString(),
         };
         this.workspaces.set(id, ws);
+        if (input.orgId !== undefined)
+            this.orgIds.set(id, input.orgId);
         return ws;
     }
+    /** Org id stamped on a workspace at creation, or undefined if not org-scoped. */
+    getWorkspaceOrgId(workspaceId) {
+        return this.orgIds.get(workspaceId);
+    }
+    /** All (workspaceId, orgId) pairs. Read-only view for fakes. */
+    workspaceOrgBindings() {
+        return this.orgIds;
+    }
     async getWorkspace(id) {
         return this.workspaces.get(id) ?? null;
     }
     async listWorkspaces() {
         return [...this.workspaces.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
     }
+    async updateWorkspace(id, patch) {
+        const existing = this.workspaces.get(id);
+        if (!existing)
+            throw new Error("workspace_not_found");
+        const next = {
+            ...existing,
+            ...(patch.name !== undefined ? { name: patch.name } : {}),
+            ...(patch.metadata !== undefined ? { metadata: patch.metadata } : {}),
+        };
+        this.workspaces.set(id, next);
+        return next;
+    }
     async deleteWorkspace(id) {
         this.workspaces.delete(id);
+        this.orgIds.delete(id);
         for (const [keyId, row] of this.keys) {
             if (row.workspaceId === id) {
                 this.byHash.delete(row.keyHash);

package/dist/adapters/memory.js

@@ -1,11 +1,5 @@
-import { foldEvents } from "../storage";
-function defaultPersonId() {
-    const ALPHA = "abcdefghijklmnopqrstuvwxyz0123456789";
-    let out = "p_";
-    for (let i = 0; i < 8; i++)
-        out += ALPHA[Math.floor(Math.random() * ALPHA.length)];
-    return out;
-}
+import { foldEvents, newPersonId } from "../storage";
+import { applyPartial } from "./util";
 /**
  * In-process storage adapter for tests, dev, and small single-node deploys.
  * Idempotency: events keyed by (sessionId, seq) — duplicates overwrite by seq.
@@ -19,7 +13,7 @@ export class InMemoryAdapter {
     identities = new Map();
     newPersonId;
     constructor(opts = {}) {
-        this.newPersonId = opts.newPersonId ?? defaultPersonId;
+        this.newPersonId = opts.newPersonId ?? newPersonId;
     }
     // --- Sessions -----------------------------------------------------
     async createSession(init) {
@@ -48,6 +42,12 @@ export class InMemoryAdapter {
                 ...(init.trigger_event_id != null
                     ? { trigger_event_id: init.trigger_event_id }
                     : {}),
+                ...(init.trigger_purpose != null
+                    ? { trigger_purpose: init.trigger_purpose }
+                    : {}),
+                ...(init.trigger_resume_hint != null
+                    ? { trigger_resume_hint: init.trigger_resume_hint }
+                    : {}),
             },
             events: new Map(),
         });
@@ -88,49 +88,12 @@ export class InMemoryAdapter {
         const s = this.sessions.get(sessionId);
         if (!s)
             return null;
-        // Patch semantics: undefined = leave alone; null = clear; value = set.
-        // SessionRow optional fields use `string | undefined`, so a "null"
-        // request collapses to `undefined` storage-side.
-        const next = { ...s.row };
-        if (patch.title !== undefined) {
-            if (patch.title === null)
-                delete next.title;
-            else
-                next.title = patch.title;
-        }
-        if (patch.channel !== undefined) {
-            if (patch.channel === null)
-                delete next.channel;
-            else
-                next.channel = patch.channel;
-        }
-        if (patch.status !== undefined) {
-            next.status = patch.status;
-        }
-        if (patch.summary !== undefined) {
-            if (patch.summary === null)
-                delete next.summary;
-            else
-                next.summary = patch.summary;
-        }
-        if (patch.model !== undefined) {
-            if (patch.model === null)
-                delete next.model;
-            else
-                next.model = patch.model;
-        }
-        if (patch.trigger_conversation_id !== undefined) {
-            if (patch.trigger_conversation_id === null)
-                delete next.trigger_conversation_id;
-            else
-                next.trigger_conversation_id = patch.trigger_conversation_id;
-        }
-        if (patch.trigger_event_id !== undefined) {
-            if (patch.trigger_event_id === null)
-                delete next.trigger_event_id;
-            else
-                next.trigger_event_id = patch.trigger_event_id;
-        }
+        // Patch semantics: undefined = leave alone; null = clear (deletes the
+        // key, matching the SessionRow shape where optional fields are absent);
+        // value = set. `status` clears to "active" to match the column default.
+        const next = applyPartial(s.row, patch, {
+            status: "active",
+        });
         next.updatedAt = new Date().toISOString();
         s.row = next;
         return foldEvents(s.row, [...s.events.values()], new Date());
@@ -213,16 +176,15 @@ export class InMemoryAdapter {
         const existing = this.persons.get(id);
         if (!existing)
             return null;
-        const now = new Date().toISOString();
-        // undefined = no-op, null = clear (per the SDK contract).
-        const next = {
-            ...existing,
-            display_name: patch.display_name !== undefined ? patch.display_name : existing.display_name,
-            role: patch.role !== undefined ? patch.role : existing.role ?? null,
-            team: patch.team !== undefined ? patch.team : existing.team ?? null,
-            source: patch.source !== undefined ? patch.source : existing.source ?? "auto",
-            updated_at: now,
-        };
+        // undefined = no-op; null = clear (display_name/role/team to null,
+        // source to "auto" to match the column default).
+        const next = applyPartial(existing, patch, {
+            display_name: null,
+            role: null,
+            team: null,
+            source: "auto",
+        });
+        next.updated_at = new Date().toISOString();
         this.persons.set(id, next);
         return next;
     }
@@ -269,8 +231,18 @@ export class InMemoryAdapter {
     }
     // --- Aliases ------------------------------------------------------
     async upsertAlias(personId, input) {
-        if (!this.persons.has(personId))
-            return null;
+        if (!this.persons.has(personId)) {
+            const stubNow = new Date().toISOString();
+            this.persons.set(personId, {
+                id: personId,
+                display_name: null,
+                role: null,
+                team: null,
+                source: undefined,
+                created_at: stubNow,
+                updated_at: stubNow,
+            });
+        }
         const key = aliasKey(personId, input.name);
         const now = new Date().toISOString();
         const existing = this.aliases.get(key);
@@ -304,8 +276,23 @@ export class InMemoryAdapter {
     }
     // --- Identities ---------------------------------------------------
     async upsertIdentity(ref, input) {
-        if (!this.persons.has(input.person_id))
-            return null;
+        // Auto-create a stub person when missing. The two telemetry
+        // calls (person + identity) race over the network; treating
+        // the identity PUT as authoritative for "this person id exists"
+        // matches the host-supplied-id upsert model and avoids a 404
+        // when the calls arrive out of order.
+        if (!this.persons.has(input.person_id)) {
+            const stubNow = new Date().toISOString();
+            this.persons.set(input.person_id, {
+                id: input.person_id,
+                display_name: null,
+                role: null,
+                team: null,
+                source: undefined,
+                created_at: stubNow,
+                updated_at: stubNow,
+            });
+        }
         const now = new Date().toISOString();
         const existing = this.identities.get(ref);
         // COALESCE-on-conflict for the soft-overlap fields; ref-level

package/dist/adapters/pg-tagged.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tagged-template SQL client backed by node-postgres (`pg`).
+ *
+ * The rest of the codebase was written against the `postgres` package's
+ * tagged-template surface (`SqlClient` in ./postgres.ts). This adapter
+ * exposes the same shape on top of a `pg.Pool` (or `pg.PoolClient`) so
+ * we can unify on a single SQL driver — better-auth requires `pg`, and
+ * keeping two pools around just to satisfy `postgres-js`'s template API
+ * was preventing cross-store transactions.
+ *
+ * Translation rule: each `${value}` becomes `$N` in the emitted SQL,
+ * and the values land in the parameter array in tag order. Arrays
+ * map directly to Postgres arrays via `pg`'s native handling (callers
+ * already include explicit `::text[]` casts where needed).
+ */
+import type { Pool, PoolClient } from "pg";
+import type { SqlClient } from "./postgres";
+export declare function pgSqlClient(executor: Pool | PoolClient): SqlClient;

package/dist/adapters/pg-tagged.js

@@ -0,0 +1,29 @@
+/**
+ * Tagged-template SQL client backed by node-postgres (`pg`).
+ *
+ * The rest of the codebase was written against the `postgres` package's
+ * tagged-template surface (`SqlClient` in ./postgres.ts). This adapter
+ * exposes the same shape on top of a `pg.Pool` (or `pg.PoolClient`) so
+ * we can unify on a single SQL driver — better-auth requires `pg`, and
+ * keeping two pools around just to satisfy `postgres-js`'s template API
+ * was preventing cross-store transactions.
+ *
+ * Translation rule: each `${value}` becomes `$N` in the emitted SQL,
+ * and the values land in the parameter array in tag order. Arrays
+ * map directly to Postgres arrays via `pg`'s native handling (callers
+ * already include explicit `::text[]` casts where needed).
+ */
+export function pgSqlClient(executor) {
+    const tagged = (async (strings, ...values) => {
+        let text = strings[0];
+        for (let i = 0; i < values.length; i++) {
+            text += `$${i + 1}` + strings[i + 1];
+        }
+        const r = await executor.query({ text, values });
+        return r.rows;
+    });
+    tagged.unsafe = async (text) => {
+        await executor.query(text);
+    };
+    return tagged;
+}

package/dist/adapters/postgres-key-store.d.ts

@@ -12,9 +12,14 @@ export declare class PostgresKeyStore implements KeyStore {
         id?: string;
         name?: string;
         metadata?: Record<string, unknown>;
+        orgId?: string;
     }): Promise<Workspace>;
     getWorkspace(id: string): Promise<Workspace | null>;
     listWorkspaces(): Promise<Workspace[]>;
+    updateWorkspace(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Workspace>;
     deleteWorkspace(id: string): Promise<void>;
     issueKey(workspaceId: string, opts?: {
         name?: string;

package/dist/adapters/postgres-key-store.js

@@ -1,5 +1,6 @@
 import { deriveKey, hashKey, mintKey, resolveWorkspaceId, } from "../key-store";
 import { runMigrations } from "../migrator";
+import { isoString } from "./util";
 export class PostgresKeyStore {
     sql;
     constructor(sql) {
@@ -15,8 +16,13 @@ export class PostgresKeyStore {
     async createWorkspace(input) {
         const id = resolveWorkspaceId(input);
         await this.sql `
-      INSERT INTO engram_workspaces (id, name, metadata)
-      VALUES (${id}, ${input.name ?? null}, ${(input.metadata ?? {})})
+      INSERT INTO engram_workspaces (id, name, metadata, org_id)
+      VALUES (
+        ${id},
+        ${input.name ?? null},
+        ${(input.metadata ?? {})},
+        ${input.orgId ?? null}
+      )
       ON CONFLICT (id) DO NOTHING
     `;
         const ws = await this.getWorkspace(id);
@@ -36,6 +42,19 @@ export class PostgresKeyStore {
     `;
         return rows.map(toWorkspace);
     }
+    async updateWorkspace(id, patch) {
+        const rows = await this.sql `
+      UPDATE engram_workspaces
+      SET
+        name = COALESCE(${patch.name ?? null}, name),
+        metadata = COALESCE(${patch.metadata ? patch.metadata : null}, metadata)
+      WHERE id = ${id}
+      RETURNING id, name, metadata, created_at
+    `;
+        if (rows.length === 0)
+            throw new Error("workspace_not_found");
+        return toWorkspace(rows[0]);
+    }
     async deleteWorkspace(id) {
         // engram_api_keys cascades via FK. engram_sessions/events are explicit
         // since they predate the workspaces table and have no FK to it.
@@ -132,6 +151,3 @@ function toInfo(r) {
         ...(r.revoked_at !== null ? { revokedAt: isoString(r.revoked_at) } : {}),
     };
 }
-function isoString(v) {
-    return typeof v === "string" ? v : v.toISOString();
-}

package/dist/adapters/postgres-org-store.d.ts

@@ -10,6 +10,10 @@ export declare class PostgresOrgStore implements OrgStore {
     }): Promise<OrgRow>;
     getOrg(id: string): Promise<OrgRow | null>;
     listOrgs(): Promise<OrgRow[]>;
+    updateOrg(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<OrgRow>;
     deleteOrg(id: string): Promise<void>;
     listMembers(orgId: string): Promise<OrgMembershipRow[]>;
     upsertMember(input: {
@@ -23,7 +27,6 @@ export declare class PostgresOrgStore implements OrgStore {
         email: string;
     } | null>;
     listOrgsForUser(userId: string): Promise<OrgMembershipRow[]>;
-    setWorkspaceOrg(workspaceId: string, orgId: string): Promise<void>;
     listWorkspacesForOrg(orgId: string): Promise<{
         id: string;
         name: string | null;
@@ -34,4 +37,5 @@ export declare class PostgresOrgStore implements OrgStore {
         orgId: string;
     }[]>;
     userCanAccessWorkspace(userId: string, workspaceId: string): Promise<boolean>;
+    workspaceInOrg(orgId: string, workspaceId: string): Promise<boolean>;
 }

package/dist/adapters/postgres-org-store.js

@@ -1,13 +1,11 @@
 import { randomUUID } from "node:crypto";
-function iso(v) {
-    return typeof v === "string" ? v : v.toISOString();
-}
+import { isoString } from "./util";
 function toOrg(r) {
     return {
         id: r.id,
         name: r.name,
         metadata: r.metadata ?? {},
-        createdAt: iso(r.created_at),
+        createdAt: isoString(r.created_at),
     };
 }
 function toMember(r) {
@@ -15,7 +13,7 @@ function toMember(r) {
         orgId: r.org_id,
         userId: r.user_id,
         role: r.role,
-        joinedAt: iso(r.joined_at),
+        joinedAt: isoString(r.joined_at),
     };
 }
 export class PostgresOrgStore {
@@ -45,6 +43,21 @@ export class PostgresOrgStore {
         const { rows } = await this.pool.query(`SELECT id, name, metadata, created_at FROM engram_orgs ORDER BY created_at`);
         return rows.map(toOrg);
     }
+    async updateOrg(id, patch) {
+        const { rows } = await this.pool.query(`UPDATE engram_orgs
+       SET
+         name = COALESCE($2, name),
+         metadata = COALESCE($3::jsonb, metadata)
+       WHERE id = $1
+       RETURNING id, name, metadata, created_at`, [
+            id,
+            patch.name ?? null,
+            patch.metadata ? JSON.stringify(patch.metadata) : null,
+        ]);
+        if (rows.length === 0)
+            throw new Error("org_not_found");
+        return toOrg(rows[0]);
+    }
     async deleteOrg(id) {
         // CASCADE drops members + workspaces under this org.
         await this.pool.query(`DELETE FROM engram_orgs WHERE id = $1`, [id]);
@@ -76,9 +89,8 @@ export class PostgresOrgStore {
         return rows.map(toMember);
     }
     // ---------- workspace ↔ org link -----------------------------
-    async setWorkspaceOrg(workspaceId, orgId) {
-        await this.pool.query(`UPDATE engram_workspaces SET org_id = $1 WHERE id = $2`, [orgId, workspaceId]);
-    }
+    // engram_workspaces.org_id is written by KeyStore.createWorkspace in
+    // the same INSERT as the workspace row. This store only reads.
     async listWorkspacesForOrg(orgId) {
         const { rows } = await this.pool.query(`SELECT id, name FROM engram_workspaces WHERE org_id = $1 ORDER BY created_at`, [orgId]);
         return rows;
@@ -99,4 +111,9 @@ export class PostgresOrgStore {
        LIMIT 1`, [userId, workspaceId]);
         return rows.length > 0;
     }
+    async workspaceInOrg(orgId, workspaceId) {
+        const { rows } = await this.pool.query(`SELECT 1 AS ok FROM engram_workspaces
+       WHERE id = $1 AND org_id = $2 LIMIT 1`, [workspaceId, orgId]);
+        return rows.length > 0;
+    }
 }