@telecrypt-io/storage 0.1.3 → 0.2.1

package/dist/cli/poll.js

@@ -1,3 +0,0 @@
-// Re-homed under src/core/poll.ts (platform-agnostic — no Node/CLI
-// dependencies), re-exported here so existing CLI imports keep working.
-export { waitForCondition } from "../core/poll.js";

package/dist/cli/profile.d.ts

@@ -1,33 +0,0 @@
-export interface Session {
-    homeserver: string;
-    userId: string;
-    deviceId: string;
-    accessToken: string;
-    /**
-     * Present only when logged in via `storage login --oidc` (device-code
-     * grant against MAS; see src/cli/oidc.ts).
-     * Absent for a plain password login. `oidcTokenEndpoint` is persisted
-     * directly (rather than re-discovered from `oidcIssuer` on every command)
-     * so reusing/refreshing the session never needs OIDC discovery again —
-     * discovery is Node-hostile (see src/cli/oidcWindowPolyfill.ts) and this
-     * avoids needing it more than once, at login time.
-     */
-    refreshToken?: string;
-    oidcIssuer?: string;
-    oidcClientId?: string;
-    oidcTokenEndpoint?: string;
-}
-/**
- * Resolves the profile directory: everything this CLI persists (session,
- * crypto store) lives here. Overridable via TELECRYPT_IO_STORAGE_HOME so
- * tests can give each simulated user/device its own isolated profile.
- * Defaults to ~/.telecrypt-io/storage for normal interactive use.
- */
-export declare function profileDir(): string;
-export declare function sessionPath(dir?: string): string;
-export declare function cryptoSnapshotPath(dir?: string): string;
-export declare function ensureProfileDir(dir?: string): void;
-export declare function readSession(dir?: string): Session | null;
-export declare function writeSession(session: Session, dir?: string): void;
-/** Clears all local state for this profile (session + crypto store). */
-export declare function clearProfile(dir?: string): void;

package/dist/cli/profile.js

@@ -1,46 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-/**
- * Resolves the profile directory: everything this CLI persists (session,
- * crypto store) lives here. Overridable via TELECRYPT_IO_STORAGE_HOME so
- * tests can give each simulated user/device its own isolated profile.
- * Defaults to ~/.telecrypt-io/storage for normal interactive use.
- */
-export function profileDir() {
-    const home = process.env.TELECRYPT_IO_STORAGE_HOME;
-    if (home && home.trim() !== "")
-        return home;
-    return path.join(os.homedir(), ".telecrypt-io", "storage");
-}
-export function sessionPath(dir = profileDir()) {
-    return path.join(dir, "session.json");
-}
-export function cryptoSnapshotPath(dir = profileDir()) {
-    return path.join(dir, "crypto.snapshot");
-}
-export function ensureProfileDir(dir = profileDir()) {
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-}
-export function readSession(dir = profileDir()) {
-    const p = sessionPath(dir);
-    if (!fs.existsSync(p))
-        return null;
-    const raw = fs.readFileSync(p, "utf8");
-    return JSON.parse(raw);
-}
-export function writeSession(session, dir = profileDir()) {
-    ensureProfileDir(dir);
-    fs.writeFileSync(sessionPath(dir), JSON.stringify(session, null, 2), {
-        mode: 0o600,
-    });
-}
-/** Clears all local state for this profile (session + crypto store). */
-export function clearProfile(dir = profileDir()) {
-    const sp = sessionPath(dir);
-    const cp = cryptoSnapshotPath(dir);
-    if (fs.existsSync(sp))
-        fs.rmSync(sp);
-    if (fs.existsSync(cp))
-        fs.rmSync(cp);
-}

package/dist/cli/storage.d.ts

@@ -1,36 +0,0 @@
-import "fake-indexeddb/auto";
-import { TeleCryptIOStorage } from "../TeleCryptIOStorage.js";
-import { Session } from "./profile.js";
-export interface OpenedStorage {
-    storage: TeleCryptIOStorage;
-    session: Session;
-    /** Persists the crypto store back to disk and stops the client. Call this
-     * in a `finally` block around every command that opens storage, so the
-     * next CLI invocation sees whatever this one learned (new megolm sessions,
-     * device keys, etc.) — this is what makes decryption survive across
-     * separate processes. */
-    close: () => Promise<void>;
-}
-/**
- * Opens a TeleCryptIOStorage bound to the current profile's session, having first
- * restored the crypto store snapshot (if any) from a previous CLI
- * invocation. Throws CliError("not logged in") if there is no session.
- */
-export declare function openStorage(dir?: string): Promise<OpenedStorage>;
-/**
- * If server-side key backup is active for this account, waits (best-effort,
- * bounded) for the SDK's backup engine to report zero sessions remaining to
- * upload. This matters specifically because a CLI command is a *short-lived
- * process*: the backup engine deliberately fire-and-forgets its upload loop
- * with a randomised 0-10s startup jitter (to avoid a multi-device thundering
- * herd), so a command that creates a new megolm session (recovery setup,
- * or a file upload once recovery is already set up) and then exits
- * immediately can easily outrun that loop, leaving the new key silently
- * absent from the backup — recoverable-looking but not actually recoverable.
- * Never throws: this is a best-effort settle grace period, not a
- * correctness gate on the command's primary result.
- */
-export declare function waitForBackupSettled(storage: TeleCryptIOStorage, timeoutMs?: number): Promise<void>;
-/** Used by login/register: builds storage for a brand-new session and
- * establishes the initial (empty) crypto store snapshot on disk. */
-export declare function initStorageForNewSession(session: Session, dir?: string): Promise<OpenedStorage>;

