rnxsim 0.0.0 → 0.1.313

package/dist-lib/attached-projects.cjs

@@ -0,0 +1,526 @@
+/*! rnx v0.1.313 | (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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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);
+
+// scripts/optional-demo-registry.ts
+var optional_demo_registry_exports = {};
+__export(optional_demo_registry_exports, {
+  __withOptionalDemoAppsForTests: () => __withOptionalDemoAppsForTests,
+  findInternalDemoRegistry: () => findInternalDemoRegistry,
+  loadOptionalDemoApps: () => loadOptionalDemoApps,
+  optionalDemoAppsSync: () => optionalDemoAppsSync
+});
+function findInternalDemoRegistry(startDir) {
+  let dir = startDir;
+  for (let step = 0; step < MAX_ANCESTOR_STEPS; step++) {
+    if ((0, import_node_path2.basename)(dir) === "node_modules") return null;
+    const candidate = (0, import_node_path2.join)(dir, REGISTRY_REPO_PATH);
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path2.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+async function loadOptionalDemoApps() {
+  if (cached) return cached;
+  const registryPath = findInternalDemoRegistry((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)));
+  if (!registryPath) {
+    cached = [];
+    return cached;
+  }
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      (0, import_node_url.pathToFileURL)(registryPath).href
+    );
+    cached = Array.isArray(mod.APPS) ? mod.APPS : [];
+  } catch {
+    cached = [];
+  }
+  return cached;
+}
+function optionalDemoAppsSync() {
+  return cached ?? [];
+}
+function __withOptionalDemoAppsForTests(apps) {
+  const previous = cached;
+  cached = apps;
+  return {
+    restore: () => {
+      cached = previous;
+    }
+  };
+}
+var import_node_fs, import_node_path2, import_node_url, REGISTRY_REPO_PATH, MAX_ANCESTOR_STEPS, cached;
+var init_optional_demo_registry = __esm({
+  "scripts/optional-demo-registry.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_path2 = require("node:path");
+    import_node_url = require("node:url");
+    REGISTRY_REPO_PATH = "packages/sootsim/scripts/demo-app-registry.ts";
+    MAX_ANCESTOR_STEPS = 8;
+    cached = null;
+  }
+});
+
+// src/attached-projects.ts
+var attached_projects_exports = {};
+__export(attached_projects_exports, {
+  __setUserDataDirForTests: () => __setUserDataDirForTests,
+  applySessionStatusPatch: () => applySessionStatusPatch,
+  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,
+  updateSessionStatuses: () => updateSessionStatuses,
+  upsertPreviewAttachment: () => upsertPreviewAttachment,
+  upsertProject: () => upsertProject,
+  upsertSession: () => upsertSession
+});
+module.exports = __toCommonJS(attached_projects_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+
+// src/home-paths.ts
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+function sootsimHomeDir() {
+  const override = process.env[SOOTSIM_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
+}
+function electronDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "electron");
+}
+function electronUserDataDir() {
+  return import_node_path.default.join(electronDir(), "userData");
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+
+// src/attached-projects.ts
+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;
+  return electronUserDataDir();
+}
+function getUserDataDir() {
+  return userDataDir();
+}
+function storeFile() {
+  return import_node_path3.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_fs2.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_fs2.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_fs2.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  const fd = import_node_fs2.default.openSync(tmp, "w", 384);
+  try {
+    import_node_fs2.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs2.default.fsyncSync(fd);
+  } finally {
+    import_node_fs2.default.closeSync(fd);
+  }
+  import_node_fs2.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_path3.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_path3.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_path3.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_path3.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 applySessionStatusPatch(existing, patch, now = Date.now()) {
+  return {
+    ...existing,
+    ...patch,
+    id: existing.id,
+    projectId: existing.projectId,
+    createdAt: existing.createdAt,
+    lastSeenAt: now
+  };
+}
+function updateSessionStatuses(updates) {
+  if (updates.length === 0) return;
+  mutateStore((store) => {
+    const now = Date.now();
+    const indexById = new Map(
+      store.agentSessions.map((session, index) => [session.id, index])
+    );
+    for (const { id, patch } of updates) {
+      const idx = indexById.get(id);
+      if (idx === void 0) continue;
+      store.agentSessions[idx] = applySessionStatusPatch(
+        store.agentSessions[idx],
+        patch,
+        now
+      );
+    }
+  });
+}
+function updateSessionStatus(id, patch) {
+  updateSessionStatuses([{ id, patch }]);
+}
+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.simId === input.simId
+    );
+    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,
+      simId: input.simId,
+      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;
+  const { loadOptionalDemoApps: loadOptionalDemoApps2 } = await Promise.resolve().then(() => (init_optional_demo_registry(), optional_demo_registry_exports));
+  const apps = await loadOptionalDemoApps2();
+  if (apps.length === 0) return;
+  mutateStore((store) => {
+    for (const app of apps) {
+      if (!import_node_fs2.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path3.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,
+  applySessionStatusPatch,
+  costThisWeek,
+  deletePreviewAttachment,
+  deleteProject,
+  deleteSession,
+  findProjectByBundleUrl,
+  findProjectByCwd,
+  findProjectById,
+  findSessionById,
+  getUserDataDir,
+  listPreviewAttachments,
+  listProjects,
+  listSessions,
+  loadStore,
+  mutateStore,
+  projectIdForCwd,
+  recordTurnTelemetry,
+  seedFromDemoAppRegistry,
+  setUserDataDir,
+  updateSessionStatus,
+  updateSessionStatuses,
+  upsertPreviewAttachment,
+  upsertProject,
+  upsertSession
+});