@agentdocumentformat/cli 0.7.8 → 0.8.0

package/dist/chunks/{chunk-VN7UH7I5.mjs → chunk-6XQZGYMK.mjs}

@@ -7,15 +7,25 @@ const __dirname = __adfDirname(__filename);
 import {
   DaemonError,
   MAIN_LOOP
-} from "./chunk-XNPZBLYL.mjs";
+} from "./chunk-75DC5EWN.mjs";
 import {
   cjs
 } from "./chunk-SGUTYISF.mjs";
 import {
   daemon_url_exports
-} from "./chunk-GKKCMXIZ.mjs";
+} from "./chunk-V2T6NZX2.mjs";
+import {
+  __export
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/shared/daemon-client/client.ts
+var client_exports = {};
+__export(client_exports, {
+  DaemonClient: () => DaemonClient,
+  staticCredentials: () => staticCredentials
+});
 
-// src/main/tui/api/sse.ts
+// src/shared/daemon-client/sse.ts
 var EventStream = class {
   options;
   fetchImpl;
@@ -31,6 +41,8 @@ var EventStream = class {
   resumePending = !1;
   seen = /* @__PURE__ */ new Set();
   seenOrder = [];
+  /** Remembered keys that a daemon restart invalidates (DedupeKey.cursorScoped). */
+  cursorScoped = /* @__PURE__ */ new Set();
   idleTimer = null;
   retryTimer = null;
   info = { state: "idle", attempt: 0 };
@@ -67,10 +79,12 @@ var EventStream = class {
     }
   }
   buildUrl() {
-    let params = new URLSearchParams();
-    this.options.agentId && params.set("agentId", this.options.agentId), this.lastCursor >= 0 ? (params.set("since", String(this.lastCursor)), this.epoch && params.set("epoch", this.epoch)) : this.options.replay || params.set("since", String(Number.MAX_SAFE_INTEGER));
+    let params = new URLSearchParams(), query = typeof this.options.query == "function" ? this.options.query() : this.options.query;
+    for (let [key, value] of Object.entries(query ?? {}))
+      value == null || value === "" || params.set(key, String(value));
+    this.options.agentId && params.set("agentId", this.options.agentId), this.lastCursor >= 0 ? (params.set("since", String(this.lastCursor)), this.epoch ? params.set("epoch", this.epoch) : params.delete("epoch")) : (this.options.replay ? params.delete("since") : params.set("since", String(Number.MAX_SAFE_INTEGER)), params.delete("epoch"));
     let qs = params.toString();
-    return `${this.options.baseUrl}/events${qs ? `?${qs}` : ""}`;
+    return `${this.options.baseUrl}${this.options.path ?? "/events"}${qs ? `?${qs}` : ""}`;
   }
   async connect() {
     if (this.closed) return;
@@ -81,12 +95,17 @@ var EventStream = class {
     this.controller = controller;
     let failure;
     try {
-      let response = await this.fetchImpl(this.buildUrl(), {
-        headers: { Accept: "text/event-stream", ...typeof this.options.headers == "function" ? this.options.headers() : this.options.headers ?? {} },
-        signal: controller.signal
+      let url = this.buildUrl();
+      if (await this.options.beforeConnect?.(url), this.closed) return;
+      let response = await this.fetchImpl(url, {
+        headers: { Accept: "text/event-stream", ...typeof this.options.headers == "function" ? this.options.headers(url) : this.options.headers ?? {} },
+        signal: controller.signal,
+        // A redirect would carry the headers (token) to wherever it points.
+        redirect: "manual"
       });
       if (!response.ok || !response.body)
-        throw new Error(`HTTP ${response.status} ${response.statusText}`.trim());
+        throw response.body?.cancel().catch(() => {
+        }), isRedirect(response) ? new Error(redirectMessage(this.options.baseUrl, response)) : new Error(`HTTP ${response.status} ${response.statusText}`.trim());
       this.attempt = 0, this.resumePending = resumed, this.hasOpened = !0, this.setState({ state: "open", attempt: 0, resumed }), this.armIdle(), await this.read(response.body, controller), failure = "stream ended";
     } catch (err) {
       failure = controller.signal.aborted && this.closed ? void 0 : errorMessage(err);
@@ -94,6 +113,10 @@ var EventStream = class {
       this.clearIdle();
     }
     if (this.closed) return;
+    try {
+      this.options.onDrop?.();
+    } catch {
+    }
     this.attempt += 1;
     let delay = this.backoff();
     this.setState({ state: "reconnecting", attempt: this.attempt, error: failure, retryInMs: delay }), this.retryTimer = setTimeout(() => {
@@ -153,18 +176,19 @@ var EventStream = class {
 `));
       return;
     }
-    let frame;
+    let parsed;
     try {
-      frame = JSON.parse(data.join(`
+      parsed = JSON.parse(data.join(`
 `));
     } catch {
       return;
     }
-    if (!frame || typeof frame != "object" || !frame.event) return;
+    if (!(this.options.isFrame ?? isEventFrame)(parsed)) return;
+    let frame = parsed;
     typeof frame.cursor == "number" && (frame.cursor < this.lastCursor && this.forgetCursorKeys(), this.lastCursor = frame.cursor);
-    let key = dedupeKey(frame);
+    let key = this.options.dedupeKey ? this.options.dedupeKey(frame) : defaultDedupeKey(frame);
     if (key) {
-      if (this.seen.has(key)) return;
+      if (this.seen.has(key.key)) return;
       this.remember(key);
     }
     try {
@@ -196,7 +220,14 @@ var EventStream = class {
       return;
     }
     let reason = data.reason === "epoch_changed" ? "epoch_changed" : "evicted";
-    reason === "epoch_changed" && (this.forgetCursorKeys(), this.lastCursor = -1), this.reportResume({ exact: !1, reason, epoch });
+    reason === "epoch_changed" && (this.forgetCursorKeys(), this.lastCursor = -1);
+    let gap = { reason, epoch };
+    (typeof data.requestedCursor == "number" || data.requestedCursor === null) && (gap.requestedCursor = data.requestedCursor), (typeof data.oldestCursor == "number" || data.oldestCursor === null) && (gap.oldestCursor = data.oldestCursor), typeof data.latestCursor == "number" && (gap.latestCursor = data.latestCursor), typeof data.dropped == "number" && (gap.dropped = data.dropped);
+    try {
+      this.options.onGap?.(gap);
+    } catch {
+    }
+    this.reportResume({ exact: !1, reason, epoch });
   }
   reportResume(info) {
     if (this.resumePending) {
@@ -207,24 +238,42 @@ var EventStream = class {
       }
     }
   }
-  remember(key) {
-    this.seen.add(key), this.seenOrder.push(key);
+  remember({ key, cursorScoped }) {
+    this.seen.add(key), this.seenOrder.push(key), cursorScoped && this.cursorScoped.add(key);
     let cap = this.options.dedupeWindow ?? 5e3;
     for (; this.seenOrder.length > cap; ) {
       let old = this.seenOrder.shift();
-      old && this.seen.delete(old);
+      old && (this.seen.delete(old), this.cursorScoped.delete(old));
     }
   }
+  /** The daemon restarted: keys built from its cursors no longer identify anything. */
   forgetCursorKeys() {
-    for (let i = this.seenOrder.length - 1; i >= 0; i--) {
-      let key = this.seenOrder[i];
-      key.startsWith("c:") && (this.seen.delete(key), this.seenOrder.splice(i, 1));
+    if (this.cursorScoped.size !== 0) {
+      for (let i = this.seenOrder.length - 1; i >= 0; i--) {
+        let key = this.seenOrder[i];
+        this.cursorScoped.has(key) && (this.seen.delete(key), this.seenOrder.splice(i, 1));
+      }
+      this.cursorScoped.clear();
     }
   }
 };
 function dedupeKey(frame) {
   let { event } = frame;
-  return event.agent_id && typeof event.seq == "number" && event.seq > 0 ? `a:${event.agent_id}:${event.seq}` : typeof frame.cursor == "number" ? `c:${frame.cursor}` : null;
+  return event?.agent_id && typeof event.seq == "number" && event.seq > 0 ? `a:${event.agent_id}:${event.seq}` : typeof frame.cursor == "number" ? `c:${frame.cursor}` : null;
+}
+function defaultDedupeKey(frame) {
+  let key = dedupeKey(frame);
+  return key ? { key, cursorScoped: key.startsWith("c:") } : null;
+}
+function isRedirect(response) {
+  return response.type === "opaqueredirect" || response.status >= 300 && response.status < 400 && response.status !== 304;
+}
+function redirectMessage(baseUrl, response) {
+  let location = response.headers.get("location");
+  return `Daemon at ${baseUrl} answered a redirect (HTTP ${response.status}${location ? ` to ${location}` : ""}); redirects are not followed, so the token stays with ${baseUrl}`;
+}
+function isEventFrame(value) {
+  return !!value && typeof value == "object" && !!value.event;
 }
 function errorMessage(err) {
   if (err instanceof Error) {
@@ -233,8 +282,16 @@ function errorMessage(err) {
   }
   return String(err);
 }
+function isClientFrame(value) {
+  if (!value || typeof value != "object") return !1;
+  let { kind, cursor } = value;
+  return (kind === "executor" || kind === "host" || kind === "push" || kind === "umbilical" || kind === "turn") && typeof cursor == "number";
+}
+function clientFrameDedupeKey(frame) {
+  return typeof frame.cursor == "number" ? { key: `s:${frame.cursor}`, cursorScoped: !0 } : null;
+}
 
-// src/main/tui/api/normalize.ts
+// src/shared/daemon-client/normalize.ts
 var obj = (v) => v && typeof v == "object" && !Array.isArray(v) ? v : {}, arr = (v) => Array.isArray(v) ? v : [], num = (v) => typeof v == "number" && Number.isFinite(v) ? v : 0;
 function normalizeRuntime(raw) {
   let r = obj(raw), daemon = obj(r.daemon), providers = obj(r.providers), network = obj(r.network), mesh = obj(network.mesh), websocket = obj(network.websocket);
@@ -252,83 +309,119 @@ function normalizeRuntime(raw) {
   };
 }
 
-// src/main/tui/api/client.ts
-var { localDaemonToken, localProofHeaders, resolveDaemonToken, resolveDaemonUrl } = cjs(daemon_url_exports), enc = encodeURIComponent;
-function sameOrigin(a, b) {
+// src/shared/daemon-client/client.ts
+function staticCredentials(token) {
+  return { token: () => token };
+}
+var enc = encodeURIComponent;
+function originOf(url) {
   try {
-    return new URL(a).origin === new URL(b).origin;
+    let origin = new URL(url).origin;
+    return origin === "null" ? null : origin;
   } catch {
-    return !1;
+    return null;
   }
 }
-var DaemonClient = class _DaemonClient {
+var DaemonClient = class {
   baseUrl;
-  token;
+  /** The one origin `credentials` are sent to. */
+  origin;
+  credentials;
   fetchImpl;
   timeoutMs;
   options;
-  constructor(options = {}) {
-    this.baseUrl = resolveDaemonUrl(options.baseUrl), this.token = resolveDaemonToken(options.token, options.env ?? process.env, options.localToken ? this.baseUrl : void 0), this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis), this.timeoutMs = options.timeoutMs ?? 15e3, this.options = options;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, ""), this.origin = originOf(this.baseUrl), this.credentials = options.credentials, this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis), this.timeoutMs = options.timeoutMs ?? 15e3, this.options = options;
   }
   /**
-   * Same transport (fetch, timeout) against another daemon. The current token
-   * is carried over only to the same origin; another origin gets `token`, or
-   * ADF_DAEMON_TOKEN, or none — never this daemon's bearer token.
+   * Same transport (fetch, timeout) against another daemon. The current
+   * credentials are carried over only to the same origin without a `token`;
+   * otherwise the client gets `credentialsFor(baseUrl, token)` (or just
+   * `token`), or none — never this daemon's.
    */
   withBaseUrl(baseUrl, token) {
-    let carried = sameOrigin(this.baseUrl, resolveDaemonUrl(baseUrl)) ? this.token : void 0;
-    return new _DaemonClient({ ...this.options, baseUrl, token: token ?? carried });
+    let next = baseUrl.replace(/\/+$/, ""), credentials = token ? this.options.credentialsFor?.(next, token) ?? staticCredentials(token) : this.origin !== null && originOf(next) === this.origin ? this.credentials : this.options.credentialsFor?.(next);
+    return this.derive({ ...this.options, baseUrl: next, credentials });
+  }
+  /** Same daemon and credentials, another default timeout for the calls made through it. */
+  withTimeout(timeoutMs) {
+    return this.derive({ ...this.options, timeoutMs });
+  }
+  /** Same daemon and credentials; every request names this client session (null: none). */
+  withClientSession(sessionId) {
+    return this.derive({ ...this.options, clientSession: sessionId ?? void 0 });
+  }
+  /**
+   * A client like this one with other options; `withBaseUrl` and
+   * `withTimeout` build through it. A subclass whose constructor takes other
+   * options overrides it so the derived client keeps the subclass.
+   */
+  derive(options) {
+    return new this.constructor(options);
   }
   /** Whether requests carry a bearer token. */
   get hasToken() {
-    return !!this.token;
+    return !!this.credentials?.token();
   }
   // --- transport ------------------------------------------------------------
   url(path, query) {
     let qs = query ? buildQuery(query) : "";
     return `${this.baseUrl}${path}${qs}`;
   }
+  /** Headers for a request to `baseUrl` itself. */
   headers(extra = {}) {
+    return this.headersFor(this.baseUrl, extra);
+  }
+  /**
+   * Headers for a request to `url`: the bearer token (and `localProof` for
+   * `path`) only when `url` has the credentials' origin. A path that turns
+   * the URL into another host (`@host`, a full URL) gets no credentials.
+   */
+  headersFor(url, extra = {}, path) {
+    let own = this.ownsUrl(url), token = own ? this.credentials?.token() : void 0, session = own ? this.options.clientSession : void 0;
     return {
       Accept: "application/json",
-      ...this.token ? { Authorization: `Bearer ${this.token}` } : {},
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...session ? { "X-ADF-Client-Session": session } : {},
+      ...own && path !== void 0 ? this.credentials?.localProof?.(path) ?? {} : {},
       ...extra
     };
   }
-  /**
-   * The daemon answered 401: with `localToken` and no explicit token, pick up
-   * a token file that appeared or changed since (daemon first start). True
-   * when the token changed, so the request is worth one retry.
-   */
-  refreshLocalToken() {
-    if (!this.options.localToken || this.options.token) return !1;
-    let env = this.options.env ?? process.env;
-    if (env.ADF_DAEMON_TOKEN) return !1;
-    let fresh = localDaemonToken(this.baseUrl, env);
-    return !fresh || fresh === this.token ? !1 : (this.token = fresh, !0);
+  ownsUrl(url) {
+    return this.origin !== null && originOf(url) === this.origin;
   }
   async request(method, path, options = {}, retried = !1) {
     let controller = new AbortController(), timeoutMs = options.timeoutMs ?? this.timeoutMs, timer = setTimeout(() => controller.abort(new Error("timeout")), timeoutMs), onAbort = () => controller.abort(options.signal?.reason);
-    options.signal?.addEventListener("abort", onAbort, { once: !0 });
-    let response;
+    options.signal?.aborted ? onAbort() : options.signal?.addEventListener("abort", onAbort, { once: !0 });
+    let url = this.url(path, options.query), response, text, own = this.ownsUrl(url);
     try {
-      response = await this.fetchImpl(this.url(path, options.query), {
+      if (controller.signal.throwIfAborted(), own && this.credentials?.ready)
+        try {
+          await this.credentials.ready();
+        } catch (err) {
+          throw new DaemonError(errorMessage2(err), null);
+        }
+      if (response = await this.fetchImpl(url, {
         method,
-        headers: this.headers({
-          ...options.body !== void 0 ? { "Content-Type": "application/json" } : {},
-          // Proxy-mode daemons (ADF_DAEMON_BEHIND_PROXY) need this machine's proof on local-only routes.
-          ...this.options.localToken ? localProofHeaders(this.baseUrl, path, this.options.env ?? process.env) : {}
-        }),
+        // Proxy-mode daemons (ADF_DAEMON_BEHIND_PROXY) need this machine's proof on local-only routes.
+        headers: this.headersFor(url, options.body !== void 0 ? { "Content-Type": "application/json" } : {}, path),
         body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
-        signal: controller.signal
-      });
+        signal: controller.signal,
+        // Never followed: a 302 would forward the token / local proof, a 307 the body.
+        redirect: "manual"
+      }), isRedirect(response))
+        throw response.body?.cancel().catch(() => {
+        }), new DaemonError(redirectMessage(this.baseUrl, response), response.status);
+      text = await response.text();
     } catch (err) {
+      if (err instanceof DaemonError) throw err;
+      own && this.credentials?.dropped?.();
       let reason = controller.signal.aborted && !options.signal?.aborted ? `timed out after ${timeoutMs}ms` : errorMessage2(err);
       throw new DaemonError(`Cannot reach daemon at ${this.baseUrl}: ${reason}`, null);
     } finally {
       clearTimeout(timer), options.signal?.removeEventListener("abort", onAbort);
     }
-    let text = await response.text(), body = null;
+    let body = null;
     if (text.trim())
       try {
         body = JSON.parse(text);
@@ -336,7 +429,7 @@ var DaemonClient = class _DaemonClient {
         body = text;
       }
     if (!response.ok) {
-      if (response.status === 401 && !retried && this.refreshLocalToken()) return this.request(method, path, options, !0);
+      if (response.status === 401 && !retried && this.ownsUrl(url) && this.credentials?.refresh?.()) return this.request(method, path, options, !0);
       let message = isRecord(body) && typeof body.error == "string" ? body.error : `HTTP ${response.status} ${response.statusText}`;
       throw new DaemonError(message, response.status, body);
     }
@@ -357,11 +450,65 @@ var DaemonClient = class _DaemonClient {
   del(path, query) {
     return this.request("DELETE", path, { query });
   }
-  /** Live umbilical events (SSE) with auto-reconnect. Call `.start()` on the result. */
+  /**
+   * Live events (SSE) with auto-reconnect: `GET /events` (umbilical frames)
+   * unless `path` names another stream. Call `.start()` on the result.
+   */
   events(options) {
-    return new EventStream({ ...options, baseUrl: this.baseUrl, headers: () => this.headers({ Accept: "text/event-stream" }), fetch: this.fetchImpl });
+    return new EventStream({
+      ...options,
+      baseUrl: this.baseUrl,
+      headers: (url) => this.headersFor(url, { Accept: "text/event-stream" }),
+      fetch: this.fetchImpl,
+      beforeConnect: async (url) => {
+        this.ownsUrl(url) && await this.credentials?.ready?.();
+      },
+      onDrop: () => this.credentials?.dropped?.()
+    });
+  }
+  // --- client sessions (design D5; internal) ---------------------------------
+  /** POST /client/sessions: open a session. Its stream starts at the first frame after this call. */
+  createClientSession(input) {
+    return this.post("/client/sessions", input);
+  }
+  /**
+   * GET /client/sessions/:id/events: the session's frames (executor, host,
+   * push). Replays from the session's first frame unless `since` is given;
+   * reconnects resume with `?since=&epoch=`. `onGap` / `onResume` report lost
+   * frames (resync then, design D6). A 404 means the session is gone (it
+   * expired or the daemon restarted): close the stream and open a new
+   * session. Call `.start()` on the result.
+   */
+  clientSessionEvents(sessionId, options) {
+    return this.events({
+      replay: !0,
+      dedupeKey: clientFrameDedupeKey,
+      ...options,
+      path: `/client/sessions/${enc(sessionId)}/events`,
+      isFrame: (value) => isClientFrame(value)
+    });
+  }
+  /** PUT /client/sessions/:id/focus: the agent whose deltas and full tool results this session gets (null: none). */
+  setClientSessionFocus(sessionId, agentId) {
+    return this.put(`/client/sessions/${enc(sessionId)}/focus`, { agentId });
+  }
+  /** POST /client/sessions/:id/documents: hold an agent file open for this session. */
+  holdClientSessionDocument(sessionId, document) {
+    return this.post(`/client/sessions/${enc(sessionId)}/documents`, document);
+  }
+  /** DELETE /client/sessions/:id/documents/:agentId. */
+  releaseClientSessionDocument(sessionId, agentId) {
+    return this.del(`/client/sessions/${enc(sessionId)}/documents/${enc(agentId)}`);
+  }
+  /** DELETE /client/sessions/:id: end the session now; its documents are released. */
+  endClientSession(sessionId) {
+    return this.del(`/client/sessions/${enc(sessionId)}`);
   }
   // --- daemon ---------------------------------------------------------------
+  /** GET /version: build, client API version, settings file, pid, who started this run (§8.2). */
+  version() {
+    return this.get("/version");
+  }
   health() {
     return this.get("/health");
   }
@@ -433,7 +580,7 @@ var DaemonClient = class _DaemonClient {
   lanAddresses() {
     return this.get("/network/mesh/lan-addresses");
   }
-  // --- subscription provider sign-in (ChatGPT, Grok) ------------------------
+  // --- subscription provider sign-in (ChatGPT, Grok, Claude) ----------------
   // Sign-in flows themselves (browser, callback server, polling) live in
   // cli/auth-flow.ts over `request`; these are the plain reads and sign-out.
   subscriptionStatus(provider) {
@@ -442,6 +589,14 @@ var DaemonClient = class _DaemonClient {
   logoutSubscription(provider) {
     return this.post(`/auth/${provider}/logout`);
   }
+  /** Hand the code Claude's sign-in page shows to the daemon's waiting Claude Code. */
+  submitClaudeCode(code) {
+    return this.post("/auth/claude/code", { code });
+  }
+  /** Stop a running Claude sign-in on the daemon host. */
+  cancelClaudeAuth() {
+    return this.post("/auth/claude/cancel");
+  }
   // --- owner identity + agent creation --------------------------------------
   // create / restore / unlock answer loopback callers only (403 loopback_only).
   // Nothing here logs or keeps a request or response body.
@@ -861,6 +1016,30 @@ function errorMessage2(err) {
   return String(err);
 }
 
+// src/main/tui/api/client.ts
+var { daemonCredentials, resolveDaemonUrl } = cjs(daemon_url_exports), shared = cjs(client_exports), staticCredentials2 = shared.staticCredentials, DaemonClient2 = class _DaemonClient extends shared.DaemonClient {
+  /** `resolved`: options already built for the shared client (derive); `options` is then ignored. */
+  constructor(options = {}, resolved) {
+    super(resolved ?? _DaemonClient.resolve(options));
+  }
+  static resolve(options) {
+    let baseUrl = resolveDaemonUrl(options.baseUrl, options.env), lookup = { localToken: options.localToken, env: options.env, fetch: options.fetch };
+    return {
+      baseUrl,
+      // `--token` belongs to this URL; another daemon (withBaseUrl) gets its
+      // own `--token`, or ADF_DAEMON_TOKEN, or its own local token file (and
+      // local proof, when it is this machine's daemon), never this one.
+      credentials: daemonCredentials(baseUrl, { ...lookup, token: options.token }),
+      credentialsFor: (url, token) => daemonCredentials(url, { ...lookup, token }),
+      fetch: options.fetch,
+      timeoutMs: options.timeoutMs
+    };
+  }
+  derive(options) {
+    return new _DaemonClient({}, options);
+  }
+};
+
 export {
-  DaemonClient
+  DaemonClient2 as DaemonClient
 };

package/dist/chunks/{chunk-XNPZBLYL.mjs → chunk-75DC5EWN.mjs}

@@ -4,8 +4,18 @@ import { dirname as __adfDirname } from 'node:path';
 const require = __adfCreateRequire(import.meta.url);
 const __filename = __adfFileURLToPath(import.meta.url);
 const __dirname = __adfDirname(__filename);
+import {
+  __export
+} from "./chunk-M2RX3S2T.mjs";
 
-// src/main/tui/api/types.ts
+// src/shared/daemon-client/types.ts
+var types_exports = {};
+__export(types_exports, {
+  DaemonError: () => DaemonError,
+  MAIN_LOOP: () => MAIN_LOOP,
+  SUPPORTED_CLIENT_API_VERSION: () => SUPPORTED_CLIENT_API_VERSION,
+  isCredentialsLocked: () => isCredentialsLocked
+});
 var MAIN_LOOP = "main", DaemonError = class extends Error {
   constructor(message, status, body = null) {
     super(message);
@@ -25,9 +35,10 @@ function isCredentialsLocked(err) {
   let body = err.body;
   return !!body && typeof body == "object" && body.code === "credentials_locked";
 }
+var SUPPORTED_CLIENT_API_VERSION = 2;
 
 export {
   MAIN_LOOP,
   DaemonError,
-  isCredentialsLocked
+  types_exports
 };