@yawlabs/mcp 0.58.0 → 0.58.1

package/dist/chunk-C3WU6HAG.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+
+// src/team-sync.ts
+import { existsSync } from "fs";
+import { chmod, readFile, unlink as unlink2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join } from "path";
+
+// src/atomic-write.ts
+import { mkdir, rename, unlink, writeFile } from "fs/promises";
+import path from "path";
+async function atomicWriteFile(filePath, contents, encoding = "utf8") {
+  const dir = path.dirname(filePath);
+  const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await mkdir(dir, { recursive: true });
+  try {
+    await writeFile(tmp, contents, encoding);
+    await rename(tmp, filePath);
+  } catch (err) {
+    await unlink(tmp).catch(() => void 0);
+    throw err;
+  }
+}
+
+// src/logger.ts
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var minLevel = LOG_LEVELS[process.env.LOG_LEVEL?.toLowerCase()] ?? LOG_LEVELS.info;
+function log(level, msg, data) {
+  if (LOG_LEVELS[level] < minLevel) return;
+  const entry = JSON.stringify({ level, msg, ts: (/* @__PURE__ */ new Date()).toISOString(), ...data });
+  process.stderr.write(`${entry}
+`);
+}
+
+// src/paths.ts
+import { access } from "fs/promises";
+import { homedir } from "os";
+import path2 from "path";
+function cacheDir() {
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    const base = localAppData && localAppData.length > 0 ? localAppData : path2.join(homedir(), "AppData", "Local");
+    return path2.join(base, "yaw-mcp", "Cache");
+  }
+  if (process.platform === "darwin") {
+    return path2.join(homedir(), "Library", "Caches", "yaw-mcp");
+  }
+  const xdg = process.env.XDG_CACHE_HOME;
+  return path2.join(xdg && xdg.length > 0 ? xdg : path2.join(homedir(), ".cache"), "yaw-mcp");
+}
+var CONFIG_DIRNAME = ".yaw-mcp";
+function userConfigDir(home = homedir()) {
+  return path2.join(home, CONFIG_DIRNAME);
+}
+async function findProjectConfigDir(start, home = homedir()) {
+  const homeResolved = path2.resolve(home);
+  let dir = path2.resolve(start);
+  let prev = "";
+  while (dir !== prev) {
+    if (dir === homeResolved) return null;
+    const candidate = path2.join(dir, CONFIG_DIRNAME);
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+    prev = dir;
+    dir = path2.dirname(dir);
+  }
+  return null;
+}
+var GUIDE_FILENAME = "YAW-MCP.md";
+function guidePath(configDir) {
+  return path2.join(configDir, GUIDE_FILENAME);
+}
+
+// src/team-sync.ts
+var BASE_URL_DEFAULT = "https://yaw.sh";
+var COOKIE_NAME = "yaw_team";
+var REQUEST_TIMEOUT_MS = 15e3;
+var SESSION_STATE_FILENAME = "team-session.json";
+var TeamSyncAuthError = class extends Error {
+  constructor(message = "Not signed in.") {
+    super(message);
+    this.name = "TeamSyncAuthError";
+  }
+};
+var TeamSyncForbiddenError = class extends Error {
+  constructor(message = "You do not have permission to edit this resource.") {
+    super(message);
+    this.name = "TeamSyncForbiddenError";
+  }
+};
+var TeamSyncStaleVersionError = class extends Error {
+  currentVersion;
+  constructor(currentVersion) {
+    super("Your copy is out of date. Pull the latest version and retry.");
+    this.name = "TeamSyncStaleVersionError";
+    this.currentVersion = currentVersion;
+  }
+};
+function sessionStatePath(home = homedir2()) {
+  return join(home, CONFIG_DIRNAME, SESSION_STATE_FILENAME);
+}
+function resolveBaseUrl(env = process.env) {
+  const fromEnv = env.YAW_MCP_TEAM_BASE_URL;
+  return fromEnv && fromEnv.length > 0 ? fromEnv.replace(/\/$/, "") : BASE_URL_DEFAULT;
+}
+function expMs(session) {
+  const e = session.exp;
+  return e > 0 && e < 1e12 ? e * 1e3 : e;
+}
+var cachedState = null;
+function invalidateState() {
+  cachedState = null;
+}
+async function loadStoredState(filePath) {
+  if (cachedState) {
+    const s = cachedState.state;
+    if (s && expMs(s.session) < Date.now()) {
+      cachedState = { state: null };
+      return null;
+    }
+    return s;
+  }
+  let parsed;
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const obj = JSON.parse(raw);
+    if (!obj || typeof obj !== "object") parsed = null;
+    else if (typeof obj.cookie !== "string" || !obj.cookie) parsed = null;
+    else if (!obj.session || typeof obj.session !== "object") parsed = null;
+    else parsed = obj;
+  } catch {
+    parsed = null;
+  }
+  if (parsed && expMs(parsed.session) < Date.now()) {
+    cachedState = { state: null };
+    return null;
+  }
+  cachedState = { state: parsed };
+  return parsed;
+}
+async function saveStoredState(filePath, state) {
+  cachedState = { state };
+  try {
+    await atomicWriteFile(filePath, JSON.stringify(state, null, 2));
+    if (process.platform !== "win32") {
+      try {
+        await chmod(filePath, 384);
+      } catch {
+      }
+    }
+  } catch (err) {
+    log("warn", "Failed to persist team session", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function clearStoredState(filePath) {
+  invalidateState();
+  try {
+    if (existsSync(filePath)) await unlink2(filePath);
+  } catch {
+  }
+}
+function parseOneSetCookie(line) {
+  const semi = line.indexOf(";");
+  const pair = semi >= 0 ? line.slice(0, semi) : line;
+  const eq = pair.indexOf("=");
+  if (eq < 1) return null;
+  return { name: pair.slice(0, eq).trim(), value: pair.slice(eq + 1).trim() };
+}
+function parseSetCookie(headers) {
+  const getAll = headers.getSetCookie;
+  if (typeof getAll === "function") {
+    for (const line of getAll.call(headers)) {
+      const parsed2 = parseOneSetCookie(line);
+      if (parsed2 && parsed2.name === COOKIE_NAME) return parsed2.value;
+    }
+    return null;
+  }
+  const headerValue = headers.get("set-cookie");
+  if (!headerValue) return null;
+  const parsed = parseOneSetCookie(headerValue);
+  return parsed && parsed.name === COOKIE_NAME ? parsed.value : null;
+}
+async function httpJson(opts) {
+  const baseUrl = opts.baseUrl ?? resolveBaseUrl();
+  const headers = { "Content-Type": "application/json" };
+  if (opts.cookie) headers.Cookie = `${COOKIE_NAME}=${opts.cookie}`;
+  const res = await fetch(`${baseUrl}${opts.path}`, {
+    method: opts.method,
+    headers,
+    body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = {};
+  }
+  const cookie = parseSetCookie(res.headers);
+  return { status: res.status, body, cookie };
+}
+async function signIn(key, opts = {}) {
+  const trimmed = key.trim();
+  if (!trimmed) throw new Error("License key is required.");
+  const baseUrl = opts.baseUrl;
+  const post = await httpJson({
+    method: "POST",
+    path: "/api/team/session",
+    body: { key: trimmed },
+    baseUrl
+  });
+  if (post.status !== 200 || !post.cookie || !post.body.email || !post.body.role || !post.body.order_id) {
+    if (post.body.error) log("warn", "team sign-in failed", { status: post.status, error: post.body.error });
+    throw new TeamSyncAuthError("Sign in failed. Check your license key and try again.");
+  }
+  const get = await httpJson({
+    method: "GET",
+    path: "/api/team/session",
+    cookie: post.cookie,
+    baseUrl
+  });
+  if (get.status !== 200 || !get.body.email || !get.body.role || !get.body.order_id || typeof get.body.exp !== "number") {
+    await httpJson({ method: "POST", path: "/api/team/session/logout", cookie: post.cookie, baseUrl }).catch(
+      () => void 0
+    );
+    throw new TeamSyncAuthError("Sign in succeeded but session check failed.");
+  }
+  const session = {
+    email: get.body.email,
+    role: get.body.role,
+    order_id: get.body.order_id,
+    exp: get.body.exp,
+    can_edit: get.body.can_edit
+  };
+  const filePath = opts.filePath ?? sessionStatePath(opts.home);
+  await saveStoredState(filePath, { cookie: post.cookie, session });
+  return session;
+}
+async function signOut(opts = {}) {
+  const filePath = opts.filePath ?? sessionStatePath(opts.home);
+  const state = await loadStoredState(filePath);
+  if (state) {
+    try {
+      await httpJson({
+        method: "POST",
+        path: "/api/team/session/logout",
+        cookie: state.cookie,
+        baseUrl: opts.baseUrl
+      });
+    } catch {
+    }
+  }
+  await clearStoredState(filePath);
+}
+async function getSession(opts = {}) {
+  const filePath = opts.filePath ?? sessionStatePath(opts.home);
+  const state = await loadStoredState(filePath);
+  return state?.session ?? null;
+}
+async function getResource(name, opts = {}) {
+  const filePath = opts.filePath ?? sessionStatePath(opts.home);
+  const state = await loadStoredState(filePath);
+  if (!state) throw new TeamSyncAuthError();
+  const res = await httpJson({
+    method: "GET",
+    path: `/api/team/resource/${encodeURIComponent(name)}`,
+    cookie: state.cookie,
+    baseUrl: opts.baseUrl
+  });
+  if (res.status === 401) {
+    await clearStoredState(filePath);
+    throw new TeamSyncAuthError();
+  }
+  if (res.status === 403) throw new TeamSyncForbiddenError();
+  if (res.status !== 200) {
+    if (res.body.error) log("warn", "team fetch failed", { name, status: res.status, error: res.body.error });
+    throw new Error(`Team fetch failed (${res.status}).`);
+  }
+  return {
+    version: res.body.version,
+    data: res.body.data,
+    updated_at: res.body.updated_at,
+    updated_by: res.body.updated_by
+  };
+}
+async function putResource(name, version, data, opts = {}) {
+  const filePath = opts.filePath ?? sessionStatePath(opts.home);
+  const state = await loadStoredState(filePath);
+  if (!state) throw new TeamSyncAuthError();
+  const res = await httpJson({
+    method: "PUT",
+    path: `/api/team/resource/${encodeURIComponent(name)}`,
+    body: { version, data },
+    cookie: state.cookie,
+    baseUrl: opts.baseUrl
+  });
+  if (res.status === 401) {
+    await clearStoredState(filePath);
+    throw new TeamSyncAuthError();
+  }
+  if (res.status === 403) throw new TeamSyncForbiddenError();
+  if (res.status === 409) throw new TeamSyncStaleVersionError(res.body.current_version ?? 0);
+  if (res.status !== 200) {
+    if (res.body.error) log("warn", "team write failed", { name, status: res.status, error: res.body.error });
+    throw new Error(`Team write failed (${res.status}).`);
+  }
+  return {
+    version: res.body.version,
+    data: res.body.data,
+    updated_at: res.body.updated_at,
+    updated_by: res.body.updated_by
+  };
+}
+async function postAnalyticsEvent(event, opts = {}) {
+  const filePath = opts.filePath ?? sessionStatePath(opts.home);
+  const state = await loadStoredState(filePath);
+  if (!state) return { ok: false };
+  const res = await httpJson({
+    method: "POST",
+    path: "/api/team/analytics/event",
+    body: event,
+    cookie: state.cookie,
+    baseUrl: opts.baseUrl
+  });
+  if (res.status === 401) {
+    await clearStoredState(filePath);
+    return { ok: false };
+  }
+  return { ok: res.status === 200 };
+}
+async function listAnalyticsEvents(opts = {}) {
+  const filePath = opts.filePath ?? sessionStatePath(opts.home);
+  const state = await loadStoredState(filePath);
+  if (!state) throw new TeamSyncAuthError();
+  const res = await httpJson({
+    method: "GET",
+    path: "/api/team/analytics",
+    cookie: state.cookie,
+    baseUrl: opts.baseUrl
+  });
+  if (res.status === 401) {
+    await clearStoredState(filePath);
+    throw new TeamSyncAuthError();
+  }
+  if (res.status !== 200) {
+    if (res.body.error) log("warn", "team analytics list failed", { status: res.status, error: res.body.error });
+    throw new Error(`Team analytics fetch failed (${res.status}).`);
+  }
+  return { events: res.body.events ?? [], cap: res.body.cap ?? 0, order_id: res.body.order_id ?? "" };
+}
+function _resetForTests() {
+  invalidateState();
+}
+
+export {
+  log,
+  cacheDir,
+  CONFIG_DIRNAME,
+  userConfigDir,
+  findProjectConfigDir,
+  guidePath,
+  atomicWriteFile,
+  SESSION_STATE_FILENAME,
+  TeamSyncAuthError,
+  TeamSyncForbiddenError,
+  TeamSyncStaleVersionError,
+  sessionStatePath,
+  signIn,
+  signOut,
+  getSession,
+  getResource,
+  putResource,
+  postAnalyticsEvent,
+  listAnalyticsEvents,
+  _resetForTests
+};