hippo-memory 1.69.0 → 1.71.0

package/dist/connectors/github/signature.d.ts

@@ -7,32 +7,10 @@ export interface VerifyOpts {
     previousSecret?: string;
 }
 export declare function verifyGitHubSignature(opts: VerifyOpts): boolean;
-/**
- * Source-aware idempotency key: artifact_ref plus the source-side updated_at.
- * A raw-body key would hash a webhook envelope and a REST backfill item of the
- * SAME source event differently and ingest it twice. Same artifact + same
- * revision = same key, whichever path delivered it; an edit gets a new key,
- * which is correct because each edit IS a new memory revision.
- *
- * Both inputs are upstream-derived from the parsed event, not from the
- * unsigned delivery header — replay attacks still cannot bypass dedupe.
- *
- * Inputs:
- *   - artifactRef: e.g. 'github://acme/repo/issue/42' or
- *     'github://acme/repo/issue/42/comment/123'.
- *   - updatedAt: source-side ISO timestamp (issue.updated_at,
- *     comment.updated_at, pull_request.updated_at). Empty string when the
- *     payload omits it (rare; older REST shapes).
- */
+/** Source-aware idempotency key: artifact_ref plus the source-side updated_at, so a webhook and a REST backfill of the SAME event dedupe.
+ *  An edit gets a new key (a new revision); both inputs come from the parsed event, not the unsigned delivery header, so replays cannot bypass dedupe. */
 export declare function computeIdempotencyKey(artifactRef: string, updatedAt: string | null | undefined): string;
-/**
- * Deletion-specific idempotency key: sha256('deleted:' + artifactRef + ':' +
- * updatedAt). Distinct namespace from computeIdempotencyKey so an ingest's row
- * in github_event_log doesn't make a deletion return 'duplicate' before it
- * gets a chance to archive; retries of the SAME deletion still dedupe.
- *
- * Kept as a separate exported function so the namespace prefix is explicit
- * at every call site (server.ts deletion branches, deletion.ts, DLQ replay).
- */
+/** Deletion idempotency key: sha256('deleted:' + artifactRef + ':' + updatedAt).
+ *  A separate namespace so an ingest's event-log row cannot make a deletion return 'duplicate'; retries of the same deletion still dedupe. */
 export declare function computeDeletionKey(artifactRef: string, updatedAt: string | null | undefined): string;
 //# sourceMappingURL=signature.d.ts.map

package/dist/connectors/github/signature.js

@@ -16,35 +16,13 @@ export function verifyGitHubSignature(opts) {
         return true;
     return false;
 }
-/**
- * Source-aware idempotency key: artifact_ref plus the source-side updated_at.
- * A raw-body key would hash a webhook envelope and a REST backfill item of the
- * SAME source event differently and ingest it twice. Same artifact + same
- * revision = same key, whichever path delivered it; an edit gets a new key,
- * which is correct because each edit IS a new memory revision.
- *
- * Both inputs are upstream-derived from the parsed event, not from the
- * unsigned delivery header — replay attacks still cannot bypass dedupe.
- *
- * Inputs:
- *   - artifactRef: e.g. 'github://acme/repo/issue/42' or
- *     'github://acme/repo/issue/42/comment/123'.
- *   - updatedAt: source-side ISO timestamp (issue.updated_at,
- *     comment.updated_at, pull_request.updated_at). Empty string when the
- *     payload omits it (rare; older REST shapes).
- */
+/** Source-aware idempotency key: artifact_ref plus the source-side updated_at, so a webhook and a REST backfill of the SAME event dedupe.
+ *  An edit gets a new key (a new revision); both inputs come from the parsed event, not the unsigned delivery header, so replays cannot bypass dedupe. */
 export function computeIdempotencyKey(artifactRef, updatedAt) {
     return createHash('sha256').update(`${artifactRef}:${updatedAt ?? ''}`).digest('hex');
 }
