agent-relay 1.3.2 → 1.5.0

package/dist/cloud/db/bulk-ingest.d.ts

@@ -12,7 +12,7 @@
  * - Chunk processing for memory efficiency
  */
 import { Pool } from 'pg';
-import type { NewAgentMessage } from './schema.js';
+type NewAgentMessage = Record<string, unknown>;
 export interface PoolConfig {
     connectionString: string;
     /** Maximum number of connections in pool (default: 20) */
@@ -85,4 +85,5 @@ export declare function checkPoolHealth(pool: Pool): Promise<{
     latencyMs: number;
     error?: string;
 }>;
+export {};
 //# sourceMappingURL=bulk-ingest.d.ts.map

package/dist/cloud/db/drizzle.d.ts

@@ -116,7 +116,6 @@ export interface LinkedDaemonQueries {
     delete(id: string): Promise<void>;
     markStale(): Promise<number>;
     getAllAgentsForUser(userId: string): Promise<DaemonAgentInfo[]>;
-    getAgentsForWorkspace(workspaceId: string): Promise<DaemonAgentInfo[]>;
     getPendingUpdates(id: string): Promise<DaemonUpdate[]>;
     queueUpdate(id: string, update: DaemonUpdate): Promise<void>;
     queueMessage(id: string, message: Record<string, unknown>): Promise<void>;
@@ -221,31 +220,27 @@ export interface CommentMentionQueries {
     markIgnored(id: string): Promise<void>;
 }
 export declare const commentMentionQueries: CommentMentionQueries;
-export interface MessageQuery {
-    workspaceId: string;
-    limit?: number;
-    offset?: number;
-    fromAgent?: string;
-    toAgent?: string;
-    thread?: string;
-    channel?: string;
-    sinceTs?: Date;
-    beforeTs?: Date;
-    includeExpired?: boolean;
-}
-export interface AgentMessageQueries {
-    create(data: schema.NewAgentMessage): Promise<schema.AgentMessage>;
-    createMany(data: schema.NewAgentMessage[]): Promise<schema.AgentMessage[]>;
-    findById(id: string): Promise<schema.AgentMessage | null>;
-    findByOriginalId(workspaceId: string, originalId: string): Promise<schema.AgentMessage | null>;
-    query(params: MessageQuery): Promise<schema.AgentMessage[]>;
-    getUnindexed(workspaceId: string, limit?: number): Promise<schema.AgentMessage[]>;
-    markIndexed(ids: string[]): Promise<void>;
-    deleteExpired(): Promise<number>;
-    countByWorkspace(workspaceId: string): Promise<number>;
-    getThreadMessages(workspaceId: string, thread: string, limit?: number): Promise<schema.AgentMessage[]>;
-}
-export declare const agentMessageQueries: AgentMessageQueries;
+export interface ChannelQueries {
+    findById(id: string): Promise<schema.Channel | null>;
+    findByWorkspaceId(workspaceId: string): Promise<schema.Channel[]>;
+    findByWorkspaceAndChannelId(workspaceId: string, channelId: string): Promise<schema.Channel | null>;
+    create(channel: schema.NewChannel): Promise<schema.Channel>;
+    update(id: string, updates: Partial<schema.NewChannel>): Promise<void>;
+    archive(id: string): Promise<void>;
+    unarchive(id: string): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const channelQueries: ChannelQueries;
+export interface ChannelMemberQueries {
+    findByChannelId(channelId: string): Promise<schema.ChannelMember[]>;
+    findByMemberId(memberId: string): Promise<schema.ChannelMember[]>;
+    findMembership(channelId: string, memberId: string): Promise<schema.ChannelMember | null>;
+    addMember(member: schema.NewChannelMember): Promise<schema.ChannelMember>;
+    removeMember(channelId: string, memberId: string): Promise<void>;
+    updateRole(channelId: string, memberId: string, role: string): Promise<void>;
+    countByChannelIds(channelIds: string[]): Promise<Map<string, number>>;
+}
+export declare const channelMemberQueries: ChannelMemberQueries;
 export declare function runMigrations(): Promise<void>;
 export declare function closeDb(): Promise<void>;
 //# sourceMappingURL=drizzle.d.ts.map

package/dist/cloud/db/drizzle.js

@@ -537,19 +537,6 @@ export const linkedDaemonQueries = {
             agents: d.metadata?.agents || [],
         }));
     },
