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

package/dist/cli/conduit-4H32UYEA.js

@@ -0,0 +1,308 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/conduit.ts
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Show Conduit daemon health and message queue depth" },
+  args: {
+    "agent-id": {
+      type: "string",
+      description: "Agent ID to check (defaults to active agent)",
+      alias: "a"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "conduit",
+      "status",
+      {
+        agentId: args["agent-id"]
+      },
+      { command: "conduit status" }
+    );
+  }
+});
+var peekCommand = defineCommand({
+  meta: {
+    name: "peek",
+    description: "Preview queued Conduit messages without consuming"
+  },
+  args: {
+    "agent-id": {
+      type: "string",
+      description: "Agent ID to poll as (defaults to active agent)",
+      alias: "a"
+    },
+    limit: {
+      type: "string",
+      description: "Max messages to show (default: 20)",
+      default: "20"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "conduit",
+      "peek",
+      {
+        agentId: args["agent-id"],
+        limit: Number.parseInt(args.limit, 10)
+      },
+      { command: "conduit peek" }
+    );
+  }
+});
+var startCommand = defineCommand({
+  meta: { name: "start", description: "Start or resume the Conduit polling daemon" },
+  args: {
+    "agent-id": {
+      type: "string",
+      description: "Agent ID to poll as (defaults to active agent)",
+      alias: "a"
+    },
+    interval: {
+      type: "string",
+      description: "Poll interval in milliseconds (default: 5000)",
+      default: "5000"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "conduit",
+      "start",
+      {
+        agentId: args["agent-id"],
+        pollIntervalMs: Number.parseInt(args.interval, 10)
+      },
+      { command: "conduit start" }
+    );
+  }
+});
+var stopCommand = defineCommand({
+  meta: { name: "stop", description: "Stop the active Conduit polling daemon" },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "conduit",
+      "stop",
+      {},
+      {
+        command: "conduit stop"
+      }
+    );
+  }
+});
+var sendCommand = defineCommand({
+  meta: { name: "send", description: "Send a message via Conduit to an agent or conversation" },
+  args: {
+    to: {
+      type: "string",
+      description: "Target agent ID (required if --conversation-id not given)"
+    },
+    content: {
+      type: "string",
+      description: "Message content to send",
+      required: true
+    },
+    "conversation-id": {
+      type: "string",
+      description: "Target conversation ID (required if --to not given)"
+    },
+    "agent-id": {
+      type: "string",
+      description: "Sending agent ID (defaults to active agent)",
+      alias: "a"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "conduit",
+      "send",
+      {
+        to: args.to,
+        content: args.content,
+        conversationId: args["conversation-id"],
+        agentId: args["agent-id"]
+      },
+      { command: "conduit send" }
+    );
+  }
+});
+var publishCommand = defineCommand({
+  meta: {
+    name: "publish",
+    description: "Publish a message to a Conduit topic (A2A)"
+  },
+  args: {
+    topic: {
+      type: "string",
+      description: 'Topic name to publish to (e.g. "epic-T1149.wave-2")',
+      required: true
+    },
+    kind: {
+      type: "string",
+      description: "Message kind: message | request | notify | subscribe (default: message)",
+      default: "message"
+    },
+    payload: {
+      type: "string",
+      description: "Structured JSON payload to attach (optional)"
+    },
+    content: {
+      type: "string",
+      description: "Message content (defaults to the payload JSON when omitted)"
+    },
+    "agent-id": {
+      type: "string",
+      description: "Publishing agent ID (defaults to active agent)",
+      alias: "a"
+    }
+  },
+  async run({ args }) {
+    const content = args.content ?? args.payload ?? "{}";
+    let parsedPayload;
+    if (args.payload) {
+      try {
+        parsedPayload = JSON.parse(args.payload);
+      } catch {
+        parsedPayload = { raw: args.payload };
+      }
+    }
+    await dispatchFromCli(
+      "mutate",
+      "conduit",
+      "publish",
+      {
+        topicName: args.topic,
+        kind: args.kind,
+        content,
+        payload: parsedPayload,
+        agentId: args["agent-id"]
+      },
+      { command: "conduit publish" }
+    );
+  }
+});
+var subscribeCommand = defineCommand({
+  meta: {
+    name: "subscribe",
+    description: "Subscribe agent to a Conduit topic (A2A)"
+  },
+  args: {
+    topic: {
+      type: "string",
+      description: 'Topic name to subscribe to (e.g. "epic-T1149.coordination")',
+      required: true
+    },
+    "agent-id": {
+      type: "string",
+      description: "Agent ID to subscribe (defaults to active agent)",
+      alias: "a"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "conduit",
+      "subscribe",
+      {
+        topicName: args.topic,
+        agentId: args["agent-id"]
+      },
+      { command: "conduit subscribe" }
+    );
+  }
+});
+var listenCommand = defineCommand({
+  meta: {
+    name: "listen",
+    description: "One-shot poll for messages on a Conduit topic (A2A)"
+  },
+  args: {
+    topic: {
+      type: "string",
+      description: 'Topic name to poll (e.g. "epic-T1149.wave-2")',
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Max messages to return (default: 50)",
+      default: "50"
+    },
+    since: {
+      type: "string",
+      description: "Return only messages after this ISO 8601 timestamp (optional)"
+    },
+    "agent-id": {
+      type: "string",
+      description: "Agent ID to poll as (defaults to active agent)",
+      alias: "a"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "conduit",
+      "listen",
+      {
+        topicName: args.topic,
+        limit: Number.parseInt(args.limit, 10),
+        since: args.since,
+        agentId: args["agent-id"]
+      },
+      { command: "conduit listen" }
+    );
+  }
+});
+var conduitCommand = defineCommand({
+  meta: { name: "conduit", description: "Manage Conduit inter-agent messaging" },
+  subCommands: {
+    status: statusCommand,
+    peek: peekCommand,
+    start: startCommand,
+    stop: stopCommand,
+    send: sendCommand,
+    publish: publishCommand,
+    subscribe: subscribeCommand,
+    listen: listenCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  conduitCommand
+};
+//# sourceMappingURL=conduit-4H32UYEA.js.map