mindwire 0.1.30 → 0.1.33

package/dist/{chunk-RN7ERVJ2.js → chunk-H2I3VRBS.js}

@@ -79,7 +79,7 @@ function computerPairingURI(invitation) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.30" ;
+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;
@@ -751,6 +918,10 @@ var WorkspaceApi = class {
   snapshot(options = {}) {
     return this.mw.http.request("GET", "/workspace", { query: options });
   }
+  /** Read the saved icon, or preview a candidate relative path within the project. Requires projectIconsVersion >= 1. */
+  projectIcon(projectId, path2) {
+    return this.mw.http.request("GET", `/workspace/projects/${encodeURIComponent(projectId)}/icon`, { query: { path: path2 } });
+  }
   /** Start an operation owned by the daemon. The same ID/payload returns the existing operation. */
   createProject(request) {
     return this.mw.http.request("POST", "/workspace/projects", { body: request });
@@ -807,7 +978,7 @@ var GitAccessApi = class {
   run(projectId, operation, auth) {
     return this.mw.http.request("POST", `/workspace/projects/${encodeURIComponent(projectId)}/git/${operation}`, { body: { auth } });
   }
-  /** Requires health.gitOperationsVersion >= 1 (>= 2 for branches, >= 4 for restore_commit). Acceptance persists before Git runs;
+  /** Requires health.gitOperationsVersion >= 1 (>= 2 for switch/create, >= 4 for restore_commit, >= 5 for rename/delete). Acceptance persists before Git runs;
    * disconnecting only detaches the client. The same ID/intent never runs twice.
    */
   start(projectId, request) {
@@ -817,7 +988,7 @@ var GitAccessApi = class {
     const result = await this.mw.http.request(
       "GET",
       `/workspace/projects/${encodeURIComponent(projectId)}/git/operations`,
-      { query: { active: activeOnly, actionsVersion: 4 } }
+      { query: { active: activeOnly, actionsVersion: 5 } }
     );
     return result.operations;
   }
@@ -1955,9 +2126,11 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
   let launchFailure;
   const waitUntilReady = async () => {
     let phase;
+    let lastState;
     for (let attempt = 0; attempt < 1200; attempt++) {
       options.signal?.throwIfAborted();
       const controller = await readJSON(path.join(directory, "computer-controller.json"));
+      lastState = controller;
       if (launchFailure) throw launchFailure;
       if (launchedPID && controller?.pid !== launchedPID) {
         await setTimeout$1(250);
@@ -1971,7 +2144,9 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
       }
       await setTimeout$1(250);
     }
-    throw new Error(`Mindwire did not finish starting. Inspect ${path.join(directory, "computer.log")}.`);
+    const lastStep = lastState?.errorCode === "dns" ? "Your DNS resolver still cannot find the tunnel address." : lastState?.error ?? phase ?? "The background service hasn't reported readiness.";
+    const recovering = lastState?.recovering && await processStateAlive(lastState).catch(() => false);
+    throw new Error(`Mindwire's connection is not ready. ${lastStep}${recovering ? " Background recovery continues." : ""} Run mindwire status for the current state, then mindwire connect to retry.`);
   };
   if (current) {
     if (Object.keys(patch).some((key) => JSON.stringify(config[key]) !== JSON.stringify(previous?.[key]))) {
@@ -2014,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-4GXF4ATR.js');
+      const { handoffController } = await import('./controller-handoff-NFDOLPJL.js');
       await handoffController(directory, controller, config, await existing.computer.info());
       controller = void 0;
     }
@@ -2048,7 +2223,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
   }
 }
 async function superviseComputer(directory) {
-  const controller = await import('./controller-DIJKMWWU.js');
+  const controller = await import('./controller-QBC6L7AT.js');
   await controller.superviseComputer(directory);
 }
 async function stopComputer(directory, force = false) {
@@ -2073,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-RN7ERVJ2.js.map
-//# sourceMappingURL=chunk-RN7ERVJ2.js.map
+//# sourceMappingURL=chunk-H2I3VRBS.js.map
+//# sourceMappingURL=chunk-H2I3VRBS.js.map