@minionry/minion 0.7.36

package/dist/bin/machine-layout.js

@@ -0,0 +1,200 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+
+
+import { chmodSync, existsSync, linkSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const MACHINE_DIRNAME = '.minionry';
+
+export const MACHINE_LAYOUT = Object.freeze({
+  credentials: 'credentials',
+  config: 'config',
+  state: 'state',
+  cache: 'cache',
+  run: 'run',
+  logs: 'logs',
+  native: 'native',
+  sandboxes: 'sandboxes',
+  prompts: 'prompts',
+  snippets: 'snippets',
+});
+
+export const MACHINE_FILES = Object.freeze({
+  platformCredentials: Object.freeze(['credentials', 'platform.json']),
+  platformCredentialsDev: Object.freeze(['credentials', 'platform-dev.json']),
+  sessionToken: Object.freeze(['credentials', 'session-token']),
+  e2eeIdentity: Object.freeze(['credentials', 'e2ee-identity']),
+  engineCredentials: Object.freeze(['credentials', 'auth.json']),
+  modelProfiles: Object.freeze(['credentials', 'model-profiles.json']),
+  settings: Object.freeze(['config', 'settings.json']),
+  telemetry: Object.freeze(['config', 'telemetry.json']),
+  devEnv: Object.freeze(['config', '.env']),
+  clientId: Object.freeze(['state', 'client-id']),
+  clientIdBinding: Object.freeze(['state', 'client-id-binding']),
+  instances: Object.freeze(['state', 'instances.json']),
+  appGrants: Object.freeze(['state', 'app-grants.json']),
+  frecency: Object.freeze(['state', 'autocomplete-frecency.json']),
+  ptySetupDismissed: Object.freeze(['state', 'pty-setup-dismissed']),
+  modelCatalog: Object.freeze(['cache', 'model-catalog.json']),
+  updateCheck: Object.freeze(['cache', 'update-check.json']),
+  sessionSlots: Object.freeze(['run', 'session-slots']),
+});
+
+export const LEGACY_MACHINE_MOVES = Object.freeze([
+  Object.freeze(['credentials.json', 'platformCredentials', 'copy']),
+  Object.freeze(['credentials-dev.json', 'platformCredentialsDev', 'copy']),
+  Object.freeze(['session-token', 'sessionToken', 'copy']),
+  Object.freeze(['e2ee-identity', 'e2eeIdentity', 'copy']),
+  Object.freeze(['settings.json', 'settings', 'copy']),
+  Object.freeze(['client-id', 'clientId', 'copy']),
+  Object.freeze(['app-grants.json', 'appGrants', 'move']),
+  Object.freeze(['config.json', 'telemetry', 'move']),
+  Object.freeze(['.env', 'devEnv', 'move']),
+  Object.freeze(['instances.json', 'instances', 'move']),
+  Object.freeze(['autocomplete-frecency.json', 'frecency', 'move']),
+  Object.freeze(['.pty-setup-dismissed', 'ptySetupDismissed', 'move']),
+  Object.freeze(['model-catalog.json', 'modelCatalog', 'move']),
+  Object.freeze(['update-check.json', 'updateCheck', 'move']),
+]);
+
+const LEGACY_MCP_CONFIG_RE = /^mcp-config(?:-[0-9a-f-]{36})?\.json$/i;
+const LEGACY_MCP_CONFIG_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+export function machineRoot() {
+  return join(homedir(), MACHINE_DIRNAME);
+}
+
+export function machinePath(entry, ...rest) {
+  const dirname = MACHINE_LAYOUT[entry];
+  if (typeof dirname !== 'string') throw new TypeError(`Unknown machine layout entry: ${String(entry)}`);
+  ensureMachineLayout();
+  const path = join(machineRoot(), dirname, ...rest);
+  return legacyFallbacks.get(path) ?? path;
+}
+
+export function machineFile(key) {
+  const spec = MACHINE_FILES[key];
+  if (!spec) throw new TypeError(`Unknown machine file: ${String(key)}`);
+  return machinePath(spec[0], spec[1]);
+}
+
+export function machineLockPath(name) {
+  return machinePath('run', `${name}.lock`);
+}
+
+export function ensureMachineDir(entry) {
+  const dir = machinePath(entry);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+
+
+const migratedRoots = new Set();
+const legacyFallbacks = new Map();
+function report(message, err) {
+  if (err === undefined) console.warn(`[MachineLayout] ${message}`);
+  else console.warn(`[MachineLayout] ${message}`, err);
+}
+
+export function ensureMachineLayout() {
+  const root = machineRoot();
+  if (migratedRoots.has(root)) return;
+  migratedRoots.add(root);
+  if (!existsSync(root)) return;
+
+  const credentialsDir = join(root, MACHINE_LAYOUT.credentials);
+  try {
+    mkdirSync(credentialsDir, { recursive: true, mode: 0o700 });
+    if (process.platform !== 'win32') chmodSync(credentialsDir, 0o700);
+  } catch (err) {
+    report(`Could not restrict ${credentialsDir} to 0700:`, err);
+  }
+
+  for (const [legacyName, key, strategy] of LEGACY_MACHINE_MOVES) {
+    const [entry, name] = MACHINE_FILES[key];
+    migrateLegacyEntry(join(root, legacyName), join(root, MACHINE_LAYOUT[entry], name), strategy);
+  }
+
+  sweepStaleRootMcpConfigs(root);
+}
+
+function migrateLegacyEntry(from, to, strategy) {
+  if (!existsSync(from)) return;
+  if (existsSync(to)) {
+    if (strategy === 'move') {
+      report(`${from} is a leftover from before the machine layout and is ignored; ${to} is the live copy`);
+    } else if (isNewerThan(from, to)) {
+      report(`${from} was written after its copy at ${to}, by a \`minion\` started before this layout; that change is not visible at the new location — restart every \`minion\` on this machine, then delete the root copy`);
+    }
+    return;
+  }
+  try {
+    mkdirSync(join(to, '..'), { recursive: true, mode: 0o700 });
+    if (strategy === 'copy') {
+      placeCopy(from, to);
+      report(`Copied ${from} → ${to}; the original stays for \`minion\` processes started before this layout and can be deleted once they are all restarted`);
+    } else if (placeNoClobber(from, to)) {
+      unlinkSync(from);
+      report(`Moved ${from} → ${to}`);
+    }
+  } catch (err) {
+    if (existsSync(to)) return;
+    legacyFallbacks.set(to, from);
+    report(`Could not bring ${from} to ${to}; this process keeps using the old location and will retry on its next start:`, err);
+  }
+}
+
+function placeCopy(from, to) {
+  const mode = statSync(from).mode & 0o777;
+  const staging = `${to}.${process.pid}.tmp`;
+  writeFileSync(staging, readFileSync(from), { mode });
+  chmodSync(staging, mode);
+  try {
+    placeNoClobber(staging, to);
+  } finally {
+    rmSync(staging, { force: true });
+  }
+}
+
+function placeNoClobber(from, to) {
+  try {
+    linkSync(from, to);
+    return true;
+  } catch (err) {
+    const code = err?.code;
+    if (code === 'EEXIST') return false;
+    if (code === 'EXDEV' || code === 'EPERM' || code === 'ENOTSUP' || code === 'EACCES') {
+      renameSync(from, to);
+      return true;
+    }
+    throw err;
+  }
+}
+
+function isNewerThan(from, to) {
+  try {
+    return statSync(from).mtimeMs > statSync(to).mtimeMs + 1000;
+  } catch {
+    return false;
+  }
+}
+
+function sweepStaleRootMcpConfigs(root) {
+  let names = [];
+  try {
+    names = readdirSync(root);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const name of names) {
+    if (!LEGACY_MCP_CONFIG_RE.test(name)) continue;
+    const file = join(root, name);
+    try {
+      if (now - statSync(file).mtimeMs > LEGACY_MCP_CONFIG_MAX_AGE_MS) rmSync(file, { force: true });
+    } catch {
+    }
+  }
+}

package/dist/electron-host/agent-lease.js

@@ -0,0 +1,141 @@
+import { EventEmitter } from "node:events";
+export const DEFAULT_LEASE_TTL_MS = 30_000;
+export const GC_INTERVAL_MS = 5_000;
+export const GRACE_PERIOD_MS = 15_000;
+export class TabAlreadyLeasedError extends Error {
+    code = "tab_already_leased";
+    currentOwner;
+    constructor(currentOwner) {
+        super(`Tab ${currentOwner.tabId} is already leased by agent ${currentOwner.agentId}`);
+        this.name = "TabAlreadyLeasedError";
+        this.currentOwner = { ...currentOwner };
+    }
+}
+export class AgentLeaseRegistry extends EventEmitter {
+    entries = new Map();
+    nowMs;
+    defaultTtlMs;
+    gcIntervalMs;
+    gracePeriodMs;
+    setIntervalFn;
+    clearIntervalFn;
+    gcHandle;
+    constructor(options = {}) {
+        super();
+        this.nowMs = options.nowMs ?? (() => Date.now());
+        this.defaultTtlMs = options.defaultTtlMs ?? DEFAULT_LEASE_TTL_MS;
+        this.gcIntervalMs = options.gcIntervalMs ?? GC_INTERVAL_MS;
+        this.gracePeriodMs = options.gracePeriodMs ?? GRACE_PERIOD_MS;
+        this.setIntervalFn =
+            options.setIntervalFn ??
+                ((handler, ms) => setInterval(handler, ms));
+        this.clearIntervalFn =
+            options.clearIntervalFn ?? ((handle) => clearInterval(handle));
+    }
+    lease(req) {
+        const existing = this.entries.get(req.tabId);
+        if (existing !== undefined) {
+            throw new TabAlreadyLeasedError(existing);
+        }
+        const now = this.nowMs();
+        const ttl = req.ttlMs ?? this.defaultTtlMs;
+        const entry = {
+            tabId: req.tabId,
+            agentId: req.agentId,
+            ...(req.planId !== undefined ? { planId: req.planId } : {}),
+            leasedAt: now,
+            leasedUntil: now + ttl,
+        };
+        this.entries.set(req.tabId, entry);
+        return { ...entry };
+    }
+    release(tabId, agentId) {
+        const existing = this.entries.get(tabId);
+        if (existing === undefined)
+            return false;
+        if (existing.agentId !== agentId)
+            return false;
+        this.entries.delete(tabId);
+        return true;
+    }
+    heartbeat(req) {
+        const now = this.nowMs();
+        const ttl = req.ttlMs ?? this.defaultTtlMs;
+        const stillLeased = [];
+        for (const tabId of req.tabIds) {
+            const entry = this.entries.get(tabId);
+            if (entry === undefined)
+                continue;
+            if (entry.agentId !== req.agentId)
+                continue;
+            entry.leasedUntil = now + ttl;
+            stillLeased.push(tabId);
+        }
+        return { stillLeased };
+    }
+    releasePlan(planId) {
+        const released = [];
+        for (const [tabId, entry] of this.entries) {
+            if (entry.planId !== planId)
+                continue;
+            released.push(tabId);
+            this.entries.delete(tabId);
+            this.emit("lease-expired", {
+                tabId: entry.tabId,
+                agentId: entry.agentId,
+                ...(entry.planId !== undefined ? { planId: entry.planId } : {}),
+            });
+        }
+        return released;
+    }
+    list(filter = {}) {
+        const out = [];
+        for (const entry of this.entries.values()) {
+            if (filter.agentId !== undefined && entry.agentId !== filter.agentId)
+                continue;
+            if (filter.planId !== undefined && entry.planId !== filter.planId)
+                continue;
+            out.push({ ...entry });
+        }
+        return out;
+    }
+    gcLoop() {
+        if (this.gcHandle !== undefined)
+            return;
+        this.gcHandle = this.setIntervalFn(() => this.sweepExpired(), this.gcIntervalMs);
+        const handle = this.gcHandle;
+        if (handle && typeof handle.unref === "function") {
+            handle.unref();
+        }
+    }
+    stopGc() {
+        if (this.gcHandle === undefined)
+            return;
+        this.clearIntervalFn(this.gcHandle);
+        this.gcHandle = undefined;
+    }
+    sweepExpired() {
+        const now = this.nowMs();
+        const expired = [];
+        for (const [tabId, entry] of this.entries) {
+            if (now >= entry.leasedUntil + this.gracePeriodMs) {
+                expired.push(tabId);
+            }
+        }
+        for (const tabId of expired) {
+            const entry = this.entries.get(tabId);
+            if (entry === undefined)
+                continue;
+            this.entries.delete(tabId);
+            this.emit("lease-expired", {
+                tabId: entry.tabId,
+                agentId: entry.agentId,
+                ...(entry.planId !== undefined ? { planId: entry.planId } : {}),
+            });
+        }
+        return expired;
+    }
+    size() {
+        return this.entries.size;
+    }
+}