replicas-cli 0.2.119 → 0.2.121

package/dist/event-streams-S7HDVT33.mjs

@@ -0,0 +1,255 @@
+#!/usr/bin/env bun
+import {
+  fromUtf8,
+  toUtf8
+} from "./chunk-S6VA5TIO.mjs";
+import {
+  __publicField
+} from "./chunk-FFDYI4OH.mjs";
+
+// ../node_modules/.bun/@smithy+core@3.23.17/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
+var EventStreamSerde = class {
+  constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType }) {
+    __publicField(this, "marshaller");
+    __publicField(this, "serializer");
+    __publicField(this, "deserializer");
+    __publicField(this, "serdeContext");
+    __publicField(this, "defaultContentType");
+    this.marshaller = marshaller;
+    this.serializer = serializer;
+    this.deserializer = deserializer;
+    this.serdeContext = serdeContext;
+    this.defaultContentType = defaultContentType;
+  }
+  async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = requestSchema.getEventStreamMember();
+    const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+    const serializer = this.serializer;
+    const defaultContentType = this.defaultContentType;
+    const initialRequestMarker = /* @__PURE__ */ Symbol("initialRequestMarker");
+    const eventStreamIterable = {
+      async *[Symbol.asyncIterator]() {
+        if (initialRequest) {
+          const headers = {
+            ":event-type": { type: "string", value: "initial-request" },
+            ":message-type": { type: "string", value: "event" },
+            ":content-type": { type: "string", value: defaultContentType }
+          };
+          serializer.write(requestSchema, initialRequest);
+          const body = serializer.flush();
+          yield {
+            [initialRequestMarker]: true,
+            headers,
+            body
+          };
+        }
+        for await (const page of eventStream) {
+          yield page;
+        }
+      }
+    };
+    return marshaller.serialize(eventStreamIterable, (event) => {
+      if (event[initialRequestMarker]) {
+        return {
+          headers: event.headers,
+          body: event.body
+        };
+      }
+      let unionMember = "";
+      for (const key in event) {
+        if (key !== "__type") {
+          unionMember = key;
+          break;
+        }
+      }
+      const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+      const headers = {
+        ":event-type": { type: "string", value: eventType },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+        ...additionalHeaders
+      };
+      return {
+        headers,
+        body
+      };
+    });
+  }
+  async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = responseSchema.getEventStreamMember();
+    const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+    const memberSchemas = unionSchema.getMemberSchemas();
+    const initialResponseMarker = /* @__PURE__ */ Symbol("initialResponseMarker");
+    const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+      let unionMember = "";
+      for (const key in event) {
+        if (key !== "__type") {
+          unionMember = key;
+          break;
+        }
+      }
+      const body = event[unionMember].body;
+      if (unionMember === "initial-response") {
+        const dataObject = await this.deserializer.read(responseSchema, body);
+        delete dataObject[eventStreamMember];
+        return {
+          [initialResponseMarker]: true,
+          ...dataObject
+        };
+      } else if (unionMember in memberSchemas) {
+        const eventStreamSchema = memberSchemas[unionMember];
+        if (eventStreamSchema.isStructSchema()) {
+          const out = {};
+          let hasBindings = false;
+          for (const [name, member] of eventStreamSchema.structIterator()) {
+            const { eventHeader, eventPayload } = member.getMergedTraits();
+            hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
+            if (eventPayload) {
+              if (member.isBlobSchema()) {
+                out[name] = body;
+              } else if (member.isStringSchema()) {
+                out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8)(body);
+              } else if (member.isStructSchema()) {
+                out[name] = await this.deserializer.read(member, body);
+              }
+            } else if (eventHeader) {
+              const value = event[unionMember].headers[name]?.value;
+              if (value != null) {
+                if (member.isNumericSchema()) {
+                  if (value && typeof value === "object" && "bytes" in value) {
+                    out[name] = BigInt(value.toString());
+                  } else {
+                    out[name] = Number(value);
+                  }
+                } else {
+                  out[name] = value;
+                }
+              }
+            }
+          }
+          if (hasBindings) {
+            return {
+              [unionMember]: out
+            };
+          }
+          if (body.byteLength === 0) {
+            return {
+              [unionMember]: {}
+            };
+          }
+        }
+        return {
+          [unionMember]: await this.deserializer.read(eventStreamSchema, body)
+        };
+      } else {
+        return {
+          $unknown: event
+        };
+      }
+    });
+    const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+    const firstEvent = await asyncIterator.next();
+    if (firstEvent.done) {
+      return asyncIterable;
+    }
+    if (firstEvent.value?.[initialResponseMarker]) {
+      if (!responseSchema) {
+        throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+      }
+      for (const key in firstEvent.value) {
+        initialResponseContainer[key] = firstEvent.value[key];
+      }
+    }
+    return {
+      async *[Symbol.asyncIterator]() {
+        if (!firstEvent?.value?.[initialResponseMarker]) {
+          yield firstEvent.value;
+        }
+        while (true) {
+          const { done, value } = await asyncIterator.next();
+          if (done) {
+            break;
+          }
+          yield value;
+        }
+      }
+    };
+  }
+  writeEventBody(unionMember, unionSchema, event) {
+    const serializer = this.serializer;
+    let eventType = unionMember;
+    let explicitPayloadMember = null;
+    let explicitPayloadContentType;
+    const isKnownSchema = (() => {
+      const struct = unionSchema.getSchema();
+      return struct[4].includes(unionMember);
+    })();
+    const additionalHeaders = {};
+    if (!isKnownSchema) {
+      const [type, value] = event[unionMember];
+      eventType = type;
+      serializer.write(15, value);
+    } else {
+      const eventSchema = unionSchema.getMemberSchema(unionMember);
+      if (eventSchema.isStructSchema()) {
+        for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+          const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+          if (eventPayload) {
+            explicitPayloadMember = memberName;
+          } else if (eventHeader) {
+            const value = event[unionMember][memberName];
+            let type = "binary";
+            if (memberSchema.isNumericSchema()) {
+              if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                type = "integer";
+              } else {
+                type = "long";
+              }
+            } else if (memberSchema.isTimestampSchema()) {
+              type = "timestamp";
+            } else if (memberSchema.isStringSchema()) {
+              type = "string";
+            } else if (memberSchema.isBooleanSchema()) {
+              type = "boolean";
+            }
+            if (value != null) {
+              additionalHeaders[memberName] = {
+                type,
+                value
+              };
+              delete event[unionMember][memberName];
+            }
+          }
+        }
+        if (explicitPayloadMember !== null) {
+          const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+          if (payloadSchema.isBlobSchema()) {
+            explicitPayloadContentType = "application/octet-stream";
+          } else if (payloadSchema.isStringSchema()) {
+            explicitPayloadContentType = "text/plain";
+          }
+          serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+        } else {
+          serializer.write(eventSchema, event[unionMember]);
+        }
+      } else if (eventSchema.isUnitSchema()) {
+        serializer.write(eventSchema, {});
+      } else {
+        throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+      }
+    }
+    const messageSerialization = serializer.flush() ?? new Uint8Array();
+    const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization) : messageSerialization;
+    return {
+      body,
+      eventType,
+      explicitPayloadContentType,
+      additionalHeaders
+    };
+  }
+};
+export {
+  EventStreamSerde
+};

