@ateam-ai-mobile/core 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -12,8 +12,11 @@ function getConfig() {
   }
   return _config;
 }
+function resolveUrl(src) {
+  return (typeof src === "function" ? src() : src).replace(/\/$/, "");
+}
 function getCoreApiUrl() {
-  return getConfig().coreUrl.replace(/\/$/, "");
+  return resolveUrl(getConfig().coreUrl);
 }
 function getCoreWsUrl() {
   return getCoreApiUrl().replace(/^http/, "ws");
@@ -21,10 +24,16 @@ function getCoreWsUrl() {
 function getVoiceApiUrl() {
   const url = getConfig().voiceUrl;
   if (!url) throw new Error("[adas] voiceUrl not configured");
-  return url.replace(/\/$/, "");
+  return resolveUrl(url);
+}
+function getConsumerAuthApiUrl() {
+  const url = getConfig().consumerAuthUrl;
+  if (!url) throw new Error("[adas] consumerAuthUrl not configured \u2014 required for switchTenant()");
+  return resolveUrl(url);
 }
 function getTenant() {
-  return getConfig().tenant || "";
+  const t = getConfig().tenant;
+  return (typeof t === "function" ? t() : t) || "";
 }
 function getUser() {
   return getConfig().getUser?.() || null;
@@ -895,6 +904,41 @@ async function pollJob(jobId, token) {
   });
 }
 
+// src/api/tenants.ts
+async function listMyTenants() {
+  const data = await apiFetch("/api/tenants/list");
+  return data.ok && Array.isArray(data.tenants) ? data.tenants : [];
+}
+async function switchTenant(targetTenantId) {
+  const token = getToken();
+  if (!token) throw new Error("[adas] switchTenant: not signed in");
+  const res = await fetch(`${getConsumerAuthApiUrl()}/platform/consumer/switch-tenant`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ target_tenant: targetTenantId })
+  });
+  const data = await res.json().catch(() => null);
+  if (!res.ok || !data?.ok || !data.jwt) {
+    throw new Error(data?.error || `switchTenant failed (${res.status})`);
+  }
+  const session = {
+    jwt: data.jwt,
+    tenant: data.tenant,
+    actor: data.actor
+  };
+  const onSession = getConfig().onSession;
+  if (!onSession) {
+    throw new Error("[adas] switchTenant: config.onSession is required to persist the new session");
+  }
+  await onSession(session);
+  closeChatStream();
+  useChatStore.getState().clearChat();
+  return session;
+}
+
 // src/theme/tokens.ts
 var colors = {
   dark: {
@@ -994,6 +1038,580 @@ var borderRadius = {
   xl: 20,
   full: 9999
 };
+
+// src/acs/providers.ts
+var _reachability = null;
+function setAcsReachabilityReporter(r) {
+  _reachability = r;
+}
+function reportAcsServerUp() {
+  try {
+    _reachability?.up();
+  } catch {
+  }
+}
+function reportAcsServerDown() {
+  try {
+    _reachability?.down();
+  } catch {
+  }
+}
+var _kv = null;
+function setAcsCacheStorage(kv) {
+  _kv = kv;
+}
+function getAcsCacheStorage() {
+  return _kv;
+}
+
+// src/acs/api.ts
+async function authedFetch(path, init) {
+  const token = getToken();
+  try {
+    const res = await fetch(`${getCoreApiUrl()}${path}`, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {},
+        ...init?.headers || {}
+      }
+    });
+    reportAcsServerUp();
+    return res;
+  } catch (e) {
+    reportAcsServerDown();
+    throw e;
+  }
+}
+async function listSurface(surface, context) {
+  try {
+    const res = await authedFetch("/api/acs/surface", {
+      method: "POST",
+      body: JSON.stringify({ surface, ...context ? { context } : {} })
+    });
+    if (!res.ok) {
+      console.warn(`[acs] /surface ${surface} returned ${res.status}`);
+      return [];
+    }
+    const data = await res.json();
+    return Array.isArray(data?.items) ? data.items : [];
+  } catch (e) {
+    console.warn("[acs] /surface failed:", e?.message || e);
+    return [];
+  }
+}
+async function listMadeForYou() {
+  try {
+    const res = await authedFetch("/api/acs/made-for-you", { method: "GET" });
+    if (!res.ok) {
+      console.warn(`[acs] /made-for-you returned ${res.status}`);
+      return [];
+    }
+    const data = await res.json();
+    return Array.isArray(data?.artifacts) ? data.artifacts : [];
+  } catch (e) {
+    console.warn("[acs] /made-for-you failed:", e?.message || e);
+    return [];
+  }
+}
+async function deleteArtifact(artifactId, reason = "user_long_press_delete") {
+  try {
+    const res = await authedFetch(
+      `/api/acs/artifacts/${encodeURIComponent(artifactId)}`,
+      { method: "DELETE", body: JSON.stringify({ reason }) }
+    );
+    const data = await res.json().catch(() => ({}));
+    if (res.ok) {
+      return { ok: true, already: !!data?.already, status: res.status };
+    }
+    if (res.status === 404) {
+      return { ok: true, notFound: true, status: 404 };
+    }
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function patchArtifact(artifactId, body, reason) {
+  try {
+    const res = await authedFetch(
+      `/api/acs/artifacts/${encodeURIComponent(artifactId)}`,
+      { method: "PATCH", body: JSON.stringify({ ...body, reason }) }
+    );
+    const data = await res.json().catch(() => ({}));
+    if (res.ok) {
+      return {
+        ok: true,
+        already: !!data?.already,
+        artifact: data?.artifact || void 0,
+        status: res.status
+      };
+    }
+    if (res.status === 404) {
+      return { ok: true, notFound: true, status: 404 };
+    }
+    return {
+      ok: false,
+      status: res.status,
+      error: data?.error || `HTTP ${res.status}`
+    };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function setOrder(pinned) {
+  try {
+    const res = await authedFetch("/api/acs/order", {
+      method: "PUT",
+      body: JSON.stringify({ pinned })
+    });
+    if (res.ok) return { ok: true, status: res.status };
+    const data = await res.json().catch(() => ({}));
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function recordEvent(artifactId, event, surface) {
+  try {
+    await authedFetch("/api/acs/event", {
+      method: "POST",
+      body: JSON.stringify({ artifactId, event, ...surface ? { surface } : {} })
+    });
+  } catch {
+  }
+}
+async function listHomeActions() {
+  try {
+    const res = await authedFetch("/api/acs/home-actions", { method: "GET" });
+    if (!res.ok) {
+      console.warn(`[acs] /home-actions returned ${res.status}`);
+      return [];
+    }
+    const data = await res.json();
+    return Array.isArray(data?.actions) ? data.actions : [];
+  } catch (e) {
+    console.warn("[acs] /home-actions failed:", e?.message || e);
+    return [];
+  }
+}
+async function patchHomeAction(actionId, body, reason) {
+  try {
+    const res = await authedFetch(
+      `/api/acs/home-actions/${encodeURIComponent(actionId)}`,
+      { method: "PATCH", body: JSON.stringify({ ...body, reason }) }
+    );
+    const data = await res.json().catch(() => ({}));
+    if (res.ok) return { ok: true, action: data?.action || void 0, status: res.status };
+    if (res.status === 404) return { ok: true, status: 404 };
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function setHomeActionOrder(order) {
+  try {
+    const res = await authedFetch("/api/acs/home-actions/order", {
+      method: "PUT",
+      body: JSON.stringify({ order })
+    });
+    if (res.ok) return { ok: true, status: res.status };
+    const data = await res.json().catch(() => ({}));
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+
+// src/acs/widgetsStore.ts
+import { create as create2 } from "zustand";
+var useWidgetsStore = create2((set, get) => ({
+  tiles: [],
+  hydrated: false,
+  loading: false,
+  error: null,
+  hydrate: async () => {
+    if (get().hydrated || get().loading) return;
+    await get().refresh();
+  },
+  refresh: async () => {
+    if (get().loading) return;
+    set({ loading: true, error: null });
+    try {
+      const tiles = await listSurface("home");
+      set({ tiles, loading: false, hydrated: true });
+    } catch (e) {
+      set({ loading: false, hydrated: true, error: e?.message || "Failed to load widgets" });
+    }
+  },
+  clear: () => set({ tiles: [], hydrated: false, loading: false, error: null }),
+  remove: async (artifactId, reason = "user_long_press_delete") => {
+    const before = get().tiles;
+    set({ tiles: before.filter((t) => t.id !== artifactId) });
+    const result = await deleteArtifact(artifactId, reason);
+    if (result.ok) {
+      return { ok: true };
+    }
+    set({ tiles: before });
+    return { ok: false, error: result.error || `HTTP ${result.status}` };
+  },
+  hide: async (artifactId) => {
+    const before = get().tiles;
+    set({
+      tiles: before.map(
+        (t) => t.id === artifactId ? { ...t, visibility: "hidden" } : t
+      )
+    });
+    const r = await patchArtifact(artifactId, { visibility: "hidden" }, "user_long_press_hide");
+    if (r.ok) {
+      if (r.artifact) {
+        set({
+          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
+        });
+      }
+      return { ok: true };
+    }
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  unhide: async (artifactId) => {
+    const before = get().tiles;
+    set({
+      tiles: before.map(
+        (t) => t.id === artifactId ? { ...t, visibility: "pinned" } : t
+      )
+    });
+    const r = await patchArtifact(artifactId, { visibility: "pinned" }, "user_long_press_unhide");
+    if (r.ok) {
+      if (r.artifact) {
+        set({
+          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
+        });
+      }
+      return { ok: true };
+    }
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  rename: async (artifactId, name) => {
+    const trimmed = name.trim();
+    if (!trimmed) return { ok: false, error: "Name cannot be empty" };
+    if (trimmed.length > 60) return { ok: false, error: "Name must be 60 characters or less" };
+    const before = get().tiles;
+    set({
+      tiles: before.map((t) => t.id === artifactId ? { ...t, name: trimmed } : t)
+    });
+    const r = await patchArtifact(artifactId, { name: trimmed }, "user_long_press_rename");
+    if (r.ok) {
+      if (r.artifact) {
+        set({
+          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
+        });
+      }
+      return { ok: true };
+    }
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  reorder: async (pinnedIds) => {
+    const before = get().tiles;
+    const idToOrder = new Map(pinnedIds.map((id, i) => [id, i]));
+    set({
+      tiles: before.map((t) => {
+        const o = idToOrder.get(t.id);
+        return o == null ? t : { ...t, pinOrder: o };
+      })
+    });
+    const r = await setOrder(pinnedIds);
+    if (r.ok) return { ok: true };
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  applyServerUpdate: (artifact) => {
+    set({
+      tiles: get().tiles.map((t) => t.id === artifact.id ? { ...t, ...artifact } : t)
+    });
+  },
+  applyServerRetire: (artifactId) => {
+    set({ tiles: get().tiles.filter((t) => t.id !== artifactId) });
+  },
+  applyServerOrder: (pinnedIds) => {
+    const idToOrder = new Map(pinnedIds.map((id, i) => [id, i]));
+    set({
+      tiles: get().tiles.map((t) => {
+        const o = idToOrder.get(t.id);
+        return o == null ? t : { ...t, pinOrder: o };
+      })
+    });
+  },
+  track: (artifactId, event) => {
+    recordEvent(artifactId, event, "home");
+  }
+}));
+
+// src/acs/homeActionsStore.ts
+import { create as create3 } from "zustand";
+var CACHE_KEY = "ateam.homeActions.v1";
+function persist(actions) {
+  getAcsCacheStorage()?.setItem(CACHE_KEY, JSON.stringify(actions)).catch(() => {
+  });
+}
+function sortByPin(a, b) {
+  if (!!a.pinned !== !!b.pinned) return a.pinned ? -1 : 1;
+  const ao = typeof a.pinOrder === "number" ? a.pinOrder : Number.MAX_SAFE_INTEGER;
+  const bo = typeof b.pinOrder === "number" ? b.pinOrder : Number.MAX_SAFE_INTEGER;
+  return ao - bo;
+}
+var useHomeActionsStore = create3((set, get) => ({
+  actions: [],
+  hydrated: false,
+  loading: false,
+  hydrate: async () => {
+    if (get().hydrated || get().loading) return;
+    try {
+      const cached = await getAcsCacheStorage()?.getItem(CACHE_KEY);
+      if (cached) {
+        const parsed = JSON.parse(cached);
+        if (Array.isArray(parsed) && parsed.length > 0) {
+          set({ actions: parsed, hydrated: true });
+        }
+      }
+    } catch {
+    }
+    await get().refresh();
+  },
+  refresh: async () => {
+    if (get().loading) return;
+    set({ loading: true });
+    const actions = await listHomeActions();
+    if (actions.length > 0) {
+      set({ actions, loading: false, hydrated: true });
+      persist(actions);
+    } else {
+      set({ loading: false, hydrated: true });
+    }
+  },
+  // clear() wipes in-memory state on sign-out AND drops the disk cache — a
+  // different user must not see the prior user's cards.
+  clear: () => {
+    set({ actions: [], hydrated: false, loading: false });
+    getAcsCacheStorage()?.setItem(CACHE_KEY, "[]").catch(() => {
+    });
+  },
+  dismiss: async (actionId) => {
+    const before = get().actions;
+    const next = before.filter((a) => a.actionId !== actionId);
+    set({ actions: next });
+    persist(next);
+    const r = await patchHomeAction(actionId, { dismissed: true }, "user_dismiss");
+    if (r.ok) return { ok: true };
+    set({ actions: before });
+    persist(before);
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  setPinned: async (actionId, pinned) => {
+    const before = get().actions;
+    const next = before.map((a) => a.actionId === actionId ? { ...a, pinned } : a).sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+    const r = await patchHomeAction(actionId, { pinned }, pinned ? "user_pin" : "user_unpin");
+    if (r.ok) {
+      if (r.action) {
+        const merged = get().actions.map((a) => a.actionId === actionId ? { ...a, ...r.action } : a).sort(sortByPin);
+        set({ actions: merged });
+        persist(merged);
+      }
+      return { ok: true };
+    }
+    set({ actions: before });
+    persist(before);
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  reorder: async (orderedIds) => {
+    const before = get().actions;
+    const idx = new Map(orderedIds.map((id, i) => [id, i]));
+    const next = before.map((a) => {
+      const o = idx.get(a.actionId);
+      return o == null ? a : { ...a, pinOrder: o };
+    }).sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+    const r = await setHomeActionOrder(orderedIds);
+    if (r.ok) return { ok: true };
+    set({ actions: before });
+    persist(before);
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  applyServerUpsert: (action) => {
+    const rest = get().actions.filter((a) => a.actionId !== action.actionId);
+    const next = [...rest, action].sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+  },
+  applyServerRemove: (actionId) => {
+    const next = get().actions.filter((a) => a.actionId !== actionId);
+    set({ actions: next });
+    persist(next);
+  },
+  applyServerOrder: (orderedIds) => {
+    const idx = new Map(orderedIds.map((id, i) => [id, i]));
+    const next = get().actions.map((a) => {
+      const o = idx.get(a.actionId);
+      return o == null ? a : { ...a, pinOrder: o };
+    }).sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+  }
+}));
+
+// src/acs/ws.ts
+var _ws2 = null;
+var _wantOpen = false;
+var _retryAttempt = 0;
+var _retryTimer = null;
+var _token = null;
+var _tenant = null;
+var TOPIC = "acs.artifacts";
+var TOPIC_HOME = "acs.home-actions";
+var MAX_BACKOFF_MS = 3e4;
+function backoffMs(attempt) {
+  const base = Math.min(MAX_BACKOFF_MS, 500 * Math.pow(2, attempt));
+  const jitter = Math.random() * 250;
+  return base + jitter;
+}
+function send(obj) {
+  if (_ws2 && _ws2.readyState === 1) {
+    try {
+      _ws2.send(JSON.stringify(obj));
+    } catch (e) {
+      console.warn("[acsWs] send failed", e);
+    }
+  }
+}
+function handleEvent(msg) {
+  if (msg?.event === "subscribed") {
+    console.log("[acsWs] subscribed to", msg?.data?.topic);
+    return;
+  }
+  if (msg?.topic === TOPIC_HOME) {
+    const home = useHomeActionsStore.getState();
+    switch (msg.event) {
+      case "updated":
+        if (msg.action && typeof msg.action.actionId === "string") home.applyServerUpsert(msg.action);
+        break;
+      case "removed":
+        if (typeof msg.actionId === "string") home.applyServerRemove(msg.actionId);
+        break;
+      case "order":
+        if (Array.isArray(msg.order)) home.applyServerOrder(msg.order.filter((id) => typeof id === "string"));
+        break;
+      case "refreshed":
+        home.refresh();
+        break;
+      default:
+        break;
+    }
+    return;
+  }
+  if (msg?.topic !== TOPIC) return;
+  const store = useWidgetsStore.getState();
+  switch (msg.event) {
+    case "updated":
+      if (msg.artifact && typeof msg.artifact.id === "string") {
+        store.applyServerUpdate(msg.artifact);
+      }
+      break;
+    case "retired":
+      if (typeof msg.artifactId === "string") {
+        store.applyServerRetire(msg.artifactId);
+      }
+      break;
+    case "order":
+      if (Array.isArray(msg.pinned)) {
+        store.applyServerOrder(msg.pinned.filter((id) => typeof id === "string"));
+      }
+      break;
+    case "created":
+      if (msg.artifact && typeof msg.artifact.id === "string") {
+        store.applyServerUpdate(msg.artifact);
+      }
+      break;
+    default:
+      break;
+  }
+}
+function openSocket() {
+  if (_ws2) return;
+  if (!_token || !_tenant) return;
+  const url = `${getCoreWsUrl()}/ws?token=${encodeURIComponent(_token)}&tenant=${encodeURIComponent(_tenant)}`;
+  console.log(`[acsWs] opening`);
+  const ws = new WebSocket(url);
+  _ws2 = ws;
+  ws.onopen = () => {
+    _retryAttempt = 0;
+    send({ type: "subscribe", topic: TOPIC });
+    send({ type: "subscribe", topic: TOPIC_HOME });
+  };
+  ws.onmessage = (e) => {
+    try {
+      const msg = JSON.parse(typeof e.data === "string" ? e.data : "");
+      handleEvent(msg);
+    } catch (err) {
+      console.warn("[acsWs] parse failed", err);
+    }
+  };
+  ws.onerror = (e) => {
+    console.warn("[acsWs] error", e?.message || e);
+  };
+  ws.onclose = () => {
+    _ws2 = null;
+    if (!_wantOpen) return;
+    const delay = backoffMs(_retryAttempt++);
+    console.log(`[acsWs] closed; reconnecting in ${Math.round(delay)}ms (attempt ${_retryAttempt})`);
+    if (_retryTimer) clearTimeout(_retryTimer);
+    _retryTimer = setTimeout(openSocket, delay);
+  };
+}
+function notifyAcsWsForeground() {
+  if (_wantOpen && !_ws2) {
+    if (_retryTimer) {
+      clearTimeout(_retryTimer);
+      _retryTimer = null;
+    }
+    _retryAttempt = 0;
+    openSocket();
+  }
+}
+function connectAcsWs(token, tenant) {
+  if (_ws2 && _wantOpen && _token === token && _tenant === tenant) return;
+  if (_ws2) {
+    try {
+      _ws2.close();
+    } catch {
+    }
+    _ws2 = null;
+  }
+  _token = token;
+  _tenant = tenant;
+  _wantOpen = true;
+  openSocket();
+}
+function disconnectAcsWs() {
+  _wantOpen = false;
+  _token = null;
+  _tenant = null;
+  if (_retryTimer) {
+    clearTimeout(_retryTimer);
+    _retryTimer = null;
+  }
+  if (_ws2) {
+    try {
+      _ws2.close();
+    } catch {
+    }
+    _ws2 = null;
+  }
+}
 export {
   PluginCommandEmitter,
   TABLE_BLOCK_CLOSE,
@@ -1005,9 +1623,13 @@ export {
   borderRadius,
   closeChatStream,
   colors,
+  connectAcsWs,
   connectorCall,
+  deleteArtifact,
+  disconnectAcsWs,
   fontSize,
   getConfig,
+  getConsumerAuthApiUrl,
   getCoreApiUrl,
   getCoreWsUrl,
   getTenant,
@@ -1016,12 +1638,27 @@ export {
   getVoiceApiUrl,
   initAdas,
   isAdasInitialized,
+  listHomeActions,
+  listMadeForYou,
+  listMyTenants,
+  listSurface,
   mcpFetch,
   mcpToolCall,
+  notifyAcsWsForeground,
+  patchArtifact,
+  patchHomeAction,
   pluginCommandEmitter,
   postCommandResult,
+  recordEvent,
+  setAcsCacheStorage,
+  setAcsReachabilityReporter,
+  setHomeActionOrder,
+  setOrder,
   spacing,
+  switchTenant,
   unwrapMcpResult,
-  useChatStore
+  useChatStore,
+  useHomeActionsStore,
+  useWidgetsStore
 };
 //# sourceMappingURL=index.mjs.map