@mindbridgeio/muse 0.1.0

package/dist/oauth-hook.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { createClaudeOAuthRuntime, createCodexOAuthRuntime, createMuseOAuthRuntime, runOAuthHook } from "./agent-hooks.mjs";
+
+const host = process.argv[2];
+if (host === "codex") runOAuthHook(createCodexOAuthRuntime);
+else if (host === "claude") runOAuthHook(createClaudeOAuthRuntime);
+else if (host === "muse") runOAuthHook(createMuseOAuthRuntime);
+else process.exitCode = 2;

package/dist/project-metadata.mjs

@@ -0,0 +1,159 @@
+import { execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { basename, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const DETECTION_TIMEOUT_MS = 1_000;
+
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function digest(value, length) {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+
+async function beforeDeadline(operation, deadline) {
+  const timeout = deadline - Date.now();
+  if (timeout <= 0) throw new Error("project detection timed out");
+  let timer;
+  try {
+    return await Promise.race([
+      operation(),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("project detection timed out")), timeout);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Returns a credential-free host/path identity for common Git remote forms. */
+export function normalizeGitRemote(value) {
+  const remote = text(value);
+  if (!remote || /^[A-Za-z]:[\\/]/.test(remote)) return "";
+  let host = "";
+  let port = "";
+  let path = "";
+  if (remote.includes("://")) {
+    try {
+      const parsed = new URL(remote);
+      if (!parsed.hostname || !["http:", "https:", "ssh:", "git:"].includes(parsed.protocol)) return "";
+      host = parsed.hostname.toLowerCase();
+      port = parsed.port;
+      path = parsed.pathname;
+    } catch {
+      return "";
+    }
+  } else {
+    const match = remote.match(/^(?:[^@/]+@)?([^:/]+):(.+)$/);
+    if (!match) return "";
+    host = match[1].toLowerCase();
+    path = match[2];
+  }
+  path = path.replace(/[?#].*$/, "").replaceAll("\\", "/").replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "");
+  return host && path ? `${host}${port ? `:${port}` : ""}/${path}` : "";
+}
+
+async function git(cwd, args, deadline, run = execFileAsync) {
+  const timeout = deadline - Date.now();
+  if (timeout <= 0) throw new Error("project detection timed out");
+  const result = await beforeDeadline(() => run("git", ["-C", cwd, ...args], {
+    timeout,
+    maxBuffer: 64 * 1024,
+    windowsHide: true,
+  }), deadline);
+  return text(typeof result === "string" ? result : result.stdout);
+}
+
+async function canonical(path, deadline) {
+  if (!text(path)) return "";
+  try {
+    return await beforeDeadline(() => realpath(resolve(path)), deadline);
+  } catch {
+    return "";
+  }
+}
+
+async function installID(stateRoot, deadline) {
+  const path = resolve(stateRoot, "install-id");
+  const read = async () => {
+    const value = text(await beforeDeadline(() => readFile(path, "utf8"), deadline));
+    if (!value) {
+      const error = new Error("install id is empty");
+      error.code = "EEMPTY";
+      throw error;
+    }
+    await beforeDeadline(() => chmod(path, 0o600), deadline);
+    return value;
+  };
+  const readAfterRace = async () => {
+    while (Date.now() < deadline) {
+      try {
+        return await read();
+      } catch (error) {
+        if (error?.code !== "EEMPTY" && error?.code !== "ENOENT") throw error;
+        await beforeDeadline(() => new Promise((resolve) => setTimeout(resolve, 5)), deadline);
+      }
+    }
+    throw new Error("project detection timed out");
+  };
+  try {
+    const existing = await read();
+    if (existing) return existing;
+  } catch (error) {
+    if (error?.code === "EEMPTY") return readAfterRace();
+    if (error?.code !== "ENOENT") throw error;
+  }
+  await beforeDeadline(() => mkdir(stateRoot, { recursive: true, mode: 0o700 }), deadline);
+  const created = randomUUID();
+  try {
+    await beforeDeadline(() => writeFile(path, `${created}\n`, { flag: "wx", mode: 0o600 }), deadline);
+    return created;
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+    return readAfterRace();
+  }
+}
+
+/** Best-effort project metadata for a lifecycle event. */
+export async function resolveProjectMetadata({ cwd, projectRoot, stateRoot, runGit } = {}) {
+  const deadline = Date.now() + DETECTION_TIMEOUT_MS;
+  const workingDirectory = await canonical(cwd || projectRoot, deadline);
+  if (!workingDirectory || !text(stateRoot)) return undefined;
+  let root = "";
+  try {
+    root = await canonical(await git(workingDirectory, ["rev-parse", "--show-toplevel"], deadline, runGit), deadline);
+  } catch {
+    root = await canonical(projectRoot, deadline) || workingDirectory;
+  }
+  if (!root) return undefined;
+
+  let remoteIdentity = "";
+  try {
+    const remotes = (await git(root, ["remote"], deadline, runGit)).split(/\r?\n/).map(text).filter(Boolean).sort();
+    const remote = remotes.includes("origin") ? "origin" : remotes.includes("upstream") ? "upstream" : remotes[0];
+    if (remote) remoteIdentity = normalizeGitRemote(await git(root, ["remote", "get-url", remote], deadline, runGit));
+  } catch {
+    remoteIdentity = "";
+  }
+
+  const relativeDirectory = relative(root, workingDirectory).replaceAll("\\", "/");
+  const project = {
+    key: "",
+    name: basename(remoteIdentity || root),
+    root,
+    working_directory: workingDirectory,
+    ...(relativeDirectory && !relativeDirectory.startsWith("../") ? { relative_directory: relativeDirectory } : {}),
+    identity_source: remoteIdentity ? "git_remote" : "local",
+  };
+  if (remoteIdentity) project.key = `git:${remoteIdentity}`;
+  else {
+    const id = await installID(stateRoot, deadline);
+    project.key = `local:${digest(id, 12)}:${digest(root, 20)}`;
+  }
+  return { project };
+}

package/hooks/hooks.json

@@ -0,0 +1,52 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"<MINDBRIDGE_MUSE_HOME>/dist/oauth-hook.mjs\" muse",
+            "timeout": 30,
+            "statusMessage": "Loading MindBridge memory"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"<MINDBRIDGE_MUSE_HOME>/dist/oauth-hook.mjs\" muse",
+            "timeout": 10,
+            "statusMessage": "Recording MindBridge context"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"<MINDBRIDGE_MUSE_HOME>/dist/oauth-hook.mjs\" muse",
+            "timeout": 10,
+            "statusMessage": "Recording MindBridge response"
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"<MINDBRIDGE_MUSE_HOME>/dist/oauth-hook.mjs\" muse",
+            "timeout": 30,
+            "statusMessage": "Finalizing MindBridge context"
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@mindbridgeio/muse",
+  "version": "0.1.0",
+  "description": "MindBridge MCP and lifecycle hooks for Muse.",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "mindbridge-muse": "bin/mindbridge-muse.mjs"
+  },
+  "dependencies": {
+    "@napi-rs/keyring": "^1.3.0"
+  },
+  "files": [
+    "bin/mindbridge-muse.mjs",
+    "hooks/",
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node ../../scripts/build-agent-hook-package.mjs muse && node --test bin/mindbridge-muse.test.mjs",
+    "prepack": "node ../../scripts/build-agent-hook-package.mjs muse"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}