@j-256/ccam 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James Klein
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,209 @@
+# ccam
+
+TypeScript CLI and SDK for the Salesforce Commerce Cloud Account Manager REST API.
+
+The AM API is largely undocumented. **ccam** serves as both a practical tool and a reference implementation for developers working with Commerce Cloud account management.
+
+## Why ccam?
+
+ccam is built for people who administer Account Manager: security and compliance teams running access audits, team leads onboarding and offboarding users, and developers integrating AM into their own tooling.
+
+- **Complete AM coverage.** Users, organizations, API clients, roles, realms, permissions, service types, org configurations, instances -- every resource, every subresource, every finder.
+- **Exportable.** CSV, TSV, YAML, JSON, or table. `ccam user list --org <id> --format csv` produces a spreadsheet-ready roster.
+- **Typed SDK.** `ccam-sdk` is a first-class, documented TypeScript library with TSDoc on every method, typed sort enums, and a structured error taxonomy.
+- **Named auth profiles.** Switch between orgs or accounts without re-authenticating. Refresh tokens are stored at `~/.config/ccam/credentials` with 0600 permissions.
+- **Interactive TUI.** Run `ccam` with no arguments for a keyboard-driven resource browser with drill-down from user to orgs to realms.
+
+Comparisons with the other Commerce Cloud CLIs:
+
+- [b2c-cli](https://github.com/SalesforceCommerceCloud/b2c-developer-tooling) is Salesforce's official CLI (GA, supersedes sfcc-ci). Broad Commerce Cloud coverage (OCAPI, sandboxes, SLAS, MRT), basic AM commands. See [docs/vs-b2c-cli.md](docs/vs-b2c-cli.md).
+- [sfcc-ci](https://github.com/SalesforceCommerceCloud/sfcc-ci) is the long-standing community CLI for CI/CD. Minimal AM coverage. See [docs/vs-sfcc-ci.md](docs/vs-sfcc-ci.md).
+
+ccam fills the AM-administration gap both leave open.
+
+## Quick Start: CLI
+
+### Installation
+
+```bash
+npm install -g @j-256/ccam
+```
+
+### First run
+
+ccam talks to Account Manager over OAuth2, so you need an AM API client before you can log in. If you already use sfcc-ci or other Commerce Cloud tooling, you can reuse that client; otherwise see [`docs/getting-started.md`](docs/getting-started.md) for a step-by-step walkthrough of creating one.
+
+Once you have a client ID (and secret, for confidential clients):
+
+```bash
+ccam auth login --client-id <your-client-id>
+```
+
+This opens a browser to AM, captures the authorization code on a loopback server, and saves a profile to `~/.config/ccam/profiles.yaml` (non-secret) and `~/.config/ccam/credentials` (0600; contains refresh token).
+
+Non-interactive alternatives:
+
+- `ccam auth login --client` -- client_credentials flow (for CI/automation)
+- `ccam auth login --password` -- ROPC flow (when SSO/MFA are not enforced)
+- `ccam auth login --manual` -- browser flow without a loopback server (for SSH/headless)
+- Set environment variables instead -- see below
+
+### Authentication
+
+Set environment variables for your API client credentials:
+
+```bash
+export CCAM_CLIENT_ID="your-client-id"
+export CCAM_CLIENT_SECRET="your-client-secret"
+export CCAM_HOST="https://account.demandware.com"  # optional, this is the default
+```
+
+For user-context operations (e.g. `client.users.current()` in the SDK), also set:
+
+```bash
+export CCAM_USER="your-email@example.com"
+export CCAM_USER_PASSWORD="your-password"
+```
+
+### Example Commands
+
+List users:
+```bash
+ccam user list
+```
+
+List users with filters:
+```bash
+ccam user list --org abc123 --role def456
+ccam user list --login user@example.com
+ccam user list --org-type customer
+```
+
+Filter organizations:
+```bash
+ccam org list --name "Acme Corp"
+ccam org list --starts-with "Acme"
+ccam org list --sf-account-id "001..."
+```
+
+List roles:
+```bash
+ccam role list
+```
+
+Export to CSV:
+```bash
+ccam user list --org abc123 --format csv > users.csv
+```
+
+## Quick Start: SDK
+
+### Installation
+
+```bash
+npm install ccam-sdk
+```
+
+### Usage
+
+```typescript
+import { CcamClient } from 'ccam-sdk';
+
+// Create client (uses environment variables or explicit options)
+const client = new CcamClient({
+  clientId: 'your-client-id',
+  clientSecret: 'your-client-secret',
+  host: 'https://account.demandware.com' // optional
+});
+
+// List users with pagination
+const result = await client.users.list({
+  page: 0,
+  size: 25
+});
+
+console.log(result.content);
+console.log(`Page ${result.page.number + 1} of ${result.page.totalPages}`);
+
+// Get user by login with expanded organizations
+const user = await client.users.getByLogin('user@example.com', {
+  expand: 'organizations'
+});
+
+console.log(user.mail, user.organizations);
+
+// List roles with sorting
+const roles = await client.roles.list({
+  page: 0,
+  size: 50,
+  sort: { field: 'name', direction: 'asc' }
+});
+```
+
+## Authentication
+
+ccam supports three credential sources (first wins):
+
+1. **Explicit options** passed to `CcamClient` constructor
+2. **Environment variables**: `CCAM_CLIENT_ID`, `CCAM_CLIENT_SECRET`, `CCAM_USER`, `CCAM_USER_PASSWORD`, `CCAM_HOST`
+3. **Default host**: `https://account.demandware.com`
+
+Two authentication modes:
+
+- **Client-only** (system context): read all resources, most common mode
+- **Client + user** (user context): required for the `/users/current` endpoint
+
+## Output Formats
+
+| Format | Use case | CLI flag |
+|--------|----------|----------|
+| `table` | Human-readable display (TTY default) | `--format table` |
+| `json` | Machine-readable, piping to jq | `--format json` or `-j` |
+| `csv` | Spreadsheet import, data analysis | `--format csv` |
+| `tsv` | Tab-separated (better for whitespace) | `--format tsv` |
+| `yaml` | Config files, human-readable structured | `--format yaml` |
+
+When output is piped (not a TTY), JSON is the default format.
+
+## Resources
+
+| Resource | CLI command | SDK property |
+|----------|-------------|--------------|
+| Users | `ccam user` | `client.users` |
+| Organizations | `ccam org` | `client.organizations` |
+| API Clients | `ccam client` | `client.apiClients` |
+| Roles | `ccam role` | `client.roles` |
+| Realms | `ccam realm` | `client.realms` |
+| Permissions | `ccam permission` | `client.permissions` |
+| Service Types | `ccam service-type` | `client.serviceTypes` |
+
+Most resources support:
+- `list` -- paginated list of resources
+- `get <id>` -- get a single resource by ID
+
+Additional commands:
+- Users: `get` by login (default) or by ID (`--id`), `current`, `audit`, `roles`, `instances`, `assigned-realms`, `assigned-instances`, `create`, `update`, `delete`, `reset`, `disable`, `revoke-verifier`. Filter flags on `list` (see below).
+- Organizations: `realms`, `instances`, `audit`, `update`. Filter flags on `list` (`--name`, `--starts-with`, `--sf-account-id`).
+- API Clients: `audit`, `assigned-realms`, `assigned-instances`, `create`, `update`, `delete`, `set-password`, `set-auth-type`.
+- Instances: `validate-filter`.
+
+Users and API Clients support `--expand` on `get` to include related resources (`organizations`, `roles`, or `organizations,roles`). Roles and Org Realms support `--expand serviceType` / `--expand instance` respectively.
+
+## User Search Filters
+
+The `ccam user list` command maps filter flags to AM API finder methods:
+
+| Flag | API finder | Example |
+|------|------------|---------|
+| `--login <email>` | `findByLogin` | `ccam user list --login user@example.com` |
+| `--org <id>` | `findByOrg` | `ccam user list --org abc123` |
+| `--org <id> --all` | `findAllByOrg` | `ccam user list --org abc123 --all` |
+| `--role <id>` | `findByRole` | `ccam user list --role def456` |
+| `--org <id> --role <id>` | `findByOrgAndRole` | `ccam user list --org abc123 --role def456` |
+| `--org-realm-access <id>` | `findByOrgRealmAccess` | `ccam user list --org-realm-access abc123` |
+
+Add `--modified-after <date>` with `--role` to filter by modification date.
+
+## License
+
+MIT

package/dist/auth/browser-login.d.ts

@@ -0,0 +1,14 @@
+export interface LoopbackLoginOptions {
+    authorizeUrl: string;
+    expectedState: string;
+    port: number;
+    open: (url: string) => void | Promise<void>;
+}
+export interface LoopbackLoginResult {
+    code: string;
+}
+export type LoopbackPromise = Promise<LoopbackLoginResult> & {
+    port: Promise<number>;
+};
+export declare function runLoopbackLogin(options: LoopbackLoginOptions): LoopbackPromise;
+//# sourceMappingURL=browser-login.d.ts.map

package/dist/auth/browser-login.js

@@ -0,0 +1,72 @@
+import http from 'node:http';
+export function runLoopbackLogin(options) {
+    let portResolve;
+    let portReject;
+    const portPromise = new Promise((resolve, reject) => {
+        portResolve = resolve;
+        portReject = reject;
+    });
+    const done = new Promise((resolve, reject) => {
+        const sockets = new Set();
+        const shutdown = () => {
+            for (const sock of sockets)
+                sock.destroy();
+            server.close();
+        };
+        const server = http.createServer((req, res) => {
+            res.setHeader('Connection', 'close');
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+            if (url.pathname !== '/callback') {
+                res.statusCode = 404;
+                res.end();
+                return;
+            }
+            const err = url.searchParams.get('error');
+            const state = url.searchParams.get('state');
+            const code = url.searchParams.get('code');
+            if (err === 'access_denied') {
+                res.statusCode = 200;
+                res.end('Login was cancelled. You can close this tab.');
+                shutdown();
+                reject(new Error('Login was cancelled.'));
+                return;
+            }
+            if (state !== options.expectedState) {
+                res.statusCode = 400;
+                res.end('State mismatch. You can close this tab.');
+                shutdown();
+                reject(new Error('Login failed: state mismatch.'));
+                return;
+            }
+            if (!code) {
+                res.statusCode = 400;
+                res.end('Missing authorization code.');
+                shutdown();
+                reject(new Error('Login failed: no code in redirect.'));
+                return;
+            }
+            res.statusCode = 200;
+            res.end('Authorization received. Return to the terminal to finish login. You can close this tab.');
+            shutdown();
+            resolve({ code });
+        });
+        server.on('connection', (sock) => {
+            sockets.add(sock);
+            sock.once('close', () => sockets.delete(sock));
+        });
+        server.on('error', (err) => {
+            portReject(err);
+            reject(err);
+        });
+        server.listen(options.port, '127.0.0.1', () => {
+            const addr = server.address();
+            if (addr && typeof addr === 'object') {
+                portResolve(addr.port);
+                Promise.resolve(options.open(options.authorizeUrl)).catch(reject);
+            }
+        });
+    });
+    Object.assign(done, { port: portPromise });
+    return done;
+}
+//# sourceMappingURL=browser-login.js.map

package/dist/auth/manual-login.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Manual-paste OAuth redirect handling for `auth login --manual`.
+ *
+ * Note: The `promptText` helper echoes input via plain readline. A user
+ * pasting the full redirect URL will briefly display the one-time `code`
+ * parameter on the terminal. Auth codes are single-use so the exposure
+ * is bounded, but be aware if you are screen-recording or screen-sharing.
+ */
+export declare function extractCodeFromInput(input: string, expectedState: string): string;
+//# sourceMappingURL=manual-login.d.ts.map

package/dist/auth/manual-login.js

@@ -0,0 +1,33 @@
+/**
+ * Manual-paste OAuth redirect handling for `auth login --manual`.
+ *
+ * Note: The `promptText` helper echoes input via plain readline. A user
+ * pasting the full redirect URL will briefly display the one-time `code`
+ * parameter on the terminal. Auth codes are single-use so the exposure
+ * is bounded, but be aware if you are screen-recording or screen-sharing.
+ */
+export function extractCodeFromInput(input, expectedState) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        throw new Error('Pasted value was empty.');
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+    const err = url.searchParams.get('error');
+    if (err === 'access_denied')
+        throw new Error('Login was cancelled.');
+    if (err)
+        throw new Error(`AM returned an error: ${err}`);
+    const state = url.searchParams.get('state');
+    if (state !== expectedState)
+        throw new Error('Login failed: state mismatch.');
+    const code = url.searchParams.get('code');
+    if (!code)
+        throw new Error('No `code` parameter in the pasted URL.');
+    return code;
+}
+//# sourceMappingURL=manual-login.js.map

package/dist/auth/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function getConfigDir(): string;
+export declare function getProfilesPath(): string;
+export declare function getCredentialsPath(): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/auth/paths.js

@@ -0,0 +1,15 @@
+import os from 'node:os';
+import path from 'node:path';
+export function getConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg && xdg.length > 0)
+        return path.join(xdg, 'ccam');
+    return path.join(os.homedir(), '.config', 'ccam');
+}
+export function getProfilesPath() {
+    return path.join(getConfigDir(), 'profiles.yaml');
+}
+export function getCredentialsPath() {
+    return path.join(getConfigDir(), 'credentials');
+}
+//# sourceMappingURL=paths.js.map

