@parix/cli 0.1.5

package/dist/lib/oauth-session.d.cts

@@ -0,0 +1,32 @@
+import type { OAuthTokenSet } from "./oauth-api.cjs";
+import type { StoredSession } from "./session.cjs";
+export declare function createStoredSession(input: {
+    baseUrl: string;
+    createdAt?: string;
+    tokenSet: OAuthTokenSet;
+}): Promise<{
+    version: 2;
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    baseUrl: string;
+    createdAt: string;
+    refreshToken: string | null;
+    scopes: string[];
+    tokenType: string;
+    updatedAt: string;
+    user: {
+        email: string | null;
+        emailVerified: boolean | null;
+        id: string;
+        image: string | null;
+        name: string | null;
+    };
+    organization: {
+        id: string | null;
+        memberRole: string | null;
+        name: string | null;
+        slug: string | null;
+    };
+}>;
+export declare function hydrateStoredSessionOrganization(session: StoredSession): Promise<StoredSession>;
+export declare function ensureFreshSession(session: StoredSession): Promise<StoredSession>;

package/dist/lib/oauth-session.d.ts

@@ -0,0 +1,32 @@
+import type { OAuthTokenSet } from "./oauth-api.js";
+import type { StoredSession } from "./session.js";
+export declare function createStoredSession(input: {
+    baseUrl: string;
+    createdAt?: string;
+    tokenSet: OAuthTokenSet;
+}): Promise<{
+    version: 2;
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    baseUrl: string;
+    createdAt: string;
+    refreshToken: string | null;
+    scopes: string[];
+    tokenType: string;
+    updatedAt: string;
+    user: {
+        email: string | null;
+        emailVerified: boolean | null;
+        id: string;
+        image: string | null;
+        name: string | null;
+    };
+    organization: {
+        id: string | null;
+        memberRole: string | null;
+        name: string | null;
+        slug: string | null;
+    };
+}>;
+export declare function hydrateStoredSessionOrganization(session: StoredSession): Promise<StoredSession>;
+export declare function ensureFreshSession(session: StoredSession): Promise<StoredSession>;

package/dist/lib/oauth-session.js

