@moxt-ai/mobius 0.0.145 → 0.0.147

package/dist/cli.js

@@ -3381,7 +3381,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.145",
+  version: "0.0.147",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -4227,6 +4227,17 @@ var AgentProbeFailed = class extends UnavailableAgent {
     this.message = message;
   }
 };
+var UnsupportedAgentVersion = class extends UnavailableInstalledAgent {
+  code = "agent_version_unsupported";
+  message;
+  minimumSupportedVersion;
+  status = "unsupported_version";
+  constructor(specification, agent, minimumSupportedVersion) {
+    super(specification, agent);
+    this.minimumSupportedVersion = minimumSupportedVersion;
+    this.message = `Agent version ${agent.agentVersion} is below the minimum supported version ${minimumSupportedVersion}`;
+  }
+};
 var IntegrationProbeFailed = class extends UnavailableInstalledAgent {
   code;
   message;
@@ -4254,12 +4265,25 @@ var AuthenticationRequiredAgent = class extends UnavailableInstalledAgent {
     super(specification, agent);
   }
 };
+var AgentDiscoveryResult = class {
+  detectionMilliseconds;
+  discovery;
+  constructor(discovery, detectionMilliseconds) {
+    if (!Number.isFinite(detectionMilliseconds) || detectionMilliseconds < 0) {
+      throw new Error("The Agent detection duration is invalid");
+    }
+    this.detectionMilliseconds = Math.round(detectionMilliseconds * 1e3) / 1e3;
+    this.discovery = discovery;
+  }
+};
 var LocalAgentInventory = class {
   available;
   discoveries;
   installable;
+  results;
   unavailable;
-  constructor(discoveries) {
+  constructor(results) {
+    const discoveries = results.map((result) => result.discovery);
     const available = [];
     const unavailable = [];
     for (const discovery of discoveries) {
@@ -4278,8 +4302,17 @@ var LocalAgentInventory = class {
         (discovery) => discovery instanceof UnavailableInstalledAgent ? discovery.agent : new MissingAgentDefinition(discovery.specification.id, discovery.specification.label)
       )
     );
+    this.results = Object.freeze([...results]);
     this.unavailable = Object.freeze(unavailable);
   }
+  detectionMillisecondsFor = (discovery) => {
+    for (const result of this.results) {
+      if (result.discovery === discovery) {
+        return result.detectionMilliseconds;
+      }
+    }
+    throw new Error("The Agent discovery result is unavailable");
+  };
   readyAgents = () => this.available.map((discovery) => discovery.agent);
 };
 
@@ -4313,19 +4346,48 @@ var UnavailableAgentDiagnostic = class {
     this.status = discovery.status;
   }
 };