package/dist/cli/storage.js

@@ -1,126 +0,0 @@
-import "fake-indexeddb/auto";
-import { CryptoEvent } from "matrix-js-sdk/lib/crypto-api/index.js";
-import { TeleCryptIOStorage } from "../TeleCryptIOStorage.js";
-import { cryptoSnapshotPath, ensureProfileDir, profileDir, readSession, writeSession } from "./profile.js";
-import { persistCryptoStore, restoreCryptoStore } from "./cryptoSnapshot.js";
-import { CliError } from "./errors.js";
-import { buildTokenRefreshFunction } from "../core/oidc.js";
-/**
- * Builds a TeleCryptIOStorage for the given session — plain password/access-
- * token sessions go through `create()`; sessions with an OIDC token set
- * (persisted by `storage login --oidc`, see src/cli/oidc.ts) go through
- * `createFromOidc()` with a token refresh function wired to persist
- * refreshed tokens straight back to this profile's session.json, so a later
- * CLI invocation picks up the refreshed access token rather than the
- * (possibly now-expired) one this process started with. Needs no OIDC
- * discovery / `window` shim here — `oidcTokenEndpoint` was already resolved
- * and persisted at login time (see src/cli/oidc.ts).
- */
-async function buildStorageForSession(session, dir) {
-    if (!session.refreshToken || !session.oidcClientId || !session.oidcTokenEndpoint) {
-        return TeleCryptIOStorage.create({
-            baseUrl: session.homeserver,
-            userId: session.userId,
-            accessToken: session.accessToken,
-            deviceId: session.deviceId,
-        });
-    }
-    const tokenRefreshFunction = buildTokenRefreshFunction(session.oidcTokenEndpoint, session.oidcClientId, async (tokens) => {
-        writeSession({
-            ...session,
-            accessToken: tokens.accessToken,
-            refreshToken: tokens.refreshToken ?? session.refreshToken,
-        }, dir);
-    });
-    return TeleCryptIOStorage.createFromOidc({
-        baseUrl: session.homeserver,
-        userId: session.userId,
-        accessToken: session.accessToken,
-        deviceId: session.deviceId,
-        refreshToken: session.refreshToken,
-        tokenRefreshFunction,
-    });
-}
-/**
- * Opens a TeleCryptIOStorage bound to the current profile's session, having first
- * restored the crypto store snapshot (if any) from a previous CLI
- * invocation. Throws CliError("not logged in") if there is no session.
- */
-export async function openStorage(dir = profileDir()) {
-    const session = readSession(dir);
-    if (!session) {
-        throw new CliError("not logged in — run `telecrypt-io storage login` first");
-    }
-    const snapshotPath = cryptoSnapshotPath(dir);
-    await restoreCryptoStore(snapshotPath);
-    const storage = await buildStorageForSession(session, dir);
-    let closed = false;
-    const close = async () => {
-        if (closed)
-            return;
-        closed = true;
-        try {
-            await persistCryptoStore(snapshotPath);
-        }
-        finally {
-            storage.getClient().stopClient();
-        }
-    };
-    return { storage, session, close };
-}
-/**
- * If server-side key backup is active for this account, waits (best-effort,
- * bounded) for the SDK's backup engine to report zero sessions remaining to
- * upload. This matters specifically because a CLI command is a *short-lived
- * process*: the backup engine deliberately fire-and-forgets its upload loop
- * with a randomised 0-10s startup jitter (to avoid a multi-device thundering
- * herd), so a command that creates a new megolm session (recovery setup,
- * or a file upload once recovery is already set up) and then exits
- * immediately can easily outrun that loop, leaving the new key silently
- * absent from the backup — recoverable-looking but not actually recoverable.
- * Never throws: this is a best-effort settle grace period, not a
- * correctness gate on the command's primary result.
- */
-export async function waitForBackupSettled(storage, timeoutMs = 20000) {
-    const active = await storage.keys.isRecoverySetup();
-    if (!active)
-        return;
-    const client = storage.getClient();
-    await new Promise((resolve) => {
-        let settled = false;
-        const finish = () => {
-            if (settled)
-                return;
-            settled = true;
-            client.removeListener(CryptoEvent.KeyBackupSessionsRemaining, onRemaining);
-            clearTimeout(timer);
-            resolve();
-        };
-        const onRemaining = (remaining) => {
-            if (remaining === 0)
-                finish();
-        };
-        client.on(CryptoEvent.KeyBackupSessionsRemaining, onRemaining);
-        const timer = setTimeout(finish, timeoutMs);
-    });
-}
-/** Used by login/register: builds storage for a brand-new session and
- * establishes the initial (empty) crypto store snapshot on disk. */
-export async function initStorageForNewSession(session, dir = profileDir()) {
-    ensureProfileDir(dir);
-    const snapshotPath = cryptoSnapshotPath(dir);
-    const storage = await buildStorageForSession(session, dir);
-    let closed = false;
-    const close = async () => {
-        if (closed)
-            return;
-        closed = true;
-        try {
-            await persistCryptoStore(snapshotPath);
-        }
-        finally {
-            storage.getClient().stopClient();
-        }
-    };
-    return { storage, session, close };
-}