@fatagnus/remote-cmd-relay-convex 1.0.0

package/src/configPush.ts

@@ -0,0 +1,96 @@
+import { v } from "convex/values";
+import { query, mutation } from "./_generated/server";
+import { configPushTypeValidator } from "./schema";
+
+/**
+ * Queue a config push for a relay
+ */
+export const queue = mutation({
+  args: {
+    relayId: v.string(),
+    pushType: v.string(),
+    payload: v.string(),
+  },
+  returns: v.id("configPushQueue"),
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    // Map string pushType to valid enum values
+    const validPushTypes = ["credential", "ssh_targets", "allowed_commands", "metrics_interval"] as const;
+    const pushType = validPushTypes.includes(args.pushType as typeof validPushTypes[number])
+      ? (args.pushType as typeof validPushTypes[number])
+      : "credential"; // Default to credential if invalid
+    
+    return await ctx.db.insert("configPushQueue", {
+      relayId: args.relayId,
+      pushType,
+      payload: args.payload,
+      status: "pending",
+      createdBy: "system", // Required by schema
+      createdAt: now,
+    });
+  },
+});
+
+/**
+ * Get a config push by ID
+ */
+export const get = query({
+  args: {
+    id: v.id("configPushQueue"),
+  },
+  returns: v.union(
+    v.object({
+      _id: v.id("configPushQueue"),
+      relayId: v.string(),
+      pushType: v.string(),
+      payload: v.string(),
+      status: v.string(),
+      createdAt: v.number(),
+      ackedAt: v.optional(v.number()),
+      errorMessage: v.optional(v.string()),
+    }),
+    v.null()
+  ),
+  handler: async (ctx, args) => {
+    const push = await ctx.db.get(args.id);
+    if (!push) return null;
+    return {
+      _id: push._id,
+      relayId: push.relayId,
+      pushType: push.pushType,
+      payload: push.payload,
+      status: push.status,
+      createdAt: push.createdAt,
+      ackedAt: push.ackedAt,
+      errorMessage: push.errorMessage,
+    };
+  },
+});
+
+/**
+ * List all config pushes
+ */
+export const listAll = query({
+  args: {},
+  returns: v.array(
+    v.object({
+      _id: v.id("configPushQueue"),
+      relayId: v.string(),
+      pushType: v.string(),
+      payload: v.string(),
+      status: v.string(),
+      createdAt: v.number(),
+    })
+  ),
+  handler: async (ctx) => {
+    const pushes = await ctx.db.query("configPushQueue").collect();
+    return pushes.map((p) => ({
+      _id: p._id,
+      relayId: p.relayId,
+      pushType: p.pushType,
+      payload: p.payload,
+      status: p.status,
+      createdAt: p.createdAt,
+    }));
+  },
+});

package/src/convex.config.ts

@@ -0,0 +1,5 @@
+import { defineComponent } from "convex/server";
+
+const component = defineComponent("remoteCmdRelay");
+
+export default component;

package/src/credentials.ts

@@ -0,0 +1,112 @@
+import { v } from "convex/values";
+import { query, mutation } from "./_generated/server";
+import { credentialTypeValidator, storageModeValidator } from "./schema";
+
+/**
+ * Create a shared credential
+ */
+export const create = mutation({
+  args: {
+    name: v.string(),
+    credentialType: credentialTypeValidator,
+    encryptedValue: v.string(),
+    assignedRelays: v.array(v.string()),
+    targetHost: v.optional(v.string()),
+  },
+  returns: v.id("sharedCredentials"),
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    return await ctx.db.insert("sharedCredentials", {
+      name: args.name,
+      credentialType: args.credentialType,
+      encryptedValue: args.encryptedValue,
+      assignedRelays: args.assignedRelays,
+      targetHost: args.targetHost,
+      createdBy: "system", // Required by schema
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+/**
+ * List credential inventory by relay ID
+ */
+export const listByRelay = query({
+  args: {
+    relayId: v.string(),
+  },
+  returns: v.array(
+    v.object({
+      _id: v.id("relayCredentialInventory"),
+      relayId: v.string(),
+      credentialName: v.string(),
+      credentialType: credentialTypeValidator,
+      targetHost: v.optional(v.string()),
+      storageMode: storageModeValidator,
+      lastUpdatedAt: v.number(),
+      reportedAt: v.number(),
+    })
+  ),
+  handler: async (ctx, args) => {
+    const inventory = await ctx.db
+      .query("relayCredentialInventory")
+      .withIndex("by_relayId", (q) => q.eq("relayId", args.relayId))
+      .collect();
+
+    return inventory.map((c) => ({
+      _id: c._id,
+      relayId: c.relayId,
+      credentialName: c.credentialName,
+      credentialType: c.credentialType,
+      targetHost: c.targetHost,
+      storageMode: c.storageMode,
+      lastUpdatedAt: c.lastUpdatedAt,
+      reportedAt: c.reportedAt,
+    }));
+  },
+});
+
+/**
+ * List all shared credentials
+ */
+export const listAll = query({
+  args: {},
+  returns: v.array(
+    v.object({
+      _id: v.id("sharedCredentials"),
+      name: v.string(),
+      credentialType: credentialTypeValidator,
+      assignedRelays: v.array(v.string()),
+      targetHost: v.optional(v.string()),
+      createdAt: v.number(),
+      updatedAt: v.number(),
+    })
+  ),
+  handler: async (ctx) => {
+    const creds = await ctx.db.query("sharedCredentials").collect();
+    return creds.map((c) => ({
+      _id: c._id,
+      name: c.name,
+      credentialType: c.credentialType,
+      assignedRelays: c.assignedRelays,
+      targetHost: c.targetHost,
+      createdAt: c.createdAt,
+      updatedAt: c.updatedAt,
+    }));
+  },
+});
+
+/**
+ * Delete a shared credential
+ */
+export const remove = mutation({
+  args: {
+    id: v.id("sharedCredentials"),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return null;
+  },
+});