geni-bioinfo 0.1.0

package/dist/commands/setup/create.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommand = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const commander_1 = require("commander");
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const client_iam_1 = require("@aws-sdk/client-iam");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const clients_1 = require("../../aws/clients");
+const errors_1 = require("../../errors");
+const STACK_NAME = 'geni-setup';
+function parseBucketList(value) {
+    if (!value)
+        return [];
+    return value.split(',').map(b => b.trim()).filter(Boolean);
+}
+function buildBucketPolicy(bucket, mode, account) {
+    const condition = {
+        StringEquals: {
+            'aws:PrincipalAccount': account,
+        },
+        StringLike: {
+            'aws:PrincipalTag/GeniName': [
+                'geni-engine-*',
+                'geni-batch-*',
+            ],
+        },
+    };
+    const statements = [];
+    if (mode === 'read-write' || mode === 'read-only') {
+        statements.push({
+            Sid: 'GeniListBucket',
+            Effect: 'Allow',
+            Principal: '*',
+            Action: 's3:ListBucket',
+            Resource: `arn:aws:s3:::${bucket}`,
+            Condition: condition,
+        });
+    }
+    const actions = [];
+    if (mode === 'read-write') {
+        actions.push('s3:GetObject', 's3:PutObject', 's3:DeleteObject');
+    }
+    else if (mode === 'read-only') {
+        actions.push('s3:GetObject');
+    }
+    else {
+        actions.push('s3:PutObject', 's3:DeleteObject');
+    }
+    statements.push({
+        Sid: 'GeniObjectAccess',
+        Effect: 'Allow',
+        Principal: '*',
+        Action: actions,
+        Resource: `arn:aws:s3:::${bucket}/*`,
+        Condition: condition,
+    });
+    return JSON.stringify({ Version: '2012-10-17', Statement: statements });
+}
+exports.createCommand = new commander_1.Command('create')
+    .alias('activate')
+    .description('Create IAM roles and policies for Geni cross-account access')
+    .argument('<uri>', 'Target AWS account URI (aws://<account>/<region>)')
+    .option('--geni-account <account>', 'Geni AWS account ID to trust', '880420038460')
+    .option('--trust <account>', 'Alias for --geni-account')
+    .option('--read-write-buckets <buckets>', 'Comma-separated list of existing S3 buckets to grant read-write access')
+    .option('--read-only-buckets <buckets>', 'Comma-separated list of existing S3 buckets to grant read-only access')
+    .option('--write-only-buckets <buckets>', 'Comma-separated list of existing S3 buckets to grant write-only access')
+    .option('--profile <profile>', 'AWS profile to use for credentials')
+    .action(async (uri, options) => {
+    const { account, region } = (0, clients_1.parseAwsUri)(uri);
+    const { cfn, iam, s3, sts } = (0, clients_1.createClients)(region, options.profile);
+    const identity = await (0, clients_1.getCallerIdentity)(sts);
+    console.log(`Authenticated as ${identity.arn} (account ${identity.account})`);
+    if (identity.account !== account) {
+        console.warn(`Warning: Current account (${identity.account}) does not match target (${account}). ` +
+            `Ensure you have credentials for the target account.`);
+    }
+    const templateBody = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../templates/setup.yaml'), 'utf-8');
+    const trustedAccount = options.trust ?? options.geniAccount;
+    const parameters = [
+        { ParameterKey: 'GeniAccount', ParameterValue: trustedAccount },
+    ];
+    const tags = [{ Key: 'CreatedBy', Value: 'GENI' }];
+    let needsPoll = null;
+    let stackAlreadyUpToDate = false;
+    try {
+        await cfn.send(new client_cloudformation_1.CreateStackCommand({
+            StackName: STACK_NAME,
+            TemplateBody: templateBody,
+            Capabilities: ['CAPABILITY_NAMED_IAM'],
+            Parameters: parameters,
+            Tags: tags,
+        }));
+        console.log(`Creating stack ${STACK_NAME}...`);
+        needsPoll = 'CREATE';
+    }
+    catch (err) {
+        if (err.name === 'AlreadyExistsException') {
+            try {
+                await cfn.send(new client_cloudformation_1.UpdateStackCommand({
+                    StackName: STACK_NAME,
+                    TemplateBody: templateBody,
+                    Capabilities: ['CAPABILITY_NAMED_IAM'],
+                    Parameters: parameters,
+                    Tags: tags,
+                }));
+                console.log(`Updating stack ${STACK_NAME}...`);
+                needsPoll = 'UPDATE';
+            }
+            catch (updateErr) {
+                const message = updateErr instanceof Error ? updateErr.message : '';
+                if (message.includes('No updates are to be performed')) {
+                    console.log(`Stack ${STACK_NAME} is already up to date.`);
+                    stackAlreadyUpToDate = true;
+                }
+                else {
+                    throw updateErr;
+                }
+            }
+        }
+        else {
+            // Stack does not exist in this region. IAM roles are global — if they already
+            // exist they were created via a stack in another region; skip silently.
+            const iamRolesExist = await checkIAMRolesExist(iam);
+            if (iamRolesExist) {
+                console.log('\nIAM roles already exist in this account (GeniCrossAccountRole, GeniCfnServiceRole).\n' +
+                    'Skipping CloudFormation stack — IAM roles are global and shared across all regions.\n' +
+                    'To update role permissions, run this command against the region where the stack was first created.');
+                console.log(`\n  GeniCrossAccountRole: arn:aws:iam::${account}:role/GeniCrossAccountRole`);
+                console.log(`  GeniCfnServiceRole:   arn:aws:iam::${account}:role/GeniCfnServiceRole`);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    if (needsPoll) {
+        const outputs = await pollStack(cfn, STACK_NAME, needsPoll);
+        console.log('\nSetup complete:');
+        printRoleArns(outputs);
+        for (const output of outputs) {
+            console.log(`  ${output.OutputKey}: ${output.OutputValue}`);
+        }
+    }
+    else if (stackAlreadyUpToDate) {
+        const outputs = await getStackOutputs(cfn, STACK_NAME);
+        if (outputs.length > 0) {
+            console.log('\nExisting role ARNs:');
+            printRoleArns(outputs);
+        }
+    }
+    const bucketConfigs = [
+        ...parseBucketList(options.readWriteBuckets).map(b => ({ bucket: b, mode: 'read-write' })),
+        ...parseBucketList(options.readOnlyBuckets).map(b => ({ bucket: b, mode: 'read-only' })),
+        ...parseBucketList(options.writeOnlyBuckets).map(b => ({ bucket: b, mode: 'write-only' })),
+    ];
+    if (bucketConfigs.length > 0) {
+        console.log('\nConfiguring bucket permissions...');
+        const bucketFailures = [];
+        for (const { bucket, mode } of bucketConfigs) {
+            try {
+                let existingTags = [];
+                try {
+                    const tagging = await s3.send(new client_s3_1.GetBucketTaggingCommand({ Bucket: bucket }));
+                    existingTags = tagging.TagSet ?? [];
+                }
+                catch (err) {
+                    if (err.name !== 'NoSuchTagSet')
+                        throw err;
+                }
+                const filteredTags = existingTags.filter(t => t.Key !== 'CreatedBy' && t.Key !== 'GeniPermission');
+                filteredTags.push({ Key: 'CreatedBy', Value: 'GENI' }, { Key: 'GeniPermission', Value: mode });
+                await s3.send(new client_s3_1.PutBucketTaggingCommand({
+                    Bucket: bucket,
+                    Tagging: { TagSet: filteredTags },
+                }));
+                const policy = buildBucketPolicy(bucket, mode, account);
+                await s3.send(new client_s3_1.PutBucketPolicyCommand({ Bucket: bucket, Policy: policy }));
+                console.log(`  ${bucket}: ${mode}`);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.error(`  ${bucket}: FAILED - ${message}`);
+                bucketFailures.push({ bucket, mode, message });
+            }
+        }
+        if (bucketFailures.length > 0) {
+            throw new errors_1.CliError({
+                code: 'UPSTREAM',
+                message: `Failed to configure ${bucketFailures.length} bucket permission update(s).`,
+                hint: 'Fix failed bucket permissions and rerun `geni setup create`.',
+                exitCode: 5,
+                details: { failures: bucketFailures },
+            });
+        }
+    }
+});
+async function checkIAMRolesExist(iam) {
+    try {
+        await iam.send(new client_iam_1.GetRoleCommand({ RoleName: 'GeniCrossAccountRole' }));
+        return true;
+    }
+    catch (err) {
+        if (err.name === 'NoSuchEntityException') {
+            return false;
+        }
+        throw err;
+    }
+}
+async function pollStack(cfn, stackName, operation) {
+    const successState = `${operation}_COMPLETE`;
+    const failureStates = [
+        `${operation}_FAILED`,
+        'ROLLBACK_COMPLETE',
+        'ROLLBACK_FAILED',
+        'UPDATE_ROLLBACK_COMPLETE',
+        'UPDATE_ROLLBACK_FAILED',
+    ];
+    for (;;) {
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        const { Stacks } = await cfn.send(new client_cloudformation_1.DescribeStacksCommand({ StackName: stackName }));
+        const stack = Stacks?.[0];
+        if (!stack) {
+            throw new Error(`Stack ${stackName} not found`);
+        }
+        const status = stack.StackStatus ?? '';
+        process.stdout.write(`  Status: ${status}\n`);
+        if (status === successState) {
+            return stack.Outputs ?? [];
+        }
+        if (failureStates.includes(status)) {
+            throw new Error(`Stack ${stackName} reached failure state: ${status}`);
+        }
+    }
+}
+async function getStackOutputs(cfn, stackName) {
+    const { Stacks } = await cfn.send(new client_cloudformation_1.DescribeStacksCommand({ StackName: stackName }));
+    return Stacks?.[0]?.Outputs ?? [];
+}
+function printRoleArns(outputs) {
+    const roleArns = [
+        { key: 'CrossAccountRoleArn', label: 'GeniCrossAccountRole' },
+        { key: 'CfnServiceRoleArn', label: 'GeniCfnServiceRole' },
+    ];
+    for (const roleArn of roleArns) {
+        const output = outputs.find(o => o.OutputKey === roleArn.key);
+        if (output?.OutputValue) {
+            console.log(`  ${roleArn.label}: ${output.OutputValue}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../src/commands/setup/create.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync } from 'fs';\nimport { join } from 'path';\nimport { Command } from 'commander';\nimport {\n    CreateStackCommand,\n    UpdateStackCommand,\n    DescribeStacksCommand,\n} from '@aws-sdk/client-cloudformation';\nimport { GetRoleCommand } from '@aws-sdk/client-iam';\nimport {\n    GetBucketTaggingCommand,\n    PutBucketTaggingCommand,\n    PutBucketPolicyCommand,\n} from '@aws-sdk/client-s3';\nimport { createClients, getCallerIdentity, parseAwsUri } from '../../aws/clients';\nimport { CliError } from '../../errors';\n\nconst STACK_NAME = 'geni-setup';\n\ntype PermissionMode = 'read-write' | 'read-only' | 'write-only';\n\ninterface CreateOptions {\n    geniAccount: string;\n    trust?: string;\n    readWriteBuckets?: string;\n    readOnlyBuckets?: string;\n    writeOnlyBuckets?: string;\n    profile?: string;\n}\n\ntype StackOutput = { OutputKey?: string; OutputValue?: string };\n\nfunction parseBucketList(value?: string): string[] {\n    if (!value) return [];\n    return value.split(',').map(b => b.trim()).filter(Boolean);\n}\n\nfunction buildBucketPolicy(\n    bucket: string,\n    mode: PermissionMode,\n    account: string,\n): string {\n    const condition = {\n        StringEquals: {\n            'aws:PrincipalAccount': account,\n        },\n        StringLike: {\n            'aws:PrincipalTag/GeniName': [\n                'geni-engine-*',\n                'geni-batch-*',\n            ],\n        },\n    };\n\n    const statements: object[] = [];\n\n    if (mode === 'read-write' || mode === 'read-only') {\n        statements.push({\n            Sid: 'GeniListBucket',\n            Effect: 'Allow',\n            Principal: '*',\n            Action: 's3:ListBucket',\n            Resource: `arn:aws:s3:::${bucket}`,\n            Condition: condition,\n        });\n    }\n\n    const actions: string[] = [];\n    if (mode === 'read-write') {\n        actions.push('s3:GetObject', 's3:PutObject', 's3:DeleteObject');\n    } else if (mode === 'read-only') {\n        actions.push('s3:GetObject');\n    } else {\n        actions.push('s3:PutObject', 's3:DeleteObject');\n    }\n\n    statements.push({\n        Sid: 'GeniObjectAccess',\n        Effect: 'Allow',\n        Principal: '*',\n        Action: actions,\n        Resource: `arn:aws:s3:::${bucket}/*`,\n        Condition: condition,\n    });\n\n    return JSON.stringify({ Version: '2012-10-17', Statement: statements });\n}\n\nexport const createCommand = new Command('create')\n    .alias('activate')\n    .description('Create IAM roles and policies for Geni cross-account access')\n    .argument('<uri>', 'Target AWS account URI (aws://<account>/<region>)')\n    .option('--geni-account <account>', 'Geni AWS account ID to trust', '880420038460')\n    .option('--trust <account>', 'Alias for --geni-account')\n    .option('--read-write-buckets <buckets>', 'Comma-separated list of existing S3 buckets to grant read-write access')\n    .option('--read-only-buckets <buckets>', 'Comma-separated list of existing S3 buckets to grant read-only access')\n    .option('--write-only-buckets <buckets>', 'Comma-separated list of existing S3 buckets to grant write-only access')\n    .option('--profile <profile>', 'AWS profile to use for credentials')\n    .action(async (uri: string, options: CreateOptions) => {\n        const { account, region } = parseAwsUri(uri);\n        const { cfn, iam, s3, sts } = createClients(region, options.profile);\n        const identity = await getCallerIdentity(sts);\n        console.log(`Authenticated as ${identity.arn} (account ${identity.account})`);\n\n        if (identity.account !== account) {\n            console.warn(\n                `Warning: Current account (${identity.account}) does not match target (${account}). ` +\n                `Ensure you have credentials for the target account.`\n            );\n        }\n\n        const templateBody = readFileSync(join(__dirname, '../../templates/setup.yaml'), 'utf-8');\n        const trustedAccount = options.trust ?? options.geniAccount;\n        const parameters = [\n            { ParameterKey: 'GeniAccount', ParameterValue: trustedAccount },\n        ];\n        const tags = [{ Key: 'CreatedBy', Value: 'GENI' }];\n\n        let needsPoll: 'CREATE' | 'UPDATE' | null = null;\n        let stackAlreadyUpToDate = false;\n        try {\n            await cfn.send(new CreateStackCommand({\n                StackName: STACK_NAME,\n                TemplateBody: templateBody,\n                Capabilities: ['CAPABILITY_NAMED_IAM'],\n                Parameters: parameters,\n                Tags: tags,\n            }));\n            console.log(`Creating stack ${STACK_NAME}...`);\n            needsPoll = 'CREATE';\n        } catch (err: unknown) {\n            if ((err as { name?: string }).name === 'AlreadyExistsException') {\n                try {\n                    await cfn.send(new UpdateStackCommand({\n                        StackName: STACK_NAME,\n                        TemplateBody: templateBody,\n                        Capabilities: ['CAPABILITY_NAMED_IAM'],\n                        Parameters: parameters,\n                        Tags: tags,\n                    }));\n                    console.log(`Updating stack ${STACK_NAME}...`);\n                    needsPoll = 'UPDATE';\n                } catch (updateErr: unknown) {\n                    const message = updateErr instanceof Error ? updateErr.message : '';\n                    if (message.includes('No updates are to be performed')) {\n                        console.log(`Stack ${STACK_NAME} is already up to date.`);\n                        stackAlreadyUpToDate = true;\n                    } else {\n                        throw updateErr;\n                    }\n                }\n            } else {\n                // Stack does not exist in this region. IAM roles are global — if they already\n                // exist they were created via a stack in another region; skip silently.\n                const iamRolesExist = await checkIAMRolesExist(iam);\n                if (iamRolesExist) {\n                    console.log(\n                        '\\nIAM roles already exist in this account (GeniCrossAccountRole, GeniCfnServiceRole).\\n' +\n                        'Skipping CloudFormation stack — IAM roles are global and shared across all regions.\\n' +\n                        'To update role permissions, run this command against the region where the stack was first created.'\n                    );\n                    console.log(`\\n  GeniCrossAccountRole: arn:aws:iam::${account}:role/GeniCrossAccountRole`);\n                    console.log(`  GeniCfnServiceRole:   arn:aws:iam::${account}:role/GeniCfnServiceRole`);\n                } else {\n                    throw err;\n                }\n            }\n        }\n\n        if (needsPoll) {\n            const outputs = await pollStack(cfn, STACK_NAME, needsPoll);\n            console.log('\\nSetup complete:');\n            printRoleArns(outputs);\n            for (const output of outputs) {\n                console.log(`  ${output.OutputKey}: ${output.OutputValue}`);\n            }\n        } else if (stackAlreadyUpToDate) {\n            const outputs = await getStackOutputs(cfn, STACK_NAME);\n            if (outputs.length > 0) {\n                console.log('\\nExisting role ARNs:');\n                printRoleArns(outputs);\n            }\n        }\n\n        const bucketConfigs: Array<{ bucket: string; mode: PermissionMode }> = [\n            ...parseBucketList(options.readWriteBuckets).map(b => ({ bucket: b, mode: 'read-write' as const })),\n            ...parseBucketList(options.readOnlyBuckets).map(b => ({ bucket: b, mode: 'read-only' as const })),\n            ...parseBucketList(options.writeOnlyBuckets).map(b => ({ bucket: b, mode: 'write-only' as const })),\n        ];\n\n        if (bucketConfigs.length > 0) {\n            console.log('\\nConfiguring bucket permissions...');\n            const bucketFailures: Array<{ bucket: string; mode: PermissionMode; message: string }> = [];\n\n            for (const { bucket, mode } of bucketConfigs) {\n                try {\n                    let existingTags: Array<{ Key?: string; Value?: string }> = [];\n                    try {\n                        const tagging = await s3.send(new GetBucketTaggingCommand({ Bucket: bucket }));\n                        existingTags = tagging.TagSet ?? [];\n                    } catch (err: unknown) {\n                        if ((err as { name?: string }).name !== 'NoSuchTagSet') throw err;\n                    }\n\n                    const filteredTags = existingTags.filter(\n                        t => t.Key !== 'CreatedBy' && t.Key !== 'GeniPermission',\n                    );\n                    filteredTags.push(\n                        { Key: 'CreatedBy', Value: 'GENI' },\n                        { Key: 'GeniPermission', Value: mode },\n                    );\n\n                    await s3.send(new PutBucketTaggingCommand({\n                        Bucket: bucket,\n                        Tagging: { TagSet: filteredTags as Array<{ Key: string; Value: string }> },\n                    }));\n\n                    const policy = buildBucketPolicy(bucket, mode, account);\n                    await s3.send(new PutBucketPolicyCommand({ Bucket: bucket, Policy: policy }));\n\n                    console.log(`  ${bucket}: ${mode}`);\n                } catch (err) {\n                    const message = err instanceof Error ? err.message : String(err);\n                    console.error(`  ${bucket}: FAILED - ${message}`);\n                    bucketFailures.push({ bucket, mode, message });\n                }\n            }\n\n            if (bucketFailures.length > 0) {\n                throw new CliError({\n                    code: 'UPSTREAM',\n                    message: `Failed to configure ${bucketFailures.length} bucket permission update(s).`,\n                    hint: 'Fix failed bucket permissions and rerun `geni setup create`.',\n                    exitCode: 5,\n                    details: { failures: bucketFailures },\n                });\n            }\n        }\n    });\n\nasync function checkIAMRolesExist(\n    iam: import('@aws-sdk/client-iam').IAMClient,\n): Promise<boolean> {\n    try {\n        await iam.send(new GetRoleCommand({ RoleName: 'GeniCrossAccountRole' }));\n        return true;\n    } catch (err: unknown) {\n        if ((err as { name?: string }).name === 'NoSuchEntityException') {\n            return false;\n        }\n        throw err;\n    }\n}\n\nasync function pollStack(\n    cfn: import('@aws-sdk/client-cloudformation').CloudFormationClient,\n    stackName: string,\n    operation: 'CREATE' | 'UPDATE',\n): Promise<StackOutput[]> {\n    const successState = `${operation}_COMPLETE`;\n    const failureStates = [\n        `${operation}_FAILED`,\n        'ROLLBACK_COMPLETE',\n        'ROLLBACK_FAILED',\n        'UPDATE_ROLLBACK_COMPLETE',\n        'UPDATE_ROLLBACK_FAILED',\n    ];\n\n    for (; ;) {\n        await new Promise((resolve) => setTimeout(resolve, 5000));\n\n        const { Stacks } = await cfn.send(new DescribeStacksCommand({ StackName: stackName }));\n        const stack = Stacks?.[0];\n        if (!stack) {\n            throw new Error(`Stack ${stackName} not found`);\n        }\n\n        const status = stack.StackStatus ?? '';\n        process.stdout.write(`  Status: ${status}\\n`);\n\n        if (status === successState) {\n            return stack.Outputs ?? [];\n        }\n\n        if (failureStates.includes(status)) {\n            throw new Error(`Stack ${stackName} reached failure state: ${status}`);\n        }\n    }\n}\n\nasync function getStackOutputs(\n    cfn: import('@aws-sdk/client-cloudformation').CloudFormationClient,\n    stackName: string,\n): Promise<StackOutput[]> {\n    const { Stacks } = await cfn.send(new DescribeStacksCommand({ StackName: stackName }));\n    return Stacks?.[0]?.Outputs ?? [];\n}\n\nfunction printRoleArns(outputs: StackOutput[]): void {\n    const roleArns = [\n        { key: 'CrossAccountRoleArn', label: 'GeniCrossAccountRole' },\n        { key: 'CfnServiceRoleArn', label: 'GeniCfnServiceRole' },\n    ];\n\n    for (const roleArn of roleArns) {\n        const output = outputs.find(o => o.OutputKey === roleArn.key);\n        if (output?.OutputValue) {\n            console.log(`  ${roleArn.label}: ${output.OutputValue}`);\n        }\n    }\n}\n"]}

package/dist/commands/setup/delete.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const deleteCommand: Command;

package/dist/commands/setup/delete.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCommand = void 0;
+const readline = __importStar(require("readline"));
+const commander_1 = require("commander");
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const clients_1 = require("../../aws/clients");
+const STACK_NAME = 'geni-setup';
+exports.deleteCommand = new commander_1.Command('destroy')
+    .description('Remove Geni cross-account roles and policies')
+    .argument('<uri>', 'Target AWS account URI (aws://<account>/<region>)')
+    .option('--force', 'Skip confirmation prompt')
+    .option('--profile <profile>', 'AWS profile to use for credentials')
+    .action(async (uri, options) => {
+    const { account, region } = (0, clients_1.parseAwsUri)(uri);
+    const { cfn } = (0, clients_1.createClients)(region, options.profile);
+    if (!options.force) {
+        const confirmed = await confirm(`This will delete the Geni roles and policies from account ${account}. Continue? (y/N) `);
+        if (!confirmed) {
+            console.log('Aborted.');
+            return;
+        }
+    }
+    await cfn.send(new client_cloudformation_1.DeleteStackCommand({ StackName: STACK_NAME }));
+    console.log(`Deleting stack ${STACK_NAME}...`);
+    await pollDelete(cfn, STACK_NAME);
+    console.log('\nGeni setup removed.');
+});
+async function pollDelete(cfn, stackName) {
+    for (;;) {
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        try {
+            const { Stacks } = await cfn.send(new client_cloudformation_1.DescribeStacksCommand({ StackName: stackName }));
+            const status = Stacks?.[0]?.StackStatus ?? '';
+            process.stdout.write(`  Status: ${status}\n`);
+            if (status === 'DELETE_COMPLETE') {
+                return;
+            }
+            if (status === 'DELETE_FAILED') {
+                throw new Error(`Stack ${stackName} delete failed`);
+            }
+        }
+        catch (err) {
+            const message = err.message ?? '';
+            if (message.includes('does not exist')) {
+                return;
+            }
+            throw err;
+        }
+    }
+}
+function confirm(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(message, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/setup/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const statusCommand: Command;

package/dist/commands/setup/status.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = void 0;
+const commander_1 = require("commander");
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const clients_1 = require("../../aws/clients");
+const STACK_NAME = 'geni-setup';
+exports.statusCommand = new commander_1.Command('status')
+    .description('Check the status of Geni cross-account setup')
+    .argument('<uri>', 'Target AWS account URI (aws://<account>/<region>)')
+    .option('--profile <profile>', 'AWS profile to use for credentials')
+    .action(async (uri, options) => {
+    const { account, region } = (0, clients_1.parseAwsUri)(uri);
+    const { cfn } = (0, clients_1.createClients)(region, options.profile);
+    console.log(`Checking Geni setup in account ${account} (${region})...\n`);
+    try {
+        const { Stacks } = await cfn.send(new client_cloudformation_1.DescribeStacksCommand({ StackName: STACK_NAME }));
+        const stack = Stacks?.[0];
+        if (!stack) {
+            console.log('Geni setup not found. Run `geni setup create` to set up.');
+            return;
+        }
+        console.log(`Stack:   ${stack.StackName}`);
+        console.log(`Status:  ${stack.StackStatus}`);
+        console.log(`Created: ${stack.CreationTime?.toISOString()}`);
+        if (stack.LastUpdatedTime) {
+            console.log(`Updated: ${stack.LastUpdatedTime.toISOString()}`);
+        }
+        if (stack.Outputs && stack.Outputs.length > 0) {
+            console.log('\nOutputs:');
+            for (const output of stack.Outputs) {
+                console.log(`  ${output.OutputKey}: ${output.OutputValue}`);
+            }
+        }
+    }
+    catch (err) {
+        const message = err.message ?? '';
+        if (message.includes('does not exist')) {
+            console.log('Geni setup not found. Run `geni setup create` to set up.');
+        }
+        else {
+            throw err;
+        }
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/setup.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const setupCommand: Command;

package/dist/commands/setup.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCommand = void 0;
+const commander_1 = require("commander");
+const create_1 = require("./setup/create");
+const status_1 = require("./setup/status");
+const delete_1 = require("./setup/delete");
+exports.setupCommand = new commander_1.Command('setup')
+    .description('Manage AWS cross-account setup for Geni')
+    .addCommand(create_1.createCommand)
+    .addCommand(status_1.statusCommand)
+    .addCommand(delete_1.deleteCommand);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbWFuZHMvc2V0dXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEseUNBQW9DO0FBQ3BDLDJDQUErQztBQUMvQywyQ0FBK0M7QUFDL0MsMkNBQStDO0FBRWxDLFFBQUEsWUFBWSxHQUFHLElBQUksbUJBQU8sQ0FBQyxPQUFPLENBQUM7S0FDM0MsV0FBVyxDQUFDLHlDQUF5QyxDQUFDO0tBQ3RELFVBQVUsQ0FBQyxzQkFBYSxDQUFDO0tBQ3pCLFVBQVUsQ0FBQyxzQkFBYSxDQUFDO0tBQ3pCLFVBQVUsQ0FBQyxzQkFBYSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tYW5kIH0gZnJvbSAnY29tbWFuZGVyJztcbmltcG9ydCB7IGNyZWF0ZUNvbW1hbmQgfSBmcm9tICcuL3NldHVwL2NyZWF0ZSc7XG5pbXBvcnQgeyBzdGF0dXNDb21tYW5kIH0gZnJvbSAnLi9zZXR1cC9zdGF0dXMnO1xuaW1wb3J0IHsgZGVsZXRlQ29tbWFuZCB9IGZyb20gJy4vc2V0dXAvZGVsZXRlJztcblxuZXhwb3J0IGNvbnN0IHNldHVwQ29tbWFuZCA9IG5ldyBDb21tYW5kKCdzZXR1cCcpXG4gICAgLmRlc2NyaXB0aW9uKCdNYW5hZ2UgQVdTIGNyb3NzLWFjY291bnQgc2V0dXAgZm9yIEdlbmknKVxuICAgIC5hZGRDb21tYW5kKGNyZWF0ZUNvbW1hbmQpXG4gICAgLmFkZENvbW1hbmQoc3RhdHVzQ29tbWFuZClcbiAgICAuYWRkQ29tbWFuZChkZWxldGVDb21tYW5kKTtcbiJdfQ==

package/dist/commands/storage.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const storageCommand: Command;

package/dist/commands/storage.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageCommand = void 0;
+const commander_1 = require("commander");
+const auth_1 = require("../auth");
+const format_js_1 = require("../format.js");
+exports.storageCommand = new commander_1.Command('storage')
+    .description('Manage storages');
+exports.storageCommand
+    .command('list')
+    .description('List storages')
+    .option('--status <status>', 'Filter by status (e.g. ACTIVE, PENDING, FAILED, DELETED)')
+    .option('--environment-id <id>', 'Filter by environment ID')
+    .addOption(new commander_1.Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))
+    .action(async (opts) => {
+    const params = new URLSearchParams();
+    if (opts.status)
+        params.set('status', opts.status);
+    if (opts.environmentId)
+        params.set('environmentId', opts.environmentId);
+    if (process.env.GENI_TENANT_ID)
+        params.set('tenantId', process.env.GENI_TENANT_ID);
+    const query = params.size ? `?${params}` : '';
+    const data = await (0, auth_1.fetchJson)((0, auth_1.apiUrl)(`/admin/storages${query}`));
+    (0, format_js_1.formatOutput)(opts.format === 'json' ? data : data.items, opts.format, format_js_1.storageColumns);
+});
+exports.storageCommand
+    .command('get <id>')
+    .description('Get a storage by ID')
+    .addOption(new commander_1.Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))
+    .action(async (id, opts) => {
+    const query = process.env.GENI_TENANT_ID ? `?tenantId=${process.env.GENI_TENANT_ID}` : '';
+    const data = await (0, auth_1.fetchJson)((0, auth_1.apiUrl)(`/admin/storages/${id}${query}`));
+    (0, format_js_1.formatOutput)(data, opts.format, format_js_1.storageColumns);
+});
+exports.storageCommand
+    .command('delete <id>')
+    .description('Delete a storage')
+    .addOption(new commander_1.Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))
+    .action(async (id, opts) => {
+    const query = process.env.GENI_TENANT_ID ? `?tenantId=${process.env.GENI_TENANT_ID}` : '';
+    const data = await (0, auth_1.fetchJson)((0, auth_1.apiUrl)(`/admin/storages/${id}${query}`), {
+        method: 'DELETE',
+    });
+    (0, format_js_1.formatOutput)(data, opts.format, format_js_1.storageColumns);
+});
+exports.storageCommand
+    .command('create')
+    .description('Create a storage')
+    .requiredOption('--name <name>', 'Storage name')
+    .requiredOption('--environment-id <id>', 'Environment ID')
+    .option('--permission-mode <mode>', 'Permission mode (read-write, read-only, write-only)', 'read-write')
+    .addOption(new commander_1.Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))
+    .action(async (opts) => {
+    const data = await (0, auth_1.fetchJson)((0, auth_1.apiUrl)('/admin/storages'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            name: opts.name,
+            environmentId: opts.environmentId,
+            permissionMode: opts.permissionMode,
+            ...(process.env.GENI_TENANT_ID ? { tenantId: process.env.GENI_TENANT_ID } : {}),
+        }),
+    });
+    (0, format_js_1.formatOutput)(data, opts.format, format_js_1.storageColumns);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/commands/storage.ts"],"names":[],"mappings":";;;AAAA,yCAA2C;AAC3C,kCAA2C;AAC3C,4CAA8E;AAEjE,QAAA,cAAc,GAAG,IAAI,mBAAO,CAAC,SAAS,CAAC;KACjD,WAAW,CAAC,iBAAiB,CAAC,CAAA;AAEjC,sBAAc;KACX,OAAO,CAAC,MAAM,CAAC;KACf,WAAW,CAAC,eAAe,CAAC;KAC5B,MAAM,CAAC,mBAAmB,EAAE,0DAA0D,CAAC;KACvF,MAAM,CAAC,uBAAuB,EAAE,0BAA0B,CAAC;KAC3D,SAAS,CAAC,IAAI,kBAAM,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;KAC9G,MAAM,CAAC,KAAK,EAAE,IAAuE,EAAE,EAAE;IACxF,MAAM,MAAM,GAAG,IAAI,eAAe,EAAE,CAAA;IACpC,IAAI,IAAI,CAAC,MAAM;QAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IAClD,IAAI,IAAI,CAAC,aAAa;QAAE,MAAM,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;IACvE,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc;QAAE,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;IAClF,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAC7C,MAAM,IAAI,GAAG,MAAM,IAAA,gBAAS,EAAC,IAAA,aAAM,EAAC,kBAAkB,KAAK,EAAE,CAAC,CAAyB,CAAA;IACvF,IAAA,wBAAY,EAAC,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,0BAAc,CAAC,CAAA;AACvF,CAAC,CAAC,CAAA;AAEJ,sBAAc;KACX,OAAO,CAAC,UAAU,CAAC;KACnB,WAAW,CAAC,qBAAqB,CAAC;KAClC,SAAS,CAAC,IAAI,kBAAM,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;KAC9G,MAAM,CAAC,KAAK,EAAE,EAAU,EAAE,IAA8B,EAAE,EAAE;IAC3D,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,aAAa,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IACzF,MAAM,IAAI,GAAG,MAAM,IAAA,gBAAS,EAAC,IAAA,aAAM,EAAC,mBAAmB,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC,CAAA;IACrE,IAAA,wBAAY,EAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,0BAAc,CAAC,CAAA;AACjD,CAAC,CAAC,CAAA;AAEJ,sBAAc;KACX,OAAO,CAAC,aAAa,CAAC;KACtB,WAAW,CAAC,kBAAkB,CAAC;KAC/B,SAAS,CAAC,IAAI,kBAAM,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;KAC9G,MAAM,CAAC,KAAK,EAAE,EAAU,EAAE,IAA8B,EAAE,EAAE;IAC3D,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,aAAa,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IACzF,MAAM,IAAI,GAAG,MAAM,IAAA,gBAAS,EAAC,IAAA,aAAM,EAAC,mBAAmB,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE;QACpE,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAA;IACF,IAAA,wBAAY,EAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,0BAAc,CAAC,CAAA;AACjD,CAAC,CAAC,CAAA;AAEJ,sBAAc;KACX,OAAO,CAAC,QAAQ,CAAC;KACjB,WAAW,CAAC,kBAAkB,CAAC;KAC/B,cAAc,CAAC,eAAe,EAAE,cAAc,CAAC;KAC/C,cAAc,CAAC,uBAAuB,EAAE,gBAAgB,CAAC;KACzD,MAAM,CAAC,0BAA0B,EAAE,qDAAqD,EAAE,YAAY,CAAC;KACvG,SAAS,CAAC,IAAI,kBAAM,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;KAC9G,MAAM,CAAC,KAAK,EAAE,IAKd,EAAE,EAAE;IACH,MAAM,IAAI,GAAG,MAAM,IAAA,gBAAS,EAAC,IAAA,aAAM,EAAC,iBAAiB,CAAC,EAAE;QACtD,MAAM,EAAE,MAAM;QACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;QAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;YACnB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAChF,CAAC;KACH,CAAC,CAAA;IACF,IAAA,wBAAY,EAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,0BAAc,CAAC,CAAA;AACjD,CAAC,CAAC,CAAA","sourcesContent":["import { Command, Option } from 'commander'\nimport { apiUrl, fetchJson } from '../auth'\nimport { formatOutput, storageColumns, type OutputFormat } from '../format.js'\n\nexport const storageCommand = new Command('storage')\n  .description('Manage storages')\n\nstorageCommand\n  .command('list')\n  .description('List storages')\n  .option('--status <status>', 'Filter by status (e.g. ACTIVE, PENDING, FAILED, DELETED)')\n  .option('--environment-id <id>', 'Filter by environment ID')\n  .addOption(new Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))\n  .action(async (opts: { status?: string; environmentId?: string; format: OutputFormat }) => {\n    const params = new URLSearchParams()\n    if (opts.status) params.set('status', opts.status)\n    if (opts.environmentId) params.set('environmentId', opts.environmentId)\n    if (process.env.GENI_TENANT_ID) params.set('tenantId', process.env.GENI_TENANT_ID)\n    const query = params.size ? `?${params}` : ''\n    const data = await fetchJson(apiUrl(`/admin/storages${query}`)) as { items: unknown[] }\n    formatOutput(opts.format === 'json' ? data : data.items, opts.format, storageColumns)\n  })\n\nstorageCommand\n  .command('get <id>')\n  .description('Get a storage by ID')\n  .addOption(new Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))\n  .action(async (id: string, opts: { format: OutputFormat }) => {\n    const query = process.env.GENI_TENANT_ID ? `?tenantId=${process.env.GENI_TENANT_ID}` : ''\n    const data = await fetchJson(apiUrl(`/admin/storages/${id}${query}`))\n    formatOutput(data, opts.format, storageColumns)\n  })\n\nstorageCommand\n  .command('delete <id>')\n  .description('Delete a storage')\n  .addOption(new Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))\n  .action(async (id: string, opts: { format: OutputFormat }) => {\n    const query = process.env.GENI_TENANT_ID ? `?tenantId=${process.env.GENI_TENANT_ID}` : ''\n    const data = await fetchJson(apiUrl(`/admin/storages/${id}${query}`), {\n      method: 'DELETE',\n    })\n    formatOutput(data, opts.format, storageColumns)\n  })\n\nstorageCommand\n  .command('create')\n  .description('Create a storage')\n  .requiredOption('--name <name>', 'Storage name')\n  .requiredOption('--environment-id <id>', 'Environment ID')\n  .option('--permission-mode <mode>', 'Permission mode (read-write, read-only, write-only)', 'read-write')\n  .addOption(new Option('--format <format>', 'Output format').choices(['table', 'json', 'csv']).default('table'))\n  .action(async (opts: {\n    name: string\n    environmentId: string\n    permissionMode: string\n    format: OutputFormat\n  }) => {\n    const data = await fetchJson(apiUrl('/admin/storages'), {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({\n        name: opts.name,\n        environmentId: opts.environmentId,\n        permissionMode: opts.permissionMode,\n        ...(process.env.GENI_TENANT_ID ? { tenantId: process.env.GENI_TENANT_ID } : {}),\n      }),\n    })\n    formatOutput(data, opts.format, storageColumns)\n  })\n"]}

package/dist/commands/submission.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const submissionCommand: Command;