@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/conduit-EY54WTZA.js

@@ -0,0 +1,535 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineTypedHandler,
+  typedDispatch,
+  wrapConduitImpl
+} from "./chunk-QWNKLLLG.js";
+import {
+  envelopeToEngineResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/conduit.ts
+import { getProjectRoot } from "@cleocode/core";
+var activePoller = null;
+var activeAgentId = null;
+var _conduitTypedHandler = defineTypedHandler("conduit", {
+  // -------------------------------------------------------------------------
+  // Query ops
+  // -------------------------------------------------------------------------
+  status: async (params) => wrapConduitImpl(() => getStatusImpl(params.agentId), "status"),
+  peek: async (params) => wrapConduitImpl(() => peekImpl(params.agentId, params.limit), "peek"),
+  listen: async (params) => wrapConduitImpl(
+    () => listenTopicImpl(params.topicName, params.agentId, params.limit, params.since),
+    "listen"
+  ),
+  // -------------------------------------------------------------------------
+  // Mutate ops
+  // -------------------------------------------------------------------------
+  start: async (params) => wrapConduitImpl(
+    () => startPollingImpl(params.agentId, params.pollIntervalMs, params.groupConversationIds),
+    "start"
+  ),
+  stop: async (_params) => wrapConduitImpl(() => Promise.resolve(stopPollingImpl()), "stop"),
+  send: async (params) => wrapConduitImpl(
+    () => sendMessageImpl(params.content, params.to, params.conversationId, params.agentId),
+    "send"
+  ),
+  subscribe: async (params) => wrapConduitImpl(
+    () => subscribeTopicImpl(params.topicName, params.agentId, params.filter),
+    "subscribe"
+  ),
+  publish: async (params) => wrapConduitImpl(
+    () => publishToTopicImpl(
+      params.topicName,
+      params.content,
+      params.kind,
+      params.payload,
+      params.agentId
+    ),
+    "publish"
+  )
+});
+var QUERY_OPS = /* @__PURE__ */ new Set(["status", "peek", "listen"]);
+var MUTATE_OPS = /* @__PURE__ */ new Set(["start", "stop", "send", "subscribe", "publish"]);
+var ConduitHandler = class {
+  /**
+   * Execute a read-only conduit query operation.
+   *
+   * @param operation - The conduit query op name (e.g. 'status', 'peek', 'listen').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "conduit", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _conduitTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(envelopeToEngineResult(envelope), "query", "conduit", operation, startTime);
+    } catch (error) {
+      return handleErrorResult("query", "conduit", operation, error, startTime);
+    }
+  }
+  /**
+   * Execute a state-modifying conduit mutation operation.
+   *
+   * @param operation - The conduit mutate op name (e.g. 'start', 'send', 'publish').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "conduit", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _conduitTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(
+        envelopeToEngineResult(envelope),
+        "mutate",
+        "conduit",
+        operation,
+        startTime
+      );
+    } catch (error) {
+      return handleErrorResult("mutate", "conduit", operation, error, startTime);
+    }
+  }
+  getSupportedOperations() {
+    return {
+      query: ["status", "peek", "listen"],
+      mutate: ["start", "stop", "send", "subscribe", "publish"]
+    };
+  }
+};
+async function _resolveCredential(agentId) {
+  const { AgentRegistryAccessor, getDb } = await import("@cleocode/core/internal");
+  await getDb();
+  const registry = new AgentRegistryAccessor(getProjectRoot());
+  const credential = agentId ? await registry.get(agentId) : await registry.getActive();
+  if (!credential) {
+    throw new Error(
+      "No agent credential found. Run: cleo agent register --id <id> --api-key <key>"
+    );
+  }
+  return credential;
+}
+async function getStatusImpl(agentId) {
+  const credential = await _resolveCredential(agentId);
+  const pollerRunning = activePoller !== null && activeAgentId === credential.agentId;
+  const { LocalTransport, SignalDockRetiredError, conduitFetch, retiredCloudHost } = await import("@cleocode/core/conduit");
+  if (LocalTransport.isAvailable(getProjectRoot())) {
+    const transport = new LocalTransport();
+    await transport.connect({
+      agentId: credential.agentId,
+      apiKey: credential.apiKey,
+      apiBaseUrl: credential.apiBaseUrl
+    });
+    try {
+      const pending = await transport.poll({ limit: 1e3 });
+      return {
+        success: true,
+        data: {
+          agentId: credential.agentId,
+          connected: true,
+          transport: "local",
+          pollerRunning,
+          unreadTotal: pending.length,
+          actionItems: 0
+        }
+      };
+    } finally {
+      await transport.disconnect();
+    }
+  }
+  const retiredHost = retiredCloudHost(credential.apiBaseUrl);
+  if (retiredHost !== null) {
+    return {
+      success: true,
+      data: {
+        agentId: credential.agentId,
+        connected: false,
+        transport: "http",
+        pollerRunning,
+        error: new SignalDockRetiredError(retiredHost).message
+      }
+    };
+  }
+  const response = await conduitFetch(
+    `${credential.apiBaseUrl}/agents/${credential.agentId}/inbox`,
+    {
+      headers: {
+        Authorization: `Bearer ${credential.apiKey}`,
+        "X-Agent-Id": credential.agentId
+      }
+    }
+  );
+  if (!response.ok) {
+    return {
+      success: true,
+      data: {
+        agentId: credential.agentId,
+        connected: false,
+        transport: "http",
+        pollerRunning,
+        error: `API returned ${response.status}`
+      }
+    };
+  }
+  const body = await response.json();
+  return {
+    success: true,
+    data: {
+      agentId: credential.agentId,
+      connected: true,
+      transport: "http",
+      pollerRunning,
+      unreadTotal: body.data?.unreadTotal ?? 0,
+      actionItems: body.data?.actionItems?.length ?? 0
+    }
+  };
+}
+async function peekImpl(agentId, limit) {
+  const credential = await _resolveCredential(agentId);
+  const { LocalTransport, conduitFetch } = await import("@cleocode/core/conduit");
+  if (LocalTransport.isAvailable(getProjectRoot())) {
+    const transport = new LocalTransport();
+    await transport.connect({
+      agentId: credential.agentId,
+      apiKey: credential.apiKey,
+      apiBaseUrl: credential.apiBaseUrl
+    });
+    try {
+      const messages = await transport.poll({ limit: limit ?? 20 });
+      return {
+        success: true,
+        data: {
+          agentId: credential.agentId,
+          messages: messages.map((m) => ({
+            id: m.id,
+            from: m.from,
+            content: m.content,
+            conversationId: m.threadId,
+            timestamp: m.timestamp
+          }))
+        }
+      };
+    } finally {
+      await transport.disconnect();
+    }
+  }
+  const params = new URLSearchParams();
+  params.set("mentioned", credential.agentId);
+  params.set("limit", String(limit ?? 20));
+  const response = await conduitFetch(`${credential.apiBaseUrl}/messages/peek?${params}`, {
+    headers: {
+      Authorization: `Bearer ${credential.apiKey}`,
+      "X-Agent-Id": credential.agentId
+    }
+  });
+  if (!response.ok) {
+    return { success: true, data: { agentId: credential.agentId, messages: [] } };
+  }
+  const body = await response.json();
+  return {
+    success: true,
+    data: {
+      agentId: credential.agentId,
+      messages: (body.data?.messages ?? []).map((m) => ({
+        id: m.id,
+        from: m.senderAgentId ?? "unknown",
+        content: m.content ?? "",
+        conversationId: m.conversationId,
+        timestamp: m.createdAt
+      }))
+    }
+  };
+}
+async function startPollingImpl(agentId, pollIntervalMs, groupConversationIds) {
+  if (activePoller) {
+    return {
+      success: true,
+      data: {
+        agentId: activeAgentId,
+        message: "Poller already running. Use conduit.stop first.",
+        alreadyRunning: true
+      }
+    };
+  }
+  const credential = await _resolveCredential(agentId);
+  const { AgentPoller } = await import("@cleocode/runtime");
+  const { LocalTransport } = await import("@cleocode/core/conduit");
+  let transport;
+  let transportName = "http";
+  if (LocalTransport.isAvailable(getProjectRoot())) {
+    const local = new LocalTransport();
+    await local.connect({
+      agentId: credential.agentId,
+      apiKey: credential.apiKey,
+      apiBaseUrl: credential.apiBaseUrl
+    });
+    transport = local;
+    transportName = "local";
+  }
+  activePoller = new AgentPoller({
+    agentId: credential.agentId,
+    apiKey: credential.apiKey,
+    apiBaseUrl: credential.apiBaseUrl,
+    pollIntervalMs: pollIntervalMs ?? 5e3,
+    groupConversationIds,
+    transport
+  });
+  activeAgentId = credential.agentId;
+  activePoller.start();
+  return {
+    success: true,
+    data: {
+      agentId: credential.agentId,
+      pollIntervalMs: pollIntervalMs ?? 5e3,
+      groupConversationIds: groupConversationIds ?? [],
+      transport: transportName,
+      message: "Polling started."
+    }
+  };
+}
+function stopPollingImpl() {
+  if (!activePoller) {
+    return {
+      success: true,
+      data: { message: "No active poller to stop." }
+    };
+  }
+  const stoppedAgent = activeAgentId;
+  activePoller.stop();
+  activePoller = null;
+  activeAgentId = null;
+  return {
+    success: true,
+    data: {
+      agentId: stoppedAgent,
+      message: "Polling stopped."
+    }
+  };
+}
+async function subscribeTopicImpl(topicName, agentId, _filter) {
+  if (!topicName) {
+    return {
+      success: false,
+      error: { code: "E_ARGS", message: 'Must specify "topicName"' }
+    };
+  }
+  const credential = await _resolveCredential(agentId);
+  const { LocalTransport } = await import("@cleocode/core/conduit");
+  if (!LocalTransport.isAvailable(getProjectRoot())) {
+    return {
+      success: false,
+      error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
+    };
+  }
+  const transport = new LocalTransport();
+  await transport.connect({
+    agentId: credential.agentId,
+    apiKey: credential.apiKey,
+    apiBaseUrl: credential.apiBaseUrl
+  });
+  try {
+    await transport.subscribeTopic(topicName);
+    return {
+      success: true,
+      data: {
+        agentId: credential.agentId,
+        topicName,
+        message: `Subscribed to topic: ${topicName}`
+      }
+    };
+  } finally {
+    await transport.disconnect();
+  }
+}
+async function publishToTopicImpl(topicName, content, kind, payload, agentId) {
+  if (!topicName) {
+    return {
+      success: false,
+      error: { code: "E_ARGS", message: 'Must specify "topicName"' }
+    };
+  }
+  if (!content) {
+    return {
+      success: false,
+      error: { code: "E_ARGS", message: 'Must specify "content"' }
+    };
+  }
+  const credential = await _resolveCredential(agentId);
+  const { LocalTransport } = await import("@cleocode/core/conduit");
+  if (!LocalTransport.isAvailable(getProjectRoot())) {
+    return {
+      success: false,
+      error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
+    };
+  }
+  const transport = new LocalTransport();
+  await transport.connect({
+    agentId: credential.agentId,
+    apiKey: credential.apiKey,
+    apiBaseUrl: credential.apiBaseUrl
+  });
+  try {
+    const result = await transport.publishToTopic(topicName, content, { kind, payload });
+    return {
+      success: true,
+      data: {
+        messageId: result.messageId,
+        from: credential.agentId,
+        topicName,
+        transport: "local",
+        publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  } finally {
+    await transport.disconnect();
+  }
+}
+async function listenTopicImpl(topicName, agentId, limit, since) {
+  if (!topicName) {
+    return {
+      success: false,
+      error: { code: "E_ARGS", message: 'Must specify "topicName"' }
+    };
+  }
+  const startMs = Date.now();
+  const credential = await _resolveCredential(agentId);
+  const { LocalTransport } = await import("@cleocode/core/conduit");
+  if (!LocalTransport.isAvailable(getProjectRoot())) {
+    return {
+      success: false,
+      error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
+    };
+  }
+  const transport = new LocalTransport();
+  await transport.connect({
+    agentId: credential.agentId,
+    apiKey: credential.apiKey,
+    apiBaseUrl: credential.apiBaseUrl
+  });
+  try {
+    const messages = await transport.pollTopic(topicName, {
+      limit: limit ?? 50,
+      since: since ?? ""
+    });
+    return {
+      success: true,
+      data: {
+        topicName,
+        messages: messages.map((m) => ({
+          id: m.id,
+          from: m.from,
+          content: m.content,
+          conversationId: m.threadId,
+          timestamp: m.timestamp
+        })),
+        listenedForMs: Date.now() - startMs
+      }
+    };
+  } finally {
+    await transport.disconnect();
+  }
+}
+async function sendMessageImpl(content, to, conversationId, agentId) {
+  if (!to && !conversationId) {
+    return {
+      success: false,
+      error: { code: "E_ARGS", message: 'Must specify "to" (agent ID) or "conversationId"' }
+    };
+  }
+  const credential = await _resolveCredential(agentId);
+  const { LocalTransport, conduitFetch } = await import("@cleocode/core/conduit");
+  if (LocalTransport.isAvailable(getProjectRoot())) {
+    const transport = new LocalTransport();
+    await transport.connect({
+      agentId: credential.agentId,
+      apiKey: credential.apiKey,
+      apiBaseUrl: credential.apiBaseUrl
+    });
+    try {
+      const recipient = to ?? conversationId ?? "";
+      const result = await transport.push(recipient, content, {
+        conversationId
+      });
+      return {
+        success: true,
+        data: {
+          messageId: result.messageId,
+          from: credential.agentId,
+          to: recipient,
+          transport: "local",
+          sentAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    } finally {
+      await transport.disconnect();
+    }
+  }
+  let url;
+  const body = { content };
+  if (conversationId) {
+    url = `${credential.apiBaseUrl}/conversations/${conversationId}/messages`;
+  } else {
+    url = `${credential.apiBaseUrl}/messages`;
+    body["toAgentId"] = to;
+  }
+  const response = await conduitFetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${credential.apiKey}`,
+      "X-Agent-Id": credential.agentId
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    return {
+      success: false,
+      error: { code: "E_SEND", message: `Send failed: ${response.status} ${text}` }
+    };
+  }
+  const data = await response.json();
+  return {
+    success: true,
+    data: {
+      messageId: data.data?.message?.id ?? "unknown",
+      from: credential.agentId,
+      to: to ?? conversationId,
+      transport: "http",
+      sentAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+export {
+  ConduitHandler
+};
+//# sourceMappingURL=conduit-EY54WTZA.js.map