@tutti-os/auth-bridge 0.0.1

package/README.md

@@ -0,0 +1,28 @@
+# @tutti-os/auth-bridge
+
+High-level Tutti auth helpers for browser apps and Node/Electron clients.
+
+## Browser
+
+```ts
+import { createTuttiBrowserAuthClient } from '@tutti-os/auth-bridge/browser';
+
+const auth = createTuttiBrowserAuthClient();
+
+auth.login();
+const user = await auth.getUserInfo();
+await auth.logout();
+```
+
+## Node
+
+```ts
+import { createTuttiNodeAuthClient } from '@tutti-os/auth-bridge/node';
+
+const auth = createTuttiNodeAuthClient({
+  authJsonPath,
+  appCallbackUrl,
+});
+
+const { session, user } = await auth.login();
+```

package/dist/browser.d.ts

@@ -0,0 +1,20 @@
+import { T as TuttiUserInfo } from './shared-Bm-pnst6.js';
+
+interface TuttiBrowserAuthClientOptions {
+    openUrl?: (url: string) => void;
+    appId?: string;
+    accountBaseUrl?: string;
+    authLoginUrl?: string;
+}
+interface TuttiBrowserLoginOptions {
+    redirectUri?: string;
+    locale?: string;
+}
+interface TuttiBrowserAuthClient {
+    login: (options?: TuttiBrowserLoginOptions) => void;
+    getUserInfo: () => Promise<TuttiUserInfo | null>;
+    logout: () => Promise<void>;
+}
+declare function createTuttiBrowserAuthClient(options?: TuttiBrowserAuthClientOptions): TuttiBrowserAuthClient;
+
+export { type TuttiBrowserAuthClient, type TuttiBrowserAuthClientOptions, type TuttiBrowserLoginOptions, TuttiUserInfo, createTuttiBrowserAuthClient };

package/dist/browser.js

@@ -0,0 +1,72 @@
+import {
+  DEFAULT_ACCOUNT_BASE_URL,
+  DEFAULT_APP_ID,
+  DEFAULT_AUTH_LOGIN_URL,
+  buildAccountUrl,
+  mapUserInfo,
+  readEnvelopeError
+} from "./chunk-B7N5AC4Q.js";
+
+// src/browser.ts
+function defaultOpenUrl(url) {
+  window.location.assign(url);
+}
+function resolveCurrentRedirectUri() {
+  return `${window.location.pathname}${window.location.search}${window.location.hash}` || "/";
+}
+async function readJsonEnvelope(response) {
+  return await response.json().catch(() => null);
+}
+function createTuttiBrowserAuthClient(options = {}) {
+  const appId = options.appId?.trim() || DEFAULT_APP_ID;
+  const accountBaseUrl = options.accountBaseUrl?.trim() || DEFAULT_ACCOUNT_BASE_URL;
+  const authLoginUrl = options.authLoginUrl?.trim() || DEFAULT_AUTH_LOGIN_URL;
+  const openUrl = options.openUrl ?? defaultOpenUrl;
+  return {
+    login(loginOptions = {}) {
+      const url = new URL(authLoginUrl);
+      url.searchParams.set("redirect_uri", loginOptions.redirectUri ?? resolveCurrentRedirectUri());
+      if (loginOptions.locale) {
+        url.searchParams.set("locale", loginOptions.locale);
+      }
+      openUrl(url.toString());
+    },
+    async getUserInfo() {
+      const response = await fetch(buildAccountUrl(accountBaseUrl, "/user/v1/user_info"), {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({})
+      });
+      const payload = await readJsonEnvelope(response);
+      if (response.status === 401 || payload?.code === 401) {
+        return null;
+      }
+      if (!response.ok || payload?.code !== 0) {
+        throw readEnvelopeError(response, payload);
+      }
+      return mapUserInfo(payload.data);
+    },
+    async logout() {
+      const response = await fetch(buildAccountUrl(accountBaseUrl, "/auth/v1/logout-web-session"), {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ appId })
+      });
+      const payload = await readJsonEnvelope(response);
+      if (!response.ok || (payload?.code ?? 0) !== 0) {
+        throw readEnvelopeError(response, payload);
+      }
+    }
+  };
+}
+export {
+  createTuttiBrowserAuthClient
+};

