@webgrow/skillhub 0.1.0

package/convex/bridge.ts

@@ -0,0 +1,709 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+const logLevel = v.union(
+  v.literal("debug"),
+  v.literal("info"),
+  v.literal("warn"),
+  v.literal("error"),
+);
+
+async function nextRunEventSequence(ctx: any, runId: any) {
+  const latest = await ctx.db
+    .query("runEvents")
+    .withIndex("by_run_sequence", (q: any) => q.eq("runId", runId))
+    .order("desc")
+    .first();
+
+  return (latest?.sequence ?? 0) + 1;
+}
+
+async function appendRunEvent(ctx: any, runId: any, event: any) {
+  const now = Date.now();
+  const sequence = await nextRunEventSequence(ctx, runId);
+
+  await ctx.db.insert("runEvents", {
+    runId,
+    sequence,
+    eventType: event.eventType,
+    level: event.level ?? "info",
+    nodeId: event.nodeId,
+    edgeId: event.edgeId,
+    message: event.message,
+    payload: event.payload,
+    createdAt: now,
+  });
+
+  await ctx.db.patch(runId, { updatedAt: now });
+}
+
+async function getLeaseAndAction(ctx: any, claimId: string) {
+  const lease = await ctx.db
+    .query("bridgeLeases")
+    .withIndex("by_claim", (q: any) => q.eq("claimId", claimId))
+    .unique();
+
+  if (!lease || lease.status !== "active") {
+    throw new Error(`Active lease not found: ${claimId}`);
+  }
+
+  const action = await ctx.db.get(lease.actionId);
+  if (!action) {
+    throw new Error(`Host action not found for lease: ${claimId}`);
+  }
+
+  return { lease, action };
+}
+
+function isActionSupported(action: any, capabilities: string[] | undefined) {
+  if (!capabilities?.length) {
+    return true;
+  }
+
+  return capabilities.includes(action.actionType) || capabilities.includes("*");
+}
+
+export const getOperatorPacket = query({
+  args: {
+    runId: v.id("loopRuns"),
+    eventLimit: v.optional(v.number()),
+    logLimit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const run = await ctx.db.get(args.runId);
+    if (!run) {
+      return null;
+    }
+
+    const eventLimit = Math.min(args.eventLimit ?? 100, 500);
+    const logLimit = Math.min(args.logLimit ?? 100, 500);
+
+    const [pendingActions, events, logs] = await Promise.all([
+      ctx.db
+        .query("hostActions")
+        .withIndex("by_run_status", (q) => q.eq("runId", args.runId))
+        .filter((q) =>
+          q.or(
+            q.eq(q.field("status"), "pending"),
+            q.eq(q.field("status"), "claimed"),
+            q.eq(q.field("status"), "applying"),
+          ),
+        )
+        .take(100),
+      ctx.db
+        .query("runEvents")
+        .withIndex("by_run_sequence", (q) => q.eq("runId", args.runId))
+        .order("desc")
+        .take(eventLimit),
+      ctx.db
+        .query("bridgeLogs")
+        .withIndex("by_run_createdAt", (q) => q.eq("runId", args.runId))
+        .order("desc")
+        .take(logLimit),
+    ]);
+
+    return {
+      run,
+      pendingActions,
+      events: events.reverse(),
+      logs: logs.reverse(),
+    };
+  },
+});
+
+export const listWorkerState = query({
+  args: {
+    sessionLimit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const sessionLimit = Math.min(args.sessionLimit ?? 12, 50);
+    const now = Date.now();
+    const [sessions, pendingActions, claimedActions, applyingActions, failedActions] =
+      await Promise.all([
+        ctx.db
+          .query("bridgeSessions")
+          .withIndex("by_lastSeenAt")
+          .order("desc")
+          .take(sessionLimit),
+        ctx.db
+          .query("hostActions")
+          .withIndex("by_status_createdAt", (q) => q.eq("status", "pending"))
+          .order("desc")
+          .take(100),
+        ctx.db
+          .query("hostActions")
+          .withIndex("by_status_createdAt", (q) => q.eq("status", "claimed"))
+          .order("desc")
+          .take(100),
+        ctx.db
+          .query("hostActions")
+          .withIndex("by_status_createdAt", (q) => q.eq("status", "applying"))
+          .order("desc")
+          .take(100),
+        ctx.db
+          .query("hostActions")
+          .withIndex("by_status_createdAt", (q) => q.eq("status", "failed"))
+          .order("desc")
+          .take(20),
+      ]);
+
+    const activeActions = [...claimedActions, ...applyingActions];
+
+    return {
+      pendingCount: pendingActions.length,
+      activeCount: activeActions.length,
+      workers: sessions.map((session) => {
+        const currentAction =
+          activeActions.find((action) => action.claimedBy === session.name) ?? null;
+        const lastError =
+          failedActions.find((action) => action.claimedBy === session.name)?.error ?? null;
+        const connected =
+          session.status === "online" && now - session.lastSeenAt < 90_000;
+
+        return {
+          session,
+          connected,
+          currentAction,
+          lastError,
+        };
+      }),
+    };
+  },
+});
+
+export const registerSession = mutation({
+  args: {
+    name: v.string(),
+    kind: v.optional(v.string()),
+    capabilities: v.optional(v.array(v.string())),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+
+    return await ctx.db.insert("bridgeSessions", {
+      name: args.name,
+      kind: args.kind ?? "codex-harness",
+      status: "online",
+      capabilities: args.capabilities ?? ["*"],
+      lastSeenAt: now,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const enqueueHostAction = mutation({
+  args: {
+    runId: v.id("loopRuns"),
+    nodeId: v.optional(v.string()),
+    actionType: v.string(),
+    title: v.string(),
+    idempotencyKey: v.string(),
+    payload: v.any(),
+    codexTool: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const run = await ctx.db.get(args.runId);
+    if (!run) {
+      throw new Error(`Run not found: ${args.runId}`);
+    }
+
+    const existing = await ctx.db
+      .query("hostActions")
+      .withIndex("by_idempotency", (q) =>
+        q.eq("idempotencyKey", args.idempotencyKey),
+      )
+      .unique();
+
+    if (existing) {
+      return existing._id;
+    }
+
+    const now = Date.now();
+    const actionId = await ctx.db.insert("hostActions", {
+      runId: args.runId,
+      loopSlug: run.loopSlug,
+      nodeId: args.nodeId,
+      actionType: args.actionType,
+      title: args.title,
+      status: "pending",
+      idempotencyKey: args.idempotencyKey,
+      payload: args.payload,
+      codexTool: args.codexTool,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await appendRunEvent(ctx, args.runId, {
+      eventType: "host_action.enqueued",
+      nodeId: args.nodeId,
+      message: args.title,
+      payload: {
+        actionId,
+        actionType: args.actionType,
+        idempotencyKey: args.idempotencyKey,
+      },
+    });
+
+    return actionId;
+  },
+});
+
+export const claimNextAction = mutation({
+  args: {
+    claimId: v.string(),
+    claimedBy: v.string(),
+    sessionId: v.optional(v.id("bridgeSessions")),
+    capabilities: v.optional(v.array(v.string())),
+    leaseMs: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const leaseMs = Math.max(1000, Math.min(args.leaseMs ?? 60_000, 30 * 60_000));
+    const existingLease = await ctx.db
+      .query("bridgeLeases")
+      .withIndex("by_claim", (q) => q.eq("claimId", args.claimId))
+      .unique();
+
+    if (existingLease) {
+      const existingAction = await ctx.db.get(existingLease.actionId);
+      if (!existingAction) {
+        throw new Error(`Claim exists without a host action: ${args.claimId}`);
+      }
+      if (existingLease.status !== "active") {
+        throw new Error(`Claim is already closed: ${args.claimId}`);
+      }
+
+      return {
+        action: existingAction,
+        leaseExpiresAt: existingLease.leaseExpiresAt,
+      };
+    }
+
+    const candidates = await ctx.db
+      .query("hostActions")
+      .withIndex("by_status_createdAt", (q) => q.eq("status", "pending"))
+      .take(50);
+
+    const action = candidates.find((candidate) =>
+      isActionSupported(candidate, args.capabilities),
+    );
+
+    if (!action) {
+      if (args.sessionId) {
+        await ctx.db.patch(args.sessionId, {
+          status: "online",
+          lastSeenAt: now,
+          updatedAt: now,
+        });
+      }
+      return null;
+    }
+
+    const leaseExpiresAt = now + leaseMs;
+
+    await ctx.db.patch(action._id, {
+      status: "claimed",
+      claimId: args.claimId,
+      claimedBy: args.claimedBy,
+      claimedAt: now,
+      leaseExpiresAt,
+      updatedAt: now,
+    });
+
+    if (args.sessionId) {
+      await ctx.db.patch(args.sessionId, {
+        status: "online",
+        lastSeenAt: now,
+        updatedAt: now,
+      });
+    }
+
+    await ctx.db.insert("bridgeLeases", {
+      actionId: action._id,
+      sessionId: args.sessionId,
+      claimId: args.claimId,
+      status: "active",
+      leaseExpiresAt,
+      heartbeatAt: now,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await appendRunEvent(ctx, action.runId, {
+      eventType: "host_action.claimed",
+      nodeId: action.nodeId,
+      message: `${args.claimedBy} claimed ${action.title}`,
+      payload: {
+        actionId: action._id,
+        claimId: args.claimId,
+        leaseExpiresAt,
+      },
+    });
+
+    return {
+      action: {
+        ...action,
+        status: "claimed",
+        claimId: args.claimId,
+        claimedBy: args.claimedBy,
+        claimedAt: now,
+        leaseExpiresAt,
+      },
+      leaseExpiresAt,
+    };
+  },
+});
+
+export const heartbeatLease = mutation({
+  args: {
+    claimId: v.string(),
+    extendMs: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const { lease, action } = await getLeaseAndAction(ctx, args.claimId);
+    const now = Date.now();
+    const extendMs = Math.max(1000, Math.min(args.extendMs ?? 60_000, 30 * 60_000));
+    const leaseExpiresAt = now + extendMs;
+
+    await ctx.db.patch(lease._id, {
+      leaseExpiresAt,
+      heartbeatAt: now,
+      updatedAt: now,
+    });
+    await ctx.db.patch(action._id, {
+      leaseExpiresAt,
+      updatedAt: now,
+    });
+
+    return { leaseExpiresAt };
+  },
+});
+
+export const expireStaleLeases = mutation({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const limit = Math.min(args.limit ?? 25, 100);
+    const leases = await ctx.db
+      .query("bridgeLeases")
+      .withIndex("by_expiry", (q) => q.lt("leaseExpiresAt", now))
+      .filter((q) => q.eq(q.field("status"), "active"))
+      .take(limit);
+
+    let expired = 0;
+
+    for (const lease of leases) {
+      const action = await ctx.db.get(lease.actionId);
+      await ctx.db.patch(lease._id, {
+        status: "expired",
+        updatedAt: now,
+      });
+
+      if (!action) {
+        continue;
+      }
+
+      await ctx.db.patch(action._id, {
+        status: "pending",
+        claimId: undefined,
+        claimedBy: undefined,
+        claimedAt: undefined,
+        leaseExpiresAt: undefined,
+        updatedAt: now,
+      });
+
+      await appendRunEvent(ctx, action.runId, {
+        eventType: "host_action.lease_expired",
+        level: "warn",
+        nodeId: action.nodeId,
+        message: `${action.title} returned to the queue after a stale lease`,
+        payload: {
+          actionId: action._id,
+          claimId: lease.claimId,
+        },
+      });
+
+      expired += 1;
+    }
+
+    return { expired };
+  },
+});
+
+export const markApplying = mutation({
+  args: {
+    claimId: v.string(),
+    note: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const { action } = await getLeaseAndAction(ctx, args.claimId);
+    const now = Date.now();
+
+    await ctx.db.patch(action._id, {
+      status: "applying",
+      updatedAt: now,
+    });
+
+    await appendRunEvent(ctx, action.runId, {
+      eventType: "host_action.applying",
+      nodeId: action.nodeId,
+      message: args.note ?? action.title,
+      payload: {
+        actionId: action._id,
+        claimId: args.claimId,
+      },
+    });
+  },
+});
+
+export const emitLog = mutation({
+  args: {
+    claimId: v.string(),
+    level: logLevel,
+    message: v.string(),
+    source: v.optional(v.string()),
+    data: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const { action } = await getLeaseAndAction(ctx, args.claimId);
+    const now = Date.now();
+
+    const logId = await ctx.db.insert("bridgeLogs", {
+      runId: action.runId,
+      actionId: action._id,
+      claimId: args.claimId,
+      source: args.source ?? "codex-harness",
+      level: args.level,
+      message: args.message,
+      data: args.data,
+      createdAt: now,
+    });
+
+    await appendRunEvent(ctx, action.runId, {
+      eventType: "bridge.log",
+      level: args.level,
+      nodeId: action.nodeId,
+      message: args.message,
+      payload: {
+        actionId: action._id,
+        claimId: args.claimId,
+        logId,
+      },
+    });
+
+    return logId;
+  },
+});
+
+export const completeAction = mutation({
+  args: {
+    claimId: v.string(),
+    result: v.optional(v.any()),
+    note: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const { lease, action } = await getLeaseAndAction(ctx, args.claimId);
+    const now = Date.now();
+
+    await ctx.db.patch(action._id, {
+      status: "completed",
+      result: args.result,
+      completedAt: now,
+      updatedAt: now,
+    });
+    await ctx.db.patch(lease._id, {
+      status: "completed",
+      updatedAt: now,
+    });
+
+    await appendRunEvent(ctx, action.runId, {
+      eventType: "host_action.completed",
+      nodeId: action.nodeId,
+      message: args.note ?? action.title,
+      payload: {
+        actionId: action._id,
+        claimId: args.claimId,
+        result: args.result,
+      },
+    });
+
+    await maybeAdvanceLoopStep(ctx, action, now);
+  },
+});
+
+export const failAction = mutation({
+  args: {
+    claimId: v.string(),
+    error: v.string(),
+    data: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const { lease, action } = await getLeaseAndAction(ctx, args.claimId);
+    const now = Date.now();
+
+    await ctx.db.patch(action._id, {
+      status: "failed",
+      error: args.error,
+      result: args.data,
+      completedAt: now,
+      updatedAt: now,
+    });
+    await ctx.db.patch(lease._id, {
+      status: "failed",
+      updatedAt: now,
+    });
+
+    await appendRunEvent(ctx, action.runId, {
+      eventType: "host_action.failed",
+      level: "error",
+      nodeId: action.nodeId,
+      message: args.error,
+      payload: {
+        actionId: action._id,
+        claimId: args.claimId,
+        data: args.data,
+      },
+    });
+  },
+});
+
+export const releaseAction = mutation({
+  args: {
+    claimId: v.string(),
+    reason: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const { lease, action } = await getLeaseAndAction(ctx, args.claimId);
+    const now = Date.now();
+
+    await ctx.db.patch(action._id, {
+      status: "pending",
+      claimId: undefined,
+      claimedBy: undefined,
+      claimedAt: undefined,
+      leaseExpiresAt: undefined,
+      updatedAt: now,
+    });
+    await ctx.db.patch(lease._id, {
+      status: "released",
+      updatedAt: now,
+    });
+
+    await appendRunEvent(ctx, action.runId, {
+      eventType: "host_action.released",
+      level: "warn",
+      nodeId: action.nodeId,
+      message: args.reason ?? "Action released back to the queue",
+      payload: {
+        actionId: action._id,
+        claimId: args.claimId,
+      },
+    });
+  },
+});
+
+async function maybeAdvanceLoopStep(ctx: any, action: any, now: number) {
+  const loopStep = action.payload?.loopStep;
+  if (!loopStep || !Array.isArray(loopStep.steps)) {
+    return;
+  }
+
+  const run = await ctx.db.get(action.runId);
+  if (!run || run.status !== "running") {
+    return;
+  }
+
+  const steps = loopStep.steps;
+  const nextIndex = Number(loopStep.stepIndex ?? -1) + 1;
+  const nextStep = steps[nextIndex];
+
+  if (!nextStep) {
+    await ctx.db.patch(action.runId, {
+      status: "completed",
+      activeNodeId: undefined,
+      completedAt: now,
+      updatedAt: now,
+      transitionCount: (run.transitionCount ?? 0) + 1,
+    });
+
+    await appendRunEvent(ctx, action.runId, {
+      eventType: "loop.completed",
+      level: "info",
+      message: `Loop completed after ${steps.length} step(s).`,
+      payload: {
+        finalActionId: action._id,
+        totalSteps: steps.length,
+      },
+    });
+    return;
+  }
+
+  await ctx.db.patch(action.runId, {
+    activeNodeId: nextStep.id,
+    updatedAt: now,
+    transitionCount: (run.transitionCount ?? 0) + 1,
+  });
+
+  const actionId = await ctx.db.insert("hostActions", {
+    runId: action.runId,
+    loopSlug: action.loopSlug,
+    nodeId: nextStep.id,
+    actionType: nextStep.actionType || "codex.cli",
+    title: `${action.payload?.loop?.name ?? action.loopSlug}: ${nextStep.label}`,
+    status: "pending",
+    idempotencyKey: `loop-step:${action.runId}:${nextStep.id}`,
+    payload: {
+      prompt: renderLoopStepPrompt({
+        loop: action.payload?.loop,
+        prompt: run.prompt,
+        step: nextStep,
+        stepIndex: nextIndex,
+        steps,
+      }),
+      loopStep: {
+        ...loopStep,
+        stepIndex: nextIndex,
+        nextStep: steps[nextIndex + 1] ?? null,
+      },
+      loop: action.payload?.loop,
+      step: nextStep,
+    },
+    codexTool: action.codexTool,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  await appendRunEvent(ctx, action.runId, {
+    eventType: "loop.step.enqueued",
+    level: "info",
+    nodeId: nextStep.id,
+    message: `Queued step ${nextIndex + 1}: ${nextStep.label}`,
+    payload: {
+      actionId,
+      stepIndex: nextIndex,
+      totalSteps: steps.length,
+    },
+  });
+}
+
+function renderLoopStepPrompt({ loop, prompt, step, stepIndex, steps }: any) {
+  return [
+    `Loop: ${loop?.name ?? "SkillHub loop"}`,
+    `Step ${stepIndex + 1} of ${steps.length}: ${step.label}`,
+    step.skillSlug ? `Skill reference: ${step.skillSlug}` : null,
+    "",
+    "Loop objective:",
+    prompt,
+    "",
+    "Step instructions:",
+    step.instructions,
+    "",
+    "All loop steps:",
+    ...steps.map((item: any, index: number) => `${index + 1}. ${item.label}`),
+  ]
+    .filter(Boolean)
+    .join("\n");
+}

package/convex/convex.config.ts

@@ -0,0 +1,8 @@
+import { defineApp } from "convex/server";
+import workflow from "@convex-dev/workflow/convex.config.js";
+
+const app = defineApp();
+
+app.use(workflow);
+
+export default app;