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

package/dist/src/worker/local-run-changes.d.ts

@@ -0,0 +1,3 @@
+import { Stream } from "effect";
+export declare function isRelevantLocalRunChange(filename: string | Buffer | null | undefined): boolean;
+export declare const localRunChanges: (projectRoot: string) => Stream.Stream<void>;

package/dist/src/worker/local-run-changes.js

@@ -0,0 +1,65 @@
+// @bun
+// packages/run-plugin/src/worker/local-run-changes.ts
+import { existsSync, mkdirSync, watch } from "fs";
+import { dirname, resolve } from "path";
+import { Effect, Queue, Stream } from "effect";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+function isRelevantLocalRunChange(filename) {
+  if (filename === null || filename === undefined)
+    return true;
+  const raw = filename.toString();
+  if (!raw.trim())
+    return true;
+  const segments = raw.split(/[\\/]+/).filter(Boolean);
+  if (segments.some((segment) => segment === ".git" || segment === "node_modules" || segment === "build" || segment === "dist" || segment === "out" || segment === ".next" || segment === "coverage")) {
+    return false;
+  }
+  const rigIndex = segments.lastIndexOf(".rig");
+  if (rigIndex < 0)
+    return false;
+  const rigChild = segments[rigIndex + 1];
+  if (rigChild === "session")
+    return true;
+  return rigChild === "runtime-context.json" && segments[rigIndex + 2] === undefined;
+}
+var localRunChanges = (projectRoot) => Stream.callback((queue) => Effect.gen(function* () {
+  const worktreesRoot = resolve(resolveCheckoutRoot(projectRoot), ".worktrees");
+  if (!existsSync(worktreesRoot)) {
+    try {
+      mkdirSync(worktreesRoot, { recursive: true });
+    } catch {}
+  }
+  const watcher = watch(worktreesRoot, { recursive: true }, (_event, filename) => {
+    if (!isRelevantLocalRunChange(filename))
+      return;
+    Queue.offerUnsafe(queue, undefined);
+  });
+  watcher.on("error", () => {});
+  yield* Effect.addFinalizer(() => Effect.sync(() => watcher.close()));
+}), { bufferSize: 1, strategy: "sliding" });
+export {
+  localRunChanges,
+  isRelevantLocalRunChange
+};

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

@@ -0,0 +1 @@
+export declare function dispatchRunNotifications(projectRoot: string, runId: string, taskId: string, outcome: "completed" | "failed", detail: string | null): Promise<void>;

package/dist/src/worker/notifications.js

@@ -0,0 +1,27 @@
+// @bun
+// packages/run-plugin/src/worker/notify-cap.ts
+import { NOTIFY_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+var NotifyCap = defineCapability(NOTIFY_SERVICE_CAPABILITY);
+async function resolveNotifyService(projectRoot) {
+  const { host } = await resolvePluginHost(projectRoot);
+  return NotifyCap.resolve(host);
+}
+
+// packages/run-plugin/src/worker/notifications.ts
+async function dispatchRunNotifications(projectRoot, runId, taskId, outcome, detail) {
+  try {
+    const notifier = await resolveNotifyService(projectRoot);
+    if (!notifier)
+      return;
+    const event = { runId, type: `run.${outcome}`, timestamp: new Date().toISOString(), payload: { taskId, detail } };
+    await Promise.race([
+      notifier.notify(event),
+      new Promise((resolveCap) => setTimeout(resolveCap, 5000))
+    ]);
+  } catch {}
+}
+export {
+  dispatchRunNotifications
+};

package/dist/src/worker/notify-cap.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cross-plugin seam: run-exec dispatches run notifications off the host's
+ * NOTIFY capability instead of importing `@rig/notifications-plugin`'s impl
+ * (`dispatchEventToTargets`/`loadNotificationConfig`). `@rig/notifications-plugin`
+ * OWNS the policy (target selection + `.rig/notifications.json` load) and
+ * registers it under {@link NOTIFY_SERVICE_CAPABILITY}; this module is the
+ * run-exec-side resolver so no run-exec file imports the provider impl.
+ */
+import { type NotifyService } from "@rig/contracts";
+/** Resolve the notify service from the project's plugin host, or `null` if unregistered. */
+export declare function resolveNotifyService(projectRoot: string): Promise<NotifyService | null>;

package/dist/src/worker/notify-cap.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/run-plugin/src/worker/notify-cap.ts
+import { NOTIFY_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+var NotifyCap = defineCapability(NOTIFY_SERVICE_CAPABILITY);
+async function resolveNotifyService(projectRoot) {
+  const { host } = await resolvePluginHost(projectRoot);
+  return NotifyCap.resolve(host);
+}
+export {
+  resolveNotifyService
+};

package/dist/src/worker/panel-plugin.d.ts

@@ -0,0 +1,11 @@
+import { RIG_RUN_STOP_PANEL_ACTION, RIG_SUPERVISOR_PANEL_ID, type PanelRegistration, type WorkerPanelProducerContext } from "@rig/contracts";
+import type { Panel } from "@rig/core";
+export { RIG_RUN_STOP_PANEL_ACTION, RIG_SUPERVISOR_PANEL_ID };
+export type { WorkerPanelProducerContext };
+export declare const RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels";
+export interface WorkerPanelRegistrySnapshot {
+    readonly registrations: readonly PanelRegistration[];
+    readonly producers: readonly Panel[];
+}
+export declare function produceWorkerPanelPayload(producer: Panel, context: WorkerPanelProducerContext): Promise<unknown>;
+export declare function loadWorkerPanelRegistry(projectRoot: string): Promise<WorkerPanelRegistrySnapshot>;

package/dist/src/worker/panel-plugin.js

@@ -0,0 +1,37 @@
+// @bun
+// packages/run-plugin/src/worker/panel-plugin.ts
+import { createProjectPluginHost } from "@rig/core/project-plugins";
+import { RIG_CAPABILITY_PANEL_SLOT, RIG_RUN_STOP_PANEL_ACTION, RIG_SUPERVISOR_PANEL_ID } from "@rig/contracts";
+var RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels";
+var PANEL_PRODUCER_TIMEOUT_MS = 2000;
+async function produceWorkerPanelPayload(producer, context) {
+  if (!producer.produce)
+    return;
+  let timeout;
+  try {
+    return await Promise.race([
+      Promise.resolve(producer.produce(context)),
+      new Promise((resolve) => {
+        timeout = setTimeout(() => resolve(undefined), PANEL_PRODUCER_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function loadWorkerPanelRegistry(projectRoot) {
+  const { host } = await createProjectPluginHost(projectRoot, {
+    mode: "strict-config-only"
+  });
+  return {
+    registrations: host.listPanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT),
+    producers: host.listExecutablePanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT)
+  };
+}
+export {
+  produceWorkerPanelPayload,
+  loadWorkerPanelRegistry,
+  RIG_SUPERVISOR_PANEL_ID,
+  RIG_RUN_STOP_PANEL_ACTION,
+  RIG_PANELS_CUSTOM_MESSAGE_TYPE
+};

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

@@ -0,0 +1,3 @@
+import { type RigPlugin } from "@rig/core/config";
+export declare const runWorkerPlugin: RigPlugin;
+export declare function createRunWorkerPlugin(): RigPlugin;