package/dist/chunk-B7N5AC4Q.js

@@ -0,0 +1,55 @@
+// src/shared.ts
+var DEFAULT_APP_ID = "nextop";
+var DEFAULT_ACCOUNT_BASE_URL = "https://tutti.sh/api/account";
+var DEFAULT_AUTH_LOGIN_URL = "https://tutti.sh/auth/login";
+var AUTH_SERVER_HOST = "127.0.0.1";
+var AUTH_SERVER_BASE_PORT = 38473;
+var AUTH_SERVER_MAX_PORT = 38492;
+var DEFAULT_LOGIN_IDLE_TIMEOUT_MS = 9e4;
+var DEFAULT_LOGIN_MAX_TIMEOUT_MS = 5 * 6e4;
+function trimString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function buildSessionCookie(sessionId) {
+  return `session_id=${sessionId.trim()}`;
+}
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/u, "");
+}
+function buildAccountUrl(accountBaseUrl, path) {
+  return `${normalizeBaseUrl(accountBaseUrl)}/${path.replace(/^\/+/u, "")}`;
+}
+function readEnvelopeError(response, payload) {
+  return new Error(payload?.errmsg ?? payload?.message ?? `Request failed with status ${response.status}`);
+}
+function mapUserInfo(data) {
+  if (!data) {
+    return null;
+  }
+  const userId = trimString(data.userId) || trimString(data.user_id);
+  if (!userId) {
+    return null;
+  }
+  return {
+    userId,
+    name: trimString(data.name) || void 0,
+    email: trimString(data.email) || trimString(data.userEmail) || trimString(data.emailAddress) || void 0,
+    avatar: trimString(data.avatar) || trimString(data.picture) || trimString(data.avatarUrl) || trimString(data.headImg) || void 0
+  };
+}
+
+export {
+  DEFAULT_APP_ID,
+  DEFAULT_ACCOUNT_BASE_URL,
+  DEFAULT_AUTH_LOGIN_URL,
+  AUTH_SERVER_HOST,
+  AUTH_SERVER_BASE_PORT,
+  AUTH_SERVER_MAX_PORT,
+  DEFAULT_LOGIN_IDLE_TIMEOUT_MS,
+  DEFAULT_LOGIN_MAX_TIMEOUT_MS,
+  trimString,
+  buildSessionCookie,
+  buildAccountUrl,
+  readEnvelopeError,
+  mapUserInfo
+};

package/dist/node.d.ts

@@ -0,0 +1,31 @@
+import { a as TuttiAuthSession, T as TuttiUserInfo } from './shared-Bm-pnst6.js';
+
+interface TuttiNodeAuthClientOptions {
+    authJsonPath: string;
+    appCallbackUrl: string;
+    openUrl?: (url: string) => Promise<void> | void;
+    appId?: string;
+    accountBaseUrl?: string;
+    authLoginUrl?: string;
+    deviceId?: string;
+    deviceName?: string;
+    clientVersion?: string;
+    hostname?: string;
+    loginIdleTimeoutMs?: number;
+    loginMaxTimeoutMs?: number;
+}
+interface TuttiNodeAuthClient {
+    login: () => Promise<{
+        session: TuttiAuthSession;
+        user: TuttiUserInfo;
+    }>;
+    getUserInfo: () => Promise<TuttiUserInfo | null>;
+    logout: () => Promise<void>;
+    readSession: () => Promise<TuttiAuthSession | null>;
+    clearSession: () => Promise<void>;
+}
+declare function createTuttiNodeAuthClient(options: TuttiNodeAuthClientOptions): TuttiNodeAuthClient;
+declare function readAuthJson(authJsonPath: string): Promise<TuttiAuthSession | null>;
+declare function writeAuthJson(authJsonPath: string, session: TuttiAuthSession): Promise<void>;
+
+export { TuttiAuthSession, type TuttiNodeAuthClient, type TuttiNodeAuthClientOptions, TuttiUserInfo, createTuttiNodeAuthClient, readAuthJson, writeAuthJson };

