@donkeylabs/cli 0.6.4 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "0.6.4",
+  "version": "1.0.0",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",
@@ -35,7 +35,7 @@
     "@types/prompts": "^2.4.9"
   },
   "peerDependencies": {
-    "@donkeylabs/server": "^0.4.0"
+    "@donkeylabs/server": "^1.0.0"
   },
   "keywords": [
     "cli",

package/templates/sveltekit-app/src/routes/+page.svelte

@@ -66,6 +66,26 @@
   let eventName = $state("demo.test");
   let eventData = $state('{"hello": "world"}');
 
+  // Audit state
+  let auditAction = $state("user.login");
+  let auditResource = $state("user");
+  let auditResourceId = $state("user-123");
+  let auditEntries = $state<Array<{
+    id: string;
+    timestamp: string;
+    action: string;
+    actor: string;
+    resource: string;
+    resourceId?: string;
+    metadata?: Record<string, any>;
+  }>>([]);
+  let lastAuditId = $state<string | null>(null);
+
+  // WebSocket state
+  let wsChannel = $state("demo");
+  let wsMessage = $state("Hello from browser!");
+  let wsClientCount = $state(0);
+
   // Counter actions - using typed client
   async function counterAction(
     action: "get" | "increment" | "decrement" | "reset",
@@ -170,6 +190,50 @@
     };
   }
 
