@topolo/cli 0.13.7 → 0.13.8

package/dist/index.js

@@ -158,7 +158,7 @@ import { platform as platform2 } from "os";
 import { createInterface } from "readline/promises";
 import { stdin as input } from "process";
 
-// node_modules/.pnpm/@topolo+sdk@0.23.19/node_modules/@topolo/sdk/dist/index.js
+// node_modules/.pnpm/@topolo+sdk@0.23.20/node_modules/@topolo/sdk/dist/index.js
 function record(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -3768,10 +3768,11 @@ async function pollUntilApproved(params) {
   throw new Error("Device code expired. Run `topolo auth login` again.");
 }
 
-// node_modules/.pnpm/@topolo+sdk@0.23.19/node_modules/@topolo/sdk/dist/node/credential-store.js
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, chmod as chmod2, lstat, readdir as readdir2, rename as rename2, link } from "fs/promises";
+// node_modules/.pnpm/@topolo+sdk@0.23.20/node_modules/@topolo/sdk/dist/node/credential-store.js
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, chmod as chmod2, lstat, readdir as readdir2 } from "fs/promises";
 import { existsSync as existsSync2, mkdirSync, lstatSync, readdirSync, readFileSync as readFileSync2, openSync, writeFileSync, fsyncSync, closeSync, renameSync, unlinkSync, rmdirSync, linkSync } from "fs";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { constants, fstatSync, readSync } from "fs";
 import { homedir as homedir2, platform } from "os";
 import { dirname as dirname2, join as join3 } from "path";
 import { createHash, randomUUID } from "crypto";
