@spinabot/brigade 1.0.1 → 1.0.2

package/convex/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  /* TypeScript project config for the Convex functions directory. The convex
+   * CLI's deploy-time "Running TypeScript..." step compiles this folder; with
+   * NO tsconfig here it ran in an emitting mode and planted compiled .js/.map
+   * files next to the sources — which the NEXT deploy's bundler picked up as
+   * duplicate entry points ("Two output files share the same path"), making
+   * every successful push break the following one. `noEmit` is the fix; the
+   * rest mirrors Convex's standard template for the function runtime.
+   */
+  "compilerOptions": {
+    "allowJs": true,
+    "strict": true,
+    "target": "ESNext",
+    "lib": ["ES2021", "dom"],
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["./**/*"]
+}

package/convex/whatsappAuth.d.ts

@@ -0,0 +1,52 @@
+/** Pre-hydrate the whole keystore in one query — Baileys reads keys inside
+ *  the Signal decrypt path, so the adapter serves them from an in-process
+ *  cache filled here at connect time. Oversized values come back as a
+ *  download URL instead of inline bytes. */
+export declare const loadAll: import("convex/server").RegisteredQuery<"public", {
+    accountId: string;
+    ownerId: string;
+}, Promise<{
+    creds: ArrayBuffer | null;
+    keys: ({
+        keyType: string;
+        keyId: string;
+        url: string | null;
+        payload?: undefined;
+    } | {
+        keyType: string;
+        keyId: string;
+        payload: ArrayBuffer | undefined;
+        url?: undefined;
+    })[];
+}>>;
+export declare const writeCreds: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    payload: ArrayBuffer;
+    ownerId: string;
+}, Promise<{
+    updated: boolean;
+}>>;
+/** Batched key upserts + deletes in one transaction — mirrors Baileys'
+ *  transaction batching (addTransactionCapability flushes whole
+ *  SignalDataSets). An entry with neither payload nor storageId is a
+ *  DELETE (Baileys sets null to remove keys). */
+export declare const writeKeys: import("convex/server").RegisteredMutation<"public", {
+    entries: {
+        payload?: ArrayBuffer | undefined;
+        storageId?: import("convex/values").GenericId<"_storage"> | undefined;
+        keyType: string;
+        keyId: string;
+    }[];
+    accountId: string;
+    ownerId: string;
+}, Promise<{
+    count: number;
+}>>;
+/** Wipe an account's auth state entirely (logout / unlink). */
+export declare const clearAccount: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    ownerId: string;
+}, Promise<{
+    removedKeys: number;
+}>>;
+//# sourceMappingURL=whatsappAuth.d.ts.map

package/convex/whatsappAuth.ts

