@paneui/cli 0.0.1

package/dist/commands/create.js

@@ -0,0 +1,196 @@
+// `pane create` — create a session via POST /v1/sessions.
+import { createSessionSchema } from "@paneui/core";
+import { makeClient } from "../config.js";
+import { resolveJson, resolveText } from "../input.js";
+import { printJson, fail, failFromError } from "../output.js";
+export const createHelp = `pane create — create a Pane session
+
+A session is one use of an artifact. Supply the artifact in ONE of two ways:
+
+  Reference form — instance an existing reusable artifact (the cheap path,
+  no HTML re-sent):
+    pane create --artifact-id <id|slug> [--version <n>] [--input-data <v>]
+
+  Inline form — a one-off artifact, defined on this call:
+    pane create --artifact <path|inline> [--event-schema <path|json>] [options]
+
+Exactly one of --artifact-id / --artifact must be given.
+
+Artifact (choose one):
+  --artifact-id <v>   Reference an existing named artifact by id or slug.
+                      Tip: run 'pane artifact search <keywords>' first — a
+                      suitable artifact may already exist; reuse it instead of
+                      regenerating HTML.
+  --version <n>       With --artifact-id: pin a specific version. Defaults to
+                      the artifact's latest version.
+  --artifact <v>      Inline HTML artifact. Either a file path / URL, or inline
+                      HTML. Combine with --artifact-type to control reading.
+  --event-schema <v>  Inline-form event schema. A .json file, or inline JSON.
+                      Optional with --artifact. Omit for a view-only artifact
+                      (a report/dashboard the human only views — no page/agent
+                      events). Ignored with --artifact-id.
+
+                      Shape — an object with an "events" map, keyed by event
+                      type. Each entry declares who may emit it and the JSON
+                      Schema for its payload:
+                          {
+                            "events": {
+                              "form.submitted": {
+                                "emittedBy": ["page"],
+                                "payload": {
+                                  "type": "object",
+                                  "properties": { "answer": { "type": "string" } },
+                                  "required": ["answer"]
+                                }
+                              }
+                            }
+                          }
+                      emittedBy is any non-empty subset of ["page", "agent"].
+                      payload is a JSON Schema; the relay validates every
+                      emit against it. See docs/SPEC.md for the full grammar.
+
+Options:
+  --input-data <v>    This instance's seed data — a JSON object (file path or
+                      inline JSON), validated by the relay against the artifact
+                      version's input_schema. The page reads it as
+                      window.pane.inputData.
+  --artifact-type <t> "html-inline" (default) or "html-ref". With "html-ref"
+                      the --artifact value is treated as a URL. Note: the relay
+                      does not serve "html-ref" artifacts in this release and
+                      will reject the session — use "html-inline".
+  --ttl <seconds>     Session time-to-live in seconds.
+  --participants <n>  Number of human participants (default 1).
+  --metadata <path|json>  Arbitrary metadata object (file path or inline JSON).
+  --callback <path|json>  Webhook callback config: { url, events[], secret }.
+  --url <url>         Relay base URL (overrides PANE_URL).
+  --api-key <key>     Agent API key (overrides PANE_API_KEY).
+  -h, --help          Show this help.
+
+Output (stdout, JSON):
+  { session_id, urls, tokens, expires_at }
+
+Deliver urls.humans to the human(s); keep tokens.agent for the WS stream.`;
+export async function runCreate(args) {
+    const artifactIdVal = args.flags.get("artifact-id");
+    const artifactVal = args.flags.get("artifact");
+    // Exactly one of the two artifact forms must be present.
+    if (artifactIdVal !== undefined && artifactVal !== undefined) {
+        fail("pass only one of --artifact-id (reference an existing artifact) or --artifact (inline a one-off)", "invalid_args");
+    }
+    if (artifactIdVal === undefined && artifactVal === undefined) {
+        fail("missing artifact — pass --artifact-id <id|slug> to reference an existing artifact, or --artifact <path|inline> to inline one", "invalid_args");
+    }
+    // Assemble a candidate request object, then validate the whole thing with
+    // the shared Zod schema (single source of truth, matches what the relay
+    // expects). Per-field number parsing still happens here so we can give a
+    // flag-specific message; the schema then enforces shape and bounds.
+    const candidate = {};
+    if (artifactIdVal !== undefined) {
+        // Reference form — instance an existing named artifact. --artifact /
+        // --event-schema are not needed here.
+        const ref = { id: artifactIdVal };
+        const versionRaw = args.flags.get("version");
+        if (versionRaw !== undefined) {
+            const version = Number(versionRaw);
+            if (!Number.isInteger(version) || version < 1) {
+                fail("--version must be a positive integer", "invalid_args");
+            }
+            ref["version"] = version;
+        }
+        candidate["artifact"] = ref;
+    }
+    else {
+        // Inline form — the event schema rides inside the `artifact` object; the
+        // relay transparently creates an anonymous artifact behind it.
+        // --event-schema is optional: omitting it makes a view-only one-off (a
+        // report/dashboard the human only views), and the relay then rejects every
+        // page/agent emit.
+        const schemaVal = args.flags.get("event-schema");
+        const artifactType = (args.flags.get("artifact-type") ?? "html-inline");
+        if (artifactType !== "html-inline" && artifactType !== "html-ref") {
+            fail("--artifact-type must be 'html-inline' or 'html-ref'", "invalid_args");
+        }
+        // html-ref: the value is a URL, used verbatim. html-inline: file or literal.
+        let source;
+        try {
+            source =
+                artifactType === "html-ref" ? artifactVal : resolveText(artifactVal);
+        }
+        catch (e) {
+            fail(e instanceof Error ? e.message : String(e), "invalid_args");
+        }
+        // Build the inline artifact object. event_schema is OMITTED entirely (not
+        // set to undefined) when --event-schema is absent — a view-only artifact.
+        const inlineArtifact = {
+            type: artifactType,
+            source,
+        };
+        if (schemaVal !== undefined) {
+            try {
+                inlineArtifact["event_schema"] = resolveJson(schemaVal, "--event-schema");
+            }
+            catch (e) {
+                fail(e instanceof Error ? e.message : String(e), "invalid_args");
+            }
+        }
+        candidate["artifact"] = inlineArtifact;
+    }
+    // --input-data — per-instance seed data, applies to either form (the relay
+    // validates it against the pinned version's input_schema).
+    const inputDataRaw = args.flags.get("input-data");
+    if (inputDataRaw !== undefined) {
+        try {
+            candidate["input_data"] = resolveJson(inputDataRaw, "--input-data");
+        }
+        catch (e) {
+            fail(e instanceof Error ? e.message : String(e), "invalid_args");
+        }
+    }
+    const ttlRaw = args.flags.get("ttl");
+    if (ttlRaw !== undefined) {
+        const ttl = Number(ttlRaw);
+        if (!Number.isFinite(ttl))
+            fail("--ttl must be a number", "invalid_args");
+        candidate["ttl"] = ttl;
+    }
+    const partRaw = args.flags.get("participants");
+    if (partRaw !== undefined) {
+        const humans = Number(partRaw);
+        if (!Number.isFinite(humans))
+            fail("--participants must be a number", "invalid_args");
+        candidate["participants"] = { humans };
+    }
+    const metaRaw = args.flags.get("metadata");
+    if (metaRaw !== undefined) {
+        try {
+            candidate["metadata"] = resolveJson(metaRaw, "--metadata");
+        }
+        catch (e) {
+            fail(e instanceof Error ? e.message : String(e), "invalid_args");
+        }
+    }
+    const cbRaw = args.flags.get("callback");
+    if (cbRaw !== undefined) {
+        try {
+            candidate["callback"] = resolveJson(cbRaw, "--callback");
+        }
+        catch (e) {
+            fail(e instanceof Error ? e.message : String(e), "invalid_args");
+        }
+    }
+    const parsed = createSessionSchema.safeParse(candidate);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        const where = issue && issue.path.length > 0 ? issue.path.join(".") : "request";
+        fail(`invalid create request: ${where}: ${issue ? issue.message : "validation failed"}`, "invalid_args", parsed.error.flatten());
+    }
+    const req = parsed.data;
+    const client = makeClient(args);
+    try {
+        const res = await client.createSession(req);
+        printJson(res);
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}

