ipfsd-ctl
Version:
Spawn IPFS Daemons, JS or Go
196 lines • 6.16 kB
TypeScript
/// <reference types="node" />
import type { EventEmitter } from 'events';
import type { IPFS } from 'ipfs-core-types';
import type { Multiaddr } from '@multiformats/multiaddr';
import type { PeerId } from '@libp2p/interface-peer-id';
export interface Subprocess {
stderr: EventEmitter | null;
stdout: EventEmitter | null;
}
export interface PeerData {
id: PeerId;
addresses: Multiaddr[];
}
export interface Controller {
init: (options?: InitOptions) => Promise<Controller>;
start: () => Promise<Controller>;
stop: () => Promise<Controller>;
cleanup: () => Promise<Controller>;
pid: () => Promise<number>;
version: () => Promise<string>;
path: string;
started: boolean;
initialized: boolean;
clean: boolean;
api: IPFS;
subprocess?: Subprocess | null;
opts: ControllerOptions;
apiAddr: Multiaddr;
peer: PeerData;
}
export interface RemoteState {
id: string;
path: string;
initialized: boolean;
started: boolean;
disposable: boolean;
clean: boolean;
apiAddr: string;
gatewayAddr: string;
grpcAddr: string;
}
export declare type NodeType = 'js' | 'go' | 'proc';
export interface InitOptions {
pass?: string;
bits?: number;
algorithm?: string;
emptyRepo?: boolean;
profiles?: string[];
allowNew?: boolean;
privateKey?: string;
}
export interface PreloadOptions {
enabled?: boolean;
addresses?: string[];
}
export interface ExperimentalOptions {
sharding?: boolean;
ipnsPubsub?: boolean;
}
export interface CircuitRelayHopOptions {
enabled: boolean;
active: boolean;
}
export interface CircuitRelayOptions {
enabled: boolean;
hop: CircuitRelayHopOptions;
}
export interface IPFSOptions {
/**
* The file path at which to store the IPFS node’s data. Alternatively, you can set up a customized storage system by providing an ipfs.Repo instance.
*/
repo?: string | any;
/**
* Initialize the repo when creating the IPFS node. Instead of a boolean, you may provide an object with custom initialization options. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionsinit
*/
init?: boolean | InitOptions;
/**
* If false, do not automatically start the IPFS node. Instead, you’ll need to manually call node.start() yourself.
*/
start?: boolean;
/**
* A passphrase to encrypt/decrypt your keys.
*/
pass?: string;
/**
* Prevents all logging output from the IPFS node.
*/
silent?: boolean;
/**
* Configure circuit relay. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionsrelay
*/
relay?: any;
/**
* Configure remote preload nodes. The remote will preload content added on this node, and also attempt to preload objects requested by this node. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionspreload
*/
preload?: boolean | PreloadOptions;
/**
* Enable and configure experimental features. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionsexperimental
*/
EXPERIMENTAL?: ExperimentalOptions;
/**
* Modify the default IPFS node config. This object will be merged with the default config; it will not replace it. The default config is documented in the js-ipfs config file docs. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionsconfig
*/
config?: any;
/**
* Modify the default IPLD config. This object will be merged with the default config; it will not replace it. Check IPLD docs for more information on the available options. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionsipld
*/
ipld?: any;
/**
* The libp2p option allows you to build your libp2p node by configuration, or via a bundle function. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionslibp2p
*/
libp2p?: any;
/**
* Configure the libp2p connection manager. https://github.com/ipfs/js-ipfs/blob/master/README.md#optionsconnectionmanager
*/
connectionManager?: any;
/**
* Run the node offline
*/
offline?: boolean;
/**
* Perform any required repo migrations
*/
repoAutoMigrate?: boolean;
}
export interface ControllerOptions {
/**
* Flag to activate custom config for tests
*/
test?: boolean;
/**
* Use remote endpoint to spawn the controllers. Defaults to `true` when not in node
*/
remote?: boolean;
/**
* Endpoint URL to manage remote Controllers. (Defaults: 'http://localhost:43134')
*/
endpoint?: string;
/**
* A new repo is created and initialized for each invocation, as well as cleaned up automatically once the process exits
*/
disposable?: boolean;
/**
* The daemon type
*/
type?: NodeType;
/**
* Additional environment variables, passed to executing shell. Only applies for Daemon controllers
*/
env?: Record<string, string>;
/**
* Custom cli args
*/
args?: string[];
/**
* Reference to an ipfs-http-client module
*/
ipfsHttpModule?: any;
/**
* Reference to an ipfs or ipfs-core module
*/
ipfsModule?: any;
/**
* Reference to an ipfs-core module
*/
ipfsClientModule?: any;
/**
* Path to a IPFS executable
*/
ipfsBin?: string;
/**
* Options for the IPFS node
*/
ipfsOptions?: IPFSOptions;
/**
* Whether to use SIGKILL to quit a daemon that does not stop after `.stop()` is called. (default true)
*/
forceKill?: boolean;
/**
* How long to wait before force killing a daemon in ms. (default 5000)
*/
forceKillTimeout?: number;
}
export interface ControllerOptionsOverrides {
js?: ControllerOptions;
go?: ControllerOptions;
proc?: ControllerOptions;
}
export interface Factory {
tmpDir: (options?: ControllerOptions) => Promise<string>;
spawn: (options?: ControllerOptions) => Promise<Controller>;
clean: () => Promise<void>;
controllers: Controller[];
opts: ControllerOptions;
}
//# sourceMappingURL=types.d.ts.map