@@ -0,0 +1,151 @@
+// convex/whatsappAuth.ts — Baileys AuthenticationState backing tables.
+//
+// The convex-mode replacement for useMultiFileAuthState's ~900-file auth
+// dir. creds = one sealed blob; keys = one row per (keyType, keyId) with a
+// File Storage spill for oversized values (LTHashState). All payloads are
+// sealed client-side — this module never sees plaintext key material.
+
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+/** Pre-hydrate the whole keystore in one query — Baileys reads keys inside
+ *  the Signal decrypt path, so the adapter serves them from an in-process
+ *  cache filled here at connect time. Oversized values come back as a
+ *  download URL instead of inline bytes. */
+export const loadAll = query({
+	args: { ownerId: v.string(), accountId: v.string() },
+	handler: async (ctx, args) => {
+		const credsRow = await ctx.db
+			.query("whatsappAuthCreds")
+			.withIndex("by_owner_account", (q) =>
+				q.eq("ownerId", args.ownerId).eq("accountId", args.accountId),
+			)
+			.first();
+		const keyRows = await ctx.db
+			.query("whatsappAuthKeys")
+			.withIndex("by_owner_account", (q) =>
+				q.eq("ownerId", args.ownerId).eq("accountId", args.accountId),
+			)
+			.collect();
+		const keys = [];
+		for (const row of keyRows) {
+			if (row.storageId) {
+				const url = await ctx.storage.getUrl(row.storageId);
+				keys.push({ keyType: row.keyType, keyId: row.keyId, url });
+			} else {
+				keys.push({ keyType: row.keyType, keyId: row.keyId, payload: row.payload });
+			}
+		}
+		return { creds: credsRow?.payload ?? null, keys };
+	},
+});
+
+export const writeCreds = mutation({
+	args: { ownerId: v.string(), accountId: v.string(), payload: v.bytes() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("whatsappAuthCreds")
+			.withIndex("by_owner_account", (q) =>
+				q.eq("ownerId", args.ownerId).eq("accountId", args.accountId),
+			)
+			.first();
+		const row = { ...args, updatedAt: Date.now() };
+		if (existing) {
+			await ctx.db.replace(existing._id, row);
+			return { updated: true };
+		}
+		await ctx.db.insert("whatsappAuthCreds", row);
+		return { updated: false };
+	},
+});
+
+/** Batched key upserts + deletes in one transaction — mirrors Baileys'
+ *  transaction batching (addTransactionCapability flushes whole
+ *  SignalDataSets). An entry with neither payload nor storageId is a
+ *  DELETE (Baileys sets null to remove keys). */
+export const writeKeys = mutation({
+	args: {
+		ownerId: v.string(),
+		accountId: v.string(),
+		entries: v.array(
+			v.object({
+				keyType: v.string(),
+				keyId: v.string(),
+				payload: v.optional(v.bytes()),
+				storageId: v.optional(v.id("_storage")),
+			}),
+		),
+	},
+	handler: async (ctx, args) => {
+		for (const entry of args.entries) {
+			const existing = await ctx.db
+				.query("whatsappAuthKeys")
+				.withIndex("by_owner_account_type_id", (q) =>
+					q
+						.eq("ownerId", args.ownerId)
+						.eq("accountId", args.accountId)
+						.eq("keyType", entry.keyType)
+						.eq("keyId", entry.keyId),
+				)
+				.first();
+			const isDelete = entry.payload === undefined && entry.storageId === undefined;
+			if (isDelete) {
+				if (existing) {
+					// Reap the spilled File Storage blob first — deleting only the
+					// row would orphan the object (storage isn't ref-counted).
+					if (existing.storageId) await ctx.storage.delete(existing.storageId);
+					await ctx.db.delete(existing._id);
+				}
+				continue;
+			}
+			const row = {
+				ownerId: args.ownerId,
+				accountId: args.accountId,
+				keyType: entry.keyType,
+				keyId: entry.keyId,
+				...(entry.payload !== undefined ? { payload: entry.payload } : {}),
+				...(entry.storageId !== undefined ? { storageId: entry.storageId } : {}),
+				updatedAt: Date.now(),
+			};
+			if (existing) {
+				// If the prior value spilled to File Storage and the new value
+				// doesn't reuse the same object, delete the old blob to avoid an
+				// orphan (overwrite with inline payload, or a fresh spill).
+				if (existing.storageId && existing.storageId !== entry.storageId) {
+					await ctx.storage.delete(existing.storageId);
+				}
+				await ctx.db.replace(existing._id, row);
+			} else {
+				await ctx.db.insert("whatsappAuthKeys", row);
+			}
+		}
+		return { count: args.entries.length };
+	},
+});
+
+/** Wipe an account's auth state entirely (logout / unlink). */
+export const clearAccount = mutation({
+	args: { ownerId: v.string(), accountId: v.string() },
+	handler: async (ctx, args) => {
+		const credsRow = await ctx.db
+			.query("whatsappAuthCreds")
+			.withIndex("by_owner_account", (q) =>
+				q.eq("ownerId", args.ownerId).eq("accountId", args.accountId),
+			)
+			.first();
+		if (credsRow) await ctx.db.delete(credsRow._id);
+		const keyRows = await ctx.db
+			.query("whatsappAuthKeys")
+			.withIndex("by_owner_account", (q) =>
+				q.eq("ownerId", args.ownerId).eq("accountId", args.accountId),
+			)
+			.collect();
+		for (const row of keyRows) {
+			// Reap any spilled File Storage blob before dropping the row so an
+			// unlink/logout leaves nothing behind in storage.
+			if (row.storageId) await ctx.storage.delete(row.storageId);
+			await ctx.db.delete(row._id);
+		}
+		return { removedKeys: keyRows.length };
+	},
+});

package/convex/workspace.d.ts

@@ -0,0 +1,49 @@
+export declare const listPersona: import("convex/server").RegisteredQuery<"public", {
+    agentId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"personaFiles">;
+    _creationTime: number;
+    agentId: string;
+    name: "AGENTS.md" | "SOUL.md" | "IDENTITY.md" | "USER.md" | "TOOLS.md" | "BOOTSTRAP.md" | "MEMORY.md" | "HEARTBEAT.md";
+    content: ArrayBuffer;
+    updatedAt: number;
+}[]>>;
+export declare const getPersona: import("convex/server").RegisteredQuery<"public", {
+    agentId: string;
+    name: "AGENTS.md" | "SOUL.md" | "IDENTITY.md" | "USER.md" | "TOOLS.md" | "BOOTSTRAP.md" | "MEMORY.md" | "HEARTBEAT.md";
+}, Promise<{
+    _id: import("convex/values").GenericId<"personaFiles">;
+    _creationTime: number;
+    agentId: string;
+    name: "AGENTS.md" | "SOUL.md" | "IDENTITY.md" | "USER.md" | "TOOLS.md" | "BOOTSTRAP.md" | "MEMORY.md" | "HEARTBEAT.md";
+    content: ArrayBuffer;
+    updatedAt: number;
+} | null>>;
+export declare const writePersona: import("convex/server").RegisteredMutation<"public", {
+    agentId: string;
+    name: "AGENTS.md" | "SOUL.md" | "IDENTITY.md" | "USER.md" | "TOOLS.md" | "BOOTSTRAP.md" | "MEMORY.md" | "HEARTBEAT.md";
+    content: ArrayBuffer;
+}, Promise<{
+    created: boolean;
+}>>;
+export declare const deletePersona: import("convex/server").RegisteredMutation<"public", {
+    agentId: string;
+    name: "AGENTS.md" | "SOUL.md" | "IDENTITY.md" | "USER.md" | "TOOLS.md" | "BOOTSTRAP.md" | "MEMORY.md" | "HEARTBEAT.md";
+}, Promise<boolean>>;
+export declare const getState: import("convex/server").RegisteredQuery<"public", {
+    agentId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"workspaceState">;
+    _creationTime: number;
+    bootstrapSeededAt?: string | undefined;
+    setupCompletedAt?: string | undefined;
+    version: number;
+    agentId: string;
+} | null>>;
+export declare const setBootstrapSeeded: import("convex/server").RegisteredMutation<"public", {
+    agentId: string;
+}, Promise<void>>;
+export declare const setSetupCompleted: import("convex/server").RegisteredMutation<"public", {
+    agentId: string;
+}, Promise<void>>;
+//# sourceMappingURL=workspace.d.ts.map

