@j-256/ccam 0.1.0

package/dist/commands/org.js

@@ -0,0 +1,234 @@
+import { CcamNotFoundError } from 'ccam-sdk';
+import { addGlobalOptions, parseExpand, resolveGlobalOptions, writePageInfoIfTable } from '../shared.js';
+import { resolveProfile } from '../auth/profile-resolver.js';
+import { createClientFromResolved } from '../client-factory.js';
+import { handleError } from '../error-handler.js';
+import { renderOutput, resolveFormat } from '../output/index.js';
+import { DEFAULT_COLUMNS } from '../output/default-columns.js';
+const ORG_REALMS_EXPAND = ['instance'];
+export function selectOrgFinder(filters) {
+    if (filters.sfAccountId) {
+        return 'findBySfAccountId';
+    }
+    if (filters.name || filters.startsWith) {
+        return 'findByName';
+    }
+    return 'list';
+}
+async function resolveOrgId(client, idOrName) {
+    // Try direct get first (handles UUIDs and non-UUID IDs like "Demandware  Inc.")
+    try {
+        const org = await client.organizations.get(idOrName);
+        return org.id;
+    }
+    catch (err) {
+        if (!(err instanceof CcamNotFoundError))
+            throw err;
+    }
+    // Fall back to name search
+    const searchResult = await client.organizations.search.findByName({
+        term: idOrName,
+        page: 0,
+        size: 1,
+    });
+    if (!searchResult.content || searchResult.content.length === 0) {
+        process.stderr.write(`Error: No organization found with ID or name "${idOrName}"\n`);
+        process.exit(1);
+    }
+    return searchResult.content[0].id;
+}
+async function listOrgs(options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const filters = {
+            name: options.name,
+            startsWith: options.startsWith,
+            sfAccountId: options.sfAccountId,
+        };
+        const finder = selectOrgFinder(filters);
+        let result;
+        switch (finder) {
+            case 'list':
+                result = await client.organizations.list({
+                    page: resolved.page,
+                    size: resolved.size,
+                    sort: resolved.sort,
+                });
+                break;
+            case 'findByName':
+                result = await client.organizations.search.findByName({
+                    term: filters.name,
+                    startsWith: filters.startsWith,
+                    ignoreCase: options.ignoreCase,
+                    page: resolved.page,
+                    size: resolved.size,
+                });
+                break;
+            case 'findBySfAccountId':
+                result = await client.organizations.search.findBySfAccountId({
+                    sfAccountId: filters.sfAccountId,
+                    page: resolved.page,
+                    size: resolved.size,
+                });
+                break;
+        }
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.org });
+        writePageInfoIfTable(format, result);
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function getOrg(idOrName, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const orgId = await resolveOrgId(client, idOrName);
+        const result = await client.organizations.get(orgId);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.orgDetail });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function getOrgRealms(idOrName, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const orgId = await resolveOrgId(client, idOrName);
+        const expand = parseExpand(options.expand, ORG_REALMS_EXPAND);
+        const result = expand ? await client.organizations.realms(orgId, { expand }) : await client.organizations.realms(orgId);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.realm });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function getOrgInstances(idOrName, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const orgId = await resolveOrgId(client, idOrName);
+        const result = await client.organizations.instances(orgId);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.instance });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function auditOrg(idOrName, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const orgId = await resolveOrgId(client, idOrName);
+        const querySize = options.querySize !== undefined ? parseInt(options.querySize, 10) : undefined;
+        const result = await client.organizations.auditLogs(orgId, querySize !== undefined ? { querySize } : undefined);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.auditLog });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function updateOrg(id, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const data = {};
+        if (options.name !== undefined)
+            data.name = options.name;
+        if (options.contactUsers)
+            data.contactUsers = options.contactUsers.split(',');
+        if (options.emailDomains)
+            data.emailDomains = options.emailDomains.split(',');
+        if (options.passwordMinEntropy)
+            data.passwordMinEntropy = parseInt(options.passwordMinEntropy, 10);
+        if (options.type)
+            data.type = options.type;
+        const result = await client.organizations.update(id, data);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result, { format, fields: resolved.fields });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+export function registerOrgCommands(program) {
+    const org = program
+        .command('org')
+        .description('Manage organizations');
+    // org list
+    const list = org
+        .command('list')
+        .description('List organizations with optional filters');
+    addGlobalOptions(list)
+        .option('--name <name>', 'Search organizations by name (exact match)')
+        .option('--starts-with <prefix>', 'Search organizations by name prefix')
+        .option('--sf-account-id <id>', 'Find organization by Salesforce Account ID')
+        .option('--ignore-case', 'Case-insensitive name search (use with --name or --starts-with)')
+        .action(listOrgs);
+    // org get
+    const get = org
+        .command('get')
+        .argument('<idOrName>', 'Organization ID (UUID) or name')
+        .description('Get a specific organization');
+    addGlobalOptions(get).action(getOrg);
+    // org realms
+    const realms = org
+        .command('realms')
+        .argument('<idOrName>', 'Organization ID (UUID) or name')
+        .description('List realms belonging to an organization');
+    addGlobalOptions(realms)
+        .option('--expand <fields>', 'Expand related resources (instance)')
+        .action(getOrgRealms);
+    // org instances
+    const instances = org
+        .command('instances')
+        .argument('<idOrName>', 'Organization ID (UUID) or name')
+        .description('List instances belonging to an organization');
+    addGlobalOptions(instances).action(getOrgInstances);
+    // org audit
+    const audit = org
+        .command('audit')
+        .argument('<idOrName>', 'Organization ID (UUID) or name')
+        .description('Get audit log for an organization');
+    addGlobalOptions(audit)
+        .option('--query-size <n>', 'Limit audit log query window size')
+        .action(auditOrg);
+    // org update
+    const update = org
+        .command('update')
+        .argument('<id>', 'Organization ID')
+        .description('Update an organization');
+    addGlobalOptions(update)
+        .option('--name <name>', 'Organization name')
+        .option('--contact-users <ids>', 'Comma-separated contact user IDs')
+        .option('--email-domains <domains>', 'Comma-separated email domains')
+        .option('--password-min-entropy <n>', 'Minimum password entropy')
+        .option('--type <type>', 'Organization type')
+        .action(updateOrg);
+}
+//# sourceMappingURL=org.js.map