package/dist/auth/profile-resolver.d.ts

@@ -0,0 +1,26 @@
+export interface ResolveFlags {
+    profile?: string;
+    host?: string;
+    clientId?: string;
+    clientSecret?: string;
+    user?: string;
+    userPassword?: string;
+}
+export interface ResolvedProfile {
+    profileName?: string;
+    host: string;
+    clientId?: string;
+    clientSecret?: string;
+    user?: string;
+    userPassword?: string;
+    cachedToken?: {
+        accessToken: string;
+        expiresAt: number;
+        refreshToken?: string;
+    };
+    source: 'flags' | 'env' | 'profile' | 'defaults' | 'mixed';
+}
+export declare function resolveProfile(input: {
+    flags: ResolveFlags;
+}): Promise<ResolvedProfile>;
+//# sourceMappingURL=profile-resolver.d.ts.map

package/dist/auth/profile-resolver.js

@@ -0,0 +1,42 @@
+// packages/cli/src/auth/profile-resolver.ts
+import { ProfileStore } from './profile-store.js';
+const DEFAULT_HOST = 'https://account.demandware.com';
+export async function resolveProfile(input) {
+    const store = new ProfileStore();
+    const state = await store.read();
+    const profileName = input.flags.profile ?? process.env.CCAM_PROFILE ?? state.activeProfile;
+    const profile = profileName ? state.profiles[profileName] : undefined;
+    const creds = profileName ? state.credentials[profileName] : undefined;
+    const pick = (flag, env, profileVal) => {
+        return flag ?? env ?? profileVal;
+    };
+    const host = pick(input.flags.host, process.env.CCAM_HOST, profile?.host) ?? DEFAULT_HOST;
+    const clientId = pick(input.flags.clientId, process.env.CCAM_CLIENT_ID, profile?.clientId);
+    const clientSecret = pick(input.flags.clientSecret, process.env.CCAM_CLIENT_SECRET, creds?.clientSecret);
+    const user = pick(input.flags.user, process.env.CCAM_USER, undefined);
+    const userPassword = pick(input.flags.userPassword, process.env.CCAM_USER_PASSWORD, creds?.userPassword);
+    const credentialOverride = (input.flags.host !== undefined ||
+        input.flags.clientId !== undefined ||
+        input.flags.clientSecret !== undefined ||
+        input.flags.user !== undefined ||
+        input.flags.userPassword !== undefined ||
+        process.env.CCAM_HOST !== undefined ||
+        process.env.CCAM_CLIENT_ID !== undefined ||
+        process.env.CCAM_CLIENT_SECRET !== undefined ||
+        process.env.CCAM_USER !== undefined ||
+        process.env.CCAM_USER_PASSWORD !== undefined);
+    const cachedToken = !credentialOverride && creds?.accessToken && creds.expiresAt
+        ? { accessToken: creds.accessToken, expiresAt: creds.expiresAt, refreshToken: creds.refreshToken }
+        : undefined;
+    let source;
+    if (input.flags.host || input.flags.clientId || input.flags.clientSecret || input.flags.user || input.flags.userPassword)
+        source = 'flags';
+    else if (process.env.CCAM_HOST || process.env.CCAM_CLIENT_ID || process.env.CCAM_CLIENT_SECRET || process.env.CCAM_USER || process.env.CCAM_USER_PASSWORD)
+        source = 'env';
+    else if (profile)
+        source = 'profile';
+    else
+        source = 'defaults';
+    return { profileName, host, clientId, clientSecret, user, userPassword, cachedToken, source };
+}
+//# sourceMappingURL=profile-resolver.js.map

