@parall/parall 1.55.0 → 1.55.2

package/dist/index.bundle.mjs

@@ -51878,6 +51878,13 @@ var ENDPOINTS = {
   PROJECTS: (orgId) => `${API_BASE}/orgs/${orgId}/projects`,
   PROJECT_TASK_SUMMARY: (orgId) => `${API_BASE}/orgs/${orgId}/projects/task-summary`,
   PROJECT: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}`,
+  PROJECT_MEMBERS: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/members`,
+  PROJECT_READERS: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/readers`,
+  PROJECT_LIBRARY: (orgId) => `${API_BASE}/orgs/${orgId}/projects/library`,
+  PROJECT_JOIN: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/join`,
+  PROJECT_JOIN_REQUESTS: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/join-requests`,
+  // subject is a bare user ID or a bare team ID; both are path-segment safe.
+  PROJECT_MEMBER: (orgId, projectId, subject) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/members/${subject}`,
   // Schedules (org-scoped, platform time trigger primitive)
   SCHEDULES: (orgId) => `${API_BASE}/orgs/${orgId}/schedules`,
   SCHEDULE: (orgId, id) => `${API_BASE}/orgs/${orgId}/schedules/${id}`,
@@ -52095,6 +52102,9 @@ var ENDPOINTS = {
   ORG_EDGE_PROFILES: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles`,
   // Per-profile egress proxy (hosted Cloud Profiles; manager-only, human-only).
   ORG_EDGE_PROFILE_PROXY: (orgId, edgeId, profileName) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles/${encodeURIComponent(profileName)}/proxy`,
+  // Per-profile one-shot cookie seed (hosted Cloud Profiles; manager-only,
+  // human-only, idle-only). Injected at the next cold start, then consumed.
+  ORG_EDGE_PROFILE_COOKIES: (orgId, edgeId, profileName) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles/${encodeURIComponent(profileName)}/cookies`,
   ORG_EDGE_EXEC: (orgId) => `/api/v1/orgs/${orgId}/edge/exec`,
   // Cloud Edge live viewer command (V1b) — api-server, gated on cap:edge-viewer.
   // Same request/reply shape as the v2 browser-profile viewer, on the v3 edge
@@ -52136,6 +52146,7 @@ var WS_EVENTS = {
   PONG: "pong",
   WATCHING: "watching",
   MESSAGE_NEW: "message.new",
+  /** @deprecated `message.patch` is retired and never published; kept for compile compatibility. */
   MESSAGE_PATCH: "message.patch",
   MESSAGE_EDIT: "message.edit",
   MESSAGE_DELETE: "message.delete",
@@ -52331,6 +52342,62 @@ var ProjectTaskClient = class {
   async deleteProject(orgId, projectId) {
     return this.request("DELETE", ENDPOINTS.PROJECT(orgId, projectId));
   }
+  /** Roster with display info; readable by anyone who can read the project. */
+  async getProjectMembers(orgId, projectId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_MEMBERS(orgId, projectId));
+    return res.data;
+  }
+  /**
+   * User IDs who may read the project — the assignee-eligibility set. Every
+   * tier answers the roster expansion (direct, team-reached, org
+   * owners/admins); visibility only shapes admission, never reach.
+   */
+  async getProjectReaders(orgId, projectId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_READERS(orgId, projectId));
+    return res.data;
+  }
+  /** The join library: every discoverable project (public + restricted, plus
+   * private for org owners/admins) with the caller's admission state. */
+  async getProjectLibrary(orgId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_LIBRARY(orgId));
+    return res.data;
+  }
+  /** Public-tier self-admission: writes the caller's own member row.
+   * Other tiers answer `404 PROJECT_NOT_FOUND`; a duplicate answers
+   * `409 MEMBER_EXISTS`. */
+  async joinProject(orgId, projectId) {
+    return this.request("POST", ENDPOINTS.PROJECT_JOIN(orgId, projectId));
+  }
+  /** Restricted-tier admission petition. A pending duplicate answers
+   * `409 REQUEST_EXISTS`; membership answers `409 MEMBER_EXISTS`. */
+  async createProjectJoinRequest(orgId, projectId) {
+    return this.request("POST", ENDPOINTS.PROJECT_JOIN_REQUESTS(orgId, projectId));
+  }
+  /** Pending petitions for one project — manager standing required. */
+  async listProjectJoinRequests(orgId, projectId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_JOIN_REQUESTS(orgId, projectId));
+    return res.data;
+  }
+  /** Withdraws the caller's own pending petition. */
+  async cancelProjectJoinRequest(orgId, projectId) {
+    return this.request("DELETE", ENDPOINTS.PROJECT_JOIN_REQUESTS(orgId, projectId));
+  }
+  /**
+   * Adds one subject (user ID or team ID) to the roster. Manager-only,
+   * create-only: an existing row answers `409 MEMBER_EXISTS` — change roles
+   * through updateProjectMember instead.
+   */
+  async addProjectMember(orgId, projectId, req) {
+    return this.request("POST", ENDPOINTS.PROJECT_MEMBERS(orgId, projectId), req);
+  }
+  /** Sets one roster entry's role. Demoting the last manager answers `400 LAST_MANAGER`. */
+  async updateProjectMember(orgId, projectId, subject, req) {
+    return this.request("PATCH", ENDPOINTS.PROJECT_MEMBER(orgId, projectId, subject), req);
+  }
+  /** Removes one roster entry. Removing the last manager answers `400 LAST_MANAGER`. */
+  async removeProjectMember(orgId, projectId, subject) {
+    return this.request("DELETE", ENDPOINTS.PROJECT_MEMBER(orgId, projectId, subject));
+  }
 };
 
 // ../sdk/dist/task-label-client.js
@@ -52723,8 +52790,9 @@ var ParallClient = class _ParallClient extends TaskLabelClient {
     return this.request("POST", ENDPOINTS.TEAMS(orgId), req);
   }
   /**
-   * Renames a team. The slug cannot be changed — wiki ACL rows reference it as
-   * `@slug`, so the server answers 400 SLUG_IMMUTABLE if one is sent.
+   * Renames a team. Renaming is an ordinary edit: ACL rows reference teams by
+   * ID. Names are org-unique (case-insensitive); a duplicate answers 409
+   * NAME_TAKEN.
    */
   async updateTeam(orgId, teamId, req) {
     return this.request("PATCH", ENDPOINTS.TEAM(orgId, teamId), req);
@@ -54353,15 +54421,18 @@ var ParallClient = class _ParallClient extends TaskLabelClient {
   /**
    * Read a clip's per-org agent exec access. Org-member readable (agents
    * included, so a denied agent can learn why exec answered
-   * `CLIP_AGENT_NOT_ALLOWED`).
+   * `CLIP_AGENT_NOT_ALLOWED` / `CLIP_AGENT_CONNECTION_NOT_ALLOWED`).
    */
   async getClipAgentExecAccess(orgId, clipId) {
     return this.request("GET", ENDPOINTS.ORG_CLIP_EXEC_ACCESS(orgId, clipId));
   }
   /**
    * Replace a clip's per-org agent exec access. Human-only (agent principals
-   * get 403); under `all_agents` the `agent_ids` must be empty. Every granted
-   * id must be an active agent of this org (else `400 INVALID_INPUT`).
+   * get 403); under `all_agents` both lists must be empty; pass either
+   * `agent_ids` (legacy flat form → every agent gets `connection_scope: 'all'`)
+   * or `grants` (connection-scoped), never both. Every granted id must be an
+   * active agent of this org, and every `connection_ids` entry a connection of
+   * THIS clip in this org (else `400 INVALID_INPUT`).
    */
   async putClipAgentExecAccess(orgId, clipId, access) {
     return this.request("PUT", ENDPOINTS.ORG_CLIP_EXEC_ACCESS(orgId, clipId), access);
@@ -54447,6 +54518,41 @@ var ParallClient = class _ParallClient extends TaskLabelClient {
       headers: expectedVersion ? { "If-Match": `"proxy-${expectedVersion}"` } : void 0
     });
   }
+  /**
+   * Read a hosted Cloud Profile's one-shot cookie-seed status (manager-only:
+   * hosted human maintainer or org admin). Sanitized — cookie VALUES never come
+   * back, only `cookie_count` and the distinct target `domains`. `can_mutate` /
+   * `lease_status` are the authoritative idle gate. Typed errors: `EDGE_NOT_HOSTED`
+   * (BYOC device), `NOT_FOUND` (unknown profile).
+   */
+  async getEdgeProfileCookieSeed(orgId, edgeId, profileName) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILE_COOKIES(orgId, edgeId, profileName));
+  }
+  /**
+   * Set/replace the profile's one-shot cookie seed (the full normalized cookie
+   * array every time) — IDLE ONLY: while the profile's hosted browser is running
+   * the server answers 409 `EDGE_PROFILE_IN_USE`; close the viewer, wait for idle
+   * scale-to-zero, and retry. The next cold start injects the cookies into the
+   * profile partition and consumes the seed. Other typed errors:
+   * `EDGE_COOKIE_SEED_STALE` (409 — expectedVersion lost a tab race, sent as the
+   * `cookieseed-<version>` If-Match), `EDGE_DELETING` (409), and
+   * `SECRETBOX_UNCONFIGURED` (503 — server cannot store cookies safely).
+   */
+  async setEdgeProfileCookieSeed(orgId, edgeId, profileName, req, expectedVersion) {
+    return this.request("PUT", ENDPOINTS.ORG_EDGE_PROFILE_COOKIES(orgId, edgeId, profileName), req, void 0, false, {
+      headers: expectedVersion ? { "If-Match": `"cookieseed-${expectedVersion}"` } : void 0
+    });
+  }
+  /**
+   * Clear the pending cookie seed (does NOT sign the profile out — cookies
+   * already injected into the partition stay). Idle-only like set — 409
+   * `EDGE_PROFILE_IN_USE` while the browser is live.
+   */
+  async clearEdgeProfileCookieSeed(orgId, edgeId, profileName, expectedVersion) {
+    return this.request("DELETE", ENDPOINTS.ORG_EDGE_PROFILE_COOKIES(orgId, edgeId, profileName), void 0, void 0, false, {
+      headers: expectedVersion ? { "If-Match": `"cookieseed-${expectedVersion}"` } : void 0
+    });
+  }
   /**
    * Execute a registry clip command on an Edge device.
    *
@@ -55794,6 +55900,56 @@ async function consumeMessageWorkItem(host, item) {
   }
 }
 
+// ../agent-core/dist/dispatch-inactivity-deadline.js
+var DispatchInactivityDeadline = class {
+  timeoutMs;
+  onExpire;
+  onDispose;
+  timer = null;
+  expired = false;
+  disposed = false;
+  constructor(timeoutMs, onExpire, onDispose) {
+    this.timeoutMs = timeoutMs;
+    this.onExpire = onExpire;
+    this.onDispose = onDispose;
+  }
+  touch = () => {
+    if (this.timeoutMs <= 0 || this.expired || this.disposed)
+      return;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.expired = true;
+      this.onExpire();
+    }, this.timeoutMs);
+  };
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = null;
+    this.onDispose();
+  }
+};
+var DispatchInactivityDeadlines = class {
+  active = /* @__PURE__ */ new Map();
+  start(sessionKey, timeoutMs, onExpire) {
+    const deadline = new DispatchInactivityDeadline(timeoutMs, onExpire, () => {
+      if (this.active.get(sessionKey) === deadline)
+        this.active.delete(sessionKey);
+    });
+    this.active.set(sessionKey, deadline);
+    deadline.touch();
+    return deadline;
+  }
+  touch(sessionKey) {
+    this.active.get(sessionKey)?.touch();
+  }
+};
+
 // ../agent-core/dist/routing.js
 var MAX_CONCURRENT_FORKS = 20;
 var defaultRoutingStrategy = (event, state) => {
@@ -57355,6 +57511,7 @@ var ParallAgentGateway = class {
    * an unrelated stalled fork's lane leased forever).
    */
   sessionActiveLanes = /* @__PURE__ */ new Map();
+  dispatchInactivityDeadlines = new DispatchInactivityDeadlines();
   noteSessionLane(sessionKey, laneKey) {
     if (laneKey == null)
       this.sessionActiveLanes.delete(sessionKey);
@@ -57364,11 +57521,12 @@ var ParallAgentGateway = class {
   /**
    * External runtime-activity signal for adapters whose tool activity does
    * not flow through the RuntimeEvent stream (openclaw hooks call this from
-   * the tool-call lifecycle): renews the session's OWN active ledger lane so
-   * a long tool call cannot outlive the lease and get dethroned mid-turn.
-   * No-op without an active ledger lane for the session.
+   * the tool-call lifecycle): refreshes the dispatch inactivity deadline and
+   * renews the session's OWN active ledger lane, when present, so a long tool
+   * call cannot time out or get dethroned mid-turn.
    */
   touchRuntimeActivity(sessionKey) {
+    this.dispatchInactivityDeadlines.touch(sessionKey);
     if (this.ledgerDisabled)
       return;
     const laneKey = this.sessionActiveLanes.get(sessionKey);
@@ -57844,14 +58002,14 @@ var ParallAgentGateway = class {
         this.writeContextFile(laneContextFilePath2, contextBody);
       }
       this.inFlightDispatches++;
-      const deadlineTimer = this.DISPATCH_DEADLINE_MS > 0 ? setTimeout(() => {
-        this.opts.log?.warn(`dispatch deadline exceeded (${this.DISPATCH_DEADLINE_MS}ms) for ${event.messageId} on ${sessionKey}; aborting`);
+      const dispatchDeadline = this.dispatchInactivityDeadlines.start(sessionKey, this.DISPATCH_DEADLINE_MS, () => {
+        this.opts.log?.warn(`dispatch inactivity deadline exceeded (${this.DISPATCH_DEADLINE_MS}ms) for ${event.messageId} on ${sessionKey}; aborting`);
         try {
           this.opts.dispatchAdapter.abortDispatch?.(sessionKey);
         } catch (err) {
           this.opts.log?.warn(`abortDispatch threw for ${sessionKey}: ${String(err)}`);
         }
-      }, this.DISPATCH_DEADLINE_MS) : null;
+      });
       let binding = this.sessionBindings.get(sessionKey);
       let inputStepsCreated = false;
       let turnHandle;
@@ -57872,8 +58030,10 @@ var ParallAgentGateway = class {
           bodyForAgent,
           sessionKey,
           context: dispatchContext,
-          inputLifecycle
+          inputLifecycle,
+          noteActivity: dispatchDeadline.touch
         })) {
+          dispatchDeadline.touch();
           if (runtimeEvent.type === "runtime_session") {
             const priorAgentSessionId = binding?.agentSessionId;
             binding = await this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath, laneContextFilePath2);
@@ -58010,8 +58170,7 @@ var ParallAgentGateway = class {
         }
         throw err;
       } finally {
-        if (deadlineTimer)
-          clearTimeout(deadlineTimer);
+        dispatchDeadline.dispose();
         const metricsSnapshot = getDispatchMetrics(sessionKey);
         const durationMs = metricsSnapshot ? Date.now() - metricsSnapshot.started_at : 0;
         const effectiveOutcome = turnOutcomeEvent?.outcome ?? (dispatchError || sawErrorEvent ? "runtime_crash" : "ok");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/parall",
-  "version": "1.55.0",
+  "version": "1.55.2",
   "description": "OpenClaw channel plugin for Parall IM",
   "license": "MIT",
   "repository": {
@@ -16,8 +16,8 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.55.0",
-    "@parall/sdk": "1.55.0"
+    "@parall/agent-core": "1.55.2",
+    "@parall/sdk": "1.55.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/skills/parall-clip-authoring/SKILL.md

@@ -114,6 +114,7 @@ function parseTweets(data) { /* ... */ }
 - `tab.cookie(name)` · `tab.fetch(url, opts)` (in-browser fetch, carries the session)
 - `tab.eval(expr)` (escape hatch) · `tab.click(sel)` · `tab.fill(sel, text)` · `tab.navigate(url)`
 - `tab.waitForSelector(sel)` · `tab.getTitle()` · `tab.getURL()` · `tab.screenshot()` · `tab.close()`
+- `tab.setFileInput(sel, url, opts?)` — upload a file into an `<input type=file>`
 - `fetch` — runtime-side HTTP, does NOT go through the browser (no session)
 - `console` — logs · `args` — the invocation input
 
@@ -122,6 +123,40 @@ returns structured data; eval is the last resort. Always `tab.close()` what you
 open, and do it in a `finally` — an early return or a thrown fetch is exactly
 when the tab leaks.
 
+### Uploading a file
+
+`tab.setFileInput` takes a URL, never a path, and the runtime — not the page —
+fetches the bytes. That is what makes it work where an in-page `fetch` +
+`DataTransfer` cannot: upload targets ship a Content-Security-Policy that
+forbids the page from fetching an arbitrary file host (Instagram's `default-src`
+allows only its own domains), and you cannot change a header on their site. The
+runtime is not a page, so no CSP applies to it — and a large video never has to
+pass through the page's memory.
+
+```js
+await tab.setFileInput("input[type=file]", videoUrl, { filename: "clip.mp4" });
+await tab.click("button[type=submit]");
+await tab.waitForSelector(".upload-complete");   // ← do not skip this
+```
+
+Four rules that decide whether your clip works:
+
+1. **The URL must be fetchable with no credentials** — a public direct link or a
+   signed temporary one. The runtime sends no cookies, so a Drive or Feishu link
+   copied from the address bar will not work: those are HTML pages behind a
+   login. If the file needs a session, use a logged-in tab to obtain a signed
+   direct link first, then pass THAT here. An HTML answer is refused with
+   `EDGE_FILE_SOURCE_NOT_A_FILE` rather than uploaded as if it were a file.
+2. **Finish the upload inside the same command.** The browser reads the file when
+   the page submits, and the runtime deletes it when your command ends. Injecting
+   and returning immediately uploads nothing — wait for the site to confirm.
+3. **Main-document inputs only.** An input inside an iframe or a shadow root is
+   not addressable and returns `EDGE_FILE_SELECTOR_MISS`. If the page rebuilds
+   the input after you inject (navigation, re-render), inject again.
+4. **`opts.filename` is what the page sees**, and many sites validate by
+   extension — set it when the URL has none. `opts.timeoutMs` bounds the
+   download. One file per call; there is no multi-file form yet.
+
 ## Develop → publish → iterate
 
 Use the platform `parall clip` subcommands — they reuse the credentials you
@@ -228,18 +263,30 @@ and the folder is just a manifest:
 }
 ```
 
-- The `mcp` block takes ONLY `server_url` and `auth` (`"none" | "bearer" |
-  "api_key" | "oauth"`). Any other key is refused at publish — a credential
-  belongs to the installing org's own configuration, NEVER to the clip
-  definition.
+- The `mcp` block takes ONLY `server_url`, `auth` (`"none" | "api_key" |
+  "basic" | "oauth"`, legacy `"bearer"` accepted) and `auth_headers`. Any
+  other key is refused at publish — a credential belongs to the installing
+  org's own configuration, NEVER to the clip definition.
+- `auth` is REQUIRED at publish: you know what your server speaks, and this
+  one word decides what the install form asks for (`none` = zero input,
+  `api_key` = key field(s), `basic` = username + password, `oauth` = a
+  Connect button).
+- `api_key` delivers as a single `X-API-Key` header by default. When the
+  server wants a different shape, declare `auth_headers` (max 4 slots, one
+  admin-supplied value each): `[{"name": "Authorization", "scheme":
+  "Bearer"}]` for Bearer tokens, `[{"name": "api-key"}]` for a custom
+  header, or a pair like `[{"name": "CF-Access-Client-Id"}, {"name":
+  "CF-Access-Client-Secret"}]`. Framing/platform headers (Host, Cookie,
+  X-Prll-*, …) are refused.
 - `server_url` must be an absolute **https** URL with no embedded credentials,
   query, or fragment. It is review material, frozen with the approved version.
+  It stays OPTIONAL for self-hosted products where each org connects its own
+  instance URL.
 - Do NOT put the server in the top-level `server` / `auth` manifest keys —
   those are legacy Edge-manifest fields nothing reads. Only the `mcp` block
   declares the server.
-- Both fields are optional, but what you declare is LOCKED: the installing
-  org's config must match it, and changing the URL or auth mode means
-  republishing.
+- What you declare is LOCKED: the installing org's config must match it, and
+  changing the URL, auth mode, or header shape means republishing.
 - Entering the credential / completing OAuth is a HUMAN step in the Clip
   Console (the config-write endpoints are session-only — an API key cannot
   call them). An org can add SEVERAL connections to one MCP clip — one