@@ -0,0 +1,103 @@
+import { fetchOAuthUserInfo, refreshOAuthTokens } from "./oauth-api.js";
+import { writeStoredSession } from "./session.js";
+const REFRESH_BUFFER_MS = 60_000;
+export async function createStoredSession(input) {
+    const now = new Date();
+    const [userInfo, resolvedOrganization] = await Promise.all([
+        fetchOAuthUserInfo({
+            accessToken: input.tokenSet.accessToken,
+            baseUrl: input.baseUrl,
+        }),
+        fetchResolvedSessionOrganization({
+            accessToken: input.tokenSet.accessToken,
+            baseUrl: input.baseUrl,
+        }).catch(() => null),
+    ]);
+    return {
+        version: 2,
+        accessToken: input.tokenSet.accessToken,
+        accessTokenExpiresAt: new Date(now.getTime() + input.tokenSet.expiresIn * 1000).toISOString(),
+        baseUrl: input.baseUrl,
+        createdAt: input.createdAt ?? now.toISOString(),
+        refreshToken: input.tokenSet.refreshToken,
+        scopes: input.tokenSet.scope,
+        tokenType: input.tokenSet.tokenType,
+        updatedAt: now.toISOString(),
+        user: {
+            email: userInfo.email ?? null,
+            emailVerified: userInfo.email_verified ?? null,
+            id: userInfo.sub,
+            image: userInfo.picture ?? null,
+            name: userInfo.name ?? null,
+        },
+        organization: {
+            id: resolvedOrganization?.id ?? userInfo.organization_id ?? null,
+            memberRole: resolvedOrganization?.memberRole ?? userInfo.member_role ?? null,
+            name: resolvedOrganization?.name ?? userInfo.organization_name ?? null,
+            slug: resolvedOrganization?.slug ?? userInfo.organization_slug ?? null,
+        },
+    };
+}
+export async function hydrateStoredSessionOrganization(session) {
+    const resolvedOrganization = await fetchResolvedSessionOrganization({
+        accessToken: session.accessToken,
+        baseUrl: session.baseUrl,
+    }).catch(() => null);
+    if (!resolvedOrganization || organizationsEqual(session.organization, resolvedOrganization)) {
+        return session;
+    }
+    const nextSession = {
+        ...session,
+        organization: resolvedOrganization,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeStoredSession(nextSession);
+    return nextSession;
+}
+export async function ensureFreshSession(session) {
+    if (!shouldRefresh(session)) {
+        return session;
+    }
+    if (!session.refreshToken) {
+        throw new Error('The local session has expired and cannot be refreshed. Run `parix auth login` again.');
+    }
+    const refreshedTokens = await refreshOAuthTokens({
+        baseUrl: session.baseUrl,
+        refreshToken: session.refreshToken,
+    });
+    const updatedSession = await createStoredSession({
+        baseUrl: session.baseUrl,
+        createdAt: session.createdAt,
+        tokenSet: refreshedTokens,
+    });
+    await writeStoredSession(updatedSession);
+    return updatedSession;
+}
+function shouldRefresh(session) {
+    const expiresAt = Date.parse(session.accessTokenExpiresAt);
+    return Number.isNaN(expiresAt) || expiresAt <= Date.now() + REFRESH_BUFFER_MS;
+}
+async function fetchResolvedSessionOrganization(input) {
+    const response = await fetch(new URL('/api/v1/session', input.baseUrl), {
+        headers: {
+            authorization: `Bearer ${input.accessToken}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error('Unable to resolve the authenticated organization.');
+    }
+    const payload = (await response.json());
+    const organization = payload.auth?.organization;
+    if (!organization) {
+        return null;
+    }
+    return {
+        id: typeof organization.id === 'string' ? organization.id : null,
+        memberRole: typeof organization.memberRole === 'string' ? organization.memberRole : null,
+        name: typeof organization.name === 'string' ? organization.name : null,
+        slug: typeof organization.slug === 'string' ? organization.slug : null,
+    };
+}
+function organizationsEqual(left, right) {
+    return (left.id === right.id && left.memberRole === right.memberRole && left.name === right.name && left.slug === right.slug);
+}

package/dist/lib/oauth.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARIX_DEFAULT_SCOPES = exports.CLI_OAUTH_CONSENT_GRANTED_PATH = exports.PARIX_LOCAL_CALLBACK_PATH = exports.PARIX_CLIENT_ID = void 0;
+exports.createPkcePair = createPkcePair;
+exports.buildAuthorizeUrl = buildAuthorizeUrl;
+exports.buildCliState = buildCliState;
+exports.buildOAuthCallbackUrl = buildOAuthCallbackUrl;
+exports.buildOAuthTokenUrl = buildOAuthTokenUrl;
+exports.buildOAuthUserInfoUrl = buildOAuthUserInfoUrl;
+const node_buffer_1 = require("node:buffer");
+const node_crypto_1 = require("node:crypto");
+const config_1 = require("./config.cjs");
+exports.PARIX_CLIENT_ID = 'parix';
+exports.PARIX_LOCAL_CALLBACK_PATH = '/callback';
+exports.CLI_OAUTH_CONSENT_GRANTED_PATH = '/cli-oauth-consent-granted';
+exports.PARIX_DEFAULT_SCOPES = [
+    'openid',
+    'profile',
+    'email',
+    'offline_access',
+    'org:read',
+    'db:read',
+    'db:write',
+    'billing:read',
+];
+function createPkcePair() {
+    const codeVerifier = (0, node_crypto_1.randomBytes)(32).toString('base64url');
+    const codeChallenge = (0, node_crypto_1.createHash)('sha256').update(codeVerifier).digest('base64url');
+    return {
+        codeChallenge,
+        codeVerifier,
+    };
+}
+function buildAuthorizeUrl(input) {
+    const url = new URL('/api/oauth/cli/authorize', (0, config_1.trimTrailingSlash)(input.baseUrl));
+    url.searchParams.set('state', input.state);
+    url.searchParams.set('code_challenge', input.codeChallenge);
+    url.searchParams.set('code_challenge_method', 'S256');
+    if (input.prompt) {
+        url.searchParams.set('prompt', input.prompt);
+    }
+    return url.toString();
+}
+function buildCliState(redirectUri) {
+    return node_buffer_1.Buffer.from(JSON.stringify({
+        nonce: (0, node_crypto_1.randomBytes)(16).toString('hex'),
+        redirectUri,
+    }), 'utf8').toString('base64url');
+}
+function buildOAuthCallbackUrl(baseUrl) {
+    return new URL('/api/oauth/cli/callback', (0, config_1.trimTrailingSlash)(baseUrl)).toString();
+}
+function buildOAuthTokenUrl(baseUrl) {
+    return new URL('/api/auth/oauth2/token', (0, config_1.trimTrailingSlash)(baseUrl)).toString();
+}
+function buildOAuthUserInfoUrl(baseUrl) {
+    return new URL('/api/auth/oauth2/userinfo', (0, config_1.trimTrailingSlash)(baseUrl)).toString();
+}

package/dist/lib/oauth.d.cts

@@ -0,0 +1,19 @@
+export declare const PARIX_CLIENT_ID = "parix";
+export declare const PARIX_LOCAL_CALLBACK_PATH = "/callback";
+export declare const CLI_OAUTH_CONSENT_GRANTED_PATH = "/cli-oauth-consent-granted";
+export declare const PARIX_DEFAULT_SCOPES: readonly ["openid", "profile", "email", "offline_access", "org:read", "db:read", "db:write", "billing:read"];
+export interface PkcePair {
+    codeChallenge: string;
+    codeVerifier: string;
+}
+export declare function createPkcePair(): PkcePair;
+export declare function buildAuthorizeUrl(input: {
+    baseUrl: string;
+    codeChallenge: string;
+    prompt?: string;
+    state: string;
+}): string;
+export declare function buildCliState(redirectUri: string): string;
+export declare function buildOAuthCallbackUrl(baseUrl: string): string;
+export declare function buildOAuthTokenUrl(baseUrl: string): string;
+export declare function buildOAuthUserInfoUrl(baseUrl: string): string;

package/dist/lib/oauth.d.ts

@@ -0,0 +1,19 @@
+export declare const PARIX_CLIENT_ID = "parix";
+export declare const PARIX_LOCAL_CALLBACK_PATH = "/callback";
+export declare const CLI_OAUTH_CONSENT_GRANTED_PATH = "/cli-oauth-consent-granted";
+export declare const PARIX_DEFAULT_SCOPES: readonly ["openid", "profile", "email", "offline_access", "org:read", "db:read", "db:write", "billing:read"];
+export interface PkcePair {
+    codeChallenge: string;
+    codeVerifier: string;
+}
+export declare function createPkcePair(): PkcePair;
+export declare function buildAuthorizeUrl(input: {
+    baseUrl: string;
+    codeChallenge: string;
+    prompt?: string;
+    state: string;
+}): string;
+export declare function buildCliState(redirectUri: string): string;
+export declare function buildOAuthCallbackUrl(baseUrl: string): string;
+export declare function buildOAuthTokenUrl(baseUrl: string): string;
+export declare function buildOAuthUserInfoUrl(baseUrl: string): string;

package/dist/lib/oauth.js

@@ -0,0 +1,49 @@
+import { Buffer } from 'node:buffer';
+import { createHash, randomBytes } from 'node:crypto';
+import { trimTrailingSlash } from "./config.js";
+export const PARIX_CLIENT_ID = 'parix';
+export const PARIX_LOCAL_CALLBACK_PATH = '/callback';
+export const CLI_OAUTH_CONSENT_GRANTED_PATH = '/cli-oauth-consent-granted';
+export const PARIX_DEFAULT_SCOPES = [
+    'openid',
+    'profile',
+    'email',
+    'offline_access',
+    'org:read',
+    'db:read',
+    'db:write',
+    'billing:read',
+];
+export function createPkcePair() {
+    const codeVerifier = randomBytes(32).toString('base64url');
+    const codeChallenge = createHash('sha256').update(codeVerifier).digest('base64url');
+    return {
+        codeChallenge,
+        codeVerifier,
+    };
+}
+export function buildAuthorizeUrl(input) {
+    const url = new URL('/api/oauth/cli/authorize', trimTrailingSlash(input.baseUrl));
+    url.searchParams.set('state', input.state);
+    url.searchParams.set('code_challenge', input.codeChallenge);
+    url.searchParams.set('code_challenge_method', 'S256');
+    if (input.prompt) {
+        url.searchParams.set('prompt', input.prompt);
+    }
+    return url.toString();
+}
+export function buildCliState(redirectUri) {
+    return Buffer.from(JSON.stringify({
+        nonce: randomBytes(16).toString('hex'),
+        redirectUri,
+    }), 'utf8').toString('base64url');
+}
+export function buildOAuthCallbackUrl(baseUrl) {
+    return new URL('/api/oauth/cli/callback', trimTrailingSlash(baseUrl)).toString();
+}
+export function buildOAuthTokenUrl(baseUrl) {
+    return new URL('/api/auth/oauth2/token', trimTrailingSlash(baseUrl)).toString();
+}
+export function buildOAuthUserInfoUrl(baseUrl) {
+    return new URL('/api/auth/oauth2/userinfo', trimTrailingSlash(baseUrl)).toString();
+}

package/dist/lib/open-url.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openUrlInBrowser = openUrlInBrowser;
+const node_child_process_1 = require("node:child_process");
+const node_process_1 = __importDefault(require("node:process"));
+async function openUrlInBrowser(url) {
+    const command = getOpenCommand(url);
+    if (!command) {
+        return false;
+    }
+    try {
+        const child = (0, node_child_process_1.spawn)(command.bin, command.args, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getOpenCommand(url) {
+    if (node_process_1.default.platform === 'darwin') {
+        return { bin: 'open', args: [url] };
+    }
+    if (node_process_1.default.platform === 'win32') {
+        return { bin: 'cmd', args: ['/c', 'start', '', url] };
+    }
+    if (node_process_1.default.platform === 'linux') {
+        return { bin: 'xdg-open', args: [url] };
+    }
+    return null;
+}

package/dist/lib/open-url.d.cts

@@ -0,0 +1 @@
+export declare function openUrlInBrowser(url: string): Promise<boolean>;

package/dist/lib/open-url.d.ts

@@ -0,0 +1 @@
+export declare function openUrlInBrowser(url: string): Promise<boolean>;

package/dist/lib/open-url.js

@@ -0,0 +1,32 @@
+import { spawn } from 'node:child_process';
+import process from 'node:process';
+export async function openUrlInBrowser(url) {
+    const command = getOpenCommand(url);
+    if (!command) {
+        return false;
+    }
+    try {
+        const child = spawn(command.bin, command.args, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getOpenCommand(url) {
+    if (process.platform === 'darwin') {
+        return { bin: 'open', args: [url] };
+    }
+    if (process.platform === 'win32') {
+        return { bin: 'cmd', args: ['/c', 'start', '', url] };
+    }
+    if (process.platform === 'linux') {
+        return { bin: 'xdg-open', args: [url] };
+    }
+    return null;
+}

package/dist/lib/output.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printJson = printJson;
+exports.printKeyValues = printKeyValues;
+exports.printTable = printTable;
+const prompts_1 = require("@clack/prompts");
+function printJson(value) {
+    prompts_1.log.message(JSON.stringify(value, null, 2));
+}
+function printKeyValues(entries) {
+    const keyWidth = Math.max(...entries.map(([key]) => key.length), 0);
+    prompts_1.log.message(entries.map(([key, value]) => `${key.padEnd(keyWidth)}  ${value}`).join('\n'));
+}
+function printTable(input) {
+    const widths = input.columns.map((column, index) => Math.max(column.length, ...input.rows.map((row) => row[index]?.length ?? 0)));
+    const header = input.columns.map((column, index) => column.padEnd(widths[index] ?? 0)).join('  ');
+    const divider = widths.map((width) => '-'.repeat(width)).join('  ');
+    const rows = input.rows.map((row) => row.map((value, index) => value.padEnd(widths[index] ?? 0)).join('  '));
+    prompts_1.log.message([header, divider, ...rows].join('\n'));
+}

package/dist/lib/output.d.cts

@@ -0,0 +1,6 @@
+export declare function printJson(value: unknown): void;
+export declare function printKeyValues(entries: Array<[string, string]>): void;
+export declare function printTable(input: {
+    columns: string[];
+    rows: string[][];
+}): void;

package/dist/lib/output.d.ts

@@ -0,0 +1,6 @@
+export declare function printJson(value: unknown): void;
+export declare function printKeyValues(entries: Array<[string, string]>): void;
+export declare function printTable(input: {
+    columns: string[];
+    rows: string[][];
+}): void;

package/dist/lib/output.js

@@ -0,0 +1,15 @@
+import { log } from '@clack/prompts';
+export function printJson(value) {
+    log.message(JSON.stringify(value, null, 2));
+}
+export function printKeyValues(entries) {
+    const keyWidth = Math.max(...entries.map(([key]) => key.length), 0);
+    log.message(entries.map(([key, value]) => `${key.padEnd(keyWidth)}  ${value}`).join('\n'));
+}
+export function printTable(input) {
+    const widths = input.columns.map((column, index) => Math.max(column.length, ...input.rows.map((row) => row[index]?.length ?? 0)));
+    const header = input.columns.map((column, index) => column.padEnd(widths[index] ?? 0)).join('  ');
+    const divider = widths.map((width) => '-'.repeat(width)).join('  ');
+    const rows = input.rows.map((row) => row.map((value, index) => value.padEnd(widths[index] ?? 0)).join('  '));
+    log.message([header, divider, ...rows].join('\n'));
+}

package/dist/lib/parix-api.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiClient = createApiClient;
+exports.requestApiJson = requestApiJson;
+const api_client_1 = require("./api-client.cjs");
+const config_1 = require("./config.cjs");
+const session_1 = require("./session.cjs");
+async function createApiClient(baseUrlOverride) {
+    const storedSession = await (0, session_1.readStoredSession)();
+    if (!storedSession) {
+        throw new Error('No local session found. Run `parix auth login` first.');
+    }
+    const baseUrl = (0, config_1.resolveBaseUrl)(baseUrlOverride, storedSession);
+    return {
+        baseUrl,
+        client: new api_client_1.ApiClient({
+            session: {
+                ...storedSession,
+                baseUrl,
+            },
+        }),
+    };
+}
+async function requestApiJson(input) {
+    const { client } = await createApiClient(input.baseUrl);
+    const response = await client.request(input.path, {
+        body: input.body,
+        headers: input.headers,
+        method: input.method,
+    });
+    const raw = await response.text();
+    const payload = raw.length > 0 ? safeParseJson(raw) : null;
+    if (!response.ok) {
+        const message = getApiErrorMessage(payload) ?? (raw.trim() || `${response.status} ${response.statusText}`);
+        throw new Error(message);
+    }
+    return payload;
+}
+function safeParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function getApiErrorMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const row = payload;
+    if (typeof row.message === 'string' && row.message.trim().length > 0) {
+        return row.message;
+    }
+    if (typeof row.error === 'string' && row.error.trim().length > 0) {
+        return row.error;
+    }
+    return null;
+}

package/dist/lib/parix-api.d.cts

@@ -0,0 +1,12 @@
+import { ApiClient } from "./api-client.cjs";
+export declare function createApiClient(baseUrlOverride?: string): Promise<{
+    baseUrl: string;
+    client: ApiClient;
+}>;
+export declare function requestApiJson<T>(input: {
+    baseUrl?: string;
+    body?: RequestInit['body'];
+    headers?: RequestInit['headers'];
+    method?: string;
+    path: string;
+}): Promise<T>;

package/dist/lib/parix-api.d.ts

@@ -0,0 +1,12 @@
+import { ApiClient } from "./api-client.js";
+export declare function createApiClient(baseUrlOverride?: string): Promise<{
+    baseUrl: string;
+    client: ApiClient;
+}>;
+export declare function requestApiJson<T>(input: {
+    baseUrl?: string;
+    body?: RequestInit['body'];
+    headers?: RequestInit['headers'];
+    method?: string;
+    path: string;
+}): Promise<T>;

package/dist/lib/parix-api.js

@@ -0,0 +1,55 @@
+import { ApiClient } from "./api-client.js";
+import { resolveBaseUrl } from "./config.js";
+import { readStoredSession } from "./session.js";
+export async function createApiClient(baseUrlOverride) {
+    const storedSession = await readStoredSession();
+    if (!storedSession) {
+        throw new Error('No local session found. Run `parix auth login` first.');
+    }
+    const baseUrl = resolveBaseUrl(baseUrlOverride, storedSession);
+    return {
+        baseUrl,
+        client: new ApiClient({
+            session: {
+                ...storedSession,
+                baseUrl,
+            },
+        }),
+    };
+}
+export async function requestApiJson(input) {
+    const { client } = await createApiClient(input.baseUrl);
+    const response = await client.request(input.path, {
+        body: input.body,
+        headers: input.headers,
+        method: input.method,
+    });
+    const raw = await response.text();
+    const payload = raw.length > 0 ? safeParseJson(raw) : null;
+    if (!response.ok) {
+        const message = getApiErrorMessage(payload) ?? (raw.trim() || `${response.status} ${response.statusText}`);
+        throw new Error(message);
+    }
+    return payload;
+}
+function safeParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function getApiErrorMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const row = payload;
+    if (typeof row.message === 'string' && row.message.trim().length > 0) {
+        return row.message;
+    }
+    if (typeof row.error === 'string' && row.error.trim().length > 0) {
+        return row.error;
+    }
+    return null;
+}

package/dist/lib/session.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_FILE_PATH = void 0;
+exports.readStoredSession = readStoredSession;
+exports.writeStoredSession = writeStoredSession;
+exports.clearStoredSession = clearStoredSession;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+exports.SESSION_FILE_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'parix', 'session.json');
+async function readStoredSession() {
+    try {
+        const raw = await (0, promises_1.readFile)(exports.SESSION_FILE_PATH, 'utf8');
+        return parseStoredSession(JSON.parse(raw));
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        if (error instanceof SyntaxError) {
+            throw new TypeError(`Failed to parse ${exports.SESSION_FILE_PATH}`);
+        }
+        throw error;
+    }
+}
+async function writeStoredSession(session) {
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(exports.SESSION_FILE_PATH), { recursive: true });
+    await (0, promises_1.writeFile)(exports.SESSION_FILE_PATH, `${JSON.stringify(session, null, 2)}\n`, 'utf8');
+}
+async function clearStoredSession() {
+    await (0, promises_1.rm)(exports.SESSION_FILE_PATH, { force: true });
+}
+function parseStoredSession(value) {
+    if (!value || typeof value !== 'object') {
+        throw new Error(`Invalid session data in ${exports.SESSION_FILE_PATH}`);
+    }
+    const row = value;
+    const user = row.user;
+    const organization = row.organization;
+    if (row.version !== 2 ||
+        typeof row.baseUrl !== 'string' ||
+        typeof row.accessToken !== 'string' ||
+        typeof row.accessTokenExpiresAt !== 'string' ||
+        typeof row.createdAt !== 'string' ||
+        !Array.isArray(row.scopes) ||
+        typeof row.tokenType !== 'string' ||
+        typeof row.updatedAt !== 'string' ||
+        !user ||
+        typeof user.id !== 'string' ||
+        !organization) {
+        throw new Error(`Invalid session data in ${exports.SESSION_FILE_PATH}`);
+    }
+    return {
+        version: 2,
+        accessToken: row.accessToken,
+        accessTokenExpiresAt: row.accessTokenExpiresAt,
+        baseUrl: row.baseUrl,
+        createdAt: row.createdAt,
+        refreshToken: typeof row.refreshToken === 'string' ? row.refreshToken : null,
+        scopes: row.scopes.filter((scope) => typeof scope === 'string'),
+        tokenType: row.tokenType,
+        updatedAt: row.updatedAt,
+        user: {
+            id: user.id,
+            email: typeof user.email === 'string' ? user.email : null,
+            emailVerified: typeof user.emailVerified === 'boolean' ? user.emailVerified : null,
+            name: typeof user.name === 'string' ? user.name : null,
+            image: typeof user.image === 'string' ? user.image : null,
+        },
+        organization: {
+            id: typeof organization.id === 'string' ? organization.id : null,
+            memberRole: typeof organization.memberRole === 'string' ? organization.memberRole : null,
+            name: typeof organization.name === 'string' ? organization.name : null,
+            slug: typeof organization.slug === 'string' ? organization.slug : null,
+        },
+    };
+}
+function isMissingFileError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}