package/dist/auth/profile-store.d.ts

@@ -0,0 +1,38 @@
+export interface ProfileConfig {
+    host: string;
+    clientId: string;
+    userEmail?: string;
+}
+export interface ProfileCredentials {
+    refreshToken?: string;
+    clientSecret?: string;
+    userPassword?: string;
+    accessToken?: string;
+    expiresAt?: number;
+}
+export interface ProfileStoreState {
+    activeProfile?: string;
+    profiles: Record<string, ProfileConfig>;
+    credentials: Record<string, ProfileCredentials>;
+}
+export interface SaveProfileInput {
+    config: ProfileConfig;
+    credentials: ProfileCredentials;
+}
+export type ProfileState = 'ok' | 'missing-credentials' | 'missing-config';
+export interface ProfileSummary {
+    name: string;
+    state: ProfileState;
+    config?: ProfileConfig;
+}
+export declare class ProfileStore {
+    read(): Promise<ProfileStoreState>;
+    saveProfile(name: string, input: SaveProfileInput): Promise<void>;
+    setActiveProfile(name: string): Promise<void>;
+    deleteProfile(name: string): Promise<void>;
+    renameProfile(oldName: string, newName: string): Promise<void>;
+    updateCredentials(name: string, patch: Partial<ProfileCredentials>): Promise<void>;
+    listProfiles(): Promise<ProfileSummary[]>;
+    private writeState;
+}
+//# sourceMappingURL=profile-store.d.ts.map