+  // Audit actions - using typed client
+  async function auditLogEntry() {
+    const result = await client.api.audit.log({
+      action: auditAction,
+      resource: auditResource,
+      resourceId: auditResourceId,
+      metadata: { browser: true, timestamp: Date.now() },
+    }) as { id: string };
+    lastAuditId = result.id;
+    refreshAuditEntries();
+  }
+
+  async function refreshAuditEntries() {
+    const result = await client.api.audit.query({ limit: 10 }) as { entries: typeof auditEntries };
+    auditEntries = result.entries;
+  }
+
+  // WebSocket actions - using typed client
+  async function wsBroadcastMessage() {
+    await client.api.websocket.broadcast({
+      channel: wsChannel,
+      event: "chat",
+      data: {
+        message: wsMessage,
+        timestamp: new Date().toISOString(),
+      },
+    });
+  }
+
+  async function wsBroadcastAll() {
+    await client.api.websocket.broadcastAll({
+      event: "announcement",
+      data: {
+        message: wsMessage,
+        timestamp: new Date().toISOString(),
+      },
+    });
+  }
+
+  async function refreshWsClients() {
+    const result = await client.api.websocket.clientCount({}) as { count: number };
+    wsClientCount = result.count;
+  }
+
   onMount(() => {
     if (!browser) return;
 
@@ -178,6 +242,8 @@
     refreshJobStats();
     refreshCronTasks();
     refreshSSEClients();
+    refreshAuditEntries();
+    refreshWsClients();
 
     // SSE subscription using the typed client
     const unsubscribe = client.sse.subscribe(
@@ -483,6 +549,73 @@
           </p>
         </CardContent>
       </Card>
+
+      <!-- Audit Demo -->
+      <Card>
+        <CardHeader>
+          <CardTitle>Audit Trail</CardTitle>
+          <CardDescription>Compliance logging and tracking</CardDescription>
+        </CardHeader>
+        <CardContent class="space-y-3">
+          <div class="flex gap-2">
+            <Input bind:value={auditAction} placeholder="Action" class="flex-1" />
+            <Input bind:value={auditResource} placeholder="Resource" class="flex-1" />
+          </div>
+          <Input bind:value={auditResourceId} placeholder="Resource ID (optional)" />
+          <div class="flex gap-2">
+            <Button onclick={auditLogEntry} size="sm">Log Entry</Button>
+            <Button onclick={refreshAuditEntries} size="sm" variant="outline">Refresh</Button>
+          </div>
+          {#if lastAuditId}
+            <p class="text-xs text-muted-foreground">
+              Last: <code class="bg-muted px-1 rounded">{lastAuditId}</code>
+            </p>
+          {/if}
+          {#if auditEntries.length > 0}
+            <div class="max-h-32 overflow-y-auto space-y-1">
+              {#each auditEntries.slice(0, 5) as entry}
+                <div class="text-xs p-2 bg-muted rounded flex justify-between items-center">
+                  <span class="font-medium">{entry.action}</span>
+                  <span class="text-muted-foreground">{entry.resource}</span>
+                  <span class="text-muted-foreground">{new Date(entry.timestamp).toLocaleTimeString()}</span>
+                </div>
+              {/each}
+            </div>
+          {:else}
+            <p class="text-xs text-muted-foreground italic">No audit entries yet</p>
+          {/if}
+        </CardContent>
+      </Card>
+
+      <!-- WebSocket Demo -->
+      <Card>
+        <CardHeader>
+          <CardTitle>WebSocket</CardTitle>
+          <CardDescription>Bidirectional real-time messaging</CardDescription>
+        </CardHeader>
+        <CardContent class="space-y-3">
+          <div class="flex gap-2">
+            <Input bind:value={wsChannel} placeholder="Channel" class="w-28" />
+            <Input bind:value={wsMessage} placeholder="Message" class="flex-1" />
+          </div>
+          <div class="flex gap-2">
+            <Button onclick={wsBroadcastMessage} size="sm">Broadcast</Button>
+            <Button onclick={wsBroadcastAll} size="sm" variant="secondary">Broadcast All</Button>
+            <Button onclick={refreshWsClients} size="sm" variant="outline">Refresh</Button>
+          </div>
+          <div class="flex items-center gap-2">
+            <span class="relative flex h-2 w-2">
+              <span class="relative inline-flex rounded-full h-2 w-2 {wsClientCount > 0 ? 'bg-green-500' : 'bg-gray-400'}"></span>
+            </span>
+            <span class="text-xs text-muted-foreground">
+              {wsClientCount} WebSocket client{wsClientCount !== 1 ? 's' : ''} connected
+            </span>
+          </div>
+          <p class="text-xs text-muted-foreground italic">
+            Messages logged to audit trail automatically
+          </p>
+        </CardContent>
+      </Card>
     </div>
 
     <!-- SSE Events Stream - Full Width -->

package/templates/sveltekit-app/src/server/plugins/demo/index.ts

@@ -104,6 +104,68 @@ export const demoPlugin = createPlugin.define({
         total: ctx.core.sse.getClients().length,
         byChannel: ctx.core.sse.getClientsByChannel("events").length,
       }),
+
+      // Audit helpers - compliance and tracking
+      auditLog: async (action: string, resource: string, resourceId?: string, metadata?: Record<string, any>) => {
+        const id = await ctx.core.audit.log({
+          action,
+          actor: "demo-user", // In real apps, get from auth context
+          resource,
+          resourceId,
+          metadata,
+        });
+        return { id };
+      },
+      auditQuery: async (filters: { action?: string; resource?: string; limit?: number }) => {
+        const entries = await ctx.core.audit.query({
+          action: filters.action,
+          resource: filters.resource,
+          limit: filters.limit ?? 10,
+        });
+        return {
+          entries: entries.map(e => ({
+            id: e.id,
+            timestamp: e.timestamp.toISOString(),
+            action: e.action,
+            actor: e.actor,
+            resource: e.resource,
+            resourceId: e.resourceId,
+            metadata: e.metadata,
+          })),
+        };
+      },
+      auditGetByResource: async (resource: string, resourceId: string) => {
+        const entries = await ctx.core.audit.getByResource(resource, resourceId);
+        return {
+          entries: entries.map(e => ({
+            id: e.id,
+            timestamp: e.timestamp.toISOString(),
+            action: e.action,
+            actor: e.actor,
+            metadata: e.metadata,
+          })),
+        };
+      },
+
+      // WebSocket helpers - bidirectional real-time communication
+      wsBroadcast: (channel: string, event: string, data: any) => {
+        ctx.core.websocket.broadcast(channel, event, data);
+        return { success: true };
+      },
+      wsBroadcastAll: (event: string, data: any) => {
+        ctx.core.websocket.broadcastAll(event, data);
+        return { success: true };
+      },
+      wsGetClients: (channel?: string) => {
+        const clients = ctx.core.websocket.getClients(channel);
+        return {
+          count: clients.length,
+          clients,
+        };
+      },
+      wsGetClientCount: (channel?: string) => {
+        return { count: ctx.core.websocket.getClientCount(channel) };
+      },
     };
   },
   init: async (ctx) => {
@@ -139,6 +201,58 @@ export const demoPlugin = createPlugin.define({
       });
     });
 
-    ctx.core.logger.info("Demo plugin initialized with all core services");
+    // WebSocket message handler - echo messages back and broadcast to channel
+    ctx.core.websocket.onMessage(async (clientId, event, data) => {
+      ctx.core.logger.info("WebSocket message received", { clientId, event, data });
+
+      // Echo the message back to the sender
+      if (event === "echo") {
+        ctx.core.websocket.send(clientId, "echo-reply", {
+          original: data,
+          timestamp: new Date().toISOString(),
+        });
+      }
+
+      // Broadcast to a channel if requested
+      if (event === "broadcast" && data?.channel) {
+        ctx.core.websocket.broadcast(data.channel, "ws-broadcast", {
+          from: clientId,
+          message: data.message,
+          timestamp: new Date().toISOString(),
+        });
+      }
+
+      // Log WebSocket activity to audit trail
+      await ctx.core.audit.log({
+        action: "websocket.message",
+        actor: clientId,
+        resource: "websocket",
+        resourceId: event,
+        metadata: { event, dataSize: JSON.stringify(data).length },
+      });
+    });
+
+    // Audit important events for compliance tracking
+    ctx.core.events.on("job.completed", async (data: any) => {
+      await ctx.core.audit.log({
+        action: "job.completed",
+        actor: "system",
+        resource: "job",
+        resourceId: data.jobId,
+        metadata: { name: data.name },
+      });
+    });
+
+    ctx.core.events.on("workflow.completed", async (data: any) => {
+      await ctx.core.audit.log({
+        action: "workflow.completed",
+        actor: "system",
+        resource: "workflow",
+        resourceId: data.instanceId,
+        metadata: { workflowName: data.workflowName },
+      });
+    });
+
+    ctx.core.logger.info("Demo plugin initialized with all core services (including audit & websocket)");
   },
 });