+var UnsupportedAgentVersionDiagnostic = class extends UnavailableAgentDiagnostic {
+  agentVersion;
+  minimumSupportedVersion;
+  constructor(discovery) {
+    super(discovery);
+    this.agentVersion = discovery.agent.agentVersion;
+    this.minimumSupportedVersion = discovery.minimumSupportedVersion;
+  }
+};
+function withDetectionTime(diagnostic, detectionMilliseconds, verbose) {
+  return verbose ? { ...diagnostic, detectionMilliseconds } : diagnostic;
+}
+function unavailableDiagnostic(discovery) {
+  return discovery instanceof UnsupportedAgentVersion ? new UnsupportedAgentVersionDiagnostic(discovery) : new UnavailableAgentDiagnostic(discovery);
+}
 var AgentDiagnostics = class {
   available;
   unavailable;
-  constructor(inventory) {
-    this.available = inventory.available.map((discovery) => new AvailableAgentDiagnostic(discovery));
-    this.unavailable = inventory.unavailable.map((discovery) => new UnavailableAgentDiagnostic(discovery));
+  constructor(inventory, verbose) {
+    this.available = inventory.available.map(
+      (discovery) => withDetectionTime(
+        new AvailableAgentDiagnostic(discovery),
+        inventory.detectionMillisecondsFor(discovery),
+        verbose
+      )
+    );
+    this.unavailable = inventory.unavailable.map(
+      (discovery) => withDetectionTime(unavailableDiagnostic(discovery), inventory.detectionMillisecondsFor(discovery), verbose)
+    );
   }
 };
 function humanLine(label, status, detail) {
   return `${label.padEnd(13)} ${status.padEnd(17)} ${detail}`.trimEnd();
 }
-function formatAgentDiagnostics(inventory, json2) {
-  const diagnostics = new AgentDiagnostics(inventory);
+function detectionSuffix(diagnostic) {
+  if (!("detectionMilliseconds" in diagnostic) || typeof diagnostic.detectionMilliseconds !== "number") {
+    return "";
+  }
+  return `   detection=${Math.round(diagnostic.detectionMilliseconds).toString()}ms`;
+}
+function formatAgentDiagnostics(inventory, json2, verbose = false) {
+  const diagnostics = new AgentDiagnostics(inventory, verbose);
   if (json2) {
     return `${JSON.stringify(diagnostics, null, 2)}
 `;
@@ -4333,11 +4395,17 @@ function formatAgentDiagnostics(inventory, json2) {
   const lines = [];
   for (const available of diagnostics.available) {
     lines.push(
-      humanLine(available.label, available.status, `${available.agentVersion}   ${available.adapterVersion}`)
+      humanLine(
+        available.label,
+        available.status,
+        `${available.agentVersion}   ${available.adapterVersion}${detectionSuffix(available)}`
+      )
     );
   }
   for (const unavailable of diagnostics.unavailable) {
-    lines.push(humanLine(unavailable.label, unavailable.status, unavailable.message));
+    lines.push(
+      humanLine(unavailable.label, unavailable.status, `${unavailable.message}${detectionSuffix(unavailable)}`)
+    );
     if (unavailable.recoveryCommand.length > 0) {
       lines.push(
         unavailable.code === "authentication_required" ? `  Authenticate locally: ${unavailable.recoveryCommand}` : `  Install adapter: ${unavailable.recoveryCommand}`
@@ -28077,15 +28145,20 @@ async function discoverAgent(specification, context) {
       );
       continue;
     }
-    if (!supportedVersion) {
-      continue;
-    }
     const installedAgent = new AgentIntegrationDefinition(
       specification.id,
       specification.label,
       agent.identity.requestedPath,
       agentVersion
     );
+    if (!supportedVersion) {
+      lastFailure = new UnsupportedAgentVersion(
+        specification,
+        installedAgent,
+        specification.minimumSupportedAgentVersion
+      );
+      continue;
+    }
     if (adapters.length === 0 && !(specification instanceof InProcessAcpAgentDefinition2)) {
       return new MissingAdapter(specification, installedAgent);
     }
@@ -28179,10 +28252,15 @@ async function discoverAgent(specification, context) {
 // src/agent-catalog/discover-local-agents.ts
 async function discoverLocalAgentInventory(options) {
   const specifications = options.specifications ?? supportedLocalAgentSpecifications();
-  const discoveries = await Promise.all(
-    specifications.map(async (specification) => await discoverAgent(specification, options))
+  const monotonicTimeMilliseconds = options.monotonicTimeMilliseconds ?? (() => performance.now());
+  const results = await Promise.all(
+    specifications.map(async (specification) => {
+      const startedAt = monotonicTimeMilliseconds();
+      const discovery = await discoverAgent(specification, options);
+      return new AgentDiscoveryResult(discovery, monotonicTimeMilliseconds() - startedAt);
+    })
   );
-  return new LocalAgentInventory(discoveries);
+  return new LocalAgentInventory(results);
 }
 
 // src/config.ts
@@ -28273,6 +28351,8 @@ var WORKSPACE_LIST_KIND = "workspace.list";
 var WORKSPACE_ENTRIES_KIND = "workspace.entries";
 var SESSION_PREPARE_KIND = "session.prepare";
 var SESSION_READY_KIND = "session.ready";
+var SESSION_LIST_KIND = "session.list";
+var SESSION_LISTED_KIND = "session.listed";
 var SESSION_QUERY_KIND = "session.query";
 var SESSION_QUERIED_KIND = "session.queried";
 var SESSION_CONFIGURE_KIND = "session.configure";
@@ -28324,6 +28404,16 @@ var sessionMetadataSchema = external_exports.strictObject({
   title: external_exports.string().max(500),
   updatedAt: external_exports.iso.datetime({ offset: true })
 }).readonly();
+var sessionListCommandSchema = external_exports.strictObject({
+  kind: external_exports.literal(SESSION_LIST_KIND),
+  limit: external_exports.number().int().positive().max(500),
+  requestId: identifierStringSchema
+}).readonly();
+var sessionsListedEventSchema = external_exports.strictObject({
+  entries: external_exports.array(sessionMetadataSchema).max(500).readonly(),
+  kind: external_exports.literal(SESSION_LISTED_KIND),
+  requestId: identifierStringSchema
+}).readonly();
 var sessionQueryCommandSchema = external_exports.strictObject({
   kind: external_exports.literal(SESSION_QUERY_KIND),
   requestId: identifierStringSchema,
@@ -28877,6 +28967,10 @@ var decodeWorkspaceListCommand = (encoded) => decode3(encoded, workspaceListComm
 var encodeWorkspaceListCommand = (message) => encode3(message, workspaceListCommandSchema);
 var decodeWorkspaceEntriesEvent = (encoded) => decode3(encoded, workspaceEntriesEventSchema);
 var encodeWorkspaceEntriesEvent = (message) => encode3(message, workspaceEntriesEventSchema);
+var decodeSessionListCommand = (encoded) => decode3(encoded, sessionListCommandSchema);
+var encodeSessionListCommand = (message) => encode3(message, sessionListCommandSchema);
+var decodeSessionsListedEvent = (encoded) => decode3(encoded, sessionsListedEventSchema);
+var encodeSessionsListedEvent = (message) => encode3(message, sessionsListedEventSchema);
 var decodeSessionQueryCommand = (encoded) => decode3(encoded, sessionQueryCommandSchema);
 var encodeSessionQueryCommand = (message) => encode3(message, sessionQueryCommandSchema);
 var decodeSessionsQueriedEvent = (encoded) => decode3(encoded, sessionsQueriedEventSchema);
@@ -29864,6 +29958,7 @@ var serviceToDaemonSignatures = {
     decodeAgentSettingsDiscoverCommand
   ),
   [FILE_READ_KIND]: defineMessageSignature(FILE_READ_KIND, encodeFileReadCommand, decodeFileReadCommand),
+  [SESSION_LIST_KIND]: defineMessageSignature(SESSION_LIST_KIND, encodeSessionListCommand, decodeSessionListCommand),
   [SESSION_QUERY_KIND]: defineMessageSignature(
     SESSION_QUERY_KIND,
     encodeSessionQueryCommand,
@@ -29999,6 +30094,11 @@ var daemonToServiceSignatures = {
   [FILE_CHUNK_KIND]: defineMessageSignature(FILE_CHUNK_KIND, encodeFileChunkEvent, decodeFileChunkEvent),
   [FILE_END_KIND]: defineMessageSignature(FILE_END_KIND, encodeFileEndEvent, decodeFileEndEvent),
   [FILE_FAILED_KIND]: defineMessageSignature(FILE_FAILED_KIND, encodeFileFailedEvent, decodeFileFailedEvent),
+  [SESSION_LISTED_KIND]: defineMessageSignature(
+    SESSION_LISTED_KIND,
+    encodeSessionsListedEvent,
+    decodeSessionsListedEvent
+  ),
   [SESSION_QUERIED_KIND]: defineMessageSignature(
     SESSION_QUERIED_KIND,
     encodeSessionsQueriedEvent,
@@ -40680,6 +40780,7 @@ var AgentRuntimeManager = class {
     const stored = this.#store.read(sessionId);
     return stored instanceof FoundAcpStoredSession ? [stored.session] : [];
   });
+  listSessions = (limit) => this.#store.list().filter((session) => session.prompted).slice(0, limit);
   findLinkedSessions = (agentId, nativeSessionId) => this.#store.findNative(agentId, nativeSessionId);
   hasPreparedSession = (sessionId, agentId, cwd, additionalDirectories) => this.#executionProcesses.get(sessionId)?.belongsTo(agentId, cwd, additionalDirectories) === true;
   createNativeSession = async (options) => this.#operations.run(options, async (options2) => {
@@ -43561,9 +43662,11 @@ var NativeSessionService = class {
       title: target.info.title ?? "Untitled session"
     };
   };
-  querySessions = async (sessionIds, signal) => {
+  listSessions = async (limit, signal) => await this.describeSessions(this.#sessions.listSessions(limit), signal);
+  querySessions = async (sessionIds, signal) => await this.describeSessions(this.#sessions.findSessions(sessionIds), signal);
+  describeSessions = async (sessions, signal) => {
     const entries = [];
-    for (const session of this.#sessions.findSessions(sessionIds)) {
+    for (const session of sessions) {
       signal.throwIfAborted();
       const directory = await this.#directories.identify(this.#config.bindingId, session.cwd, signal);
       const additionalDirectories = [];
@@ -45978,6 +46081,19 @@ function createDaemonCommandHandler({
         void executeSessionConfigure(publisher, socket, command2, config2, directories, audit, sessions, signal);
         return;
       }
+      if (kind === SESSION_LIST_KIND) {
+        const command2 = message;
+        void nativeSessions.listSessions(command2.limit, signal).then((entries) => {
+          send(socket, {
+            entries,
+            kind: SESSION_LISTED_KIND,
+            requestId: command2.requestId
+          });
+        }).catch((error62) => {
+          reportOperationFailure(socket, command2.requestId, "", error62);
+        });
+        return;
+      }
       if (kind === SESSION_QUERY_KIND) {
         const command2 = message;
         void nativeSessions.querySessions(command2.sessionIds, signal).then((entries) => {
@@ -47536,7 +47652,7 @@ function createProgram() {
     process.stdout.write(`${package_default.version}
 `);
   });
-  program2.command("agents").description("show detected, missing, and integration-ready Agents").option("--json", "write the Agent inventory as JSON").action(async (options) => {
+  program2.command("agents").description("show detected, missing, and integration-ready Agents").option("--json", "write the Agent inventory as JSON").option("--verbose", "include per-Agent detection timing").action(async (options) => {
     const installation = await openMobiusCliInstallation(shutdown.signal, process.env);
     const localContext = new DaemonLocalContext(installation.stateDirectory, process.env);
     const defaultWorkspace = loadDefaultWorkspace(localContext.environment);
@@ -47546,7 +47662,7 @@ function createProgram() {
       environment: localContext.environment,
       signal: shutdown.signal
     });
-    process.stdout.write(formatAgentDiagnostics(inventory, options.json === true));
+    process.stdout.write(formatAgentDiagnostics(inventory, options.json === true, options.verbose === true));
   });
   program2.command("__manager", { hidden: true }).action(async () => {
     const installation = await openMobiusCliInstallation(shutdown.signal, process.env);