@pstdio/pocketcoder-cli 0.6.1 → 0.6.2

package/dist/index.js

@@ -5214,7 +5214,7 @@ function isYargsInstance(y) {
 var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 // package.json
-var version = "0.6.1";
+var version = "0.6.2";
 
 // src/cli-context.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
@@ -40637,6 +40637,172 @@ class PocketCoderClient {
     return this.transport.raw(path, init);
   }
 }
+// ../sdk/src/workspace-turn-resolver.ts
+var ERROR_MESSAGES = {
+  not_resumable: "workspace cannot be resumed",
+  resume_handler_missing: "workspace resume handler is not configured",
+  resume_failed: "workspace resume failed",
+  invalid_resumed_workspace: "workspace resume returned an invalid workspace",
+  readiness_failed: "resumed workspace did not become ready"
+};
+
+class WorkspaceTurnResolutionError extends Error {
+  code;
+  constructor(code, cause) {
+    super(ERROR_MESSAGES[code], cause === undefined ? undefined : { cause });
+    this.name = "WorkspaceTurnResolutionError";
+    this.code = code;
+  }
+}
+var NON_RESUMABLE_STATES = new Set([
+  "failed",
+  "canceled",
+  "expired",
+  "succeeded",
+  "terminating"
+]);
+function aborted2(signal) {
+  return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+function waitForCaller(promise2, signal) {
+  if (!signal)
+    return promise2;
+  if (signal.aborted)
+    return Promise.reject(aborted2(signal));
+  return new Promise((resolve6, reject) => {
+    const onAbort = () => reject(aborted2(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise2.then((value) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve6(value);
+    }, (error51) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(error51);
+    });
+  });
+}
+function requireRemaining(deadline, failure) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0)
+    throw new WorkspaceTurnResolutionError(failure);
+  return remaining;
+}
+
+class WorkspaceTurnResolver {
+  client;
+  resumeWorkspace;
+  resumeTimeoutMs;
+  attempts = new Map;
+  constructor(options) {
+    this.client = options.client;
+    this.resumeWorkspace = options.resumeWorkspace;
+    this.resumeTimeoutMs = options.resumeTimeoutMs ?? 300000;
+  }
+  async resolve(sourceWorkspaceId, options = {}) {
+    if (options.signal?.aborted)
+      throw aborted2(options.signal);
+    const attempt = this.attempts.get(sourceWorkspaceId) ?? this.start(sourceWorkspaceId);
+    attempt.waiters += 1;
+    try {
+      return await waitForCaller(attempt.promise, options.signal);
+    } finally {
+      attempt.waiters -= 1;
+      if (attempt.waiters === 0 && !attempt.resumeStarted && !attempt.settled) {
+        attempt.controller.abort(new DOMException("No callers remain", "AbortError"));
+      }
+    }
+  }
+  start(sourceWorkspaceId) {
+    const attempt = {
+      controller: new AbortController,
+      promise: Promise.resolve(undefined),
+      waiters: 0,
+      resumeStarted: false,
+      settled: false
+    };
+    this.attempts.set(sourceWorkspaceId, attempt);
+    attempt.promise = this.run(sourceWorkspaceId, attempt).finally(() => {
+      attempt.settled = true;
+      if (this.attempts.get(sourceWorkspaceId) === attempt) {
+        this.attempts.delete(sourceWorkspaceId);
+      }
+    });
+    attempt.promise.catch(() => {});
+    return attempt;
+  }
+  async run(sourceWorkspaceId, attempt) {
+    const deadline = Date.now() + this.resumeTimeoutMs;
+    let source = await this.client.workspaces.get(sourceWorkspaceId, {
+      signal: attempt.controller.signal
+    });
+    if (source.state === "ready")
+      return { workspace: source, resumed: false };
+    if (source.state === "preserving") {
+      source = await this.waitForPreserved(source, deadline, attempt.controller.signal);
+    }
+    this.assertResumable(source);
+    if (!this.resumeWorkspace) {
+      throw new WorkspaceTurnResolutionError("resume_handler_missing");
+    }
+    attempt.resumeStarted = true;
+    const attemptId = crypto.randomUUID();
+    let allocated;
+    try {
+      allocated = await this.resumeWorkspace({
+        source,
+        attemptId,
+        signal: attempt.controller.signal
+      });
+    } catch (error51) {
+      throw new WorkspaceTurnResolutionError("resume_failed", error51);
+    }
+    let fetched;
+    try {
+      fetched = await this.client.workspaces.get(allocated.id, {
+        signal: attempt.controller.signal
+      });
+    } catch (error51) {
+      throw new WorkspaceTurnResolutionError("invalid_resumed_workspace", error51);
+    }
+    this.assertLineage(source, fetched);
+    try {
+      const workspace = await this.client.workspaces.waitForReady(fetched, requireRemaining(deadline, "readiness_failed"), { signal: attempt.controller.signal });
+      return { workspace, resumed: true };
+    } catch (error51) {
+      if (error51 instanceof WorkspaceTurnResolutionError)
+        throw error51;
+      throw new WorkspaceTurnResolutionError("readiness_failed", error51);
+    }
+  }
+  async waitForPreserved(initial, deadline, signal) {
+    let workspace = initial;
+    while (workspace.state === "preserving") {
+      const remaining = requireRemaining(deadline, "resume_failed");
+      try {
+        const change = await this.client.workspaces.change(workspace.id, workspace.change_cursor, Math.max(1, Math.min(30, Math.ceil(remaining / 1000))), { signal });
+        workspace = change.workspace;
+      } catch (error51) {
+        if (signal.aborted)
+          throw error51;
+        throw new WorkspaceTurnResolutionError("resume_failed", error51);
+      }
+    }
+    if (workspace.state === "failed") {
+      throw new WorkspaceTurnResolutionError("resume_failed");
+    }
+    return workspace;
+  }
+  assertResumable(workspace) {
+    if (workspace.state !== "preserved" || NON_RESUMABLE_STATES.has(workspace.state) || workspace.persistence.conversation_resume.status !== "supported" || !workspace.persistence.latest_checkpoint_id) {
+      throw new WorkspaceTurnResolutionError("not_resumable");
+    }
+  }
+  assertLineage(source, resumedWorkspace) {
+    if (resumedWorkspace.id === source.id || resumedWorkspace.origin_workspace_id !== source.id || resumedWorkspace.restored_from_checkpoint_id !== source.persistence.latest_checkpoint_id) {
+      throw new WorkspaceTurnResolutionError("invalid_resumed_workspace");
+    }
+  }
+}
 // src/cli-context.ts
 var import_dotenv = __toESM(require_main(), 1);
 function need(flags, key) {
@@ -43101,9 +43267,9 @@ class FilesystemStorageDriver {
     }
   }
   async initRoots() {
-    await mkdir3(this.workspaceRoot, { recursive: true, mode: 448 });
+    await mkdir3(this.workspaceRoot, { recursive: true, mode: 457 });
     await mkdir3(this.checkpointRoot, { recursive: true, mode: 448 });
-    await chmod3(this.workspaceRoot, 448);
+    await chmod3(this.workspaceRoot, 457);
     await chmod3(this.checkpointRoot, 448);
   }
   storageRef(ref) {
@@ -43123,8 +43289,8 @@ class FilesystemStorageDriver {
   async allocate(input) {
     await this.initRoots();
     const root = childOf2(this.workspaceRoot, input.storageId);
-    await mkdir3(root, { recursive: true, mode: 448 });
-    await chmod3(root, 448);
+    await mkdir3(root, { recursive: true, mode: 457 });
+    await chmod3(root, 457);
     for (const mount of input.mounts) {
       const path = join7(root, mount.name);
       await mkdir3(path, { recursive: true, mode: 504 });

package/package.json

@@ -6,7 +6,7 @@
       "type:app"
     ]
   },
-  "version": "0.6.1",
+  "version": "0.6.2",
   "private": false,
   "description": "Operator and diagnostics CLI for PocketCoder.",
   "type": "module",