@yanlinglabs/winter-agent-sdk 0.0.1 → 0.0.3

package/dist/index-9e98bg1r.js

@@ -0,0 +1,707 @@
+// src/brand.ts
+var BRAND_TOKEN_RE2 = /^[a-z][a-z0-9-]{0,31}$/;
+var DOT_DIR_RE = /^\.[a-z][a-z0-9-]{0,31}$/;
+var INSTRUCTIONS_FILE_RE = /^[A-Z][A-Z0-9_]{0,31}\.md$/;
+var ENV_PREFIX_RE = /^[A-Z][A-Z0-9]{0,15}_$/;
+var KEYCHAIN_SERVICE_RE = /^[a-z][a-z0-9.-]{0,63}$/;
+var MAX_PRODUCT_NAME = 64;
+var CONTROL_BYTE_RE = /[\u0000-\u001f\u007f]/;
+function isHttpsUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  if (CONTROL_BYTE_RE.test(value))
+    return false;
+  return url.protocol === "https:";
+}
+var FIRST_PARTY_ORIGINATORS2 = ["codex", "codex_cli_rs", "openai", "anthropic", "claude", "claude-code"];
+var WINTER_BRAND2 = Object.freeze({
+  productName: "Winter",
+  packageName: "winter-agent-sdk",
+  homeDirName: ".winter",
+  projectDirName: ".winter",
+  instructionsFile: "WINTER.md",
+  envPrefix: "WINTER_",
+  keychainService: "com.winter.core",
+  mcpServerName: "winter",
+  presetName: "winter_code",
+  processLabel: "winter",
+  codexOriginator: "winter",
+  tempRootName: "winter",
+  pluginManifestDir: ".winter-plugin",
+  contactUrl: "https://github.com/yanlingLabs/winter-agent-sdk"
+});
+var FIELD_RULES = [
+  { field: "packageName", re: BRAND_TOKEN_RE2, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
+  { field: "mcpServerName", re: BRAND_TOKEN_RE2, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
+  { field: "processLabel", re: BRAND_TOKEN_RE2, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
+  { field: "tempRootName", re: BRAND_TOKEN_RE2, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
+  { field: "codexOriginator", re: BRAND_TOKEN_RE2, shape: "a lowercase token of 1-32 chars: a letter, then letters/digits/hyphens" },
+  { field: "homeDirName", re: DOT_DIR_RE, shape: "a LEADING DOT then a lowercase token (it names a hidden directory)" },
+  { field: "projectDirName", re: DOT_DIR_RE, shape: "a LEADING DOT then a lowercase token (it names a hidden directory)" },
+  { field: "pluginManifestDir", re: DOT_DIR_RE, shape: "a LEADING DOT then a lowercase token (it names a hidden directory)" },
+  { field: "instructionsFile", re: INSTRUCTIONS_FILE_RE, shape: 'an UPPERCASE name with a `.md` extension, e.g. "ACME.md"' },
+  { field: "envPrefix", re: ENV_PREFIX_RE, shape: 'an UPPERCASE prefix ENDING IN AN UNDERSCORE, e.g. "ACME_"' },
+  { field: "keychainService", re: KEYCHAIN_SERVICE_RE, shape: 'a lowercase reverse-DNS-style service name, e.g. "com.acme.core"' }
+];
+function resolveBrand2(partial) {
+  const p = partial ?? {};
+  const pick = (key) => p[key] === undefined ? WINTER_BRAND2[key] : p[key];
+  const brand = {
+    productName: pick("productName"),
+    packageName: pick("packageName"),
+    homeDirName: pick("homeDirName"),
+    projectDirName: pick("projectDirName"),
+    instructionsFile: pick("instructionsFile"),
+    envPrefix: pick("envPrefix"),
+    keychainService: pick("keychainService"),
+    mcpServerName: pick("mcpServerName"),
+    presetName: pick("presetName"),
+    processLabel: pick("processLabel"),
+    codexOriginator: pick("codexOriginator"),
+    tempRootName: pick("tempRootName"),
+    pluginManifestDir: pick("pluginManifestDir"),
+    contactUrl: pick("contactUrl")
+  };
+  for (const key of Object.keys(brand)) {
+    if (typeof brand[key] !== "string")
+      return { ok: false, reason: `brand.${key}: expected a string, got ${brand[key] === null ? "null" : typeof brand[key]}` };
+  }
+  if (brand.productName.length === 0 || brand.productName.length > MAX_PRODUCT_NAME) {
+    return { ok: false, reason: `brand.productName: expected 1-${MAX_PRODUCT_NAME} characters, got ${brand.productName.length}` };
+  }
+  if (brand.presetName.length === 0)
+    return { ok: false, reason: "brand.presetName: expected a non-empty preset name" };
+  for (const rule of FIELD_RULES) {
+    const value = brand[rule.field];
+    if (!rule.re.test(value))
+      return { ok: false, reason: `brand.${rule.field}: ${JSON.stringify(value)} is not ${rule.shape}` };
+  }
+  if (!isHttpsUrl(brand.contactUrl)) {
+    return {
+      ok: false,
+      reason: `brand.contactUrl: ${JSON.stringify(brand.contactUrl)} is not an https:// URL — it is published to vendors in identity headers as the way to reach whoever runs this client`
+    };
+  }
+  if (FIRST_PARTY_ORIGINATORS2.includes(brand.codexOriginator)) {
+    return {
+      ok: false,
+      reason: `brand.codexOriginator: ${JSON.stringify(brand.codexOriginator)} is a first-party value. ` + `The originator field names the CLIENT, and sending a vendor's own name presents this software as that vendor's tool — ` + `supply your own token instead (one of: ${FIRST_PARTY_ORIGINATORS2.join(", ")} is never it).`
+    };
+  }
+  return { ok: true, brand };
+}
+function envName2(brand, suffix) {
+  return `${brand.envPrefix}${suffix}`;
+}
+function mcpToolName2(brand, tool) {
+  return `mcp__${brand.mcpServerName}__${tool}`;
+}
+function userAgent2(brand, version) {
+  return `${brand.packageName}/${version}`;
+}
+
+// src/paths/home.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function isUnset2(value) {
+  return value === undefined || value.trim() === "";
+}
+function resolveWinterHome2(env, brand) {
+  const b = brand ?? WINTER_BRAND2;
+  const e = env ?? process.env;
+  const override = e[envName2(b, "HOME")];
+  if (!isUnset2(override))
+    return override;
+  const profile = e[envName2(b, "PROFILE")];
+  const dirName = profile !== undefined && profile.trim() === "dev" ? `${b.homeDirName}-dev` : b.homeDirName;
+  return join(homedir(), dirName);
+}
+function resolveKeychainServiceForProfile2(brand, env, hostSetKeychainService) {
+  if (hostSetKeychainService)
+    return brand.keychainService;
+  const profile = (env ?? process.env)[envName2(brand, "PROFILE")];
+  if (profile === undefined || profile.trim() !== "dev")
+    return brand.keychainService;
+  const suffixed = `${brand.keychainService}.dev`;
+  return suffixed.length <= 64 ? suffixed : brand.keychainService;
+}
+
+// src/store/leases.ts
+import { openSync, readFileSync, writeSync, fsyncSync, closeSync, renameSync, linkSync, unlinkSync } from "node:fs";
+
+class WinterStoreError2 extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WinterStoreError";
+  }
+}
+
+class WinterStoreLeaseError2 extends WinterStoreError2 {
+  heldByPid;
+  constructor(message, heldByPid) {
+    super(message);
+    this.heldByPid = heldByPid;
+    this.name = "WinterStoreLeaseError";
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH")
+      return false;
+    if (code === "EPERM")
+      return true;
+    throw err;
+  }
+}
+function writeAllSync(fd, buf) {
+  let written = 0;
+  while (written < buf.length) {
+    written += writeSync(fd, buf, written, buf.length - written);
+  }
+}
+function readLeaseInfo(lockPath) {
+  let raw;
+  try {
+    raw = readFileSync(lockPath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid === "number" && typeof parsed.startTimeMs === "number") {
+      return { pid: parsed.pid, startTimeMs: parsed.startTimeMs };
+    }
+  } catch {}
+  return null;
+}
+function createExclusive(lockPath, info) {
+  const data = Buffer.from(JSON.stringify(info), "utf8");
+  const tmpPath = `${lockPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const fd = openSync(tmpPath, "wx", 384);
+  try {
+    writeAllSync(fd, data);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  try {
+    linkSync(tmpPath, lockPath);
+  } finally {
+    try {
+      unlinkSync(tmpPath);
+    } catch (err) {
+      if (err.code !== "ENOENT")
+        throw err;
+    }
+  }
+}
+function writeLeaseInfoReplacing(lockPath, info) {
+  const data = Buffer.from(JSON.stringify(info), "utf8");
+  const tmpPath = `${lockPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const fd = openSync(tmpPath, "wx", 384);
+  try {
+    writeAllSync(fd, data);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(tmpPath, lockPath);
+}
+function acquireLease(lockPath) {
+  const fresh = { pid: process.pid, startTimeMs: Date.now() };
+  try {
+    createExclusive(lockPath, fresh);
+    return fresh;
+  } catch (err) {
+    if (err.code !== "EEXIST")
+      throw err;
+  }
+  const existing = readLeaseInfo(lockPath);
+  if (existing !== null && existing.pid === process.pid) {
+    return existing;
+  }
+  if (existing !== null && isPidAlive(existing.pid)) {
+    throw new WinterStoreLeaseError2(`session lease is held by another live process (pid ${existing.pid}); refusing a concurrent writer`, existing.pid);
+  }
+  writeLeaseInfoReplacing(lockPath, fresh);
+  return fresh;
+}
+
+// src/store/session-store.ts
+import {
+  mkdirSync,
+  lstatSync,
+  chmodSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync,
+  openSync as openSync2,
+  fsyncSync as fsyncSync2,
+  closeSync as closeSync2,
+  renameSync as renameSync2,
+  rmSync,
+  ftruncateSync,
+  constants as fsConstants
+} from "node:fs";
+import { randomUUID } from "node:crypto";
+import { join as join2 } from "node:path";
+var DIALECT_RECORD_ENTRY_TYPE2 = "winter_dialect_record";
+var PROVIDER_STATE_FILE_SUFFIX2 = ".provider-state.jsonl";
+function assertSafeSingleSegment(value, label) {
+  if (value === "")
+    throw new WinterStoreError2(`${label} must not be empty`);
+  if (value.includes("/"))
+    throw new WinterStoreError2(`${label} must not contain a path separator: ${JSON.stringify(value)}`);
+  if (value === "." || value === "..")
+    throw new WinterStoreError2(`${label} must not be a traversal segment: ${JSON.stringify(value)}`);
+}
+function assertSafeSubpath(value) {
+  if (value === "")
+    throw new WinterStoreError2("subpath must not be empty");
+  if (value.startsWith("/"))
+    throw new WinterStoreError2(`subpath must not be absolute: ${JSON.stringify(value)}`);
+  const segments = value.split("/");
+  for (const segment of segments) {
+    if (segment === "") {
+      throw new WinterStoreError2(`subpath must not contain empty segments (double/trailing separators): ${JSON.stringify(value)}`);
+    }
+    if (segment === "." || segment === "..") {
+      throw new WinterStoreError2(`subpath must not contain a traversal segment: ${JSON.stringify(value)}`);
+    }
+  }
+  return segments;
+}
+function projectDir(winterHome, projectKey) {
+  return join2(winterHome, "projects", projectKey);
+}
+function sessionStem(winterHome, projectKey, sessionId) {
+  assertSafeSingleSegment(projectKey, "projectKey");
+  assertSafeSingleSegment(sessionId, "sessionId");
+  return join2(projectDir(winterHome, projectKey), sessionId);
+}
+function locateResource(winterHome, key) {
+  assertSafeSingleSegment(key.projectKey, "projectKey");
+  assertSafeSingleSegment(key.sessionId, "sessionId");
+  const projDir = projectDir(winterHome, key.projectKey);
+  const dirLevels = [winterHome, join2(winterHome, "projects"), projDir];
+  if (key.subpath === undefined) {
+    return { dirLevels, stem: join2(projDir, key.sessionId) };
+  }
+  const segments = assertSafeSubpath(key.subpath);
+  let current = join2(projDir, key.sessionId);
+  dirLevels.push(current);
+  for (let i = 0;i < segments.length - 1; i++) {
+    current = join2(current, segments[i]);
+    dirLevels.push(current);
+  }
+  const stem = join2(current, segments[segments.length - 1]);
+  return { dirLevels, stem };
+}
+function realUid() {
+  return process.getuid();
+}
+function ensureSecureDir(path) {
+  try {
+    mkdirSync(path, { mode: 448 });
+  } catch (err) {
+    if (err.code !== "EEXIST")
+      throw err;
+  }
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink())
+    throw new WinterStoreError2(`refusing a symlink at a level the store must own: ${path}`);
+  if (!stat.isDirectory())
+    throw new WinterStoreError2(`expected a directory, found something else at: ${path}`);
+  if (stat.uid !== realUid())
+    throw new WinterStoreError2(`refusing a directory owned by a different uid: ${path}`);
+  chmodSync(path, 448);
+}
+var APPEND_FLAGS = fsConstants.O_WRONLY | fsConstants.O_APPEND | fsConstants.O_CREAT | fsConstants.O_NOFOLLOW;
+var RW_EXISTING_FLAGS = fsConstants.O_RDWR | fsConstants.O_NOFOLLOW;
+function appendLinesAtomically(path, lines) {
+  const data = Buffer.from(lines.map((l) => l + `
+`).join(""), "utf8");
+  const fd = openSync2(path, APPEND_FLAGS, 384);
+  try {
+    writeAllSync(fd, data);
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  chmodSync(path, 384);
+}
+function quarantineTornTail(jsonlPath, tornRaw) {
+  const quarantinePath = `${jsonlPath}.tail-quarantine`;
+  const fd = openSync2(quarantinePath, APPEND_FLAGS, 384);
+  try {
+    writeAllSync(fd, tornRaw);
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  chmodSync(quarantinePath, 384);
+}
+function repairTruncate(jsonlPath, keepBytes) {
+  const fd = openSync2(jsonlPath, RW_EXISTING_FLAGS);
+  try {
+    ftruncateSync(fd, keepBytes);
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+}
+function writeJsonAtomically(path, value) {
+  const data = Buffer.from(JSON.stringify(value), "utf8");
+  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const fd = openSync2(tmpPath, "wx", 384);
+  try {
+    writeAllSync(fd, data);
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  renameSync2(tmpPath, path);
+  chmodSync(path, 384);
+}
+function readJsonIfExists(path) {
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    throw err;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function rmIfExists(path) {
+  try {
+    rmSync(path);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+  }
+}
+var NEWLINE = 10;
+function isParseableJson(text) {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function decodeCompleteLines(buf) {
+  if (buf.length === 0)
+    return [];
+  const lines = buf.toString("utf8").split(`
+`);
+  lines.pop();
+  return lines.map((line) => JSON.parse(line));
+}
+function parseWithTailRepair(buf) {
+  if (buf.length === 0)
+    return { entries: [], torn: null };
+  const endsWithNewline = buf[buf.length - 1] === NEWLINE;
+  if (endsWithNewline) {
+    const searchEnd = buf.length - 2;
+    const prevNL = searchEnd < 0 ? -1 : buf.lastIndexOf(NEWLINE, searchEnd);
+    const lastLineStart = prevNL + 1;
+    const lastLine = buf.subarray(lastLineStart, buf.length - 1).toString("utf8");
+    if (isParseableJson(lastLine)) {
+      return { entries: decodeCompleteLines(buf), torn: null };
+    }
+    const keepBytes = lastLineStart;
+    const tornRaw = Buffer.from(buf.subarray(lastLineStart));
+    return { entries: decodeCompleteLines(buf.subarray(0, keepBytes)), torn: { raw: tornRaw, keepBytes } };
+  }
+  const lastNL = buf.lastIndexOf(NEWLINE);
+  const keepBytes = lastNL + 1;
+  const tornRaw = Buffer.from(buf.subarray(keepBytes));
+  return { entries: decodeCompleteLines(buf.subarray(0, keepBytes)), torn: { raw: tornRaw, keepBytes } };
+}
+function hasLiveForeignLeaseHolder(lockPath) {
+  const lease = readLeaseInfo(lockPath);
+  return lease !== null && lease.pid !== process.pid && isPidAlive(lease.pid);
+}
+function walkResourceStems(dir, prefix, out) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  for (const dirent of entries) {
+    const relPath = prefix === "" ? dirent.name : `${prefix}/${dirent.name}`;
+    if (dirent.isDirectory()) {
+      walkResourceStems(join2(dir, dirent.name), relPath, out);
+    } else if (dirent.isFile() && dirent.name.endsWith(".jsonl")) {
+      out.add(relPath.slice(0, -".jsonl".length));
+    } else if (dirent.isFile() && dirent.name.endsWith(".meta.json")) {
+      out.add(relPath.slice(0, -".meta.json".length));
+    }
+  }
+}
+function foldSummary(summaryPath, sessionId, newEntries, dialectExtra) {
+  const previous = readJsonIfExists(summaryPath) ?? {};
+  const mechanical = {};
+  if (newEntries.length > 0) {
+    const lastEntry = newEntries[newEntries.length - 1];
+    mechanical.entryCount = (previous.entryCount ?? 0) + newEntries.length;
+    mechanical.lastEntryType = lastEntry.type;
+    if (lastEntry.timestamp !== undefined)
+      mechanical.lastTimestamp = lastEntry.timestamp;
+  }
+  const updated = {
+    ...previous,
+    ...dialectExtra,
+    sessionId,
+    ...mechanical,
+    mtime: Date.now()
+  };
+  writeJsonAtomically(summaryPath, updated);
+}
+
+class WinterCompatibilitySessionStore2 {
+  winterHome;
+  constructor(opts) {
+    this.winterHome = opts.winterHome;
+  }
+  async append(key, entries) {
+    if (entries.length === 0)
+      return;
+    const { dirLevels, stem } = locateResource(this.winterHome, key);
+    for (const level of dirLevels)
+      ensureSecureDir(level);
+    const lockPath = `${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.lock`;
+    acquireLease(lockPath);
+    chmodSync(lockPath, 384);
+    const jsonlPath = `${stem}.jsonl`;
+    const metaPath = `${stem}.meta.json`;
+    const nativeEntries = [];
+    let latestMetadata;
+    let dialectExtra;
+    for (const e of entries) {
+      if (e.type === "agent_metadata") {
+        latestMetadata = e;
+      } else if (e.type === DIALECT_RECORD_ENTRY_TYPE2) {
+        const { type: _type, ...fields } = e;
+        dialectExtra = fields;
+      } else {
+        nativeEntries.push(e);
+      }
+    }
+    if (nativeEntries.length > 0) {
+      appendLinesAtomically(jsonlPath, nativeEntries.map((e) => JSON.stringify(e)));
+    }
+    if (latestMetadata !== undefined) {
+      writeJsonAtomically(metaPath, latestMetadata);
+    }
+    if (key.subpath === undefined && (nativeEntries.length > 0 || dialectExtra !== undefined)) {
+      foldSummary(`${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.summary.json`, key.sessionId, nativeEntries, dialectExtra);
+    }
+  }
+  async load(key) {
+    const { stem } = locateResource(this.winterHome, key);
+    const jsonlPath = `${stem}.jsonl`;
+    const metaPath = `${stem}.meta.json`;
+    let raw;
+    try {
+      raw = readFileSync2(jsonlPath);
+    } catch (err) {
+      if (err.code !== "ENOENT")
+        throw err;
+      raw = null;
+    }
+    if (raw === null) {
+      const meta = readJsonIfExists(metaPath);
+      return meta === null ? null : [meta];
+    }
+    const { entries, torn } = parseWithTailRepair(raw);
+    if (torn !== null) {
+      const lockPath = `${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.lock`;
+      if (!hasLiveForeignLeaseHolder(lockPath)) {
+        quarantineTornTail(jsonlPath, torn.raw);
+        repairTruncate(jsonlPath, torn.keepBytes);
+      }
+    }
+    const meta = readJsonIfExists(metaPath);
+    if (meta !== null)
+      entries.push(meta);
+    return entries;
+  }
+  async listSessions(projectKey) {
+    assertSafeSingleSegment(projectKey, "projectKey");
+    const dir = projectDir(this.winterHome, projectKey);
+    let names;
+    try {
+      names = readdirSync(dir);
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return [];
+      throw err;
+    }
+    const result = [];
+    const seenSessionIds = new Set;
+    for (const name of names) {
+      if (!name.endsWith(".jsonl"))
+        continue;
+      const full = join2(dir, name);
+      const stat = statSync(full);
+      if (!stat.isFile())
+        continue;
+      const sessionId = name.slice(0, -".jsonl".length);
+      seenSessionIds.add(sessionId);
+      result.push({ sessionId, mtime: stat.mtimeMs });
+    }
+    for (const name of names) {
+      if (!name.endsWith(".meta.json"))
+        continue;
+      const sessionId = name.slice(0, -".meta.json".length);
+      if (seenSessionIds.has(sessionId))
+        continue;
+      const full = join2(dir, name);
+      const stat = statSync(full);
+      if (!stat.isFile())
+        continue;
+      seenSessionIds.add(sessionId);
+      result.push({ sessionId, mtime: stat.mtimeMs });
+    }
+    return result;
+  }
+  async listSessionSummaries(projectKey) {
+    assertSafeSingleSegment(projectKey, "projectKey");
+    const dir = projectDir(this.winterHome, projectKey);
+    let names;
+    try {
+      names = readdirSync(dir);
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return [];
+      throw err;
+    }
+    const result = [];
+    for (const name of names) {
+      if (!name.endsWith(".summary.json"))
+        continue;
+      const parsed = readJsonIfExists(join2(dir, name));
+      if (parsed !== null)
+        result.push(parsed);
+    }
+    return result;
+  }
+  async delete(key) {
+    const { stem } = locateResource(this.winterHome, key);
+    if (key.subpath === undefined) {
+      rmIfExists(`${stem}.jsonl`);
+      rmIfExists(`${stem}.jsonl.tail-quarantine`);
+      rmIfExists(`${stem}.lock`);
+      rmIfExists(`${stem}.summary.json`);
+      rmIfExists(`${stem}.meta.json`);
+      rmIfExists(`${stem}${PROVIDER_STATE_FILE_SUFFIX2}`);
+      rmSync(stem, { recursive: true, force: true });
+    } else {
+      rmIfExists(`${stem}.jsonl`);
+      rmIfExists(`${stem}.jsonl.tail-quarantine`);
+      rmIfExists(`${stem}.meta.json`);
+      rmIfExists(`${stem}${PROVIDER_STATE_FILE_SUFFIX2}`);
+    }
+  }
+  async listSubkeys(key) {
+    const sessionDir = sessionStem(this.winterHome, key.projectKey, key.sessionId);
+    const results = new Set;
+    walkResourceStems(sessionDir, "", results);
+    return [...results];
+  }
+  async listProjectKeys() {
+    const dir = join2(this.winterHome, "projects");
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return [];
+      throw err;
+    }
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  }
+  async copyProviderStateForFork(src, dest) {
+    const { stem: srcStem } = locateResource(this.winterHome, src);
+    const { stem: destStem, dirLevels } = locateResource(this.winterHome, dest);
+    let raw;
+    try {
+      raw = readFileSync2(`${srcStem}${PROVIDER_STATE_FILE_SUFFIX2}`, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return 0;
+      throw err;
+    }
+    const lines = [];
+    for (const line of raw.split(`
+`)) {
+      if (line.length === 0)
+        continue;
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (typeof record !== "object" || record === null || Array.isArray(record))
+        continue;
+      lines.push(JSON.stringify({ ...record, uuid: randomUUID(), sessionId: dest.sessionId }));
+    }
+    if (lines.length === 0)
+      return 0;
+    for (const level of dirLevels)
+      ensureSecureDir(level);
+    appendLinesAtomically(`${destStem}${PROVIDER_STATE_FILE_SUFFIX2}`, lines);
+    return lines.length;
+  }
+  async readSessionSummary(key) {
+    assertSafeSingleSegment(key.projectKey, "projectKey");
+    assertSafeSingleSegment(key.sessionId, "sessionId");
+    return readJsonIfExists(`${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.summary.json`);
+  }
+  async mergeSessionMetadata(key, patch) {
+    const stem = sessionStem(this.winterHome, key.projectKey, key.sessionId);
+    const lockPath = `${stem}.lock`;
+    acquireLease(lockPath);
+    chmodSync(lockPath, 384);
+    const summaryPath = `${stem}.summary.json`;
+    const previous = readJsonIfExists(summaryPath) ?? {};
+    const updated = {
+      ...previous,
+      ...patch,
+      sessionId: key.sessionId,
+      mtime: Date.now()
+    };
+    writeJsonAtomically(summaryPath, updated);
+  }
+  async acquireSessionLease(key) {
+    const { dirLevels } = locateResource(this.winterHome, key);
+    for (const level of dirLevels)
+      ensureSecureDir(level);
+    const lockPath = `${sessionStem(this.winterHome, key.projectKey, key.sessionId)}.lock`;
+    acquireLease(lockPath);
+    chmodSync(lockPath, 384);
+  }
+}
+
+export { BRAND_TOKEN_RE2, FIRST_PARTY_ORIGINATORS2, WINTER_BRAND2, resolveBrand2, envName2, mcpToolName2, userAgent2, isUnset2, resolveWinterHome2, resolveKeychainServiceForProfile2, WinterStoreError2, WinterStoreLeaseError2, DIALECT_RECORD_ENTRY_TYPE2, PROVIDER_STATE_FILE_SUFFIX2, WinterCompatibilitySessionStore2 };