Engineering support hub

Identify the problem layer first, then submit reproducible details

This hub covers connection, system, build, network, storage, and account issues on cloud Macs. Complete the basic checks in order, then record the node, incident time, and redacted logs to reduce back-and-forth.

Remote connection troubleshooting

Check credentials, the path, then the session

First confirm that the connection target is correct, then check the port and client. Do not use repeated credential resets to mask network- or session-layer issues.

01

Verify provisioning details and credentials

Copy the current instance hostname, port, and username from the console, and make sure you are not using details from an old order. Check the keyboard layout, capitalization, leading and trailing spaces, and password-manager autofill. Do not include passwords, private keys, or a complete connection string in screenshots or the ticket body.

02

Verify port reachability

Use nc in your local terminal to check the specified port. A successful TCP connection only confirms that the port is reachable; it does not mean the graphical session is working. If the request times out, continue recording your local network, carrier, and target node.

nc -vz "$TARGET_HOST" "$TARGET_PORT"
03

Check screen-sharing status

Confirm that the instance is running, the graphical-session service is available, and the current account has permission for remote sessions. If the command line connects but the display does not, narrow the issue to the graphical service, client negotiation, or a stale session instead of changing network settings again.

04

Lower display settings for comparison

Establish a baseline with one display, lower resolution, and lower image quality, then restore scaling, color quality, and multi-display settings one at a time. If low resolution is stable but high resolution stutters, also collect latency, packet loss, and client encoding settings.

05

Clear stale sessions and reconnect

Exit the client normally, wait for the old connection to be released, and establish the session again. Avoid connecting multiple clients to the same graphical session. If the interruption recurs, record the exact minute, client version, whether you changed networks, and whether the command-line connection was affected at the same time.

Quick system-level checks: If you can access the command line, check the system time, available disk space, memory pressure, and high-usage processes in order. Clock drift can affect certificates and build signing; insufficient disk space often appears as a failure during dependency installation, cache writes, or archiving.

CI/CD troubleshooting

Isolate the failure to the Runner, environment, or job

Start with a minimal job that does not read project secrets or install dependencies. Once it passes, add the repository, cache, signing materials, and archive steps layer by layer.

Runner

Registration and online status

Verify that the Runner is registered to the correct project or organization, its labels match, and its executor is online. If a job remains queued, check labels and concurrency limits first, then inspect the Runner process instead of rerunning the entire pipeline.

ps aux | grep -i runner
launchctl list | grep -i runner
Signing

Signing environment

Confirm that the account used by the build process, keychain search paths, certificate visibility, and provisioning-profile scope are consistent. Keep only certificate names, the failure stage, and error text in logs; remove passwords, private-key contents, and complete signing materials before submission.

security list-keychains
security find-identity -v -p codesigning
Cache

Cache directories

Keep dependency caches, derived data, and final artifacts in separate directories. When cache hits behave unexpectedly, record the cache key and directory usage, then clean only the affected project instead of deleting every working directory and losing comparison data.

du -sh "$CACHE_PATH"
df -h
find "$CACHE_PATH" -maxdepth 1 -type d
Queue

Build queue

Record when queuing began, execution started, and execution ended. Distinguish between “the job was not picked up” and “the job started but produced no output for a long time.” For the former, focus on labels, concurrency, and Runner status; for the latter, check waiting scripts, network dependencies, and child processes.

Logs

Log collection

Keep at least 50 log lines before and after the failed step, along with the command exit code, tool versions, and the smallest reproducible set of publicly shareable project parameters. Do not submit only an error-dialog screenshot, and do not upload a complete log bundle containing tokens, repository credentials, or business data.

xcodebuild -version
sw_vers
uname -m
Retry

Retrying failures

After the first failure, save the original logs before retrying once with the same commit and parameters. If the retry succeeds, compare network requests, cache hits, and execution time. If it fails consistently, narrow the issue to a single command and record its inputs, exit code, and duration.

Network diagnostics workbench

Sample the same target continuously

A single ping does not represent link quality. Collect one set of results while the issue is occurring and another after recovery, keeping the local network, target address, and command parameters consistent.

Latency and packet loss

Send 20 consecutive packets and save the minimum, average, and maximum latency and packet-loss rate.

ping -c 20 "$TARGET_HOST"

Route path

Use the route results to identify which hop begins showing latency changes. Some routers do not respond to probes; that alone does not mean the link is down.

traceroute "$TARGET_HOST"

DNS lookup

