```
import { MedplumClient } from '@medplum/core';
import dotenv from 'dotenv';
import { Reference, BundleEntry, Organization } from '@medplum/fhirtypes';
import { Command } from 'commander';

// Load environment variables
dotenv.config();

// Log environment variables (excluding secret)
console.log('Environment configuration:', {
  baseUrl: process.env.MEDPLUM_BASE_URL,
  clientId: process.env.MEDPLUM_CLIENT_ID,
  hasClientSecret: !!process.env.MEDPLUM_CLIENT_SECRET
});

const program = new Command();

program
  .name('medplum-fhir-references')
  .description('CLI tool to write fhir with references')
  .version('1.0.0');

async function main(): Promise<void> {
  try {
    // Initialize Medplum client
    const medplumClient = new MedplumClient({
      baseUrl: process.env.MEDPLUM_BASE_URL || 'https://api.medplum.com',
      clientId: process.env.MEDPLUM_CLIENT_ID,
      clientSecret: process.env.MEDPLUM_CLIENT_SECRET,
    });

    const entries: BundleEntry[] = [];
    const parentOrgPlaceholderId = `urn:uuid:61ebe359-bfdc-4613-8bf2-c5e300945f0a`;

    const parentOrg: Organization = {
      resourceType: 'Organization',
      name: 'Parent Org',
    };

    entries.push({
      resource: parentOrg,
      fullUrl: parentOrgPlaceholderId,
      request: {
        url: parentOrg.resourceType,
        method: 'POST',
      },
    });

    const childOrg: Organization = {
      resourceType: 'Organization',
      name: 'Child Org',
      partOf: { reference: parentOrgPlaceholderId },
    };

    entries.push({
      resource: childOrg,
      request: {
        url: childOrg.resourceType,
        method: 'POST',
      },
    });

    console.log('Sending transaction bundle with entries:', JSON.stringify(entries, null, 2));

    try {
      const response = await medplumClient.executeBatch({
        resourceType: 'Bundle',
        type: 'transaction',
        entry: entries,
      });
      console.log('Transaction response:', JSON.stringify(response, null, 2));
    } catch (batchError: unknown) {
      console.error('Batch execution failed:', {
        message: batchError instanceof Error ? batchError.message : 'Unknown error',
        ...(batchError as any).response?.data && { response: (batchError as any).response.data }
      });
      throw batchError;
    }

  } catch (error) {
    if (error instanceof Error) {
      console.error('Error details:', {
        message: error.message,
        stack: error.stack,
        ...(error as any).response?.data && { response: (error as any).response.data }
      });
    } else {
      console.error('An unknown error occurred:', error);
    }
    process.exit(1);
  }
}

main();
```