mcpscraper-memory-db 1.0.0

package/dist/db/usage.js

@@ -0,0 +1,106 @@
+import { ensureSchema, query } from "./pool";
+import { storageCostUsdForDay } from "../lib/cost-rates";
+import { debitAiCredits } from "../lib/credit-debit";
+const AI_SOURCES = /* @__PURE__ */ new Set(["embed", "compute", "llm"]);
+async function totalBytesForVaults(vaults) {
+  if (vaults.length === 0) return 0;
+  const res = await query(
+    `SELECT COALESCE(SUM(octet_length(content)), 0)::bigint AS bytes FROM mem_notes WHERE vault = ANY($1)`,
+    [vaults]
+  );
+  return Number(res.rows[0]?.bytes ?? 0);
+}
+function periodOf(ts) {
+  return `${ts.getUTCFullYear()}-${String(ts.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+async function recordCost(args) {
+  await ensureSchema();
+  const now = /* @__PURE__ */ new Date();
+  await query(
+    `INSERT INTO mem_usage_ledger (identity, ts, source, op, tokens, cost_usd, vault, period)
+     VALUES ($1, now(), $2, $3, $4, $5, $6, $7)`,
+    [args.identity, args.source, args.op, Math.round(args.tokens ?? 0), args.costUsd, args.vault ?? null, periodOf(now)]
+  );
+  const debitBasisUsd = args.rawCostUsd ?? args.costUsd;
+  if (AI_SOURCES.has(args.source) && debitBasisUsd > 0) {
+    const res = await debitAiCredits({ identity: args.identity, costUsd: debitBasisUsd, op: args.op, source: args.source });
+    if (!res.ok) {
+      console.warn(JSON.stringify({ event: "ai_debit_failed", identity: args.identity, source: args.source, op: args.op, costUsd: debitBasisUsd, reason: res.reason }));
+    }
+  }
+}
+async function userCostThisPeriod(identity, period) {
+  await ensureSchema();
+  const p = period ?? periodOf(/* @__PURE__ */ new Date());
+  const res = await query(
+    `SELECT source, COALESCE(SUM(cost_usd), 0)::float8 AS total
+     FROM mem_usage_ledger WHERE identity = $1 AND period = $2 GROUP BY source`,
+    [identity, p]
+  );
+  const bySource = {};
+  let total = 0;
+  for (const r of res.rows) {
+    const v = Number(r.total);
+    bySource[r.source] = v;
+    total += v;
+  }
+  return { total, bySource };
+}
+async function costByTier(period) {
+  await ensureSchema();
+  const p = period ?? periodOf(/* @__PURE__ */ new Date());
+  const res = await query(
+    `SELECT k.plan AS plan, COUNT(DISTINCT l.identity)::int AS users, COALESCE(SUM(l.cost_usd), 0)::float8 AS total
+     FROM mem_usage_ledger l
+     LEFT JOIN LATERAL (
+       SELECT plan FROM mem_keys WHERE identity = l.identity ORDER BY created_at DESC LIMIT 1
+     ) k ON true
+     WHERE l.period = $1
+     GROUP BY k.plan
+     ORDER BY k.plan`,
+    [p]
+  );
+  return res.rows.map((r) => {
+    const users = Number(r.users) || 0;
+    const totalUsd = Number(r.total) || 0;
+    return {
+      plan: r.plan ?? "unknown",
+      users,
+      totalUsd,
+      avgUsdPerUser: users > 0 ? totalUsd / users : 0
+    };
+  });
+}
+async function snapshotStorageCostForIdentity(identity, vaults) {
+  const totalBytes = await totalBytesForVaults(vaults);
+  const costUsd = storageCostUsdForDay(totalBytes);
+  if (totalBytes > 0) {
+    await recordCost({ identity, source: "storage", op: "daily-snapshot", costUsd, tokens: 0 });
+  }
+  return costUsd;
+}
+async function snapshotAllStorageCost() {
+  await ensureSchema();
+  const res = await query(
+    `SELECT DISTINCT owner_identity, vault FROM mem_vault_registry`
+  );
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const r of res.rows) {
+    const arr = byIdentity.get(r.owner_identity) ?? [];
+    arr.push(r.vault);
+    byIdentity.set(r.owner_identity, arr);
+  }
+  let totalUsd = 0;
+  for (const [identity, vaults] of byIdentity) {
+    totalUsd += await snapshotStorageCostForIdentity(identity, vaults);
+  }
+  return { identities: byIdentity.size, totalUsd };
+}
+export {
+  costByTier,
+  recordCost,
+  snapshotAllStorageCost,
+  snapshotStorageCostForIdentity,
+  userCostThisPeriod
+};
+//# sourceMappingURL=usage.js.map

package/dist/db/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/usage.ts"],"sourcesContent":["import { ensureSchema, query } from './pool'\nimport { storageCostUsdForDay } from '../lib/cost-rates'\nimport { debitAiCredits } from '../lib/credit-debit'\n\nconst AI_SOURCES = new Set(['embed', 'compute', 'llm'])   // NOT 'storage'\n\nasync function totalBytesForVaults(vaults: string[]): Promise<number> {\n  if (vaults.length === 0) return 0\n  const res = await query<{ bytes: string }>(\n    `SELECT COALESCE(SUM(octet_length(content)), 0)::bigint AS bytes FROM mem_notes WHERE vault = ANY($1)`,\n    [vaults],\n  )\n  return Number(res.rows[0]?.bytes ?? 0)\n}\n\nexport type CostSource = 'llm' | 'embed' | 'storage' | 'compute'\n\nfunction periodOf(ts: Date): string {\n  return `${ts.getUTCFullYear()}-${String(ts.getUTCMonth() + 1).padStart(2, '0')}`\n}\n\nexport interface RecordCostArgs {\n  identity: string\n  source: CostSource\n  op: string\n  tokens?: number\n  costUsd: number\n  vault?: string\n  rawCostUsd?: number\n}\n\nexport async function recordCost(args: RecordCostArgs): Promise<void> {\n  await ensureSchema()\n  const now = new Date()\n  await query(\n    `INSERT INTO mem_usage_ledger (identity, ts, source, op, tokens, cost_usd, vault, period)\n     VALUES ($1, now(), $2, $3, $4, $5, $6, $7)`,\n    [args.identity, args.source, args.op, Math.round(args.tokens ?? 0), args.costUsd, args.vault ?? null, periodOf(now)],\n  )\n  const debitBasisUsd = args.rawCostUsd ?? args.costUsd\n  if (AI_SOURCES.has(args.source) && debitBasisUsd > 0) {\n    const res = await debitAiCredits({ identity: args.identity, costUsd: debitBasisUsd, op: args.op, source: args.source })\n    if (!res.ok) {\n      console.warn(JSON.stringify({ event: 'ai_debit_failed', identity: args.identity, source: args.source, op: args.op, costUsd: debitBasisUsd, reason: res.reason }))\n    }\n  }\n}\n\nexport interface CostSummary {\n  total: number\n  bySource: Record<string, number>\n}\n\nexport async function userCostThisPeriod(identity: string, period?: string): Promise<CostSummary> {\n  await ensureSchema()\n  const p = period ?? periodOf(new Date())\n  const res = await query<{ source: string; total: string }>(\n    `SELECT source, COALESCE(SUM(cost_usd), 0)::float8 AS total\n     FROM mem_usage_ledger WHERE identity = $1 AND period = $2 GROUP BY source`,\n    [identity, p],\n  )\n  const bySource: Record<string, number> = {}\n  let total = 0\n  for (const r of res.rows) {\n    const v = Number(r.total)\n    bySource[r.source] = v\n    total += v\n  }\n  return { total, bySource }\n}\n\nexport interface TierCost {\n  plan: string\n  users: number\n  totalUsd: number\n  avgUsdPerUser: number\n}\n\nexport async function costByTier(period?: string): Promise<TierCost[]> {\n  await ensureSchema()\n  const p = period ?? periodOf(new Date())\n  const res = await query<{ plan: string | null; users: string; total: string }>(\n    `SELECT k.plan AS plan, COUNT(DISTINCT l.identity)::int AS users, COALESCE(SUM(l.cost_usd), 0)::float8 AS total\n     FROM mem_usage_ledger l\n     LEFT JOIN LATERAL (\n       SELECT plan FROM mem_keys WHERE identity = l.identity ORDER BY created_at DESC LIMIT 1\n     ) k ON true\n     WHERE l.period = $1\n     GROUP BY k.plan\n     ORDER BY k.plan`,\n    [p],\n  )\n  return res.rows.map(r => {\n    const users = Number(r.users) || 0\n    const totalUsd = Number(r.total) || 0\n    return {\n      plan: r.plan ?? 'unknown',\n      users,\n      totalUsd,\n      avgUsdPerUser: users > 0 ? totalUsd / users : 0,\n    }\n  })\n}\n\nexport async function snapshotStorageCostForIdentity(identity: string, vaults: string[]): Promise<number> {\n  const totalBytes = await totalBytesForVaults(vaults)\n  const costUsd = storageCostUsdForDay(totalBytes)\n  if (totalBytes > 0) {\n    await recordCost({ identity, source: 'storage', op: 'daily-snapshot', costUsd, tokens: 0 })\n  }\n  return costUsd\n}\n\nexport async function snapshotAllStorageCost(): Promise<{ identities: number; totalUsd: number }> {\n  await ensureSchema()\n  const res = await query<{ owner_identity: string; vault: string }>(\n    `SELECT DISTINCT owner_identity, vault FROM mem_vault_registry`,\n  )\n  const byIdentity = new Map<string, string[]>()\n  for (const r of res.rows) {\n    const arr = byIdentity.get(r.owner_identity) ?? []\n    arr.push(r.vault)\n    byIdentity.set(r.owner_identity, arr)\n  }\n  let totalUsd = 0\n  for (const [identity, vaults] of byIdentity) {\n    totalUsd += await snapshotStorageCostForIdentity(identity, vaults)\n  }\n  return { identities: byIdentity.size, totalUsd }\n}\n"],"mappings":"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","names":[]}

package/dist/db/vaults.d.ts

@@ -0,0 +1,98 @@
+import { Scope } from '../lib/auth.js';
+import { VaultContract } from '../lib/vault-contracts.js';
+
+interface VaultEntitlement {
+    handle: string;
+    vault: string;
+    ownerIdentity: string;
+    entitlement: Scope;
+    shared: boolean;
+    kind: 'notes' | 'channel' | 'secure';
+}
+declare function sharedHandle(ownerIdentity: string, vault: string): string;
+declare function entitledVaults(identity: string): Promise<VaultEntitlement[]>;
+declare function addEntitlement(args: {
+    grantee: string;
+    handle: string;
+    vault: string;
+    ownerIdentity: string;
+    entitlement: Scope;
+    shared: boolean;
+}): Promise<void>;
+declare function shareVaultRow(args: {
+    grantee: string;
+    vault: string;
+    ownerIdentity: string;
+    entitlement: Scope;
+}): Promise<void>;
+interface VaultMember {
+    grantee: string;
+    entitlement: Scope;
+    createdAt: string;
+}
+declare function isChannelVault(ownerIdentity: string, vault: string): Promise<boolean>;
+declare function isSecureVault(ownerIdentity: string, vault: string): Promise<boolean>;
+declare function listVaultMembers(ownerIdentity: string, vault: string): Promise<VaultMember[]>;
+declare function revokeVaultMember(ownerIdentity: string, vault: string, grantee: string): Promise<boolean>;
+interface IdentityVault {
+    handle: string;
+    vault: string;
+    role: 'owner' | 'shared';
+    sharedBy?: string;
+    entitlement: Scope;
+    kind: 'notes' | 'channel' | 'secure';
+}
+declare function listVaultsForIdentity(identity: string): Promise<IdentityVault[]>;
+declare function physicalVaultsForIdentity(identity: string, opts?: {
+    ownedOnly?: boolean;
+}): Promise<string[]>;
+declare function isVaultOwner(identity: string, handle: string): Promise<boolean>;
+declare function vaultOwnerIdentity(vault: string): Promise<string | null>;
+declare function deleteVaultRegistry(grantee: string, handle: string): Promise<number>;
+declare function scopedVault(owner: string, vault: string): string;
+declare function vaultOwnerAndName(grantee: string, handle: string): Promise<{
+    ownerIdentity: string;
+    vault: string;
+} | null>;
+declare function physicalVaultFor(grantee: string, handle: string): Promise<string>;
+declare const VAULT_NAME_RE: RegExp;
+declare function createVault(args: {
+    identity: string;
+    vault: string;
+    owner?: string;
+}): Promise<{
+    vault: string;
+    created: boolean;
+    owner: string;
+}>;
+declare function setVaultContract(grantee: string, vault: string, contract: VaultContract): Promise<void>;
+declare function provisionDefaultVaults(identity: string): Promise<{
+    created: string[];
+    vaults: string[];
+}>;
+declare function setKeyVaults(keyId: string, vaults: string[]): Promise<boolean>;
+declare function getActiveVault(_sessionId: string, identity: string): Promise<string | null>;
+declare function setActiveVault(_sessionId: string, identity: string, vault: string): Promise<void>;
+interface ActiveContext {
+    activeOwner: string | null;
+    activeVault: string | null;
+}
+declare function getActiveContext(identity: string): Promise<ActiveContext>;
+declare function setActiveOwner(identity: string, owner: string | null, vault: string | null): Promise<void>;
+interface AccountGrant {
+    ownerIdentity: string;
+    grantee: string;
+    entitlement: Scope;
+}
+declare function addAccountGrant(args: {
+    ownerIdentity: string;
+    grantee: string;
+    entitlement: Scope;
+}): Promise<void>;
+declare function getAccountGrant(ownerIdentity: string, grantee: string): Promise<Scope | null>;
+declare function accountGrantsForGrantee(grantee: string): Promise<AccountGrant[]>;
+declare function revokeAccountGrant(ownerIdentity: string, grantee: string): Promise<number>;
+declare function ownedVaultNames(owner: string): Promise<string[]>;
+declare function listAllNoteVaults(): Promise<string[]>;
+
+export { type AccountGrant, type ActiveContext, type IdentityVault, VAULT_NAME_RE, type VaultEntitlement, type VaultMember, accountGrantsForGrantee, addAccountGrant, addEntitlement, createVault, deleteVaultRegistry, entitledVaults, getAccountGrant, getActiveContext, getActiveVault, isChannelVault, isSecureVault, isVaultOwner, listAllNoteVaults, listVaultMembers, listVaultsForIdentity, ownedVaultNames, physicalVaultFor, physicalVaultsForIdentity, provisionDefaultVaults, revokeAccountGrant, revokeVaultMember, scopedVault, setActiveOwner, setActiveVault, setKeyVaults, setVaultContract, shareVaultRow, sharedHandle, vaultOwnerAndName, vaultOwnerIdentity };

package/dist/db/vaults.js

@@ -0,0 +1,316 @@
+import { ensureSchema, query } from "./pool";
+import { normalizeScope } from "../lib/auth";
+import { DEFAULT_VAULTS, VAULT_CONTRACTS } from "../lib/vault-contracts";
+function sharedHandle(ownerIdentity, vault) {
+  return `${ownerIdentity}/${vault}`;
+}
+function contractKind(contract) {
+  const c = contract;
+  if (c?.kind === "channel") return "channel";
+  if (c?.kind === "secure") return "secure";
+  return "notes";
+}
+async function entitledVaults(identity) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT COALESCE(r.handle, r.vault) AS handle, r.vault, r.owner_identity, r.entitlement, r.shared,
+       (SELECT owner.contract FROM mem_vault_registry owner
+          WHERE owner.owner_identity = r.owner_identity AND owner.vault = r.vault AND owner.grantee = owner.owner_identity
+          LIMIT 1) AS contract
+       FROM mem_vault_registry r WHERE r.grantee = $1 ORDER BY r.created_at ASC`,
+    [identity]
+  );
+  return res.rows.map((r) => ({
+    handle: r.handle,
+    vault: r.vault,
+    ownerIdentity: r.owner_identity,
+    entitlement: normalizeScope(r.entitlement),
+    shared: r.shared,
+    kind: contractKind(r.contract)
+  }));
+}
+async function addEntitlement(args) {
+  await ensureSchema();
+  await query(
+    `INSERT INTO mem_vault_registry (grantee, handle, vault, owner_identity, entitlement, shared)
+     VALUES ($1, $2, $3, $4, $5::jsonb, $6)
+     ON CONFLICT (grantee, handle) DO UPDATE SET entitlement = EXCLUDED.entitlement, shared = EXCLUDED.shared`,
+    [args.grantee, args.handle, args.vault, args.ownerIdentity, JSON.stringify(args.entitlement), args.shared]
+  );
+}
+async function shareVaultRow(args) {
+  await addEntitlement({ ...args, handle: sharedHandle(args.ownerIdentity, args.vault), shared: true });
+}
+async function isChannelVault(ownerIdentity, vault) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT contract FROM mem_vault_registry WHERE owner_identity = $1 AND vault = $2 LIMIT 1`,
+    [ownerIdentity, vault]
+  );
+  const contract = res.rows[0]?.contract;
+  return contract?.kind === "channel";
+}
+async function isSecureVault(ownerIdentity, vault) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT contract FROM mem_vault_registry WHERE owner_identity = $1 AND vault = $2 LIMIT 1`,
+    [ownerIdentity, vault]
+  );
+  const contract = res.rows[0]?.contract;
+  return contract?.kind === "secure";
+}
+async function listVaultMembers(ownerIdentity, vault) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT grantee, entitlement, created_at FROM mem_vault_registry
+     WHERE owner_identity = $1 AND vault = $2 AND grantee != $1 ORDER BY created_at ASC`,
+    [ownerIdentity, vault]
+  );
+  return res.rows.map((r) => ({ grantee: r.grantee, entitlement: normalizeScope(r.entitlement), createdAt: r.created_at }));
+}
+async function revokeVaultMember(ownerIdentity, vault, grantee) {
+  await ensureSchema();
+  const res = await query(
+    `DELETE FROM mem_vault_registry WHERE owner_identity = $1 AND vault = $2 AND grantee = $3`,
+    [ownerIdentity, vault, grantee]
+  );
+  return (res.rowCount ?? 0) > 0;
+}
+async function listVaultsForIdentity(identity) {
+  const ents = await entitledVaults(identity);
+  const seen = /* @__PURE__ */ new Map();
+  for (const e of ents) {
+    if (seen.has(e.handle)) continue;
+    const isOwner = e.ownerIdentity === identity;
+    seen.set(e.handle, {
+      handle: e.handle,
+      vault: e.vault,
+      role: isOwner ? "owner" : "shared",
+      sharedBy: isOwner ? void 0 : e.ownerIdentity,
+      entitlement: e.entitlement,
+      kind: e.kind
+    });
+  }
+  return [...seen.values()];
+}
+async function physicalVaultsForIdentity(identity, opts) {
+  const vaults = await listVaultsForIdentity(identity);
+  return vaults.filter((v) => opts?.ownedOnly ? v.role === "owner" : true).map((v) => scopedVault(v.role === "owner" ? identity : v.sharedBy ?? identity, v.vault));
+}
+async function isVaultOwner(identity, handle) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT owner_identity FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2 LIMIT 1`,
+    [identity, handle]
+  );
+  return res.rows[0]?.owner_identity === identity;
+}
+async function vaultOwnerIdentity(vault) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT owner_identity FROM mem_vault_registry
+     WHERE grantee = owner_identity AND (owner_identity || ' ' || vault) = $1
+     LIMIT 1`,
+    [vault]
+  );
+  return res.rows[0]?.owner_identity ?? null;
+}
+async function deleteVaultRegistry(grantee, handle) {
+  await ensureSchema();
+  const res = await query(`DELETE FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2`, [grantee, handle]);
+  return res.rowCount ?? 0;
+}
+function scopedVault(owner, vault) {
+  return `${owner} ${vault}`;
+}
+async function vaultOwnerAndName(grantee, handle) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT owner_identity, vault FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2 LIMIT 1`,
+    [grantee, handle]
+  );
+  return res.rows[0] ? { ownerIdentity: res.rows[0].owner_identity, vault: res.rows[0].vault } : null;
+}
+async function physicalVaultFor(grantee, handle) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT owner_identity, vault FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2 LIMIT 1`,
+    [grantee, handle]
+  );
+  const row = res.rows[0];
+  if (row) return scopedVault(row.owner_identity, row.vault);
+  const ctx = await getActiveContext(grantee);
+  if (ctx.activeOwner && ctx.activeOwner !== grantee) return scopedVault(ctx.activeOwner, handle);
+  return scopedVault(grantee, handle);
+}
+const VAULT_NAME_RE = /^[A-Za-z0-9 _-]{1,48}$/;
+async function createVault(args) {
+  await ensureSchema();
+  if (!VAULT_NAME_RE.test(args.vault)) {
+    throw new Error(`invalid vault name "${args.vault}" (allowed: letters, digits, space, _ or -, 1-48 chars)`);
+  }
+  const owner = args.owner ?? args.identity;
+  const existing = await query(
+    `SELECT 1 FROM mem_vault_registry WHERE grantee = $1 AND vault = $2 LIMIT 1`,
+    [owner, args.vault]
+  );
+  if ((existing.rowCount ?? 0) > 0) {
+    return { vault: args.vault, created: false, owner };
+  }
+  await addEntitlement({
+    grantee: owner,
+    handle: args.vault,
+    vault: args.vault,
+    ownerIdentity: owner,
+    entitlement: normalizeScope({ read: true, write: true, export: true, index: true, admin: true, swap: true }),
+    shared: false
+  });
+  return { vault: args.vault, created: true, owner };
+}
+async function setVaultContract(grantee, vault, contract) {
+  await ensureSchema();
+  await query(
+    `UPDATE mem_vault_registry SET contract = $3::jsonb WHERE grantee = $1 AND vault = $2`,
+    [grantee, vault, JSON.stringify(contract)]
+  );
+}
+async function provisionDefaultVaults(identity) {
+  await ensureSchema();
+  const created = [];
+  for (const vault of DEFAULT_VAULTS) {
+    const result = await createVault({ identity, vault, owner: identity });
+    if (result.created) created.push(vault);
+    const contract = VAULT_CONTRACTS[vault];
+    if (contract) await setVaultContract(identity, vault, contract);
+  }
+  return { created, vaults: [...DEFAULT_VAULTS] };
+}
+async function setKeyVaults(keyId, vaults) {
+  await ensureSchema();
+  const res = await query(
+    `UPDATE mem_keys SET vaults = $2::jsonb WHERE key_id = $1`,
+    [keyId, JSON.stringify(vaults)]
+  );
+  return (res.rowCount ?? 0) > 0;
+}
+async function getActiveVault(_sessionId, identity) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT active_vault FROM mem_active_context WHERE identity = $1 LIMIT 1`,
+    [identity]
+  );
+  return res.rows[0]?.active_vault ?? null;
+}
+async function setActiveVault(_sessionId, identity, vault) {
+  await ensureSchema();
+  await query(
+    `INSERT INTO mem_active_context (identity, active_vault, updated_at)
+     VALUES ($1, $2, now())
+     ON CONFLICT (identity) DO UPDATE SET active_vault = EXCLUDED.active_vault, updated_at = now()`,
+    [identity, vault]
+  );
+}
+async function getActiveContext(identity) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT active_owner, active_vault FROM mem_active_context WHERE identity = $1 LIMIT 1`,
+    [identity]
+  );
+  const r = res.rows[0];
+  return { activeOwner: r?.active_owner ?? null, activeVault: r?.active_vault ?? null };
+}
+async function setActiveOwner(identity, owner, vault) {
+  await ensureSchema();
+  await query(
+    `INSERT INTO mem_active_context (identity, active_owner, active_vault, updated_at)
+     VALUES ($1, $2, $3, now())
+     ON CONFLICT (identity) DO UPDATE SET active_owner = EXCLUDED.active_owner, active_vault = EXCLUDED.active_vault, updated_at = now()`,
+    [identity, owner, vault]
+  );
+}
+async function addAccountGrant(args) {
+  await ensureSchema();
+  await query(
+    `INSERT INTO mem_account_grants (owner_identity, grantee, entitlement)
+     VALUES ($1, $2, $3::jsonb)
+     ON CONFLICT (owner_identity, grantee) DO UPDATE SET entitlement = EXCLUDED.entitlement`,
+    [args.ownerIdentity, args.grantee, JSON.stringify(args.entitlement)]
+  );
+}
+async function getAccountGrant(ownerIdentity, grantee) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT entitlement FROM mem_account_grants WHERE owner_identity = $1 AND grantee = $2 LIMIT 1`,
+    [ownerIdentity, grantee]
+  );
+  const r = res.rows[0];
+  return r ? normalizeScope(r.entitlement) : null;
+}
+async function accountGrantsForGrantee(grantee) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT owner_identity, entitlement FROM mem_account_grants WHERE grantee = $1 ORDER BY created_at ASC`,
+    [grantee]
+  );
+  return res.rows.map((r) => ({
+    ownerIdentity: r.owner_identity,
+    grantee,
+    entitlement: normalizeScope(r.entitlement)
+  }));
+}
+async function revokeAccountGrant(ownerIdentity, grantee) {
+  await ensureSchema();
+  const res = await query(`DELETE FROM mem_account_grants WHERE owner_identity = $1 AND grantee = $2`, [ownerIdentity, grantee]);
+  return res.rowCount ?? 0;
+}
+async function ownedVaultNames(owner) {
+  await ensureSchema();
+  const res = await query(
+    `SELECT vault FROM mem_vault_registry WHERE grantee = $1 AND owner_identity = $1 ORDER BY created_at ASC`,
+    [owner]
+  );
+  return res.rows.map((r) => r.vault);
+}
+async function listAllNoteVaults() {
+  await ensureSchema();
+  const res = await query(
+    `SELECT (owner_identity || ' ' || vault) AS physical FROM mem_vault_registry
+     WHERE grantee = owner_identity AND COALESCE(contract->>'kind', '') != 'channel'
+     ORDER BY owner_identity, vault`
+  );
+  return res.rows.map((r) => r.physical);
+}
+export {
+  VAULT_NAME_RE,
+  accountGrantsForGrantee,
+  addAccountGrant,
+  addEntitlement,
+  createVault,
+  deleteVaultRegistry,
+  entitledVaults,
+  getAccountGrant,
+  getActiveContext,
+  getActiveVault,
+  isChannelVault,
+  isSecureVault,
+  isVaultOwner,
+  listAllNoteVaults,
+  listVaultMembers,
+  listVaultsForIdentity,
+  ownedVaultNames,
+  physicalVaultFor,
+  physicalVaultsForIdentity,
+  provisionDefaultVaults,
+  revokeAccountGrant,
+  revokeVaultMember,
+  scopedVault,
+  setActiveOwner,
+  setActiveVault,
+  setKeyVaults,
+  setVaultContract,
+  shareVaultRow,
+  sharedHandle,
+  vaultOwnerAndName,
+  vaultOwnerIdentity
+};
+//# sourceMappingURL=vaults.js.map

package/dist/db/vaults.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/vaults.ts"],"sourcesContent":["import { ensureSchema, query } from './pool'\nimport { normalizeScope } from '../lib/auth'\nimport type { Scope } from '../lib/auth'\nimport { DEFAULT_VAULTS, VAULT_CONTRACTS } from '../lib/vault-contracts'\nimport type { VaultContract } from '../lib/vault-contracts'\n\nexport interface VaultEntitlement {\n  handle: string\n  vault: string\n  ownerIdentity: string\n  entitlement: Scope\n  shared: boolean\n  kind: 'notes' | 'channel' | 'secure'\n}\n\ninterface VaultRow {\n  handle: string\n  vault: string\n  owner_identity: string\n  entitlement: unknown\n  shared: boolean\n  contract: unknown\n}\n\nexport function sharedHandle(ownerIdentity: string, vault: string): string {\n  return `${ownerIdentity}/${vault}`\n}\n\nfunction contractKind(contract: unknown): 'notes' | 'channel' | 'secure' {\n  const c = contract as { kind?: string } | null\n  if (c?.kind === 'channel') return 'channel'\n  if (c?.kind === 'secure') return 'secure'\n  return 'notes'\n}\n\nexport async function entitledVaults(identity: string): Promise<VaultEntitlement[]> {\n  await ensureSchema()\n  const res = await query<VaultRow>(\n    `SELECT COALESCE(r.handle, r.vault) AS handle, r.vault, r.owner_identity, r.entitlement, r.shared,\n       (SELECT owner.contract FROM mem_vault_registry owner\n          WHERE owner.owner_identity = r.owner_identity AND owner.vault = r.vault AND owner.grantee = owner.owner_identity\n          LIMIT 1) AS contract\n       FROM mem_vault_registry r WHERE r.grantee = $1 ORDER BY r.created_at ASC`,\n    [identity],\n  )\n  return res.rows.map(r => ({\n    handle: r.handle,\n    vault: r.vault,\n    ownerIdentity: r.owner_identity,\n    entitlement: normalizeScope(r.entitlement as Record<string, boolean>),\n    shared: r.shared,\n    kind: contractKind(r.contract),\n  }))\n}\n\nexport async function addEntitlement(args: {\n  grantee: string\n  handle: string\n  vault: string\n  ownerIdentity: string\n  entitlement: Scope\n  shared: boolean\n}): Promise<void> {\n  await ensureSchema()\n  await query(\n    `INSERT INTO mem_vault_registry (grantee, handle, vault, owner_identity, entitlement, shared)\n     VALUES ($1, $2, $3, $4, $5::jsonb, $6)\n     ON CONFLICT (grantee, handle) DO UPDATE SET entitlement = EXCLUDED.entitlement, shared = EXCLUDED.shared`,\n    [args.grantee, args.handle, args.vault, args.ownerIdentity, JSON.stringify(args.entitlement), args.shared],\n  )\n}\n\nexport async function shareVaultRow(args: {\n  grantee: string\n  vault: string\n  ownerIdentity: string\n  entitlement: Scope\n}): Promise<void> {\n  await addEntitlement({ ...args, handle: sharedHandle(args.ownerIdentity, args.vault), shared: true })\n}\n\nexport interface VaultMember {\n  grantee: string\n  entitlement: Scope\n  createdAt: string\n}\n\nexport async function isChannelVault(ownerIdentity: string, vault: string): Promise<boolean> {\n  await ensureSchema()\n  const res = await query<{ contract: unknown }>(\n    `SELECT contract FROM mem_vault_registry WHERE owner_identity = $1 AND vault = $2 LIMIT 1`,\n    [ownerIdentity, vault],\n  )\n  const contract = res.rows[0]?.contract as { kind?: string } | null\n  return contract?.kind === 'channel'\n}\n\nexport async function isSecureVault(ownerIdentity: string, vault: string): Promise<boolean> {\n  await ensureSchema()\n  const res = await query<{ contract: unknown }>(\n    `SELECT contract FROM mem_vault_registry WHERE owner_identity = $1 AND vault = $2 LIMIT 1`,\n    [ownerIdentity, vault],\n  )\n  const contract = res.rows[0]?.contract as { kind?: string } | null\n  return contract?.kind === 'secure'\n}\n\nexport async function listVaultMembers(ownerIdentity: string, vault: string): Promise<VaultMember[]> {\n  await ensureSchema()\n  const res = await query<{ grantee: string; entitlement: unknown; created_at: string }>(\n    `SELECT grantee, entitlement, created_at FROM mem_vault_registry\n     WHERE owner_identity = $1 AND vault = $2 AND grantee != $1 ORDER BY created_at ASC`,\n    [ownerIdentity, vault],\n  )\n  return res.rows.map(r => ({ grantee: r.grantee, entitlement: normalizeScope(r.entitlement as Record<string, boolean>), createdAt: r.created_at }))\n}\n\nexport async function revokeVaultMember(ownerIdentity: string, vault: string, grantee: string): Promise<boolean> {\n  await ensureSchema()\n  const res = await query(\n    `DELETE FROM mem_vault_registry WHERE owner_identity = $1 AND vault = $2 AND grantee = $3`,\n    [ownerIdentity, vault, grantee],\n  )\n  return (res.rowCount ?? 0) > 0\n}\n\nexport interface IdentityVault {\n  handle: string\n  vault: string\n  role: 'owner' | 'shared'\n  sharedBy?: string\n  entitlement: Scope\n  kind: 'notes' | 'channel' | 'secure'\n}\n\nexport async function listVaultsForIdentity(identity: string): Promise<IdentityVault[]> {\n  const ents = await entitledVaults(identity)\n  const seen = new Map<string, IdentityVault>()\n  for (const e of ents) {\n    if (seen.has(e.handle)) continue\n    const isOwner = e.ownerIdentity === identity\n    seen.set(e.handle, {\n      handle: e.handle,\n      vault: e.vault,\n      role: isOwner ? 'owner' : 'shared',\n      sharedBy: isOwner ? undefined : e.ownerIdentity,\n      entitlement: e.entitlement,\n      kind: e.kind,\n    })\n  }\n  return [...seen.values()]\n}\n\nexport async function physicalVaultsForIdentity(identity: string, opts?: { ownedOnly?: boolean }): Promise<string[]> {\n  const vaults = await listVaultsForIdentity(identity)\n  return vaults\n    .filter(v => (opts?.ownedOnly ? v.role === 'owner' : true))\n    .map(v => scopedVault(v.role === 'owner' ? identity : (v.sharedBy ?? identity), v.vault))\n}\n\nexport async function isVaultOwner(identity: string, handle: string): Promise<boolean> {\n  await ensureSchema()\n  const res = await query<{ owner_identity: string }>(\n    `SELECT owner_identity FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2 LIMIT 1`,\n    [identity, handle],\n  )\n  return res.rows[0]?.owner_identity === identity\n}\n\nexport async function vaultOwnerIdentity(vault: string): Promise<string | null> {\n  await ensureSchema()\n  const res = await query<{ owner_identity: string }>(\n    `SELECT owner_identity FROM mem_vault_registry\n     WHERE grantee = owner_identity AND (owner_identity || ' ' || vault) = $1\n     LIMIT 1`,\n    [vault],\n  )\n  return res.rows[0]?.owner_identity ?? null\n}\n\nexport async function deleteVaultRegistry(grantee: string, handle: string): Promise<number> {\n  await ensureSchema()\n  const res = await query(`DELETE FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2`, [grantee, handle])\n  return res.rowCount ?? 0\n}\n\nexport function scopedVault(owner: string, vault: string): string {\n  return `${owner} ${vault}`\n}\n\nexport async function vaultOwnerAndName(grantee: string, handle: string): Promise<{ ownerIdentity: string; vault: string } | null> {\n  await ensureSchema()\n  const res = await query<{ owner_identity: string; vault: string }>(\n    `SELECT owner_identity, vault FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2 LIMIT 1`,\n    [grantee, handle],\n  )\n  return res.rows[0] ? { ownerIdentity: res.rows[0].owner_identity, vault: res.rows[0].vault } : null\n}\n\nexport async function physicalVaultFor(grantee: string, handle: string): Promise<string> {\n  await ensureSchema()\n  const res = await query<{ owner_identity: string; vault: string }>(\n    `SELECT owner_identity, vault FROM mem_vault_registry WHERE grantee = $1 AND COALESCE(handle, vault) = $2 LIMIT 1`,\n    [grantee, handle],\n  )\n  const row = res.rows[0]\n  if (row) return scopedVault(row.owner_identity, row.vault)\n  const ctx = await getActiveContext(grantee)\n  if (ctx.activeOwner && ctx.activeOwner !== grantee) return scopedVault(ctx.activeOwner, handle)\n  return scopedVault(grantee, handle)\n}\n\nexport const VAULT_NAME_RE = /^[A-Za-z0-9 _-]{1,48}$/\n\nexport async function createVault(args: { identity: string; vault: string; owner?: string }): Promise<{ vault: string; created: boolean; owner: string }> {\n  await ensureSchema()\n  if (!VAULT_NAME_RE.test(args.vault)) {\n    throw new Error(`invalid vault name \"${args.vault}\" (allowed: letters, digits, space, _ or -, 1-48 chars)`)\n  }\n  const owner = args.owner ?? args.identity\n  const existing = await query(\n    `SELECT 1 FROM mem_vault_registry WHERE grantee = $1 AND vault = $2 LIMIT 1`,\n    [owner, args.vault],\n  )\n  if ((existing.rowCount ?? 0) > 0) {\n    return { vault: args.vault, created: false, owner }\n  }\n  await addEntitlement({\n    grantee: owner,\n    handle: args.vault,\n    vault: args.vault,\n    ownerIdentity: owner,\n    entitlement: normalizeScope({ read: true, write: true, export: true, index: true, admin: true, swap: true }),\n    shared: false,\n  })\n  return { vault: args.vault, created: true, owner }\n}\n\nexport async function setVaultContract(grantee: string, vault: string, contract: VaultContract): Promise<void> {\n  await ensureSchema()\n  await query(\n    `UPDATE mem_vault_registry SET contract = $3::jsonb WHERE grantee = $1 AND vault = $2`,\n    [grantee, vault, JSON.stringify(contract)],\n  )\n}\n\nexport async function provisionDefaultVaults(identity: string): Promise<{ created: string[]; vaults: string[] }> {\n  await ensureSchema()\n  const created: string[] = []\n  for (const vault of DEFAULT_VAULTS) {\n    const result = await createVault({ identity, vault, owner: identity })\n    if (result.created) created.push(vault)\n    const contract = VAULT_CONTRACTS[vault]\n    if (contract) await setVaultContract(identity, vault, contract)\n  }\n  return { created, vaults: [...DEFAULT_VAULTS] }\n}\n\nexport async function setKeyVaults(keyId: string, vaults: string[]): Promise<boolean> {\n  await ensureSchema()\n  const res = await query(\n    `UPDATE mem_keys SET vaults = $2::jsonb WHERE key_id = $1`,\n    [keyId, JSON.stringify(vaults)],\n  )\n  return (res.rowCount ?? 0) > 0\n}\n\nexport async function getActiveVault(_sessionId: string, identity: string): Promise<string | null> {\n  await ensureSchema()\n  const res = await query<{ active_vault: string | null }>(\n    `SELECT active_vault FROM mem_active_context WHERE identity = $1 LIMIT 1`,\n    [identity],\n  )\n  return res.rows[0]?.active_vault ?? null\n}\n\nexport async function setActiveVault(_sessionId: string, identity: string, vault: string): Promise<void> {\n  await ensureSchema()\n  await query(\n    `INSERT INTO mem_active_context (identity, active_vault, updated_at)\n     VALUES ($1, $2, now())\n     ON CONFLICT (identity) DO UPDATE SET active_vault = EXCLUDED.active_vault, updated_at = now()`,\n    [identity, vault],\n  )\n}\n\nexport interface ActiveContext {\n  activeOwner: string | null\n  activeVault: string | null\n}\n\nexport async function getActiveContext(identity: string): Promise<ActiveContext> {\n  await ensureSchema()\n  const res = await query<{ active_owner: string | null; active_vault: string | null }>(\n    `SELECT active_owner, active_vault FROM mem_active_context WHERE identity = $1 LIMIT 1`,\n    [identity],\n  )\n  const r = res.rows[0]\n  return { activeOwner: r?.active_owner ?? null, activeVault: r?.active_vault ?? null }\n}\n\nexport async function setActiveOwner(identity: string, owner: string | null, vault: string | null): Promise<void> {\n  await ensureSchema()\n  await query(\n    `INSERT INTO mem_active_context (identity, active_owner, active_vault, updated_at)\n     VALUES ($1, $2, $3, now())\n     ON CONFLICT (identity) DO UPDATE SET active_owner = EXCLUDED.active_owner, active_vault = EXCLUDED.active_vault, updated_at = now()`,\n    [identity, owner, vault],\n  )\n}\n\nexport interface AccountGrant {\n  ownerIdentity: string\n  grantee: string\n  entitlement: Scope\n}\n\nexport async function addAccountGrant(args: { ownerIdentity: string; grantee: string; entitlement: Scope }): Promise<void> {\n  await ensureSchema()\n  await query(\n    `INSERT INTO mem_account_grants (owner_identity, grantee, entitlement)\n     VALUES ($1, $2, $3::jsonb)\n     ON CONFLICT (owner_identity, grantee) DO UPDATE SET entitlement = EXCLUDED.entitlement`,\n    [args.ownerIdentity, args.grantee, JSON.stringify(args.entitlement)],\n  )\n}\n\nexport async function getAccountGrant(ownerIdentity: string, grantee: string): Promise<Scope | null> {\n  await ensureSchema()\n  const res = await query<{ entitlement: unknown }>(\n    `SELECT entitlement FROM mem_account_grants WHERE owner_identity = $1 AND grantee = $2 LIMIT 1`,\n    [ownerIdentity, grantee],\n  )\n  const r = res.rows[0]\n  return r ? normalizeScope(r.entitlement as Record<string, boolean>) : null\n}\n\nexport async function accountGrantsForGrantee(grantee: string): Promise<AccountGrant[]> {\n  await ensureSchema()\n  const res = await query<{ owner_identity: string; entitlement: unknown }>(\n    `SELECT owner_identity, entitlement FROM mem_account_grants WHERE grantee = $1 ORDER BY created_at ASC`,\n    [grantee],\n  )\n  return res.rows.map(r => ({\n    ownerIdentity: r.owner_identity,\n    grantee,\n    entitlement: normalizeScope(r.entitlement as Record<string, boolean>),\n  }))\n}\n\nexport async function revokeAccountGrant(ownerIdentity: string, grantee: string): Promise<number> {\n  await ensureSchema()\n  const res = await query(`DELETE FROM mem_account_grants WHERE owner_identity = $1 AND grantee = $2`, [ownerIdentity, grantee])\n  return res.rowCount ?? 0\n}\n\nexport async function ownedVaultNames(owner: string): Promise<string[]> {\n  await ensureSchema()\n  const res = await query<{ vault: string }>(\n    `SELECT vault FROM mem_vault_registry WHERE grantee = $1 AND owner_identity = $1 ORDER BY created_at ASC`,\n    [owner],\n  )\n  return res.rows.map(r => r.vault)\n}\n\nexport async function listAllNoteVaults(): Promise<string[]> {\n  await ensureSchema()\n  const res = await query<{ physical: string }>(\n    `SELECT (owner_identity || ' ' || vault) AS physical FROM mem_vault_registry\n     WHERE grantee = owner_identity AND COALESCE(contract->>'kind', '') != 'channel'\n     ORDER BY owner_identity, vault`,\n  )\n  return res.rows.map(r => r.physical)\n}\n"],"mappings":"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","names":[]}

