Scp React Native Reference Documentation
Scp
Current Version: 11.6.1
Chilkat.Scp
Attach
Transfer local files to remote paths or download remote files to the
local filesystem using SCP.
Upload or download binary data, encoded data, text, or
Synchronize directory trees and use filtering options to include or
exclude selected files.
Set remote UNIX permissions, pass environment variables, and control
transfer-related behavior required by the remote server.
Monitor progress, scale progress percentages, abort active transfers, and
run supported operations as asynchronous tasks.
For an extended overview, see
Scp Class Overview.
Transfer files, text, and binary data over SCP using an existing SSH connection.
Chilkat.Scp is the Chilkat class for SCP file transfer over an
already-established Chilkat.Ssh connection. It supports
local-file upload and download, in-memory binary transfer, encoded binary
transfer, text transfer with explicit character sets, BinData
transfer, directory-tree synchronization, sync filtering, remote UNIX
permission overrides, environment variables, progress scaling, abort support,
and asynchronous task integration.
Uses an SSH connection
Scp to an authenticated Chilkat.Ssh
session rather than opening a separate network connection.
Upload and download files
Memory-based transfers
Chilkat.BinData without requiring temporary files.
Directory synchronization
Remote file options
Progress and async support
Chilkat.Ssh, initialize
Chilkat.Scp with that SSH connection, then upload, download, or
synchronize the desired files or in-memory data. Use Scp for
SCP-style transfers over SSH; use Chilkat.SFtp when the remote
server expects the SFTP protocol instead.
Object Creation
// npm install @chilkat/react-native react-native-nitro-modules
// (React Native 0.76+ with the New Architecture; then `pod install` for iOS. The Chilkat
// native library is downloaded and verified during the native build -- see the package README.)
import { Chilkat, Scp } from '@chilkat/react-native'
// Once per app start, before any other Chilkat call:
Chilkat.unlockBundle('Anything for 30-day trial') // shorthand for new Global().unlockBundle(..)
const scp = new Scp()
// ... the native object is released when `scp` is garbage collected, or now with scp.dispose()Creates the underlying native Chilkat object. Scp is a Nitro Module HybridObject: use it from the JavaScript thread only (it cannot be passed to a Worklet or another runtime). Every member is synchronous and blocks the JavaScript thread until Chilkat returns; a method that can take a while also exists as a ...Async twin returning a Promise, which runs the same call on a native worker thread so the UI keeps rendering. While such a call is pending, every other call on this object throws, except abort() and assigning onPercentDone / onProgressInfo.
Releases the native object immediately instead of waiting for garbage collection (useful for a large BinData or an open socket). Calling it more than once is harmless; any other use of the object afterwards throws. An object with a pending ...Async call cannot be disposed until the promise settles.
Errors
A method that can fail throws a plain Error: a method whose only outcome is success or failure returns void and throws on failure; a method producing a string or an object returns it and throws where Chilkat would have returned null. The error's message is "Class.method(...): reason", where the reason is the last informative line of the object's lastErrorText, which holds the full Chilkat log of the failed call. A ...Async twin rejects its promise with the same Error instead of throwing. Properties never throw, and methods that answer a question (has..., is..., ...) return a plain boolean.
try {
scp.someMethod(...)
} catch (e) {
console.log((e as Error).message) // Scp.someMethod(...): <reason>
console.log(scp.lastErrorText) // the full Chilkat log of the failed call
}
// The same call without blocking the JavaScript thread:
try {
await scp.someMethodAsync(...)
} catch (e) {
console.log((e as Error).message) // Scp.someMethodAsync: <reason>
}Properties
AbortCurrent
abortCurrent: boolean
Set to true to request cancellation of the method currently executing on this object. Long-running network and file-transfer operations check this property periodically; a method that completes quickly may finish before the request is observed.
Both synchronous and asynchronous operations can be cancelled. To cancel a synchronous call, set this property from another thread on the same Scp object. Chilkat resets the property to false after the cancellation is processed. If no method is running, a previously set value is cleared when the next method begins.
LastMethodSuccess where applicable, and LastErrorText to determine the final outcome.DebugLogFilePath
debugLogFilePath: string
If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.
Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.
Possible causes of hangs include:
- A timeout property set to 0, indicating an infinite timeout.
- A hang occurring within an event callback in the application code.
- An internal bug in the Chilkat code causing the hang.
HeartbeatMs
heartbeatMs: number
Specifies the interval, in milliseconds, between AbortCheck event callbacks during supported long-running operations. The callback allows the application to report activity or request cancellation before the operation completes.
The default value is 0, which disables periodic AbortCheck callbacks.
LastErrorHtml
readonly lastErrorHtml: string
Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastErrorText
readonly lastErrorText: string
Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
LastErrorXml
readonly lastErrorXml: string
Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastMethodSuccess
lastMethodSuccess: boolean
Indicates the success or failure of the most recent method call: true means success, false means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.
PercentDoneScale
percentDoneScale: number
Specifies the value that represents 100% completion in PercentDone event callbacks. The default is 100, which reports progress in whole-percent units. For example, when the scale is 1000, a callback value of 453 represents 45.3% completion.
The value is limited to the range 10 through 100000. Increasing the scale provides finer numeric granularity for operations whose progress can be measured.
SendEnv
sendEnv: string
Specifies environment variables to send for each SCP upload or download. Set the property to a JSON object whose member names are environment-variable names and whose values are strings.
{
"LCS_PASSWORD": "myPassword",
"SOME_ENV_VAR": "some_value"
}
SyncedFiles
syncedFiles: string
Contains the local paths of the files transferred by the most recent call to SyncTreeUpload or SyncTreeDownload. Paths are listed one per line.
- After an upload, each line is the full local path of a source file that was uploaded.
- After a download, each line is the full local path of a destination file that was downloaded.
SyncMustMatch
syncMustMatch: string
Specifies a semicolon-separated list of wildcard patterns for filenames that are eligible for transfer by SyncTreeUpload and SyncTreeDownload. A file is considered only when its filename matches at least one pattern.
For example, *.xml;*.txt;*.csv limits synchronization to XML, text, and CSV files. The default empty string imposes no include restriction.
SyncMustMatchDir and SyncMustNotMatchDir.SyncMustMatchDir
syncMustMatchDir: string
Specifies a semicolon-separated list of wildcard patterns for directory names that may be traversed by SyncTreeUpload and SyncTreeDownload. When this property is nonempty, synchronization descends only into directories whose names match at least one pattern.
For example, a*;b*;c* permits traversal into directories whose names begin with a, b, or c. The default empty string permits traversal into all directories, subject to SyncMustNotMatchDir.
SyncMustNotMatch
syncMustNotMatch: string
Specifies a semicolon-separated list of wildcard patterns for filenames that must be skipped by SyncTreeUpload and SyncTreeDownload.
For example, *.tmp;*.bak;*.log excludes temporary, backup, and log files. The default empty string excludes no files.
SyncMustNotMatchDir to prevent synchronization from entering selected directories and their subtrees.SyncMustNotMatchDir
syncMustNotMatchDir: string
Specifies a semicolon-separated list of wildcard patterns for directory names that must not be traversed by SyncTreeUpload and SyncTreeDownload. A matching directory and everything below it are skipped.
For example, temp*;cache*;.git prevents traversal into temporary, cache, and Git metadata directories. The default empty string excludes no directories.
UncommonOptions
uncommonOptions: string
Provides a comma-separated list of specialized compatibility options. The default is the empty string, which is appropriate for normal SCP transfers.
| Keyword | Behavior |
|---|---|
FilenameOnly | Uses only the filename, rather than the complete target path, in the remote scp -t command. This option exists for compatibility with systems such as certain LANCOM routers. |
ProtectFromVpn | On Android, attempts to route the SCP connection outside an installed or active VPN. |
UnixPermOverride
unixPermOverride: string
Specifies an octal UNIX permission mode to apply to files uploaded by SCP, overriding the permissions derived from the local source file. For example, set this property to 0644 to grant read/write permission to the owner and read-only permission to the group and others.
The default is the empty string, which causes the uploaded file's remote permissions to be based on the local file's permissions.
0600, 0644, or 0755. The remote SSH account must still have permission to create or replace the file, and server-side policy may restrict the final mode.VerboseLogging
verboseLogging: boolean
If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.
Version
readonly version: string
Methods
DownloadBd
Downloads the file at remotePath and appends its exact bytes to the existing contents of the BinData object in bd.
An absolute remote path begins with /. A relative path is interpreted relative to the authenticated SSH user's home directory.
bd before downloading. Clear the BinData object first when the downloaded file should replace, rather than follow, its current contents.Returns normally on success; throws an Error on failure.
DownloadBdAsync
Asynchronous form of DownloadBd: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
DownloadBinaryEncoded
Downloads the file at remotePath and returns its bytes encoded as text using the binary encoding named by encoding, such as base64 or hex.
An absolute remote path begins with /. A relative path is interpreted relative to the authenticated SSH user's home directory.
encoding selects a text representation of arbitrary bytes; it is not a character set and does not decode the remote file as text. Use DownloadString when the remote file contains text that must be decoded with a charset.Throws an Error on failure (where the description says null is returned, the method throws instead).
DownloadBinaryEncodedAsync
Asynchronous form of DownloadBinaryEncoded: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
DownloadFile
Downloads the file at remotePath from the SSH server and writes its bytes to the local filesystem path in localPath.
An absolute remote path begins with /. A relative remote path is interpreted relative to the authenticated SSH user's home directory. The application must have permission to create or replace the local destination file.
Returns normally on success; throws an Error on failure.
DownloadFileAsync
Asynchronous form of DownloadFile: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
DownloadString
Downloads the file at remotePath, decodes its bytes using the character encoding named by charset, and returns the resulting text.
An absolute remote path begins with /. A relative path is interpreted relative to the authenticated SSH user's home directory.
charset describes how the remote file’s bytes represent characters, for example utf-8, windows-1252, or iso-8859-1. Using the wrong charset can produce incorrect characters. Use a binary download method for files that are not text.Throws an Error on failure (where the description says null is returned, the method throws instead).
DownloadStringAsync
Asynchronous form of DownloadString: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
SyncTreeDownload
Synchronizes files from the remote directory tree rooted at remoteRoot to the local directory rooted at localRoot. bRecurse controls recursion: set it to true to descend into subdirectories, or false to process only files directly in the root directory.
An absolute remote root begins with /; a relative remote root is interpreted relative to the authenticated SSH user's home directory. A relative local root is interpreted relative to the application's current working directory.
| Mode | Files transferred |
|---|---|
0 | Download every eligible file. |
1 | Download files that do not already exist locally. |
2 | Download files that are missing locally or whose remote last-modified time is newer than the local file. |
3 | Download only files whose remote last-modified time is newer. A remote file that has no local counterpart is not downloaded. |
5 | Download files that are missing locally or whose size differs from the local file. |
6 | Download files that are missing locally, differ in size, or have a newer remote last-modified time. |
The filename and directory filters in SyncMustMatch, SyncMustNotMatch, SyncMustMatchDir, and SyncMustNotMatchDir are applied during traversal. After completion, SyncedFiles lists the full local paths of files actually downloaded.
2, 3, and 6 compare last-modified times. Incorrect server timestamps or clock differences between systems can affect which file is considered newer.Returns normally on success; throws an Error on failure.
SyncTreeDownloadAsync
Asynchronous form of SyncTreeDownload: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
SyncTreeUpload
Synchronizes files from the local directory tree rooted at localBaseDir to the remote directory rooted at remoteBaseDir. bRecurse controls recursion: set it to true to descend into subdirectories, or false to process only files directly in the local base directory.
A relative local base directory is interpreted relative to the application's current working directory. An absolute remote base directory begins with /; a relative remote base directory is interpreted relative to the authenticated SSH user's home directory.
| Mode | Files transferred |
|---|---|
0 | Upload every eligible file. |
1 | Upload files that do not already exist on the remote server. |
2 | Upload files that are missing remotely or whose local last-modified time is newer than the remote file. |
3 | Upload only files whose local last-modified time is newer. A local file that has no remote counterpart is not uploaded. |
4 | Upload files that are missing remotely or whose size differs from the remote file. |
5 | Upload files that are missing remotely, differ in size, or have a newer local last-modified time. |
The filename and directory filters in SyncMustMatch, SyncMustNotMatch, SyncMustMatchDir, and SyncMustNotMatchDir are applied during traversal. After completion, SyncedFiles lists the full local paths of files actually uploaded.
2, 3, and 5 compare last-modified times. Incorrect server timestamps or clock differences between systems can affect which file is considered newer.Returns normally on success; throws an Error on failure.
SyncTreeUploadAsync
Asynchronous form of SyncTreeUpload: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
UploadBd
Uploads all bytes currently contained in the BinData object in bd to the remote file at remotePath. The data is transferred without character decoding or other transformation.
An absolute remote path begins with /. A relative path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist.
bd and does not remove or modify those bytes.Returns normally on success; throws an Error on failure.
UploadBdAsync
Asynchronous form of UploadBd: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
UploadBinaryEncoded
Decodes the text in encodedData using the binary encoding named by encoding, then uploads the resulting bytes to the remote file at remotePath. Typical encoding names include base64 and hex.
An absolute remote path begins with /. A relative path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist.
encoding is base64, Chilkat Base64-decodes encodedData and transfers the decoded binary bytes. This method is for encoded binary representations, not character-set conversion.Returns normally on success; throws an Error on failure.
UploadBinaryEncodedAsync
Asynchronous form of UploadBinaryEncoded: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
UploadFile
Uploads the local filesystem file at localPath to the remote path in remotePath. The file is transferred as raw bytes.
An absolute remote path begins with /. A relative remote path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist, and the SSH account must have permission to create or replace the destination file.
Remote permissions are normally derived from the local file. Set UnixPermOverride when a specific remote UNIX mode is required.
UploadFile copies the file bytes without line-ending or character-set conversion.Returns normally on success; throws an Error on failure.
UploadFileAsync
Asynchronous form of UploadFile: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
UploadString
Encodes the text in textData using the character encoding named by charset, then uploads the resulting bytes to the remote file at remotePath.
An absolute remote path begins with /. A relative path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist.
charset controls how characters are converted to bytes, for example utf-8, windows-1252, or iso-8859-1. SCP itself has no text mode; any line-ending characters already present in textData are encoded and transferred as part of the text.Returns normally on success; throws an Error on failure.
UploadStringAsync
Asynchronous form of UploadString: the same call on a native worker thread, so the JavaScript thread (and the UI) stays responsive. Takes the same arguments and resolves with the same result. While the returned Promise is pending, every other call on this object throws (the object is busy), except abort(), which cancels the call, and assigning the onPercentDone / onProgressInfo callbacks, which report its progress.
Note: the onPercentDone and onProgressInfo callbacks run on the JavaScript thread while the promise is pending, so they can update the UI directly. A rejection's message is "Class.methodAsync: reason"; the full log is in lastErrorText.
Returns a Promise that resolves with the synchronous method's result (undefined for a void method) and rejects with an Error where the synchronous method would throw.
UseSsh
Associates this Scp object with the connected and authenticated Ssh object in sshConnection. Subsequent SCP operations use that existing SSH session rather than opening a separate network connection.
Connection, proxy, timeout, host-key verification, algorithm, logging, and other transport-related settings belong to the Ssh object and therefore apply to the SCP operations performed through it. Keep the SSH object connected and available for as long as the Scp object is using it.
Scp performs SCP-style transfers over SSH and requires compatible SCP support on the remote system. Use Chilkat.SFtp when the server expects the SSH File Transfer Protocol subsystem or when directory listing and remote file-management features are needed.Returns normally on success; throws an Error on failure.
Events
While a method runs, Scp reports progress through two optional callback properties. Assign a function to receive the event, or undefined to stop receiving it. The callbacks are delivered on the JavaScript thread, so they are useful with the ...Async methods: during a synchronous call the JavaScript thread is busy inside Chilkat, and the events can only arrive after it returns.
const scp = new Scp()
scp.onPercentDone = (pct) => setProgress(pct) // pct is 0..100
scp.onProgressInfo = (name, value) => console.log(`${name}: ${value}`)
scp.heartbeatMs = 250 // let abort() take effect within a quarter second
const pending = scp.someMethodAsync(...)
cancelButton.onPress = () => scp.abort() // the promise then rejects
await pendingPercentDone fires when an operation's completion percentage is known; ProgressInfo delivers named progress values (what is reported depends on the class and method). There is no AbortCheck callback: to cancel a pending ...Async call, call abort() on the object. Chilkat notices the request at its next progress check, which happens at least every heartbeatMs milliseconds on the classes that have that property (0, the default, disables the heartbeat, so set it for a responsive cancel), and the promise rejects with Chilkat's abort error. abort() is harmless when nothing is pending.
PercentDone
onPercentDone?: (pctDone: number) => void
This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The pctDone argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have pctDone equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100).
The PercentDone callback also acts as an AbortCheck event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination.
To abort the operation, set the abort output argument to true. This will cause the method to terminate and return a failure status or corresponding failure value.
Example:
scp.onPercentDone = (pct) => {
// pct ranges from 0 to 100.
setProgress(pct) // runs on the JavaScript thread: React state may be updated directly
}
await scp.someMethodAsync(...)
// To stop an operation from within the callback, call scp.abort()ProgressInfo
onProgressInfo?: (name: string, value: string) => void
This event callback provides tag name/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory.
Note: Some Chilkat methods don't fire any ProgressInfo events.
Example:
scp.onProgressInfo = (name, value) => console.log(`${name}: ${value}`)
await scp.someMethodAsync(...)