mnemonad-cli 0.1.0

package/README.md

@@ -0,0 +1,325 @@
+# mnemonad-cli
+
+CLI tool to sync local folders to versioned, diffed on-chain streams on [Monad](https://monad.xyz).
+
+Built on top of [`mnemonad`](../js) and [`monadsync`](../monadsync), which layers
+content-defined-chunking folder diffing on top of a Mnemonad stream.
+
+Each `push` stores a versioned, gzip-compressed diff or snapshot inside a Mnemonad stream
+on-chain (with large files optionally offloaded to IPFS via Pinata). Any past version can be
+restored at any time with `pull`. Streams can optionally be encrypted with a password or the
+signer's own wallet key.
+
+## Installation
+
+This package lives in the monorepo alongside `mnemonad` and `monadsync` and is not yet
+published. From the repo root:
+
+```bash
+cd cli
+pnpm install
+node bin/mnemonad.js --help
+```
+
+Or link it for a global `mnemonad` command:
+
+```bash
+cd cli
+pnpm install
+npm link
+mnemonad --help
+```
+
+`sample/` holds example content (pulled from a stream created via the dApp) used to try the
+CLI out. `pnpm push-sample` pushes it to testnet as a brand-new stream:
+
+```bash
+export MNEMONAD_KEY=0xabc123...
+pnpm push-sample
+```
+
+## Usage
+
+```
+mnemonad push [stream-id] <path> [options]     Sync a folder to a stream (creates one if no id given)
+mnemonad pull <stream-id> <path> [options]     Restore stream contents to a folder
+mnemonad info [stream-id] [path] [options]     Show chain/wallet info, or full stream metadata
+mnemonad diff <stream-id> <path> [options]     List files added/modified/deleted locally vs the on-chain version
+mnemonad watch <stream-id> <path> [options]    Watch folder: auto-push on changes, auto-pull on remote updates
+mnemonad compact <stream-id> <path> [options]  Truncate old history and push folder as a fresh snapshot
+```
+
+`<path>` is always required for any command that touches a folder — there is no need to
+`cd` into the folder first, but there's also no falling back to the current working
+directory: an omitted or mistyped path fails fast with an error rather than silently
+operating on wherever the CLI happened to be run from. The only command that can run with
+no path at all is `mnemonad info` with no stream id either (it just checks your configured
+chain/wallet). A stream id is recognized as a bare decimal number (`123`) or a
+`0x`-prefixed hex string; anything else in that position is treated as a path.
+
+Every command prints the installed CLI version as its first line of output.
+
+### Options
+
+| Flag | Description |
+|---|---|
+| `--chain <name>` | Chain: `testnet`, `mainnet`, `local` (default: `testnet`) |
+| `--rpc-url <url>` | Override the resolved RPC endpoint (e.g. a local Hardhat node) |
+| `--contract-address <addr>` | Registry address to use instead of the chain's known deployment (required with `--chain local`) |
+| `--gateway-url <url>` | IPFS gateway for reading externally-offloaded items (default: `https://gateway.pinata.cloud/ipfs/`, or `MNEMONAD_IPFS_GATEWAY` env var) |
+| `--key <privkey>` | Monad private key (or set `MNEMONAD_KEY` env var) |
+| `--phrase <mnemonic>` | Mnemonic phrase instead of a raw key |
+| `--version <n>` | Version to restore or compare against (`pull`, `diff`, `info`; default: latest) |
+| `--exclude <p1,p2>` | Extra exclude patterns (comma-separated) |
+| `--no-compress` | Disable gzip compression |
+| `--encrypt` | Create a new stream encrypted. Only applies when creating; ignored for existing streams |
+| `--encrypt-with <method>` | How to key it: `password` (needs `--password`), or `wallet` — the `--key`/`--phrase` account signs for it, and only that account can ever decrypt it. Implied by `--password` |
+| `--password <pw>` | Password to encrypt a new stream with, or decrypt an existing one |
+| `--pinata-jwt <jwt>` | Pinata JWT for IPFS offload of large files (or `PINATA_JWT` env var) |
+| `--manifest` | Write/use `.mnemonad` manifest for faster change detection |
+| `--force-snapshot` | Push a full snapshot regardless of prior history (repairs a corrupt stream) |
+| `--poll-interval <s>` | `watch`: seconds between remote version checks (default: `2`) |
+| `--debounce <ms>` | `watch`: quiet period in ms before pushing after a local change (default: `1000`) |
+| `--push-only` | `watch`: disable auto-pull |
+| `--pull-only` | `watch`: disable auto-push |
+| `--help` | Show help |
+
+### Authentication
+
+Pass the signing key inline:
+
+```bash
+mnemonad push ~/my-data --key 0xabc123...
+```
+
+Or export it once and drop the flag from every command:
+
+```bash
+export MNEMONAD_KEY=0xabc123...
+mnemonad push ~/my-data
+```
+
+A mnemonic works instead of a raw key: `--phrase "word1 word2 ..."`. `--key` and
+`MNEMONAD_KEY` both take precedence over `--phrase`.
+
+`pull`, `info` and `diff` work without a key for public (unencrypted) streams. A key is
+required for encrypted streams that use wallet-based encryption (not needed for
+password-based encryption — see below), and for any `push`.
+
+## Examples
+
+The examples below assume the key comes from `MNEMONAD_KEY` and use the default `testnet`
+chain.
+
+### Push a folder (first time)
+
+```bash
+mnemonad push ~/my-data
+
+# prints the new stream id, e.g.:
+#   created: 123
+#   version 1 pushed (full snapshot, gzip compressed)
+```
+
+By default a new stream is public (unencrypted). Encrypting one takes a method — the CLI
+never picks for you, since both are reachable from the same invocation:
+
+```bash
+# Keyed by a password: anyone who knows it can read the stream, from any machine.
+mnemonad push ~/my-data --encrypt --password "correct horse battery staple"
+
+# Keyed by the signing account itself: no password to remember or leak, but ONLY this
+# account can ever decrypt it, and there is no recovery if the key is lost.
+mnemonad push ~/my-data --encrypt --encrypt-with wallet
+```
+
+Reading one back needs whichever credential it was keyed with — `--password` for the first,
+just the owner's `--key`/`--phrase` for the second. `mnemonad info` reports which:
+`encrypted: yes (password)` or `encrypted: yes (owner wallet)`.
+
+### Push an update
+
+```bash
+mnemonad push 123 ~/my-data
+
+# same stream on mainnet
+mnemonad push 123 ~/my-data --chain mainnet
+```
+
+### Pull the latest version
+
+```bash
+mnemonad pull 123 ~/restored
+```
+
+### Pull a specific version
+
+```bash
+mnemonad pull 123 ~/restored --version 1
+```
+
+### Inspect a stream
+
+```bash
+# check your wallet + chain (no stream id needed)
+mnemonad info
+
+# full stream metadata + local sync status
+mnemonad info 123 ~/my-data
+```
+
+```
+  chain:           testnet
+  your wallet:     0x06bc6420b37a4898424429dcfa236f0065e12279
+
+stream: 123
+  owner:           0x06bc6420b37a4898424429dcfa236f0065e12279 (you)
+  encrypted:       no
+  versions:        3
+  binary size:     385.7 KB
+
+  local tree hash: 9f2c1a4b8e...
+  detecting local version...
+  local matches:   version 3 of 3
+  status:          up to date
+```
+
+### See what changed locally (diff)
+
+```bash
+# list files added/modified/deleted locally compared to the latest on-chain version
+mnemonad diff 123 ~/my-data
+
+# compare against a specific version
+mnemonad diff 123 ~/my-data --version 2
+```
+
+Output shows the changes from the local folder's perspective — what a `push` would apply:
+
+```
+diff: ~/my-data vs 123 (version 3 of 3)
+local changes vs chain (what push would apply):
+  added:      docs/new-page.md
+  modified:   src/index.js
+  deleted:    old-config.json
+
+  3 change(s): 1 added, 1 modified, 1 deleted
+```
+
+### Fast incremental pushes with a manifest
+
+```bash
+mnemonad push 123 ~/my-data --manifest
+# subsequent pushes are skipped when nothing has changed locally
+```
+
+### Watch a folder (auto push + pull)
+
+```bash
+mnemonad watch 123 ~/my-data
+# pushes local changes 1 s after the last edit
+# pulls remote updates every 2 s
+# Ctrl-C to stop
+```
+
+Tune the timing:
+
+```bash
+mnemonad watch 123 ~/my-data --debounce 3000 --poll-interval 5
+```
+
+Watch in push-only or pull-only mode:
+
+```bash
+mnemonad watch 123 ~/my-data --push-only   # no auto-pull
+mnemonad watch 123 ~/my-data --pull-only   # no auto-push (read-only mirror)
+```
+
+### Compact old history
+
+After many incremental syncs, drop old history and push the current folder as a fresh
+single snapshot. This speeds up future `pull`/`info`/`diff` (they replay less history to
+reach the latest version) — Monad storage is not refundable, so this is not a cost rebate,
+just a faster-replay optimization.
+
+```bash
+mnemonad compact 123 ~/my-data
+```
+
+### Repair a corrupt stream with a force snapshot
+
+If a diff patch was pushed against a stale base (e.g. a race condition in `watch`),
+subsequent pulls will fail. Fix it by pushing a new full snapshot:
+
+```bash
+mnemonad push 123 ~/my-data --force-snapshot
+# skips chain replay and pushes the current folder as a self-contained full snapshot
+# restore() will recover from this snapshot, skipping any corrupt diffs before it
+```
+
+## End-to-end workflow
+
+Create a stream, verify what was stored, then roll back to an earlier version:
+
+```bash
+export MNEMONAD_KEY=0xabc123...
+
+# 1. first push — creates the stream
+mnemonad push ~/my-data
+#   created: 123
+#   version 1 pushed (full snapshot, gzip compressed)
+
+# 2. verify: restore into a scratch folder and compare against the original
+mnemonad pull 123 ~/verify-tmp
+diff -r ~/my-data ~/verify-tmp
+
+# 3. change something and push again
+echo "hello" > ~/my-data/new.txt
+mnemonad push 123 ~/my-data
+#   version 2 pushed (diff, gzip compressed)
+
+# 4. review the history
+mnemonad info 123 ~/my-data
+#   versions:        2
+#   local matches:   version 2 of 2
+
+# 5. roll back: restore version 1 into a separate folder
+mnemonad pull 123 ~/my-data-v1 --version 1
+```
+
+## How it works
+
+1. **push** — scans the current directory, computes a tree hash, and compares it against the
+   last stored version. If changes are detected, a compressed diff (or full snapshot on the
+   first push) is uploaded on-chain (large items offloaded to IPFS when `--pinata-jwt` is
+   set).
+2. **pull** — reads the requested version from the stream (fetching any externally-offloaded
+   items through `--gateway-url`), decrypts it if encrypted, and writes only changed files to
+   disk. Files absent from the stored version are deleted.
+3. **info** — reads stream metadata from the chain (version count, binary size, owner) and
+   checks whether the local folder matches any stored version.
+4. **diff** — restores the requested version in memory (nothing is written to disk), hashes
+   every file on both sides, and lists files added, modified, or deleted locally compared to
+   the on-chain version.
+5. **watch** — combines push and pull in a loop. A filesystem watcher triggers a debounced
+   push on local changes. A poll interval checks the remote stream for new versions and
+   pulls them if found. Push and pull never run concurrently. Monad's registry has no
+   "expected prior length" guard on push, so `watch` re-checks the remote length itself
+   right before pushing and resyncs if it has moved — a best-effort narrowing of the race
+   window, not a hard guarantee.
+6. **compact** — drops all existing history on-chain and pushes the current folder as a
+   single fresh full snapshot, speeding up future replay after many incremental syncs.
+
+### Default excludes
+
+The following are always excluded from snapshots: `node_modules`, `.git`, `.env`,
+`.DS_Store`, `.mnemonad`, `.claude`, `pnpm-lock.yaml`, `package-lock.json`. Add more with
+`--exclude`.
+
+## Dependencies
+
+| Package | Role |
+|---|---|
+| `mnemonad` | On-chain stream primitive (this repo's `js/`) |
+| `monadsync` | Folder-diff / snapshot layer on top of `mnemonad` (this repo's `monadsync/`) |
+| `viem` | Monad client / key management |

package/bin/mnemonad.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+// Intercept process.exit() calls from dependencies so they don't interrupt
+// the top-level await before it settles. Converts them to thrown errors that
+// our try/catch handles, then sets process.exitCode without calling exit().
+// Defensive: harmless if nothing in the dependency chain ever actually calls
+// process.exit() mid-await, but cheap insurance if something eventually does.
+const _realExit = process.exit.bind(process);
+process.exit = (code) => {
+    const err = new Error(`process.exit(${code ?? 0})`);
+    err._isProcessExit = true;
+    err._exitCode = code ?? 0;
+    throw err;
+};
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+import { push, pull, info, diff, watch, compact } from '../lib/commands/index.js';
+import defaultConfig from '../mnemonad.config.js';
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+const VERSION = (() => {
+    try {
+        return JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8')).version;
+    } catch {
+        return 'unknown';
+    }
+})();
+
+// Project-wide operational defaults — see mnemonad.config.js's own comments for what each
+// value means and why it's safe to commit. Precedence for every value it feeds
+// (`gatewayUrl`, `presignUrl`): CLI flag > env var > that file > the hardcoded fallback
+// below (kept in case the import above ever fails).
+const CONFIG = defaultConfig || {};
+
+// Same default the explorer dApp uses (explorer/src/mnemonad/presignProvider.js) — a
+// public read gateway so pulling/diffing/inspecting a stream with IPFS-offloaded items
+// works out of the box, with no setup, for anyone who didn't push it themselves.
+const DEFAULT_IPFS_GATEWAY = CONFIG.gatewayUrl || 'https://gateway.pinata.cloud/ipfs/';
+
+// The deployed presign server (presign-server/) this project runs by default — see its own
+// README for what it does. Pushing an item too big to fit on-chain uses this automatically
+// so a signer needs no Pinata credential of their own; --pinata-jwt still works as a direct
+// alternative for anyone who'd rather supply their own.
+const DEFAULT_PRESIGN_URL = CONFIG.presignUrl || null;
+
+const USAGE = `mnemonad v${VERSION} — sync local folders to a versioned, diffed stream on Monad
+
+Usage:
+  mnemonad push [stream-id] <path> [options]     Sync a folder to a stream (creates if no id)
+  mnemonad pull <stream-id> <path> [options]      Restore stream contents to a folder
+  mnemonad info [stream-id] [path] [options]      Show stream metadata (path only needed with a stream-id)
+  mnemonad diff <stream-id> <path> [options]      List local files added/modified/deleted vs the on-chain version
+  mnemonad watch <stream-id> <path> [options]     Watch folder and auto-push/pull
+  mnemonad compact <stream-id> <path> [options]   Truncate old history, push a fresh snapshot
+
+<path> is always required wherever a command touches a folder — the CLI never assumes the
+current directory. The only exception is \`mnemonad info\` with no stream-id, which just
+checks your configured chain/wallet and needs no folder at all.
+
+Options:
+  --chain <name>            Chain: testnet, mainnet, local (default: testnet)
+  --rpc-url <url>           Override the resolved RPC endpoint (e.g. a local Hardhat node)
+  --contract-address <addr> Registry address to use instead of the chain's known deployment
+                            (required with --chain local)
+  --gateway-url <url>       IPFS gateway for reading externally-offloaded items
+                            (default: https://gateway.pinata.cloud/ipfs/, or MNEMONAD_IPFS_GATEWAY env var)
+  --presign-url <url>       Presign server for paid IPFS uploads with no Pinata credential
+                            (default: the deployed server in mnemonad.config.js, or MNEMONAD_PRESIGN_URL env var)
+  --key <privkey>           Monad private key (or set MNEMONAD_KEY env var)
+  --phrase <mnemonic>       Mnemonic phrase
+  --version <n>             Version to restore/compare (pull, diff, info; default: latest)
+  --exclude <p1,p2>         Extra exclude patterns (comma-separated)
+  --no-compress             Disable gzip compression
+  --encrypt                 Create a new stream encrypted; only applies on creation
+  --encrypt-with <method>   How to key it: password, or wallet (the --key/--phrase account
+                            signs for it). Implied by --password; required otherwise
+  --password <pw>           Password to encrypt a new stream with, or decrypt an existing one
+  --pinata-jwt <jwt>        Pinata JWT for IPFS offload of large files (or PINATA_JWT env var)
+  --manifest                Write/use .mnemonad manifest for faster change detection
+  --force-snapshot          Push a full snapshot regardless of prior history (repairs corrupt streams)
+  --poll-interval <s>       Watch: seconds between remote checks (default: 2)
+  --debounce <ms>           Watch: ms quiet period before pushing after a change (default: 1000)
+  --push-only               Watch: disable auto-pull
+  --pull-only               Watch: disable auto-push
+  --help                    Show this help
+`;
+
+function parseArgs(argv) {
+    const args = {
+        command: null,
+        streamId: null,
+        // No cwd fallback — every command that touches a folder requires it explicitly (see
+        // shared.js's resolvePath(), which throws a friendly error if it's still null here).
+        path: null,
+        chain: 'testnet',
+        rpcUrl: null,
+        contractAddress: null,
+        gatewayUrl: process.env.MNEMONAD_IPFS_GATEWAY || DEFAULT_IPFS_GATEWAY,
+        presignUrl: process.env.MNEMONAD_PRESIGN_URL || DEFAULT_PRESIGN_URL,
+        key: null,
+        phrase: null,
+        version: null,
+        exclude: null,
+        compress: 'gzip',
+        encrypt: false,
+        encryptWith: null,
+        password: null,
+        pinataJwt: process.env.PINATA_JWT || null,
+        manifest: false,
+        forceSnapshot: false,
+        pollInterval: 2,
+        debounce: 1000,
+        pushOnly: false,
+        pullOnly: false,
+    };
+
+    const raw = argv.slice(2);
+
+    if (raw.length === 0 || raw.includes('--help')) {
+        console.log(USAGE);
+        _realExit(0);
+    }
+
+    args.command = raw[0];
+
+    let i = 1;
+
+    // Collect up to two positional args: [streamId] [path]. `path` is left null when it
+    // isn't given here — never defaulted to cwd — so a command that needs one (every
+    // command except a bare `info`) fails fast with a clear error instead of silently
+    // operating on whatever directory the CLI happened to be run from.
+    // A stream id is a decimal bigint or a 0x-prefixed hex string; anything else is a path.
+    const isStreamId = (s) => /^\d+$/.test(s) || /^0x[0-9a-fA-F]+$/.test(s);
+    const positionals = [];
+    while (i < raw.length && !raw[i].startsWith('--')) {
+        positionals.push(raw[i]);
+        i++;
+    }
+    if (positionals.length === 2) {
+        args.streamId = positionals[0];
+        args.path = positionals[1];
+    } else if (positionals.length === 1) {
+        if (isStreamId(positionals[0])) {
+            args.streamId = positionals[0];
+        } else {
+            args.path = positionals[0];
+        }
+    }
+
+    while (i < raw.length) {
+        const flag = raw[i];
+        if (flag === '--chain' && i + 1 < raw.length) {
+            args.chain = raw[++i];
+        } else if (flag === '--rpc-url' && i + 1 < raw.length) {
+            args.rpcUrl = raw[++i];
+        } else if (flag === '--contract-address' && i + 1 < raw.length) {
+            args.contractAddress = raw[++i];
+        } else if (flag === '--gateway-url' && i + 1 < raw.length) {
+            args.gatewayUrl = raw[++i];
+        } else if (flag === '--presign-url' && i + 1 < raw.length) {
+            args.presignUrl = raw[++i];
+        } else if (flag === '--key' && i + 1 < raw.length) {
+            args.key = raw[++i];
+        } else if (flag === '--phrase' && i + 1 < raw.length) {
+            args.phrase = raw[++i];
+        } else if (flag === '--version' && i + 1 < raw.length) {
+            args.version = raw[++i];
+        } else if (flag === '--exclude' && i + 1 < raw.length) {
+            args.exclude = raw[++i];
+        } else if (flag === '--no-compress') {
+            args.compress = false;
+        } else if (flag === '--encrypt') {
+            args.encrypt = true;
+        } else if (flag === '--encrypt-with' && i + 1 < raw.length) {
+            args.encryptWith = raw[++i];
+        } else if (flag === '--password' && i + 1 < raw.length) {
+            args.password = raw[++i];
+        } else if (flag === '--pinata-jwt' && i + 1 < raw.length) {
+            args.pinataJwt = raw[++i];
+        } else if (flag === '--manifest') {
+            args.manifest = true;
+        } else if (flag === '--force-snapshot') {
+            args.forceSnapshot = true;
+        } else if (flag === '--poll-interval' && i + 1 < raw.length) {
+            args.pollInterval = Number(raw[++i]);
+        } else if (flag === '--debounce' && i + 1 < raw.length) {
+            args.debounce = Number(raw[++i]);
+        } else if (flag === '--push-only') {
+            args.pushOnly = true;
+        } else if (flag === '--pull-only') {
+            args.pullOnly = true;
+        }
+        i++;
+    }
+
+    return args;
+}
+
+const args = parseArgs(process.argv);
+
+console.log(`mnemonad v${VERSION}`);
+
+// A ref'd interval keeps the event loop alive for the duration of the command, in case
+// anything in the RPC/fetch stack unref's its own I/O (see the process.exit note above).
+const keepAlive = setInterval(() => {}, 60_000);
+
+try {
+    if (args.command === 'push') {
+        await push(args);
+    } else if (args.command === 'pull') {
+        await pull(args);
+    } else if (args.command === 'info') {
+        await info(args);
+    } else if (args.command === 'diff') {
+        await diff(args);
+    } else if (args.command === 'watch') {
+        await watch(args);
+    } else if (args.command === 'compact') {
+        await compact(args);
+    } else {
+        console.error('Unknown command:', args.command);
+        console.log(USAGE);
+        process.exitCode = 1;
+    }
+} catch (err) {
+    if (err._isProcessExit) {
+        process.exitCode = err._exitCode;
+    } else if (err._isUserError) {
+        // Expected, actionable failure — message only, no stack trace.
+        console.error('Error:', err.message);
+        process.exitCode = 1;
+    } else {
+        console.error('Error:', err.message);
+        if (err.stack) console.error(err.stack);
+        process.exitCode = 1;
+    }
+} finally {
+    clearInterval(keepAlive);
+}

package/lib/FSFile.js

@@ -0,0 +1,25 @@
+import { readFile, stat } from 'node:fs/promises';
+import { basename } from 'node:path';
+// monadsync re-exports its whole sync-primitives surface so a consumer needs only one
+// dependency, not two — see monadsync/index.js.
+import { DoubleSyncFile as SyncFile } from 'monadsync';
+
+export class FSFile extends SyncFile {
+    constructor(filePath) {
+        super();
+        this._path = filePath;
+        this._name = basename(filePath);
+    }
+
+    get name() { return this._name; }
+
+    async getContent() {
+        const buf = await readFile(this._path);
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+
+    async getSize() {
+        const s = await stat(this._path);
+        return s.size;
+    }
+}

package/lib/FSFolder.js

@@ -0,0 +1,39 @@
+import { readdir } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+// monadsync re-exports its whole sync-primitives surface so a consumer needs only one
+// dependency, not two — see monadsync/index.js.
+import { DoubleSyncFolder as SyncFolder } from 'monadsync';
+import { FSFile } from './FSFile.js';
+
+const DEFAULT_EXCLUDES = ['node_modules', '.git', '.env', '.DS_Store', '.mnemonad', '.claude', 'pnpm-lock.yaml', 'package-lock.json'];
+
+export class FSFolder extends SyncFolder {
+    constructor(dirPath, excludes = DEFAULT_EXCLUDES) {
+        super();
+        this._path = dirPath;
+        this._name = basename(dirPath);
+        this._excludes = excludes;
+    }
+
+    get name() { return this._name; }
+
+    async list() {
+        const entries = await readdir(this._path, { withFileTypes: true });
+        const children = [];
+
+        for (const entry of entries) {
+            if (this._excludes.includes(entry.name)) continue;
+            if (entry.name.startsWith('.')) continue;
+
+            const fullPath = join(this._path, entry.name);
+
+            if (entry.isDirectory()) {
+                children.push(new FSFolder(fullPath, this._excludes));
+            } else if (entry.isFile()) {
+                children.push(new FSFile(fullPath));
+            }
+        }
+
+        return children;
+    }
+}