package/dist/db/video-runs.d.ts

@@ -0,0 +1,70 @@
+type VideoRunStatus = 'queued' | 'resolving' | 'analyzing' | 'synthesizing' | 'detail' | 'done' | 'failed';
+interface VideoRunRow {
+    id: string;
+    identity: string;
+    vault: string;
+    sourceUrl: string;
+    mediaUrl: string | null;
+    scraperApiKey: string | null;
+    intervalS: number;
+    maxFrames: number;
+    detail: string;
+    durationS: number | null;
+    frameCount: number;
+    status: VideoRunStatus;
+    error: string | null;
+    transcript: unknown;
+    metrics: unknown;
+    lenses: unknown;
+    qc: unknown;
+    reportMd: string | null;
+    artifactPath: string | null;
+    costUsd: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare function createVideoRun(args: {
+    identity: string;
+    vault: string;
+    sourceUrl: string;
+    intervalS: number;
+    maxFrames: number;
+    detail: string;
+    scraperApiKey: string | null;
+}): Promise<string>;
+declare function getVideoRun(id: string, identity: string): Promise<VideoRunRow | null>;
+declare const PATCH_COLS: Record<string, string>;
+declare function updateVideoRun(id: string, patch: Partial<Record<keyof typeof PATCH_COLS, unknown>>): Promise<void>;
+declare function insertFrames(runId: string, frames: Array<{
+    idx: number;
+    tSec: number;
+    imgB64?: string;
+}>): Promise<void>;
+declare function setFrameObservation(runId: string, idx: number, observation: unknown, status: 'ok' | 'error'): Promise<void>;
+interface PendingFrame {
+    idx: number;
+    tSec: number;
+    imgB64: string;
+}
+declare function listPendingImageFrames(runId: string, limit: number): Promise<PendingFrame[]>;
+declare function countPendingFrames(runId: string): Promise<number>;
+declare function setFrameDetail(runId: string, idx: number, detail: unknown): Promise<void>;
+interface FrameRow {
+    idx: number;
+    tSec: number;
+    observation: unknown;
+    detail: unknown;
+    status: string;
+}
+declare function listFrames(runId: string): Promise<FrameRow[]>;
+declare function listQueuedVideoRuns(limit: number): Promise<Array<{
+    id: string;
+    identity: string;
+}>>;
+declare function reapStaleVideoRun(id: string, reapMinutes: number): Promise<VideoRunRow | null>;
+declare function runProgress(runId: string): Promise<{
+    total: number;
+    analyzed: number;
+}>;
+
+export { type FrameRow, type PendingFrame, type VideoRunRow, type VideoRunStatus, countPendingFrames, createVideoRun, getVideoRun, insertFrames, listFrames, listPendingImageFrames, listQueuedVideoRuns, reapStaleVideoRun, runProgress, setFrameDetail, setFrameObservation, updateVideoRun };