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

package/src/lib/orchestrator/projection-claude-entry.ts

@@ -0,0 +1,198 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { TOKENSAVE_CLAUDE_MD_MARKER } from "../../tools/setup/capabilities/tokensave-shared";
+import { cutFromMarker } from "../../tools/setup/providers/agent-file-sections";
+import {
+  filterClaudeHookGroups,
+  isManagedHookGroup,
+  removeManagedHookGroups,
+  serializeClaudeSettings,
+  type ClaudeSettings,
+} from "../../tools/setup/providers/claude-format";
+import { isMateGuardHookGroup } from "../../tools/setup/providers/claude-plugin-hooks";
+import { pruneEmptyAncestors } from "../../tools/setup/utils";
+import { GlobalConfigStore } from "./global-config-store";
+
+/**
+ * The working-repo half of the Claude Runtime Surface, as one Managed Projection
+ * entry. Depends on the Claude settings *format* only: it never reaches back
+ * into the provider, so a second Agent Runtime writing the same destination adds
+ * a sibling module rather than a branch here.
+ */
+
+export const CLAUDE_WORKING_SETTINGS_PATH = path.join(".claude", "settings.local.json");
+export const LEGACY_TOKENSAVE_CLAUDE_MD_PATH = "CLAUDE.md";
+
+function settingsPath(repoPath: string): string {
+  return path.join(path.resolve(repoPath), CLAUDE_WORKING_SETTINGS_PATH);
+}
+
+function claudeMdPath(repoPath: string): string {
+  return path.join(path.resolve(repoPath), LEGACY_TOKENSAVE_CLAUDE_MD_PATH);
+}
+
+async function readRaw(filePath: string): Promise<string | null> {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function parseSettings(raw: string | null): ClaudeSettings {
+  if (raw === null) return {};
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (parsed && typeof parsed === "object") return parsed as ClaudeSettings;
+  } catch {
+    /* unparseable — start from an empty object */
+  }
+  return {};
+}
+
+/**
+ * Strips the managed hook groups earlier releases wrote here, but leaves the
+ * guard group the `wrap` scope places: that one is managed by another entry,
+ * and stripping it would disarm every Unmanaged Session on the next launch.
+ */
+function withoutForeignManagedHookGroups(settings: ClaudeSettings): ClaudeSettings {
+  const hooks = filterClaudeHookGroups(
+    settings.hooks ?? {},
+    (group) => isMateGuardHookGroup(group) || !isManagedHookGroup(group),
+  );
+  const next = { ...settings };
+  if (Object.keys(hooks).length > 0) next.hooks = hooks;
+  else delete next.hooks;
+  return next;
+}
+
+/**
+ * Reconciles `permissions.additionalDirectories` so the active companion is
+ * reachable and no other registered companion lingers, and strips hook groups
+ * earlier releases wrote here. Everything else in the document is preserved
+ * byte-for-byte: an unchanged document is not rewritten, so `current` really
+ * means untouched.
+ */
+export async function syncWorkingRepoClaudeAdditionalDirectories(
+  repoPath: string,
+  companionPath: string,
+  globalConfigStore: GlobalConfigStore = new GlobalConfigStore(),
+): Promise<"written" | "current"> {
+  const target = settingsPath(repoPath);
+  const raw = await readRaw(target);
+  const existing = withoutForeignManagedHookGroups(parseSettings(raw));
+  const permissions = { ...existing.permissions };
+  const existingAdditionalDirectories = Array.isArray(permissions.additionalDirectories)
+    ? permissions.additionalDirectories
+    : [];
+  const registeredCompanionPaths = new Set(
+    (await globalConfigStore.list()).map((registeredCompanionPath) =>
+      path.resolve(registeredCompanionPath),
+    ),
+  );
+  const resolvedCompanionPath = path.resolve(companionPath);
+  const additionalDirectories = Array.from(
+    new Set(
+      existingAdditionalDirectories
+        .map((directory) => path.resolve(directory))
+        .filter(
+          (directory) =>
+            !registeredCompanionPaths.has(directory) || directory === resolvedCompanionPath,
+        )
+        .concat(resolvedCompanionPath),
+    ),
+  );
+
+  const next = serializeClaudeSettings({
+    ...existing,
+    permissions: {
+      ...permissions,
+      additionalDirectories,
+    },
+  });
+  if (next === raw) return "current";
+
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.writeFile(target, next, "utf8");
+  return "written";
+}
+
+/**
+ * Strips Mate's entries and leaves the document Mate found. A document carrying
+ * none of them is not rewritten at all, so its formatting survives; a document
+ * left empty is deleted along with any directory Mate created to hold it.
+ */
+export async function removeWorkingRepoClaudeSettings(
+  repoPath: string,
+  registeredCompanionPaths: string[] = [],
+): Promise<"removed" | "absent"> {
+  const target = settingsPath(repoPath);
+  const raw = await readRaw(target);
+  if (raw === null) return "absent";
+
+  const existing = parseSettings(raw);
+  const settings = removeManagedHookGroups(existing);
+  const permissions = { ...settings.permissions };
+  const managedPaths = new Set(
+    registeredCompanionPaths.map((candidate) => path.resolve(candidate)),
+  );
+  const currentDirectories = Array.isArray(permissions.additionalDirectories)
+    ? permissions.additionalDirectories
+    : [];
+  const additionalDirectories = currentDirectories.filter(
+    (candidate) => !managedPaths.has(path.resolve(candidate)),
+  );
+  if (additionalDirectories.length > 0) {
+    permissions.additionalDirectories = additionalDirectories;
+  } else {
+    delete permissions.additionalDirectories;
+  }
+  if (Object.keys(permissions).length > 0) {
+    settings.permissions = permissions;
+  } else {
+    delete settings.permissions;
+  }
+
+  if (JSON.stringify(settings) === JSON.stringify(existing)) return "absent";
+  if (Object.keys(settings).length === 0) {
+    await fs.unlink(target);
+    await pruneEmptyAncestors(path.dirname(target), path.resolve(repoPath));
+    return "removed";
+  }
+  await fs.writeFile(target, serializeClaudeSettings(settings), "utf8");
+  return "removed";
+}
+
+/** Present when Mate's own key is in the document, not merely when it exists. */
+export async function workingRepoClaudeSettingsPresent(repoPath: string): Promise<boolean> {
+  const settings = parseSettings(await readRaw(settingsPath(repoPath)));
+  return Array.isArray(settings.permissions?.additionalDirectories);
+}
+
+/**
+ * The TokenSave installer appends a block to a Working Repository's `CLAUDE.md`.
+ * Mate never writes it, which is why the entry is removal-only: a launch strips
+ * it the same way `unproject` does.
+ */
+export async function stripTokensaveClaudeMdAppend(
+  repoPath: string,
+): Promise<"removed" | "absent"> {
+  const target = claudeMdPath(repoPath);
+  const content = await readRaw(target);
+  if (content === null) return "absent";
+
+  const stripped = cutFromMarker(content, TOKENSAVE_CLAUDE_MD_MARKER);
+  if (stripped === content) return "absent";
+  if (stripped.length > 0) {
+    await fs.writeFile(target, stripped, "utf8");
+  } else {
+    await fs.unlink(target);
+  }
+  return "removed";
+}
+
+export async function legacyTokensaveClaudeMdPresent(repoPath: string): Promise<boolean> {
+  const content = await readRaw(claudeMdPath(repoPath));
+  return content !== null && content.includes(TOKENSAVE_CLAUDE_MD_MARKER);
+}

