@h-rig/core 0.0.6-alpha.176 → 0.0.6-alpha.178

package/dist/src/project-plugins.js

@@ -225,7 +225,7 @@ function createPluginHost(plugins) {
 // packages/core/src/load-config.ts
 import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
 import { isBuiltin } from "module";
-import { dirname, isAbsolute, join as join2, relative, resolve } from "path";
+import { basename, dirname, isAbsolute, join as join2, relative, resolve } from "path";
 import { pathToFileURL } from "url";
 import { Schema as Schema3 } from "effect";
 import { RigConfig as RigConfig3 } from "@rig/contracts";
@@ -292,8 +292,11 @@ function parseDeclarativeFile(path) {
 }
 function loadDeclarativeConfig(path) {
   const data = parseDeclarativeFile(path);
-  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : {};
-  const useStandard = standardSection.enabled !== false;
+  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : null;
+  if (standardSection?.enabled !== true && standardSection?.enabled !== false) {
+    throw new Error(`Declarative config ${path} must explicitly set [standard] enabled = true or false.`);
+  }
+  const useStandard = standardSection.enabled === true;
   let plugins = [];
   if (useStandard) {
     const resolver = getStandardPluginsResolver();
@@ -335,19 +338,27 @@ function packageNameAndSubpath(specifier) {
 function exportTargetFromEntry(entry) {
   if (typeof entry === "string")
     return entry;
-  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+  if (Array.isArray(entry)) {
+    for (const candidate of entry) {
+      const target = exportTargetFromEntry(candidate);
+      if (target)
+        return target;
+    }
+    return null;
+  }
+  if (entry && typeof entry === "object") {
     const conditions = entry;
-    for (const key of ["bun", "import", "default", "require"]) {
-      if (typeof conditions[key] === "string")
-        return conditions[key];
+    for (const key of ["bun", "node", "import", "default", "require"]) {
+      const target = exportTargetFromEntry(conditions[key]);
+      if (target)
+        return target;
     }
   }
   return null;
 }
 function patternExportTarget(record, subpath) {
-  for (const [pattern, entry] of Object.entries(record)) {
-    if (!pattern.includes("*"))
-      continue;
+  const entries = Object.entries(record).filter(([pattern]) => pattern.includes("*")).sort(([a], [b]) => b.replace("*", "").length - a.replace("*", "").length);
+  for (const [pattern, entry] of entries) {
     const [prefix = "", suffix = ""] = pattern.split("*");
     if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
       continue;
@@ -372,6 +383,49 @@ function exportTargetFromPackageJson(pkg, subpath) {
     return target;
   return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
 }
+function patternImportTarget(record, specifier) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
+      continue;
+    const replacement = specifier.slice(prefix.length, specifier.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function resolvePackagePrivateImport(specifier, importer, projectRoot) {
+  if (!specifier.startsWith("#") || !importer || !isAbsolute(importer))
+    return null;
+  let dir = dirname(importer);
+  const stop = resolve(projectRoot);
+  while (isWithinDir(dir, stop)) {
+    const packageJsonPath = join2(dir, "package.json");
+    if (existsSync2(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+        const imports = pkg.imports;
+        if (imports && typeof imports === "object" && !Array.isArray(imports)) {
+          const record = imports;
+          const target = exportTargetFromEntry(record[specifier]) ?? patternImportTarget(record, specifier);
+          if (target)
+            return resolveModulePath(join2(dir, target));
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+  return null;
+}
 function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
   const storeDir = join2(nodeModulesDir, ".bun");
   if (!existsSync2(storeDir))
@@ -446,8 +500,15 @@ function resolvePackageExportFromDir(packageDir, subpath) {
   if (existsSync2(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-      const target = exportTargetFromPackageJson(pkg, subpath);
-      if (target) {
+      const targets = [
+        exportTargetFromPackageJson(pkg, subpath),
+        ...subpath === "." ? [typeof pkg.module === "string" ? pkg.module : null, typeof pkg.main === "string" ? pkg.main : null] : []
+      ];
+      const seen = new Set;
+      for (const target of targets) {
+        if (!target || seen.has(target))
+          continue;
+        seen.add(target);
         const resolved = resolveModulePath(join2(packageDir, target));
         if (resolved)
           return resolved;
@@ -535,10 +596,17 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
   }
   const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
   const configDir = dirname(configPath);
+  const configProjectRoot = basename(configDir) === ".rig" ? dirname(configDir) : configDir;
   const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
+  const ABSOLUTE_EXTERNAL_NAMESPACE = "rig-config-absolute-external";
   const unresolvedLocalPlugin = {
     name: "rig-config-unresolved-local",
     setup(build) {
+      build.onLoad({ filter: /[\\/]@oh-my-pi[\\/]pi-coding-agent[\\/]src[\\/]export[\\/]html[\\/](?:template\.css|template\.html|template\.js|tool-views\.generated\.js)$/ }, (args) => ({
+        loader: "js",
+        contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
+`
+      }));
       build.onLoad({ filter: /\.(?:html|txt)$/ }, (args) => ({
         loader: "js",
         contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
@@ -548,32 +616,77 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
         const directFilePath = resolvedFilePath(args.path, configDir);
         if (directFilePath)
           return { path: directFilePath };
+        if (args.path.startsWith("#")) {
+          const packagePrivatePath = resolvePackagePrivateImport(args.path, args.importer, configProjectRoot);
+          if (packagePrivatePath)
+            return { path: packagePrivatePath };
+          try {
+            const parent2 = args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configProjectRoot;
+            const resolved = bun.resolveSync?.(args.path, parent2);
+            const filePath = resolvedFilePath(resolved, configProjectRoot);
+            if (filePath)
+              return { path: filePath };
+          } catch {}
+          return;
+        }
         const packageImport = packageNameAndSubpath(args.path);
-        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
-          return { path: args.path, external: true };
+        if (packageImport?.packageName === "uhyphen" && packageImport.subpath === ".") {
+          const uhyphenPath = resolveProjectPackageImport("uhyphen", configProjectRoot);
+          if (uhyphenPath)
+            return { path: uhyphenPath };
         }
-        const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
+        if (packageImport && packageImport.packageName !== "uhyphen") {
+          try {
+            const parent2 = args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configProjectRoot;
+            const resolved = bun.resolveSync?.(args.path, parent2);
+            const filePath = resolvedFilePath(resolved, configProjectRoot);
+            if (filePath)
+              return { path: filePath };
+          } catch {}
+        }
+        const projectPackagePath = packageImport ? resolveProjectPackageImport(args.path, configProjectRoot) : null;
         if (projectPackagePath)
           return { path: projectPackagePath };
+        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
+          return { path: args.path, external: true };
+        }
         if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path))
           return;
         if (packageImport)
           return { path: args.path, external: true };
-        const parentCandidates = args.path.startsWith(".") ? [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : null, configDir].filter((value) => Boolean(value)) : [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configDir];
+        const importerDir = args.importer && isAbsolute(args.importer) ? dirname(args.importer) : null;
+        if (args.path.startsWith(".") && importerDir) {
+          const fromImporter = resolveModulePath(resolve(importerDir, args.path));
+          if (fromImporter)
+            return { path: fromImporter };
+          if (/[\\/]node_modules[\\/]/.test(args.importer ?? ""))
+            return;
+        }
+        const parentCandidates = args.path.startsWith(".") ? [importerDir, configDir].filter((value) => Boolean(value)) : [importerDir ?? configDir];
         for (const parent2 of parentCandidates) {
-          const filePath = resolvedFilePath(resolve(parent2, args.path), configDir);
+          const filePath = resolvedFilePath(resolve(parent2, args.path), configProjectRoot);
           if (filePath)
             return { path: filePath };
         }
         const parent = parentCandidates[0] ?? configDir;
         try {
           const resolved = bun.resolveSync?.(args.path, parent) ?? resolve(parent, args.path);
-          const filePath = resolvedFilePath(resolved, configDir);
+          const filePath = resolvedFilePath(resolved, configProjectRoot);
           if (filePath)
             return { path: filePath };
         } catch {}
         return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
       });
+      build.onLoad({ filter: /.*/, namespace: ABSOLUTE_EXTERNAL_NAMESPACE }, (args) => {
+        const href = pathToFileURL(args.path).href;
+        return {
+          loader: "js",
+          contents: `export * from ${JSON.stringify(href)};
+const mod = await import(${JSON.stringify(href)});
+export default (mod && "default" in mod) ? mod.default : mod;
+`
+        };
+      });
       build.onLoad({ filter: /.*/, namespace: UNRESOLVED_NAMESPACE }, (args) => ({
         loader: "js",
         contents: `module.exports = {};
@@ -585,7 +698,6 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   const result = await bun.build({
     entrypoints: [configPath],
     target: "bun",
-    external: ["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
     format: "esm",
     throw: false,
     packages: "bundle",
@@ -596,7 +708,7 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
 `);
     throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
   }
-  const bundleParentDir = join2(configDir, ".rig", "tmp");
+  const bundleParentDir = join2(configProjectRoot, ".rig", "tmp");
   mkdirSync(bundleParentDir, { recursive: true });
   const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
   try {

package/dist/src/remote-config.d.ts

@@ -1,38 +1,16 @@
-export declare const DEFAULT_REMOTE_PORT = 7890;
-/**
- * Register the transport-owned relay/registry/sshTarget defaults. Called at the
- * transport plugin module's load (plugin → floor). The floor keeps NO product
- * host string or remote-execution target of its own; this is the only way the
- * runtime fallback acquires those defaults. Idempotent and last-write-wins;
- * absent/empty values are ignored so a second caller cannot clear a prior
- * registration.
- */
-export declare function registerBackboneDefaults(defaults: {
-    relayUrl?: string;
-    registryBaseUrl?: string;
-    sshTarget?: string;
-}): void;
-/**
- * The collab relay URL: rig.config.ts (propagated to RIG_COLLAB_RELAY by the CLI)
- * → env → the transport plugin's injected default (see registerBackboneDefaults)
- * → "" (the floor bakes no product host).
- */
-export declare function resolveRelayUrl(env?: NodeJS.ProcessEnv): string;
 /**
- * The remote execution sshTarget: rig.config.ts `runtime.server.sshTarget`
- * (propagated to RIG_SSH_TARGET by the CLI) → env → the transport plugin's
- * injected default (see registerBackboneDefaults) → "" (the floor bakes no
- * product remote target). This is a SEPARATE axis from the backbone server:
- * picking a backbone never changes where runs execute, and vice versa.
+ * Deprecated compatibility subpath. Remote transport configuration, registry /
+ * relay defaults, managed endpoints, dispatch placement, and owner namespace
+ * resolution are owned by @rig/transport-plugin. Core must not implement this
+ * product behavior.
  */
-export declare function resolveSshTarget(env?: NodeJS.ProcessEnv): string;
-export declare const REMOTES_CONFIG_PATH: string;
-type JsonRecord = Record<string, unknown>;
+export declare const DEFAULT_REMOTE_PORT = 7890;
+export declare const REMOTES_CONFIG_PATH = "";
 export declare class RemoteCliError extends Error {
     readonly code: string;
     readonly exitCode: number;
-    readonly details: JsonRecord | undefined;
-    constructor(code: string, message: string, exitCode?: number, details?: JsonRecord);
+    readonly details: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, exitCode?: number, details?: Record<string, unknown>);
 }
 export type RemoteConfigEntry = {
     host?: string;
@@ -91,14 +69,6 @@ export type ManagedRemoteEndpoint = {
     addedAt: string | null;
     lastConnected: string | null;
 };
-export declare function loadRemotesConfig(configPath?: string): RemotesToml;
-/**
- * GitHub owner namespace key that scopes the relay registry. The run (which
- * registers a room) and the cockpit (which lists rooms) MUST derive the SAME
- * value or `list` returns empty. Order: env override → github-auth.userNamespaceKey
- * → derived `gh:${userId}`.
- */
-export declare function resolveOwnerNamespaceKey(projectRoot: string, env?: NodeJS.ProcessEnv): string | undefined;
 export type SelectedRemote = {
     alias: string;
     host: string;
@@ -119,65 +89,37 @@ export type DispatchTransportPlacement = {
     readonly sshTarget: string;
     readonly selected: SelectedRemote | null;
 };
-/**
- * Canonical dispatch-time transport placement. Kernel adoption can happen before
- * a CLI has resolved projectRoot or hydrated env, so transport providers call
- * this at dispatch time instead of letting command/capability callers branch.
- */
-export declare function resolveDispatchTransportPlacement(projectRoot: string, env?: NodeJS.ProcessEnv): DispatchTransportPlacement;
-/**
- * Selected remote placement from connection.json.selected matched against
- * endpoints.toml.alias. Returns null => LOCAL placement. RIG_REMOTE_ALIAS overrides
- * the persisted selection.
- */
-export declare function resolveSelectedRemote(projectRoot: string, env?: NodeJS.ProcessEnv): SelectedRemote | null;
-/**
- * Registry base URL for the selected target (remote), else the transport plugin's
- * injected backbone default (see registerBackboneDefaults), else "" — the floor
- * bakes no product host.
- */
-export declare function resolveRegistryBaseUrl(projectRoot: string, env?: NodeJS.ProcessEnv): string;
-/**
- * The OMP `--config` overlay, DERIVED from rig.config.ts-propagated values
- * (relay/registry via the resolvers above: ambient env → rig.config.ts-filled env →
- * computed default) plus cockpit-quiet. Written to a real temp file so OMP's
- * `--config` gets a normal path; memoized per process. Single source for BOTH the
- * CLI launch and the in-pty agent session (rig-host), so rig.config.ts values
- * propagate identically — no checked-in/embedded YAML, so the binary is self-contained.
- */
-export declare function resolveRigOmpConfigOverlayPath(projectRoot?: string): string;
-export declare function listAuthorityRemoteEndpoints(projectRoot: string): AuthorityMaterializedRemoteEndpoint[];
-export declare function updateAuthorityRemoteEndpoint(projectRoot: string, input: {
-    endpointId?: string | undefined;
-    alias?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    token?: string | undefined;
-    autoConnect?: boolean | undefined;
-    transport?: string | undefined;
-    labels?: string[] | undefined;
-    capabilities?: string[] | undefined;
-}): AuthorityMaterializedRemoteEndpoint | null;
-export declare function markAuthorityRemoteEndpointConnected(projectRoot: string, endpointId: string, connectedAt?: string): void;
-export declare function importLegacyRemoteEndpoints(projectRoot: string, legacyPath?: string): {
-    imported: number;
-    skipped: number;
-    sourcePath: string;
-};
-export declare function doctorAuthorityRemoteEndpoints(projectRoot: string): {
-    manifestPath: string;
-    secretsPath: string;
-    endpointCount: number;
-    missingSecrets: string[];
-    warnings: string[];
-};
-export declare function listManagedRemoteEndpoints(configPath?: string, projectRoot?: string): ManagedRemoteEndpoint[];
-export declare function upsertManagedRemoteEndpoint(input: {
+export declare function registerBackboneDefaults(_defaults: {
+    relayUrl?: string;
+    registryBaseUrl?: string;
+    sshTarget?: string;
+}): void;
+export declare function resolveRelayUrl(_env?: NodeJS.ProcessEnv): string;
+export declare function resolveSshTarget(_env?: NodeJS.ProcessEnv): string;
+export declare function loadRemotesConfig(_configPath?: string): RemotesToml;
+export declare function listManagedRemoteEndpoints(_configPath?: string, _projectRoot?: string): ManagedRemoteEndpoint[];
+export declare function resolveManagedRemoteEndpoint(_alias: string, _configPath?: string, _projectRoot?: string): SelectedRemote | null;
+export declare function upsertManagedRemoteEndpoint(_input: {
     alias: string;
     host: string;
     port: number;
     token?: string;
-}, configPath?: string, projectRoot?: string): ManagedRemoteEndpoint;
-export declare function removeManagedRemoteEndpoint(alias: string, configPath?: string, projectRoot?: string): boolean;
-export declare function normalizeString(value: string | null | undefined): string;
-export {};
+}, _configPath?: string, _projectRoot?: string): ManagedRemoteEndpoint;
+export declare function updateAuthorityRemoteEndpoint(_projectRoot: string, _input: {
+    endpointId?: string;
+    alias?: string;
+    host?: string;
+    port?: number;
+    token?: string;
+    autoConnect?: boolean;
+    transport?: string;
+    labels?: string[];
+    capabilities?: string[];
+}): AuthorityMaterializedRemoteEndpoint | null;
+export declare function removeManagedRemoteEndpoint(_alias: string, _configPath?: string, _projectRoot?: string): boolean;
+export declare function resolveSelectedRemote(_projectRoot: string, _env?: NodeJS.ProcessEnv): SelectedRemote | null;
+export declare function resolveDispatchTransportPlacement(_projectRoot: string, _env?: NodeJS.ProcessEnv): DispatchTransportPlacement;
+export declare function resolveRegistryBaseUrl(_projectRoot: string, _env?: NodeJS.ProcessEnv): string;
+export declare function resolveOwnerNamespaceKey(_projectRoot: string, _env?: NodeJS.ProcessEnv): string | undefined;
+export declare function resolveRigOmpConfigOverlayPath(_projectRoot?: string): string;
+export declare function materializeRigOmpConfigOverlay(_projectRoot: string, _env?: NodeJS.ProcessEnv): string;