@sensaiorg/adapter-android 0.1.0

package/dist/transport/agent-client.test.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_events_1 = require("node:events");
+const agent_client_js_1 = require("./agent-client.js");
+// --- Mock Socket ---
+class MockSocket extends node_events_1.EventEmitter {
+    write = vitest_1.vi.fn((_data, _enc, cb) => {
+        cb?.();
+        return true;
+    });
+    destroy = vitest_1.vi.fn();
+}
+let mockSocket;
+vitest_1.vi.mock("node:net", () => ({
+    createConnection: () => {
+        mockSocket = new MockSocket();
+        // Schedule the "connect" event by default (tests can override before it fires)
+        return mockSocket;
+    },
+}));
+(0, vitest_1.describe)("AgentClient", () => {
+    let client;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.useFakeTimers();
+        client = new agent_client_js_1.AgentClient("127.0.0.1", 9222);
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.clearAllMocks();
+    });
+    // Helper: connect the client by emitting the connect event
+    async function connectClient() {
+        const p = client.connect();
+        mockSocket.emit("connect");
+        await p;
+    }
+    (0, vitest_1.describe)("connect()", () => {
+        (0, vitest_1.it)("resolves on successful connection", async () => {
+            const p = client.connect();
+            // Socket emits connect
+            mockSocket.emit("connect");
+            await (0, vitest_1.expect)(p).resolves.toBeUndefined();
+            (0, vitest_1.expect)(client.isConnected()).toBe(true);
+        });
+        (0, vitest_1.it)("rejects on timeout", async () => {
+            const p = client.connect();
+            // Advance past the 5s connect timeout
+            vitest_1.vi.advanceTimersByTime(5_001);
+            await (0, vitest_1.expect)(p).rejects.toThrow("Agent connection timed out");
+            (0, vitest_1.expect)(mockSocket.destroy).toHaveBeenCalled();
+        });
+        (0, vitest_1.it)("rejects on connection error", async () => {
+            const p = client.connect();
+            mockSocket.emit("error", new Error("ECONNREFUSED"));
+            await (0, vitest_1.expect)(p).rejects.toThrow("Agent connection failed: ECONNREFUSED");
+            (0, vitest_1.expect)(client.isConnected()).toBe(false);
+        });
+        (0, vitest_1.it)("reuses existing connection (no-op)", async () => {
+            await connectClient();
+            // Second connect should resolve immediately without creating a new socket
+            await (0, vitest_1.expect)(client.connect()).resolves.toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)("call()", () => {
+        (0, vitest_1.it)("sends JSON-RPC request with incremented id", async () => {
+            await connectClient();
+            // Fire first call
+            const p1 = client.call("getTree", { depth: 2 });
+            const payload1 = JSON.parse(mockSocket.write.mock.calls[0][0].trim());
+            (0, vitest_1.expect)(payload1).toEqual({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "getTree",
+                params: { depth: 2 },
+            });
+            // Respond
+            mockSocket.emit("data", Buffer.from(JSON.stringify({ id: 1, result: "ok" }) + "\n"));
+            await p1;
+            // Fire second call
+            const p2 = client.call("getState");
+            const payload2 = JSON.parse(mockSocket.write.mock.calls[1][0].trim());
+            (0, vitest_1.expect)(payload2.id).toBe(2);
+            mockSocket.emit("data", Buffer.from(JSON.stringify({ id: 2, result: {} }) + "\n"));
+            await p2;
+        });
+        (0, vitest_1.it)("resolves with result from response", async () => {
+            await connectClient();
+            const p = client.call("getVersion");
+            mockSocket.emit("data", Buffer.from(JSON.stringify({ id: 1, result: { version: "1.0" } }) + "\n"));
+            await (0, vitest_1.expect)(p).resolves.toEqual({ version: "1.0" });
+        });
+        (0, vitest_1.it)("rejects on RPC error response", async () => {
+            await connectClient();
+            const p = client.call("badMethod");
+            mockSocket.emit("data", Buffer.from(JSON.stringify({
+                id: 1,
+                error: { code: -32601, message: "Method not found" },
+            }) + "\n"));
+            await (0, vitest_1.expect)(p).rejects.toThrow("RPC error (-32601): Method not found");
+        });
+        (0, vitest_1.it)("rejects on timeout", async () => {
+            await connectClient();
+            const p = client.call("slowMethod", undefined, 2_000);
+            // No response comes; advance past timeout
+            vitest_1.vi.advanceTimersByTime(2_001);
+            await (0, vitest_1.expect)(p).rejects.toThrow("RPC call 'slowMethod' timed out after 2000ms");
+        });
+        (0, vitest_1.it)("rejects if not connected", async () => {
+            await (0, vitest_1.expect)(client.call("anyMethod")).rejects.toThrow("Agent not connected. Call connect() first.");
+        });
+        (0, vitest_1.it)("sends empty params when none provided", async () => {
+            await connectClient();
+            const p = client.call("ping");
+            const payload = JSON.parse(mockSocket.write.mock.calls[0][0].trim());
+            (0, vitest_1.expect)(payload.params).toEqual({});
+            mockSocket.emit("data", Buffer.from(JSON.stringify({ id: 1, result: "pong" }) + "\n"));
+            await p;
+        });
+        (0, vitest_1.it)("rejects when socket write fails", async () => {
+            await connectClient();
+            mockSocket.write.mockImplementationOnce((_data, _enc, cb) => {
+                cb?.(new Error("broken pipe"));
+                return false;
+            });
+            await (0, vitest_1.expect)(client.call("test")).rejects.toThrow("Failed to send RPC: broken pipe");
+        });
+    });
+    (0, vitest_1.describe)("disconnect()", () => {
+        (0, vitest_1.it)("cleans up socket and pending requests", async () => {
+            await connectClient();
+            // Create a pending request
+            const p = client.call("longRunning");
+            client.disconnect();
+            (0, vitest_1.expect)(mockSocket.destroy).toHaveBeenCalled();
+            (0, vitest_1.expect)(client.isConnected()).toBe(false);
+            await (0, vitest_1.expect)(p).rejects.toThrow("Agent disconnected");
+        });
+    });
+    (0, vitest_1.describe)("isConnected()", () => {
+        (0, vitest_1.it)("returns false before connecting", () => {
+            (0, vitest_1.expect)(client.isConnected()).toBe(false);
+        });
+        (0, vitest_1.it)("returns true after connecting", async () => {
+            await connectClient();
+            (0, vitest_1.expect)(client.isConnected()).toBe(true);
+        });
+        (0, vitest_1.it)("returns false after disconnect", async () => {
+            await connectClient();
+            client.disconnect();
+            (0, vitest_1.expect)(client.isConnected()).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)("buffer processing", () => {
+        (0, vitest_1.it)("handles multiple messages in one chunk", async () => {
+            await connectClient();
+            const p1 = client.call("method1");
+            const p2 = client.call("method2");
+            // Send both responses in a single data chunk
+            const combined = JSON.stringify({ id: 1, result: "r1" }) +
+                "\n" +
+                JSON.stringify({ id: 2, result: "r2" }) +
+                "\n";
+            mockSocket.emit("data", Buffer.from(combined));
+            await (0, vitest_1.expect)(p1).resolves.toBe("r1");
+            await (0, vitest_1.expect)(p2).resolves.toBe("r2");
+        });
+        (0, vitest_1.it)("handles split messages across chunks", async () => {
+            await connectClient();
+            const p = client.call("method1");
+            const full = JSON.stringify({ id: 1, result: "split-result" }) + "\n";
+            const mid = Math.floor(full.length / 2);
+            // Send first half
+            mockSocket.emit("data", Buffer.from(full.slice(0, mid)));
+            // Send second half
+            mockSocket.emit("data", Buffer.from(full.slice(mid)));
+            await (0, vitest_1.expect)(p).resolves.toBe("split-result");
+        });
+    });
+    (0, vitest_1.describe)("disconnect rejects all pending requests", () => {
+        (0, vitest_1.it)("rejects multiple pending requests on disconnect", async () => {
+            await connectClient();
+            const p1 = client.call("a");
+            const p2 = client.call("b");
+            const p3 = client.call("c");
+            client.disconnect();
+            await (0, vitest_1.expect)(p1).rejects.toThrow("Agent disconnected");
+            await (0, vitest_1.expect)(p2).rejects.toThrow("Agent disconnected");
+            await (0, vitest_1.expect)(p3).rejects.toThrow("Agent disconnected");
+        });
+        (0, vitest_1.it)("rejects pending requests on socket close event", async () => {
+            await connectClient();
+            const p = client.call("pending");
+            mockSocket.emit("close");
+            await (0, vitest_1.expect)(p).rejects.toThrow("Agent disconnected: Socket closed");
+        });
+    });
+});
+//# sourceMappingURL=agent-client.test.js.map

package/dist/transport/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../src/transport/connection-manager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAWvD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,iBAAiB;IAC5B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,WAAW,CAA+C;IAClE,OAAO,CAAC,iBAAiB,CAAK;gBAElB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQ9D;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,gBAAgB,CAAC;IA0B7C;;OAEG;IACH,SAAS,IAAI,gBAAgB;IAS7B;;OAEG;IACH,QAAQ,IAAI,IAAI;IAUhB,iDAAiD;YACnC,eAAe;IAS7B,qEAAqE;IACrE,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,KAAK;CAGd"}

package/dist/transport/connection-manager.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Connection Manager - Maintains ADB and agent connections with health checks
+ * and automatic reconnection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionManager = void 0;
+const adb_client_js_1 = require("./adb-client.js");
+const agent_client_js_1 = require("./agent-client.js");
+const ui_tree_cache_js_1 = require("../util/ui-tree-cache.js");
+/** How often to run health checks (ms). */
+const HEALTH_CHECK_INTERVAL_MS = 30_000;
+/** Delay before attempting agent reconnection (ms). */
+const RECONNECT_DELAY_MS = 5_000;
+/** Maximum consecutive agent reconnect failures before backing off. */
+const MAX_RECONNECT_ATTEMPTS = 3;
+class ConnectionManager {
+    adb;
+    agent;
+    uiCache;
+    agentPort;
+    device;
+    healthTimer = null;
+    reconnectAttempts = 0;
+    constructor(adbPath, device, agentPort) {
+        this.device = device;
+        this.agentPort = agentPort;
+        this.adb = new adb_client_js_1.AdbClient(adbPath, device);
+        this.agent = new agent_client_js_1.AgentClient("127.0.0.1", agentPort);
+        this.uiCache = new ui_tree_cache_js_1.UiTreeCache();
+    }
+    /**
+     * Initialize connections: verify ADB, set up port forwarding, attempt agent connection.
+     * ADB must succeed; agent connection is best-effort (Phase 2 feature).
+     */
+    async initialize() {
+        // ADB is required
+        const adbOk = await this.adb.isConnected();
+        if (!adbOk) {
+            throw new Error(`Device ${this.device} not reachable via ADB. ` +
+                `Ensure the emulator/device is running and 'adb devices' lists it.`);
+        }
+        // Forward the agent port (best-effort)
+        try {
+            await this.adb.forward(this.agentPort, this.agentPort);
+        }
+        catch {
+            // Port forwarding may fail if agent isn't installed yet - that's fine
+        }
+        // Try connecting to the on-device agent (optional for Phase 1)
+        await this.tryConnectAgent();
+        // Start periodic health checks
+        this.startHealthChecks();
+        return this.getStatus();
+    }
+    /**
+     * Get current connection status.
+     */
+    getStatus() {
+        return {
+            adb: this.adb.isDeviceConnected,
+            agent: this.agent.isConnected(),
+            device: this.device,
+            agentPort: this.agentPort,
+        };
+    }
+    /**
+     * Cleanly shut down connections and timers.
+     */
+    shutdown() {
+        if (this.healthTimer) {
+            clearInterval(this.healthTimer);
+            this.healthTimer = null;
+        }
+        this.agent.disconnect();
+    }
+    // --- Private helpers ---
+    /** Attempt agent connection without throwing. */
+    async tryConnectAgent() {
+        try {
+            await this.agent.connect();
+            this.reconnectAttempts = 0;
+        }
+        catch {
+            // Agent not available - Phase 1 operates without it
+        }
+    }
+    /** Periodic health check: verify ADB, reconnect agent if dropped. */
+    startHealthChecks() {
+        this.healthTimer = setInterval(async () => {
+            // Check ADB
+            try {
+                await this.adb.isConnected();
+            }
+            catch {
+                // ADB went away - not much we can do automatically
+            }
+            // Reset reconnect counter if agent is healthy
+            if (this.agent.isConnected()) {
+                this.reconnectAttempts = 0;
+            }
+            // Reconnect agent if it dropped
+            if (!this.agent.isConnected() && this.reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+                this.reconnectAttempts++;
+                await this.sleep(RECONNECT_DELAY_MS);
+                await this.tryConnectAgent();
+            }
+        }, HEALTH_CHECK_INTERVAL_MS);
+        // Don't keep the process alive just for health checks
+        if (this.healthTimer.unref) {
+            this.healthTimer.unref();
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.ConnectionManager = ConnectionManager;
+//# sourceMappingURL=connection-manager.js.map

package/dist/util/logcat-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logcat-parser.d.ts","sourceRoot":"","sources":["../../src/util/logcat-parser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,8CAA8C;AAC9C,MAAM,MAAM,QAAQ,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAEzD,oCAAoC;AACpC,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAgBD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAsBnD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAGjF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAGxE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CAG7E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAEnD"}

package/dist/util/logcat-parser.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Logcat Parser - Parses Android logcat output into structured entries.
+ *
+ * Supports the "threadtime" format which is the default for `adb logcat -v threadtime`.
+ * Format: "MM-DD HH:MM:SS.mmm  PID  TID LEVEL TAG: MESSAGE"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLogcat = parseLogcat;
+exports.filterByLevel = filterByLevel;
+exports.filterByTag = filterByTag;
+exports.filterByGrep = filterByGrep;
+exports.formatEntry = formatEntry;
+/** Regex for threadtime logcat format. */
+const THREADTIME_RE = /^(\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d{3})\s+(\d+)\s+(\d+)\s+([VDIWEF])\s+(.+?):\s+(.*)$/;
+/** Level priorities for filtering. */
+const LEVEL_PRIORITY = {
+    V: 0,
+    D: 1,
+    I: 2,
+    W: 3,
+    E: 4,
+    F: 5,
+};
+/**
+ * Parse raw logcat output into structured entries.
+ *
+ * @param raw - Raw logcat text (threadtime format).
+ * @returns Array of parsed log entries.
+ */
+function parseLogcat(raw) {
+    const lines = raw.split("\n");
+    const entries = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("-----"))
+            continue;
+        const match = trimmed.match(THREADTIME_RE);
+        if (match) {
+            entries.push({
+                timestamp: match[1],
+                pid: match[2],
+                tid: match[3],
+                level: match[4],
+                tag: match[5].trim(),
+                message: match[6],
+            });
+        }
+    }
+    return entries;
+}
+/**
+ * Filter log entries by minimum level.
+ */
+function filterByLevel(entries, minLevel) {
+    const minPriority = LEVEL_PRIORITY[minLevel];
+    return entries.filter((e) => LEVEL_PRIORITY[e.level] >= minPriority);
+}
+/**
+ * Filter log entries by tag (case-insensitive substring match).
+ */
+function filterByTag(entries, tag) {
+    const lower = tag.toLowerCase();
+    return entries.filter((e) => e.tag.toLowerCase().includes(lower));
+}
+/**
+ * Filter log entries by grep pattern (applied to message, case-insensitive).
+ */
+function filterByGrep(entries, pattern) {
+    const re = new RegExp(pattern, "i");
+    return entries.filter((e) => re.test(e.message) || re.test(e.tag));
+}
+/**
+ * Format a log entry back to a human-readable string.
+ */
+function formatEntry(entry) {
+    return `${entry.timestamp} ${entry.pid} ${entry.tid} ${entry.level} ${entry.tag}: ${entry.message}`;
+}
+//# sourceMappingURL=logcat-parser.js.map

package/dist/util/safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety.d.ts","sourceRoot":"","sources":["../../src/util/safety.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAuDH,oCAAoC;AACpC,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,CAkCnE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CA+BxD"}

package/dist/util/safety.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Safety - ADB command allowlist validation.
+ *
+ * Restricts which ADB commands can be executed through the `run_adb` tool
+ * to prevent destructive or dangerous operations on the device.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAdbCommand = validateAdbCommand;
+exports.parseCommandString = parseCommandString;
+/**
+ * Allowed top-level ADB commands.
+ * These are the first argument after `adb -s <device>`.
+ */
+const ALLOWED_ADB_COMMANDS = new Set([
+    "shell",
+    "pull",
+    "push",
+    "install",
+    "uninstall",
+    "logcat",
+    "bugreport",
+    "devices",
+    "get-state",
+    "get-serialno",
+    "forward",
+    "reverse",
+    "version",
+]);
+/**
+ * Blocked shell sub-commands or patterns that could be destructive.
+ */
+const BLOCKED_SHELL_PATTERNS = [
+    /^rm\s+-rf?\s+\/(?!sdcard|data\/local\/tmp)/i, // rm -rf outside safe dirs
+    /\bformat\b/i,
+    /\bdd\s+if=/i,
+    /\bflash\b/i,
+    /\breboot\s+bootloader/i,
+    /\breboot\b/i,
+    /\bfastboot\b/i,
+    /\bsu\s/i,
+    /\bsu$/i,
+    /\bmkfs\b/i,
+    /\bwipe\b/i,
+    /[;&|`]/, // Block shell chaining operators (;, &, |, backtick)
+    /\$\(/, // Block command substitution $()
+];
+/**
+ * Blocked top-level ADB commands.
+ */
+const BLOCKED_ADB_COMMANDS = new Set([
+    "root",
+    "remount",
+    "reboot-bootloader",
+    "sideload",
+    "restore",
+    "disable-verity",
+    "enable-verity",
+    "keygen",
+]);
+/**
+ * Validate whether an ADB command is safe to execute.
+ *
+ * @param args - The ADB command arguments (after `adb -s <device>`).
+ * @returns Validation result with allowed flag and optional denial reason.
+ */
+function validateAdbCommand(args) {
+    if (args.length === 0) {
+        return { allowed: false, reason: "Empty command" };
+    }
+    const command = args[0].toLowerCase();
+    // Check against blocked commands
+    if (BLOCKED_ADB_COMMANDS.has(command)) {
+        return { allowed: false, reason: `Command '${command}' is blocked for safety` };
+    }
+    // Check against allowlist
+    if (!ALLOWED_ADB_COMMANDS.has(command)) {
+        return {
+            allowed: false,
+            reason: `Command '${command}' is not in the allowlist. Allowed: ${[...ALLOWED_ADB_COMMANDS].join(", ")}`,
+        };
+    }
+    // Extra validation for shell commands
+    if (command === "shell" && args.length > 1) {
+        const shellCmd = args.slice(1).join(" ");
+        for (const pattern of BLOCKED_SHELL_PATTERNS) {
+            if (pattern.test(shellCmd)) {
+                return {
+                    allowed: false,
+                    reason: `Shell command matches blocked pattern: ${pattern.source}`,
+                };
+            }
+        }
+    }
+    return { allowed: true };
+}
+/**
+ * Parse a command string into an argument array, respecting quotes.
+ */
+function parseCommandString(cmd) {
+    const args = [];
+    let current = "";
+    let inQuote = null;
+    for (let i = 0; i < cmd.length; i++) {
+        const ch = cmd[i];
+        if (inQuote) {
+            if (ch === inQuote) {
+                inQuote = null;
+            }
+            else {
+                current += ch;
+            }
+        }
+        else if (ch === '"' || ch === "'") {
+            inQuote = ch;
+        }
+        else if (ch === " " || ch === "\t") {
+            if (current) {
+                args.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current) {
+        args.push(current);
+    }
+    return args;
+}
+//# sourceMappingURL=safety.js.map

package/dist/util/safety.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety.test.d.ts","sourceRoot":"","sources":["../../src/util/safety.test.ts"],"names":[],"mappings":""}