quack-search 0.0.1

package/dist/index.js

@@ -0,0 +1,110 @@
+// @bun
+// src/core/runner.ts
+import { spawn } from "child_process";
+
+// src/core/binary.ts
+import { join } from "path";
+
+// src/util/path.ts
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+function resolveDirname(metaUrl) {
+  return typeof import.meta.dir === "string" ? import.meta.dir : dirname(fileURLToPath(metaUrl));
+}
+
+// src/core/binary.ts
+function resolveBinaryPath(metaUrl) {
+  const platform = process.platform;
+  const arch = process.arch;
+  let suffix;
+  if (platform === "darwin" && arch === "arm64") {
+    suffix = "darwin-arm64";
+  } else if (platform === "darwin" && arch === "x64") {
+    suffix = "darwin-x64";
+  } else if (platform === "linux" && arch === "x64") {
+    suffix = "linux-x64";
+  } else if (platform === "win32" && arch === "x64") {
+    suffix = "windows-x64.exe";
+  } else {
+    throw new Error(`unsupported platform: ${platform} ${arch}`);
+  }
+  const dir = resolveDirname(metaUrl);
+  return join(dir, "..", "bin", `quack-${suffix}`);
+}
+
+// src/core/runner.ts
+function runCore(payload, timeoutMs = 30000, metaUrl = import.meta.url) {
+  return new Promise((resolve, reject) => {
+    const binaryPath = resolveBinaryPath(metaUrl);
+    const proc = spawn(binaryPath, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = setTimeout(() => {
+      proc.kill();
+      reject(new Error("core process timed out"));
+    }, timeoutMs);
+    proc.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code !== 0) {
+        reject(new Error(stderr || "core process failed"));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout);
+      } catch {
+        reject(new Error("invalid JSON returned from core"));
+        return;
+      }
+      if (parsed.error) {
+        reject(new Error(parsed.error));
+        return;
+      }
+      if (!parsed.text) {
+        reject(new Error("empty response from core"));
+        return;
+      }
+      resolve(parsed.text);
+    });
+    proc.stdin.write(JSON.stringify(payload));
+    proc.stdin.end();
+  });
+}
+
+// src/api/search.ts
+async function search(query, options = {}) {
+  if (!query) {
+    throw new Error("query is required");
+  }
+  return runCore({
+    action: "search",
+    query,
+    maxResults: options.maxResults ?? 10
+  }, options.timeoutMs);
+}
+// src/api/fetch.ts
+async function fetchContent(url, timeoutMs) {
+  if (!url) {
+    throw new Error("url is required");
+  }
+  return runCore({
+    action: "fetch",
+    url
+  }, timeoutMs);
+}
+export {
+  search,
+  fetchContent
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "quack-search",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "bin",
+    "scripts"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,25 @@
+import { platform, arch } from "node:process";
+import { chmodSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BIN_DIR = join(__dirname, "..", "bin");
+
+function suffix() {
+  if (platform === "darwin" && arch === "arm64") return "darwin-arm64";
+  if (platform === "darwin" && arch === "x64") return "darwin-x64";
+  if (platform === "linux" && arch === "x64") return "linux-x64";
+  if (platform === "win32" && arch === "x64") return "windows-x64.exe";
+  throw new Error(`Unsupported platform: ${platform} ${arch}`);
+}
+
+const binPath = join(BIN_DIR, `quack-${suffix()}`);
+
+if (!existsSync(binPath)) {
+  console.error(`Missing binary: ${binPath}`);
+  process.exit(1);
+}
+
+chmodSync(binPath, 0o755);
+console.log(`quack binary ready: ${binPath}`);