package/templates/sveltekit-app/src/server/routes/demo.ts

@@ -316,4 +316,143 @@ demo.route("workflow.cancel").typed(
   })
 );
 
+// =============================================================================
+// AUDIT - Compliance and tracking (via plugin service)
+// =============================================================================
+
+demo.route("audit.log").typed(
+  defineRoute({
+    input: z.object({
+      action: z.string(),
+      resource: z.string(),
+      resourceId: z.string().optional(),
+      metadata: z.record(z.any()).optional(),
+    }),
+    output: z.object({ id: z.string() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.auditLog(
+        input.action,
+        input.resource,
+        input.resourceId,
+        input.metadata
+      );
+    },
+  })
+);
+
+demo.route("audit.query").typed(
+  defineRoute({
+    input: z.object({
+      action: z.string().optional(),
+      resource: z.string().optional(),
+      limit: z.number().optional().default(10),
+    }),
+    output: z.object({
+      entries: z.array(
+        z.object({
+          id: z.string(),
+          timestamp: z.string(),
+          action: z.string(),
+          actor: z.string(),
+          resource: z.string(),
+          resourceId: z.string().optional(),
+          metadata: z.record(z.any()).optional(),
+        })
+      ),
+    }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.auditQuery({
+        action: input.action,
+        resource: input.resource,
+        limit: input.limit ?? 10,
+      });
+    },
+  })
+);
+
+demo.route("audit.byResource").typed(
+  defineRoute({
+    input: z.object({
+      resource: z.string(),
+      resourceId: z.string(),
+    }),
+    output: z.object({
+      entries: z.array(
+        z.object({
+          id: z.string(),
+          timestamp: z.string(),
+          action: z.string(),
+          actor: z.string(),
+          metadata: z.record(z.any()).optional(),
+        })
+      ),
+    }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.auditGetByResource(input.resource, input.resourceId);
+    },
+  })
+);
+
+// =============================================================================
+// WEBSOCKET - Bidirectional real-time communication (via plugin service)
+// =============================================================================
+
+demo.route("websocket.broadcast").typed(
+  defineRoute({
+    input: z.object({
+      channel: z.string(),
+      event: z.string().default("message"),
+      data: z.any(),
+    }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.wsBroadcast(
+        input.channel,
+        input.event ?? "message",
+        input.data
+      );
+    },
+  })
+);
+
+demo.route("websocket.broadcastAll").typed(
+  defineRoute({
+    input: z.object({
+      event: z.string().default("message"),
+      data: z.any(),
+    }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.wsBroadcastAll(input.event ?? "message", input.data);
+    },
+  })
+);
+
+demo.route("websocket.clients").typed(
+  defineRoute({
+    input: z.object({
+      channel: z.string().optional(),
+    }),
+    output: z.object({
+      count: z.number(),
+      clients: z.array(z.string()),
+    }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.wsGetClients(input.channel);
+    },
+  })
+);
+
+demo.route("websocket.clientCount").typed(
+  defineRoute({
+    input: z.object({
+      channel: z.string().optional(),
+    }),
+    output: z.object({ count: z.number() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.wsGetClientCount(input.channel);
+    },
+  })
+);
+
 export default demo;