@parall/parall 1.46.0 → 1.48.0

package/dist/index.bundle.mjs

@@ -51482,10 +51482,17 @@ var ENDPOINTS = {
   CHANNEL_CONVERSATION_SESSION: (orgId, conversationId) => `${API_BASE}/orgs/${orgId}/channel-conversations/${conversationId}/session`,
   CHANNEL_MESSAGE: (orgId, messageId) => `${API_BASE}/orgs/${orgId}/channel-messages/${messageId}`,
   CHANNEL_PROVISIONING: (orgId) => `${API_BASE}/orgs/${orgId}/channel-provisioning`,
+  CHANNEL_SLACK_MANIFEST_LINK: (orgId) => `${API_BASE}/orgs/${orgId}/channel-provisioning/slack/manifest-link`,
   CHANNEL_PROVISIONING_SESSION: (orgId, sessionId) => `${API_BASE}/orgs/${orgId}/channel-provisioning/${sessionId}`,
   CHANNEL_PROVISIONING_CANCEL: (orgId, sessionId) => `${API_BASE}/orgs/${orgId}/channel-provisioning/${sessionId}/cancel`,
   // Tier-B platform verb (agent-only): send one message as the bound bot.
   CHANNEL_SEND: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me/channel-send`,
+  // Tier-B read verbs (agent-only): workspace visibility as the bot sees it.
+  SLACK_CHANNELS: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me/slack/channels`,
+  SLACK_USERS: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me/slack/users`,
+  SLACK_HISTORY: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me/slack/history`,
+  SLACK_MEMBERS: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me/slack/members`,
+  SLACK_STATUS: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me/slack/status`,
   // Invitations (org-scoped, admin)
   ORG_INVITATIONS: (orgId) => `${API_BASE}/orgs/${orgId}/invitations`,
   ORG_INVITATION: (orgId, invId) => `${API_BASE}/orgs/${orgId}/invitations/${invId}`,
@@ -51580,6 +51587,7 @@ var ENDPOINTS = {
   ORG_UNREAD: (orgId) => `${API_BASE}/orgs/${orgId}/unread`,
   CHAT_READ: (orgId, chatId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/read`,
   THREAD_UNREAD: (orgId, chatId, threadRootId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/threads/${threadRootId}/unread`,
+  THREAD_READ: (orgId, chatId, threadRootId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/threads/${threadRootId}/read`,
   // References (org-scoped)
   REFS_RESOLVE: (orgId) => `${API_BASE}/orgs/${orgId}/refs/resolve`,
   REFS_BACKLINKS: (orgId) => `${API_BASE}/orgs/${orgId}/refs/backlinks`,
@@ -51641,10 +51649,17 @@ var ENDPOINTS = {
   ORG_EDGE: (orgId) => `/api/v1/orgs/${orgId}/edge`,
   ORG_EDGE_DEVICES: (orgId) => `/api/v1/orgs/${orgId}/edge/devices`,
   ORG_EDGE_DEVICE: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}`,
+  ORG_EDGE_DEVICE_UNREGISTER: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/unregister`,
   ORG_EDGE_ONBOARDING: (orgId) => `/api/v1/orgs/${orgId}/edge/onboarding`,
   ORG_EDGE_PROFILES: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles`,
+  ORG_EDGE_EXEC: (orgId) => `/api/v1/orgs/${orgId}/edge/exec`,
   CLIP_CONNECTIONS: (orgId, clipId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/connections`,
-  CLIP_CONNECTION: (orgId, connId) => `/api/v1/orgs/${orgId}/clip-connections/${connId}`
+  CLIP_CONNECTION: (orgId, connId) => `/api/v1/orgs/${orgId}/clip-connections/${connId}`,
+  // Clip registry (v3, org-scoped, served by api-server — `crg_` entries; the
+  // Pinix Hub catalog proxy above is a different, id-less surface)
+  ORG_CLIP_REGISTRY: (orgId) => `/api/v1/orgs/${orgId}/clip-registry`,
+  ORG_CLIP_INSTALL: (orgId) => `/api/v1/orgs/${orgId}/clips/install`,
+  ORG_CLIPS_INSTALLED: (orgId) => `/api/v1/orgs/${orgId}/clips/installed`
 };
 var WS_EVENTS = {
   // Client -> Server
@@ -52670,10 +52685,16 @@ var ParallClient = class _ParallClient {
   async resizeMachine(orgId, machineId, spec) {
     return this.request("PATCH", ENDPOINTS.MACHINE_SPEC(orgId, machineId), spec);
   }
-  /** Signal a local daemon-mode Machine to check for and apply an update. */
+  /** @deprecated Retired server-side (daemon-control-authorization §4.2):
+   *  daemons update autonomously (CDN poll + platform release signal). The
+   *  endpoint now answers 409 LOCAL_UPDATE_NOT_SUPPORTED unconditionally. */
   async requestMachineUpdate(orgId, machineId, mandatory = false) {
     await this.request("POST", ENDPOINTS.MACHINE_REQUEST_UPDATE(orgId, machineId), { mandatory });
   }
+  /** @deprecated Retired server-side (daemon-control-authorization §4.2):
+   *  remote filesystem browse of a member's machine was remote device access.
+   *  The endpoint now answers 409 LOCAL_BROWSE_NOT_SUPPORTED unconditionally;
+   *  workspace paths are typed in (or picked on the machine's own Desktop). */
   async browseMachineFilesystem(orgId, machineId, path9) {
     return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path9 }, void 0, false, { timeoutMs: 15e3 });
   }
@@ -52698,6 +52719,14 @@ var ParallClient = class _ParallClient {
   async getThreadUnread(orgId, chatId, threadRootId) {
     return this.request("GET", ENDPOINTS.THREAD_UNREAD(orgId, chatId, threadRootId));
   }
+  /** Advance the per-thread read cursor (forward-only). The server auto-clears
+   *  thread-scoped inbox items (thread_reply + in-thread mentions) the cursor
+   *  now covers. */
+  async markThreadRead(orgId, chatId, threadRootId, messageId) {
+    return this.request("POST", ENDPOINTS.THREAD_READ(orgId, chatId, threadRootId), {
+      message_id: messageId
+    });
+  }
   // ---- Inbox ----
   async getInbox(orgId, params) {
     return this.request("GET", ENDPOINTS.INBOX(orgId), void 0, params);
@@ -52721,9 +52750,12 @@ var ParallClient = class _ParallClient {
   async archiveAllInbox(orgId) {
     return this.request("POST", ENDPOINTS.INBOX_ARCHIVE_ALL(orgId));
   }
-  /** Mark an inbox item as read by its source (source_type + source_id) rather than inbox item ID. */
-  async ackInbox(orgId, source) {
-    return this.request("POST", ENDPOINTS.INBOX_ACK(orgId), source);
+  /** Mark inbox items as read by their source (source_type + source_id) or by
+   *  group_key, rather than by inbox item ID. The group_key form clears a whole
+   *  group at once (e.g. `task:{taskId}` — task_assign/task_update/task_comment
+   *  share it), used by the task detail view's auto-ack on open. */
+  async ackInbox(orgId, target) {
+    return this.request("POST", ENDPOINTS.INBOX_ACK(orgId), target);
   }
   async deleteInboxItem(orgId, id) {
     return this.request("DELETE", ENDPOINTS.INBOX_ITEM(orgId, id));
@@ -53005,6 +53037,15 @@ var ParallClient = class _ParallClient {
   async initiateChannelProvisioning(orgId, input) {
     return this.request("POST", ENDPOINTS.CHANNEL_PROVISIONING(orgId), input);
   }
+  /**
+   * Mint a pending slack connection + api.slack.com manifest-prefill link
+   * (guided manual path). Activate the returned connection_id with
+   * deliverChannelCredentials once the user brings back the bot token +
+   * signing secret.
+   */
+  async createSlackManifestLink(orgId, input) {
+    return this.request("POST", ENDPOINTS.CHANNEL_SLACK_MANIFEST_LINK(orgId), input);
+  }
   /**
    * Lazy status poll — server-side this may forward one provider poll, so
    * call it at the session's `poll_interval_seconds` cadence, not faster.
@@ -53023,6 +53064,38 @@ var ParallClient = class _ParallClient {
   async sendChannelMessage(orgId, input) {
     return this.request("POST", ENDPOINTS.CHANNEL_SEND(orgId), input);
   }
+  slackReadQuery(base, query, extra) {
+    const params = new URLSearchParams();
+    if (query?.cursor)
+      params.set("cursor", query.cursor);
+    if (query?.limit)
+      params.set("limit", String(query.limit));
+    for (const [k, v] of Object.entries(extra ?? {}))
+      params.set(k, v);
+    const qs = params.toString();
+    return qs ? `${base}?${qs}` : base;
+  }
+  /**
+   * Tier-B read verbs (agent-only): workspace visibility as the bot sees
+   * it. Same live gate as the send verb; authorization beyond it is the
+   * bot's own Slack permissions.
+   */
+  async listSlackChannels(orgId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_CHANNELS(orgId), query));
+  }
+  async listSlackUsers(orgId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_USERS(orgId), query));
+  }
+  async slackHistory(orgId, conversationId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_HISTORY(orgId), query, { conversation: conversationId }));
+  }
+  async slackMembers(orgId, conversationId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_MEMBERS(orgId), query, { conversation: conversationId }));
+  }
+  /** Set/clear the Agents-pane "typing…" indicator (best-effort cosmetic). */
+  async setSlackStatus(orgId, input) {
+    await this.request("POST", ENDPOINTS.SLACK_STATUS(orgId), input);
+  }
   async listChannelConversations(orgId, connectionId) {
     return this.request("GET", ENDPOINTS.CHANNEL_CONNECTION_CONVERSATIONS(orgId, connectionId));
   }
@@ -53527,6 +53600,31 @@ var ParallClient = class _ParallClient {
     const resp = await this.request("GET", url);
     return resp.data;
   }
+  // ---- Clip registry (v3, api-server org registry — `crg_` entries) ----
+  /**
+   * List registry clips visible to the org: its own plus public+approved
+   * cross-org entries. This is the surface `installRegistryClip` and clip
+   * connections operate on — NOT the Pinix catalog proxy
+   * ({@link listRegistryClips}), whose entries carry no `crg_` id.
+   */
+  async listOrgRegistryClips(orgId) {
+    const resp = await this.request("GET", `${ENDPOINTS.ORG_CLIP_REGISTRY(orgId)}?limit=100`);
+    return resp ?? [];
+  }
+  /**
+   * Install a registry clip into the org (a reference in `clip_installs`, not a
+   * copy). Idempotent: installing an already-installed clip returns the same
+   * `200 {ok:true}`. Fails closed with `403 CLIP_NOT_APPROVED` when the clip is
+   * not eligible (cross-org requires public + approved).
+   */
+  async installRegistryClip(orgId, clipId) {
+    return this.request("POST", ENDPOINTS.ORG_CLIP_INSTALL(orgId), { clip_id: clipId });
+  }
+  /** List the org's installed registry clips (full entries). */
+  async listInstalledRegistryClips(orgId) {
+    const resp = await this.request("GET", ENDPOINTS.ORG_CLIPS_INSTALLED(orgId));
+    return resp ?? [];
+  }
   // ---- Edge devices ----
   async listEdgeDevices(orgId) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_DEVICES(orgId));
@@ -53544,8 +53642,8 @@ var ParallClient = class _ParallClient {
     return this.request("POST", ENDPOINTS.ORG_EDGE(orgId), input);
   }
   /**
-   * Delete a hosted Cloud Profile. Hosted only — a BYOC device is removed by
-   * uninstalling Parall Clip on that machine (`400 EDGE_PLACEMENT_UNSUPPORTED`).
+   * Delete a hosted Cloud Profile. Hosted only — use {@link unregisterEdgeDevice}
+   * for an offline BYOC registration (`400 EDGE_PLACEMENT_UNSUPPORTED` here).
    *
    * Idempotent and ASYNC: returns `202` with `hosted_state: 'deleting'` on the first
    * call and on every repeat. The device stops being usable immediately (no exec, no
@@ -53555,12 +53653,68 @@ var ParallClient = class _ParallClient {
   async deleteEdgeDevice(orgId, edgeId) {
     return this.request("DELETE", ENDPOINTS.ORG_EDGE_DEVICE(orgId, edgeId));
   }
+  /**
+   * Remove the interactive human caller's own offline BYOC registration.
+   *
+   * Synchronous and idempotent: a committed removal and a repeat after removal
+   * both resolve with no response body. A live connection returns `EDGE_ONLINE`;
+   * callers must not clear local device identity until this method resolves.
+   */
+  async unregisterEdgeDevice(orgId, edgeId) {
+    await this.request("DELETE", ENDPOINTS.ORG_EDGE_DEVICE_UNREGISTER(orgId, edgeId));
+  }
   async getEdgeOnboarding(orgId) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_ONBOARDING(orgId));
   }
   async listEdgeProfiles(orgId, edgeId) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILES(orgId, edgeId));
   }
+  /**
+   * Execute a registry clip command on an Edge device.
+   *
+   * A hosted (Cloud Profile) device is reachable ONLY through an explicit
+   * `connection` (id `ccn_…` or alias) — there is no implicit route to an
+   * org-shared browser login. BYOC keeps its legacy selectors (`edge_id`, or
+   * nothing for the caller's own online device).
+   *
+   * Returns the result envelope on completion (`success` may be false when the
+   * command RAN and failed — `error`/`error_code` describe why). Everything
+   * else throws a typed {@link ApiError}; match on `err.code`:
+   *
+   * Safe to retry (guaranteed nothing was dispatched):
+   * - `EDGE_ACTIVATING` 503 + `Retry-After` — cold cloud profile is starting.
+   *   Bounded backoff, same `correlation_id` across the loop.
+   * - `EDGE_BUSY` 409 — the device is executing another request.
+   * - `EDGE_CONCURRENCY_LIMIT` 429 — org at its concurrent-session limit.
+   * - `EDGE_UNAVAILABLE` 503 — session torn down / replaced mid-dispatch.
+   *
+   * NOT retryable:
+   * - `OUTCOME_UNKNOWN` 504 — dispatched, but no result arrived. The command
+   *   MAY HAVE EXECUTED (posted, ordered, deleted…). Never retry
+   *   automatically: verify the effect first, then decide. The message carries
+   *   the request id for audit.
+   * - `EDGE_DEADLINE_EXCEEDED` 504 — arrived late, provably NOT executed.
+   * - `EDGE_HOSTED_DISABLED_FOR_ORG` 403, `EDGE_REPAIR` 503 (operator-held),
+   *   `EDGE_RUNTIME_UNAVAILABLE` 503 (deployment has no hosted runtime).
+   * - Routing errors: `HOSTED_CONNECTION_REQUIRED`, `CONNECTION_NOT_FOUND`,
+   *   `CONNECTION_CLIP_MISMATCH`, `CONNECTION_TARGET_GONE`,
+   *   `CONNECTION_PROFILE_MISMATCH`, `EDGE_DELETING`, `DEVICE_OFFLINE`.
+   */
+  async execEdgeClip(orgId, req) {
+    const t = req.timeout;
+    const serverTimeout = t !== void 0 && t > 0 && t <= 12e4 ? t : 3e4;
+    const timeoutMs = serverTimeout + 1e4;
+    try {
+      return await this.request("POST", ENDPOINTS.ORG_EDGE_EXEC(orgId), req, void 0, false, {
+        timeoutMs
+      });
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 422 && !err.code && typeof err.extras?.error_code === "string") {
+        err.code = err.extras.error_code;
+      }
+      throw err;
+    }
+  }
   // ---- Clip connections ----
   async listClipConnections(orgId, clipId) {
     return this.request("GET", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId));

package/package.json

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

package/skills/parall-clips/SKILL.md

@@ -25,6 +25,27 @@ parall clip invoke github-tools list-repos '{"org":"acme"}'
 
 Results are JSON on stdout; failures print an error.
 
+## Execute on an Edge device (registry clips)
+
+Registry clips run on an Edge — a member's desktop, or an org-shared cloud
+profile. **Name the target explicitly.** A cloud profile has NO implicit
+route; omitting the target entirely is a desktop-only legacy form that
+reaches just YOUR OWN online desktop device — never a shared cloud profile.
+
+```bash
+parall clip exec <clip> <command> [args] --connection <id|alias>  # the normal form
+parall clip exec browser-tools screenshot '{"url":"…"}' --connection cloud-main
+```
+
+- A cloud (hosted) profile is reachable ONLY via `--connection` — the clip
+  connection its maintainer bound (`ccn_…` id or alias). That binding IS your
+  authorization; without one the server answers `HOSTED_CONNECTION_REQUIRED`
+  and the fix is to ask an owner/admin to bind the clip, never to retry.
+- `--edge <edgeId>` targets only a desktop device YOU own.
+- Cold cloud profiles are handled by the CLI: it absorbs `EDGE_ACTIVATING`
+  with a bounded wait (~60s) while the profile starts. If the command still
+  fails, report the error — do not blind-retry in a loop.
+
 ## Behavior rules
 
 - An authorization error (clip not bound to you) is a fail-fast: ask the
@@ -34,6 +55,12 @@ Results are JSON on stdout; failures print an error.
 - Hosted browser activation is handled by the CLI: it waits (bounded) while a
   cold hosted browser starts, so if the invoke still fails, report the error —
   do not blind-retry in a loop.
+- **`OUTCOME_UNKNOWN` is never retryable.** It means the command was
+  dispatched and MAY HAVE EXECUTED even though no result came back. Retrying
+  could post, order or delete twice. Verify the effect through the system you
+  acted on (or tell the human, quoting the request id from the error) before
+  ever re-running. `EDGE_BUSY` is the opposite: guaranteed-unexecuted — wait
+  briefly, then one retry is safe.
 - A clip may act through a person's real logged-in account — outward,
   irreversible, or spending actions (post, order, delete, pay) get the same
   caution as any shared-state change: confirm when intent isn't explicit.