apps 0.0.1-beta.5 → 0.0.1-beta.54

package/js/{chunk-KUMBKVJD.js → chunk-KLYSEHUD.js}

@@ -1,9 +1,9 @@
 import {
   appSignInCallbackPath
-} from "./chunk-VFZKSM3T.js";
+} from "./chunk-JPEUKEV4.js";
 import {
   HttpServerResponse_exports
-} from "./chunk-UK573G7W.js";
+} from "./chunk-EOPQ727L.js";
 
 // src/implementation/ui-auth.ts
 var appPrivateHeaders = {

package/js/chunk-LTDHQJ2Z.js

@@ -0,0 +1,171 @@
+import {
+  ProviderError,
+  maxUpstreamMessageLength
+} from "./chunk-MWKHKOTL.js";
+import {
+  owned
+} from "./chunk-JM7LOD2W.js";
+import {
+  AccountId
+} from "./chunk-H2CJWXA3.js";
+import {
+  Effect_exports,
+  Option_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/implementation/authoring.ts
+var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
+var appCode = (code) => owned("app", "app.code", { attributes: { "executor.app.code": code } });
+var fromPromise = (callback, code) => (...args) => {
+  if (NativeCallback in callback) {
+    const native = callback[NativeCallback];
+    return native(...args);
+  }
+  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error }).pipe(
+    appCode(code)
+  );
+};
+var method = (target, key) => {
+  const value = target[key];
+  const call = (...args) => Reflect.apply(value, target, args);
+  if (NativeCallback in value) Object.assign(call, { [NativeCallback]: value[NativeCallback] });
+  return call;
+};
+var toPromise = (operation, signalOf, services) => {
+  const native = (...args) => Effect_exports.suspend(() => {
+    const signal = typeof signalOf === "function" ? signalOf(...args) : signalOf;
+    if (signal === void 0) return operation(...args);
+    if (signal.aborted) return Effect_exports.interrupt;
+    const cancelled = Effect_exports.callback((resume) => {
+      if (signal.aborted) {
+        resume(Effect_exports.interrupt);
+        return;
+      }
+      const abort = () => resume(Effect_exports.interrupt);
+      signal.addEventListener("abort", abort, { once: true });
+      return Effect_exports.sync(() => signal.removeEventListener("abort", abort));
+    });
+    return Effect_exports.raceFirst(
+      cancelled,
+      Effect_exports.suspend(() => operation(...args))
+    );
+  });
+  return Object.assign(
+    (...args) => services === void 0 ? Effect_exports.runPromise(native(...args)) : Effect_exports.runPromiseWith(services)(native(...args)),
+    {
+      [NativeCallback]: native
+    }
+  );
+};
+
+// src/implementation/upstream-error.ts
+var ErrorToken = Schema_exports.String.check(Schema_exports.isPattern(/^[A-Za-z0-9._-]{1,128}$/u));
+var JsonRpcError = Schema_exports.Struct({
+  error: Schema_exports.Struct({ code: Schema_exports.Int, message: Schema_exports.String })
+});
+var OAuthError = Schema_exports.Struct({
+  error: ErrorToken,
+  error_description: Schema_exports.optional(Schema_exports.String)
+});
+var bounded = (message) => message.length <= maxUpstreamMessageLength ? message : `${message.slice(0, maxUpstreamMessageLength - 1)}\u2026`;
+var isShortenedUpstream = (message) => message.length === maxUpstreamMessageLength && message.endsWith("\u2026");
+var stated = (code, message) => ({
+  code,
+  ...message === void 0 || message === "" ? {} : { message: bounded(message) }
+});
+var bodyUpstreamError = (json) => {
+  const rpc = Schema_exports.decodeUnknownOption(JsonRpcError)(json);
+  if (Option_exports.isSome(rpc)) return stated(rpc.value.error.code, rpc.value.error.message);
+  const oauth = Schema_exports.decodeUnknownOption(OAuthError)(json);
+  if (Option_exports.isSome(oauth)) return stated(oauth.value.error, oauth.value.error_description);
+  return void 0;
+};
+var authParam = /([A-Za-z][A-Za-z0-9_-]*)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^\s,"]+))/g;
+var challengeUpstreamError = (header) => {
+  const bearer = header === void 0 ? -1 : header.search(/\bBearer\b/i);
+  if (header === void 0 || bearer === -1) return void 0;
+  const params = /* @__PURE__ */ new Map();
+  for (const [, name, quoted, token] of header.slice(bearer + "Bearer".length).matchAll(authParam))
+    if (name !== void 0 && !params.has(name.toLowerCase()))
+      params.set(name.toLowerCase(), quoted?.replace(/\\(.)/g, "$1") ?? token ?? "");
+  const code = Schema_exports.decodeUnknownOption(ErrorToken)(params.get("error"));
+  return Option_exports.isNone(code) ? void 0 : stated(code.value, params.get("error_description"));
+};
+
+// src/implementation/provider-error.ts
+var providerError = ({
+  reason,
+  status,
+  accountId,
+  phase,
+  upstream
+}) => new ProviderError({
+  reason,
+  ...status === void 0 ? {} : { status },
+  ...accountId === void 0 ? {} : { accountId },
+  ...phase === void 0 ? {} : { phase },
+  ...upstream === void 0 ? {} : { upstream }
+});
+function parseProviderError(error) {
+  return Schema_exports.decodeUnknownOption(ProviderError)(error).pipe(Option_exports.map(providerError));
+}
+function providerErrorDetail(error, detail) {
+  return providerError({
+    ...error,
+    phase: error.phase ?? detail.phase,
+    upstream: error.upstream ?? detail.upstream
+  });
+}
+function httpProviderError(status, headers = {}) {
+  const upstream = challengeUpstreamError(headers["www-authenticate"]);
+  if (status >= 500 && status <= 599)
+    return providerError({ reason: "unavailable", status, upstream });
+  if (status === 401) return providerError({ reason: "unauthorized", status, upstream });
+  if (status === 429) return providerError({ reason: "rate_limited", status, upstream });
+  if (status !== 403) return void 0;
+  const retry = headers["retry-after"];
+  if (headers["x-ratelimit-remaining"] === "0" || retry !== void 0 && (/^\d+$/.test(retry) || Number.isFinite(Date.parse(retry))))
+    return providerError({ reason: "rate_limited", status, upstream });
+  if (typeof upstream?.code === "string" && upstream.code.toLowerCase() === "insufficient_scope")
+    return providerError({ reason: "forbidden", status, upstream });
+  return providerError({ reason: "rejected", status, upstream });
+}
+function accountProviderError(error, accountId) {
+  const parsed = parseProviderError(error);
+  const account = Schema_exports.decodeUnknownOption(AccountId)(accountId);
+  if (Option_exports.isNone(parsed) || Option_exports.isNone(account)) return error;
+  return providerError({ ...parsed.value, accountId: account.value });
+}
+function graphqlProviderError(errors, status) {
+  const codes = errors.flatMap((error) => {
+    const parsed = Schema_exports.decodeUnknownOption(
+      Schema_exports.Struct({
+        type: Schema_exports.optional(Schema_exports.String),
+        extensions: Schema_exports.optional(Schema_exports.Struct({ code: Schema_exports.optional(Schema_exports.String) }))
+      })
+    )(error);
+    return Option_exports.isSome(parsed) ? [parsed.value.type, parsed.value.extensions?.code] : [];
+  });
+  if (codes.includes("RATE_LIMITED") || codes.includes("TOO_MANY_REQUESTS"))
+    return new ProviderError({ reason: "rate_limited", status });
+  if (codes.includes("UNAUTHENTICATED"))
+    return new ProviderError({ reason: "unauthorized", status });
+  if (codes.includes("FORBIDDEN")) return new ProviderError({ reason: "forbidden", status });
+  return void 0;
+}
+
+export {
+  appCode,
+  fromPromise,
+  method,
+  toPromise,
+  isShortenedUpstream,
+  bodyUpstreamError,
+  providerError,
+  parseProviderError,
+  providerErrorDetail,
+  httpProviderError,
+  accountProviderError,
+  graphqlProviderError
+};

