@bob-kit/client 0.0.1

package/dist/cache.d.ts

@@ -0,0 +1,7 @@
+import type { BobQueryResult, Memory } from "@bob-kit/types";
+export declare class MemoryCache implements Memory {
+    cache: Map<any, any>;
+    get(id: string): BobQueryResult;
+    has(id: string): boolean;
+    set(id: string, value: BobQueryResult): Map<any, any>;
+}

package/dist/cache.js

@@ -0,0 +1,14 @@
+export class MemoryCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(id) {
+        return this.cache.get(id);
+    }
+    has(id) {
+        return this.cache.has(id);
+    }
+    set(id, value) {
+        return this.cache.set(id, value);
+    }
+}

package/dist/daemon.d.ts

@@ -0,0 +1,10 @@
+import type { Motor } from "@bob-kit/types";
+export declare class Daemon {
+    private process;
+    private buffer;
+    private queue;
+    constructor(driver: Motor);
+    query(message: string): Promise<string>;
+    close(): void;
+    status(): boolean;
+}

package/dist/daemon.js

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+export class Daemon {
+    constructor(driver) {
+        this.buffer = "";
+        this.queue = [];
+        const cwd = process.cwd();
+        this.process = spawn(`${cwd}/src/bob/motors/bob-windows-amd64.exe`, ["-d", driver, "--json", "--daemon"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        this.process.stdout.setEncoding("utf8");
+        this.process.stdout.on("data", (data) => {
+            this.buffer += data;
+            let endIndex;
+            while ((endIndex = this.buffer.indexOf("__END__")) !== -1) {
+                const response = this.buffer.slice(0, endIndex).trim();
+                this.buffer = this.buffer.slice(endIndex + "__END__".length);
+                if (this.queue.length) {
+                    const resolve = this.queue.shift();
+                    if (resolve)
+                        resolve(response);
+                }
+            }
+        });
+        this.process.on("exit", () => {
+            this.buffer = "";
+            this.queue = [];
+        });
+    }
+    async query(message) {
+        if (!this.process || !this.process.stdin) {
+            throw new Error("Daemon process not available.");
+        }
+        return new Promise((resolve) => {
+            this.queue.push(resolve);
+            this.process.stdin.write(`${message}\n__END__\n`);
+        });
+    }
+    close() {
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+    }
+    status() {
+        return !!this.process && !this.process.killed;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { BobQueryResult, BobResult, Driver } from "@bob-kit/types";
+type BobQueryParams = {
+    id?: string;
+    driver: Driver;
+    input: TemplateStringsArray | string;
+};
+export declare const bobQuery: ({ id, driver: { cache, driver }, input, }: BobQueryParams) => Promise<BobQueryResult>;
+export default function bob(driver: Driver): {
+    query: <A, B = any>(input: TemplateStringsArray | string, ...parameters: B[]) => Promise<BobResult<A>>;
+    cache: (id: string) => <A, B = any>(input: TemplateStringsArray | string, ...parameters: B[]) => Promise<BobResult<A>>;
+    factory: any;
+};
+export { };
+

package/dist/index.js

@@ -0,0 +1,55 @@
+import { Daemon } from "./daemon";
+let daemon;
+export const bobQuery = async ({ id, driver: { cache, driver }, input, }) => {
+    daemon = new Daemon(driver);
+    const query = typeof input === "string" ? input : input.join("?");
+    const cacheKey = id ?? query;
+    if (cache) {
+        const cached = cache.get(cacheKey);
+        if (cached)
+            return cache.get(cacheKey);
+    }
+    const jsonString = await daemon.query(query);
+    let json;
+    try {
+        json = JSON.parse(jsonString);
+    }
+    catch (err) {
+        throw new Error("Invalid JSON returned by daemon '" + err + "'");
+    }
+    if (cache) {
+        cache.set(cacheKey, json);
+    }
+    return json;
+};
+export default function bob(driver) {
+    const execute = async (input, parameters = [], id) => {
+        const { error, tables, actions } = await bobQuery({ input, driver, id });
+        if (error)
+            return { error };
+        if (tables) {
+            for (const table of tables) {
+                await driver.querier(table.trim());
+            }
+        }
+        if (actions) {
+            const result = await Promise.all(actions.map((action) => driver.querier(action, ...parameters)));
+            if (result.length === 1) {
+                return { value: (result[0].length ? result[0] : undefined) };
+            }
+            return { value: result };
+        }
+        return { value: undefined };
+    };
+    return {
+        query: (input, ...parameters) => execute(input, parameters),
+        cache: (id) => (input, ...parameters) => execute(input, parameters, id),
+        factory: new Proxy({}, {
+            get(_, id) {
+                return (input, ...parameters) => {
+                    return execute(input, parameters, id);
+                };
+            },
+        }),
+    };
+}

package/dist/install.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/install.js

@@ -0,0 +1,45 @@
+import * as fs from "fs";
+import * as path from "path";
+import { pipeline } from "stream";
+import { promisify } from "util";
+const streamPipeline = promisify(pipeline);
+function detectBobFile() {
+    const platform = process.platform; // 'win32', 'darwin', 'linux'
+    const arch = process.arch; // 'x64', 'arm64', etc.
+    let file = "";
+    if (platform === "win32") {
+        file = "bob-windows-amd64.exe";
+    }
+    else if (platform === "darwin") {
+        file = arch === "arm64" ? "bob-darwin-arm64" : "bob-darwin-amd64";
+    }
+    else if (platform === "linux") {
+        file = arch === "arm64" ? "bob-linux-arm64" : "bob-linux-amd64";
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+    return file;
+}
+async function downloadFile(url, folder, filename) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Failed to fetch ${url}: ${res.statusText}`);
+    fs.mkdirSync(folder, { recursive: true });
+    const filePath = path.join(folder, filename);
+    const nodeStream = res.body;
+    await streamPipeline(nodeStream, fs.createWriteStream(filePath));
+    console.log(`Downloaded ${filename} to ${filePath}`);
+}
+(async () => {
+    try {
+        const version = "v0.0.1"; // or dynamic
+        const fileName = detectBobFile();
+        const url = `https://github.com/bob-object-builder/bob/releases/download/${version}/${fileName}`;
+        const downloadFolder = "src/lib/motors";
+        await downloadFile(url, downloadFolder, fileName);
+    }
+    catch (err) {
+        console.error("Error:", err);
+    }
+})();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@bob-kit/client",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "description": "",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./cache": {
+      "import": "./dist/cache.js",
+      "require": "./dist/cache.js",
+      "types": "./dist/cache.d.ts"
+    },
+    "./daemon": {
+      "import": "./dist/daemon.js",
+      "require": "./dist/daemon.js",
+      "types": "./dist/daemon.d.ts"
+    },
+    "./install": {
+      "import": "./dist/install.js",
+      "require": "./dist/install.js",
+      "types": "./dist/install.d.ts"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "tsc-alias": "^1.8.16",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "@bob-kit/types": "^0.0.1"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "postinstall": "node dist/install.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}