package/src/lib/orchestrator/projection-claude-skills.ts

@@ -0,0 +1,120 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { readProjectionFile } from "../../runtime/projection";
+import { pruneEmptyAncestors } from "../../tools/setup/utils";
+
+const CLAUDE_SKILLS_PATH = path.join(".claude", "skills");
+
+async function skillNames(root: string): Promise<string[]> {
+  const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+  const names: string[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const skillPath = path.join(root, entry.name, "SKILL.md");
+    if (
+      await fs
+        .stat(skillPath)
+        .then(() => true)
+        .catch(() => false)
+    )
+      names.push(entry.name);
+  }
+  return names;
+}
+
+async function linkTarget(link: string): Promise<string | null> {
+  const target = await fs.readlink(link).catch(() => null);
+  return target === null ? null : path.resolve(path.dirname(link), target);
+}
+
+async function isManagedSkillLink(link: string, roots: string[]): Promise<boolean> {
+  const target = await linkTarget(link);
+  if (target === null) return false;
+  return roots.some((root) => path.dirname(target) === root);
+}
+
+async function registeredSkillRoots(
+  repoPath: string,
+  companionPath: string | null,
+  registeredCompanionPaths: string[],
+): Promise<string[]> {
+  const projection = readProjectionFile(repoPath);
+  const candidates = [
+    ...registeredCompanionPaths,
+    companionPath ?? "",
+    projection?.projection.companionPath ?? "",
+  ];
+  return [
+    ...new Set(
+      candidates.filter(Boolean).map((candidate) => path.resolve(candidate, CLAUDE_SKILLS_PATH)),
+    ),
+  ];
+}
+
+async function createSkillLink(target: string, link: string): Promise<void> {
+  await fs.symlink(target, link, process.platform === "win32" ? "junction" : "dir");
+}
+
+export async function reconcileWorkingRepoClaudeSkillLinks(
+  repoPath: string,
+  companionPath: string | null,
+  enabled: boolean,
+  registeredCompanionPaths: string[] = [],
+): Promise<"written" | "current"> {
+  const currentRoot = companionPath ? path.resolve(companionPath, CLAUDE_SKILLS_PATH) : null;
+  const roots = await registeredSkillRoots(repoPath, companionPath, registeredCompanionPaths);
+  const targetRoot = path.join(path.resolve(repoPath), CLAUDE_SKILLS_PATH);
+  const existing = await fs.readdir(targetRoot, { withFileTypes: true }).catch(() => []);
+  const sourceNames: Set<string> =
+    currentRoot && enabled ? new Set(await skillNames(currentRoot)) : new Set<string>();
+  let changed = false;
+
+  for (const entry of existing) {
+    if (!entry.isSymbolicLink()) continue;
+    const link = path.join(targetRoot, entry.name);
+    if (!(await isManagedSkillLink(link, roots))) continue;
+
+    const target = await linkTarget(link);
+    if (
+      currentRoot &&
+      enabled &&
+      target === path.join(currentRoot, entry.name) &&
+      sourceNames.has(entry.name)
+    ) {
+      continue;
+    }
+
+    await fs.unlink(link);
+    changed = true;
+  }
+
+  if (currentRoot && enabled && sourceNames.size > 0) {
+    await fs.mkdir(targetRoot, { recursive: true });
+    for (const name of sourceNames) {
+      const link = path.join(targetRoot, name);
+      const existingLink = await fs.lstat(link).catch(() => null);
+      if (existingLink) continue;
+      await createSkillLink(path.join(currentRoot, name), link);
+      changed = true;
+    }
+  }
+
+  if (changed || !enabled) {
+    await pruneEmptyAncestors(targetRoot, path.resolve(repoPath));
+  }
+  return changed ? "written" : "current";
+}
+
+export async function removeWorkingRepoClaudeSkillLinks(
+  repoPath: string,
+  registeredCompanionPaths: string[] = [],
+): Promise<"removed" | "absent"> {
+  const result = await reconcileWorkingRepoClaudeSkillLinks(
+    repoPath,
+    null,
+    false,
+    registeredCompanionPaths,
+  );
+  return result === "written" ? "removed" : "absent";
+}