-    async getAgentsForWorkspace(workspaceId) {
-        const db = getDb();
-        const daemons = await db
-            .select()
-            .from(schema.linkedDaemons)
-            .where(eq(schema.linkedDaemons.workspaceId, workspaceId));
-        return daemons.map((d) => ({
-            daemonId: d.id,
-            daemonName: d.name,
-            machineId: d.machineId,
-            agents: d.metadata?.agents || [],
-        }));
-    },
     async getPendingUpdates(id) {
         const db = getDb();
         const result = await db.select().from(schema.linkedDaemons).where(eq(schema.linkedDaemons.id, id));
@@ -1126,118 +1113,118 @@ export const commentMentionQueries = {
             .where(eq(schema.commentMentions.id, id));
     },
 };
-export const agentMessageQueries = {
-    async create(data) {
+export const channelQueries = {
+    async findById(id) {
         const db = getDb();
-        const result = await db.insert(schema.agentMessages).values(data).returning();
-        return result[0];
+        const result = await db.select().from(schema.channels).where(eq(schema.channels.id, id));
+        return result[0] ?? null;
     },
-    async createMany(data) {
-        if (data.length === 0)
-            return [];
+    async findByWorkspaceId(workspaceId) {
         const db = getDb();
-        const result = await db
-            .insert(schema.agentMessages)
-            .values(data)
-            .onConflictDoNothing() // Skip duplicates based on workspace_original_unique constraint
-            .returning();
-        return result;
+        return db
+            .select()
+            .from(schema.channels)
+            .where(eq(schema.channels.workspaceId, workspaceId))
+            .orderBy(desc(schema.channels.lastActivityAt));
     },
-    async findById(id) {
+    async findByWorkspaceAndChannelId(workspaceId, channelId) {
         const db = getDb();
         const result = await db
             .select()
-            .from(schema.agentMessages)
-            .where(eq(schema.agentMessages.id, id));
+            .from(schema.channels)
+            .where(and(eq(schema.channels.workspaceId, workspaceId), eq(schema.channels.channelId, channelId)));
         return result[0] ?? null;
     },
-    async findByOriginalId(workspaceId, originalId) {
+    async create(channel) {
         const db = getDb();
-        const result = await db
-            .select()
-            .from(schema.agentMessages)
-            .where(and(eq(schema.agentMessages.workspaceId, workspaceId), eq(schema.agentMessages.originalId, originalId)));
-        return result[0] ?? null;
+        const result = await db.insert(schema.channels).values(channel).returning();
+        return result[0];
     },
-    async query(params) {
+    async update(id, updates) {
         const db = getDb();
-        const conditions = [eq(schema.agentMessages.workspaceId, params.workspaceId)];
-        if (params.fromAgent) {
-            conditions.push(eq(schema.agentMessages.fromAgent, params.fromAgent));
-        }
-        if (params.toAgent) {
-            conditions.push(eq(schema.agentMessages.toAgent, params.toAgent));
-        }
-        if (params.thread) {
-            conditions.push(eq(schema.agentMessages.thread, params.thread));
-        }
-        if (params.channel) {
-            conditions.push(eq(schema.agentMessages.channel, params.channel));
-        }
-        if (params.sinceTs) {
-            conditions.push(sql `${schema.agentMessages.messageTs} >= ${params.sinceTs}`);
-        }
-        if (params.beforeTs) {
-            conditions.push(sql `${schema.agentMessages.messageTs} < ${params.beforeTs}`);
-        }
-        if (!params.includeExpired) {
-            conditions.push(sql `(${schema.agentMessages.expiresAt} IS NULL OR ${schema.agentMessages.expiresAt} > NOW())`);
-        }
-        let query = db
-            .select()
-            .from(schema.agentMessages)
-            .where(and(...conditions))
-            .orderBy(desc(schema.agentMessages.messageTs));
-        if (params.limit) {
-            query = query.limit(params.limit);
-        }
-        if (params.offset) {
-            query = query.offset(params.offset);
-        }
-        return query;
+        await db
+            .update(schema.channels)
+            .set({ ...updates, updatedAt: new Date() })
+            .where(eq(schema.channels.id, id));
     },
-    async getUnindexed(workspaceId, limit = 100) {
+    async archive(id) {
         const db = getDb();
-        return db
-            .select()
-            .from(schema.agentMessages)
-            .where(and(eq(schema.agentMessages.workspaceId, workspaceId), isNull(schema.agentMessages.indexedAt), sql `(${schema.agentMessages.expiresAt} IS NULL OR ${schema.agentMessages.expiresAt} > NOW())`))
-            .orderBy(schema.agentMessages.messageTs)
-            .limit(limit);
+        await db
+            .update(schema.channels)
+            .set({ status: 'archived', updatedAt: new Date() })
+            .where(eq(schema.channels.id, id));
     },
-    async markIndexed(ids) {
-        if (ids.length === 0)
-            return;
+    async unarchive(id) {
         const db = getDb();
         await db
-            .update(schema.agentMessages)
-            .set({ indexedAt: new Date() })
-            .where(inArray(schema.agentMessages.id, ids));
+            .update(schema.channels)
+            .set({ status: 'active', updatedAt: new Date() })
+            .where(eq(schema.channels.id, id));
     },
-    async deleteExpired() {
+    async delete(id) {
         const db = getDb();
-        const result = await db
-            .delete(schema.agentMessages)
-            .where(and(isNotNull(schema.agentMessages.expiresAt), lt(schema.agentMessages.expiresAt, new Date())))
-            .returning({ id: schema.agentMessages.id });
-        return result.length;
+        await db.delete(schema.channels).where(eq(schema.channels.id, id));
     },
-    async countByWorkspace(workspaceId) {
+};
+export const channelMemberQueries = {
+    async findByChannelId(channelId) {
         const db = getDb();
-        const result = await db
-            .select({ count: sql `count(*)` })
-            .from(schema.agentMessages)
-            .where(eq(schema.agentMessages.workspaceId, workspaceId));
-        return Number(result[0]?.count ?? 0);
+        return db
+            .select()
+            .from(schema.channelMembers)
+            .where(eq(schema.channelMembers.channelId, channelId));
     },
-    async getThreadMessages(workspaceId, thread, limit = 50) {
+    async findByMemberId(memberId) {
         const db = getDb();
         return db
             .select()
-            .from(schema.agentMessages)
-            .where(and(eq(schema.agentMessages.workspaceId, workspaceId), eq(schema.agentMessages.thread, thread), sql `(${schema.agentMessages.expiresAt} IS NULL OR ${schema.agentMessages.expiresAt} > NOW())`))
-            .orderBy(schema.agentMessages.messageTs)
-            .limit(limit);
+            .from(schema.channelMembers)
+            .where(eq(schema.channelMembers.memberId, memberId));
+    },
+    async findMembership(channelId, memberId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.channelMembers)
+            .where(and(eq(schema.channelMembers.channelId, channelId), eq(schema.channelMembers.memberId, memberId)));
+        return result[0] ?? null;
+    },
+    async addMember(member) {
+        const db = getDb();
+        const result = await db.insert(schema.channelMembers).values(member).returning();
+        return result[0];
+    },
+    async removeMember(channelId, memberId) {
+        const db = getDb();
+        await db
+            .delete(schema.channelMembers)
+            .where(and(eq(schema.channelMembers.channelId, channelId), eq(schema.channelMembers.memberId, memberId)));
+    },
+    async updateRole(channelId, memberId, role) {
+        const db = getDb();
+        await db
+            .update(schema.channelMembers)
+            .set({ role })
+            .where(and(eq(schema.channelMembers.channelId, channelId), eq(schema.channelMembers.memberId, memberId)));
+    },
+    async countByChannelIds(channelIds) {
+        if (channelIds.length === 0) {
+            return new Map();
+        }
+        const db = getDb();
+        const results = await db
+            .select({
+            channelId: schema.channelMembers.channelId,
+            count: sql `count(*)::int`,
+        })
+            .from(schema.channelMembers)
+            .where(inArray(schema.channelMembers.channelId, channelIds))
+            .groupBy(schema.channelMembers.channelId);
+        const countMap = new Map();
+        for (const row of results) {
+            countMap.set(row.channelId, row.count);
+        }
+        return countMap;
     },
 };
 // ============================================================================

package/dist/cloud/db/index.d.ts

@@ -7,9 +7,9 @@
  * Generate migrations: npm run db:generate
  * Run migrations: npm run db:migrate
  */
-export type { User, NewUser, GitHubInstallation, NewGitHubInstallation, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceAgentPolicy, AgentPolicyRule, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, CIAnnotation, CIFailureEvent, NewCIFailureEvent, CIFixAttempt, NewCIFixAttempt, CICheckStrategy, CIWebhookConfig, IssueAssignment, NewIssueAssignment, CommentMention, NewCommentMention, AgentTriggerConfig, AgentMessage, NewAgentMessage, MessagePayloadMeta, } from './schema.js';
-export { users as usersTable, githubInstallations as githubInstallationsTable, credentials as credentialsTable, workspaces as workspacesTable, workspaceMembers as workspaceMembersTable, projectGroups as projectGroupsTable, repositories as repositoriesTable, linkedDaemons as linkedDaemonsTable, subscriptions as subscriptionsTable, usageRecords as usageRecordsTable, ciFailureEvents as ciFailureEventsTable, ciFixAttempts as ciFixAttemptsTable, issueAssignments as issueAssignmentsTable, commentMentions as commentMentionsTable, agentMessages as agentMessagesTable, } from './schema.js';
-import { getDb, closeDb, runMigrations, getRawPool, userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, linkedDaemonQueries, projectGroupQueries, repositoryQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, agentMessageQueries } from './drizzle.js';
+export type { User, NewUser, GitHubInstallation, NewGitHubInstallation, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceAgentPolicy, AgentPolicyRule, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, CIAnnotation, CIFailureEvent, NewCIFailureEvent, CIFixAttempt, NewCIFixAttempt, CICheckStrategy, CIWebhookConfig, IssueAssignment, NewIssueAssignment, CommentMention, NewCommentMention, AgentTriggerConfig, Channel, NewChannel, ChannelMember, NewChannelMember, } from './schema.js';
+export { users as usersTable, githubInstallations as githubInstallationsTable, credentials as credentialsTable, workspaces as workspacesTable, workspaceMembers as workspaceMembersTable, projectGroups as projectGroupsTable, repositories as repositoriesTable, linkedDaemons as linkedDaemonsTable, subscriptions as subscriptionsTable, usageRecords as usageRecordsTable, ciFailureEvents as ciFailureEventsTable, ciFixAttempts as ciFixAttemptsTable, issueAssignments as issueAssignmentsTable, commentMentions as commentMentionsTable, channels as channelsTable, channelMembers as channelMembersTable, } from './schema.js';
+import { getDb, closeDb, runMigrations, getRawPool, userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, linkedDaemonQueries, projectGroupQueries, repositoryQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries } from './drizzle.js';
 import { bulkInsertMessages, streamingBulkInsert, optimizedBulkInsert, getPoolStats, checkPoolHealth, type BulkInsertResult } from './bulk-ingest.js';
 export type PlanType = 'free' | 'pro' | 'team' | 'enterprise';
 export type WorkspaceMemberRole = 'owner' | 'admin' | 'member' | 'viewer';
@@ -26,7 +26,8 @@ export declare const db: {
     ciFixAttempts: import("./drizzle.js").CIFixAttemptQueries;
     issueAssignments: import("./drizzle.js").IssueAssignmentQueries;
     commentMentions: import("./drizzle.js").CommentMentionQueries;
-    agentMessages: import("./drizzle.js").AgentMessageQueries;
+    channels: import("./drizzle.js").ChannelQueries;
+    channelMembers: import("./drizzle.js").ChannelMemberQueries;
     bulk: {
         insertMessages: typeof bulkInsertMessages;
         streamingInsert: typeof streamingBulkInsert;
@@ -47,7 +48,7 @@ export declare const db: {
     close: typeof closeDb;
     runMigrations: typeof runMigrations;
 };
-export { userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, projectGroupQueries, repositoryQueries, linkedDaemonQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, agentMessageQueries, };
+export { userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, projectGroupQueries, repositoryQueries, linkedDaemonQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, };
 export { getDb, closeDb, runMigrations, getRawPool };
 export { bulkInsertMessages, streamingBulkInsert, optimizedBulkInsert, getPoolStats, checkPoolHealth, type BulkInsertResult, };
 export declare function initializeDatabase(): Promise<void>;

package/dist/cloud/db/index.js

@@ -8,10 +8,10 @@
  * Run migrations: npm run db:migrate
  */
 // Re-export schema tables for direct access if needed
-export { users as usersTable, githubInstallations as githubInstallationsTable, credentials as credentialsTable, workspaces as workspacesTable, workspaceMembers as workspaceMembersTable, projectGroups as projectGroupsTable, repositories as repositoriesTable, linkedDaemons as linkedDaemonsTable, subscriptions as subscriptionsTable, usageRecords as usageRecordsTable, ciFailureEvents as ciFailureEventsTable, ciFixAttempts as ciFixAttemptsTable, issueAssignments as issueAssignmentsTable, commentMentions as commentMentionsTable, agentMessages as agentMessagesTable, } from './schema.js';
+export { users as usersTable, githubInstallations as githubInstallationsTable, credentials as credentialsTable, workspaces as workspacesTable, workspaceMembers as workspaceMembersTable, projectGroups as projectGroupsTable, repositories as repositoriesTable, linkedDaemons as linkedDaemonsTable, subscriptions as subscriptionsTable, usageRecords as usageRecordsTable, ciFailureEvents as ciFailureEventsTable, ciFixAttempts as ciFixAttemptsTable, issueAssignments as issueAssignmentsTable, commentMentions as commentMentionsTable, channels as channelsTable, channelMembers as channelMembersTable, } from './schema.js';
 // Import query modules
-import { getDb, closeDb, runMigrations, getRawPool, userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, linkedDaemonQueries, projectGroupQueries, repositoryQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, agentMessageQueries, } from './drizzle.js';
-// Import bulk ingest utilities
+import { getDb, closeDb, runMigrations, getRawPool, userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, linkedDaemonQueries, projectGroupQueries, repositoryQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, channelQueries, channelMemberQueries, } from './drizzle.js';
+// Bulk ingest utilities for high-volume message sync to cloud
 import { bulkInsertMessages, streamingBulkInsert, optimizedBulkInsert, getPoolStats, checkPoolHealth, } from './bulk-ingest.js';
 // Export the db object with all query namespaces
 export const db = {
@@ -37,9 +37,10 @@ export const db = {
     // Issue and comment tracking
     issueAssignments: issueAssignmentQueries,
     commentMentions: commentMentionQueries,
-    // Agent messages (cloud-synced relay messages)
-    agentMessages: agentMessageQueries,
-    // Bulk ingest utilities (optimized high-volume operations)
+    // Channel operations (workspace-scoped messaging)
+    channels: channelQueries,
+    channelMembers: channelMemberQueries,
+    // Bulk ingest utilities for high-volume message sync
     bulk: {
         insertMessages: bulkInsertMessages,
         streamingInsert: streamingBulkInsert,
@@ -54,10 +55,10 @@ export const db = {
     runMigrations,
 };
 // Export query objects for direct import
-export { userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, projectGroupQueries, repositoryQueries, linkedDaemonQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, agentMessageQueries, };
+export { userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, projectGroupQueries, repositoryQueries, linkedDaemonQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, };
 // Export database utilities
 export { getDb, closeDb, runMigrations, getRawPool };
-// Export bulk ingest utilities
+// Bulk ingest utilities for direct import
 export { bulkInsertMessages, streamingBulkInsert, optimizedBulkInsert, getPoolStats, checkPoolHealth, };
 // Legacy function - use runMigrations instead
 export async function initializeDatabase() {