-/**
- * Deletion-specific idempotency key: sha256('deleted:' + artifactRef + ':' +
- * updatedAt). Distinct namespace from computeIdempotencyKey so an ingest's row
- * in github_event_log doesn't make a deletion return 'duplicate' before it
- * gets a chance to archive; retries of the SAME deletion still dedupe.
- *
- * Kept as a separate exported function so the namespace prefix is explicit
- * at every call site (server.ts deletion branches, deletion.ts, DLQ replay).
- */
+/** Deletion idempotency key: sha256('deleted:' + artifactRef + ':' + updatedAt).
+ *  A separate namespace so an ingest's event-log row cannot make a deletion return 'duplicate'; retries of the same deletion still dedupe. */
 export function computeDeletionKey(artifactRef, updatedAt) {
     return createHash('sha256').update(`deleted:${artifactRef}:${updatedAt ?? ''}`).digest('hex');
 }

package/dist/connectors/github/tenant-routing.d.ts

@@ -1,33 +1,11 @@
-import type { DatabaseSyncLike } from '../../db.js';
+import { type HippoStore } from '../../store/index.js';
 export interface ResolveArgs {
     /** String form of `installation.id`. `null`/`undefined` means "no installation field" (PAT-mode webhook). */
     installationId?: string | null;
     /** `repository.full_name` from the webhook envelope, used for PAT-mode multi-tenant routing. */
     repoFullName?: string | null;
 }
-/**
- * Resolve the tenant_id for a GitHub webhook envelope.
- *
- * Returns:
- *   - mapped tenant_id when `github_installations` has a row for `installationId`
- *     (App-mode multi-tenant — primary path)
- *   - mapped tenant_id when `installation` is absent, `repository.full_name`
- *     matches a `github_repositories` row (PAT-mode multi-tenant)
- *   - the deployment's HIPPO_TENANT fallback (or 'default') when BOTH routing
- *     tables are empty (single-tenant deployment — env fallback is safe)
- *   - null when:
- *       - `installationId` is present but unknown AND `github_installations`
- *         is non-empty (multi-tenant install with foreign installation)
- *       - `installationId` is missing AND either routing table is non-empty
- *         AND no `repository.full_name` match (PAT-mode webhook from a foreign
- *         account)
- *
- * Escape hatch: `GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1` restores the
- * env fallback for emergency rollback only. Mirrors the Slack equivalent
- * (`SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK`).
- *
- * The fail-closed contract lives here so every caller (route handler, CLI
- * replay, future MCP) gets identical protection.
- */
-export declare function resolveTenantForGitHub(db: DatabaseSyncLike, args: ResolveArgs): string | null;
+/** Resolve a GitHub envelope's tenant_id by installation id, then repository.full_name; the HIPPO_TENANT fallback applies only if both tables are empty.
+ *  An unknown installation or repo on a multi-tenant deployment returns null (fail closed); GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1 escapes. */
+export declare function resolveTenantForGitHub(hippoRoot: string, args: ResolveArgs, store?: HippoStore): Promise<string | null>;
 //# sourceMappingURL=tenant-routing.d.ts.map

package/dist/connectors/github/tenant-routing.js

