sootsim 0.0.1 → 0.0.2

package/dist-lib/attached-projects.cjs

@@ -0,0 +1,448 @@
+/*! sootsim v0.0.2 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/attached-projects.ts
+var attached_projects_exports = {};
+__export(attached_projects_exports, {
+  __setUserDataDirForTests: () => __setUserDataDirForTests,
+  costThisWeek: () => costThisWeek,
+  deletePreviewAttachment: () => deletePreviewAttachment,
+  deleteProject: () => deleteProject,
+  deleteSession: () => deleteSession,
+  findProjectByBundleUrl: () => findProjectByBundleUrl,
+  findProjectByCwd: () => findProjectByCwd,
+  findProjectById: () => findProjectById,
+  findSessionById: () => findSessionById,
+  getUserDataDir: () => getUserDataDir,
+  listPreviewAttachments: () => listPreviewAttachments,
+  listProjects: () => listProjects,
+  listSessions: () => listSessions,
+  loadStore: () => loadStore,
+  mutateStore: () => mutateStore,
+  projectIdForCwd: () => projectIdForCwd,
+  recordTurnTelemetry: () => recordTurnTelemetry,
+  seedFromDemoAppRegistry: () => seedFromDemoAppRegistry,
+  setUserDataDir: () => setUserDataDir,
+  updateSessionStatus: () => updateSessionStatus,
+  upsertPreviewAttachment: () => upsertPreviewAttachment,
+  upsertProject: () => upsertProject,
+  upsertSession: () => upsertSession
+});
+module.exports = __toCommonJS(attached_projects_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var overrideDir = null;
+function setUserDataDir(dir) {
+  overrideDir = dir;
+}
+var __setUserDataDirForTests = setUserDataDir;
+function userDataDir() {
+  if (overrideDir) return overrideDir;
+  const fromEnv = process.env.SOOTSIM_USER_DATA_DIR;
+  if (fromEnv) return fromEnv;
+  try {
+    const electron = require("electron");
+    if (electron.app?.getPath) return electron.app.getPath("userData");
+  } catch {
+  }
+  return platformDefaultUserDataDir();
+}
+function platformDefaultUserDataDir() {
+  const home = import_node_os.default.homedir();
+  if (process.platform === "darwin") {
+    return import_node_path.default.join(home, "Library", "Application Support", "sootsim");
+  }
+  if (process.platform === "win32") {
+    return import_node_path.default.join(process.env.APPDATA || home, "sootsim");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || import_node_path.default.join(home, ".config");
+  return import_node_path.default.join(xdg, "sootsim");
+}
+function getUserDataDir() {
+  return userDataDir();
+}
+function storeFile() {
+  return import_node_path.default.join(userDataDir(), "attached-projects.json");
+}
+function cloneEmpty() {
+  return {
+    version: 1,
+    attachedProjects: [],
+    previewAttachments: [],
+    agentSessions: []
+  };
+}
+function loadStore() {
+  const file = storeFile();
+  let raw;
+  try {
+    raw = import_node_fs.default.readFileSync(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return cloneEmpty();
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") throw new Error("not an object");
+    return {
+      version: 1,
+      attachedProjects: Array.isArray(parsed.attachedProjects) ? parsed.attachedProjects : [],
+      previewAttachments: Array.isArray(parsed.previewAttachments) ? parsed.previewAttachments : [],
+      agentSessions: Array.isArray(parsed.agentSessions) ? parsed.agentSessions : []
+    };
+  } catch (err) {
+    const quarantine = `${file}.corrupt-${Date.now()}`;
+    try {
+      import_node_fs.default.renameSync(file, quarantine);
+      console.warn(
+        `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
+      );
+    } catch {
+    }
+    return cloneEmpty();
+  }
+}
+function writeStore(store) {
+  const file = storeFile();
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  const fd = import_node_fs.default.openSync(tmp, "w", 384);
+  try {
+    import_node_fs.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs.default.fsyncSync(fd);
+  } finally {
+    import_node_fs.default.closeSync(fd);
+  }
+  import_node_fs.default.renameSync(tmp, file);
+}
+function mutateStore(fn) {
+  const store = loadStore();
+  fn(store);
+  writeStore(store);
+  return store;
+}
+function projectIdForCwd(cwd) {
+  return (0, import_node_crypto.createHash)("sha256").update(import_node_path.default.resolve(cwd)).digest("hex").slice(0, 16);
+}
+function newSessionId() {
+  return `s_${(0, import_node_crypto.randomBytes)(10).toString("hex")}`;
+}
+function newPreviewId() {
+  return `pa_${(0, import_node_crypto.randomBytes)(10).toString("hex")}`;
+}
+function upsertProject(input) {
+  const cwd = import_node_path.default.resolve(input.cwd);
+  const id = projectIdForCwd(cwd);
+  let result;
+  mutateStore((store) => {
+    const existing = store.attachedProjects.find((p) => p.id === id);
+    if (existing) {
+      const merged = {
+        ...existing,
+        ...input,
+        id,
+        cwd,
+        sourceRoots: input.sourceRoots ?? existing.sourceRoots,
+        knownBundleUrls: input.knownBundleUrls ?? existing.knownBundleUrls,
+        pinnedSourceResolutions: input.pinnedSourceResolutions ?? existing.pinnedSourceResolutions,
+        telemetry: input.telemetry ?? existing.telemetry,
+        updatedAt: Date.now(),
+        createdAt: existing.createdAt
+      };
+      const idx = store.attachedProjects.indexOf(existing);
+      store.attachedProjects[idx] = merged;
+      result = merged;
+      return;
+    }
+    const now = Date.now();
+    const created = {
+      id,
+      name: input.name ?? import_node_path.default.basename(cwd),
+      cwd,
+      repoRoot: input.repoRoot,
+      sourceRoots: input.sourceRoots ?? [cwd],
+      framework: input.framework ?? "unknown",
+      bundleId: input.bundleId,
+      knownBundleUrls: input.knownBundleUrls ?? [],
+      preferredProvider: input.preferredProvider ?? "codex",
+      preferredTransport: input.preferredTransport ?? "tmux",
+      editorOpenCommand: input.editorOpenCommand,
+      moshiWebhookToken: input.moshiWebhookToken,
+      pinnedSourceResolutions: input.pinnedSourceResolutions ?? {},
+      isolateDiscovery: input.isolateDiscovery,
+      git: input.git,
+      telemetry: input.telemetry ?? { lastOpened: 0, runsCompleted: 0 },
+      createdAt: now,
+      updatedAt: now
+    };
+    store.attachedProjects.push(created);
+    result = created;
+  });
+  return result;
+}
+function findProjectById(id) {
+  return loadStore().attachedProjects.find((p) => p.id === id) ?? null;
+}
+function findProjectByCwd(cwd) {
+  const resolved = import_node_path.default.resolve(cwd);
+  return loadStore().attachedProjects.find((p) => p.cwd === resolved) ?? null;
+}
+function findProjectByBundleUrl(bundleUrl) {
+  const store = loadStore();
+  const exact = store.attachedProjects.find((p) => p.knownBundleUrls.includes(bundleUrl));
+  if (exact) return exact;
+  const base = stripQuery(bundleUrl);
+  return store.attachedProjects.find(
+    (p) => p.knownBundleUrls.some((u) => stripQuery(u) === base)
+  ) ?? null;
+}
+function stripQuery(url) {
+  const q = url.indexOf("?");
+  return q >= 0 ? url.slice(0, q) : url;
+}
+function listProjects() {
+  return loadStore().attachedProjects;
+}
+var COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function recordTurnTelemetry(projectId, input = {}) {
+  mutateStore((store) => {
+    const project = store.attachedProjects.find((p) => p.id === projectId);
+    if (!project) return;
+    const ts = input.ts ?? Date.now();
+    project.telemetry.runsCompleted = (project.telemetry.runsCompleted ?? 0) + 1;
+    if (typeof input.usd === "number" && Number.isFinite(input.usd) && input.usd >= 0) {
+      const history = project.telemetry.costHistory ?? [];
+      const cutoff = ts - COST_HISTORY_MAX_AGE_MS;
+      const trimmed = history.filter((e) => e.ts >= cutoff);
+      trimmed.push({ ts, usd: input.usd });
+      project.telemetry.costHistory = trimmed;
+    }
+    project.updatedAt = ts;
+  });
+}
+function costThisWeek(project, now = Date.now()) {
+  const cutoff = now - 7 * 24 * 60 * 60 * 1e3;
+  const history = project.telemetry.costHistory ?? [];
+  let total = 0;
+  for (const e of history) {
+    if (e.ts >= cutoff) total += e.usd;
+  }
+  return total;
+}
+function deleteProject(id) {
+  mutateStore((store) => {
+    store.attachedProjects = store.attachedProjects.filter((p) => p.id !== id);
+    store.agentSessions = store.agentSessions.filter((s) => s.projectId !== id);
+    store.previewAttachments = store.previewAttachments.filter(
+      (pa) => pa.projectId !== id
+    );
+  });
+}
+function upsertSession(input) {
+  let result;
+  mutateStore((store) => {
+    if (input.id) {
+      const existing = store.agentSessions.find((s) => s.id === input.id);
+      if (existing) {
+        const merged = {
+          ...existing,
+          ...input,
+          lastSeenAt: Date.now()
+        };
+        const idx = store.agentSessions.indexOf(existing);
+        store.agentSessions[idx] = merged;
+        result = merged;
+        return;
+      }
+    }
+    const project = store.attachedProjects.find((p) => p.id === input.projectId);
+    if (!project) {
+      throw new Error(`upsertSession: no AttachedProject with id=${input.projectId}`);
+    }
+    const now = Date.now();
+    const created = {
+      id: input.id ?? newSessionId(),
+      projectId: input.projectId,
+      provider: input.provider,
+      transport: input.transport ?? project.preferredTransport,
+      cwd: input.cwd ?? project.cwd,
+      claudeSessionUuid: input.claudeSessionUuid,
+      tmuxSessionName: input.tmuxSessionName,
+      wrapperPid: input.wrapperPid,
+      status: input.status ?? "idle",
+      needsAttention: input.needsAttention ?? false,
+      lastPrompt: input.lastPrompt,
+      lastSummary: input.lastSummary,
+      lastTurnFiles: input.lastTurnFiles,
+      currentlyEditing: input.currentlyEditing,
+      lastSeenAt: now,
+      createdAt: now
+    };
+    store.agentSessions.push(created);
+    result = created;
+  });
+  return result;
+}
+function findSessionById(id) {
+  return loadStore().agentSessions.find((s) => s.id === id) ?? null;
+}
+function listSessions(projectId) {
+  const all = loadStore().agentSessions;
+  return projectId ? all.filter((s) => s.projectId === projectId) : all;
+}
+function updateSessionStatus(id, patch) {
+  mutateStore((store) => {
+    const existing = store.agentSessions.find((s) => s.id === id);
+    if (!existing) return;
+    const idx = store.agentSessions.indexOf(existing);
+    store.agentSessions[idx] = {
+      ...existing,
+      ...patch,
+      id: existing.id,
+      projectId: existing.projectId,
+      createdAt: existing.createdAt,
+      lastSeenAt: Date.now()
+    };
+  });
+}
+function deleteSession(id) {
+  mutateStore((store) => {
+    store.agentSessions = store.agentSessions.filter((s) => s.id !== id);
+  });
+}
+function upsertPreviewAttachment(input) {
+  let result;
+  mutateStore((store) => {
+    const existing = store.previewAttachments.find(
+      (pa) => pa.bundleUrl === input.bundleUrl && pa.browserId === input.browserId
+    );
+    if (existing) {
+      const merged = {
+        ...existing,
+        ...input,
+        lastSeenAt: Date.now()
+      };
+      const idx = store.previewAttachments.indexOf(existing);
+      store.previewAttachments[idx] = merged;
+      result = merged;
+      return;
+    }
+    const created = {
+      id: input.id ?? newPreviewId(),
+      projectId: input.projectId ?? null,
+      bundleUrl: input.bundleUrl,
+      browserId: input.browserId,
+      deviceModel: input.deviceModel ?? "unknown",
+      status: input.status ?? "connecting",
+      lastSeenAt: Date.now()
+    };
+    store.previewAttachments.push(created);
+    result = created;
+  });
+  return result;
+}
+function listPreviewAttachments(projectId) {
+  const all = loadStore().previewAttachments;
+  return projectId ? all.filter((pa) => pa.projectId === projectId) : all;
+}
+function deletePreviewAttachment(id) {
+  mutateStore((store) => {
+    store.previewAttachments = store.previewAttachments.filter((pa) => pa.id !== id);
+  });
+}
+async function seedFromDemoAppRegistry() {
+  const existing = loadStore().attachedProjects;
+  if (existing.length > 0) return;
+  let APPS;
+  try {
+    const mod = await import("sootsim/scripts/demo-app-registry");
+    APPS = mod.APPS;
+  } catch (err) {
+    console.warn(
+      "[sootsim] seedFromDemoAppRegistry: could not load demo registry:",
+      err.message
+    );
+    return;
+  }
+  if (!Array.isArray(APPS)) return;
+  const apps = APPS;
+  mutateStore((store) => {
+    for (const app of apps) {
+      if (!import_node_fs.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path.default.resolve(app.dir);
+      const id = projectIdForCwd(cwd);
+      if (store.attachedProjects.some((p) => p.id === id)) continue;
+      const now = Date.now();
+      store.attachedProjects.push({
+        id,
+        name: app.label,
+        cwd,
+        sourceRoots: [cwd],
+        framework: app.framework,
+        knownBundleUrls: [`http://localhost:${app.preferredPort}/index.bundle`],
+        preferredProvider: "codex",
+        preferredTransport: "tmux",
+        pinnedSourceResolutions: {},
+        telemetry: { lastOpened: 0, runsCompleted: 0 },
+        createdAt: now,
+        updatedAt: now
+      });
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __setUserDataDirForTests,
+  costThisWeek,
+  deletePreviewAttachment,
+  deleteProject,
+  deleteSession,
+  findProjectByBundleUrl,
+  findProjectByCwd,
+  findProjectById,
+  findSessionById,
+  getUserDataDir,
+  listPreviewAttachments,
+  listProjects,
+  listSessions,
+  loadStore,
+  mutateStore,
+  projectIdForCwd,
+  recordTurnTelemetry,
+  seedFromDemoAppRegistry,
+  setUserDataDir,
+  updateSessionStatus,
+  upsertPreviewAttachment,
+  upsertProject,
+  upsertSession
+});

package/dist-lib/auth/shared-session.cjs

@@ -0,0 +1,174 @@
+/*! sootsim v0.0.2 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/auth/shared-session.ts
+var shared_session_exports = {};
+__export(shared_session_exports, {
+  clearSharedDesktopAuthSession: () => clearSharedDesktopAuthSession,
+  getSharedDesktopAuthFilePath: () => getSharedDesktopAuthFilePath,
+  readSharedDesktopAuthSession: () => readSharedDesktopAuthSession,
+  refreshSharedDesktopAuthSession: () => refreshSharedDesktopAuthSession,
+  writeSharedDesktopAuthSession: () => writeSharedDesktopAuthSession
+});
+module.exports = __toCommonJS(shared_session_exports);
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var SESSION_VERSION = 1;
+var SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
+var DEFAULT_ORIGIN = "https://sootbean.com";
+function getBaseDir() {
+  const explicit = process.env[SESSION_FILE_ENV];
+  if (explicit?.trim()) {
+    return (0, import_node_path.dirname)((0, import_node_path.resolve)(explicit));
+  }
+  const home = (0, import_node_os.homedir)();
+  if (!home) {
+    throw new Error("could not determine home directory for sootsim auth storage");
+  }
+  switch ((0, import_node_os.platform)()) {
+    case "darwin":
+      return (0, import_node_path.join)(home, "Library", "Application Support", "sootsim");
+    case "win32":
+      return (0, import_node_path.join)(process.env.APPDATA || (0, import_node_path.join)(home, "AppData", "Roaming"), "sootsim");
+    case "aix":
+    case "android":
+    case "cygwin":
+    case "freebsd":
+    case "haiku":
+    case "linux":
+    case "netbsd":
+    case "openbsd":
+    case "sunos":
+    default:
+      return (0, import_node_path.join)(process.env.XDG_CONFIG_HOME || (0, import_node_path.join)(home, ".config"), "sootsim");
+  }
+}
+function getSharedDesktopAuthFilePath() {
+  const explicit = process.env[SESSION_FILE_ENV];
+  if (explicit?.trim()) return (0, import_node_path.resolve)(explicit);
+  return (0, import_node_path.join)(getBaseDir(), "desktop-auth.json");
+}
+function normalizeUser(input) {
+  if (!input || typeof input !== "object") return null;
+  const value = input;
+  if (typeof value.id !== "string" || !value.id.trim()) return null;
+  return {
+    id: value.id.trim(),
+    name: typeof value.name === "string" ? value.name : void 0,
+    email: typeof value.email === "string" ? value.email : void 0,
+    image: typeof value.image === "string" ? value.image : void 0
+  };
+}
+function normalizeSession(input) {
+  if (!input || typeof input !== "object") return null;
+  const value = input;
+  if (value.version !== SESSION_VERSION) return null;
+  if (typeof value.token !== "string" || !value.token.trim()) return null;
+  const origin = typeof value.origin === "string" && value.origin.trim() ? value.origin.trim() : DEFAULT_ORIGIN;
+  const source = value.source === "cli" || value.source === "electron" || value.source === "browser" || value.source === "unknown" ? value.source : "unknown";
+  const updatedAt = typeof value.updatedAt === "string" && value.updatedAt ? value.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
+  const validatedAt = typeof value.validatedAt === "string" && value.validatedAt ? value.validatedAt : void 0;
+  return {
+    version: SESSION_VERSION,
+    token: value.token.trim(),
+    user: normalizeUser(value.user),
+    origin,
+    source,
+    updatedAt,
+    validatedAt
+  };
+}
+function readSharedDesktopAuthSession() {
+  const filepath = getSharedDesktopAuthFilePath();
+  if (!(0, import_node_fs.existsSync)(filepath)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(filepath, "utf8"));
+    const normalized = normalizeSession(parsed);
+    if (!normalized) {
+      (0, import_node_fs.rmSync)(filepath, { force: true });
+      return null;
+    }
+    return normalized;
+  } catch {
+    (0, import_node_fs.rmSync)(filepath, { force: true });
+    return null;
+  }
+}
+function writeSharedDesktopAuthSession(session) {
+  const filepath = getSharedDesktopAuthFilePath();
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(filepath), { recursive: true });
+  const normalized = {
+    version: SESSION_VERSION,
+    token: session.token.trim(),
+    user: session.user ? normalizeUser(session.user) : null,
+    origin: session.origin?.trim() || DEFAULT_ORIGIN,
+    source: session.source,
+    updatedAt: session.updatedAt || (/* @__PURE__ */ new Date()).toISOString(),
+    validatedAt: session.validatedAt
+  };
+  (0, import_node_fs.writeFileSync)(filepath, JSON.stringify(normalized, null, 2) + "\n");
+  try {
+    (0, import_node_fs.chmodSync)(filepath, 384);
+  } catch {
+  }
+  return normalized;
+}
+function clearSharedDesktopAuthSession() {
+  (0, import_node_fs.rmSync)(getSharedDesktopAuthFilePath(), { force: true });
+}
+async function refreshSharedDesktopAuthSession(originOverride) {
+  const current = readSharedDesktopAuthSession();
+  if (!current?.token) return null;
+  const origin = originOverride || current.origin || DEFAULT_ORIGIN;
+  try {
+    const res = await fetch(`${origin.replace(/\/$/, "")}/api/auth/me`, {
+      headers: { authorization: `Bearer ${current.token}` }
+    });
+    if (res.status === 401) {
+      clearSharedDesktopAuthSession();
+      return null;
+    }
+    if (!res.ok) return current;
+    const data = await res.json();
+    if (!data.user?.id) {
+      clearSharedDesktopAuthSession();
+      return null;
+    }
+    return writeSharedDesktopAuthSession({
+      token: current.token,
+      user: data.user,
+      origin,
+      source: current.source,
+      validatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch {
+    return current;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearSharedDesktopAuthSession,
+  getSharedDesktopAuthFilePath,
+  readSharedDesktopAuthSession,
+  refreshSharedDesktopAuthSession,
+  writeSharedDesktopAuthSession
+});

package/dist-lib/backend-origin.cjs

@@ -0,0 +1,70 @@
+/*! sootsim v0.0.2 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend-origin.ts
+var backend_origin_exports = {};
+__export(backend_origin_exports, {
+  DEFAULT_SOOT_BACKEND_ORIGIN: () => DEFAULT_SOOT_BACKEND_ORIGIN,
+  isLoopbackHost: () => isLoopbackHost,
+  isSootBackendHost: () => isSootBackendHost,
+  isSootBackendOrigin: () => isSootBackendOrigin,
+  resolveSootBackendOrigin: () => resolveSootBackendOrigin
+});
+module.exports = __toCommonJS(backend_origin_exports);
+var DEFAULT_SOOT_BACKEND_ORIGIN = "https://sootbean.com";
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+function isSootBackendHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return isLoopbackHost(normalized) || normalized === "sootbean.com" || normalized.endsWith(".sootbean.com");
+}
+function isSootBackendOrigin(origin) {
+  try {
+    return isSootBackendHost(new URL(origin).hostname);
+  } catch {
+    return false;
+  }
+}
+function resolveSootBackendOrigin(currentOrigin) {
+  const origin = currentOrigin?.trim();
+  if (!origin) return DEFAULT_SOOT_BACKEND_ORIGIN;
+  try {
+    const parsed = new URL(origin);
+    if (isLoopbackHost(parsed.hostname) || isSootBackendHost(parsed.hostname)) {
+      return parsed.origin;
+    }
+  } catch {
+  }
+  return DEFAULT_SOOT_BACKEND_ORIGIN;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SOOT_BACKEND_ORIGIN,
+  isLoopbackHost,
+  isSootBackendHost,
+  isSootBackendOrigin,
+  resolveSootBackendOrigin
+});