package/js/chunk-MWKHKOTL.js

@@ -0,0 +1,240 @@
+import {
+  AccountId
+} from "./chunk-H2CJWXA3.js";
+import {
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/failure.ts
+var maxFailureMessageLength = 2048;
+var FailureSource = Schema_exports.Literals(["app", "storage", "service"]);
+var FailureName = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureCode = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureMessage = Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureMessageLength));
+var maxFailureFields = 8;
+var maxFailureFieldLength = 256;
+var FailureFieldName = Schema_exports.String.check(
+  Schema_exports.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/)
+);
+var FailureFieldValue = Schema_exports.Union([
+  Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureFieldLength)),
+  Schema_exports.Finite,
+  Schema_exports.Boolean
+]);
+var FailureFields = Schema_exports.Record(FailureFieldName, FailureFieldValue).check(
+  Schema_exports.isMaxProperties(maxFailureFields)
+);
+var FailureDetail = {
+  source: Schema_exports.optionalKey(FailureSource),
+  errorName: Schema_exports.optionalKey(FailureName),
+  code: Schema_exports.optionalKey(FailureCode),
+  message: Schema_exports.optionalKey(FailureMessage),
+  fields: Schema_exports.optionalKey(FailureFields)
+};
+var maxUpstreamMessageLength = 1024;
+var UpstreamError = Schema_exports.Struct({
+  code: Schema_exports.Union([
+    Schema_exports.Int,
+    Schema_exports.String.check(Schema_exports.isMinLength(1), Schema_exports.isMaxLength(128))
+  ]),
+  message: Schema_exports.optionalKey(Schema_exports.String.check(Schema_exports.isMaxLength(maxUpstreamMessageLength)))
+});
+var FailurePhase = Schema_exports.Literals(["connect", "discover", "call"]);
+
+// src/contracts/provider-error.ts
+var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
+  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  accountId: Schema_exports.optional(AccountId),
+  phase: Schema_exports.optional(FailurePhase),
+  upstream: Schema_exports.optional(UpstreamError)
+}) {
+};
+
+// src/contracts/network.ts
+var NetworkRefusal = Schema_exports.Union([
+  Schema_exports.Struct({ reason: Schema_exports.Literal("private_address") }),
+  Schema_exports.Struct({
+    reason: Schema_exports.Literal("credential_host"),
+    /** The provider of the credential handle the request carried. */
+    provider: Schema_exports.String,
+    /** The hosts that provider's credentials may reach; empty when it declares none. */
+    allowedHosts: Schema_exports.Array(Schema_exports.String)
+  }),
+  Schema_exports.Struct({ reason: Schema_exports.Literal("credential_app") }),
+  Schema_exports.Struct({
+    reason: Schema_exports.Literal("credential_expired"),
+    /** The provider of the expired credential handle. */
+    provider: Schema_exports.String
+  })
+]);
+var NetworkRefused = class extends Schema_exports.TaggedError()("NetworkRefused", {
+  /** The refused destination, with its port when the URL names one. */
+  host: Schema_exports.String,
+  refusal: NetworkRefusal
+}) {
+  get message() {
+    const refusal = this.refusal;
+    switch (refusal.reason) {
+      case "private_address":
+        return `Executor refused a request to ${this.host}: apps on this instance can reach only public addresses, and ${this.host} is a private, loopback or internal address. The request was not sent.`;
+      case "credential_host":
+        return refusal.allowedHosts.length === 0 ? `Executor refused this request: ${refusal.provider} credentials cannot be sent to ${this.host}: the provider declares no hosts.` : `Executor refused this request: ${refusal.provider} credentials cannot be sent to ${this.host}. The provider allows: ${refusal.allowedHosts.join(", ")}.`;
+      case "credential_app":
+        return "Executor refused this request: it carries a credential handle that is not valid for this app. Use the account fields this invocation received.";
+      case "credential_expired":
+        return `Executor refused this request: it carries an expired ${refusal.provider} credential handle. Use the account fields this invocation received.`;
+    }
+  }
+};
+var networkRefusalStatus = 421;
+var networkRefusalHeader = "x-executor-refused";
+var NetworkRefusedHeader = Schema_exports.StringFromUriComponent.pipe(
+  Schema_exports.decodeTo(Schema_exports.fromJsonString(NetworkRefused))
+);
+var encodeRefusal = Schema_exports.encodeSync(NetworkRefused);
+var encodeRefusalHeader = Schema_exports.encodeSync(NetworkRefusedHeader);
+var networkRefusalResponse = (refused) => new Response(JSON.stringify({ ...encodeRefusal(refused), message: refused.message }), {
+  status: networkRefusalStatus,
+  statusText: "Refused by Executor",
+  headers: {
+    "content-type": "application/json; charset=utf-8",
+    [networkRefusalHeader]: encodeRefusalHeader(refused)
+  }
+});
+var RestrictedFetchOption = Schema_exports.Literals(["redirect", "cache", "integrity"]);
+var supportedFetchOptions = {
+  redirect: ["follow", "manual"],
+  cache: ["no-store", "no-cache"],
+  integrity: [""]
+};
+var FetchOptionUnsupported = class extends Schema_exports.TaggedError()(
+  "FetchOptionUnsupported",
+  {
+    option: RestrictedFetchOption,
+    value: Schema_exports.String,
+    supported: Schema_exports.Array(Schema_exports.String)
+  }
+) {
+  get message() {
+    const supported = this.supported.map((value) => JSON.stringify(value)).join(" or ");
+    return `fetch option ${this.option}: ${JSON.stringify(this.value)} is not supported by Executor's app runtime. Use ${supported}, or omit ${this.option}.${this.advice}`;
+  }
+  /** What to do instead, when the standard value has an equivalent the runtime supports. */
+  get advice() {
+    switch (this.option) {
+      case "redirect":
+        return this.value === "error" ? ` To reject redirects, send redirect: "manual" and treat a 3xx response as the error.` : "";
+      case "cache":
+        return "";
+      case "integrity":
+        return " To check a digest, read the body and hash it with crypto.subtle.digest.";
+    }
+  }
+};
+
+// ../app-cache/src/contracts/cache.ts
+var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
+  reason: Schema_exports.Literals(["unavailable", "storage", "invalid", "capacity", "timeout"])
+}) {
+};
+var cacheLimits = {
+  keyBytes: 8192,
+  entryBytes: 2e6,
+  batchBytes: 8e6,
+  batchEntries: 128,
+  totalBytes: 128e6,
+  totalEntries: 1e5,
+  retentionMs: 7 * 24 * 60 * 60 * 1e3,
+  loadTimeoutMs: 9e4,
+  /**
+   * A loader's lease lapses this long after its host last renewed it. Hosts renew every
+   * `renewMs` while the invocation that claimed it runs, so a stalled or lost holder frees the
+   * key well inside an MCP execute budget.
+   */
+  leaseMs: 15e3,
+  renewMs: 5e3,
+  /** The longest a caller waits on another loader before loading for itself without publishing. */
+  waitMs: 1e4,
+  /** Bound for one command to a host store; a lost reply fails instead of holding its caller. */
+  commandTimeoutMs: 1e4
+};
+var Key = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/));
+var Time = Schema_exports.Finite.check(Schema_exports.isGreaterThanOrEqualTo(0));
+var CacheEntry = Schema_exports.Struct({
+  value: Schema_exports.Json,
+  version: Schema_exports.String,
+  freshUntil: Time,
+  staleUntil: Time
+});
+var CacheAcquired = Schema_exports.Struct({
+  entry: Schema_exports.NullOr(CacheEntry),
+  lease: Schema_exports.NullOr(Schema_exports.String)
+});
+var CacheCommand = Schema_exports.Union([
+  Schema_exports.Struct({ operation: Schema_exports.Literal("read"), keys: Schema_exports.Array(Key) }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("acquire"),
+    key: Key,
+    /** Claim even a fresh entry, as an explicit refresh does. */
+    refresh: Schema_exports.Boolean,
+    /** Claim only while the entry still has this version. Absent accepts the current one. */
+    version: Schema_exports.optionalKey(Schema_exports.NullOr(Schema_exports.String))
+  }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("claim"),
+    key: Key,
+    version: Schema_exports.NullOr(Schema_exports.String)
+  }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("publish"),
+    key: Key,
+    lease: Schema_exports.String,
+    entry: CacheEntry
+  }),
+  Schema_exports.Struct({ operation: Schema_exports.Literal("release"), key: Key, lease: Schema_exports.String }),
+  /** Extend a lease its holder still owns. Replies false once the lease lapsed or was replaced. */
+  Schema_exports.Struct({ operation: Schema_exports.Literal("renew"), key: Key, lease: Schema_exports.String }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("write"),
+    entries: Schema_exports.Array(Schema_exports.Struct({ key: Key, entry: CacheEntry }))
+  }),
+  Schema_exports.Struct({ operation: Schema_exports.Literal("invalidate"), key: Key })
+]);
+var CacheReply = Schema_exports.Union([
+  Schema_exports.Struct({ ok: Schema_exports.Literal(true), value: Schema_exports.Json }),
+  Schema_exports.Struct({ ok: Schema_exports.Literal(false), error: CacheError })
+]);
+
+export {
+  maxFailureMessageLength,
+  FailureSource,
+  FailureName,
+  FailureCode,
+  FailureMessage,
+  maxFailureFields,
+  maxFailureFieldLength,
+  FailureFieldName,
+  FailureFieldValue,
+  FailureFields,
+  FailureDetail,
+  maxUpstreamMessageLength,
+  UpstreamError,
+  FailurePhase,
+  ProviderError,
+  NetworkRefusal,
+  NetworkRefused,
+  networkRefusalStatus,
+  networkRefusalHeader,
+  NetworkRefusedHeader,
+  networkRefusalResponse,
+  RestrictedFetchOption,
+  supportedFetchOptions,
+  FetchOptionUnsupported,
+  CacheError,
+  cacheLimits,
+  CacheEntry,
+  CacheAcquired,
+  CacheCommand,
+  CacheReply
+};