profclaw 2.0.0 → 2.3.0

package/dist/routes/teams.js

@@ -0,0 +1,210 @@
+/**
+ * Teams API Routes
+ *
+ * Multi-user team management with shared cost budgets.
+ * No other OSS AI tool has this.
+ */
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { initTeamsTables, createTeam, getTeam, getTeamBySlug, listUserTeams, updateTeam, deleteTeam, addMember, removeMember, listMembers, updateMemberRole, getTeamUsage, canMemberSpend, createInvite, acceptInvite, listTeamInvites, } from '../teams/index.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('TeamsRoutes');
+const app = new Hono();
+// Lazy init
+let initialized = false;
+app.use('*', async (_c, next) => {
+    if (!initialized) {
+        initialized = true;
+        try {
+            await initTeamsTables();
+        }
+        catch (e) {
+            initialized = false;
+            log.warn('Failed to init teams tables', { error: e.message });
+        }
+    }
+    await next();
+});
+// Schemas
+const createTeamSchema = z.object({
+    name: z.string().min(1).max(50),
+    slug: z.string().min(1).max(50).regex(/^[a-z0-9-]+$/).optional(),
+    description: z.string().max(200).optional(),
+    ownerId: z.string(),
+    monthlyBudget: z.number().min(0).optional(),
+    dailyBudget: z.number().min(0).optional(),
+});
+const updateTeamSchema = z.object({
+    name: z.string().min(1).max(50).optional(),
+    description: z.string().max(200).optional(),
+    monthlyBudgetUsd: z.number().min(0).optional(),
+    dailyBudgetUsd: z.number().min(0).optional(),
+    budgetAlertThresholds: z.array(z.number().min(0).max(100)).optional(),
+    defaultModel: z.string().optional(),
+    preferredProviders: z.array(z.string()).optional(),
+    smartRoutingEnabled: z.boolean().optional(),
+});
+const addMemberSchema = z.object({
+    userId: z.string(),
+    role: z.enum(['admin', 'member', 'viewer']).optional().default('member'),
+});
+const inviteSchema = z.object({
+    email: z.string().email(),
+    role: z.enum(['admin', 'member', 'viewer']).optional().default('member'),
+    invitedBy: z.string(),
+});
+// Routes
+/**
+ * GET /api/teams - List teams for a user
+ */
+app.get('/', async (c) => {
+    const userId = c.req.query('userId');
+    if (!userId)
+        return c.json({ error: 'userId query param required' }, 400);
+    const teams = await listUserTeams(userId);
+    return c.json({ success: true, teams, total: teams.length });
+});
+/**
+ * POST /api/teams - Create a team
+ */
+app.post('/', zValidator('json', createTeamSchema), async (c) => {
+    try {
+        const body = c.req.valid('json');
+        const team = await createTeam(body);
+        return c.json({ success: true, team }, 201);
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+/**
+ * GET /api/teams/:id - Get team details
+ */
+app.get('/:id', async (c) => {
+    const { id } = c.req.param();
+    const team = id.includes('-') ? await getTeam(id) : await getTeamBySlug(id);
+    if (!team)
+        return c.json({ success: false, error: 'Team not found' }, 404);
+    return c.json({ success: true, team });
+});
+/**
+ * PATCH /api/teams/:id - Update team settings
+ */
+app.patch('/:id', zValidator('json', updateTeamSchema), async (c) => {
+    const { id } = c.req.param();
+    const body = c.req.valid('json');
+    const team = await updateTeam(id, body);
+    if (!team)
+        return c.json({ success: false, error: 'Team not found' }, 404);
+    return c.json({ success: true, team });
+});
+/**
+ * DELETE /api/teams/:id - Delete a team
+ */
+app.delete('/:id', async (c) => {
+    const { id } = c.req.param();
+    await deleteTeam(id);
+    return c.json({ success: true, deleted: true });
+});
+// Members
+/**
+ * GET /api/teams/:id/members - List team members
+ */
+app.get('/:id/members', async (c) => {
+    const { id } = c.req.param();
+    const members = await listMembers(id);
+    return c.json({ success: true, members, total: members.length });
+});
+/**
+ * POST /api/teams/:id/members - Add a member
+ */
+app.post('/:id/members', zValidator('json', addMemberSchema), async (c) => {
+    const { id } = c.req.param();
+    const body = c.req.valid('json');
+    try {
+        const member = await addMember(id, body.userId, body.role);
+        return c.json({ success: true, member }, 201);
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+/**
+ * DELETE /api/teams/:id/members/:userId - Remove a member
+ */
+app.delete('/:id/members/:userId', async (c) => {
+    const { id, userId } = c.req.param();
+    await removeMember(id, userId);
+    return c.json({ success: true, removed: true });
+});
+/**
+ * PATCH /api/teams/:id/members/:userId/role - Change member role
+ */
+app.patch('/:id/members/:userId/role', zValidator('json', z.object({
+    role: z.enum(['admin', 'member', 'viewer']),
+})), async (c) => {
+    const { id, userId } = c.req.param();
+    const { role } = c.req.valid('json');
+    await updateMemberRole(id, userId, role);
+    return c.json({ success: true, role });
+});
+// Budget & Usage
+/**
+ * GET /api/teams/:id/usage - Get team usage summary
+ */
+app.get('/:id/usage', async (c) => {
+    const { id } = c.req.param();
+    try {
+        const usage = await getTeamUsage(id);
+        return c.json({ success: true, usage });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 404);
+    }
+});
+/**
+ * GET /api/teams/:id/budget/check - Check if a member can spend
+ */
+app.get('/:id/budget/check', async (c) => {
+    const { id } = c.req.param();
+    const userId = c.req.query('userId');
+    const cost = parseFloat(c.req.query('cost') ?? '0.01');
+    if (!userId)
+        return c.json({ error: 'userId query param required' }, 400);
+    const result = await canMemberSpend(id, userId, cost);
+    return c.json({ success: true, ...result });
+});
+// Invites
+/**
+ * GET /api/teams/:id/invites - List pending invites
+ */
+app.get('/:id/invites', async (c) => {
+    const { id } = c.req.param();
+    const invites = await listTeamInvites(id);
+    return c.json({ success: true, invites, total: invites.length });
+});
+/**
+ * POST /api/teams/:id/invites - Create an invite
+ */
+app.post('/:id/invites', zValidator('json', inviteSchema), async (c) => {
+    const { id } = c.req.param();
+    const body = c.req.valid('json');
+    const invite = await createInvite(id, body.email, body.role, body.invitedBy);
+    return c.json({ success: true, invite }, 201);
+});
+/**
+ * POST /api/teams/invites/:inviteId/accept - Accept an invite
+ */
+app.post('/invites/:inviteId/accept', zValidator('json', z.object({
+    userId: z.string(),
+})), async (c) => {
+    const { inviteId } = c.req.param();
+    const { userId } = c.req.valid('json');
+    const member = await acceptInvite(inviteId, userId);
+    if (!member)
+        return c.json({ success: false, error: 'Invite not found or expired' }, 404);
+    return c.json({ success: true, member });
+});
+export const teamRoutes = app;
+//# sourceMappingURL=teams.js.map

package/dist/routes/tools.js

@@ -230,6 +230,20 @@ tools.delete("/security/allowlist/:pattern", (c) => {
 /**
  * List available tools
  */
+tools.get("/", (c) => {
+    const registry = getToolRegistry();
+    const toolList = registry.list();
+    return c.json({
+        tools: toolList.map((t) => ({
+            name: t.name,
+            description: t.description,
+            category: t.category,
+            securityLevel: t.securityLevel,
+            requiresApproval: t.requiresApproval,
+        })),
+        total: toolList.length,
+    });
+});
 tools.get("/list", (c) => {
     const registry = getToolRegistry();
     const toolList = registry.list();

package/dist/routes/users.js

@@ -977,6 +977,8 @@ userRoutes.delete('/admin/:userId', requireAdmin, async (c) => {
     const db = getDb();
     if (!db)
         return c.json({ error: 'Database not initialized' }, 500);
+    if (!userId)
+        return c.json({ error: 'User ID required' }, 400);
     // Prevent self-deletion
     if (userId === adminUser.id) {
         return c.json({ error: 'Cannot delete your own account' }, 400);

package/dist/server/route-loader.js

@@ -45,6 +45,7 @@ const CORE_ROUTE_DEFINITIONS = [
     { id: 'auth', mountPaths: ['/auth', '/api/auth'], load: namedRoute(() => import('../routes/auth.js'), 'authRoutes') },
     { id: 'settings', mountPaths: ['/api/settings'], load: namedRoute(() => import('../routes/settings.js'), 'settingsRoutes') },
     { id: 'security', mountPaths: ['/api/security'], load: defaultRoute(() => import('../routes/security.js')) },
+    { id: 'costs', mountPaths: ['/api/costs'], load: namedRoute(() => import('../routes/costs.js'), 'costsRoutes') },
 ];
 // Dashboard/UI routes (gated on web_ui capability)
 const DASHBOARD_ROUTE_DEFINITIONS = [
@@ -54,7 +55,6 @@ const DASHBOARD_ROUTE_DEFINITIONS = [
     { id: 'skills', mountPaths: ['/api/skills'], load: namedRoute(() => import('../routes/skills.js'), 'skillsRoutes') },
     { id: 'openapi', mountPaths: ['/api/docs'], load: namedRoute(() => import('../routes/openapi.js'), 'openApiRoutes') },
     { id: 'mcp', mountPaths: ['/api/mcp'], load: namedRoute(() => import('../routes/mcp.js'), 'mcpRoutes') },
-    { id: 'costs', mountPaths: ['/api/costs'], load: namedRoute(() => import('../routes/costs.js'), 'costsRoutes') },
     { id: 'tunnels', mountPaths: ['/api/tunnels'], load: namedRoute(() => import('../routes/tunnels.js'), 'tunnelsRoutes') },
     { id: 'voice', mountPaths: ['/api/voice'], load: namedRoute(() => import('../routes/voice.js'), 'voiceRoutes') },
 ];
@@ -79,6 +79,8 @@ const WEB_UI_ROUTE_DEFINITIONS = [
 ];
 const CRON_ROUTE_DEFINITIONS = [
     { id: 'cron', mountPaths: ['/api/cron'], load: namedRoute(() => import('../routes/cron.js'), 'cronRoutes') },
+    { id: 'feeds', mountPaths: ['/api/feeds'], load: defaultRoute(() => import('../routes/feeds.js')) },
+    { id: 'teams', mountPaths: ['/api/teams'], load: namedRoute(() => import('../routes/teams.js'), 'teamRoutes') },
 ];
 const INTEGRATION_ROUTE_DEFINITIONS = [
     { id: 'tickets', mountPaths: ['/api/tickets'], load: namedRoute(() => import('../routes/tickets.js'), 'ticketsRoutes') },

package/dist/server/stream-bridge.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Stream Bridge
+ *
+ * Bridges an AgentExecutor async generator stream() to the SSE broadcast
+ * mechanism so connected clients receive real-time typed agent events.
+ */
+import type { AgentEvent } from '../agents/events.js';
+/**
+ * Consume an AgentExecutor stream and forward each event to the SSE broadcaster.
+ *
+ * Each event is emitted as `agent:<event.type>` with the sessionId injected and
+ * a timestamp attached. The function resolves when the stream is exhausted.
+ *
+ * Stream errors are caught and broadcast as a synthetic `agent:session:error`
+ * event so that connected clients are notified, then the error is re-thrown so
+ * the caller can handle it (e.g. update task state).
+ */
+export declare function bridgeStreamToSSE(stream: AsyncGenerator<AgentEvent>, broadcaster: (type: string, data: unknown) => void, sessionId: string): Promise<void>;
+//# sourceMappingURL=stream-bridge.d.ts.map

package/dist/server/stream-bridge.js

@@ -0,0 +1,38 @@
+/**
+ * Stream Bridge
+ *
+ * Bridges an AgentExecutor async generator stream() to the SSE broadcast
+ * mechanism so connected clients receive real-time typed agent events.
+ */
+/**
+ * Consume an AgentExecutor stream and forward each event to the SSE broadcaster.
+ *
+ * Each event is emitted as `agent:<event.type>` with the sessionId injected and
+ * a timestamp attached. The function resolves when the stream is exhausted.
+ *
+ * Stream errors are caught and broadcast as a synthetic `agent:session:error`
+ * event so that connected clients are notified, then the error is re-thrown so
+ * the caller can handle it (e.g. update task state).
+ */
+export async function bridgeStreamToSSE(stream, broadcaster, sessionId) {
+    try {
+        for await (const event of stream) {
+            broadcaster(`agent:${event.type}`, {
+                sessionId,
+                ...event,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    catch (error) {
+        // Notify SSE clients before re-throwing
+        broadcaster('agent:session:error', {
+            sessionId,
+            type: 'session:error',
+            error: error instanceof Error ? error.message : String(error),
+            timestamp: Date.now(),
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=stream-bridge.js.map