mindwire 0.1.32 → 0.1.33

package/dist/{chunk-5X5PAFM7.js → chunk-H2I3VRBS.js}

@@ -79,7 +79,7 @@ function computerPairingURI(invitation) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.32" ;
+var SDK_VERSION = "0.1.33" ;
 function versionAtLeast(actual, desired) {
   if (actual === desired) return true;
   if (!actual || !/^\d+\.\d+\.\d+$/.test(actual) || !/^\d+\.\d+\.\d+$/.test(desired)) return false;
@@ -665,6 +665,171 @@ var Run = class _Run {
   }
 };
 
+// src/project-sync.ts
+var ProjectSyncError = class extends MindwireError {
+  constructor(operation) {
+    super(operation.error ?? (operation.status === "conflicts" ? "Changes conflict. Both workspace copies and their checkpoints are preserved." : `Project synchronization ${operation.status}.`));
+    this.operation = operation;
+    this.name = "ProjectSyncError";
+  }
+  operation;
+};
+var active = (o) => ["queued", "exporting", "preparing", "applying"].includes(o.status);
+var prefix = "/workspace/sync";
+function delay2(ms, signal) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const done = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    const abort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+var ProjectSyncApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  flights = /* @__PURE__ */ new Map();
+  export(request, options = {}) {
+    return this.mw.http.request("POST", `${prefix}/exports`, { body: request, ...options });
+  }
+  import(request, options = {}) {
+    return this.mw.http.request("POST", `${prefix}/imports`, { body: request, ...options });
+  }
+  async list(options = {}) {
+    const response = await this.mw.http.request("GET", `${prefix}/operations`, options);
+    return response.operations;
+  }
+  get(id, options = {}) {
+    return this.mw.http.request("GET", `${prefix}/operations/${encodeURIComponent(id)}`, options);
+  }
+  retry(id, options = {}) {
+    return this.mw.http.request("POST", `${prefix}/operations/${encodeURIComponent(id)}/retry`, options);
+  }
+  cancel(id) {
+    return this.mw.http.request("POST", `${prefix}/operations/${encodeURIComponent(id)}/cancel`);
+  }
+  checkpoint(id, options = {}) {
+    return this.mw.http.request("GET", `${prefix}/checkpoints/${encodeURIComponent(id)}`, options);
+  }
+  acceptCheckpoint(checkpoint, options = {}) {
+    return this.mw.http.request("PUT", `${prefix}/checkpoints/${encodeURIComponent(checkpoint.id)}`, { body: checkpoint, ...options });
+  }
+  objects(id, cursor = 0, options = {}) {
+    return this.mw.http.request("GET", `${prefix}/checkpoints/${encodeURIComponent(id)}/objects`, { query: { cursor }, ...options });
+  }
+  async missing(objects, options = {}) {
+    const response = await this.mw.http.request("POST", `${prefix}/objects/missing`, { body: { objects }, ...options });
+    return response.objects;
+  }
+  /** Base64 chunk, at most 256 KiB before encoding. */
+  async getObject(id, options = {}) {
+    const response = await this.mw.http.request("GET", `${prefix}/objects/${encodeURIComponent(id)}`, options);
+    return response.data;
+  }
+  async putObject(id, data, options = {}) {
+    await this.mw.http.request("PUT", `${prefix}/objects/${encodeURIComponent(id)}`, { body: { data }, ...options });
+  }
+  async wait(id, options = {}) {
+    for (; ; ) {
+      const o = await this.get(id, { signal: options.signal });
+      options.onUpdate?.(o);
+      if (!active(o)) return o;
+      await delay2(500, options.signal);
+    }
+  }
+  /** Repeating this relay skips acknowledged checkpoints and verified chunks.
+   * Aborting detaches the relay; daemon export/apply operations remain durable.
+   */
+  async relayCheckpoint(target, id, options = {}) {
+    const visited = /* @__PURE__ */ new Set();
+    const visit = async (checkpointId) => {
+      options.signal?.throwIfAborted();
+      if (visited.has(checkpointId)) return;
+      visited.add(checkpointId);
+      try {
+        await target.checkpoint(checkpointId, options);
+        return;
+      } catch (error) {
+        if (!(error instanceof ApiError) || error.status !== 404) throw error;
+      }
+      const checkpoint = await this.checkpoint(checkpointId, options);
+      for (const parent of checkpoint.parents) await visit(parent);
+      let cursor = 0;
+      do {
+        const page = await this.objects(checkpointId, cursor, options);
+        const missing = await target.missing(page.objects, options);
+        for (const object of missing) {
+          const data = await this.getObject(object, options);
+          await target.putObject(object, data, options);
+          const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+          options.onBytes?.(Math.floor(data.length * 3 / 4) - padding);
+        }
+        cursor = page.next ?? 0;
+      } while (cursor);
+      await target.acceptCheckpoint(checkpoint, options);
+    };
+    await visit(id);
+  }
+  /** Safe X → Y and Y → X. Persist request.id until acknowledged. A conflict
+   * throws ProjectSyncError carrying the complete conflict/recovery operation.
+   */
+  switchTo(target, request, options = {}) {
+    const intent = JSON.stringify(request);
+    const old = this.flights.get(request.id);
+    if (old) {
+      if (old.intent !== intent || old.target !== target) return Promise.reject(new MindwireError("This sync ID already belongs to a different request or destination."));
+      return old.result;
+    }
+    const work = async () => {
+      if (target === this || target.mw.http === this.mw.http) throw new MindwireError("Choose another workspace for this project.");
+      let accepted;
+      try {
+        accepted = await target.get(`${request.id}-import`, options);
+      } catch (error) {
+        if (!(error instanceof ApiError) || error.status !== 404) throw error;
+      }
+      if (accepted) {
+        if ((accepted.path ?? "") !== (request.path ?? "")) throw new MindwireError("This sync ID belongs to a different destination folder.");
+        const operation = await target.wait(accepted.id, {
+          signal: options.signal,
+          onUpdate: (operation2) => options.onProgress?.({ phase: "apply", transferredBytes: 0, operation: operation2 })
+        });
+        if (operation.status !== "succeeded") throw new ProjectSyncError(operation);
+        return operation;
+      }
+      const health = await Promise.all([this.mw.health(), target.mw.health()]);
+      if (health.some((h) => (h.projectSyncVersion ?? 0) < 1)) throw new MindwireError("Update Mindwire on both workspaces to switch this project.");
+      let bytes = 0;
+      const emit2 = (phase, operation) => options.onProgress?.({ phase, transferredBytes: bytes, operation });
+      emit2("checkpoint");
+      let o = await this.export({ id: `${request.id}-export`, projectId: request.projectId }, options);
+      o = await this.wait(o.id, { signal: options.signal, onUpdate: (value) => emit2("checkpoint", value) });
+      if (o.status !== "succeeded" || !o.resultCheckpointId) throw new ProjectSyncError(o);
+      emit2("transfer");
+      await this.relayCheckpoint(target, o.resultCheckpointId, { signal: options.signal, onBytes: (n) => {
+        bytes += n;
+        emit2("transfer");
+      } });
+      o = await target.import({ id: `${request.id}-import`, checkpointId: o.resultCheckpointId, path: request.path }, options);
+      o = await target.wait(o.id, { signal: options.signal, onUpdate: (value) => emit2("apply", value) });
+      if (o.status !== "succeeded") throw new ProjectSyncError(o);
+      return o;
+    };
+    const result = work().finally(() => this.flights.delete(request.id));
+    this.flights.set(request.id, { intent, target, result });
+    return result;
+  }
+};
+
 // src/workspace.ts
 var ProjectOperationsApi = class {
   constructor(mw) {
@@ -736,6 +901,7 @@ var WorkspaceCollection = class {
 var WorkspaceApi = class {
   constructor(mw) {
     this.mw = mw;
+    this.sync = new ProjectSyncApi(mw);
     this.git = new GitAccessApi(mw);
     this.operations = new ProjectOperationsApi(mw);
     this.agents = new WorkspaceCollection(mw, "agents");
@@ -743,6 +909,7 @@ var WorkspaceApi = class {
     this.chats = new WorkspaceCollection(mw, "chats");
   }
   mw;
+  sync;
   git;
   operations;
   agents;
@@ -2022,7 +2189,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
     let controller = await readJSON(path.join(directory, "computer-controller.json"));
     if (existing && controller && !compatible(controller) && await processStateAlive(controller)) {
       onProgress?.("Refreshing the background connection service\u2026");
-      const { handoffController } = await import('./controller-handoff-7S6SKFHX.js');
+      const { handoffController } = await import('./controller-handoff-NFDOLPJL.js');
       await handoffController(directory, controller, config, await existing.computer.info());
       controller = void 0;
     }
@@ -2056,7 +2223,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
   }
 }
 async function superviseComputer(directory) {
-  const controller = await import('./controller-CHJ5MMZS.js');
+  const controller = await import('./controller-QBC6L7AT.js');
   await controller.superviseComputer(directory);
 }
 async function stopComputer(directory, force = false) {
@@ -2081,5 +2248,5 @@ async function stopComputer(directory, force = false) {
 }
 
 export { CONTROLLER_PROTOCOL, SDK_VERSION, acquireProcessLock, adoptProcess, computerClient, computerPairingQRData, computerPairingURI, currentProcessIdentity, defaultStateDirectory, directRoutes, ensureComputer, ensureDaemonBinary, ownChild, processIdentity, processStateAlive, readJSON, stopComputer, superviseComputer, writeJSON };
-//# sourceMappingURL=chunk-5X5PAFM7.js.map
-//# sourceMappingURL=chunk-5X5PAFM7.js.map
+//# sourceMappingURL=chunk-H2I3VRBS.js.map
+//# sourceMappingURL=chunk-H2I3VRBS.js.map