@abyssinia-labs/wake-convex 0.1.0 → 0.3.0

package/src/component/views.ts

@@ -0,0 +1,42 @@
+// A summons as the host reads it back: the same shape from `forSubject`
+// (where it was made) and `runs.forOwner` (what a person's agents did).
+import { v } from "convex/values";
+import type { Doc } from "./_generated/dataModel.js";
+import { run, state, target } from "./schema.js";
+
+export const summonsView = v.object({
+  id: v.string(),
+  agent: v.string(),
+  owner: v.string(),
+  askedBy: v.string(),
+  scope: v.optional(v.string()),
+  subject: v.string(),
+  kind: v.string(),
+  target,
+  state,
+  at: v.number(),
+  updatedAt: v.number(),
+  reason: v.optional(v.string()),
+  unclaimed: v.boolean(),
+  /** Its run once Wake said it started. `session` is the owner's to see. */
+  run: v.optional(run),
+});
+
+export function viewOf(row: Doc<"summonses">) {
+  return {
+    id: row._id,
+    agent: row.agent,
+    owner: row.owner,
+    askedBy: row.askedBy,
+    ...(row.scope === undefined ? {} : { scope: row.scope }),
+    subject: row.subject,
+    kind: row.kind,
+    target: row.target,
+    state: row.state,
+    at: row.at,
+    updatedAt: row.updatedAt,
+    ...(row.reason === undefined ? {} : { reason: row.reason }),
+    unclaimed: row.state === "open" && row.noticedAt !== undefined,
+    ...(row.run === undefined ? {} : { run: row.run }),
+  };
+}

package/src/component/wire.ts

@@ -6,7 +6,8 @@ import { ConvexError, v } from "convex/values";
 import type { Doc } from "./_generated/dataModel.js";
 import { type MutationCtx, mutation, type QueryCtx, query } from "./_generated/server.js";
 import { hashSecret, KEY_SHAPE } from "./keys.js";
-import { target } from "./schema.js";
+import { target, tool } from "./schema.js";
+import { isRunReport } from "./shape.js";
 
 /** Oldest first, at most this many: Wake runs two at a time. */
 const PENDING_LIMIT = 50;
@@ -78,6 +79,40 @@ export const claim = mutation({
   },
 });
 
+/**
+ * wake:started: the agent is running, under a name people see and the
+ * session its owner resumes. A later call for the same run replaces the
+ * first (the session id of Codex and Cursor comes after they start).
+ */
+export const started = mutation({
+  args: {
+    key: v.string(),
+    id: v.string(),
+    run: v.object({ name: v.string(), tool, session: v.optional(v.string()) }),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const place = await placeOf(ctx, args.key);
+    const id = ctx.db.normalizeId("summonses", args.id);
+    const row = id ? await ctx.db.get(id) : null;
+    if (!row || row.place !== place._id || row.state !== "claimed") return null;
+    if (!isRunReport(args.run)) return null;
+    const now = Date.now();
+    await ctx.db.patch(row._id, {
+      run: {
+        name: args.run.name,
+        tool: args.run.tool,
+        ...(args.run.session === undefined ? {} : { session: args.run.session }),
+        machine: place.machine,
+        startedAt: row.run?.startedAt ?? now,
+      },
+      updatedAt: now,
+    });
+    await ctx.db.patch(place._id, { lastSeenAt: now });
+    return null;
+  },
+});
+
 /** wake:finish: what became of a run this place claimed. */
 export const finish = mutation({
   args: {