@h-rig/product-entrypoint-plugin 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/metadata.d.ts

@@ -7,6 +7,8 @@ export type StandardProductCommandDescriptor = {
 export declare const STANDARD_PRODUCT_COMMANDS: readonly StandardProductCommandDescriptor[];
 export declare function standardProductCliCommandId(command: RigProductCommandName): string;
 export declare function standardProductCliCommandMetadata(descriptor: StandardProductCommandDescriptor): {
+    productRoot: boolean;
+    rootDefault?: boolean | undefined;
     id: string;
     family: RigProductCommandName;
     description: string;

package/dist/src/metadata.js

@@ -17,7 +17,9 @@ function standardProductCliCommandMetadata(descriptor) {
     family: descriptor.command,
     description: descriptor.description,
     usage: descriptor.usage,
-    projectRequired: false
+    projectRequired: false,
+    ...descriptor.command === "launch" ? { rootDefault: true } : {},
+    productRoot: true
   };
 }
 export {

package/dist/src/plugin.js

@@ -1,4 +1,268 @@
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/product-entrypoint-plugin/src/reconcile.ts
+import { CUSTOM_TYPE_FOR } from "@rig/contracts";
+async function loadCollabApi() {
+  return await import("@oh-my-pi/pi-coding-agent/collab/api");
+}
+async function loadSessionManager() {
+  return await import("@oh-my-pi/pi-coding-agent/session/session-manager");
+}
+function isRunStatus(value) {
+  return typeof value === "string" && RUN_STATUS_VALUES.has(value);
+}
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.has(status);
+}
+function statusFromSessionEntry(entry) {
+  if (entry.type !== "custom" || entry.customType !== CUSTOM_TYPE_FOR["status-changed"])
+    return null;
+  const data = entry.data !== null && typeof entry.data === "object" ? entry.data : null;
+  if (!data)
+    return null;
+  return isRunStatus(data.to) ? data.to : null;
+}
+function projectRunFromEntries(source, runId) {
+  const entries = typeof source === "object" && source !== null && "getEntries" in source ? source.getEntries() : source;
+  let status = null;
+  for (const entry of entries) {
+    status = statusFromSessionEntry(entry) ?? status;
+  }
+  return { status };
+}
+function pidExists(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultOpenSession(sessionPath) {
+  const { SessionManager } = await loadSessionManager();
+  return await SessionManager.open(sessionPath, undefined, undefined, { suppressBreadcrumb: true });
+}
+function projectionRunId(item) {
+  if (item.runId?.trim())
+    return item.runId.trim();
+  if (item.collab?.sessionId?.trim())
+    return item.collab.sessionId.trim();
+  if (item.session.id?.trim())
+    return item.session.id.trim();
+  return null;
+}
+function isLocallyDiscovered(item) {
+  return item.source === "session-list";
+}
+function isActiveStatus(status) {
+  if (status === null)
+    return false;
+  return !isTerminalRunStatus(status);
+}
+function shouldFlip(item, status, exists) {
+  if (!isActiveStatus(status))
+    return false;
+  if (item.collab?.stale === true)
+    return true;
+  const pid = item.collab?.pid;
+  return isLocallyDiscovered(item) && pid !== undefined && ACTIVE_LOCAL_RUN_STATUSES.has(status) && !exists(pid);
+}
+function failedStatusData(status, at) {
+  return {
+    type: "status-changed",
+    from: status,
+    to: "failed",
+    reason: "lazy-reconcile:dead-pid",
+    actor: { kind: "agent" },
+    at
+  };
+}
+async function reconcileRuns(input, deps = {}) {
+  const listProjections = deps.listCollabSessionProjections ?? (await loadCollabApi()).listCollabSessionProjections;
+  const projectRun = deps.projectRunFromSession ?? projectRunFromEntries;
+  const exists = deps.processExists ?? pidExists;
+  const openSession = deps.openSession ?? defaultOpenSession;
+  const nowIso = deps.nowIso ?? (() => new Date().toISOString());
+  const projections = await listProjections(input.identityFilter);
+  const flipped = [];
+  for (const item of projections) {
+    const runId = projectionRunId(item);
+    const sessionPath = item.session.path || item.collab?.sessionPath || "";
+    if (!runId || !sessionPath)
+      continue;
+    const projection = await projectRun(item.customEntries, runId);
+    const status = projection.status;
+    if (status === null || !shouldFlip(item, status, exists))
+      continue;
+    const session = await openSession(sessionPath);
+    session.appendCustomEntry(CUSTOM_TYPE_FOR["status-changed"], failedStatusData(status, nowIso()));
+    flipped.push({ runId, sessionPath, reason: "lazy-reconcile:dead-pid" });
+  }
+  return { flipped, resumable: flipped };
+}
+var RUN_STATUS_VALUES, TERMINAL_RUN_STATUSES, ACTIVE_LOCAL_RUN_STATUSES;
+var init_reconcile = __esm(() => {
+  RUN_STATUS_VALUES = new Set([
+    "created",
+    "queued",
+    "preparing",
+    "running",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention",
+    "completed",
+    "failed",
+    "stopped"
+  ]);
+  TERMINAL_RUN_STATUSES = new Set([
+    "completed",
+    "failed",
+    "stopped"
+  ]);
+  ACTIVE_LOCAL_RUN_STATUSES = new Set([
+    "created",
+    "preparing",
+    "running",
+    "validating",
+    "reviewing",
+    "closing-out"
+  ]);
+});
+
+// packages/product-entrypoint-plugin/src/product-entrypoint.ts
+var exports_product_entrypoint = {};
+__export(exports_product_entrypoint, {
+  runRigOmpProductCommand: () => runRigOmpProductCommand
+});
+import { resolve } from "path";
+import { runCli } from "@oh-my-pi/pi-coding-agent/cli";
+import { parseArgs } from "@oh-my-pi/pi-coding-agent/cli/args";
+import { resolveCliArgv } from "@oh-my-pi/pi-coding-agent/cli-commands";
+import { prepareAcpTerminalAuthArgs } from "@oh-my-pi/pi-coding-agent/modes/acp/terminal-auth";
+import { runRootCommand } from "@oh-my-pi/pi-coding-agent/main";
+import { createAgentSession } from "@oh-my-pi/pi-coding-agent/sdk";
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import { resolveRigOmpConfigOverlayPath } from "@rig/core/remote-config";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+import { RUN_IDENTITY_ENV } from "@rig/contracts";
+function withRigDefaultConfig(projectRoot, argv) {
+  return ["--config", resolveRigOmpConfigOverlayPath(projectRoot), ...argv];
+}
+async function createRigAgentSession(projectRoot, options = {}) {
+  const { host } = await resolvePluginHost(projectRoot);
+  const sessionExtensions = host.listSessionExtensions();
+  return createAgentSession({
+    ...options,
+    extensions: [...sessionExtensions.map((entry) => (api) => entry.install(api)), ...options.extensions ?? []]
+  });
+}
+function productArgv(input) {
+  if (input.command === "launch" && input.args.length === 0)
+    return [];
+  if (input.command === "launch" && input.args[0]?.startsWith("-"))
+    return [...input.args];
+  return [input.command, ...input.args];
+}
+async function runRigOmpProductCommand(input) {
+  const projectRoot = resolve(input.projectRoot);
+  const previousProjectRoot = process.env.RIG_PROJECT_ROOT;
+  const previousCwd = process.cwd();
+  const identityEnv = await loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const restorePublicIdentityEnv = identityEnv?.applyIdentityEnv(projectRoot) ?? (() => {});
+  process.env.RIG_PROJECT_ROOT = projectRoot;
+  process.chdir(projectRoot);
+  try {
+    const argv = productArgv(input);
+    if (argv[0]?.startsWith("__omp_worker_") || argv[0] === "--smoke-test") {
+      await runCli(argv);
+      return { ok: true, group: "product", command: input.command };
+    }
+    if (process.stdin.isTTY) {
+      const reconcile = await reconcileRuns({
+        workspaceRoot: projectRoot,
+        identityFilter: identityEnv?.identityFilterFromEnv() ?? {}
+      }).catch(() => ({ flipped: [], resumable: [] }));
+      globalThis.__RIG_RESUMABLE__ = reconcile.resumable;
+    }
+    const resolved = resolveCliArgv(argv);
+    if ("error" in resolved) {
+      process.stderr.write(`error: ${resolved.error}
+`);
+      process.exitCode = 1;
+      return { ok: true, group: "product", command: input.command };
+    }
+    const [ompCommand, ...ompCommandArgs] = resolved.argv;
+    if (ompCommand === "launch") {
+      const args = withRigDefaultConfig(projectRoot, ompCommandArgs);
+      await runRootCommand(parseArgs(args), args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    } else if (ompCommand === "acp") {
+      const { args: preparedArgs, terminalAuth } = prepareAcpTerminalAuthArgs(ompCommandArgs);
+      const args = withRigDefaultConfig(projectRoot, preparedArgs);
+      const parsed = parseArgs(args);
+      if (!terminalAuth)
+        parsed.mode = "acp";
+      await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    } else if (ompCommand === "join") {
+      const link = ompCommandArgs[0]?.trim();
+      if (!link) {
+        process.stderr.write(`Usage: rig join <link>
+`);
+        process.exitCode = 1;
+        return { ok: true, group: "product", command: input.command };
+      }
+      if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write(`rig join requires an interactive terminal
+`);
+        process.exitCode = 1;
+        return { ok: true, group: "product", command: input.command };
+      }
+      const args = withRigDefaultConfig(projectRoot, []);
+      const parsed = parseArgs(args);
+      parsed.join = link;
+      await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    } else {
+      await runCli(resolved.argv);
+    }
+    return { ok: true, group: "product", command: input.command };
+  } finally {
+    restorePublicIdentityEnv();
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) {
+      delete process.env.RIG_PROJECT_ROOT;
+    } else {
+      process.env.RIG_PROJECT_ROOT = previousProjectRoot;
+    }
+  }
+}
+var RunIdentityEnvCap;
+var init_product_entrypoint = __esm(() => {
+  init_reconcile();
+  RunIdentityEnvCap = defineCapability(RUN_IDENTITY_ENV);
+});
+
 // packages/product-entrypoint-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core/config";
 
@@ -20,21 +284,22 @@ function standardProductCliCommandMetadata(descriptor) {
     family: descriptor.command,
     description: descriptor.description,
     usage: descriptor.usage,
-    projectRequired: false
+    projectRequired: false,
+    ...descriptor.command === "launch" ? { rootDefault: true } : {},
+    productRoot: true
   };
 }
 
 // packages/product-entrypoint-plugin/src/plugin.ts
 async function importProductEntrypoint() {
-  const specifier = ["./product", "-entrypoint"].join("");
-  return await import(specifier);
+  return await Promise.resolve().then(() => (init_product_entrypoint(), exports_product_entrypoint));
 }
 function createStandardProductCliCommand(descriptor) {
   return {
     ...standardProductCliCommandMetadata(descriptor),
     run: async (context, args) => {
-      const { runRigOmpProductCommand } = await importProductEntrypoint();
-      return runRigOmpProductCommand({
+      const { runRigOmpProductCommand: runRigOmpProductCommand2 } = await importProductEntrypoint();
+      return runRigOmpProductCommand2({
         projectRoot: context.projectRoot,
         command: descriptor.command,
         args

package/dist/src/product-entrypoint.js

@@ -9,23 +9,62 @@ import { resolveCliArgv } from "@oh-my-pi/pi-coding-agent/cli-commands";
 import { prepareAcpTerminalAuthArgs } from "@oh-my-pi/pi-coding-agent/modes/acp/terminal-auth";
 import { runRootCommand } from "@oh-my-pi/pi-coding-agent/main";
 import { createAgentSession } from "@oh-my-pi/pi-coding-agent/sdk";
-import { applyIdentityEnv, identityFilterFromEnv } from "@rig/runtime/control-plane/identity-env";
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import { resolveRigOmpConfigOverlayPath } from "@rig/core/remote-config";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+import { RUN_IDENTITY_ENV } from "@rig/contracts";
 
 // packages/product-entrypoint-plugin/src/reconcile.ts
-import {
-  CUSTOM_TYPE_FOR,
-  foldRunSessionEntries,
-  isTerminalRunStatus
-} from "@rig/contracts";
+import { CUSTOM_TYPE_FOR } from "@rig/contracts";
 async function loadCollabApi() {
   return await import("@oh-my-pi/pi-coding-agent/collab/api");
 }
 async function loadSessionManager() {
   return await import("@oh-my-pi/pi-coding-agent/session/session-manager");
 }
+var RUN_STATUS_VALUES = new Set([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention",
+  "completed",
+  "failed",
+  "stopped"
+]);
+var TERMINAL_RUN_STATUSES = new Set([
+  "completed",
+  "failed",
+  "stopped"
+]);
+function isRunStatus(value) {
+  return typeof value === "string" && RUN_STATUS_VALUES.has(value);
+}
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.has(status);
+}
+function statusFromSessionEntry(entry) {
+  if (entry.type !== "custom" || entry.customType !== CUSTOM_TYPE_FOR["status-changed"])
+    return null;
+  const data = entry.data !== null && typeof entry.data === "object" ? entry.data : null;
+  if (!data)
+    return null;
+  return isRunStatus(data.to) ? data.to : null;
+}
 function projectRunFromEntries(source, runId) {
   const entries = typeof source === "object" && source !== null && "getEntries" in source ? source.getEntries() : source;
-  return foldRunSessionEntries(entries, runId);
+  let status = null;
+  for (const entry of entries) {
+    status = statusFromSessionEntry(entry) ?? status;
+  }
+  return { status };
 }
 var ACTIVE_LOCAL_RUN_STATUSES = new Set([
   "created",
@@ -109,15 +148,16 @@ async function reconcileRuns(input, deps = {}) {
 }
 
 // packages/product-entrypoint-plugin/src/product-entrypoint.ts
-import rigExtension from "@rig/rig-extension";
-import { resolveRigOmpConfigOverlayPath } from "@rig/runtime/control-plane/remote-config";
+var RunIdentityEnvCap = defineCapability(RUN_IDENTITY_ENV);
 function withRigDefaultConfig(projectRoot, argv) {
   return ["--config", resolveRigOmpConfigOverlayPath(projectRoot), ...argv];
 }
-function createRigAgentSession(options = {}) {
+async function createRigAgentSession(projectRoot, options = {}) {
+  const { host } = await resolvePluginHost(projectRoot);
+  const sessionExtensions = host.listSessionExtensions();
   return createAgentSession({
     ...options,
-    extensions: [(api) => rigExtension(api), ...options.extensions ?? []]
+    extensions: [...sessionExtensions.map((entry) => (api) => entry.install(api)), ...options.extensions ?? []]
   });
 }
 function productArgv(input) {
@@ -131,7 +171,8 @@ async function runRigOmpProductCommand(input) {
   const projectRoot = resolve(input.projectRoot);
   const previousProjectRoot = process.env.RIG_PROJECT_ROOT;
   const previousCwd = process.cwd();
-  const restorePublicIdentityEnv = applyIdentityEnv(projectRoot);
+  const identityEnv = await loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const restorePublicIdentityEnv = identityEnv?.applyIdentityEnv(projectRoot) ?? (() => {});
   process.env.RIG_PROJECT_ROOT = projectRoot;
   process.chdir(projectRoot);
   try {
@@ -143,7 +184,7 @@ async function runRigOmpProductCommand(input) {
     if (process.stdin.isTTY) {
       const reconcile = await reconcileRuns({
         workspaceRoot: projectRoot,
-        identityFilter: identityFilterFromEnv()
+        identityFilter: identityEnv?.identityFilterFromEnv() ?? {}
       }).catch(() => ({ flipped: [], resumable: [] }));
       globalThis.__RIG_RESUMABLE__ = reconcile.resumable;
     }
@@ -157,14 +198,14 @@ async function runRigOmpProductCommand(input) {
     const [ompCommand, ...ompCommandArgs] = resolved.argv;
     if (ompCommand === "launch") {
       const args = withRigDefaultConfig(projectRoot, ompCommandArgs);
-      await runRootCommand(parseArgs(args), args, { createAgentSession: createRigAgentSession });
+      await runRootCommand(parseArgs(args), args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
     } else if (ompCommand === "acp") {
       const { args: preparedArgs, terminalAuth } = prepareAcpTerminalAuthArgs(ompCommandArgs);
       const args = withRigDefaultConfig(projectRoot, preparedArgs);
       const parsed = parseArgs(args);
       if (!terminalAuth)
         parsed.mode = "acp";
-      await runRootCommand(parsed, args, { createAgentSession: createRigAgentSession });
+      await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
     } else if (ompCommand === "join") {
       const link = ompCommandArgs[0]?.trim();
       if (!link) {
@@ -182,7 +223,7 @@ async function runRigOmpProductCommand(input) {
       const args = withRigDefaultConfig(projectRoot, []);
       const parsed = parseArgs(args);
       parsed.join = link;
-      await runRootCommand(parsed, args, { createAgentSession: createRigAgentSession });
+      await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
     } else {
       await runCli(resolved.argv);
     }

package/dist/src/reconcile.d.ts

@@ -31,5 +31,4 @@ export type LazyReconcileInput = {
     readonly identityFilter: CollabRegistryFilter;
 };
 export declare function reconcileRuns(input: LazyReconcileInput, deps?: LazyReconcileDeps): Promise<LazyReconcileResult>;
-export declare const runLazyReconcile: typeof reconcileRuns;
 export {};

package/dist/src/reconcile.js

@@ -2,20 +2,55 @@
 var __require = import.meta.require;
 
 // packages/product-entrypoint-plugin/src/reconcile.ts
-import {
-  CUSTOM_TYPE_FOR,
-  foldRunSessionEntries,
-  isTerminalRunStatus
-} from "@rig/contracts";
+import { CUSTOM_TYPE_FOR } from "@rig/contracts";
 async function loadCollabApi() {
   return await import("@oh-my-pi/pi-coding-agent/collab/api");
 }
 async function loadSessionManager() {
   return await import("@oh-my-pi/pi-coding-agent/session/session-manager");
 }
+var RUN_STATUS_VALUES = new Set([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention",
+  "completed",
+  "failed",
+  "stopped"
+]);
+var TERMINAL_RUN_STATUSES = new Set([
+  "completed",
+  "failed",
+  "stopped"
+]);
+function isRunStatus(value) {
+  return typeof value === "string" && RUN_STATUS_VALUES.has(value);
+}
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.has(status);
+}
+function statusFromSessionEntry(entry) {
+  if (entry.type !== "custom" || entry.customType !== CUSTOM_TYPE_FOR["status-changed"])
+    return null;
+  const data = entry.data !== null && typeof entry.data === "object" ? entry.data : null;
+  if (!data)
+    return null;
+  return isRunStatus(data.to) ? data.to : null;
+}
 function projectRunFromEntries(source, runId) {
   const entries = typeof source === "object" && source !== null && "getEntries" in source ? source.getEntries() : source;
-  return foldRunSessionEntries(entries, runId);
+  let status = null;
+  for (const entry of entries) {
+    status = statusFromSessionEntry(entry) ?? status;
+  }
+  return { status };
 }
 var ACTIVE_LOCAL_RUN_STATUSES = new Set([
   "created",
@@ -97,8 +132,6 @@ async function reconcileRuns(input, deps = {}) {
   }
   return { flipped, resumable: flipped };
 }
-var runLazyReconcile = reconcileRuns;
 export {
-  runLazyReconcile,
   reconcileRuns
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/product-entrypoint-plugin",
-  "version": "0.0.6-alpha.156",
+  "version": "0.0.6-alpha.158",
   "type": "module",
   "description": "Standard Rig product entrypoint plugin boundary for OMP-backed product commands.",
   "license": "UNLICENSED",
@@ -31,8 +31,7 @@
   },
   "dependencies": {
     "@oh-my-pi/pi-coding-agent": "16.0.4",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.156",
-    "@rig/rig-extension": "npm:@h-rig/rig-extension@0.0.6-alpha.156",
-    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.156"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.158",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.158"
   }
 }