tauri-kargo-tools 0.1.0 → 0.1.2

package/dist/api.ts

@@ -0,0 +1,218 @@
+// dist/client.ts
+import * as T from "./types";
+
+export type FetchLike = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export interface ClientOptions {
+  /** Exemple: "http://127.0.0.1:5173" ; si absent, utilise 127.0.0.1:8080 */
+  baseUrl?: string;
+  /** Port à utiliser si baseUrl est omis */
+  port?: number | string;
+  /** En-têtes par défaut à ajouter à chaque requête */
+  headers?: Record<string, string>;
+  /** fetch custom (ex. node-fetch) si l’environnement ne fournit pas fetch */
+  fetchImpl?: FetchLike;
+}
+
+export class TauriKargoClient {
+  readonly baseUrl: string;
+  readonly headers: Record<string, string>;
+  private readonly fetchImpl: FetchLike;
+
+  constructor(opts: ClientOptions = {}) {
+    const port = opts.port ?? 8080;
+    this.baseUrl = opts.baseUrl ?? (opts.port ?`http://127.0.0.1:${port}`:'');
+    this.headers = opts.headers ?? {};
+    this.fetchImpl = opts.fetchImpl ?? (globalThis.fetch?.bind(globalThis) as FetchLike);
+    if (!this.fetchImpl) throw new Error("No fetch implementation available.");
+  }
+
+  /* =============== Helpers HTTP =============== */
+
+  private  req(path: string, init: RequestInit): Promise<Response> {
+    const url = this.baseUrl + path;
+    const headers = { ...this.headers, ...(init.headers || {}) } as Record<string, string>;
+    return this.fetchImpl(url, { ...init, headers });
+  }
+
+  private async postJson<R>(path: string, body: unknown): Promise<R> {
+    const res = await this.req(path, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: body == null ? undefined : JSON.stringify(body),
+    });
+    return this.parseJsonOrThrow<R>(res);
+  }
+
+  private async parseJsonOrThrow<R>(res: Response): Promise<R> {
+    if (!res.ok) {
+      const text = await this.safeText(res);
+      throw new Error(`HTTP ${res.status} ${res.statusText}: ${text}`);
+    }
+    const ct = res.headers.get("content-type") || "";
+    if (ct.includes("application/json")) {
+      return (await res.json()) as R;
+    }
+    // Tolérance: certains endpoints peuvent répondre text/plain en erreur
+    const text = await res.text();
+    try {
+      return JSON.parse(text) as R;
+    } catch {
+      throw new Error(`Unexpected content-type: ${ct || "unknown"}; body: ${text}`);
+    }
+  }
+
+  private async safeText(res: Response): Promise<string> {
+    try { return await res.text(); } catch { return "<no-body>"; }
+  }
+
+  /* =============== Routes: Embed =============== */
+
+  /** POST /api/embed */
+  embed(body: T.EmbedReqAny): Promise<T.EmbedResp> {
+    return this.postJson<T.EmbedResp>("/api/embed", body);
+  }
+
+  /* =============== Routes: Config =============== */
+
+  /** POST /api/useConfig */
+  useConfig(body: T.UseConfigReq): Promise<T.UseConfigResp> {
+    return this.postJson<T.UseConfigResp>("/api/useConfig", body);
+  }
+
+  /** POST /api/get-config */
+  getConfig(): Promise<T.GetConfigResp> {
+    return this.postJson<T.GetConfigResp>("/api/get-config", {});
+  }
+
+  /* =============== Routes: Files =============== */
+
+  /** POST /api/current-directory */
+  setCurrentDirectory(body: T.CurrentDirReq): Promise<T.CurrentDirResp> {
+    return this.postJson<T.CurrentDirResp>("/api/current-directory", body);
+  }
+
+  /**
+   * Lire un fichier texte relatif au répertoire courant.
+   * (POST sans corps ⇒ READ ; renvoie text/plain ou octet-stream)
+   */
+  async readFileText(file: string, encoding: string = "utf-8"): Promise<string> {
+    const res = await this.req(`/api/file/${encodeURIComponent(file)}`, { method: "POST" });
+    if (!res.ok) throw new Error(`READ ${file} failed: ${res.status} ${await this.safeText(res)}`);
+    const ct = res.headers.get("content-type") || "";
+    if (ct.includes("application/octet-stream")) {
+      const buf = await res.arrayBuffer();
+      return new TextDecoder(encoding).decode(buf);
+    }
+    return res.text();
+  }
+
+  /** Lire un fichier binaire */
+  async readFileBinary(file: string): Promise<ArrayBuffer> {
+    const res = await this.req(`/api/file/${encodeURIComponent(file)}`, { method: "POST" });
+    if (!res.ok) throw new Error(`READ ${file} failed: ${res.status} ${await this.safeText(res)}`);
+    return res.arrayBuffer();
+  }
+
+  /** Écrire un fichier texte (UTF-8) */
+  async writeFileText(file: string, content: string): Promise<T.FileWriteResp> {
+    const res = await this.req(`/api/file/${encodeURIComponent(file)}`, {
+      method: "POST",
+      headers: { "content-type": "text/plain; charset=utf-8" },
+      body: content,
+    });
+    return this.parseJsonOrThrow<T.FileWriteResp>(res);
+  }
+
+  /** Écrire un fichier binaire */
+async writeFileBinary(
+  file: string,
+  data:  Blob 
+): Promise<T.FileWriteResp> {
+  // Normalise en Blob (OK WebView2/WebKit/Chromium)
+  const blob = data
+
+  const res = await fetch(`${this.baseUrl}/api/file/${encodeURIComponent(file)}`, {
+    method: "POST",
+    // Laisser fetch gérer le Content-Length; Content-Type vient du blob
+    headers: { "content-type": blob.type || "application/octet-stream" },
+    body: blob,
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => "<no-body>");
+    throw new Error(`WRITE ${file} failed: ${res.status} ${text}`);
+  }
+
+  // La route renvoie du JSON en cas d’écriture
+  const ct = res.headers.get("content-type") || "";
+  if (ct.includes("application/json")) {
+    return (await res.json()) as T.FileWriteResp;
+  }
+  // Fallback s'il répond "text/plain" avec un JSON sérialisé
+  return JSON.parse(await res.text()) as T.FileWriteResp;
+}
+
+  /** DELETE /api/file/{file} */
+  async deleteFile(file: string): Promise<T.FileDeleteResp> {
+    const res = await this.req(`/api/file/${encodeURIComponent(file)}`, { method: "DELETE" });
+    return this.parseJsonOrThrow<T.FileDeleteResp>(res);
+    // En cas d'erreur 4xx/5xx, parseJsonOrThrow lève déjà une exception
+  }
+
+  /* =============== Routes: Run (process) =============== */
+
+  /** POST /api/run */
+  run(body: T.RunReq): Promise<T.RunResp> {
+    return this.postJson<T.RunResp>("/api/run", body);
+  }
+
+  /** POST /api/run/status */
+  runStatus(body: T.ProcIdReq): Promise<T.ProcStatusResp> {
+    return this.postJson<T.ProcStatusResp>("/api/run/status", body);
+  }
+
+  /** POST /api/run/stop */
+  runStop(body: T.ProcIdReq): Promise<T.ProcStopResp> {
+    return this.postJson<T.ProcStopResp>("/api/run/stop", body);
+  }
+
+  /** POST /api/run/stopAll */
+  runStopAll(): Promise<T.StopAllResp> {
+    return this.postJson<T.StopAllResp>("/api/run/stopAll", {});
+  }
+
+  /* =============== Routes: Explorer =============== */
+
+  /** POST /api/explorer */
+  explorer(body: T.ExplorerReq): Promise<T.ExplorerResult> {
+    return this.postJson<T.ExplorerResult>("/api/explorer", body);
+  }
+
+  /* =============== Routes: Servers =============== */
+
+  /** POST /api/newServer */
+  newServer(body: T.NewServerReq): Promise<T.NewServerResp> {
+    return this.postJson<T.NewServerResp>("/api/newServer", body);
+  }
+
+  /** POST /api/stop */
+  stopServer(body: T.StopServerReq = {}): Promise<T.StopServerResp> {
+    return this.postJson<T.StopServerResp>("/api/stop", body);
+  }
+}
+
+/* =============== Petit helper factory =============== */
+export function createClient(opts?: ClientOptions) {
+  return new TauriKargoClient(opts);
+}
+
+/* =============== Exemple d'usage =============== */
+/*
+const api = createClient({ port: 5173 });
+await api.useConfig({ code: "C:/code", executable: "C:/bin" });
+const txt = await api.readFileText("README.md");
+await api.writeFileText("out.txt", "hello");
+const run = await api.run({ executableName: "mytool", arguments: ["--help"] });
+const st = await api.runStatus({ id: run.id! });
+*/