package/convex/workspace.ts

@@ -0,0 +1,106 @@
+// convex/workspace.ts — personaFiles + workspaceState
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+const PersonaName = v.union(
+	v.literal("AGENTS.md"),
+	v.literal("SOUL.md"),
+	v.literal("IDENTITY.md"),
+	v.literal("USER.md"),
+	v.literal("TOOLS.md"),
+	v.literal("BOOTSTRAP.md"),
+	v.literal("MEMORY.md"),
+	v.literal("HEARTBEAT.md"),
+);
+
+export const listPersona = query({
+	args: { agentId: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("personaFiles")
+			.withIndex("by_agent", (q) => q.eq("agentId", args.agentId))
+			.collect();
+	},
+});
+
+export const getPersona = query({
+	args: { agentId: v.string(), name: PersonaName },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("personaFiles")
+			.withIndex("by_agent_name", (q) => q.eq("agentId", args.agentId).eq("name", args.name))
+			.first();
+	},
+});
+
+export const writePersona = mutation({
+	args: { agentId: v.string(), name: PersonaName, content: v.bytes() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("personaFiles")
+			.withIndex("by_agent_name", (q) => q.eq("agentId", args.agentId).eq("name", args.name))
+			.first();
+		const payload = { agentId: args.agentId, name: args.name, content: args.content, updatedAt: Date.now() };
+		if (existing) {
+			await ctx.db.replace(existing._id, payload);
+			return { created: false };
+		}
+		await ctx.db.insert("personaFiles", payload);
+		return { created: true };
+	},
+});
+
+export const deletePersona = mutation({
+	args: { agentId: v.string(), name: PersonaName },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("personaFiles")
+			.withIndex("by_agent_name", (q) => q.eq("agentId", args.agentId).eq("name", args.name))
+			.first();
+		if (!existing) return false;
+		await ctx.db.delete(existing._id);
+		return true;
+	},
+});
+
+export const getState = query({
+	args: { agentId: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("workspaceState")
+			.withIndex("by_agent", (q) => q.eq("agentId", args.agentId))
+			.first();
+	},
+});
+
+export const setBootstrapSeeded = mutation({
+	args: { agentId: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("workspaceState")
+			.withIndex("by_agent", (q) => q.eq("agentId", args.agentId))
+			.first();
+		const now = new Date().toISOString();
+		if (existing) {
+			await ctx.db.patch(existing._id, { bootstrapSeededAt: now });
+		} else {
+			await ctx.db.insert("workspaceState", { agentId: args.agentId, version: 1, bootstrapSeededAt: now });
+		}
+	},
+});
+
+export const setSetupCompleted = mutation({
+	args: { agentId: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("workspaceState")
+			.withIndex("by_agent", (q) => q.eq("agentId", args.agentId))
+			.first();
+		const now = new Date().toISOString();
+		if (existing) {
+			await ctx.db.patch(existing._id, { setupCompletedAt: now });
+		} else {
+			await ctx.db.insert("workspaceState", { agentId: args.agentId, version: 1, setupCompletedAt: now });
+		}
+	},
+});

package/dist/buildstamp.json

@@ -1 +1 @@
-{"builtAt":1782022440571,"head":"b5f7612e37790cd56e8e24183b9348aac8dbe122"}
+{"builtAt":1782023379616,"head":"61cbf9e328c11cd48b152ce27039e857cffbc271"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spinabot/brigade",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Brigade — your personal AI crew",
   "homepage": "https://brigade-agent.ai",
   "author": "Spinabot",
@@ -32,9 +32,15 @@
     "brigade.mjs",
     "scripts/run-brigade.mjs",
     "scripts/build-done.mjs",
+    "scripts/install-convex.mjs",
+    "scripts/convex-dev.mjs",
+    "scripts/convex-push.mjs",
     "dist/**/*",
     "templates/**/*",
     "skills/**/*",
+    "convex/**/*.ts",
+    "convex/_generated/**",
+    "convex/tsconfig.json",
     "README.md",
     "LICENSE"
   ],