@uniqbit/mate-core 0.16.0 → 0.17.0-canary.10

package/src/tools/setup/capabilities/context-mode.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 
 import {
   CONTEXT_MODE_PACKAGE_NAME,
+  CONTEXT_MODE_VERSION,
   getContextModeInstallDir,
   getContextModePackageReference,
   installContextModePackage,
@@ -10,6 +11,7 @@ import {
   validateContextModePackage,
 } from "../../../lib/context-mode-package";
 import { warmOpenCodePackageCache } from "../../../lib/opencode-plugin-package";
+import { installedVersionAt, isPreinstalledPluginPath } from "../../../lib/preinstalled-plugins";
 import type {
   CapabilityPlugin,
   LaunchPreflightContext,
@@ -69,17 +71,43 @@ async function assertNoMcpConflict(ctx: SetupContext, provider: "claude" | "open
   }
 }
 
+/**
+ * Both spellings of a current reference are accepted, because the Runtime
+ * Surface writes either one: the published spec on an ordinary workstation, and
+ * an absolute path into the machine-local workspace where the distribution
+ * supplied an installed copy. Accepting only the first would refuse the launch
+ * on exactly the deployments preinstalled binding exists for.
+ *
+ * Staleness is still caught in both cases — a published reference by its
+ * version, a bound one by the version of the copy it points at — so this is not
+ * the looser check it might look like.
+ */
 async function validateOpenCodeReferences(ctx: LaunchPreflightContext): Promise<string[]> {
   const expected = getContextModePackageReference();
   const diagnostics: string[] = [];
   for (const name of ["opencode.json", "tui.json"]) {
     const configPath = path.join(ctx.companionPath, ".opencode", name);
     const { config } = await readOpenCodeConfig(configPath);
-    if (!getOpenCodePluginReferences(config).includes(expected)) {
+    const references = getOpenCodePluginReferences(config);
+    if (references.includes(expected)) continue;
+
+    const bound = references.find(
+      (reference): reference is string =>
+        typeof reference === "string" &&
+        isPreinstalledPluginPath(reference, CONTEXT_MODE_PACKAGE_NAME),
+    );
+    if (bound !== undefined) {
+      const version = await installedVersionAt(bound);
+      if (version === CONTEXT_MODE_VERSION) continue;
       diagnostics.push(
-        `Missing or stale context-mode package reference in ${configPath}; expected ${expected}.`,
+        `Stale context-mode package reference in ${configPath}; it points at ${bound}, which is ${version ?? "not installed"} rather than ${CONTEXT_MODE_VERSION}.`,
       );
+      continue;
     }
+
+    diagnostics.push(
+      `Missing or stale context-mode package reference in ${configPath}; expected ${expected}.`,
+    );
   }
   return diagnostics;
 }
@@ -117,6 +145,10 @@ export function createContextModePlugin(deps: ContextModePluginDeps = {}): Capab
               reference: getContextModePackageReference(),
               isManagedReference: isContextModePackageReference,
               configFiles: ["opencode.json", "tui.json"],
+              preinstalled: {
+                packageName: CONTEXT_MODE_PACKAGE_NAME,
+                version: CONTEXT_MODE_VERSION,
+              },
             },
           ],
         },

package/src/tools/setup/capabilities/openspec.ts

@@ -6,7 +6,7 @@ import { promisify } from "node:util";
 import { getOpenSpecSchemaSelection } from "../../../lib/orchestrator/setup-compatibilities";
 import { getWrapperBinPath } from "../../../lib/package-paths";
 import { fetchPublicPackageVersion } from "../../../lib/public-npm";
-import { isNewer } from "../../../lib/update-checker";
+import { isNewer, isPinnedDeployment } from "../../../lib/update-checker";
 import { FRAMEWORK_NAME } from "../../../framework";
 import { confirm } from "../../../cli/confirm";
 import type { CapabilityPlugin, RuntimeContributionsByRuntime, SetupContext } from "../plugin";
@@ -63,6 +63,7 @@ export interface OpenSpecPluginDeps {
   wrapperBinPath?: () => string;
   getInstalledVersion?: (pathValue: string) => Promise<string | undefined>;
   fetchLatestVersion?: () => Promise<string | undefined>;
+  isPinnedDeployment?: () => boolean;
 }
 
 const OPEN_SPEC_SUPPORTED_TOOLS = Object.keys(OPENSPEC_TOOL_DIRS) as OpenSpecTool[];