package/dist/test.ts

@@ -0,0 +1,324 @@
+// test.ts — mini runner front sans dépendances.
+// Usage:
+//   import { test } from "./test.ts";
+//   test("grammar compiles", () => { assertEquals(typeof parser.parse, "function"); });
+//   test("examples parse to expected AST", async (t) => {
+//     for (let i = 0; i < tests.length; i++) {
+//       const tc = tests[i];
+//       await t.step(`case #${i + 1}`, () => {
+//         const got = parser.parse(tc.source);
+//         assertEquals(got, tc.prog);
+//       });
+//     }
+//   });
+
+type StepFn = () => void | Promise<void>;
+type TestFn = (t: { step: (name: string, fn: StepFn) => Promise<void> }) => void | Promise<void>;
+
+function ensureRoot(): HTMLElement {
+  const id = "test-root";
+  let el = document.getElementById(id);
+  if (!el) {
+    el = document.createElement("div");
+    el.id = id;
+    el.style.cssText = "font-family: ui-sans-serif, system-ui, Arial; line-height:1.4; padding:16px;";
+    document.body.appendChild(el);
+  }
+  return el;
+}
+
+function createTestBlock(name: string): { block: HTMLElement; header: HTMLElement; list: HTMLUListElement } {
+  const root = ensureRoot();
+
+  const block = document.createElement("section");
+  block.style.cssText = "margin: 12px 0; padding: 12px; border: 1px solid #ddd; border-radius: 8px;";
+
+  const header = document.createElement("h3");
+  header.textContent = `Test: ${name}`;
+  header.style.cssText = "margin: 0 0 8px 0; font-size: 16px;";
+
+  const list = document.createElement("ul");
+  list.style.cssText = "margin: 8px 0 0 16px; padding: 0;";
+
+  block.appendChild(header);
+  block.appendChild(list);
+  root.appendChild(block);
+
+  return { block, header, list };
+}
+
+function formatError(e: unknown): string {
+  if (e instanceof Error) return e.stack || `${e.name}: ${e.message}`;
+  try { return JSON.stringify(e); } catch { return String(e); }
+}
+
+export function test(name: string, fn: TestFn): void {
+  const { block, header, list } = createTestBlock(name);
+
+  // status badge
+  const status = document.createElement("span");
+  status.textContent = "⏳ running…";
+  status.style.cssText = "margin-left: 8px; font-size: 12px; color: #555;";
+  header.appendChild(status);
+
+  // Collect step results
+  let failed = false;
+
+  const t = {
+    step: async (stepName: string, stepFn: StepFn): Promise<void> => {
+      const li = document.createElement("li");
+      li.style.cssText = "margin: 4px 0;";
+      li.textContent = `• ${stepName}: `;
+      const badge = document.createElement("span");
+      badge.style.marginLeft = "4px";
+      li.appendChild(badge);
+      list.appendChild(li);
+
+      try {
+        await stepFn();
+        badge.textContent = "✅ ok";
+        badge.style.color = "#1a7f37";
+      } catch (e) {
+        failed = true;
+        badge.textContent = "❌ fail";
+        badge.style.color = "#c62828";
+        const pre = document.createElement("pre");
+        pre.style.cssText = "white-space: pre-wrap; background:#fff5f5; border:1px solid #f0caca; padding:8px; border-radius:6px; margin:6px 0 0 0;";
+        pre.textContent = formatError(e);
+        li.appendChild(pre);
+      }
+    },
+  };
+
+  // Run test (and implicit single-step if user didn’t use t.step)
+  (async () => {
+    let usedStep = false;
+
+    // Proxy t.step to detect usage
+    const proxiedT = {
+      step: async (n: string, f: StepFn) => {
+        usedStep = true;
+        return t.step(n, f);
+      },
+    };
+
+    try {
+      const r = fn(proxiedT);
+      if (r instanceof Promise) await r;
+
+      if (!usedStep) {
+        // Wrap whole test as one step
+        await t.step("default", async () => {
+          // re-run nothing; the body has already executed
+          // but we still need to mark success
+        });
+      }
+    } catch (e) {
+      failed = true;
+      // show top-level failure as a step
+      await t.step("default", () => { throw e; }).catch(() => void 0);
+    } finally {
+      if (failed) {
+        status.textContent = "❌ failed";
+        status.style.color = "#c62828";
+        block.style.borderColor = "#f19999";
+      } else {
+        status.textContent = "✅ passed";
+        status.style.color = "#1a7f37";
+        block.style.borderColor = "#9fd3a7";
+      }
+    }
+  })();
+}
+
+
+// assert.ts
+// Usage (Deno):
+//   import { assertEquals } from "./assert.ts";
+//   Deno.test("ex", () => assertEquals(parse("..."), expected));
+
+// ————— Deep equality —————
+function isTypedArray(x: unknown): x is
+  | Int8Array | Uint8Array | Uint8ClampedArray
+  | Int16Array | Uint16Array
+  | Int32Array | Uint32Array
+  | Float32Array | Float64Array
+  | BigInt64Array | BigUint64Array {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+function sameValueZero(a: unknown, b: unknown): boolean {
+  // SameValueZero: like === but NaN equals NaN, and +0/-0 considered equal
+  return (a === b) || (Number.isNaN(a as number) && Number.isNaN(b as number));
+}
+
+function isPlainObject(x: unknown): x is Record<string, unknown> {
+  if (x === null || typeof x !== "object") return false;
+  const proto = Object.getPrototypeOf(x);
+  return proto === Object.prototype || proto === null;
+}
+
+export function deepEqual(a: unknown, b: unknown, seen = new Map<any, any>()): boolean {
+  if (sameValueZero(a, b)) return true;
+
+  // Handle null vs objects/types quickly
+  if (a === null || b === null) return false;
+
+  const ta = typeof a;
+  const tb = typeof b;
+  if (ta !== "object" && tb !== "object") return false; // two different primitives
+  if (ta !== tb) return false;
+
+  // Cycle handling
+  if (typeof a === "object" && typeof b === "object") {
+    const prev = seen.get(a);
+    if (prev && prev === b) return true;
+    seen.set(a, b);
+  }
+
+  // Dates
+  if (a instanceof Date || b instanceof Date) {
+    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+  }
+
+  // RegExp
+  if (a instanceof RegExp || b instanceof RegExp) {
+    return a instanceof RegExp && b instanceof RegExp &&
+           a.source === b.source && a.flags === b.flags;
+  }
+
+  // Typed arrays
+  if (isTypedArray(a) || isTypedArray(b)) {
+    if (!isTypedArray(a) || !isTypedArray(b)) return false;
+    if (Object.getPrototypeOf(a).constructor !== Object.getPrototypeOf(b).constructor) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!sameValueZero(a[i], b[i])) return false;
+    }
+    return true;
+  }
+
+  // Array
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i], seen)) return false;
+    }
+    return true;
+  }
+
+  // Set
+  if (a instanceof Set || b instanceof Set) {
+    if (!(a instanceof Set) || !(b instanceof Set)) return false;
+    if (a.size !== b.size) return false;
+    // Compare as multisets with deep equality
+    const used = new Array<boolean>(b.size).fill(false);
+    const bArr = Array.from(b);
+    outer: for (const av of a) {
+      for (let i = 0; i < bArr.length; i++) {
+        if (!used[i] && deepEqual(av, bArr[i], seen)) {
+          used[i] = true;
+          continue outer;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+
+  // Map
+  if (a instanceof Map || b instanceof Map) {
+    if (!(a instanceof Map) || !(b instanceof Map)) return false;
+    if (a.size !== b.size) return false;
+    // For each entry in a, find deep-equal key in b, then compare values
+    const bEntries = Array.from(b.entries());
+    const used = new Array<boolean>(bEntries.length).fill(false);
+    outerMap: for (const [ak, av] of a.entries()) {
+      for (let i = 0; i < bEntries.length; i++) {
+        if (used[i]) continue;
+        const [bk, bv] = bEntries[i];
+        if (deepEqual(ak, bk, seen) && deepEqual(av, bv, seen)) {
+          used[i] = true;
+          continue outerMap;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+
+  // Plain objects
+  if (isPlainObject(a) || isPlainObject(b)) {
+    if (!isPlainObject(a) || !isPlainObject(b)) return false;
+    const ka = Object.keys(a as Record<string, unknown>);
+    const kb = Object.keys(b as Record<string, unknown>);
+    if (ka.length !== kb.length) return false;
+    // keys order-insensitive
+    ka.sort(); kb.sort();
+    for (let i = 0; i < ka.length; i++) {
+      if (ka[i] !== kb[i]) return false;
+    }
+    for (const k of ka) {
+      if (!deepEqual((a as any)[k], (b as any)[k], seen)) return false;
+    }
+    return true;
+  }
+
+  // Fallback for objects with prototypes/functions/etc.
+  // Compare own enumerable props + constructor
+  if (typeof a === "object" && typeof b === "object") {
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+    const ka = Object.keys(a as any);
+    const kb = Object.keys(b as any);
+    if (ka.length !== kb.length) return false;
+    for (const k of ka) {
+      if (!(k in (b as any))) return false;
+      if (!deepEqual((a as any)[k], (b as any)[k], seen)) return false;
+    }
+    return true;
+  }
+
+  return false;
+}
+
+// ————— Pretty printers —————
+function safeStringify(v: unknown, maxDepth = 10): string {
+  const seen = new WeakSet<object>();
+  function helper(x: unknown, depth: number): unknown {
+    if (depth <= 0) return "[Object]";
+    if (x && typeof x === "object") {
+      if (seen.has(x as object)) return "[Circular]";
+      seen.add(x as object);
+      if (Array.isArray(x)) return (x as unknown[]).map((e) => helper(e, depth - 1));
+      if (x instanceof Map) return { __map__: Array.from(x.entries()).map(([k, val]) => [helper(k, depth - 1), helper(val, depth - 1)]) };
+      if (x instanceof Set) return { __set__: Array.from(x.values()).map((e) => helper(e, depth - 1)) };
+      if (x instanceof Date) return { __date__: (x as Date).toISOString() };
+      if (x instanceof RegExp) return { __regexp__: x.toString() };
+      if (ArrayBuffer.isView(x)) return { __typedarray__: Object.getPrototypeOf(x).constructor.name, values: Array.from(x as any) };
+      const out: Record<string, unknown> = {};
+      for (const k of Object.keys(x as Record<string, unknown>)) {
+        out[k] = helper((x as any)[k], depth - 1);
+      }
+      return out;
+    }
+    if (typeof x === "number" && Number.isNaN(x)) return "NaN";
+    if (Object.is(x, -0)) return "-0";
+    return x as any;
+  }
+  try {
+    return JSON.stringify(helper(v, maxDepth), null, 2);
+  } catch {
+    return String(v);
+  }
+}
+
+// ————— Public assert —————
+export function assertEquals(actual: unknown, expected: unknown, msg?: string): void {
+  if (deepEqual(actual, expected)) return;
+  const aStr = safeStringify(actual);
+  const eStr = safeStringify(expected);
+  const defaultMsg = `assertEquals failed:\nExpected:\n${eStr}\nActual:\n${aStr}`;
+  throw new Error(msg ? `${msg}\n${defaultMsg}` : defaultMsg);
+}
+

package/dist/types.ts

@@ -0,0 +1,178 @@
+/** OpenAPI: 3.0.3 — Tauri Static Server API — v1.0.0 */
+
+/* =========================
+   Schemas (components)
+   ========================= */
+
+export interface EmbedReqAny {
+  /** Code folder to package (required server-side) */
+  code: string | null;
+  /** Binary folder to package */
+  executable: string | null;
+  /** Path of the new executable */
+  output: string;
+}
+
+export interface EmbedResp {
+  ok: boolean;
+  message: string;
+}
+
+export interface UseConfigReq {
+  code: string;
+  executable: string;
+}
+
+export interface UseConfigResp {
+  ok: boolean;
+  message: string;
+}
+
+export interface GetConfigResp {
+  ok: boolean;
+  code: string;
+  executable: string;
+  fileBase: string;
+}
+
+export interface CurrentDirReq {
+  /** Absolute or relative path. Empty ⇒ CWD. */
+  path: string;
+}
+
+export interface CurrentDirResp {
+  ok: boolean;
+  message: string;
+  current: string;
+}
+
+export interface FileWriteResp {
+  ok: boolean;
+  message: string;
+  path: string;
+}
+
+export interface FileDeleteResp {
+  ok: boolean;
+  message: string;
+  path: string;
+}
+
+export interface RunReq {
+  executableName: string;
+  /** Either an argv array or a single command-line string */
+  arguments?: string[] | string;
+}
+
+export interface RunResp {
+  ok: boolean;
+  /** exit status code (when available) */
+  status?: number | null;
+  message: string;
+  stdout?: string;
+  stderr?: string;
+  /** internal id of started process */
+  id?: number | null;   // int64 → number
+  /** OS pid (when available) */
+  pid?: number | null;
+}
+
+export interface ProcIdReq {
+  id: number; // int64
+}
+
+export interface ProcStatusResp {
+  ok: boolean;
+  running: boolean;
+  status?: number | null;
+  pid?: number | null;
+  stdout: string;
+  stderr: string;
+  message: string;
+}
+
+export interface ProcStopResp {
+  ok: boolean;
+  message: string;
+}
+
+export interface StopAllResp {
+  ok: boolean;
+  message: string;
+}
+
+export interface ExplorerReq {
+  path?: string;
+}
+
+export type ExplorerElement = ExplorerDirectory | ExplorerFile
+
+export interface ExplorerFile {
+  type: "file";
+  path: string;
+  name: string;
+  parent: string | null;
+}
+
+export interface ExplorerDirectory {
+  type: "directory";
+  path: string;
+  parent: string | null;
+  content: ExplorerElement[];
+}
+
+export interface ExplorerError {
+  type: "error";
+  message: string;
+}
+
+export interface NewServerReq {
+  code: string;
+  executable: string;
+  /** 0..65535 (nullable) */
+  port?: number | null;
+}
+
+export interface NewServerResp {
+  ok: boolean;
+  port?: number | null;
+  message: string;
+}
+
+export interface StopServerReq {
+  /** if omitted, targets current server (parent) */
+  port?: number | null;
+}
+
+export interface StopServerResp {
+  ok: boolean;
+  port?: number | null;
+  message: string;
+}
+
+/* =========================
+   Helper union types
+   ========================= */
+
+/** Result of /api/explorer (200) */
+export type ExplorerResult = ExplorerFile | ExplorerDirectory;
+
+/** Error shapes from /api/explorer (404/500) */
+export type ExplorerErrorResult = ExplorerError;
+
+/* =========================
+   (Optionnel) Types d’IO par route
+   — utiles si tu veux typer ton client HTTP
+   ========================= */
+
+/* =========================
+   (Optionnel) Types utilitaires client
+   ========================= */
+
+export type Json =
+  | null
+  | boolean
+  | number
+  | string
+  | Json[]
+  | { [k: string]: Json };

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "tauri-kargo-tools",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+   "files": ["dist"],
+ "exports": { "./*": "./dist/*" },
+  "publishConfig": { "access": "public" },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/blockapicoder/tauriKargoTools.git"