Record the resolution result, response time, and DNS servers currently in use to distinguish resolution issues from target-port issues.

dig "$TARGET_HOST"
scutil --dns

Upload, download, and responsiveness

Use the built-in macOS tool to collect upload and download capacity, responsiveness, and idle latency. Pause large-file synchronization and other high-bandwidth tasks during the test.

networkQuality -v
Cross-border links can fluctuate with carrier routing and local network load. Do not choose a node based only on straight-line distance; test available targets in Singapore, Japan (Tokyo), South Korea (Seoul), and Hong Kong separately, then decide based on your team’s location and primary working hours.

Storage and data handling

Separate source code, caches, artifacts, and backups

Storage issues are rarely about a single capacity figure. Define directory boundaries, write permissions, recoverable copies, and migration timing before the first build.

Working-directory planning

  • Keep repository content and required configuration in the source directory; avoid mixing in large build artifacts.
  • Use separate directories for dependency caches and derived data so they can be cleaned and usage can be tracked by project.
  • Store archives, packages, and debug symbols in an artifact directory labeled with the task identifier.
  • Define cleanup rules for temporary files, and confirm that no build is running before cleanup.

Application-level backup responsibilities

  • Create independent copies of source code, databases, signing materials, and artifacts that cannot be regenerated.
  • Regularly verify that backups can be read; do not treat “the task was uploaded” as a recovery test.
  • Store keys and credentials in controlled storage; do not put them in repositories, build logs, or shared directories.
  • Complete the export before the rental term ends and verify file counts, checksums, and readability at the destination.

Expansion SSD detection

After adding expanded storage, first check that the system detects the device, the volume is mounted, and the file system is writable before changing build directories. Do not switch cache or artifact paths while a job is running.

diskutil list
df -h
mount

Pre-migration checks

  • Stop builds, synchronization, and background tasks that would continue writing data.
  • Copy a small sample first to verify permissions, filenames, and symbolic-link handling.
  • After the full migration, compare directory sizes, file counts, and checksums for key files.
  • Complete a read or build test in the destination environment before deleting the original directory.

Service availability

Use continuous monitoring records to verify impact

Status records help determine the scope of any service-side impact. The service terms govern the specific measurement window, exclusions, eligibility requirements, service credits, and applicable scope.

Target availability
99.9%

Nodes operate normally 365 days a year. Impacts caused by force majeure, user actions, user-side networks, or workload configuration are excluded from platform availability.

Daily status over the past 90 days 90 DAYS
Normal Affected period recorded

If you believe an order was affected by a platform-side service event, retain the order ID, node, first-detected time, recovery time, and continuous probe records, then submit them through a console ticket. Eligibility for and the form of any service credit are governed by the specific service-term rules.

View service terms

Submit a support request

Provide enough context to start troubleshooting

Organize each technical support request around one issue. Describe different nodes, orders, or failure stages separately to prevent timelines from overlapping.

Six required details

  1. 01
    Order ID

    Provide the order or instance ID shown in the console. Do not send account passwords.

  2. 02
    Target node

    Specify Singapore, Japan (Tokyo), South Korea (Seoul), or Hong Kong.

  3. 03
    Incident time

    Include the date, time zone, start time, duration, and whether the issue has recovered.

  4. 04
    Expected and actual results

    State separately what you expected to happen and what you actually saw; do not write only “it doesn’t work.”

  5. 05
    Reproduction steps

    List the shortest path from the normal state to the failure, and state whether retries reproduce it consistently.

  6. 06
    Redacted logs

    Include logs before and after the failed step, command exit codes, and necessary screenshots. Remove tokens, passwords, private keys, payment credentials, and business data.

How should logs be redacted?

Keep error codes, timestamps, command names, tool versions, path structures, and exit codes. Replace access tokens, passwords, private keys, credentials in repository URLs, real user names, and business data. After redaction, search again for common secret prefixes and email addresses.

What network results should I include at minimum?

Include at least one continuous ping set, one traceroute, the incident time, target node, local city and carrier, and whether the result changed after switching to wired, Wi-Fi, or a mobile hotspot.

Do I need to upload the complete project for a build failure?

Usually not. Start with the failed command, exit code, logs before and after the failure, tool versions, and minimal reproduction steps. If a sample is required, remove business code, keys, signing materials, and production data, keeping only the smallest structure that reproduces the issue.

Get ready to submit

Include the order, node, timeline, and redacted logs

For existing-order issues, use a console ticket first; for general inquiries, contact support by email. Complete context lets engineers begin with an actionable sample.