package/dist/commands/permission.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerPermissionCommands(program: Command): void;
+//# sourceMappingURL=permission.d.ts.map

package/dist/commands/permission.js

@@ -0,0 +1,60 @@
+import { addGlobalOptions, resolveGlobalOptions, writePageInfoIfTable } from '../shared.js';
+import { resolveProfile } from '../auth/profile-resolver.js';
+import { createClientFromResolved } from '../client-factory.js';
+import { handleError } from '../error-handler.js';
+import { renderOutput, resolveFormat } from '../output/index.js';
+import { DEFAULT_COLUMNS } from '../output/default-columns.js';
+async function getPermission(name, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const result = await client.permissions.get(name);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.permission });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function listPermissions(options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const result = await client.permissions.list({
+            page: resolved.page,
+            size: resolved.size,
+            ...(options.admin !== undefined ? { adminPermission: options.admin } : {}),
+        });
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.permission });
+        writePageInfoIfTable(format, result);
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+export function registerPermissionCommands(program) {
+    const permission = program
+        .command('permission')
+        .description('Manage permissions');
+    // permission list
+    const list = permission
+        .command('list')
+        .description('List permissions');
+    addGlobalOptions(list)
+        .option('--admin', 'Filter to admin permissions only')
+        .action(listPermissions);
+    // permission get
+    const get = permission
+        .command('get')
+        .argument('<name>', 'Permission name (e.g. "READ_USER", "WRITE_ORGANIZATION")')
+        .description('Get a specific permission');
+    addGlobalOptions(get).action(getPermission);
+}
+//# sourceMappingURL=permission.js.map

package/dist/commands/realm.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerRealmCommands(program: Command): void;
+//# sourceMappingURL=realm.d.ts.map

package/dist/commands/realm.js

@@ -0,0 +1,58 @@
+import { addGlobalOptions, resolveGlobalOptions, writePageInfoIfTable } from '../shared.js';
+import { resolveProfile } from '../auth/profile-resolver.js';
+import { createClientFromResolved } from '../client-factory.js';
+import { handleError } from '../error-handler.js';
+import { renderOutput, resolveFormat } from '../output/index.js';
+import { DEFAULT_COLUMNS } from '../output/default-columns.js';
+async function listRealms(options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const result = await client.realms.list({
+            page: resolved.page,
+            size: resolved.size,
+            sort: resolved.sort,
+        });
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.realm });
+        writePageInfoIfTable(format, result);
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function getRealm(id, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const result = await client.realms.get(id);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.realm });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+export function registerRealmCommands(program) {
+    const realm = program
+        .command('realm')
+        .description('Manage realms');
+    // realm list
+    const list = realm
+        .command('list')
+        .description('List realms');
+    addGlobalOptions(list).action(listRealms);
+    // realm get
+    const get = realm
+        .command('get')
+        .argument('<id>', 'Realm ID (4-character code)')
+        .description('Get a specific realm');
+    addGlobalOptions(get).action(getRealm);
+}
+//# sourceMappingURL=realm.js.map

