Connection & Migration Manual

From delivery details to a reproducible cloud Mac workflow

Verify the node, credentials, and local network before establishing a remote session. Once the connection is stable, migrate code and data, the toolchain, and CI separately—rather than moving your entire local environment at once.

Connection order
Verify delivery → Start session → Change credentials
Migration order
Code & data → Toolchain → CI
Session Handoff Board REMOTE / READY
01 Verify delivery Node address, username, access method
02 Start session Network, display, keyboard, permissions
03 Migrate workflow Data, toolchain, Runner, artifacts
Hardware Dedicated physical machine
Environment Not a virtual machine
Approach Migrate in small batches; verify rollback
Pre-connection checks

Eliminate session failure points locally first

Do not migrate a project during your first connection. Complete these five basic checks to confirm that your local client, network, and delivery details support a stable session.

Client

Prepare a supported connection tool

Confirm that the client version works and keep one backup access method available. Before the first session, disable extensions that rewrite keyboard mappings, proxies, or display scaling.

Network

Use a stable connection for the first login

Prefer wired networking or reliable Wi-Fi, and pause large file syncs and local uploads. If you use a corporate proxy, first confirm that remote-session and SSH traffic are not being rewritten.

Delivery details

Verify the address and credentials item by item

Read the node address, username, and connection method from the console—not from chat history or an old ticket. Store credentials only in a password manager, never in scripts or repositories.

Display

Connect at a conservative resolution first

Use one display and standard scaling for the first connection. Increase the resolution only after text, the pointer, and shortcuts work correctly, so display issues are not mistaken for network problems.

Local files

Prepare only the data needed for the first check

Bring only the project list, dependency lockfiles, and one small verifiable branch initially. Transfer media source files, old caches, and archives in batches after connection validation is complete.

First connection workflow

Validate one variable at a time

Break the first session into five steps: address, connection, credentials, input, and display. Each step has a clear completion condition, making the latest change easy to identify when something goes wrong.

  1. 01

    Verify the node address

    Compare the hostname or address, username, and connection protocol with the console delivery information. Confirm the target node before attempting to start the session.

    Completion condition: Every target detail matches
  2. 02

    Start a minimal session

    Connect with one display, a standard resolution, and default quality. Keep the session open for several minutes while switching windows, entering text, and browsing files.

    Completion condition: Input and display remain continuously usable
  3. 03

    Change the initial credentials

    Set unique, strong credentials immediately after the first login. Update the password manager and remove the delivery-stage credentials from routine use.

    Completion condition: Login succeeds with the new credentials
  4. 04

    Confirm the keyboard layout

    Test Command, Option, Control, arrow keys, and common English and Chinese input. The remote client and macOS layout should match.

    Completion condition: No editor shortcut conflicts
  5. 05

    Adjust display settings

    Increase resolution, scaling, and quality only after the basic session is stable. Change one setting at a time while watching text clarity, pointer latency, and network usage.

    Completion condition: Stable operation at the target display settings
Migration paths

From a local Mac to a cloud Mac: three rollback-ready paths

Follow the three paths in order. Record inputs, actions, results, and rollback points for each one, avoiding simultaneous changes to code, tool versions, and automation before the remote environment is stable.

Path A

Data migration

Input
Code repository, dependency lockfiles, required assets, and verification checklist
Action
Transfer a small buildable branch first, then sync caches, assets, and archives by directory in batches
Result
Repository state matches, key file checks pass, and the sample project is readable
Rollback
Keep the original local copy; place each remote batch in a separate staging directory
Path B

Reproduce the toolchain

Input
macOS, Xcode, command-line tools, package managers, and script version list
Action
Install and pin versions in dependency order, running diagnostic commands item by item
Result
The same commit completes resolution, compilation, testing, and pre-archive checks
Rollback
Save version lists and configuration copies; return to the last verified version set if needed
Path C

Integrate CI

Input
Runner configuration, variable list, secret scope, build directories, and artifact rules
Action
Register an isolated Runner first, then add the smallest build job and artifact upload
Result
Jobs run repeatably, with clear logs, exit codes, and artifact locations
Rollback
Disable the new Runner, restore the previous executor, and remove remote temporary directories
Data migration guide

Prioritize transfers by rebuildability

Move code and configuration first, reproducible caches later, and independently verify hard-to-recreate signing materials and media sources. Validate the path and permissions with a small sample before moving large packages.