@@ -1,70 +1,22 @@
-import { envGithubAllowUnknownInstallationFallback, envTenant } from '../../env.js';
-/**
- * Resolve the tenant_id for a GitHub webhook envelope.
- *
- * Returns:
- *   - mapped tenant_id when `github_installations` has a row for `installationId`
- *     (App-mode multi-tenant — primary path)
- *   - mapped tenant_id when `installation` is absent, `repository.full_name`
- *     matches a `github_repositories` row (PAT-mode multi-tenant)
- *   - the deployment's HIPPO_TENANT fallback (or 'default') when BOTH routing
- *     tables are empty (single-tenant deployment — env fallback is safe)
- *   - null when:
- *       - `installationId` is present but unknown AND `github_installations`
- *         is non-empty (multi-tenant install with foreign installation)
- *       - `installationId` is missing AND either routing table is non-empty
- *         AND no `repository.full_name` match (PAT-mode webhook from a foreign
- *         account)
- *
- * Escape hatch: `GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1` restores the
- * env fallback for emergency rollback only. Mirrors the Slack equivalent
- * (`SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK`).
- *
- * The fail-closed contract lives here so every caller (route handler, CLI
- * replay, future MCP) gets identical protection.
- */
-export function resolveTenantForGitHub(db, args) {
+import { envGitHubAllowUnknownInstallationFallback, envTenant } from '../../util/env.js';
+import { requireGroup, storeFor } from '../../store/index.js';
+/** Resolve a GitHub envelope's tenant_id by installation id, then repository.full_name; the HIPPO_TENANT fallback applies only if both tables are empty.
+ *  An unknown installation or repo on a multi-tenant deployment returns null (fail closed); GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1 escapes. */
+export async function resolveTenantForGitHub(hippoRoot, args, store) {
     const envFallback = () => envTenant();
-    const escapeHatch = envGithubAllowUnknownInstallationFallback();
-    // SAFETY: the row comes from the SELECT above, which projects exactly one
-    // column, `c`, as a COUNT(*).
-    const instCount = db
-        .prepare(`SELECT COUNT(*) AS c FROM github_installations`)
-        .get().c;
-    // SAFETY: the row comes from the SELECT above, which projects exactly one
-    // column, `c`, as a COUNT(*).
-    const repoCount = db
-        .prepare(`SELECT COUNT(*) AS c FROM github_repositories`)
-        .get().c;
+    const escapeHatch = envGitHubAllowUnknownInstallationFallback();
+    const routing = await requireGroup(storeFor({ hippoRoot, store }), 'connectorEvents').githubRouting(args);
+    if (routing.tenant)
+        return routing.tenant;
     if (args.installationId) {
-        // SAFETY: the row comes from the SELECT above, which projects exactly
-        // the tenant_id column of github_installations.
-        const row = db
-            .prepare(`SELECT tenant_id FROM github_installations WHERE installation_id = ?`)
-            .get(args.installationId);
-        if (row?.tenant_id)
-            return row.tenant_id;
-        if (Number(instCount) === 0) {
-            // Single-tenant install (table empty); env fallback is safe.
+        // An empty table is a single-tenant install, where the env fallback is safe; else fail closed.
+        if (routing.installations === 0)
             return envFallback();
-        }
-        // Multi-tenant install with unknown installation_id — fail closed.
         return escapeHatch ? envFallback() : null;
     }
-    // No installation.id (PAT-mode webhook).
-    if (Number(instCount) === 0 && Number(repoCount) === 0) {
-        // Single-tenant deployment with no routing tables populated.
+    // No installation.id (PAT-mode webhook) and no routing rows at all: single-tenant deployment.
+    if (routing.installations === 0 && routing.repositories === 0)
         return envFallback();
-    }
-    if (args.repoFullName) {
-        // SAFETY: the row comes from the SELECT above, which projects exactly
-        // the tenant_id column of github_repositories.
-        const row = db
-            .prepare(`SELECT tenant_id FROM github_repositories WHERE repo_full_name = ? ORDER BY added_at, tenant_id LIMIT 1`)
-            .get(args.repoFullName);
-        if (row?.tenant_id)
-            return row.tenant_id;
-    }
     return escapeHatch ? envFallback() : null;
 }
 //# sourceMappingURL=tenant-routing.js.map

package/dist/connectors/github/transform.d.ts

@@ -1,4 +1,4 @@
-import type { RememberOpts } from '../../api.js';
+import type { RememberOpts } from '../../api/index.js';
 import type { GitHubIssueEvent, GitHubIssueCommentEvent, GitHubPullRequestEvent, GitHubPullRequestReviewCommentEvent } from './types.js';
 export declare function issueEventToRememberOpts(evt: GitHubIssueEvent): RememberOpts | null;
 export declare function issueCommentEventToRememberOpts(evt: GitHubIssueCommentEvent): RememberOpts | null;

package/dist/connectors/github/transform.js

@@ -1,20 +1,6 @@
 import { scopeFromRepository } from './scope.js';
-/**
- * Convert GitHub webhook events into RememberOpts for api.remember(). Each
- * function returns null when the event has no usable body so the webhook
- * caller can mark the delivery seen for idempotency and skip the insert.
- *
- * Contract (mirrors src/connectors/slack/transform.ts):
- * - kind is the literal 'raw' (connector boundary, see src/importers.ts).
- * - artifact_ref formats are stable; deletion paths look up by these strings.
- *   - issue:               github://<owner/repo>/issue/<number>
- *   - issue_comment:       github://<owner/repo>/issue/<number>/comment/<id>
- *   - pull_request:        github://<owner/repo>/pull/<number>
- *   - pr_review_comment:   github://<owner/repo>/pull/<number>/review_comment/<id>
- * - owner is `user:github:<login>`. Required by the provenance gate.
- * - scope is derived from repository.private via scopeFromRepository (default
- *   private when undetermined).
- */
+/** Convert GitHub webhook events into RememberOpts; each returns null when the event has no usable body so the caller marks it seen and skips the insert.
+ *  artifact_ref formats (github://<owner/repo>/issue|pull/<n>[/comment|review_comment/<id>]) are stable because deletion looks rows up by them. */
 const UNKNOWN_REPO = 'unknown/unknown';
 export function issueEventToRememberOpts(evt) {
     const body = evt.issue.body?.trim();

package/dist/connectors/github/types.d.ts

@@ -1,19 +1,7 @@
-/**
- * GitHub webhook event shapes used by the ingestion connector.
- * Spec: https://docs.github.com/en/webhooks/webhook-events-and-payloads
- *
- * V1 cares about four event types: issues, issue_comment, pull_request,
- * pull_request_review_comment. Each guard is gated on the X-GitHub-Event
- * header value so a malicious or misrouted payload cannot satisfy a guard
- * for the wrong event type.
- */
-import { type JsonValue } from '../../json.js';
-/**
- * `private` MUST be optional, not required. The Slack-style
- * fail-safe in scope.ts requires an envelope with `private: undefined` to
- * map to private; a strict boolean type would reject the payload before
- * scope can fail closed.
- */
+/** GitHub webhook event shapes for the ingestion connector (https://docs.github.com/en/webhooks/webhook-events-and-payloads).
+ *  Each guard is gated on the X-GitHub-Event header so a misrouted payload cannot satisfy a guard for the wrong event type. */
+import { type JsonValue } from '../../util/json.js';
+/** `private` MUST stay optional: scope.ts maps `private: undefined` to private, and a strict boolean would reject the payload before scope can fail closed. */
 export interface GitHubRepository {
     full_name: string;
     private?: boolean;

package/dist/connectors/github/types.js

@@ -1,39 +1,29 @@
-/**
- * GitHub webhook event shapes used by the ingestion connector.
- * Spec: https://docs.github.com/en/webhooks/webhook-events-and-payloads
- *
- * V1 cares about four event types: issues, issue_comment, pull_request,
- * pull_request_review_comment. Each guard is gated on the X-GitHub-Event
- * header value so a malicious or misrouted payload cannot satisfy a guard
- * for the wrong event type.
- */
-import { isJsonString } from '../../json.js';
-function isJsonObject(x) {
+/** GitHub webhook event shapes for the ingestion connector (https://docs.github.com/en/webhooks/webhook-events-and-payloads).
+ *  Each guard is gated on the X-GitHub-Event header so a misrouted payload cannot satisfy a guard for the wrong event type. */
+import { isJsonString, isJsonNumber } from '../../util/json.js';
+function isObjectOrArray(x) {
     return x !== null && typeof x === 'object';
 }
-function isJsonNumber(x) {
-    return typeof x === 'number';
-}
 function isGitHubSender(x) {
-    if (!isJsonObject(x))
+    if (!isObjectOrArray(x))
         return false;
     return isJsonString(x.login) && isJsonNumber(x.id);
 }
 export function isGitHubWebhookEnvelope(x) {
-    if (!isJsonObject(x))
+    if (!isObjectOrArray(x))
         return false;
     // Duck-type: an envelope must at least carry an action OR a repository field.
-    return isJsonString(x.action) || isJsonObject(x.repository);
+    return isJsonString(x.action) || isObjectOrArray(x.repository);
 }
 export function isGitHubIssueEvent(x, evtHeader) {
     if (evtHeader !== 'issues')
         return false;
-    if (!isJsonObject(x))
+    if (!isObjectOrArray(x))
         return false;
     if (!isJsonString(x.action))
         return false;
     const issue = x.issue;
-    if (!isJsonObject(issue))
+    if (!isObjectOrArray(issue))
         return false;
     if (!isJsonNumber(issue.number))
         return false;
@@ -44,15 +34,15 @@ export function isGitHubIssueEvent(x, evtHeader) {
 export function isGitHubIssueCommentEvent(x, evtHeader) {
     if (evtHeader !== 'issue_comment')
         return false;
-    if (!isJsonObject(x))
+    if (!isObjectOrArray(x))
         return false;
     if (!isJsonString(x.action))
         return false;
     const issue = x.issue;
-    if (!isJsonObject(issue) || !isJsonNumber(issue.number))
+    if (!isObjectOrArray(issue) || !isJsonNumber(issue.number))
         return false;
     const comment = x.comment;
-    if (!isJsonObject(comment))
+    if (!isObjectOrArray(comment))
         return false;
     if (!isJsonNumber(comment.id))
         return false;
@@ -63,12 +53,12 @@ export function isGitHubIssueCommentEvent(x, evtHeader) {
 export function isGitHubPullRequestEvent(x, evtHeader) {
     if (evtHeader !== 'pull_request')
         return false;
-    if (!isJsonObject(x))
+    if (!isObjectOrArray(x))
         return false;
     if (!isJsonString(x.action))
         return false;
     const pr = x.pull_request;
-    if (!isJsonObject(pr))
+    if (!isObjectOrArray(pr))
         return false;
     if (!isJsonNumber(pr.number))
         return false;
@@ -79,15 +69,15 @@ export function isGitHubPullRequestEvent(x, evtHeader) {
 export function isGitHubPullRequestReviewCommentEvent(x, evtHeader) {
     if (evtHeader !== 'pull_request_review_comment')
         return false;
-    if (!isJsonObject(x))
+    if (!isObjectOrArray(x))
         return false;
     if (!isJsonString(x.action))
         return false;
     const pr = x.pull_request;
-    if (!isJsonObject(pr) || !isJsonNumber(pr.number))
+    if (!isObjectOrArray(pr) || !isJsonNumber(pr.number))
         return false;
     const comment = x.comment;
-    if (!isJsonObject(comment))
+    if (!isObjectOrArray(comment))
         return false;
     if (!isJsonNumber(comment.id))
         return false;

package/dist/connectors/github/webhook.d.ts

@@ -1,19 +1,6 @@
-import { type WebhookRequest } from '../../http-util.js';
-/**
- * GitHub webhook receiver. Mirrors the Slack route shape but with
- * GitHub-specific idioms:
- *   1. HMAC SHA-256 over the raw body (X-Hub-Signature-256), no timestamp.
- *   2. Event type discriminated by the X-GitHub-Event header (not body.type).
- *   3. X-GitHub-Delivery is required audit metadata (NOT the dedupe seam - see
- *      computeIdempotencyKey, which folds the signed body into the key so a
- *      replayed body with a fresh delivery UUID still dedupes).
- *   4. Tenant resolved by installation.id → github_installations, then by
- *      repository.full_name → github_repositories (PAT-mode multi-tenant).
- *   5. ALWAYS ACK 200 on signed envelopes (DLQ included). 401 only on bad
- *      signature; 404 only when GITHUB_WEBHOOK_SECRET is unset (don't expose
- *      the route's existence on builds where it's gated off).
- *
- * Bearer auth is skipped on purpose: server.ts checks isPublicRoute before calling this.
- */
-export declare function handleGitHubEventsWebhook({ req, res, opts }: WebhookRequest): Promise<void>;
+import type { HippoStore } from '../../store/index.js';
+import { type WebhookRequest } from '../../util/http-util.js';
+/** GitHub webhook receiver: HMAC SHA-256 over the raw body, event type from the X-GitHub-Event header, tenant by installation.id then repository.full_name.
+ *  ACKs 200 on signed envelopes (DLQ too); 401 only on a bad signature; 404 when GITHUB_WEBHOOK_SECRET is unset. No Bearer: server.ts checks isPublicRoute. */
+export declare function handleGitHubEventsWebhook(request: WebhookRequest, store?: HippoStore): Promise<void>;
 //# sourceMappingURL=webhook.d.ts.map