package/dist/node.js

@@ -0,0 +1,420 @@
+import {
+  AUTH_SERVER_BASE_PORT,
+  AUTH_SERVER_HOST,
+  AUTH_SERVER_MAX_PORT,
+  DEFAULT_ACCOUNT_BASE_URL,
+  DEFAULT_APP_ID,
+  DEFAULT_AUTH_LOGIN_URL,
+  DEFAULT_LOGIN_IDLE_TIMEOUT_MS,
+  DEFAULT_LOGIN_MAX_TIMEOUT_MS,
+  buildAccountUrl,
+  buildSessionCookie,
+  mapUserInfo,
+  readEnvelopeError,
+  trimString
+} from "./chunk-B7N5AC4Q.js";
+
+// src/node.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { createServer } from "http";
+import { createServer as createNetServer } from "net";
+import { hostname } from "os";
+import { dirname } from "path";
+function createTuttiNodeAuthClient(options) {
+  const authJsonPath = options.authJsonPath.trim();
+  const appCallbackUrl = options.appCallbackUrl.trim();
+  if (!authJsonPath) {
+    throw new Error("authJsonPath is required");
+  }
+  if (!appCallbackUrl) {
+    throw new Error("appCallbackUrl is required");
+  }
+  new URL(appCallbackUrl);
+  const appId = options.appId?.trim() || DEFAULT_APP_ID;
+  const accountBaseUrl = options.accountBaseUrl?.trim() || DEFAULT_ACCOUNT_BASE_URL;
+  const authLoginUrl = options.authLoginUrl?.trim() || DEFAULT_AUTH_LOGIN_URL;
+  const openUrl = options.openUrl ?? openUrlWithDefaultBrowser;
+  const idleTimeoutMs = positiveMs(options.loginIdleTimeoutMs, DEFAULT_LOGIN_IDLE_TIMEOUT_MS);
+  const maxTimeoutMs = Math.max(idleTimeoutMs, positiveMs(options.loginMaxTimeoutMs, DEFAULT_LOGIN_MAX_TIMEOUT_MS));
+  async function readSession() {
+    return await readAuthJson(authJsonPath);
+  }
+  async function clearSession() {
+    await rm(authJsonPath, { force: true });
+  }
+  async function getUserInfo() {
+    const session = await readSession();
+    if (!session) {
+      return null;
+    }
+    const user = await fetchUserInfo(accountBaseUrl, session.cookie);
+    if (!user) {
+      return null;
+    }
+    await writeAuthJson(authJsonPath, sessionFromUser(session.sessionId, user));
+    return user;
+  }
+  return {
+    async login() {
+      const port = await findAvailablePort();
+      const localServerOrigin = `http://${AUTH_SERVER_HOST}:${port}`;
+      const attemptId = randomUUID();
+      const bridgeToken = randomUUID();
+      const deviceId = options.deviceId?.trim() || randomUUID();
+      const now = Date.now();
+      const state = encodeBridgeState({
+        v: 1,
+        flow: "desktop_bridge",
+        attemptId,
+        localServerOrigin,
+        bridgeToken,
+        appId,
+        appCallbackUrl,
+        deviceId,
+        deviceName: options.deviceName?.trim() || hostname() || "Desktop",
+        clientVersion: options.clientVersion?.trim() || void 0,
+        hostname: options.hostname?.trim() || hostname()
+      });
+      const pending = {
+        accountBaseUrl,
+        appId,
+        appCallbackUrl,
+        attemptId,
+        authOrigin: new URL(authLoginUrl).origin,
+        bridgeToken,
+        completed: false,
+        deviceId,
+        expiresAt: now + maxTimeoutMs,
+        idleTimeoutMs,
+        localServerOrigin,
+        maxExpiresAt: now + maxTimeoutMs,
+        state
+      };
+      const bridge = await createLoginBridgeServer(pending, port);
+      const loginUrl = buildLoginUrl(authLoginUrl, state);
+      const completion = waitForCompletion(pending, bridge.waitForCompletion);
+      void completion.catch(() => void 0);
+      try {
+        await openUrl(loginUrl);
+        const transferCode = await completion;
+        const sessionId = await redeemDesktopTransferCode(pending, transferCode);
+        const user = await fetchUserInfo(accountBaseUrl, buildSessionCookie(sessionId));
+        if (!user) {
+          throw new Error("Failed to load user info after login");
+        }
+        const session = sessionFromUser(sessionId, user);
+        await writeAuthJson(authJsonPath, session);
+        return { session, user };
+      } finally {
+        await closeServer(bridge.server);
+      }
+    },
+    getUserInfo,
+    logout: async () => {
+      const session = await readSession();
+      if (session) {
+        await logoutSession(accountBaseUrl, appId, session.cookie);
+      }
+      await clearSession();
+    },
+    readSession,
+    clearSession
+  };
+}
+async function readAuthJson(authJsonPath) {
+  try {
+    const parsed = JSON.parse(await readFile(authJsonPath, "utf8"));
+    const sessionId = trimString(parsed.sessionId) || trimString(parsed.session_id);
+    if (!sessionId) {
+      return null;
+    }
+    return {
+      sessionId,
+      cookie: trimString(parsed.cookie) || buildSessionCookie(sessionId),
+      userId: trimString(parsed.userId) || trimString(parsed.user_id),
+      name: trimString(parsed.name),
+      avatar: trimString(parsed.avatar),
+      email: trimString(parsed.email),
+      updatedAt: typeof parsed.updatedAt === "number" && Number.isFinite(parsed.updatedAt) ? parsed.updatedAt : Date.now()
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeAuthJson(authJsonPath, session) {
+  await mkdir(dirname(authJsonPath), { recursive: true });
+  const payload = {
+    session_id: session.sessionId,
+    cookie: session.cookie,
+    user_id: session.userId,
+    name: session.name,
+    avatar: session.avatar,
+    email: session.email,
+    updatedAt: session.updatedAt
+  };
+  const tempPath = `${authJsonPath}.tmp-${process.pid}-${Date.now()}-${randomUUID()}`;
+  try {
+    await writeFile(tempPath, JSON.stringify(payload, null, 2), { encoding: "utf8", mode: 384 });
+    await rename(tempPath, authJsonPath);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function encodeBridgeState(state) {
+  return Buffer.from(JSON.stringify(state), "utf8").toString("base64url");
+}
+function decodeBridgeState(rawState) {
+  try {
+    const parsed = JSON.parse(Buffer.from(rawState, "base64url").toString("utf8"));
+    if (parsed.v !== 1 || parsed.flow !== "desktop_bridge" || !trimString(parsed.attemptId) || !trimString(parsed.localServerOrigin) || !trimString(parsed.bridgeToken)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function buildLoginUrl(authLoginUrl, state) {
+  const url = new URL(authLoginUrl);
+  url.pathname = "/auth/login";
+  url.search = "";
+  url.hash = "";
+  url.searchParams.set("state", state);
+  return url.toString();
+}
+function stateMatches(input, rawState) {
+  const state = decodeBridgeState(rawState);
+  return !input.completed && Date.now() <= input.maxExpiresAt && state?.attemptId === input.attemptId && state.bridgeToken === input.bridgeToken && state.localServerOrigin === input.localServerOrigin && (state.appId ?? "") === input.appId;
+}
+async function createLoginBridgeServer(input, port) {
+  let resolveCompletion;
+  let rejectCompletion;
+  let completed = false;
+  const waitForCompletion2 = new Promise((resolve, reject) => {
+    resolveCompletion = resolve;
+    rejectCompletion = reject;
+  });
+  const complete = (fn) => {
+    if (completed) {
+      return;
+    }
+    completed = true;
+    fn();
+  };
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", input.localServerOrigin);
+    if (req.method === "OPTIONS") {
+      if (!isAllowedBridgeOrigin(req, input) || !isAllowedLoopbackHost(req, port)) {
+        res.writeHead(403);
+        res.end();
+        return;
+      }
+      sendCors(res, 204);
+      return;
+    }
+    if (req.method === "GET" && url.pathname === "/oauth/health") {
+      const matched = !input.completed && Date.now() <= input.expiresAt && Date.now() <= input.maxExpiresAt && url.searchParams.get("attempt_id") === input.attemptId && url.searchParams.get("token") === input.bridgeToken;
+      if (!matched) {
+        sendJson(res, 401, { ok: false, error: { code: "INVALID_BRIDGE_ATTEMPT", message: "Desktop login attempt is unavailable." } });
+        return;
+      }
+      input.expiresAt = Math.min(input.maxExpiresAt, Date.now() + input.idleTimeoutMs);
+      sendJson(res, 200, { ok: true, data: { attemptId: input.attemptId, status: "ready", expiresAt: input.expiresAt } });
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/oauth/complete") {
+      if (!isAllowedBridgeOrigin(req, input) || !isAllowedLoopbackHost(req, port)) {
+        sendJson(res, 403, { ok: false, error: { code: "FORBIDDEN_BRIDGE_ORIGIN", message: "Bridge origin is not allowed." } });
+        return;
+      }
+      const payload = await readJsonBody(req).catch(() => ({}));
+      const callbackError = trimString(payload.error);
+      const callbackState = trimString(payload.state);
+      const transferCode = trimString(payload.transfer_code) || trimString(payload.transferCode);
+      if (!stateMatches(input, callbackState)) {
+        const error = new Error("Invalid state");
+        sendJson(res, 400, { ok: false, error: { code: "INVALID_STATE", message: error.message } });
+        complete(() => rejectCompletion(error));
+        return;
+      }
+      if (callbackError) {
+        const error = new Error(callbackError);
+        sendJson(res, 400, { ok: false, error: { code: "PROVIDER_CALLBACK_ERROR", message: error.message } });
+        complete(() => rejectCompletion(error));
+        return;
+      }
+      if (!transferCode) {
+        const error = new Error("Missing transfer_code");
+        sendJson(res, 400, { ok: false, error: { code: "MISSING_TRANSFER_CODE", message: error.message } });
+        complete(() => rejectCompletion(error));
+        return;
+      }
+      input.completed = true;
+      sendJson(res, 200, { ok: true, data: { status: "completed" } });
+      complete(() => resolveCompletion(transferCode));
+      return;
+    }
+    sendJson(res, 404, { ok: false, error: { code: "NOT_FOUND", message: "Not found" } });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, AUTH_SERVER_HOST, () => resolve());
+  });
+  return { server, waitForCompletion: waitForCompletion2 };
+}
+async function waitForCompletion(input, completion) {
+  while (true) {
+    const remainingMs = Math.min(input.expiresAt, input.maxExpiresAt) - Date.now();
+    if (remainingMs <= 0) {
+      throw new Error("Login timed out");
+    }
+    const result = await Promise.race([
+      completion.then((transferCode) => ({ transferCode })),
+      delay(Math.min(remainingMs, 500)).then(() => null)
+    ]);
+    if (result) {
+      return result.transferCode;
+    }
+  }
+}
+async function fetchUserInfo(accountBaseUrl, cookie) {
+  const response = await fetch(buildAccountUrl(accountBaseUrl, "/user/v1/user_info"), {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      Cookie: cookie
+    },
+    body: JSON.stringify({})
+  });
+  const payload = await response.json().catch(() => null);
+  if (response.status === 401 || payload?.code === 401) {
+    return null;
+  }
+  if (!response.ok || payload?.code !== 0) {
+    throw readEnvelopeError(response, payload);
+  }
+  return mapUserInfo(payload.data);
+}
+async function redeemDesktopTransferCode(input, transferCode) {
+  const response = await fetch(buildAccountUrl(input.accountBaseUrl, "/auth/v1/redeem_desktop_transfer_code"), {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      transfer_code: transferCode,
+      attempt_id: input.attemptId,
+      bridge_token: input.bridgeToken,
+      app_id: input.appId,
+      device_id: input.deviceId
+    })
+  });
+  const payload = await response.json().catch(() => null);
+  const sessionId = trimString(payload?.data?.sessionId) || trimString(payload?.data?.session_id);
+  if (!response.ok || payload?.code !== 0 || !sessionId) {
+    throw readEnvelopeError(response, payload);
+  }
+  return sessionId;
+}
+async function logoutSession(accountBaseUrl, appId, cookie) {
+  const response = await fetch(buildAccountUrl(accountBaseUrl, "/auth/v1/logout-web-session"), {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      Cookie: cookie
+    },
+    body: JSON.stringify({ appId })
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || (payload?.code ?? 0) !== 0) {
+    throw readEnvelopeError(response, payload);
+  }
+}
+async function findAvailablePort() {
+  for (let port = AUTH_SERVER_BASE_PORT; port <= AUTH_SERVER_MAX_PORT; port += 1) {
+    const available = await new Promise((resolve) => {
+      const probe = createNetServer();
+      probe.once("error", () => resolve(false));
+      probe.listen(port, AUTH_SERVER_HOST, () => {
+        probe.close(() => resolve(true));
+      });
+    });
+    if (available) {
+      return port;
+    }
+  }
+  throw new Error("unable to allocate localhost auth port");
+}
+function sessionFromUser(sessionId, user) {
+  return {
+    sessionId,
+    cookie: buildSessionCookie(sessionId),
+    userId: user.userId,
+    name: user.name ?? "",
+    avatar: user.avatar ?? "",
+    email: user.email ?? "",
+    updatedAt: Date.now()
+  };
+}
+function positiveMs(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readJsonBody(req) {
+  let raw = "";
+  for await (const chunk of req) {
+    raw += chunk;
+  }
+  return raw ? JSON.parse(raw) : {};
+}
+function sendCors(res, status) {
+  res.writeHead(status, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+    "Access-Control-Allow-Private-Network": "true"
+  });
+  res.end();
+}
+function isAllowedBridgeOrigin(req, input) {
+  const origin = trimString(req.headers.origin);
+  return !origin || origin === input.authOrigin;
+}
+function isAllowedLoopbackHost(req, port) {
+  const host = trimString(req.headers.host).toLowerCase();
+  return host === `${AUTH_SERVER_HOST}:${port}` || host === `localhost:${port}`;
+}
+function sendJson(res, status, payload) {
+  res.writeHead(status, {
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json; charset=utf-8"
+  });
+  res.end(JSON.stringify(payload));
+}
+function closeServer(server) {
+  return new Promise((resolve) => server.close(() => resolve()));
+}
+function openUrlWithDefaultBrowser(url) {
+  const command = process.platform === "darwin" ? { file: "open", args: [url] } : process.platform === "win32" ? { file: "cmd", args: ["/c", "start", "", url] } : { file: "xdg-open", args: [url] };
+  return new Promise((resolve, reject) => {
+    const child = spawn(command.file, command.args, { detached: true, stdio: "ignore", windowsHide: true });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+export {
+  createTuttiNodeAuthClient,
+  readAuthJson,
+  writeAuthJson
+};

package/dist/shared-Bm-pnst6.d.ts

@@ -0,0 +1,17 @@
+interface TuttiUserInfo {
+    userId: string;
+    name?: string;
+    email?: string;
+    avatar?: string;
+}
+interface TuttiAuthSession {
+    sessionId: string;
+    cookie: string;
+    userId: string;
+    name: string;
+    avatar: string;
+    email: string;
+    updatedAt: number;
+}
+
+export type { TuttiUserInfo as T, TuttiAuthSession as a };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tutti-os/auth-bridge",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "types": "./dist/browser.d.ts",
+  "exports": {
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.12.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "type-check": "tsc --noEmit",
+    "test": "pnpm exec tsx --test src/*.test.ts"
+  }
+}