package/dist/auth/profile-store.js

@@ -0,0 +1,125 @@
+import fs from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import YAML from 'yaml';
+import { getProfilesPath, getCredentialsPath, getConfigDir } from './paths.js';
+export class ProfileStore {
+    async read() {
+        const profilesText = await readIfExists(getProfilesPath());
+        const credentialsText = await readIfExists(getCredentialsPath());
+        const profilesDoc = profilesText ? YAML.parse(profilesText) : {};
+        const credentialsDoc = credentialsText ? YAML.parse(credentialsText) : {};
+        return {
+            activeProfile: profilesDoc?.activeProfile,
+            profiles: profilesDoc?.profiles ?? {},
+            credentials: credentialsDoc ?? {},
+        };
+    }
+    async saveProfile(name, input) {
+        await ensureConfigDir();
+        const state = await this.read();
+        state.profiles[name] = input.config;
+        state.credentials[name] = input.credentials;
+        await this.writeState(state);
+    }
+    async setActiveProfile(name) {
+        const state = await this.read();
+        if (!state.profiles[name]) {
+            if (state.credentials[name]) {
+                throw new Error(`Profile '${name}' is incomplete: credentials present but config is missing. Run \`ccam auth login --profile ${name}\` to repair.`);
+            }
+            throw new Error(`Profile '${name}' not found`);
+        }
+        state.activeProfile = name;
+        await this.writeState(state);
+    }
+    async deleteProfile(name) {
+        const state = await this.read();
+        delete state.profiles[name];
+        delete state.credentials[name];
+        if (state.activeProfile === name) {
+            state.activeProfile = undefined;
+        }
+        await this.writeState(state);
+    }
+    async renameProfile(oldName, newName) {
+        const state = await this.read();
+        if (!state.profiles[oldName]) {
+            throw new Error(`Profile '${oldName}' not found`);
+        }
+        if (state.profiles[newName]) {
+            throw new Error(`Profile '${newName}' already exists`);
+        }
+        state.profiles[newName] = state.profiles[oldName];
+        delete state.profiles[oldName];
+        if (state.credentials[oldName]) {
+            state.credentials[newName] = state.credentials[oldName];
+            delete state.credentials[oldName];
+        }
+        if (state.activeProfile === oldName) {
+            state.activeProfile = newName;
+        }
+        await this.writeState(state);
+    }
+    async updateCredentials(name, patch) {
+        await ensureConfigDir();
+        const credentialsText = await readIfExists(getCredentialsPath());
+        const credentialsDoc = credentialsText
+            ? (YAML.parse(credentialsText) ?? {})
+            : {};
+        credentialsDoc[name] = { ...(credentialsDoc[name] ?? {}), ...patch };
+        await atomicWrite(getCredentialsPath(), YAML.stringify(credentialsDoc), 0o600);
+    }
+    async listProfiles() {
+        const state = await this.read();
+        const names = new Set([
+            ...Object.keys(state.profiles),
+            ...Object.keys(state.credentials),
+        ]);
+        return Array.from(names).sort().map((name) => {
+            const hasConfig = Boolean(state.profiles[name]);
+            const hasCreds = Boolean(state.credentials[name]);
+            let s;
+            if (hasConfig && hasCreds)
+                s = 'ok';
+            else if (!hasConfig)
+                s = 'missing-config';
+            else
+                s = 'missing-credentials';
+            return { name, state: s, config: state.profiles[name] };
+        });
+    }
+    async writeState(state) {
+        const profilesDoc = {
+            activeProfile: state.activeProfile,
+            profiles: state.profiles,
+        };
+        await atomicWrite(getProfilesPath(), YAML.stringify(profilesDoc), 0o644);
+        await atomicWrite(getCredentialsPath(), YAML.stringify(state.credentials), 0o600);
+    }
+}
+async function readIfExists(path) {
+    try {
+        return await fs.readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+async function ensureConfigDir() {
+    const dir = getConfigDir();
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    // mkdir with `recursive: true` will not re-chmod an existing directory, so
+    // enforce 0o700 explicitly to close the loophole where a pre-existing dir
+    // (e.g. created by hand or by an older ccam version) has looser perms.
+    if (process.platform !== 'win32') {
+        await fs.chmod(dir, 0o700);
+    }
+}
+async function atomicWrite(target, content, mode) {
+    const tmp = `${target}.tmp-${randomBytes(4).toString('hex')}`;
+    await fs.writeFile(tmp, content, { mode });
+    await fs.rename(tmp, target);
+}
+//# sourceMappingURL=profile-store.js.map

package/dist/auth/prompt.d.ts

@@ -0,0 +1,9 @@
+export interface PromptOptions {
+    message: string;
+    defaultValue?: string;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function promptText(opts: PromptOptions): Promise<string>;
+export declare function promptPassword(opts: PromptOptions): Promise<string>;
+//# sourceMappingURL=prompt.d.ts.map