@telecrypt-io/storage 0.1.3 → 0.2.1

package/dist/cli/index.js

@@ -1,443 +0,0 @@
-#!/usr/bin/env node
-import "fake-indexeddb/auto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { Command } from "commander";
-import { createClient } from "matrix-js-sdk";
-import { clearProfile, readSession, writeSession } from "./profile.js";
-import { initStorageForNewSession, openStorage, waitForBackupSettled } from "./storage.js";
-import { CliError } from "./errors.js";
-import { runAction } from "./output.js";
-import * as core from "../core/operations.js";
-import { runDeviceCodeLogin } from "./oidc.js";
-// matrix-js-sdk (loglevel) and the rust-crypto WASM tracing layer write
-// verbose logs straight to console.log/debug/info/trace (stdout by default)
-// AND console.warn/error (stderr by default) — e.g. push-rule setup notices
-// and background-request warnings fire on totally successful runs. Left
-// alone, that corrupts BOTH halves of the CLI's output contract: stdout must
-// be exactly one line (human text or --json payload), and stderr under
-// --json must be exactly one `{"error": "..."}` line for a test (or script)
-// to parse. Silence all of them here, before TeleCryptIOStorage.create() ever
-// triggers rust-crypto initialisation; the CLI's own output always goes
-// through process.stdout.write/process.stderr.write directly (see
-// output.ts), never console.*, so this can't swallow anything we emit
-// ourselves. Set TELECRYPT_IO_STORAGE_DEBUG=1 to see the SDK's logs again
-// (all routed to stderr, labelled) when troubleshooting.
-if (!process.env.TELECRYPT_IO_STORAGE_DEBUG) {
-    console.log = () => { };
-    console.debug = () => { };
-    console.info = () => { };
-    console.trace = () => { };
-    console.warn = () => { };
-    console.error = () => { };
-}
-else {
-    const toStderr = (label) => (...args) => process.stderr.write(`[${label}] ${args.map(String).join(" ")}\n`);
-    console.log = toStderr("log");
-    console.debug = toStderr("debug");
-    console.info = toStderr("info");
-    console.trace = toStderr("trace");
-    console.warn = toStderr("warn");
-    console.error = toStderr("error");
-}
-const EXT_MIMETYPES = {
-    ".txt": "text/plain",
-    ".json": "application/json",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".pdf": "application/pdf",
-    ".md": "text/markdown",
-};
-function guessMimetype(filePath) {
-    return EXT_MIMETYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
-}
-const program = new Command();
-program
-    .name("telecrypt-io")
-    .description("TeleCrypt.io CLI")
-    .option("--json", "machine-readable JSON output")
-    .showHelpAfterError();
-const storage = program
-    .command("storage")
-    .description("End-to-end encrypted file storage on Matrix");
-// ---------------------------------------------------------------------------
-// Session
-// ---------------------------------------------------------------------------
-storage
-    .command("login")
-    .description("Log in and persist the session + crypto store to the profile")
-    .requiredOption("--homeserver <url>", "Matrix homeserver base URL")
-    .option("--user <localpart>", "Username (localpart or full MXID) — password login")
-    .option("--password <pw>", "Password — password login")
-    .option("--oidc", "Log in via OIDC/MAS device-code grant instead of password")
-    .action(async (opts, command) => {
-    await runAction(command, async () => {
-        let session;
-        if (opts.oidc) {
-            session = await runDeviceCodeLogin(opts.homeserver, {
-                onVerification: ({ verificationUri, verificationUriComplete, userCode }) => {
-                    // Progress output — stderr only, so it never corrupts the
-                    // stdout contract (--json's single JSON line / text mode's
-                    // single line), same convention as TELECRYPT_IO_STORAGE_DEBUG
-                    // SDK logging below.
-                    process.stderr.write([
-                        "",
-                        `To finish logging in, visit: ${verificationUriComplete ?? verificationUri}`,
-                        verificationUriComplete ? "" : `and enter code: ${userCode}`,
-                        "Attempting to open your browser…",
-                        "Waiting for approval…",
-                        "",
-                    ]
-                        .filter((l) => l !== "")
-                        .join("\n") + "\n");
-                },
-            });
-        }
-        else {
-            if (!opts.user || !opts.password) {
-                throw new CliError("--user and --password are required for password login (or pass --oidc)");
-            }
-            const client = createClient({ baseUrl: opts.homeserver });
-            let res;
-            try {
-                res = await client.loginWithPassword(opts.user, opts.password);
-            }
-            catch (err) {
-                throw new CliError(`login failed: ${err.message}`);
-            }
-            session = {
-                homeserver: opts.homeserver,
-                userId: res.user_id,
-                deviceId: res.device_id,
-                accessToken: res.access_token,
-            };
-        }
-        writeSession(session);
-        // Establishes this device's crypto identity and does a first sync
-        // (proves connectivity end-to-end), and writes the initial crypto
-        // store snapshot so later commands have something to load.
-        const opened = await initStorageForNewSession(session);
-        await opened.close();
-        return {
-            json: { userId: session.userId, deviceId: session.deviceId, homeserver: session.homeserver },
-            text: `Logged in as ${session.userId} (device ${session.deviceId})`,
-        };
-    });
-});
-storage
-    .command("register")
-    .description("Register a new account (dev/test convenience), then log in")
-    .requiredOption("--homeserver <url>", "Matrix homeserver base URL")
-    .requiredOption("--user <localpart>", "Username (localpart)")
-    .requiredOption("--password <pw>", "Password")
-    .action(async (opts, command) => {
-    await runAction(command, async () => {
-        const res = await fetch(`${opts.homeserver}/_matrix/client/v3/register`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                username: opts.user,
-                password: opts.password,
-                auth: { type: "m.login.dummy" },
-                inhibit_login: false,
-            }),
-        });
-        if (!res.ok) {
-            const body = await res.text();
-            throw new CliError(`registration failed (${res.status}): ${body}`);
-        }
-        const data = (await res.json());
-        const session = {
-            homeserver: opts.homeserver,
-            userId: data.user_id,
-            deviceId: data.device_id,
-            accessToken: data.access_token,
-        };
-        writeSession(session);
-        const opened = await initStorageForNewSession(session);
-        await opened.close();
-        return {
-            json: { userId: session.userId, deviceId: session.deviceId, homeserver: session.homeserver },
-            text: `Registered and logged in as ${session.userId} (device ${session.deviceId})`,
-        };
-    });
-});
-storage
-    .command("whoami")
-    .description("Print the current session identity")
-    .action(async (_opts, command) => {
-    await runAction(command, async () => {
-        const session = readSession();
-        if (!session)
-            throw new CliError("not logged in");
-        return {
-            json: { userId: session.userId, deviceId: session.deviceId, homeserver: session.homeserver },
-            text: `${session.userId} (device ${session.deviceId}) @ ${session.homeserver}`,
-        };
-    });
-});
-storage
-    .command("logout")
-    .description("Clear the local profile (session + crypto store)")
-    .action(async (_opts, command) => {
-    await runAction(command, async () => {
-        const session = readSession();
-        if (session) {
-            // Best-effort server-side logout; local profile is cleared either way.
-            await fetch(`${session.homeserver}/_matrix/client/v3/logout`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${session.accessToken}` },
-            }).catch(() => undefined);
-        }
-        clearProfile();
-        return { json: { loggedOut: true }, text: "Logged out." };
-    });
-});
-// ---------------------------------------------------------------------------
-// Recovery (Layer 2)
-// ---------------------------------------------------------------------------
-const recovery = storage.command("recovery").description("Server-side key backup / recovery");
-recovery
-    .command("setup")
-    .description("Set up recovery (cross-signing + key backup) and print the Recovery Key")
-    .action(async (_opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const result = await core.setupRecovery(opened.storage);
-            // Give any already-known megolm sessions a chance to actually reach
-            // the server backup before this short-lived process exits — see
-            // waitForBackupSettled's doc comment.
-            await waitForBackupSettled(opened.storage);
-            return {
-                json: { ...result },
-                text: [
-                    "Recovery Key (SAVE THIS — it is the only way to recover your files on a new device):",
-                    "",
-                    result.recoveryKey,
-                ].join("\n"),
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-recovery
-    .command("restore <recoveryKey>")
-    .description("Restore keys on this device from a Recovery Key")
-    .action(async (recoveryKey, _opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const result = await core.restoreRecovery(opened.storage, recoveryKey);
-            return {
-                json: { ...result },
-                text: `Restored ${result.imported}/${result.total} keys.`,
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Folders
-// ---------------------------------------------------------------------------
-const folder = storage.command("folder").description("Shared folder operations");
-folder
-    .command("create <name>")
-    .description("Create a new shared folder")
-    .action(async (name, _opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const result = await core.createFolder(opened.storage, name);
-            return {
-                json: { folderId: result.id, name: result.name },
-                text: `Created folder "${result.name}" (${result.id})`,
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-folder
-    .command("list")
-    .description("List folders visible to the current user")
-    .action(async (_opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const folders = await core.listFolders(opened.storage);
-            return {
-                json: { folders },
-                text: folders.length === 0
-                    ? "(no folders)"
-                    : folders.map((f) => `${f.id}\t${f.name}`).join("\n"),
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-folder
-    .command("join <folderId>")
-    .description("Accept a pending folder invitation (join the room)")
-    .action(async (folderId, _opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const result = await core.joinFolder(opened.storage, folderId);
-            return { json: { ...result }, text: `Joined folder ${result.folderId}` };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-folder
-    .command("share <folderId> <userId>")
-    .description("Invite a participant to a shared folder at a given role")
-    .option("--role <role>", "viewer or editor", "viewer")
-    .action(async (folderId, userId, opts, command) => {
-    await runAction(command, async () => {
-        // Validated here too (before openStorage/login is even attempted) so
-        // a bad --role fails fast exactly as before; core.shareFolder repeats
-        // the same check so it's still safe to call standalone (e.g. from a
-        // future UI) without this CLI-side pre-check.
-        if (opts.role !== "viewer" && opts.role !== "editor") {
-            throw new CliError(`invalid --role "${opts.role}" (must be viewer or editor)`);
-        }
-        const opened = await openStorage();
-        try {
-            const result = await core.shareFolder(opened.storage, folderId, userId, opts.role);
-            return {
-                json: { ...result },
-                text: `Invited ${result.userId} to ${result.folderId} as ${result.role}`,
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-folder
-    .command("members <folderId>")
-    .description("List participants and their roles")
-    .action(async (folderId, _opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const members = await core.listMembers(opened.storage, folderId);
-            return {
-                json: { members },
-                text: members.map((m) => `${m.userId}\t${m.role}\t${m.membership}`).join("\n"),
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-folder
-    .command("unshare <folderId> <userId>")
-    .description("Remove a participant from a shared folder")
-    .action(async (folderId, userId, _opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const result = await core.unshareFolder(opened.storage, folderId, userId);
-            return { json: { ...result }, text: `Removed ${result.userId} from ${result.folderId}` };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Files
-// ---------------------------------------------------------------------------
-const file = storage.command("file").description("File operations within a folder");
-file
-    .command("upload <folderId> <path>")
-    .description("Encrypt and upload a local file into a folder")
-    .option("--name <name>", "Name to store the file as (default: basename of path)")
-    .action(async (folderId, filePath, opts, command) => {
-    await runAction(command, async () => {
-        if (!fs.existsSync(filePath)) {
-            throw new CliError(`file not found: ${filePath}`);
-        }
-        const opened = await openStorage();
-        try {
-            const name = opts.name ?? path.basename(filePath);
-            const data = fs.readFileSync(filePath);
-            const result = await core.uploadFile(opened.storage, folderId, name, data, guessMimetype(filePath));
-            // If recovery/backup is already active for this account, give the
-            // new session's key a chance to actually reach the server backup
-            // before this short-lived process exits.
-            await waitForBackupSettled(opened.storage);
-            return {
-                json: { fileId: result.id, name: result.name },
-                text: `Uploaded "${result.name}" as ${result.id}`,
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-file
-    .command("list <folderId>")
-    .description("List files in a folder")
-    .action(async (folderId, _opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const files = await core.listFiles(opened.storage, folderId);
-            return {
-                json: { files },
-                text: files.length === 0 ? "(no files)" : files.map((f) => `${f.id}\t${f.name}`).join("\n"),
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-file
-    .command("download <folderId> <fileId> <destPath>")
-    .description("Download and decrypt a file to a local path")
-    .action(async (folderId, fileId, destPath, _opts, command) => {
-    await runAction(command, async () => {
-        const opened = await openStorage();
-        try {
-            const result = await core.downloadFile(opened.storage, folderId, fileId);
-            fs.writeFileSync(destPath, Buffer.from(result.bytes));
-            return {
-                json: { path: destPath, bytes: result.bytes.byteLength, mimetype: result.mimetype },
-                text: `Downloaded ${result.bytes.byteLength} bytes to ${destPath}`,
-            };
-        }
-        finally {
-            await opened.close();
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-program
-    .parseAsync(process.argv)
-    .catch((err) => {
-    process.stderr.write(`Error: ${err.message}\n`);
-    process.exitCode = 1;
-})
-    .finally(() => {
-    // Every action closes its own storage (stopClient()), but Node's global
-    // fetch (undici) can keep a keep-alive socket open past that, leaving
-    // the process hanging instead of exiting on its own. Exit explicitly
-    // once the command has fully finished and printed its output.
-    process.exit(process.exitCode ?? 0);
-});

package/dist/cli/oidc.d.ts

@@ -1,19 +0,0 @@
-import type { Session } from "./profile.js";
-export interface DeviceCodeLoginHooks {
-    /** Called once the device+user code is known, before polling begins —
-     * the caller (CLI command) prints it and attempts to open the browser. */
-    onVerification: (info: {
-        verificationUri: string;
-        verificationUriComplete?: string;
-        userCode: string;
-    }) => void;
-}
-/**
- * Runs the full device-code login flow against `homeserver`: discovery, DCR,
- * start device authorization, print verification info + try to open the
- * browser, poll until approved, confirm identity via `/whoami`. Returns a
- * `Session` ready to `writeSession()` — includes the OIDC token set fields
- * (`refreshToken`, `oidcIssuer`, `oidcClientId`, `oidcIdToken`) so later CLI
- * invocations can reuse + refresh it.
- */
-export declare function runDeviceCodeLogin(homeserver: string, hooks: DeviceCodeLoginHooks): Promise<Session>;

package/dist/cli/oidc.js

@@ -1,97 +0,0 @@
-/**
- * CLI-only OIDC/MAS adapter: device-code login (RFC 8628) against a
- * homeserver's delegated auth service (MAS). Node-only (child_process for
- * best-effort browser open). Platform-specific behavior stays out of `src/core/`; the actual
- * OIDC protocol calls all live in `src/core/oidc.ts` and are shared with the
- * UI's PKCE adapter.
- */
-import { randomBytes } from "node:crypto";
-import { spawn } from "node:child_process";
-import { discoverOidcIssuer, registerClient, startDeviceCodeLogin, waitForDeviceCodeLogin, isDeviceAccessTokenError, whoAmI, } from "../core/oidc.js";
-import { CliError } from "./errors.js";
-import { withOidcWindowShim } from "./oidcWindowPolyfill.js";
-/** Generates a device ID the same shape matrix-js-sdk itself would (short
- * uppercase alphanumeric) — this CLI process chooses it upfront (unlike the
- * UI's authorization-code flow, where the SDK picks a random one) so it's
- * available immediately for logging/display and is guaranteed to match the
- * resulting Matrix device_id (embedded in the requested scope, see
- * `core/oidc.ts`'s `startDeviceCodeLogin`). */
-function generateDeviceId() {
-    return randomBytes(5).toString("hex").toUpperCase();
-}
-/** Best-effort: try to open the verification URL in the user's default
- * browser. Never throws — if it fails (headless box, no display, unknown
- * platform), the caller already printed the URL for the user to open by
- * hand. */
-function tryOpenBrowser(url) {
-    const platform = process.platform;
-    const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-    try {
-        const child = spawn(cmd, platform === "win32" ? ["", url] : [url], {
-            detached: true,
-            stdio: "ignore",
-            shell: platform === "win32",
-        });
-        child.unref();
-    }
-    catch {
-        // best-effort only
-    }
-}
-/**
- * Runs the full device-code login flow against `homeserver`: discovery, DCR,
- * start device authorization, print verification info + try to open the
- * browser, poll until approved, confirm identity via `/whoami`. Returns a
- * `Session` ready to `writeSession()` — includes the OIDC token set fields
- * (`refreshToken`, `oidcIssuer`, `oidcClientId`, `oidcIdToken`) so later CLI
- * invocations can reuse + refresh it.
- */
-export async function runDeviceCodeLogin(homeserver, hooks) {
-    // See src/cli/oidcWindowPolyfill.ts: discovery is the one OIDC call that
-    // needs a `window` stub under Node, and the only place in the CLI it's
-    // safe to install one — nothing crypto/WASM-related exists yet in this
-    // process.
-    const authMetadata = await withOidcWindowShim(() => discoverOidcIssuer(homeserver));
-    if (!authMetadata.device_authorization_endpoint) {
-        throw new CliError(`${homeserver} does not advertise OIDC device-code support (no device_authorization_endpoint) — try password login instead.`);
-    }
-    const clientId = await registerClient(authMetadata, {
-        clientName: "TeleCrypt.io CLI",
-        clientUri: "https://telecrypt.io/",
-        applicationType: "native",
-        // Device-code flow never redirects a browser back to us, so this URI is
-        // never actually dereferenced — it's a DCR-schema placeholder only.
-        // Unverified against production MAS's DCR policy (only exercised here
-        // against the local dev/test MAS, which allows insecure/mismatched URIs).
-        redirectUris: ["http://localhost:0/"],
-        contacts: undefined,
-        tosUri: undefined,
-        policyUri: undefined,
-    });
-    const deviceId = generateDeviceId();
-    const session = await startDeviceCodeLogin(authMetadata, clientId, deviceId);
-    hooks.onVerification({
-        verificationUri: session.verification_uri,
-        verificationUriComplete: session.verification_uri_complete,
-        userCode: session.user_code,
-    });
-    tryOpenBrowser(session.verification_uri_complete ?? session.verification_uri);
-    const result = await waitForDeviceCodeLogin(authMetadata, clientId, session);
-    if (isDeviceAccessTokenError(result)) {
-        throw new CliError(`device login was not approved: ${result.error_description ?? result.error}`);
-    }
-    const who = await whoAmI(homeserver, result.access_token);
-    if (who.deviceId && who.deviceId !== deviceId) {
-        throw new CliError(`device_id mismatch after OIDC login: requested ${deviceId}, server confirmed ${who.deviceId}`);
-    }
-    return {
-        homeserver,
-        userId: who.userId,
-        deviceId,
-        accessToken: result.access_token,
-        refreshToken: result.refresh_token,
-        oidcIssuer: authMetadata.issuer,
-        oidcClientId: clientId,
-        oidcTokenEndpoint: authMetadata.token_endpoint,
-    };
-}

package/dist/cli/oidcWindowPolyfill.d.ts

@@ -1 +0,0 @@
-export declare function withOidcWindowShim<T>(fn: () => Promise<T>): Promise<T>;

package/dist/cli/oidcWindowPolyfill.js

@@ -1,76 +0,0 @@
-/**
- * `src/core/oidc.ts`'s `discoverOidcIssuer()` calls matrix-js-sdk's
- * `MatrixClient.getAuthMetadata()`, which internally constructs
- * oidc-client-ts state requiring `window.sessionStorage`/`window.
- * localStorage` to exist — a real browser has both natively; plain Node does
- * not, so under Node it throws `ReferenceError: window is not defined`
- * before ever making the HTTP request. Confirmed by direct testing — this is
- * a genuine gap in matrix-js-sdk's OIDC helpers for non-browser consumers,
- * not a misconfiguration on our side. (The same root cause is why we
- * deliberately do NOT use matrix-js-sdk's `OidcTokenRefresher` for token
- * refresh — see `core/oidc.ts`'s `refreshOidcToken`/`buildTokenRefreshFunction`,
- * a plain hand-rolled `fetch` instead, which needs no `window` at all and so
- * has no such gap, no matter when a refresh happens to fire.)
- *
- * `withOidcWindowShim()` installs a minimal in-memory `Storage`-shaped
- * `window` stub, runs `fn`, then removes it again — DELIBERATELY SCOPED, not
- * a permanent global assignment:
- *
- * A permanent `globalThis.window` breaks something unrelated —
- * `@matrix-org/matrix-sdk-crypto-wasm`'s own environment detection
- * (`typeof window !== "undefined"` → assumes a real browser IndexedDB is
- * available) fails with "Unsupported environment" once `window` exists at
- * all, even as an empty-ish stub, since CLI crypto persistence depends on Node being detected as Node
- * (`fake-indexeddb`), not as a browser. Confirmed by direct testing:
- * `initRustCrypto()` broke the moment `globalThis.window` was defined
- * unconditionally at module load.
- *
- * This is safe to use ONLY around `discoverOidcIssuer()`, and ONLY at OIDC
- * login time (`src/cli/oidc.ts`'s `runDeviceCodeLogin`) — the one call site
- * where it runs before any `TeleCryptIOStorage`/`MatrixClient`/rust-crypto
- * WASM exists in the process, so there is no concurrent WASM environment
- * check for the temporary stub to corrupt. Never wrap anything that runs
- * concurrently with, or after, crypto initialisation.
- */
-class MemoryStorage {
-    map = new Map();
-    get length() {
-        return this.map.size;
-    }
-    clear() {
-        this.map.clear();
-    }
-    getItem(key) {
-        return this.map.has(key) ? this.map.get(key) : null;
-    }
-    key(index) {
-        return [...this.map.keys()][index] ?? null;
-    }
-    removeItem(key) {
-        this.map.delete(key);
-    }
-    setItem(key, value) {
-        this.map.set(key, value);
-    }
-}
-export async function withOidcWindowShim(fn) {
-    const hadWindow = "window" in globalThis;
-    const previous = globalThis.window;
-    if (!hadWindow) {
-        globalThis.window = {
-            sessionStorage: new MemoryStorage(),
-            localStorage: new MemoryStorage(),
-        };
-    }
-    try {
-        return await fn();
-    }
-    finally {
-        if (!hadWindow) {
-            delete globalThis.window;
-        }
-        else {
-            globalThis.window = previous;
-        }
-    }
-}

package/dist/cli/output.d.ts

@@ -1,16 +0,0 @@
-import type { Command } from "commander";
-export interface CommandResult {
-    /** Machine-readable payload for --json. */
-    json: Record<string, unknown>;
-    /** Human-readable text for the default (non --json) output. */
-    text: string;
-}
-/**
- * Runs a command action: executes `fn`, prints its result (JSON or human
- * text) to stdout on success, or a clean `{ "error": "..." }` (JSON mode) /
- * `Error: ...` (text mode) to stderr on failure — never a raw stack trace.
- * Sets process.exitCode accordingly (0 on success, 1 on failure) rather than
- * calling process.exit() directly, so callers can do any final cleanup
- * first.
- */
-export declare function runAction(command: Command, fn: () => Promise<CommandResult>): Promise<void>;

package/dist/cli/output.js

@@ -1,24 +0,0 @@
-function isJsonMode(command) {
-    return Boolean(command.optsWithGlobals().json);
-}
-/**
- * Runs a command action: executes `fn`, prints its result (JSON or human
- * text) to stdout on success, or a clean `{ "error": "..." }` (JSON mode) /
- * `Error: ...` (text mode) to stderr on failure — never a raw stack trace.
- * Sets process.exitCode accordingly (0 on success, 1 on failure) rather than
- * calling process.exit() directly, so callers can do any final cleanup
- * first.
- */
-export async function runAction(command, fn) {
-    const json = isJsonMode(command);
-    try {
-        const result = await fn();
-        process.stdout.write((json ? JSON.stringify(result.json) : result.text) + "\n");
-        process.exitCode = 0;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write((json ? JSON.stringify({ error: message }) : `Error: ${message}`) + "\n");
-        process.exitCode = 1;
-    }
-}

package/dist/cli/poll.d.ts

@@ -1 +0,0 @@
-export { waitForCondition } from "../core/poll.js";