-
Notifications
You must be signed in to change notification settings - Fork 117
External Core
The External Core plugin lets an advanced user run a trusted local executable through Furious's normal connection lifecycle. It is a managed proxy backend, not a general shell-command feature.
Furious starts, monitors, logs, and stops the configured process. The external program remains responsible for reading its own configuration and exposing the local proxy listeners that Furious is told to use.
An External Core profile can execute a local program when you explicitly connect it.
- Configure only executables you trust.
- Do not import untrusted Furious JSON containing an External Core profile.
- No shell is used: Furious launches the executable and argument list directly.
- Arguments and environment values are not written to lifecycle logs because they may contain secrets.
- External Core has no public share-URI scheme and cannot be imported from subscriptions.
Open Server and choose Add External Core....
| Field | Meaning |
|---|---|
| Remark | Profile name displayed by Furious |
| Executable | Absolute path to the local program |
| Working Directory | Optional absolute directory; blank defaults to the executable's directory |
| Arguments | Command-line arguments parsed into a list and passed directly, without a shell |
| Environment Variables | Optional KEY=VALUE overrides, one per line; the parent environment is inherited |
| Shutdown Timeout (seconds) | Bounded time allowed for graceful and terminating shutdown stages |
The executable must exist and be a file. On Unix-like systems it must also be executable. The working directory, when set, must exist and be a directory.
Use the browse buttons to avoid path-typing mistakes. Furious normalizes saved executable and working-directory paths to absolute local paths.
| Field | Meaning |
|---|---|
| HTTP Proxy | Local HTTP listener exposed by the external program |
| SOCKS Proxy | Local SOCKS listener exposed by the external program |
These values do not make the external program create the listeners. Configure the external program itself to listen on the same endpoints.
The HTTP endpoint is used for normal Furious proxy integration and connection operations. The SOCKS endpoint is required when the profile opts into application-managed tun2socks.
Use Application tun2socks declares that this profile can participate in Furious's application-managed TUN path.
When enabled, TUN Remote Address is required. It must be the actual upstream server hostname, IPv4 address, or IPv6 address used for DNS resolution and the remote-server bypass route.
These three values are deliberately separate:
- Executable is a local file path.
- HTTP/SOCKS Proxy are local listeners.
- TUN Remote Address is a remote network destination.
Furious never substitutes the executable path or a local listener for the TUN remote address.
Application tun2socks starts only when both the global TUN Mode setting and this profile option are enabled. If the profile option is off, a globally enabled TUN setting does not force this External Core profile through Furious's tun2socks path.
Arguments are entered as a human-readable command line, parsed with quoting support, stored as a list, and passed as:
executable, argument 1, argument 2, ...
Furious does not use shell=True, command substitution, or implicit script interpretation. Quote an argument that contains spaces. Empty or malformed quoting is rejected by the editor.
Environment entries use one KEY=VALUE pair per line. Furious inherits its own environment and overlays only the configured values. Names and values containing NUL characters are invalid, and environment names cannot contain =.
When you click Connect, Furious:
- validates the process paths, arguments, environment, endpoints, and optional TUN settings;
- launches the process directly with the configured working directory and environment;
- captures stdout and stderr without allowing the child pipes to fill and deadlock;
- waits briefly to reject an immediate startup exit;
- marks the runtime available and continues the ordinary connection workflow;
- starts application tun2socks only when the global and profile settings both request it.
Successful process creation and survival through the short startup window count as startup. Furious does not currently implement a port-readiness probe, stdout readiness pattern, or protocol-specific health check. A program that remains alive but never opens the configured proxy port can therefore start successfully and still fail the later connectivity check.
If the process exits unexpectedly, the runtime reports the exit and the connection is torn down through the shared controller path.
External program output appears under the unified Core log category.
- stdout is retained as normal core output;
- stderr is marked with an
[stderr]prefix; - Furious records lifecycle events such as executable, working directory, PID, exit status, and shutdown escalation;
- arguments and environment values are intentionally omitted.
Output pipes are continuously drained on background readers to prevent the child from blocking. The Log page keeps bounded entries and renders them lazily, so hiding the page reduces UI work without stopping process-output consumption.
On disconnect, Furious uses a bounded escalation sequence:
- request graceful termination for the owned process group;
- wait for part of the configured timeout;
- terminate the group if it remains alive;
- kill it as a final fallback;
- wait/reap the process and join output readers.
Windows uses an owned process group and tree-aware termination support. Unix-like systems use a separate session/process group. This is intended to clean up descendants created by the configured program without searching for unrelated processes by name.
External Core profiles are machine-local:
- paths differ between systems;
- the executable is not bundled into the profile;
- arguments and environment can contain secrets;
- the expected listener ports must match an independently maintained program configuration.
The plugin does not provide share-link or QR export and marks the protocol as unsuitable for subscription import. Furious JSON can preserve the profile internally, but review and edit it before moving it to another machine.
Use an absolute path and confirm the current user can access it. On Linux/macOS, confirm the execute permission.
Clear the field to use the executable's directory, or select an existing absolute directory.
Confirm that the program opens the exact configured HTTP listener. If application tun2socks is enabled, also confirm the SOCKS listener. Inspect the Core log for startup output.
Run the same executable and argument list in a terminal. Furious reports the early exit rather than treating it as a stable connection. Correct the external program's configuration or arguments.
Verify TUN Remote Address. It must be the real remote host/IP, never the executable path and never 127.0.0.1.
Both global TUN Mode and Use Application tun2socks must be enabled. The SOCKS endpoint and TUN remote address must also be valid.