@spinabot/brigade 1.0.1 → 1.0.2

package/convex/blobs.d.ts

@@ -0,0 +1,38 @@
+export declare const generateUploadUrl: import("convex/server").RegisteredMutation<"public", {
+    sha256: string;
+    ownerId: string;
+}, Promise<{
+    uploadUrl: string;
+    storageId: string | null;
+    existed: boolean;
+    ownerId: string;
+}>>;
+export declare const recordUpload: import("convex/server").RegisteredMutation<"public", {
+    contentType?: string | undefined;
+    sha256: string;
+    size: number;
+    ownerId: string;
+    storageId: import("convex/values").GenericId<"_storage">;
+}, Promise<{
+    existed: boolean;
+}>>;
+export declare const getMeta: import("convex/server").RegisteredQuery<"public", {
+    sha256: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"brigadeBlobs">;
+    _creationTime: number;
+    sha256: string;
+    size: number;
+    ownerId: string;
+    storageId: import("convex/values").GenericId<"_storage">;
+    mime: string;
+    refcount: number;
+    lastTouchedAt: number;
+} | null>>;
+export declare const getDownloadUrl: import("convex/server").RegisteredQuery<"public", {
+    sha256: string;
+}, Promise<string | null>>;
+export declare const remove: import("convex/server").RegisteredMutation<"public", {
+    sha256: string;
+}, Promise<boolean>>;
+//# sourceMappingURL=blobs.d.ts.map

package/convex/blobs.ts

@@ -0,0 +1,115 @@
+// convex/blobs.ts — content-addressed bytes via Convex File Storage.
+//
+// Public surface:
+//   generateUploadUrl(sha256)  — operator-facing one-time URL (client PUTs bytes)
+//   recordUpload(sha256, storageId, contentType?, size?)
+//   getUrl(sha256)             — short-lived signed URL for download
+//   delete(sha256)             — remove blob + storage row
+//
+// `brigadeBlobs` is the metadata side; the actual byte storage lives in
+// Convex's `_storage` table managed by `storage.generateUploadUrl` and
+// `storage.getUrl`.
+
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+export const generateUploadUrl = mutation({
+	args: { ownerId: v.string(), sha256: v.string() },
+	handler: async (ctx, args) => {
+		// Brief OCC: if this sha already has a row, hand back the existing
+		// upload URL so re-uploaders don't get a fresh storageId.
+		const existing = await ctx.db
+			.query("brigadeBlobs")
+			.withIndex("by_sha256", (q) => q.eq("sha256", args.sha256))
+			.first();
+		if (existing) {
+			return {
+				uploadUrl: await ctx.storage.generateUploadUrl(),
+				storageId: existing.storageId,
+				existed: true,
+				ownerId: args.ownerId,
+			};
+		}
+		return {
+			uploadUrl: await ctx.storage.generateUploadUrl(),
+			storageId: null as string | null,
+			existed: false,
+			ownerId: args.ownerId,
+		};
+	},
+});
+
+export const recordUpload = mutation({
+	args: {
+		ownerId: v.string(),
+		sha256: v.string(),
+		storageId: v.id("_storage"),
+		contentType: v.optional(v.string()),
+		size: v.number(),
+	},
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("brigadeBlobs")
+			.withIndex("by_sha256", (q) => q.eq("sha256", args.sha256))
+			.first();
+		if (existing) {
+			await ctx.db.patch(existing._id, {
+				refcount: (existing.refcount as number ?? 0) + 1,
+				lastTouchedAt: Date.now(),
+			});
+			return { existed: true };
+		}
+		await ctx.db.insert("brigadeBlobs", {
+			ownerId: args.ownerId,
+			sha256: args.sha256,
+			storageId: args.storageId,
+			mime: args.contentType ?? "application/octet-stream",
+			size: args.size,
+			refcount: 1,
+			lastTouchedAt: Date.now(),
+		});
+		return { existed: false };
+	},
+});
+
+export const getMeta = query({
+	args: { sha256: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("brigadeBlobs")
+			.withIndex("by_sha256", (q) => q.eq("sha256", args.sha256))
+			.first();
+	},
+});
+
+export const getDownloadUrl = query({
+	args: { sha256: v.string() },
+	handler: async (ctx, args) => {
+		const row = await ctx.db
+			.query("brigadeBlobs")
+			.withIndex("by_sha256", (q) => q.eq("sha256", args.sha256))
+			.first();
+		if (!row) return null;
+		return ctx.storage.getUrl(row.storageId);
+	},
+});
+
+export const remove = mutation({
+	args: { sha256: v.string() },
+	handler: async (ctx, args) => {
+		const row = await ctx.db
+			.query("brigadeBlobs")
+			.withIndex("by_sha256", (q) => q.eq("sha256", args.sha256))
+			.first();
+		if (!row) return false;
+		// Decrement refcount; only delete when zero.
+		const next = (row.refcount as number ?? 1) - 1;
+		if (next > 0) {
+			await ctx.db.patch(row._id, { refcount: next, lastTouchedAt: Date.now() });
+			return false;
+		}
+		await ctx.storage.delete(row.storageId);
+		await ctx.db.delete(row._id);
+		return true;
+	},
+});

