@uniqbit/mate-core 0.15.5-canary.1 → 0.15.5-canary.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniqbit/mate-core",
-  "version": "0.15.5-canary.1",
+  "version": "0.15.5-canary.2",
   "description": "Core framework and plugin APIs for Mate.",
   "license": "MIT",
   "files": [

package/src/cli/commands/workspace/open.ts

@@ -17,8 +17,8 @@ export const workspaceOpenCommandDeps = {
 /**
  * @command mate companion open
  * @description Updates the managed `.mate/workspace.code-workspace` file for
- * the active working repository and companion. When that workspace is open,
- * the editor reloads it in place; otherwise the command falls back to `--add`.
+ * the active working repository and companion, then adds both folders to the
+ * current editor window via `--add`.
  * @remarks Throws if the active repository (from `MATE_REPO_ID`) isn't found
  * in the registry; sets a non-zero exit code if the editor CLI is unavailable,
  * or if the working repo is linked from multiple companions and the ambiguity
@@ -59,5 +59,7 @@ export async function runWorkspaceOpenCommand(): Promise<void> {
     return;
   }
 
-  console.log('Workspace: updated .mate/workspace.code-workspace; open it via "Open Workspace"');
+  console.log(
+    "Workspace: added to the current editor window; persistent file at .mate/workspace.code-workspace",
+  );
 }

package/src/lib/orchestrator/editor.ts

@@ -1,14 +1,9 @@
 import { execFileSync, spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
 
 type SpawnLike = typeof spawn;
-type StatusProcess = typeof execFileSync;
-type ReadStorage = typeof readFileSync;
-
-export type EditorWorkspaceState = "open" | "not-open" | "undetermined";
 
 const CURSOR_FALLBACK_PATHS = [
   "/usr/local/bin/cursor",
@@ -84,62 +79,6 @@ export function editorWorkspacePath(repoPath: string): string {
   return path.join(path.resolve(repoPath), ".mate", "workspace.code-workspace");
 }
 
-function editorStoragePath(cli: string): string {
-  const appName =
-    cli === "cursor" ? "Cursor" : cli === "code-insiders" ? "Code - Insiders" : "Code";
-  if (process.platform === "darwin") {
-    return path.join(
-      process.env.HOME ?? "",
-      "Library",
-      "Application Support",
-      appName,
-      "User",
-      "globalStorage",
-      "storage.json",
-    );
-  }
-  if (process.platform === "win32") {
-    return path.join(process.env.APPDATA ?? "", appName, "User", "globalStorage", "storage.json");
-  }
-  return path.join(
-    process.env.XDG_CONFIG_HOME ?? path.join(process.env.HOME ?? "", ".config"),
-    appName,
-    "User",
-    "globalStorage",
-    "storage.json",
-  );
-}
-
-export function detectEditorWorkspaceState(
-  workspacePath: string,
-  cli: string,
-  statusProcess: StatusProcess = execFileSync,
-  readStorage: ReadStorage = readFileSync,
-): EditorWorkspaceState {
-  const binary = resolveEditorBinary(cli);
-  if (!binary) return "undetermined";
-
-  try {
-    statusProcess(binary, ["--status"], { stdio: ["ignore", "pipe", "ignore"] });
-    const storage = JSON.parse(readStorage(editorStoragePath(cli), "utf8").toString()) as {
-      windowsState?: {
-        lastActiveWindow?: { workspaceIdentifier?: { configURIPath?: string } };
-        openedWindows?: Array<{ workspaceIdentifier?: { configURIPath?: string } }>;
-      };
-    };
-    const workspaceUri = pathToFileURL(path.resolve(workspacePath)).toString();
-    const windows = [
-      storage.windowsState?.lastActiveWindow,
-      ...(storage.windowsState?.openedWindows ?? []),
-    ];
-    return windows.some((window) => window?.workspaceIdentifier?.configURIPath === workspaceUri)
-      ? "open"
-      : "not-open";
-  } catch {
-    return "undetermined";
-  }
-}
-
 export interface WorkspaceDocument {
   workspacePath: string;
   folders: [string, string];
@@ -178,10 +117,6 @@ export async function injectEditorFolder(
   repoPath: string,
   cli = "code",
   spawnProcess: SpawnLike = spawn,
-  detectWorkspace: (
-    workspacePath: string,
-    cli: string,
-  ) => EditorWorkspaceState = detectEditorWorkspaceState,
 ): Promise<boolean> {
   const resolved = resolveEditorCli(cli);
   if (!resolved) {
@@ -194,14 +129,9 @@ export async function injectEditorFolder(
     return false;
   }
 
-  const { cli: resolvedCli, binary } = resolved;
-
-  const { workspacePath, folders: workspaceFolders } = await writeWorkspaceDocument(
-    companionPath,
-    repoPath,
-  );
+  const { binary } = resolved;
 
-  if (detectWorkspace(workspacePath, resolvedCli) === "open") return true;
+  const { folders: workspaceFolders } = await writeWorkspaceDocument(companionPath, repoPath);
 
   const child = spawnProcess(binary, ["--add", ...workspaceFolders], {
     stdio: "ignore",

package/src/lib/orchestrator/types.ts

@@ -102,7 +102,11 @@ export type PluginDeclarationPolicy = "default" | "optional";
 export interface PluginDeclaration {
   /** npm package name (e.g. `@acme/custom-plugin`). */
   package: string;
-  /** Exact version, semver range, or the literal `latest`. */
+  /**
+   * Exact version, semver range, or a moving tag (`latest`, `canary`). Moving
+   * tags are re-resolved via `npm update` on every `mate install`; anything
+   * else is pinned and only re-resolves when the declaration changes.
+   */
   version: string;
   /** Registration policy; absent means `optional`. */
   policy?: PluginDeclarationPolicy;

package/src/tools/setup/dynamic-plugins/install.ts

@@ -44,7 +44,10 @@ function defaultNpmInstall(workspaceRoot: string): { ok: boolean; detail?: strin
   return { ok: true };
 }
 
-/** Runs `npm update <pkg...>` to force re-resolution of `latest`-declared plugins every run. */
+/** Version literals treated as moving targets: re-resolved via `npm update` on every run. */
+const MOVING_VERSION_TAGS = new Set(["latest", "canary"]);
+
+/** Runs `npm update <pkg...>` to force re-resolution of moving-tag-declared plugins every run. */
 function defaultNpmUpdate(
   workspaceRoot: string,
   packages: string[],
@@ -102,12 +105,13 @@ async function writeWorkspaceManifest(
  * `.mate/plugins/`. Builds a single `dependencies` map (package
  * → declared version, sorted by name) and diffs it against the workspace's
  * current `package.json` plus each package's actual installed presence; an
- * identical, fully-installed map with no `latest` declaration skips the
- * install entirely. Otherwise the map is written and `npm install` runs once
- * for the whole workspace. `latest`-declared plugins additionally get an
- * `npm update` every run, regardless of whether the map changed, so they
- * re-resolve on every run. The shared, committed `package-lock.json` is the
- * sole reproducibility record; nothing else pins versions. Private
+ * identical, fully-installed map with no moving-tag declaration (`latest` or
+ * `canary`) skips the install entirely. Otherwise the map is written and
+ * `npm install` runs once for the whole workspace. Moving-tag-declared
+ * plugins additionally get an `npm update` every run, regardless of whether
+ * the map changed, so they re-resolve on every run. The shared, committed
+ * `package-lock.json` is the sole reproducibility record; nothing else pins
+ * versions. Private
  * registries are never Mate's concern: installs run through the operator's
  * own ambient npm config, or a project-local, gitignored `.npmrc` dropped
  * next to the workspace's `package.json`.
@@ -134,12 +138,12 @@ export async function installDeclaredPlugins(
     ),
   ]);
 
-  const latestPackages = sorted
-    .filter((declaration) => declaration.version === "latest")
+  const movingPackages = sorted
+    .filter((declaration) => MOVING_VERSION_TAGS.has(declaration.version))
     .map((declaration) => declaration.package);
   const manifestMatches = JSON.stringify(desired) === JSON.stringify(current);
   const allInstalled = installedBefore.every((version) => version !== null);
-  const unchanged = latestPackages.length === 0 && manifestMatches && allInstalled;
+  const unchanged = movingPackages.length === 0 && manifestMatches && allInstalled;
 
   if (unchanged) {
     return sorted.map((declaration, index) => ({
@@ -156,8 +160,8 @@ export async function installDeclaredPlugins(
     : (installOutcome.detail ?? "npm install failed");
 
   let updateFailure: string | undefined;
-  if (latestPackages.length > 0) {
-    const updateOutcome = await runNpmUpdate(workspaceRoot, latestPackages);
+  if (movingPackages.length > 0) {
+    const updateOutcome = await runNpmUpdate(workspaceRoot, movingPackages);
     updateFailure = updateOutcome.ok ? undefined : (updateOutcome.detail ?? "npm update failed");
   }
 
@@ -168,8 +172,8 @@ export async function installDeclaredPlugins(
   );
 
   return sorted.map((declaration, index) => {
-    const isLatest = declaration.version === "latest";
-    const failure = installFailure ?? (isLatest ? updateFailure : undefined);
+    const isMoving = MOVING_VERSION_TAGS.has(declaration.version);
+    const failure = installFailure ?? (isMoving ? updateFailure : undefined);
     if (failure) {
       return { package: declaration.package, status: "failed", error: failure };
     }

package/src/tools/setup/plugins/gitignore.ts

@@ -73,7 +73,7 @@ export function collectManagedGitignoreEntries(ctx: SetupContext, plugins: Plugi
     // Holds absolute local paths of every linked working repo; never shared
     // across machines or committed to the companion repo.
     `.${FRAMEWORK_NAME}/config/registry.yaml`,
-    ".mcp.json*",
+    ".mcp.json.bak",
     ...plugins
       .filter((p) => p.kind !== "root" && (p.isEnabled(ctx.config) || p.persistGitignoreEntries))
       .flatMap((p) => p.gitignoreEntries?.(ctx) ?? []),