Batch migration strategy for local data to a cloud Mac
Data type First batch Recommended action Verification Rollback
Code repository Main repository, submodules, dependency lockfiles Start from a clean clone instead of copying a working directory with local state Check the branch, commit, submodules, and untracked files Delete the remote copy and clone again
Build cache Only caches confirmed to be reusable Complete one cache-free build, then restore caches tool by tool Compare hit logs, build results, and disk usage Clear the relevant cache directory and regenerate it
Signing materials The minimum set required by the project Transfer through a controlled encrypted channel and restrict file and keychain access Run signing verification without uploading artifacts Remove imported items and revoke temporary access
Media assets A small sample sufficient to validate the workflow Organize directories by project, batch, and purpose; keep them separate from caches Check file count, size, and content checksums Delete the current batch and resend it from the local originals
Large archives Index, manifest, and one test archive Transfer in volumes, record each volume's status, and avoid overwriting the target directory at once Verify each volume and spot-check extracted contents Resend only failed volumes instead of transferring everything again
Migration completion criteria

Completion does not mean “the files have finished transferring.” It means the remote environment can reproduce a verifiable build from a specific commit and dependency list.

Toolchain reproduction

Record versions first, then restore the project environment

Do not start by installing every commonly used tool. Use the project's actual dependencies as the boundary, reproducing them in order: system, compiler, command-line tools, dependency management, certificates, and scripts.

Item Verification step Success signal
macOS

Record the system version, architecture, disk space, and regional settings, and confirm that project requirements match system capabilities.

System information archived
Xcode

Confirm the project-specified version, first-launch components, and active developer directory without relying on a temporary GUI selection.

Version and path match
Command-line tools

Check the compiler, SDK, Git, Ruby, and any other required runtimes; record the paths actually resolved.

Unambiguous command resolution
Package manager

Restore dependencies from lockfiles, distinguish global tools from project dependencies, and avoid masking missing items with local caches.

Reproducible clean install
Certificates & permissions

Import only materials required for the current task. Check keychain access scope, file permissions, and automation-process visibility.

Minimum-scope verification passes
Project scripts

Start with read-only checks, then run dependency resolution, tests, and builds. Scripts must not depend on unregistered local absolute paths.

Consistent result for the same commit
CI integration

Run the smallest job successfully before adding the production pipeline

Runner integration should not happen alongside toolchain migration. First confirm that the build is reproducible in a manual session, then place the same command in the automated job.

01 / Runner

Register an isolated executor

Use a dedicated Runner identifier and tags for the cloud Mac, limiting the repositories and job types it can receive. Start with a diagnostic job that outputs system information only.

02 / Variables

Separate variables and secrets

Use regular environment variables for versions and paths; store sensitive values in controlled secret storage. Never echo tokens, private keys, or signing materials in logs.

03 / Workspace

Fix the build-directory boundaries

Separate source, dependency caches, temporary output, and final artifact directories. Check free space before each job and clean only rebuildable content afterward.

04 / Artifact

Define artifact upload rules

Make uploads read only the agreed output directory, while retaining the commit ID, build number, and checksums. Do not mix temporary logs into delivery packages.

05 / Cleanup

Make failed jobs safe to rerun

Capture the exit code and remove lockfiles, suspended processes, and temporary directories. After retaining diagnostic logs, the next job should start from a known state.

Before moving to the production pipeline

Validate at least one build in a fresh working directory, one rerun after failure, and one artifact upload with verification. Expand the job scope only after all three pass.

Connection command examples

Use read-only commands to verify the session and base environment

These checks do not modify system configuration. Set the console-delivered host and username in your local terminal, then start an SSH session and record the system, architecture, disk, and developer-tool paths.

Do not write to the repository

Do not put the host, username, key path, or token in project scripts or version control.

Do not install immediately

Complete the read-only checks first, confirm the current state, and only then change the toolchain.

Session verification checklist READ ONLY
export SETMINI_HOST="Console-delivered node address"
export SETMINI_USER="Console-delivered username"

ssh "${SETMINI_USER}@${SETMINI_HOST}"

hostname
sw_vers
uname -m
df -h /
xcode-select -p
xcodebuild -version
git --version
echo "$SHELL"
Session security

Treat remote sessions as production access

A dedicated physical machine does not mean access controls can be relaxed. Credentials, permissions, screen locking, sign-out, and sensitive-file cleanup all belong on the team handoff checklist.

Strong credentials

Set unique credentials for the node and store them in a password manager. Update them immediately after team changes, suspected exposure, or unusual logins.

Least privilege

Use only the permissions required for daily work. Exit temporary elevated access promptly, and never put high-privilege access in automation scripts.

Lock when away

Lock the session even during a short absence. In shared offices, also disable local screen previews to prevent remote content exposure.

End the session completely

When the task is complete, exit the remote client and SSH session. Confirm that no interactive processes or temporary port forwards remain in the background.

Remove sensitive files

Remove temporary downloads, debug exports, unencrypted archives, and signing materials no longer needed, while retaining a cleanup record.

Report access anomalies

If you find an unknown session, unusual process, or credential risk, first record the time and necessary logs, then submit a ticket through the console.

Submit a ticket in the console
Start migration

Establish a stable session first, then migrate the first verifiable workflow

Choose a dedicated Apple Silicon Mac. After receiving the delivery details, follow this page to complete connection, environment registration, and CI integration.