package/convex/channels.d.ts

@@ -0,0 +1,150 @@
+export declare const listAccess: import("convex/server").RegisteredQuery<"public", {
+    accountId: string;
+    kind: "allow-from" | "group-allow-from" | "pairing";
+    channelId: string;
+    ownerId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"channelAccess">;
+    _creationTime: number;
+    code?: ArrayBuffer | undefined;
+    senderName?: string | undefined;
+    createdAt?: number | undefined;
+    lastSeenAt?: number | undefined;
+    accountId: string;
+    kind: "allow-from" | "group-allow-from" | "pairing";
+    channelId: string;
+    ownerId: string;
+    senderId: ArrayBuffer;
+}[]>>;
+/** Every access row for the owner — single-operator scale keeps this tiny.
+ *  Boot hydration uses it to fill the in-process access cache in one query
+ *  instead of guessing the channel/account layout from config. */
+export declare const listAllAccess: import("convex/server").RegisteredQuery<"public", {
+    ownerId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"channelAccess">;
+    _creationTime: number;
+    code?: ArrayBuffer | undefined;
+    senderName?: string | undefined;
+    createdAt?: number | undefined;
+    lastSeenAt?: number | undefined;
+    accountId: string;
+    kind: "allow-from" | "group-allow-from" | "pairing";
+    channelId: string;
+    ownerId: string;
+    senderId: ArrayBuffer;
+}[]>>;
+/** Replace the row set for one (channel, account, kind) in a single
+ *  transaction — the convex-mode realisation of the filesystem's
+ *  whole-file atomic write. Caller-supplied codes/timestamps are
+ *  authoritative so locally-generated pairing codes survive verbatim. */
+export declare const reconcileAccess: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    kind: "allow-from" | "group-allow-from" | "pairing";
+    channelId: string;
+    ownerId: string;
+    rows: {
+        code?: ArrayBuffer | undefined;
+        senderName?: string | undefined;
+        createdAt: number;
+        senderId: ArrayBuffer;
+        lastSeenAt: number;
+    }[];
+}, Promise<{
+    count: number;
+}>>;
+export declare const upsertAccess: import("convex/server").RegisteredMutation<"public", {
+    code?: ArrayBuffer | undefined;
+    senderName?: string | undefined;
+    accountId: string;
+    kind: "allow-from" | "group-allow-from" | "pairing";
+    channelId: string;
+    ownerId: string;
+    senderId: ArrayBuffer;
+}, Promise<{
+    changed: boolean;
+}>>;
+export declare const removeAccess: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    kind: "allow-from" | "group-allow-from" | "pairing";
+    channelId: string;
+    ownerId: string;
+    senderId: ArrayBuffer;
+}, Promise<boolean>>;
+export declare const eraseAccount: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    channelId: string;
+    ownerId: string;
+}, Promise<void>>;
+export declare const upsertPairingRequest: import("convex/server").RegisteredMutation<"public", {
+    senderName?: string | undefined;
+    accountId: string;
+    channelId: string;
+    ownerId: string;
+    senderId: ArrayBuffer;
+}, Promise<{
+    code: string;
+    isNew: boolean;
+}>>;
+export declare const approvePairing: import("convex/server").RegisteredMutation<"public", {
+    code: string;
+    accountId: string;
+    channelId: string;
+    ownerId: string;
+}, Promise<{
+    code: string;
+    senderId: string;
+    senderName: string | null;
+} | null>>;
+export declare const revokePairing: import("convex/server").RegisteredMutation<"public", {
+    code: string;
+    accountId: string;
+    channelId: string;
+    ownerId: string;
+}, Promise<boolean>>;
+export declare const generateMediaUploadUrl: import("convex/server").RegisteredMutation<"public", {}, Promise<string>>;
+export declare const recordMediaBlob: import("convex/server").RegisteredMutation<"public", {
+    fileName?: string | undefined;
+    accountId: string;
+    channelId: string;
+    mimeType: string;
+    bytes: number;
+    index: number;
+    ownerId: string;
+    messageId: string;
+    storageId: import("convex/values").GenericId<"_storage">;
+}, Promise<{
+    ok: boolean;
+}>>;
+export declare const getMediaBlobUrl: import("convex/server").RegisteredQuery<"public", {
+    accountId: string;
+    channelId: string;
+    index: number;
+    ownerId: string;
+    messageId: string;
+}, Promise<{
+    url: string;
+    mimeType: string;
+    bytes: number;
+} | null>>;
+export declare const writeAuthFile: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    ownerId: string;
+    fileKey: string;
+    contentB64: ArrayBuffer;
+}, Promise<void>>;
+export declare const readAuthFile: import("convex/server").RegisteredQuery<"public", {
+    accountId: string;
+    ownerId: string;
+    fileKey: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"whatsappAuthFile">;
+    _creationTime: number;
+    accountId: string;
+    ownerId: string;
+    updatedAt: number;
+    fileKey: string;
+    contentB64: ArrayBuffer;
+    contentVersion: number;
+} | null>>;
+//# sourceMappingURL=channels.d.ts.map