@h-rig/run-plugin 0.0.6-alpha.186

package/dist/src/worker/host.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/worker/host.js

@@ -0,0 +1 @@
+// @bun

package/dist/src/worker/inbox-command.d.ts

@@ -0,0 +1,23 @@
+import type { CommandOutcome, RunInboxResolutionInit, RunInboxResolutionResult, RunReadModelInboxRecord } from "@rig/contracts";
+import type { RuntimeCliContext } from "@rig/core/config";
+export type InboxKind = "approvals" | "inputs";
+export type InboxRecord = RunReadModelInboxRecord;
+export interface InboxFilters {
+    readonly run?: string;
+    readonly task?: string;
+}
+export interface InboxDeps {
+    readonly listInbox?: (projectRoot: string, kind: InboxKind, filters: InboxFilters) => Promise<readonly InboxRecord[]>;
+    readonly getInboxCounts?: (projectRoot: string) => Promise<{
+        readonly approvals: number;
+        readonly inputs: number;
+    } | null>;
+    readonly resolveInboxRequest?: (projectRoot: string, runId: string, resolution: RunInboxResolutionInit) => Promise<RunInboxResolutionResult>;
+}
+export declare function listInboxRecords(context: Pick<RuntimeCliContext, "projectRoot">, kind: InboxKind, filters?: InboxFilters, deps?: InboxDeps): Promise<readonly InboxRecord[]>;
+export declare function listInbox(context: Pick<RuntimeCliContext, "projectRoot">, kind: InboxKind, filters?: InboxFilters, deps?: InboxDeps): Promise<readonly InboxRecord[]>;
+export declare function readPendingInboxCounts(context: Pick<RuntimeCliContext, "projectRoot">, deps?: InboxDeps): Promise<{
+    approvals: number;
+    inputs: number;
+} | null>;
+export declare function executeInbox(context: RuntimeCliContext, args: string[], deps?: InboxDeps): Promise<CommandOutcome>;

package/dist/src/worker/inbox-command.js