@@ -4637,6 +4638,7 @@ async function resolveCredential(environment = selectedEnvironment()) {
 var REFRESH_SKEW_SECONDS = 60;
 var CONFIG_LOCK_RETRY_MS = 25;
 var CONFIG_LOCK_TIMEOUT_MS = 5e3;
+var CONFIG_LOCK_DEAD_OWNER_MIN_AGE_MS = 2e3;
 var ConfigOwnershipError = class extends TopoloSdkError2 {
   constructor() {
     super("state_conflict", "Credential configuration ownership cannot be verified. Retain the unresolved operation instead of starting another renewal.");
@@ -4651,32 +4653,145 @@ function lockEntryExists(path) {
     throw new ConfigOwnershipError();
   }
 }
+function lockIdentity(entry) {
+  return [entry.dev, entry.ino, entry.uid, entry.mode, entry.nlink, entry.size, entry.mtimeMs, entry.ctimeMs];
+}
+function privateLockDirectory(path) {
+  const entry = lstatSync(path);
+  if (typeof process.getuid !== "function" || !entry.isDirectory() || entry.isSymbolicLink() || entry.uid !== process.getuid() || (entry.mode & 511) !== 448) throw new ConfigOwnershipError();
+  return entry;
+}
+function readPrivateLockMarker(path) {
+  const before = lstatSync(path);
+  if (!before.isFile() || before.isSymbolicLink() || before.nlink !== 1 || before.size > 512 || before.uid !== process.getuid?.() || (before.mode & 511) !== 384) throw new ConfigOwnershipError();
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    if (JSON.stringify(lockIdentity(fstatSync(fd))) !== JSON.stringify(lockIdentity(before))) throw new ConfigOwnershipError();
+    const bytes = Buffer.alloc(513);
+    const count = readSync(fd, bytes, 0, bytes.length, 0);
+    if (count !== before.size || count > 512 || JSON.stringify(lockIdentity(fstatSync(fd))) !== JSON.stringify(lockIdentity(before)) || JSON.stringify(lockIdentity(lstatSync(path))) !== JSON.stringify(lockIdentity(before))) throw new ConfigOwnershipError();
+    return bytes.subarray(0, count).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+var OWNER_MARKER_NAME = /^owner-[a-f0-9-]{36}\.json$/;
+function readOwnerMarker(lockPath, name) {
+  const bytes = readPrivateLockMarker(join3(lockPath, name));
+  const owner = JSON.parse(bytes);
+  if (owner.version !== 1 || Object.keys(owner).sort().join(",") !== "identity,pid,version" || name !== "owner-" + owner.identity + ".json" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) throw new ConfigOwnershipError();
+  return { bytes, pid: owner.pid };
+}
+function writePrivateLockRecord(path, bytes) {
+  const fd = openSync(path, "wx", 384);
+  try {
+    writeFileSync(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function deadOwnerMarker(lockPath, ignoreOwnFence = false) {
+  try {
+    if (!ignoreOwnFence && lockEntryExists(lockPath + ".reconcile")) return null;
+    const directory = privateLockDirectory(lockPath);
+    const entries = readdirSync(lockPath);
+    if (entries.length !== 1 || !OWNER_MARKER_NAME.test(entries[0])) return null;
+    const name = entries[0];
+    const { bytes, pid } = readOwnerMarker(lockPath, name);
+    if (Date.now() - lstatSync(join3(lockPath, name)).mtimeMs < CONFIG_LOCK_DEAD_OWNER_MIN_AGE_MS) return null;
+    try {
+      process.kill(pid, 0);
+      return null;
+    } catch (error) {
+      if (error.code !== "ESRCH") return null;
+    }
+    return { directory, name, bytes, pid };
+  } catch {
+    return null;
+  }
+}
+function reclaimDeadOwnerLock(lockPath, markerName, marker) {
+  const observed = deadOwnerMarker(lockPath);
+  if (!observed) return false;
+  const fence = lockPath + ".reconcile";
+  try {
+    mkdirSync(fence, { mode: 448 });
+  } catch {
+    return false;
+  }
+  const fenceMarker = join3(fence, markerName);
+  const quarantine = join3(dirname2(lockPath), ".credential-reclaim-" + randomUUID2());
+  let captured;
+  let reclaimed = false;
+  try {
+    writePrivateLockRecord(fenceMarker, marker);
+    const current = deadOwnerMarker(lockPath, true);
+    if (!current || current.name !== observed.name || current.bytes !== observed.bytes || current.directory.dev !== observed.directory.dev || current.directory.ino !== observed.directory.ino) return false;
+    mkdirSync(quarantine, { mode: 448 });
+    writePrivateLockRecord(join3(quarantine, "receipt.json"), JSON.stringify({
+      schemaVersion: 1,
+      disposition: "DEAD_OWNER_RECLAIMED",
+      lockPath,
+      deadOwnerMarker: current.name,
+      deadOwnerPid: current.pid,
+      deadOwnerEvidence: "ESRCH",
+      reclaimedByPid: process.pid,
+      reclaimedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      configCredentialOrOAuthEffectsByThisReclaim: "none"
+    }, null, 2));
+    captured = join3(quarantine, current.name);
+    renameSync(join3(lockPath, current.name), captured);
+    const directory = privateLockDirectory(lockPath);
+    if (directory.dev !== observed.directory.dev || directory.ino !== observed.directory.ino || readdirSync(lockPath).length) throw new ConfigOwnershipError();
+    writePrivateLockRecord(join3(lockPath, markerName), marker);
+    reclaimed = true;
+  } catch {
+    if (captured && !reclaimed) {
+      try {
+        linkSync(captured, join3(lockPath, observed.name));
+      } catch {
+      }
+    }
+  } finally {
+    try {
+      if (readPrivateLockMarker(fenceMarker) !== marker || readdirSync(fence).length !== 1) throw new ConfigOwnershipError();
+      unlinkSync(fenceMarker);
+      rmdirSync(fence);
+    } catch {
+      reclaimed = false;
+    }
+  }
+  return reclaimed;
+}
+var RELEASE_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 async function withConfigWriteLock(operation) {
   const lockPath = `${configPath()}.lock`;
   await mkdir2(dirname2(lockPath), { recursive: true });
   const startedAt = performance.now();
+  const identity = randomUUID2();
+  const markerName = "owner-" + identity + ".json";
+  const markerPath = join3(lockPath, markerName);
+  const marker = JSON.stringify({ version: 1, identity, pid: process.pid });
   while (true) {
     try {
       if (lockEntryExists(lockPath + ".reconcile")) throw Object.assign(new Error(), { code: "EEXIST" });
-      await mkdir2(lockPath, { mode: 448 });
+      mkdirSync(lockPath, { mode: 448 });
       if (lockEntryExists(lockPath + ".reconcile")) {
         throw new ConfigOwnershipError();
       }
+      writeFileSync(markerPath, marker, { flag: "wx", mode: 384 });
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
+      if (reclaimDeadOwnerLock(lockPath, markerName, marker)) break;
       if (performance.now() - startedAt >= CONFIG_LOCK_TIMEOUT_MS) {
         throw new TopoloSdkError2("state_conflict", "Credential configuration is still held or unresolved. This waiter did not dispatch a renewal.");
       }
       await new Promise((resolve22) => setTimeout(resolve22, CONFIG_LOCK_RETRY_MS));
     }
   }
-  const directory = await lstat(lockPath);
-  const identity = randomUUID2();
-  const markerName = "owner-" + identity + ".json";
-  const markerPath = join3(lockPath, markerName);
-  const marker = JSON.stringify({ version: 1, identity, pid: process.pid });
-  await writeFile2(markerPath, marker, { flag: "wx", mode: 384 });
+  const directory = lstatSync(lockPath);
   const assertDirectory = async () => {
     const current = await lstat(lockPath);
     if (lockEntryExists(lockPath + ".reconcile") || !current.isDirectory() || current.isSymbolicLink() || current.dev !== directory.dev || current.ino !== directory.ino)
@@ -4700,10 +4815,14 @@ async function withConfigWriteLock(operation) {
       throw new ConfigOwnershipError();
   };
   const assertOwnedSync = () => {
-    assertDirectorySync();
-    const entries = readdirSync(lockPath);
-    const entry = lstatSync(markerPath);
-    if (entries.length !== 1 || entries[0] !== markerName || !entry.isFile() || entry.isSymbolicLink() || readFileSync2(markerPath, "utf8") !== marker) throw new ConfigOwnershipError();
+    try {
+      assertDirectorySync();
+      const entries = readdirSync(lockPath);
+      const entry = lstatSync(markerPath);
+      if (entries.length !== 1 || entries[0] !== markerName || !entry.isFile() || entry.isSymbolicLink() || readFileSync2(markerPath, "utf8") !== marker) throw new ConfigOwnershipError();
+    } catch {
+      throw new ConfigOwnershipError();
+    }
   };
   const persist = async (update) => {
     const path = configPath();
@@ -4732,14 +4851,14 @@ async function withConfigWriteLock(operation) {
       if (temporaryOwned) unlinkSync(temporary);
     }
   };
-  const release = async () => {
-    await assertOwned();
+  const release = () => {
+    assertOwnedSync();
     const quarantine = join3(dirname2(lockPath), ".credential-release-" + randomUUID2());
-    await mkdir2(quarantine, { mode: 448 });
+    mkdirSync(quarantine, { mode: 448 });
     const captured = join3(quarantine, markerName);
     try {
-      await assertOwned();
-      await rename2(markerPath, captured);
+      assertOwnedSync();
+      renameSync(markerPath, captured);
       assertDirectorySync();
       const entry = lstatSync(captured);
       if (!entry.isFile() || entry.isSymbolicLink() || readFileSync2(captured, "utf8") !== marker || readdirSync(lockPath).length) throw new ConfigOwnershipError();
@@ -4751,20 +4870,40 @@ async function withConfigWriteLock(operation) {
     } catch {
       if (existsSync2(captured)) {
         try {
-          await link(captured, markerPath);
+          linkSync(captured, markerPath);
         } catch {
         }
       }
       throw new ConfigOwnershipError();
     }
   };
+  let held = true;
+  const releaseOnce = () => {
+    if (!held) return;
+    held = false;
+    process.off("exit", onExit);
+    for (const signal of RELEASE_SIGNALS) process.off(signal, onSignal);
+    release();
+  };
+  const onExit = () => {
+    try {
+      releaseOnce();
+    } catch {
+    }
+  };
+  const onSignal = (signal) => {
+    onExit();
+    if (process.listenerCount(signal) === 0) process.kill(process.pid, signal);
+  };
+  process.on("exit", onExit);
+  for (const signal of RELEASE_SIGNALS) process.on(signal, onSignal);
   try {
     await assertOwned();
     const result = await operation(assertOwned, persist);
     await assertOwned();
     return result;
   } finally {
-    await release();
+    releaseOnce();
   }
 }
 function renewalFailure(error) {
@@ -6657,6 +6796,7 @@ async function readGooseRegistrations(path) {
       continue;
     }
     if (inExtensions && /^\S/.test(rawLine) && rawLine.trim()) {
+      if (current?.command) registrations.push(current);
       inExtensions = false;
       inTopolo = false;
       current = void 0;
@@ -6664,6 +6804,7 @@ async function readGooseRegistrations(path) {
     if (!inExtensions) continue;
     const extension = rawLine.match(/^  ([A-Za-z0-9_-]+):\s*$/);
     if (extension) {
+      if (current?.command) registrations.push(current);
       inTopolo = true;
       current = isPublicRegistrationName(extension[1]) ? { name: extension[1], command: "", args: [], env: {} } : void 0;
       continue;
@@ -6841,7 +6982,7 @@ function message(error) {
 
 // src/commands/agent-config.ts
 import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir3, readFile as readFile5, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile5, rename as rename2, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname5 } from "path";
 async function installAgentSkill(agent, source, homeDir, projectDir) {
   const path = agentSkillPath(agent, homeDir, projectDir);
@@ -6877,6 +7018,7 @@ async function unregisterAgentConfig(agent, homeDir, name, projectDir) {
 function registrationEnvironment(agent, registration) {
   return {
     TOPOLO_AGENT_NAME: AGENT_NAME_FOR[agent],
+    ...registration.configPath ? { TOPOLO_CONFIG_PATH: registration.configPath } : {},
     ...registration.installationId ? { TOPOLO_AGENT_INSTALLATION_ID: registration.installationId } : {},
     ...registration.context ? { TOPOLO_CONTEXT: registration.context, TOPOLO_ENV: registration.environment } : {}
   };
@@ -7008,7 +7150,7 @@ async function atomicWrite(path, contents) {
   await mkdir3(dirname5(path), { recursive: true });
   const temporaryPath = path + ".topolo-" + process.pid + ".tmp";
   await writeFile3(temporaryPath, contents, { encoding: "utf8", mode: 384 });
-  await rename3(temporaryPath, path);
+  await rename2(temporaryPath, path);
 }
 function withoutMcpServerSections(text2, name) {
   const section = "[mcp_servers." + name + "]";
@@ -7072,7 +7214,14 @@ function resolveMcpRegistration(options) {
   if (installationId && /[\r\n]/.test(installationId)) {
     throw new Error("Installation id must be a single-line identifier.");
   }
-  return { name, ...context ? { context } : {}, environment, ...installationId ? { installationId } : {} };
+  const configPath2 = process.env.TOPOLO_CONFIG_PATH;
+  return {
+    name,
+    ...context ? { context } : {},
+    environment,
+    ...installationId ? { installationId } : {},
+    ...configPath2 ? { configPath: configPath2 } : {}
+  };
 }
 async function installForAgent(agent, sourceDir, mcp, opts) {
   const source = await readFile6(join7(sourceDir, "topolo", "SKILL.md"), "utf8");

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@topolo/cli",
   "packageManager": "pnpm@10.17.1",
-  "version": "0.13.7",
-  "topoloPublishedVersion": "0.13.7",
+  "version": "0.13.8",
+  "topoloPublishedVersion": "0.13.8",
   "description": "Public command-line interface for Topolo customer organizations, developers, and agents.",
   "license": "UNLICENSED",
   "author": "Topolo",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@topolo/mcp": "0.14.24",
-    "@topolo/sdk": "0.23.19",
+    "@topolo/mcp": "0.14.25",
+    "@topolo/sdk": "0.23.20",
     "commander": "^12.1.0",
     "undici": "6.29.0"
   },