@shadowob/sdk 1.1.7 → 1.1.8

package/dist/index.cjs

@@ -32,15 +32,717 @@ var index_exports = {};
 __export(index_exports, {
   CLIENT_EVENTS: () => import_shared.CLIENT_EVENTS,
   SERVER_EVENTS: () => import_shared.SERVER_EVENTS,
+  SHADOW_SERVER_APP_COMMAND_COMPLETED_EVENT: () => SHADOW_SERVER_APP_COMMAND_COMPLETED_EVENT,
+  SHADOW_SERVER_APP_COMMAND_EVENTS: () => SHADOW_SERVER_APP_COMMAND_EVENTS,
+  SHADOW_SERVER_APP_COMMAND_FAILED_EVENT: () => SHADOW_SERVER_APP_COMMAND_FAILED_EVENT,
+  SHADOW_SERVER_APP_PROTOCOL: () => SHADOW_SERVER_APP_PROTOCOL,
+  ShadowBridge: () => ShadowBridge,
   ShadowClient: () => ShadowClient,
+  ShadowServerAppCommandError: () => ShadowServerAppCommandError,
+  ShadowServerAppOutbox: () => ShadowServerAppOutbox,
+  ShadowServerAppRuntime: () => ShadowServerAppRuntime,
   ShadowSocket: () => ShadowSocket,
   ShadowVoiceConsumer: () => ShadowVoiceConsumer,
+  buildShadowServerAppInboxDelivery: () => buildShadowServerAppInboxDelivery,
+  buildShadowServerAppInboxTaskRequest: () => buildShadowServerAppInboxTaskRequest,
   channelRoom: () => channelRoom,
+  createShadowServerAppManifest: () => createShadowServerAppManifest,
+  defineShadowServerApp: () => defineShadowServerApp,
+  extractShadowServerAppBearerToken: () => extractShadowServerAppBearerToken,
+  getShadowServerAppChannelMessageDeliveries: () => getShadowServerAppChannelMessageDeliveries,
+  getShadowServerAppChannelMessageErrors: () => getShadowServerAppChannelMessageErrors,
+  getShadowServerAppTaskCardId: () => getShadowServerAppTaskCardId,
+  introspectShadowServerAppToken: () => introspectShadowServerAppToken,
+  normalizeShadowServerAppCommandInput: () => normalizeShadowServerAppCommandInput,
+  parseShadowServerAppCommandRequest: () => parseShadowServerAppCommandRequest,
+  shadowServerAppActorAvatarUrl: () => shadowServerAppActorAvatarUrl,
+  shadowServerAppActorDisplayName: () => shadowServerAppActorDisplayName,
+  shadowServerAppActorRef: () => shadowServerAppActorRef,
+  shadowServerAppError: () => shadowServerAppError,
+  shadowServerAppInboxTaskEndpoint: () => shadowServerAppInboxTaskEndpoint,
   threadRoom: () => threadRoom,
-  userRoom: () => userRoom
+  userRoom: () => userRoom,
+  validateShadowServerAppJsonSchema: () => validateShadowServerAppJsonSchema
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/server-app.ts
+var SHADOW_SERVER_APP_PROTOCOL = "shadow.app/1";
+var SHADOW_SERVER_APP_COMMAND_COMPLETED_EVENT = "server_app.command.completed";
+var SHADOW_SERVER_APP_COMMAND_FAILED_EVENT = "server_app.command.failed";
+var SHADOW_SERVER_APP_COMMAND_EVENTS = [
+  SHADOW_SERVER_APP_COMMAND_COMPLETED_EVENT,
+  SHADOW_SERVER_APP_COMMAND_FAILED_EVENT
+];
+function isProtocolRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function optionalProtocolString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function protocolPathSegment(value) {
+  return encodeURIComponent(value);
+}
+function shadowServerAppInboxTaskEndpoint(serverIdOrSlug, target) {
+  if ("channelId" in target && target.channelId) {
+    return `/api/channels/${protocolPathSegment(target.channelId)}/inbox/tasks`;
+  }
+  if ("agentId" in target && target.agentId) {
+    return `/api/servers/${protocolPathSegment(serverIdOrSlug)}/inboxes/${protocolPathSegment(
+      target.agentId
+    )}/tasks`;
+  }
+  throw new Error("Missing Inbox task target");
+}
+function buildShadowServerAppInboxTaskRequest(input) {
+  const appId = input.app.id ?? input.app.appId ?? input.app.appKey;
+  const serverAppData = isProtocolRecord(input.task.data?.serverApp) ? input.task.data.serverApp : {};
+  return {
+    endpoint: shadowServerAppInboxTaskEndpoint(input.serverIdOrSlug, input.target),
+    body: {
+      title: input.task.title,
+      body: input.task.body,
+      priority: input.task.priority,
+      idempotencyKey: input.task.idempotencyKey,
+      source: {
+        kind: "server_app",
+        id: appId,
+        appId,
+        appKey: input.app.appKey,
+        ...input.app.serverId ? { serverId: input.app.serverId } : {},
+        ...input.commandName ? { command: input.commandName } : {},
+        label: input.app.label ?? input.app.name ?? input.app.appKey,
+        ...input.task.resource ? { resource: input.task.resource } : {}
+      },
+      data: {
+        ...input.task.data ?? {},
+        serverApp: {
+          ...serverAppData,
+          appKey: input.app.appKey,
+          ...input.commandName ? { command: input.commandName } : {}
+        }
+      }
+    }
+  };
+}
+function getShadowServerAppTaskCardId(message) {
+  const metadata = isProtocolRecord(message) ? message.metadata : null;
+  const cards = isProtocolRecord(metadata) && Array.isArray(metadata.cards) ? metadata.cards : [];
+  for (const item of cards) {
+    if (!isProtocolRecord(item)) continue;
+    if (item.kind === "task" && typeof item.id === "string" && item.id) return item.id;
+  }
+  return null;
+}
+function buildShadowServerAppInboxDelivery(input) {
+  const message = isProtocolRecord(input.message) ? input.message : {};
+  return {
+    ..."agentId" in input.target && input.target.agentId ? { agentId: input.target.agentId } : {},
+    channelId: optionalProtocolString(message.channelId),
+    messageId: optionalProtocolString(message.id),
+    cardId: getShadowServerAppTaskCardId(message),
+    idempotencyKey: input.idempotencyKey
+  };
+}
+function shadowFromPayload(payload) {
+  if (payload.protocol === SHADOW_SERVER_APP_PROTOCOL) {
+    return payload;
+  }
+  const shadow = isProtocolRecord(payload.shadow) ? payload.shadow : null;
+  if (shadow?.protocol === SHADOW_SERVER_APP_PROTOCOL) {
+    return shadow;
+  }
+  return null;
+}
+function mergeShadowResult(value, shadow) {
+  if (!shadow) return value;
+  const existing = shadowFromPayload(value);
+  if (!existing) return { ...value, shadow };
+  return {
+    ...value,
+    shadow: {
+      protocol: SHADOW_SERVER_APP_PROTOCOL,
+      outbox: {
+        ...existing.outbox ?? {},
+        ...shadow.outbox ?? {}
+      }
+    }
+  };
+}
+function getShadowServerAppInboxDeliveries(payload) {
+  if (!isProtocolRecord(payload)) return [];
+  const shadow = shadowFromPayload(payload);
+  return shadow?.outbox?.deliveries ?? [];
+}
+function getShadowServerAppInboxErrors(payload) {
+  if (!isProtocolRecord(payload)) return [];
+  const shadow = shadowFromPayload(payload);
+  return shadow?.outbox?.errors ?? [];
+}
+function getShadowServerAppChannelMessageDeliveries(payload) {
+  if (!isProtocolRecord(payload)) return [];
+  const shadow = shadowFromPayload(payload);
+  return shadow?.outbox?.channelMessageDeliveries ?? [];
+}
+function getShadowServerAppChannelMessageErrors(payload) {
+  if (!isProtocolRecord(payload)) return [];
+  const shadow = shadowFromPayload(payload);
+  return shadow?.outbox?.channelMessageErrors ?? [];
+}
+function unwrapShadowServerAppCommandPayload(payload) {
+  if (isProtocolRecord(payload) && payload.ok === false) {
+    throw new Error(typeof payload.error === "string" ? payload.error : "Command failed");
+  }
+  if (isProtocolRecord(payload) && "result" in payload && payload.result !== void 0) {
+    const nested = unwrapShadowServerAppCommandPayload(payload.result);
+    const shadow = shadowFromPayload(payload);
+    if (isProtocolRecord(nested)) return mergeShadowResult(nested, shadow);
+    return nested;
+  }
+  return payload;
+}
+var ShadowServerAppOutbox = class {
+  inboxTasks = [];
+  channelMessages = [];
+  enqueueInboxTask(task) {
+    this.inboxTasks.push(task);
+    return this;
+  }
+  enqueueInboxTasks(tasks) {
+    for (const task of tasks) this.enqueueInboxTask(task);
+    return this;
+  }
+  sendChannelMessage(message) {
+    this.channelMessages.push(message);
+    return this;
+  }
+  sendChannelMessages(messages) {
+    for (const message of messages) this.sendChannelMessage(message);
+    return this;
+  }
+  toShadow() {
+    return {
+      protocol: SHADOW_SERVER_APP_PROTOCOL,
+      outbox: {
+        ...this.inboxTasks.length > 0 ? { inboxTasks: [...this.inboxTasks] } : {},
+        ...this.channelMessages.length > 0 ? { channelMessages: [...this.channelMessages] } : {}
+      }
+    };
+  }
+  attachTo(result) {
+    return { ...result, shadow: this.toShadow() };
+  }
+};
+function trimTrailingSlash(value) {
+  return value.replace(/\/$/, "");
+}
+function joinBasePath(baseUrl, path) {
+  const cleanBase = trimTrailingSlash(baseUrl);
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  return `${cleanBase}${cleanPath}`;
+}
+function extractShadowServerAppBearerToken(value) {
+  if (!value) return null;
+  return value.toLowerCase().startsWith("bearer ") ? value.slice(7).trim() : null;
+}
+function normalizeShadowServerAppCommandInput(value) {
+  if (value && typeof value === "object" && !Array.isArray(value) && "input" in value && Object.keys(value).every((key) => key === "input" || key === "channelId")) {
+    return value.input ?? {};
+  }
+  return value;
+}
+function createShadowServerAppManifest(manifest, options = {}) {
+  const publicBaseUrl = trimTrailingSlash(
+    options.publicBaseUrl ?? `http://localhost:${options.port ?? 4201}`
+  );
+  const apiBaseUrl = trimTrailingSlash(options.apiBaseUrl ?? publicBaseUrl);
+  const iframePath = options.iframePath ?? "/shadow/server";
+  const iconPath = options.iconPath ?? "/assets/icon.svg";
+  return {
+    ...manifest,
+    iconUrl: joinBasePath(publicBaseUrl, iconPath),
+    iframe: manifest.iframe ? {
+      ...manifest.iframe,
+      entry: joinBasePath(publicBaseUrl, iframePath),
+      allowedOrigins: options.allowedOrigins ?? [publicBaseUrl]
+    } : manifest.iframe,
+    api: {
+      ...manifest.api,
+      baseUrl: apiBaseUrl
+    }
+  };
+}
+function defineShadowServerApp(manifest, options = {}) {
+  return new ShadowServerAppRuntime(manifest, options);
+}
+var ShadowServerAppCommandError = class extends Error {
+  status;
+  issues;
+  constructor(status, error, issues) {
+    super(error);
+    this.name = "ShadowServerAppCommandError";
+    this.status = status;
+    this.issues = issues;
+  }
+};
+function shadowServerAppError(status, error, issues) {
+  return new ShadowServerAppCommandError(status, error, issues);
+}
+var ShadowServerAppRuntime = class {
+  constructor(sourceManifest, options = {}) {
+    this.sourceManifest = sourceManifest;
+    this.options = options;
+  }
+  manifest(options = {}) {
+    return createShadowServerAppManifest(this.sourceManifest, options);
+  }
+  defineCommands(handlers) {
+    return handlers;
+  }
+  actor(envelopeOrContext) {
+    return shadowServerAppActorRef(envelopeOrContext);
+  }
+  error(status, error, issues) {
+    return shadowServerAppError(status, error, issues);
+  }
+  async parseCommand(commandName, request) {
+    return parseShadowServerAppCommandRequest(
+      {
+        ...request,
+        expectedCommand: commandName,
+        shadowBaseUrl: this.options.shadowBaseUrl,
+        fetchImpl: this.options.fetchImpl
+      }
+    );
+  }
+  async executeCommand(commandName, request, handlers) {
+    const parsed = await this.parseCommand(commandName, request);
+    if (!parsed.ok) return parseErrorResult(parsed);
+    return this.executeEnvelope(commandName, parsed.envelope, handlers);
+  }
+  async executeLocal(commandName, input, context, handlers) {
+    return this.executeEnvelope(
+      commandName,
+      {
+        input,
+        context: {
+          ...context,
+          command: commandName
+        }
+      },
+      handlers
+    );
+  }
+  async executeEnvelope(commandName, envelope, handlers) {
+    const command = this.sourceManifest.commands.find((item) => item.name === commandName);
+    if (!command) return failureResult(404, "command_not_found");
+    const validation = validateShadowServerAppJsonSchema(command.inputSchema, envelope.input);
+    if (!validation.ok) return failureResult(422, "invalid_input", validation.issues);
+    const handler = handlers[commandName];
+    if (!handler) return failureResult(404, "command_not_found");
+    try {
+      const result = await handler(envelope.input, {
+        context: envelope.context,
+        actor: this.actor(envelope)
+      });
+      return { ok: true, status: 200, body: { ok: true, result } };
+    } catch (error) {
+      if (error instanceof ShadowServerAppCommandError) {
+        return failureResult(error.status, error.message, error.issues);
+      }
+      throw error;
+    }
+  }
+};
+async function introspectShadowServerAppToken(input) {
+  const baseUrl = trimTrailingSlash(input.shadowBaseUrl ?? "http://localhost:3002");
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const response = await fetchImpl(
+    `${baseUrl}/api/servers/${encodeURIComponent(input.serverId)}/apps/${encodeURIComponent(
+      input.appKey
+    )}/oauth/introspect`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${input.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ token: input.token })
+    }
+  );
+  if (!response.ok) return null;
+  const payload = await response.json();
+  return payload.active ? payload : null;
+}
+async function parseShadowServerAppCommandRequest(input) {
+  const token = extractShadowServerAppBearerToken(input.authorizationHeader);
+  const serverId = input.serverIdHeader;
+  const appKey = input.appKeyHeader;
+  if (!token || !serverId || !appKey) {
+    return { ok: false, status: 401, error: "missing_oauth" };
+  }
+  const introspection = await introspectShadowServerAppToken({
+    token,
+    serverId,
+    appKey,
+    shadowBaseUrl: input.shadowBaseUrl,
+    fetchImpl: input.fetchImpl
+  }).catch(() => null);
+  const context = introspection?.shadow;
+  if (!context) return { ok: false, status: 401, error: "invalid_token" };
+  if (context.command !== input.expectedCommand) {
+    return { ok: false, status: 403, error: "wrong_command" };
+  }
+  let commandInput;
+  if (input.requestInput !== void 0) {
+    commandInput = input.requestInput;
+  } else {
+    let body;
+    try {
+      body = JSON.parse(input.requestBody ?? "{}");
+    } catch {
+      return { ok: false, status: 400, error: "invalid_json" };
+    }
+    commandInput = body.input ?? {};
+  }
+  return {
+    ok: true,
+    envelope: {
+      input: commandInput,
+      context
+    }
+  };
+}
+function validateShadowServerAppJsonSchema(schema, value) {
+  if (!schema) return { ok: true };
+  const issues = [];
+  validateJsonSchemaValue(schema, value, "", issues);
+  return issues.length ? { ok: false, issues } : { ok: true };
+}
+function shadowServerAppActorDisplayName(envelopeOrContext) {
+  const context = "context" in envelopeOrContext ? envelopeOrContext.context : envelopeOrContext;
+  const actor = context.actor;
+  const profile = actor.profile;
+  return profile?.displayName?.trim() || profile?.username?.trim() || (actor.buddyAgentId ? `Buddy ${actor.buddyAgentId.slice(0, 8)}` : null) || (actor.userId ? `${actor.kind}:${actor.userId.slice(0, 8)}` : null) || `${actor.kind}:unknown`;
+}
+function shadowServerAppActorAvatarUrl(envelopeOrContext) {
+  const context = "context" in envelopeOrContext ? envelopeOrContext.context : envelopeOrContext;
+  return context.actor.profile?.avatarUrl ?? null;
+}
+function shadowServerAppActorRef(envelopeOrContext) {
+  const context = "context" in envelopeOrContext ? envelopeOrContext.context : envelopeOrContext;
+  const actor = context.actor;
+  return {
+    kind: actor.kind,
+    id: actor.buddyAgentId ?? actor.userId ?? actor.ownerId ?? "unknown",
+    userId: actor.userId ?? null,
+    buddyAgentId: actor.buddyAgentId ?? null,
+    ownerId: actor.ownerId ?? null,
+    displayName: shadowServerAppActorDisplayName(context),
+    avatarUrl: shadowServerAppActorAvatarUrl(context)
+  };
+}
+function parseErrorResult(error) {
+  return failureResult(error.status, error.error, error.issues);
+}
+function failureResult(status, error, issues) {
+  return {
+    ok: false,
+    status,
+    body: issues === void 0 ? { ok: false, error } : { ok: false, error, issues }
+  };
+}
+function validateJsonSchemaValue(schema, value, path, issues) {
+  if (Array.isArray(schema.oneOf)) {
+    const matches = schema.oneOf.some((option) => {
+      const nestedIssues = [];
+      if (option && typeof option === "object" && !Array.isArray(option)) {
+        validateJsonSchemaValue(
+          option,
+          value,
+          path,
+          nestedIssues
+        );
+      }
+      return nestedIssues.length === 0;
+    });
+    if (!matches) issues.push({ path, message: "Expected value matching one schema option" });
+    return;
+  }
+  const enumValues = schema.enum;
+  if (Array.isArray(enumValues) && !enumValues.includes(value)) {
+    issues.push({ path, message: `Expected one of ${enumValues.map(String).join(", ")}` });
+    return;
+  }
+  const type = schema.type;
+  if (type === "object") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      issues.push({ path, message: "Expected object" });
+      return;
+    }
+    const record = value;
+    const properties = schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties) ? schema.properties : {};
+    const required = Array.isArray(schema.required) ? schema.required.map(String) : [];
+    for (const key of required) {
+      if (!(key in record)) issues.push({ path: joinJsonPath(path, key), message: "Required" });
+    }
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (record[key] !== void 0) {
+        validateJsonSchemaValue(propertySchema, record[key], joinJsonPath(path, key), issues);
+      }
+    }
+    const additionalProperties = schema.additionalProperties && typeof schema.additionalProperties === "object" && !Array.isArray(schema.additionalProperties) ? schema.additionalProperties : null;
+    if (additionalProperties) {
+      for (const [key, nestedValue] of Object.entries(record)) {
+        if (!(key in properties)) {
+          validateJsonSchemaValue(
+            additionalProperties,
+            nestedValue,
+            joinJsonPath(path, key),
+            issues
+          );
+        }
+      }
+    } else if (schema.additionalProperties === false) {
+      for (const key of Object.keys(record)) {
+        if (!(key in properties)) {
+          issues.push({ path: joinJsonPath(path, key), message: "Unknown property" });
+        }
+      }
+    }
+    return;
+  }
+  if (type === "array") {
+    if (!Array.isArray(value)) {
+      issues.push({ path, message: "Expected array" });
+      return;
+    }
+    const maxItems = typeof schema.maxItems === "number" ? schema.maxItems : null;
+    if (maxItems !== null && value.length > maxItems) {
+      issues.push({ path, message: `Expected at most ${maxItems} items` });
+    }
+    const itemSchema = schema.items && typeof schema.items === "object" && !Array.isArray(schema.items) ? schema.items : null;
+    if (itemSchema) {
+      value.forEach(
+        (item, index) => validateJsonSchemaValue(itemSchema, item, `${path}[${index}]`, issues)
+      );
+    }
+    return;
+  }
+  if (type === "string") {
+    if (typeof value !== "string") {
+      issues.push({ path, message: "Expected string" });
+      return;
+    }
+    const maxLength = typeof schema.maxLength === "number" ? schema.maxLength : null;
+    const minLength = typeof schema.minLength === "number" ? schema.minLength : null;
+    if (minLength !== null && value.length < minLength) {
+      issues.push({ path, message: `Expected at least ${minLength} characters` });
+    }
+    if (maxLength !== null && value.length > maxLength) {
+      issues.push({ path, message: `Expected at most ${maxLength} characters` });
+    }
+    return;
+  }
+  if (type === "number" || type === "integer") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      issues.push({ path, message: "Expected number" });
+      return;
+    }
+    if (type === "integer" && !Number.isInteger(value)) {
+      issues.push({ path, message: "Expected integer" });
+    }
+    return;
+  }
+  if (type === "boolean" && typeof value !== "boolean") {
+    issues.push({ path, message: "Expected boolean" });
+  }
+}
+function joinJsonPath(parent, key) {
+  return parent ? `${parent}.${key}` : key;
+}
+
+// src/bridge.ts
+var ShadowBridge = class _ShadowBridge {
+  static commandRequestType = "shadow.app.command.request";
+  static commandResponseType = "shadow.app.command.response";
+  static inboxesRequestType = "shadow.app.inboxes.request";
+  static inboxesResponseType = "shadow.app.inboxes.response";
+  static enqueueInboxTaskRequestType = "shadow.app.inbox.enqueue.request";
+  static enqueueInboxTaskResponseType = "shadow.app.inbox.enqueue.response";
+  static openBuddyCreatorRequestType = "shadow.app.buddy.create.request";
+  static openBuddyCreatorResponseType = "shadow.app.buddy.create.response";
+  static inboxDeliveries(payload) {
+    return getShadowServerAppInboxDeliveries(payload);
+  }
+  static inboxErrors(payload) {
+    return getShadowServerAppInboxErrors(payload);
+  }
+  static channelMessageDeliveries(payload) {
+    return getShadowServerAppChannelMessageDeliveries(payload);
+  }
+  static channelMessageErrors(payload) {
+    return getShadowServerAppChannelMessageErrors(payload);
+  }
+  static unwrapCommandPayload(payload) {
+    return unwrapShadowServerAppCommandPayload(payload);
+  }
+  appKey;
+  targetOrigin;
+  timeoutMs;
+  win;
+  hasLaunchContext;
+  pending = /* @__PURE__ */ new Map();
+  onMessage = (event) => {
+    let data = event.data;
+    if (typeof data === "string") {
+      try {
+        data = JSON.parse(data || "{}");
+      } catch {
+        return;
+      }
+    }
+    if (!data || typeof data !== "object") return;
+    const record = data;
+    if (typeof record.requestId !== "string" || typeof record.type !== "string") return;
+    const entry = this.pending.get(record.requestId);
+    if (!entry || record.type !== entry.responseType) return;
+    this.pending.delete(record.requestId);
+    if (record.ok) entry.resolve(record.result);
+    else
+      entry.reject(
+        new Error(typeof record.error === "string" ? record.error : "Bridge request failed")
+      );
+  };
+  constructor(options) {
+    this.appKey = options.appKey;
+    this.targetOrigin = options.targetOrigin ?? "*";
+    this.timeoutMs = options.timeoutMs ?? 6e4;
+    this.win = options.windowRef ?? (typeof window === "undefined" ? null : window);
+    this.hasLaunchContext = this.resolveLaunchContext();
+    this.win?.addEventListener("message", this.onMessage);
+  }
+  dispose() {
+    this.win?.removeEventListener("message", this.onMessage);
+    for (const entry of this.pending.values()) {
+      entry.reject(new Error("ShadowBridge disposed"));
+    }
+    this.pending.clear();
+  }
+  isAvailable() {
+    if (!this.win) return false;
+    return this.hasLaunchContext && (this.win.parent !== this.win || !!this.win.ReactNativeWebView);
+  }
+  command(commandName, input, options = {}) {
+    return this.request(
+      _ShadowBridge.commandRequestType,
+      _ShadowBridge.commandResponseType,
+      {
+        commandName,
+        input,
+        ...options.channelId ? { channelId: options.channelId } : {},
+        ...options.task ? { task: options.task } : {}
+      },
+      options.timeoutMs
+    ).then(
+      (payload) => unwrapShadowServerAppCommandPayload(payload)
+    );
+  }
+  inboxes(options = {}) {
+    return this.request(
+      _ShadowBridge.inboxesRequestType,
+      _ShadowBridge.inboxesResponseType,
+      {},
+      options.timeoutMs ?? 15e3
+    );
+  }
+  enqueueInboxTask(input, options = {}) {
+    return this.request(
+      _ShadowBridge.enqueueInboxTaskRequestType,
+      _ShadowBridge.enqueueInboxTaskResponseType,
+      input,
+      options.timeoutMs
+    );
+  }
+  openBuddyCreator(input = {}, options = {}) {
+    return this.request(
+      _ShadowBridge.openBuddyCreatorRequestType,
+      _ShadowBridge.openBuddyCreatorResponseType,
+      input,
+      options.timeoutMs ?? 10 * 60 * 1e3
+    );
+  }
+  unwrapCommandPayload(payload) {
+    return unwrapShadowServerAppCommandPayload(payload);
+  }
+  inboxDeliveries(payload) {
+    return getShadowServerAppInboxDeliveries(payload);
+  }
+  inboxErrors(payload) {
+    return getShadowServerAppInboxErrors(payload);
+  }
+  channelMessageDeliveries(payload) {
+    return getShadowServerAppChannelMessageDeliveries(payload);
+  }
+  channelMessageErrors(payload) {
+    return getShadowServerAppChannelMessageErrors(payload);
+  }
+  request(requestType, responseType, payload, timeoutMs = this.timeoutMs) {
+    if (!this.isAvailable()) {
+      return Promise.reject(
+        new Error("ShadowBridge is not available outside a Shadow launch frame")
+      );
+    }
+    const requestId = `req_${Math.random().toString(36).slice(2)}`;
+    this.postMessage({
+      type: requestType,
+      requestId,
+      appKey: this.appKey,
+      ...payload
+    });
+    return new Promise((resolve, reject) => {
+      this.pending.set(requestId, {
+        responseType,
+        resolve,
+        reject
+      });
+      this.win?.setTimeout(() => {
+        if (!this.pending.has(requestId)) return;
+        this.pending.delete(requestId);
+        reject(new Error("Bridge request timed out"));
+      }, timeoutMs);
+    });
+  }
+  postMessage(message) {
+    if (!this.win) return;
+    if (this.win.ReactNativeWebView) {
+      this.win.ReactNativeWebView.postMessage(JSON.stringify(message));
+      return;
+    }
+    this.win.parent.postMessage(message, this.targetOrigin);
+  }
+  resolveLaunchContext() {
+    if (!this.win) return false;
+    const storageKey = `shadow.bridge.launch:${this.appKey}`;
+    const memoryContexts = this.win.__shadowBridgeLaunchContexts ??= {};
+    const hasLaunchToken = new URLSearchParams(this.win.location.search).has("shadow_launch");
+    if (hasLaunchToken) {
+      memoryContexts[this.appKey] = true;
+      try {
+        this.win.sessionStorage?.setItem(storageKey, "1");
+      } catch {
+      }
+      return true;
+    }
+    if (memoryContexts[this.appKey]) return true;
+    try {
+      return this.win.sessionStorage?.getItem(storageKey) === "1";
+    } catch {
+      return false;
+    }
+  }
+};
+
 // src/client.ts
 function sanitizeErrorBody(body) {
   if (!body) return "(empty response)";
@@ -71,6 +773,9 @@ var ShadowClient = class {
     this.baseUrl = baseUrl.replace(/\/api\/?$/, "");
   }
   baseUrl;
+  serverAppEventStreamUrl(eventStreamPath) {
+    return new URL(eventStreamPath, `${this.baseUrl}/`).toString();
+  }
   isShadowPrivateMediaUrl(value) {
     if (value.startsWith("/shadow/uploads/") || value.startsWith("/api/media/signed/")) {
       return true;
@@ -161,6 +866,18 @@ var ShadowClient = class {
       body: JSON.stringify(data)
     });
   }
+  async startPasswordReset(data) {
+    return this.request("/api/auth/password-reset/start", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async completePasswordReset(data) {
+    return this.request("/api/auth/password-reset/complete", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
   async refreshToken(refreshToken) {
     return this.request("/api/auth/refresh", {
       method: "POST",
@@ -246,6 +963,27 @@ var ShadowClient = class {
   async generateAgentToken(agentId) {
     return this.request(`/api/agents/${agentId}/token`, { method: "POST" });
   }
+  async listConnectorComputers() {
+    return this.request("/api/connector/computers");
+  }
+  async createConnectorBootstrap(data) {
+    return this.request("/api/connector/computers/bootstrap", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async createAgentOnConnectorComputer(computerId, data) {
+    return this.request(`/api/connector/computers/${computerId}/buddies`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async configureAgentOnConnectorComputer(computerId, agentId, data) {
+    return this.request(`/api/connector/computers/${computerId}/buddies/${agentId}/configure`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
   async startAgent(agentId) {
     return this.request(`/api/agents/${agentId}/start`, { method: "POST" });
   }
@@ -291,6 +1029,7 @@ var ShadowClient = class {
     const policy = {
       serverId,
       ...data.channelId !== void 0 ? { channelId: data.channelId } : {},
+      ...data.listen !== void 0 ? { listen: data.listen } : {},
       ...data.mentionOnly !== void 0 ? { mentionOnly: data.mentionOnly } : {},
       ...data.reply !== void 0 ? { reply: data.reply } : {},
       ...data.config !== void 0 ? { config: data.config } : {}
@@ -447,6 +1186,7 @@ var ShadowClient = class {
     const form = new FormData();
     form.set("input", JSON.stringify(data.input ?? {}));
     if (data.channelId) form.set("channelId", data.channelId);
+    if (data.task) form.set("task", JSON.stringify(data.task));
     form.set(data.field ?? "file", data.file, data.filename);
     return this.request(
       `/api/servers/${serverIdOrSlug}/apps/${encodeURIComponent(appKey)}/commands/${encodeURIComponent(
@@ -669,6 +1409,83 @@ var ShadowClient = class {
   async getMessage(messageId) {
     return this.request(`/api/messages/${messageId}`);
   }
+  async listBuddyInboxes() {
+    return this.request("/api/buddy-inboxes");
+  }
+  async listServerBuddyInboxes(serverIdOrSlug) {
+    return this.request(`/api/servers/${serverIdOrSlug}/inboxes`);
+  }
+  async ensureBuddyInbox(serverIdOrSlug, agentId) {
+    return this.request(`/api/servers/${serverIdOrSlug}/inboxes/${agentId}`, {
+      method: "POST"
+    });
+  }
+  async getBuddyInboxAdmissionPolicy(serverIdOrSlug, agentId) {
+    return this.request(`/api/servers/${serverIdOrSlug}/inboxes/${agentId}/admission-policy`);
+  }
+  async updateBuddyInboxAdmissionPolicy(serverIdOrSlug, agentId, policy) {
+    return this.request(`/api/servers/${serverIdOrSlug}/inboxes/${agentId}/admission-policy`, {
+      method: "PUT",
+      body: JSON.stringify(policy)
+    });
+  }
+  async listBuddyInboxAdmissionPending(serverIdOrSlug, agentId) {
+    return this.request(`/api/servers/${serverIdOrSlug}/inboxes/${agentId}/admission-pending`);
+  }
+  async approveBuddyInboxAdmissionPending(serverIdOrSlug, agentId, pendingId) {
+    return this.request(
+      `/api/servers/${serverIdOrSlug}/inboxes/${agentId}/admission-pending/${pendingId}/approve`,
+      { method: "POST" }
+    );
+  }
+  async rejectBuddyInboxAdmissionPending(serverIdOrSlug, agentId, pendingId) {
+    return this.request(
+      `/api/servers/${serverIdOrSlug}/inboxes/${agentId}/admission-pending/${pendingId}/reject`,
+      { method: "POST" }
+    );
+  }
+  async enqueueInboxTaskForAgent(serverIdOrSlug, agentId, task) {
+    return this.request(`/api/servers/${serverIdOrSlug}/inboxes/${agentId}/tasks`, {
+      method: "POST",
+      body: JSON.stringify(task)
+    });
+  }
+  async enqueueInboxTask(channelId, task) {
+    return this.request(`/api/channels/${channelId}/inbox/tasks`, {
+      method: "POST",
+      body: JSON.stringify(task)
+    });
+  }
+  async claimTaskCard(messageId, cardId, data = {}) {
+    return this.request(`/api/messages/${messageId}/cards/${cardId}/claim`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateTaskCard(messageId, cardId, data) {
+    return this.request(`/api/messages/${messageId}/cards/${cardId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async retryTaskCard(messageId, cardId, data = {}) {
+    return this.request(`/api/messages/${messageId}/cards/${cardId}/retry`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async claimNextInboxTask(serverIdOrSlug, agentId, data = {}) {
+    return this.request(`/api/servers/${serverIdOrSlug}/inboxes/${agentId}/claim-next`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async promoteMessageToInboxTask(messageId, data) {
+    return this.request(`/api/messages/${messageId}/inbox/tasks`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
   async submitInteractiveAction(messageId, input) {
     return this.request(`/api/messages/${messageId}/interactive`, {
       method: "POST",
@@ -820,6 +1637,19 @@ var ShadowClient = class {
       formData.append("messageId", messageId);
     } else if (messageId) {
       if (messageId.messageId) formData.append("messageId", messageId.messageId);
+      if (messageId.kind) formData.append("kind", messageId.kind);
+      if (typeof messageId.durationMs === "number") {
+        formData.append("durationMs", String(messageId.durationMs));
+      }
+      if (messageId.waveformPeaks) {
+        formData.append("waveformPeaks", JSON.stringify(messageId.waveformPeaks));
+      }
+      if (messageId.transcriptText) formData.append("transcriptText", messageId.transcriptText);
+      if (messageId.transcriptLanguage) {
+        formData.append("transcriptLanguage", messageId.transcriptLanguage);
+      }
+      if (messageId.transcriptSource)
+        formData.append("transcriptSource", messageId.transcriptSource);
     }
     const url = `${this.baseUrl}/api/media/upload`;
     const res = await fetch(url, {
@@ -835,6 +1665,43 @@ var ShadowClient = class {
     }
     return res.json();
   }
+  async sendVoiceMessage(channelId, file, filename, contentType, opts) {
+    const message = await this.sendMessage(channelId, "\u200B", {
+      threadId: opts.threadId,
+      replyToId: opts.replyToId
+    });
+    await this.uploadMedia(file, filename, contentType, {
+      messageId: message.id,
+      kind: "voice",
+      durationMs: opts.durationMs,
+      waveformPeaks: opts.waveformPeaks,
+      transcriptText: opts.transcriptText,
+      transcriptLanguage: opts.transcriptLanguage,
+      transcriptSource: opts.transcriptSource
+    });
+    return this.getMessage(message.id);
+  }
+  async markVoicePlayed(attachmentId, input) {
+    return this.request(`/api/attachments/${attachmentId}/voice-playback`, {
+      method: "PUT",
+      body: JSON.stringify(input ?? {})
+    });
+  }
+  async requestVoiceTranscript(attachmentId, input) {
+    return this.request(`/api/attachments/${attachmentId}/transcript`, {
+      method: "POST",
+      body: JSON.stringify({
+        mode: "server",
+        ...input?.language ? { language: input.language } : {}
+      })
+    });
+  }
+  async updateVoiceTranscript(attachmentId, input) {
+    return this.request(`/api/attachments/${attachmentId}/transcript`, {
+      method: "PUT",
+      body: JSON.stringify(input)
+    });
+  }
   async resolveAttachmentMediaUrl(attachmentId, options) {
     const params = new URLSearchParams();
     params.set("disposition", options?.disposition ?? "inline");
@@ -1090,9 +1957,14 @@ var ShadowClient = class {
     return this.request(`/api/auth/sessions/${sessionId}`, { method: "DELETE" });
   }
   async changePassword(data) {
+    const oldPassword = data.oldPassword ?? data.currentPassword;
     return this.request("/api/auth/password", {
       method: "PUT",
-      body: JSON.stringify(data)
+      body: JSON.stringify({
+        oldPassword,
+        newPassword: data.newPassword,
+        confirmPassword: data.confirmPassword ?? data.newPassword
+      })
     });
   }
   async getDashboard() {
@@ -1101,7 +1973,13 @@ var ShadowClient = class {
   async loginWithGoogleIdToken(idToken) {
     return this.request("/api/auth/google/id-token", {
       method: "POST",
-      body: JSON.stringify({ idToken })
+      body: JSON.stringify({ credential: idToken })
+    });
+  }
+  async loginWithAppleIdentityToken(data) {
+    return this.request("/api/auth/oauth/apple/mobile", {
+      method: "POST",
+      body: JSON.stringify(data)
     });
   }
   // ── Friendships ───────────────────────────────────────────────────────
@@ -1850,6 +2728,24 @@ var ShadowClient = class {
     const suffix = qs.toString();
     return this.request(`/api/discover/business${suffix ? `?${suffix}` : ""}`);
   }
+  async discoverMarketplaceProducts(params) {
+    const qs = new URLSearchParams();
+    if (params?.q) qs.set("q", params.q);
+    if (params?.tag) qs.set("tag", params.tag);
+    if (params?.category) qs.set("category", params.category);
+    if (params?.scope) qs.set("scope", params.scope);
+    if (params?.limit) qs.set("limit", String(params.limit));
+    if (params?.offset) qs.set("offset", String(params.offset));
+    const suffix = qs.toString();
+    return this.request(`/api/discover/marketplace/products${suffix ? `?${suffix}` : ""}`);
+  }
+  async discoverMarketplaceCategories(params) {
+    const qs = new URLSearchParams();
+    if (params?.q) qs.set("q", params.q);
+    if (params?.limit) qs.set("limit", String(params.limit));
+    const suffix = qs.toString();
+    return this.request(`/api/discover/marketplace/categories${suffix ? `?${suffix}` : ""}`);
+  }
   async discoverBusinessHub(params) {
     return this.discoverCommerce(params);
   }
@@ -2317,10 +3213,35 @@ var ShadowVoiceConsumer = class {
 0 && (module.exports = {
   CLIENT_EVENTS,
   SERVER_EVENTS,
+  SHADOW_SERVER_APP_COMMAND_COMPLETED_EVENT,
+  SHADOW_SERVER_APP_COMMAND_EVENTS,
+  SHADOW_SERVER_APP_COMMAND_FAILED_EVENT,
+  SHADOW_SERVER_APP_PROTOCOL,
+  ShadowBridge,
   ShadowClient,
+  ShadowServerAppCommandError,
+  ShadowServerAppOutbox,
+  ShadowServerAppRuntime,
   ShadowSocket,
   ShadowVoiceConsumer,
+  buildShadowServerAppInboxDelivery,
+  buildShadowServerAppInboxTaskRequest,
   channelRoom,
+  createShadowServerAppManifest,
+  defineShadowServerApp,
+  extractShadowServerAppBearerToken,
+  getShadowServerAppChannelMessageDeliveries,
+  getShadowServerAppChannelMessageErrors,
+  getShadowServerAppTaskCardId,
+  introspectShadowServerAppToken,
+  normalizeShadowServerAppCommandInput,
+  parseShadowServerAppCommandRequest,
+  shadowServerAppActorAvatarUrl,
+  shadowServerAppActorDisplayName,
+  shadowServerAppActorRef,
+  shadowServerAppError,
+  shadowServerAppInboxTaskEndpoint,
   threadRoom,
-  userRoom
+  userRoom,
+  validateShadowServerAppJsonSchema
 });