package/dist/commands/delete.js

@@ -0,0 +1,31 @@
+// `pane delete <id>` — close/delete a session.
+import { makeClient } from "../config.js";
+import { printJson, fail, failFromError } from "../output.js";
+export const deleteHelp = `pane delete — close/delete a session
+
+Usage:
+  pane delete <session-id> [options]
+
+Closes and deletes the session (DELETE /v1/sessions/:id). Idempotent on the
+relay side — deleting an already-closed session still succeeds.
+
+Options:
+  --url <url>         Relay base URL (overrides PANE_URL).
+  --api-key <key>     Agent API key (overrides PANE_API_KEY).
+  -h, --help          Show this help.
+
+Output (stdout, JSON):
+  { session_id, deleted: true }`;
+export async function runDelete(args) {
+    const sessionId = args.positionals[0];
+    if (!sessionId)
+        fail("missing <session-id>", "invalid_args");
+    const client = makeClient(args);
+    try {
+        await client.deleteSession(sessionId);
+        printJson({ session_id: sessionId, deleted: true });
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}

package/dist/commands/keys.js

@@ -0,0 +1,76 @@
+// `pane keys` — inspect or revoke the calling agent's API key.
+//
+// Flat command namespace: `keys` is one top-level command that branches on a
+// positional subcommand (list / revoke). The relay scopes /v1/keys to the
+// authenticated agent, so there is exactly one key — the caller's own. Both
+// subcommands therefore act ONLY on the caller's own key.
+import { makeClient } from "../config.js";
+import { printJson, fail, failFromError } from "../output.js";
+export const keysHelp = `pane keys — inspect or revoke YOUR agent's API key
+
+Usage:
+  pane keys <subcommand> [options]
+
+Subcommands:
+  list       Show YOUR agent's key info. The relay scopes keys to the
+             authenticated agent — there is exactly one key per agent, your
+             own. Prints { agent_id, name, key_prefix, created_at,
+             last_used_at, revoked_at }.
+
+  revoke     Revoke YOUR OWN API key — a self-destruct. The key stops working
+             IMMEDIATELY; every subsequent command fails until you run
+             'pane register' again to provision a new key. The relay only
+             allows revoking your own key. Requires --yes to confirm.
+             Prints { revoked: true, agent_id }.
+
+Options:
+  --yes               Confirm 'keys revoke' (required — it is irreversible).
+  --url <url>         Relay base URL (overrides PANE_URL).
+  --api-key <key>     Agent API key (overrides PANE_API_KEY).
+  -h, --help          Show this help.
+
+Output: stdout is machine-readable JSON.`;
+async function runKeysList(args) {
+    const client = makeClient(args);
+    try {
+        const info = await client.listKeys();
+        printJson(info);
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+async function runKeysRevoke(args) {
+    if (!args.bools.has("yes")) {
+        fail("'pane keys revoke' revokes YOUR OWN API key — it stops working " +
+            "immediately and is irreversible. Pass --yes to confirm.", "confirmation_required");
+    }
+    const client = makeClient(args);
+    try {
+        // The relay only permits revoking the caller's own key. If a positional id
+        // is given, pass it through and let the relay 403 a wrong one; otherwise
+        // resolve the caller's own id from GET /v1/keys.
+        const id = args.positionals[1] ?? (await client.listKeys()).agent_id;
+        await client.revokeKey(id);
+        printJson({ revoked: true, agent_id: id });
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+export async function runKeys(args) {
+    const sub = args.positionals[0];
+    switch (sub) {
+        case "list":
+            await runKeysList(args);
+            break;
+        case "revoke":
+            await runKeysRevoke(args);
+            break;
+        case undefined:
+            fail("missing subcommand — usage: pane keys <list|revoke> (run 'pane keys --help')", "invalid_args");
+            break;
+        default:
+            fail(`unknown keys subcommand '${sub}' — expected list|revoke (run 'pane keys --help')`, "invalid_args");
+    }
+}

package/dist/commands/logout.js

@@ -0,0 +1,25 @@
+// `pane logout` — clear the locally-saved relay URL + API key.
+import { clearStore } from "../store.js";
+import { printJson } from "../output.js";
+export const logoutHelp = `pane logout — clear the saved relay URL + API key
+
+Usage:
+  pane logout [options]
+
+Deletes the CLI config file (\${XDG_CONFIG_HOME:-~/.config}/pane/config.json),
+which holds the relay URL and the agent API key saved by 'pane register'.
+Idempotent — no error if there is nothing to clear.
+
+This only clears the LOCAL config. It does NOT revoke the key on the relay —
+the key keeps working until it is revoked. To revoke it on the relay, use
+'pane keys revoke'.
+
+Options:
+  -h, --help          Show this help.
+
+Output (stdout, JSON):
+  { cleared: true, path }`;
+export async function runLogout() {
+    const path = clearStore();
+    printJson({ cleared: true, path });
+}

package/dist/commands/register.js

@@ -0,0 +1,79 @@
+// `pane register` — self-provision an agent API key from the relay.
+//
+// This is the one command that needs no API key: it is the call that obtains
+// one. If the relay runs REGISTRATION_MODE=secret, pass the shared
+// registration secret via --secret or PANE_REGISTER_SECRET. On success the key
+// (and relay URL) are persisted to the CLI config file, so every later command
+// works with only PANE_URL (or nothing) set.
+import { registerAgent, PaneApiError } from "@paneui/core";
+import { DEFAULT_RELAY_URL } from "../config.js";
+import { printJson, fail } from "../output.js";
+import { readStore, writeStore } from "../store.js";
+export const registerHelp = `pane register — register this agent with the relay and save the key locally
+
+Usage:
+  pane register [options]
+
+Calls POST /v1/register, then saves the returned API key (and relay URL) to the
+CLI config file — so afterwards every other command works with only PANE_URL
+set (no PANE_API_KEY needed).
+
+Options:
+  --name <n>          Agent display name. The relay defaults it if omitted.
+  --url <url>         Relay base URL. Falls back to PANE_URL, then the config
+                      file, then the hosted Pane relay. Self-hosters set this.
+  --secret <s>        Registration secret, sent as a Bearer token. Only needed
+                      when the relay uses REGISTRATION_MODE=secret. Falls back
+                      to the PANE_REGISTER_SECRET env var.
+  --print-key         Also echo the full api_key in the output. By default the
+                      key is only persisted to the config file, never printed.
+  -h, --help          Show this help.
+
+Output (stdout, JSON):
+  { agent_id, key_prefix, saved_to }   (+ api_key when --print-key is given)
+
+The API key is saved to the CLI config file (mode 0600); it is not printed
+unless --print-key is passed.`;
+export async function runRegister(args) {
+    const store = readStore();
+    const url = args.flags.get("url") ??
+        process.env.PANE_URL ??
+        store.url ??
+        DEFAULT_RELAY_URL;
+    const name = args.flags.get("name");
+    const secret = args.flags.get("secret") ?? process.env.PANE_REGISTER_SECRET ?? undefined;
+    let result;
+    try {
+        result = await registerAgent({
+            url: url.replace(/\/$/, ""),
+            ...(name !== undefined ? { name } : {}),
+            ...(secret !== undefined && secret !== "" ? { secret } : {}),
+        });
+    }
+    catch (e) {
+        if (e instanceof PaneApiError) {
+            if (e.status === 429) {
+                fail("registration rate limit exceeded — try again later", "rate_limited", undefined, { hint: e.hint, retryable: e.retryable, docs_url: e.docsUrl });
+            }
+            fail(e.message, e.code, e.details, {
+                hint: e.hint,
+                retryable: e.retryable,
+                docs_url: e.docsUrl,
+            });
+        }
+        fail(e instanceof Error ? e.message : String(e), "internal");
+    }
+    const savedTo = writeStore({
+        url: url.replace(/\/$/, ""),
+        apiKey: result.api_key,
+    });
+    const out = {
+        agent_id: result.agent_id,
+        key_prefix: result.key_prefix,
+        saved_to: savedTo,
+    };
+    if (args.bools.has("print-key")) {
+        out["api_key"] = result.api_key;
+    }
+    printJson(out);
+}

package/dist/commands/send.js

@@ -0,0 +1,58 @@
+// `pane send <id>` — append an agent event to a session.
+import { makeClient } from "../config.js";
+import { resolveJson } from "../input.js";
+import { printJson, fail, failFromError } from "../output.js";
+export const sendHelp = `pane send — emit an agent event into a session
+
+Usage:
+  pane send <session-id> --type <event-type> --data <path|json> [options]
+
+POSTs an event to /v1/sessions/:id/events. The event is stamped as authored by
+the agent (the relay derives identity from the API key — it cannot be spoofed).
+
+Required:
+  --type <t>          Event type. Must exist in the session's event schema
+                      with the agent in its emittedBy list.
+  --data <v>          Event payload: a file path to a .json file, or inline
+                      JSON. Use --data 'null' or --data '{}' for no payload.
+
+Options:
+  --causation-id <id> Opaque causation id stored verbatim on the event.
+  --idempotency-key <k>  Dedup key — a repeat send with the same key is a no-op.
+  --url <url>         Relay base URL (overrides PANE_URL).
+  --api-key <key>     Agent API key (overrides PANE_API_KEY).
+  -h, --help          Show this help.
+
+Output (stdout, JSON):
+  { event, deduped }`;
+export async function runSend(args) {
+    const sessionId = args.positionals[0];
+    if (!sessionId)
+        fail("missing <session-id>", "invalid_args");
+    const type = args.flags.get("type");
+    if (!type)
+        fail("missing --type", "invalid_args");
+    const dataRaw = args.flags.get("data");
+    if (dataRaw === undefined)
+        fail("missing --data", "invalid_args");
+    let data;
+    try {
+        data = resolveJson(dataRaw, "--data");
+    }
+    catch (e) {
+        fail(e instanceof Error ? e.message : String(e), "invalid_args");
+    }
+    const client = makeClient(args);
+    try {
+        const res = await client.sendEvent(sessionId, {
+            type: type,
+            data,
+            causationId: args.flags.get("causation-id"),
+            idempotencyKey: args.flags.get("idempotency-key"),
+        });
+        printJson(res);
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}

package/dist/commands/state.js

@@ -0,0 +1,34 @@
+// `pane state <id>` — non-blocking snapshot of a session.
+import { makeClient } from "../config.js";
+import { printJson, fail, failFromError } from "../output.js";
+export const stateHelp = `pane state — show a session's metadata and event log
+
+Usage:
+  pane state <session-id> [options]
+
+Non-blocking. Fetches session metadata (GET /v1/sessions/:id) plus the event
+log (GET /v1/sessions/:id/events) and prints them together.
+
+Options:
+  --since <cursor>    Only return events after this opaque cursor.
+  --url <url>         Relay base URL (overrides PANE_URL).
+  --api-key <key>     Agent API key (overrides PANE_API_KEY).
+  -h, --help          Show this help.
+
+Output (stdout, JSON):
+  { meta, events, next_cursor }`;
+export async function runState(args) {
+    const sessionId = args.positionals[0];
+    if (!sessionId)
+        fail("missing <session-id>", "invalid_args");
+    const since = args.flags.get("since") ?? null;
+    const client = makeClient(args);
+    try {
+        const meta = await client.getSession(sessionId);
+        const page = await client.getEvents(sessionId, { since });
+        printJson({ meta, events: page.events, next_cursor: page.next_cursor });
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}

package/dist/commands/watch.js

@@ -0,0 +1,138 @@
+// `pane watch <id>` — long-lived: hold a WebSocket and stream events as
+// JSON-lines on stdout. This harness-agnostic stdout is the core contract:
+// one compact JSON object per line, flushed after every event, so any
+// pipe-reader (Claude Code's Monitor tool, `while read line`, jq -c, ...)
+// sees each event the instant it lands.
+import { openStream } from "@paneui/core";
+import { resolveConfig } from "../config.js";
+import { PaneClient } from "@paneui/core";
+import { printJsonLine, fail } from "../output.js";
+export const watchHelp = `pane watch — stream a session's events as JSON-lines
+
+Usage:
+  pane watch <session-id> [options]
+
+Holds a WebSocket to WS /v1/sessions/:id/stream. Prints ONE compact JSON
+object per line to stdout, flushing after each — designed to be piped into a
+line-reader. On session close, prints a final {"type":"_closed"} line and
+exits 0.
+
+Modes:
+  (bare)              Run until SIGINT (Ctrl-C). Exit 0.
+  --once              Exit 0 after the first event.
+  --type <t>          Exit 0 after the first event whose type equals <t>.
+
+Options:
+  --since <cursor>    Replay only events after this opaque cursor.
+  --timeout <secs>    Fail with code ws_timeout if no frame (not even the
+                      replay-complete marker) arrives within this window.
+  --url <url>         Relay base URL (overrides PANE_URL).
+  --api-key <key>     Agent API key (overrides PANE_API_KEY).
+  -h, --help          Show this help.
+
+Each line is one event envelope: { id, session_id, author, ts, type, data,
+causation_id, idempotency_key }. The terminal line is {"type":"_closed"}.
+
+Pattern — Claude Code Monitor tool: run \`pane watch <id> --type form.submitted\`
+as a monitored process; the harness re-invokes the model when the line lands.`;
+export async function runWatch(args) {
+    const sessionId = args.positionals[0];
+    if (!sessionId)
+        fail("missing <session-id>", "invalid_args");
+    const cfg = resolveConfig(args);
+    const since = args.flags.get("since") ?? null;
+    const waitType = args.flags.get("type") ?? null;
+    const once = args.bools.has("once");
+    let timeoutSec = null;
+    const timeoutRaw = args.flags.get("timeout");
+    if (timeoutRaw !== undefined) {
+        const t = Number(timeoutRaw);
+        if (!Number.isFinite(t) || t <= 0)
+            fail("--timeout must be a positive number", "invalid_args");
+        timeoutSec = t;
+    }
+    const client = new PaneClient({ url: cfg.url, apiKey: cfg.apiKey });
+    let exited = false;
+    const finish = (code) => {
+        if (exited)
+            return;
+        exited = true;
+        if (timer)
+            clearTimeout(timer);
+        process.exit(code);
+    };
+    // Emit the terminal marker exactly once, then exit 0.
+    let closedEmitted = false;
+    const emitClosed = () => {
+        if (!closedEmitted) {
+            closedEmitted = true;
+            printJsonLine({ type: "_closed" });
+        }
+        finish(0);
+    };
+    // Track whether the relay told us the session expired before the socket
+    // closed — a 1006/1008/1011 close after that is still a clean shutdown.
+    let sawSessionExpired = false;
+    // Connection timeout: fail if no frame at all arrives within the window.
+    let timer;
+    if (timeoutSec !== null) {
+        timer = setTimeout(() => {
+            fail(`no stream frame within ${timeoutSec}s`, "ws_timeout");
+        }, timeoutSec * 1000);
+    }
+    const sawFrame = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const handle = openStream({
+        wsBaseUrl: client.wsBaseUrl,
+        sessionId: sessionId,
+        token: cfg.apiKey,
+        since,
+    }, {
+        onReplayComplete: () => {
+            sawFrame();
+        },
+        onEvent: (event) => {
+            sawFrame();
+            printJsonLine(event);
+            // A system.session.expired event means the session is closing.
+            if (event.type === "system.session.expired") {
+                sawSessionExpired = true;
+                emitClosed();
+                return;
+            }
+            if (once) {
+                finish(0);
+                return;
+            }
+            if (waitType !== null && event.type === waitType) {
+                finish(0);
+            }
+        },
+        onClose: ({ code, reason }) => {
+            // A clean close is 1000 (normal) or 1001 (going away). Any other code
+            // — 1006 abnormal, 1008 policy/auth, 1011 server error — is a failure
+            // UNLESS we already saw system.session.expired, which means the relay
+            // closed us on purpose after a clean session end.
+            if (code === 1000 || code === 1001 || sawSessionExpired) {
+                emitClosed();
+                return;
+            }
+            fail(`stream closed abnormally (code ${code})${reason ? ": " + reason : ""}`, "ws_closed_abnormally", { code, reason });
+        },
+        onRelayError: (err) => {
+            fail(err.message ?? "relay error", err.code ?? "relay_error", err.details);
+        },
+        onError: (err) => {
+            fail(err.message, "ws_error");
+        },
+    });
+    // SIGINT: clean shutdown, exit 0.
+    process.on("SIGINT", () => {
+        handle.close();
+        finish(0);
+    });
+}