package/dist/commands/role.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerRoleCommands(program: Command): void;
+//# sourceMappingURL=role.d.ts.map

package/dist/commands/role.js

@@ -0,0 +1,77 @@
+import { addGlobalOptions, parseExpand, resolveGlobalOptions, writePageInfoIfTable } from '../shared.js';
+import { resolveProfile } from '../auth/profile-resolver.js';
+import { createClientFromResolved } from '../client-factory.js';
+import { handleError } from '../error-handler.js';
+import { renderOutput, resolveFormat } from '../output/index.js';
+import { DEFAULT_COLUMNS } from '../output/default-columns.js';
+const ROLE_EXPAND = ['serviceType'];
+async function listRoles(options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const baseOpts = {
+            page: resolved.page,
+            size: resolved.size,
+            sort: resolved.sort,
+        };
+        const expand = parseExpand(options.expand, ROLE_EXPAND);
+        let result;
+        if (expand === 'serviceType') {
+            result = await client.roles.list({
+                ...baseOpts,
+                expand,
+                ...(options.targetType !== undefined ? { roleTargetType: options.targetType } : {}),
+            });
+        }
+        else {
+            result = await client.roles.list(baseOpts);
+        }
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.role });
+        writePageInfoIfTable(format, result);
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function getRole(id, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const expand = parseExpand(options.expand, ROLE_EXPAND);
+        const result = expand ? await client.roles.get(id, { expand }) : await client.roles.get(id);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.roleDetail });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+export function registerRoleCommands(program) {
+    const role = program
+        .command('role')
+        .description('Manage roles');
+    // role list
+    const list = role
+        .command('list')
+        .description('List roles');
+    addGlobalOptions(list)
+        .option('--expand <fields>', 'Expand related resources (serviceType)')
+        .option('--target-type <type>', 'Filter by role target type (User, ApiClient)')
+        .action(listRoles);
+    // role get
+    const get = role
+        .command('get')
+        .argument('<id>', 'Role ID')
+        .description('Get a specific role');
+    addGlobalOptions(get)
+        .option('--expand <fields>', 'Expand related resources (serviceType)')
+        .action(getRole);
+}
+//# sourceMappingURL=role.js.map

package/dist/commands/service-type.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerServiceTypeCommands(program: Command): void;
+//# sourceMappingURL=service-type.d.ts.map

package/dist/commands/service-type.js

@@ -0,0 +1,57 @@
+import { addGlobalOptions, resolveGlobalOptions, writePageInfoIfTable } from '../shared.js';
+import { resolveProfile } from '../auth/profile-resolver.js';
+import { createClientFromResolved } from '../client-factory.js';
+import { handleError } from '../error-handler.js';
+import { renderOutput, resolveFormat } from '../output/index.js';
+import { DEFAULT_COLUMNS } from '../output/default-columns.js';
+async function getServiceType(id, options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const result = await client.serviceTypes.get(id);
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.serviceType });
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+async function listServiceTypes(options) {
+    try {
+        const resolved = resolveGlobalOptions(options);
+        const profileResolved = await resolveProfile({
+            flags: { profile: options.profile, host: resolved.host },
+        });
+        const client = await createClientFromResolved(profileResolved);
+        const result = await client.serviceTypes.list({
+            page: resolved.page,
+            size: resolved.size,
+        });
+        const format = resolveFormat(resolved.format, process.stdout.isTTY);
+        renderOutput(result.content, { format, fields: resolved.fields, defaultFields: DEFAULT_COLUMNS.serviceType });
+        writePageInfoIfTable(format, result);
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+export function registerServiceTypeCommands(program) {
+    const serviceType = program
+        .command('service-type')
+        .description('Manage service types');
+    // service-type list
+    const list = serviceType
+        .command('list')
+        .description('List service types');
+    addGlobalOptions(list).action(listServiceTypes);
+    // service-type get
+    const get = serviceType
+        .command('get')
+        .argument('<id>', 'Service type ID (e.g. "ECOM", "CDN")')
+        .description('Get a specific service type');
+    addGlobalOptions(get).action(getServiceType);
+}
+//# sourceMappingURL=service-type.js.map

package/dist/commands/user.d.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+interface UserFilters {
+    login?: string;
+    org?: string;
+    role?: string;
+    orgRealmAccess?: string;
+    modifiedAfter?: string;
+    all?: boolean;
+}
+type UserFinder = 'list' | 'findByLogin' | 'findByOrg' | 'findAllByOrg' | 'findByRole' | 'findByOrgAndRole' | 'findByOrgRealmAccess';
+export declare function selectUserFinder(filters: UserFilters): UserFinder;
+export declare function registerUserCommands(program: Command): void;
+export {};
+//# sourceMappingURL=user.d.ts.map