@@ -0,0 +1,163 @@
+// @bun
+// packages/run-plugin/src/worker/inbox-command.ts
+import { RUN_CONTROL, RUN_READ_MODEL } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { CliError, requireNoExtraArgs, takeOption } from "@rig/std-shared/cli-args";
+import { printFormattedOutput } from "@rig/std-shared/cli-format";
+var RunControlCap = defineCapability(RUN_CONTROL);
+var RunReadModelCap = defineCapability(RUN_READ_MODEL);
+async function loadRunControl(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, RunControlCap, "RUN_CONTROL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+}
+async function loadRunReadModel(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, RunReadModelCap, "RUN_READ_MODEL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+}
+function readModelKind(kind) {
+  return kind === "approvals" ? "approval" : "input";
+}
+async function listInboxRecords(context, kind, filters = {}, deps = {}) {
+  if (deps.listInbox)
+    return deps.listInbox(context.projectRoot, kind, filters);
+  const readModel = await loadRunReadModel(context.projectRoot);
+  return readModel.listInboxRecords({
+    projectRoot: context.projectRoot,
+    kind: readModelKind(kind),
+    ...filters.run ? { runId: filters.run } : {},
+    ...filters.task ? { taskId: filters.task } : {}
+  });
+}
+async function listInbox(context, kind, filters = {}, deps = {}) {
+  return listInboxRecords(context, kind, filters, deps);
+}
+async function readPendingInboxCounts(context, deps = {}) {
+  if (deps.getInboxCounts)
+    return deps.getInboxCounts(context.projectRoot);
+  try {
+    const counts = await (await loadRunReadModel(context.projectRoot)).getInboxCounts({ projectRoot: context.projectRoot, kind: "all" });
+    return { approvals: counts.approvals, inputs: counts.inputs };
+  } catch {
+    return null;
+  }
+}
+function resolutionAttachError(runId, verb, error) {
+  const target = runId ?? "<run-id>";
+  const detail = error instanceof Error ? error.message : String(error);
+  throw new CliError(`rig inbox ${verb} could not deliver a resolution from this one-shot command.`, 2, {
+    hint: `${detail}
+Attach to resolve interactively: rig run attach ${target}`
+  });
+}
+async function readInboxSnapshot(context, filters, deps) {
+  const [approvals, inputs] = await Promise.all([
+    listInbox(context, "approvals", filters, deps),
+    listInbox(context, "inputs", filters, deps)
+  ]);
+  return { approvals, inputs };
+}
+function renderInboxSnapshot(readModel, snapshot) {
+  console.clear();
+  console.log(`rig inbox \u2014 watching (Ctrl-C to stop) \u2014 ${new Date().toLocaleTimeString()}`);
+  printFormattedOutput(readModel.formatInboxList("approvals", snapshot.approvals.map((entry) => ({ ...entry }))));
+  printFormattedOutput(readModel.formatInboxList("inputs", snapshot.inputs.map((entry) => ({ ...entry }))));
+  if (snapshot.approvals.length === 0 && snapshot.inputs.length === 0)
+    console.log("Nothing pending.");
+}
+function sleep(ms) {
+  const { promise, resolve } = Promise.withResolvers();
+  setTimeout(resolve, ms);
+  return promise;
+}
+async function watchInbox(context, filters, deps) {
+  const snapshot = await readInboxSnapshot(context, filters, deps);
+  if (context.outputMode !== "text")
+    return { ok: true, group: "inbox", command: "watch", details: snapshot };
+  const readModel = await loadRunReadModel(context.projectRoot);
+  renderInboxSnapshot(readModel, snapshot);
+  while (true) {
+    await sleep(500);
+    renderInboxSnapshot(readModel, await readInboxSnapshot(context, filters, deps));
+  }
+}
+async function deliverInboxResolution(context, runId, resolution, deps) {
+  const result = deps.resolveInboxRequest ? await deps.resolveInboxRequest(context.projectRoot, runId, resolution) : await (await loadRunControl(context.projectRoot)).resolveInboxRequest({ projectRoot: context.projectRoot, runId, resolution });
+  if (!result.delivered)
+    throw new Error(result.detail ?? `Inbox request ${resolution.requestId} was not delivered.`);
+  return result;
+}
+async function executeInbox(context, args, deps = {}) {
+  const [command = "approvals", ...rest] = args;
+  const text = context.outputMode === "text";
+  switch (command) {
+    case "approvals":
+    case "inputs": {
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, `rig inbox ${command} [--run <id>] [--task <id>]`);
+      const kind = command === "approvals" ? "approvals" : "inputs";
+      const filters = { ...run.value ? { run: run.value } : {}, ...task.value ? { task: task.value } : {} };
+      const entries = await listInbox(context, kind, filters, deps);
+      if (text) {
+        const readModel = await loadRunReadModel(context.projectRoot);
+        printFormattedOutput(readModel.formatInboxList(kind, entries.map((entry) => ({ ...entry }))));
+      }
+      return { ok: true, group: "inbox", command, details: { entries } };
+    }
+    case "approve": {
+      const run = takeOption(rest, "--run");
+      const request = takeOption(run.rest, "--request");
+      const decision = takeOption(request.rest, "--decision");
+      requireNoExtraArgs(decision.rest, "rig inbox approve --run <id> --request <id> --decision approve|reject");
+      if (!run.value || !request.value)
+        throw new CliError("rig inbox approve requires --run and --request.", 2);
+      const rawDecision = (decision.value ?? "approve").trim().toLowerCase();
+      if (rawDecision !== "approve" && rawDecision !== "approved" && rawDecision !== "reject" && rawDecision !== "rejected")
+        throw new CliError("--decision must be approve or reject.", 2);
+      const normalizedDecision = rawDecision === "approved" ? "approve" : rawDecision === "rejected" ? "reject" : rawDecision;
+      try {
+        await deliverInboxResolution(context, run.value, { kind: "approval", requestId: request.value, decision: normalizedDecision }, deps);
+      } catch (error) {
+        resolutionAttachError(run.value, "approve", error);
+      }
+      if (text)
+        printFormattedOutput(`Resolved approval ${request.value} for run ${run.value}.`);
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, decision: normalizedDecision } };
+    }
+    case "respond":
+    case "answer": {
+      const run = takeOption(rest, "--run");
+      const request = takeOption(run.rest, "--request");
+      const textResult = takeOption(request.rest, "--text");
+      const answerResult = takeOption(textResult.rest, "--answer");
+      requireNoExtraArgs(answerResult.rest, `rig inbox ${command} --run <id> --request <id> (--text|--answer) <answer>`);
+      if (textResult.value && answerResult.value)
+        throw new CliError("Pass only one of --text or --answer.", 2);
+      const answer = textResult.value ?? answerResult.value;
+      if (!run.value || !request.value || !answer)
+        resolutionAttachError(run.value, "respond", new Error(`rig inbox ${command} requires --run, --request, and --text/--answer.`));
+      try {
+        await deliverInboxResolution(context, run.value, { kind: "input", requestId: request.value, answers: { answer } }, deps);
+      } catch (error) {
+        resolutionAttachError(run.value, "respond", error);
+      }
+      if (text)
+        printFormattedOutput(`Sent response ${request.value} for run ${run.value}.`);
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, responded: true } };
+    }
+    case "watch": {
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, "rig inbox watch [--run <id>] [--task <id>]");
+      const filters = { ...run.value ? { run: run.value } : {}, ...task.value ? { task: task.value } : {} };
+      return watchInbox(context, filters, deps);
+    }
+    default:
+      throw new CliError(`Unknown inbox command: ${command}`, 1, { hint: "Run `rig inbox --help` to list inbox commands." });
+  }
+}
+export {
+  readPendingInboxCounts,
+  listInboxRecords,
+  listInbox,
+  executeInbox
+};

package/dist/src/worker/index.d.ts

@@ -0,0 +1,2 @@
+export { default, __rigExtensionTest, __rigRunWorkerTest } from "./extension";
+export * from "./plugin";