@@ -170,10 +171,17 @@ async function updateOpenSpecIfOutdated(
   deps: Required<
     Pick<
       OpenSpecPluginDeps,
-      "installCommand" | "pathValue" | "getInstalledVersion" | "fetchLatestVersion"
+      | "installCommand"
+      | "pathValue"
+      | "getInstalledVersion"
+      | "fetchLatestVersion"
+      | "isPinnedDeployment"
     >
   >,
 ): Promise<void> {
+  /** Pinned artifacts change tool versions by replacement, never reconciliation. */
+  if (deps.isPinnedDeployment()) return;
+
   const installed = await deps.getInstalledVersion(deps.pathValue());
   if (!installed) return;
 
@@ -204,6 +212,7 @@ async function ensureOpenSpecInstalled(
       | "pathValue"
       | "getInstalledVersion"
       | "fetchLatestVersion"
+      | "isPinnedDeployment"
     >
   >,
 ): Promise<boolean> {
@@ -326,6 +335,7 @@ export function createOpenspecPlugin(deps: OpenSpecPluginDeps = {}): CapabilityP
     wrapperBinPath: deps.wrapperBinPath ?? getWrapperBinPath,
     getInstalledVersion: deps.getInstalledVersion ?? defaultGetInstalledVersion,
     fetchLatestVersion: deps.fetchLatestVersion ?? defaultFetchLatestVersion,
+    isPinnedDeployment: deps.isPinnedDeployment ?? (() => isPinnedDeployment()),
   };
 
   return {

package/src/tools/setup/plugin.ts

@@ -35,7 +35,7 @@ export interface SetupContext {
 export interface LaunchPreflightContext {
   companionPath: string;
   config: FrameworkConfig;
-  repository: LinkedRepository;
+  repository?: LinkedRepository;
   providerId: string;
 }
 
@@ -164,6 +164,12 @@ export interface PluginReferenceContribution {
   isManagedReference(entry: unknown): boolean;
   /** Config files to reconcile, relative to the runtime dir. Defaults to both OpenCode configs. */
   configFiles?: string[];
+  /**
+   * The published package behind `reference`. Where the distribution supplies
+   * an installed copy of exactly this package, the owning Runtime Surface binds
+   * the contribution to those files instead of the published reference.
+   */
+  preinstalled?: { packageName: string; version: string };
 }
 
 /**

package/src/tools/setup/providers/opencode.ts

@@ -19,6 +19,8 @@ import {
 } from "../context-services";
 import type { CapabilityContributionInput, ProviderPlugin, SetupContext } from "../plugin";
 import { surfaceRoot } from "../surface-target";
+import { resolvePreinstalledPluginReference } from "../../../lib/preinstalled-plugins";
+import { getCurrentVersion } from "../../../lib/update-checker";
 import { mergeDir, pruneEmptyAncestors } from "../utils";
 import {
   getOpenCodePluginReferences,
@@ -268,7 +270,14 @@ async function syncOpenCodeRuntimeFiles(
   const dest = path.join(companionPath, ".opencode");
   await fs.mkdir(dest, { recursive: true });
 
-  const pluginReference = getOpenCodePluginPackageReference();
+  // Mate's own plugin binds to an installed copy the same way a Capability's
+  // does: the Runtime Surface writes the reference, so it is what changes it.
+  const pluginReference =
+    (await resolvePreinstalledPluginReference(
+      companionPath,
+      OPENCODE_PLUGIN_PACKAGE_NAME,
+      getCurrentVersion(),
+    )) ?? getOpenCodePluginPackageReference();
 
   await syncOpenCodeConfigFile(
     path.join(src, "opencode.json"),
@@ -439,6 +448,19 @@ export async function reconcileOpenCodeContributions(
 
   for (const input of inputs) {
     for (const pluginReference of input.contributions.pluginReferences ?? []) {
+      // The Runtime Surface owns the reference it writes, so it is also what
+      // binds one to an installed copy. Absent a copy, the published reference
+      // is written exactly as before.
+      const preinstalled = pluginReference.preinstalled;
+      const installedPath =
+        input.enabled && preinstalled
+          ? await resolvePreinstalledPluginReference(
+              ctx.companionPath,
+              preinstalled.packageName,
+              preinstalled.version,
+            )
+          : null;
+      const reference = installedPath ?? pluginReference.reference;
       const configFiles = pluginReference.configFiles ?? OPENCODE_CONTRIBUTION_CONFIG_FILES;
       for (const name of configFiles) {
         const configPath = path.join(root, ".opencode", name);
@@ -447,10 +469,7 @@ export async function reconcileOpenCodeContributions(
         const preserved = getOpenCodePluginReferences(config).filter(
           (entry) => !pluginReference.isManagedReference(entry),
         );
-        setOpenCodePluginReferences(
-          config,
-          input.enabled ? [...preserved, pluginReference.reference] : preserved,
-        );
+        setOpenCodePluginReferences(config, input.enabled ? [...preserved, reference] : preserved);
         await writeOpenCodeConfig(configPath, config);
       }
     }