package/dist/event-streams-T3U3ZQLC.mjs

@@ -0,0 +1,247 @@
+#!/usr/bin/env bun
+import {
+  fromUtf8,
+  toUtf8
+} from "./chunk-S6VA5TIO.mjs";
+import {
+  __publicField
+} from "./chunk-FFDYI4OH.mjs";
+
+// ../node_modules/.bun/@smithy+core@3.23.13/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
+var EventStreamSerde = class {
+  constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType }) {
+    __publicField(this, "marshaller");
+    __publicField(this, "serializer");
+    __publicField(this, "deserializer");
+    __publicField(this, "serdeContext");
+    __publicField(this, "defaultContentType");
+    this.marshaller = marshaller;
+    this.serializer = serializer;
+    this.deserializer = deserializer;
+    this.serdeContext = serdeContext;
+    this.defaultContentType = defaultContentType;
+  }
+  async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = requestSchema.getEventStreamMember();
+    const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+    const serializer = this.serializer;
+    const defaultContentType = this.defaultContentType;
+    const initialRequestMarker = /* @__PURE__ */ Symbol("initialRequestMarker");
+    const eventStreamIterable = {
+      async *[Symbol.asyncIterator]() {
+        if (initialRequest) {
+          const headers = {
+            ":event-type": { type: "string", value: "initial-request" },
+            ":message-type": { type: "string", value: "event" },
+            ":content-type": { type: "string", value: defaultContentType }
+          };
+          serializer.write(requestSchema, initialRequest);
+          const body = serializer.flush();
+          yield {
+            [initialRequestMarker]: true,
+            headers,
+            body
+          };
+        }
+        for await (const page of eventStream) {
+          yield page;
+        }
+      }
+    };
+    return marshaller.serialize(eventStreamIterable, (event) => {
+      if (event[initialRequestMarker]) {
+        return {
+          headers: event.headers,
+          body: event.body
+        };
+      }
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+      const headers = {
+        ":event-type": { type: "string", value: eventType },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+        ...additionalHeaders
+      };
+      return {
+        headers,
+        body
+      };
+    });
+  }
+  async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = responseSchema.getEventStreamMember();
+    const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+    const memberSchemas = unionSchema.getMemberSchemas();
+    const initialResponseMarker = /* @__PURE__ */ Symbol("initialResponseMarker");
+    const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      const body = event[unionMember].body;
+      if (unionMember === "initial-response") {
+        const dataObject = await this.deserializer.read(responseSchema, body);
+        delete dataObject[eventStreamMember];
+        return {
+          [initialResponseMarker]: true,
+          ...dataObject
+        };
+      } else if (unionMember in memberSchemas) {
+        const eventStreamSchema = memberSchemas[unionMember];
+        if (eventStreamSchema.isStructSchema()) {
+          const out = {};
+          let hasBindings = false;
+          for (const [name, member] of eventStreamSchema.structIterator()) {
+            const { eventHeader, eventPayload } = member.getMergedTraits();
+            hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
+            if (eventPayload) {
+              if (member.isBlobSchema()) {
+                out[name] = body;
+              } else if (member.isStringSchema()) {
+                out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8)(body);
+              } else if (member.isStructSchema()) {
+                out[name] = await this.deserializer.read(member, body);
+              }
+            } else if (eventHeader) {
+              const value = event[unionMember].headers[name]?.value;
+              if (value != null) {
+                if (member.isNumericSchema()) {
+                  if (value && typeof value === "object" && "bytes" in value) {
+                    out[name] = BigInt(value.toString());
+                  } else {
+                    out[name] = Number(value);
+                  }
+                } else {
+                  out[name] = value;
+                }
+              }
+            }
+          }
+          if (hasBindings) {
+            return {
+              [unionMember]: out
+            };
+          }
+          if (body.byteLength === 0) {
+            return {
+              [unionMember]: {}
+            };
+          }
+        }
+        return {
+          [unionMember]: await this.deserializer.read(eventStreamSchema, body)
+        };
+      } else {
+        return {
+          $unknown: event
+        };
+      }
+    });
+    const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+    const firstEvent = await asyncIterator.next();
+    if (firstEvent.done) {
+      return asyncIterable;
+    }
+    if (firstEvent.value?.[initialResponseMarker]) {
+      if (!responseSchema) {
+        throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+      }
+      for (const [key, value] of Object.entries(firstEvent.value)) {
+        initialResponseContainer[key] = value;
+      }
+    }
+    return {
+      async *[Symbol.asyncIterator]() {
+        if (!firstEvent?.value?.[initialResponseMarker]) {
+          yield firstEvent.value;
+        }
+        while (true) {
+          const { done, value } = await asyncIterator.next();
+          if (done) {
+            break;
+          }
+          yield value;
+        }
+      }
+    };
+  }
+  writeEventBody(unionMember, unionSchema, event) {
+    const serializer = this.serializer;
+    let eventType = unionMember;
+    let explicitPayloadMember = null;
+    let explicitPayloadContentType;
+    const isKnownSchema = (() => {
+      const struct = unionSchema.getSchema();
+      return struct[4].includes(unionMember);
+    })();
+    const additionalHeaders = {};
+    if (!isKnownSchema) {
+      const [type, value] = event[unionMember];
+      eventType = type;
+      serializer.write(15, value);
+    } else {
+      const eventSchema = unionSchema.getMemberSchema(unionMember);
+      if (eventSchema.isStructSchema()) {
+        for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+          const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+          if (eventPayload) {
+            explicitPayloadMember = memberName;
+          } else if (eventHeader) {
+            const value = event[unionMember][memberName];
+            let type = "binary";
+            if (memberSchema.isNumericSchema()) {
+              if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                type = "integer";
+              } else {
+                type = "long";
+              }
+            } else if (memberSchema.isTimestampSchema()) {
+              type = "timestamp";
+            } else if (memberSchema.isStringSchema()) {
+              type = "string";
+            } else if (memberSchema.isBooleanSchema()) {
+              type = "boolean";
+            }
+            if (value != null) {
+              additionalHeaders[memberName] = {
+                type,
+                value
+              };
+              delete event[unionMember][memberName];
+            }
+          }
+        }
+        if (explicitPayloadMember !== null) {
+          const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+          if (payloadSchema.isBlobSchema()) {
+            explicitPayloadContentType = "application/octet-stream";
+          } else if (payloadSchema.isStringSchema()) {
+            explicitPayloadContentType = "text/plain";
+          }
+          serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+        } else {
+          serializer.write(eventSchema, event[unionMember]);
+        }
+      } else if (eventSchema.isUnitSchema()) {
+        serializer.write(eventSchema, {});
+      } else {
+        throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+      }
+    }
+    const messageSerialization = serializer.flush() ?? new Uint8Array();
+    const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization) : messageSerialization;
+    return {
+      body,
+      eventType,
+      explicitPayloadContentType,
+      additionalHeaders
+    };
+  }
+};
+export {
+  EventStreamSerde
+};