package/src/lib/orchestrator/projection-companion-link.ts

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { companionLinkPath } from "../../runtime/repo-local";
+
+/**
+ * The one filesystem fact behind "separated but visible": a link at the
+ * Projection Root that makes the Companion Repository reachable by ordinary
+ * path traversal, for every tool, editor and GUI at once. It replaces no
+ * per-runtime directory allow-list — those stay as the fallback for a platform
+ * that permits no link at all.
+ */
+
+/**
+ * A Windows symbolic link needs Developer Mode or elevation; a directory
+ * junction needs neither, and Node creates one through the same call.
+ */
+async function createLink(target: string, link: string): Promise<void> {
+  await fs.symlink(target, link, process.platform === "win32" ? "junction" : "dir");
+}
+
+/** Absolute, so the link survives the Working Repository being moved into place. */
+async function currentTarget(link: string): Promise<string | null> {
+  const target = await fs.readlink(link).catch(() => null);
+  return target === null ? null : path.resolve(path.dirname(link), target);
+}
+
+export async function linkCompanion(
+  repoPath: string,
+  companionPath: string,
+): Promise<"written" | "current"> {
+  const link = companionLinkPath(repoPath);
+  const target = path.resolve(companionPath);
+
+  const existing = await currentTarget(link);
+  if (existing === target) return "current";
+
+  await fs.mkdir(path.dirname(link), { recursive: true });
+  if (existing !== null) await fs.unlink(link);
+  await createLink(target, link);
+  return "written";
+}
+
+/**
+ * `unlink` acts on the link itself. Nothing here may recurse: a recursive
+ * removal at this path would walk into the Companion Repository and delete the
+ * Artifacts the link exists to expose.
+ */
+export async function unlinkCompanion(repoPath: string): Promise<"removed" | "absent"> {
+  const link = companionLinkPath(repoPath);
+  if (!(await fs.lstat(link).catch(() => null))) return "absent";
+  await fs.unlink(link);
+  return "removed";
+}
+
+/** `lstat`, not `access`: a link whose target is gone is still Mate's to remove. */
+export async function companionLinkPresent(repoPath: string): Promise<boolean> {
+  return fs
+    .lstat(companionLinkPath(repoPath))
+    .then(() => true)
+    .catch(() => false);
+}