package/dist/index.mjs

@@ -16,7 +16,8 @@ import {
   setIdeCommand,
   setOrganizationId,
   writeConfig
-} from "./chunk-HOO346QO.mjs";
+} from "./chunk-CPVJVKSG.mjs";
+import "./chunk-FFDYI4OH.mjs";
 
 // src/index.ts
 import "dotenv/config";
@@ -2420,12 +2421,12 @@ async function interactiveCommand() {
     );
   }
   console.log(chalk18.gray("Starting interactive mode..."));
-  const { launchInteractive } = await import("./interactive-V22J5FZI.mjs");
+  const { launchInteractive } = await import("./interactive-P7CS3HLU.mjs");
   await launchInteractive();
 }
 
 // src/index.ts
-var CLI_VERSION = "0.2.119";
+var CLI_VERSION = "0.2.121";
 var program = new Command();
 program.name("replicas").description("CLI for managing Replicas workspaces").version(CLI_VERSION);
 program.command("login").description("Authenticate with your Replicas account").action(async () => {

package/dist/{interactive-V22J5FZI.mjs → interactive-P7CS3HLU.mjs}

@@ -12,7 +12,8 @@ import {
   isAgentBackendEvent,
   parseAgentEvents,
   parseUserMessage
-} from "./chunk-HOO346QO.mjs";
+} from "./chunk-CPVJVKSG.mjs";
+import "./chunk-FFDYI4OH.mjs";
 
 // src/interactive/index.tsx
 import { createCliRenderer } from "@opentui/core";