@jdscript/opencode-notify 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,210 @@
-# Temporary Holding Version
+# OpenCode encrypted mobile notifications
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An independently installable **OpenCode v2 plugin**. It observes semantic events
+inside OpenCode and sends end-to-end encrypted alerts and Live Activity updates to
+the [Rust relay](../notification-service/README.md). It uses standard plugin RPC,
+storage and event APIs; no OpenCode fork, external connector process or Apple key
+is required on the OpenCode instance.
+
+Validated with the **published, unmodified `@opencode/sdk` 2.0.26**, using normal
+`plugins` configuration and Bun 1.4.0. Earlier v2 versions have not been validated;
+the app negotiates `@jdscript/opencode-notify/mobile-push` application protocol v1 before handing over keys.
+
+## Install from this checkout
+
+```sh
+cd notification-plugin
+bun install --frozen-lockfile
+bun run build
+```
+
+Add the built plugin directory to the OpenCode server user's **global**
+`~/.config/opencode/opencode.json` (or the corresponding XDG config directory):
+
+```json
+{
+  "plugins": ["/absolute/path/to/OpenCode-iOS/notification-plugin"]
+}
+```
+
+Global configuration makes the sender available regardless of which project the
+mobile app opens. Directory-local configuration limits when the plugin loads and
+is not the intended server-wide enrollment setup. The root `index.js` supports
+OpenCode's local-directory entry discovery; build `dist/` before loading it.
+
+The package is prepared as **`@jdscript/opencode-notify`**, but this checkout does
+not publish it to npm. Once published, the equivalent global configuration is:
+
+```json
+{ "plugins": ["@jdscript/opencode-notify"] }
+```
+
+The same package can be bundled into a fork as a default plugin. That is optional;
+the implementation and RPC protocol are identical for upstream installations.
+
+## Pair and subscribe
+
+1. Deploy the relay with Apple credentials for the iOS app's signed bundle/environment.
+2. In the app's Settings → Notifications → Encrypted push, pair the relay using an
+   operator-issued one-use enrollment ticket. The app registers its APNs token.
+3. Enable a saved OpenCode server. The app negotiates the plugin, creates a distinct
+   relay subscription, and transfers its **send-only capability**, recipient public
+   key and authentication secret over its existing authenticated OpenCode connection.
+4. Ongoing work automatically gets one cross-server Live Activity. The app registers
+   independently authorized source routes for its single ActivityKit token, then
+   attaches each source with a bounded initial session/shell inventory.
+
+The iOS default gateway URL is **`https://opencode-mps-prod.jdscript.app`**. Users
+can enter their own HTTPS gateway and reset the selection with **Use default**.
+The app persists this preference, while an existing pairing stays bound to its
+original gateway. Changing a paired gateway requires unpairing and enrolling at the
+new one. `subscribe.relayURL` is taken from the **paired device credential's origin**,
+not an unsaved text-field value. The plugin sends to that origin's `/v1/push`;
+it has no hardcoded default gateway and receives no relay management credential.
+
+An editable URL does not grant APNs authority. A direct self-hosted sender needs
+Apple credentials authorized for the installed app's bundle/team. Developers signing
+their own app can use their own keys. Stock-app users cannot directly replace the
+publisher's APNs sender merely by deploying this relay. A forwarding adapter to a
+publisher-owned delivery service would be a separate integration, not present here.
+
+OpenCode needs no global identity/account at the relay. Its durable plugin storage
+contains subscription configuration and keys authorized by that device. Relay/device
+management tokens and Apple device/activity tokens never enter this plugin.
+HTTPS is required for remote relay origins; loopback HTTP is supported for local
+development. The app also requires confidential transport for its key handoff to OpenCode.
+
+## RPC contract
+
+The exported `./rpc` definition is a portable Standard Schema definition. Generic
+The RPC ID is `@jdscript/opencode-notify/mobile-push`. HTTP calls use
+`POST /api/rpc/{rpcID}/{method}`, `{ "input": ... }`, and the normal OpenCode
+authentication/location context. The entire RPC ID is **one percent-encoded path
+segment**, for example:
+
+```text
+POST /api/rpc/%40jdscript%2Fopencode-notify%2Fmobile-push/info
+```
+
+Both the OpenCode SDK and iOS client encode the parameter. Reverse proxies must
+preserve encoded slashes when forwarding it. Responses use `{ "output": ... }`.
+
+| Method | Input | Output |
+| --- | --- | --- |
+| `info` | `{}` | `{version:1, encoding:"aes128gcm", applicationVersion:1, activityScopes:["session","server","workspace"]}` |
+| `subscribe` | `subscriptionID`, positive `revision`, `relayURL`, `sendToken`, `expiresAt`, `serverID`, `installationID`, `recipientPublicKey`, `authSecret`, `preferences` | Safe subscription status |
+| `status` | `{subscriptionID}` | `{subscriptionID, revision, expiresAt, state}` |
+| `unsubscribe` | `{subscriptionID}` | `{ok:true}` |
+| `attach` | `{subscriptionID, activityID, sessionID, expiresAt, scope?, serverName?, seedComplete?, seeds?, shells?}` | `{ok:true}` |
+| `detach` | `{subscriptionID, activityID}` | `{ok:true}` |
+
+IDs are lowercase UUIDs except OpenCode's session ID. Keys use unpadded base64url:
+65-byte X9.63 P-256 public key and independent 16-byte RFC 8291 authentication
+secret. `preferences` is `{completed:boolean, requests:boolean, failures:boolean}`.
+Dates are Unix seconds; subscription expiry is at most 90 days, activity expiry at
+most eight hours. Receiver keys/binding cannot change under an existing subscription
+ID; generate a fresh subscription for a new binding. Sender credential/preferences
+changes use increasing revisions; identical current-revision retries are idempotent.
+
+Server overviews use `scope: "server"` and the binding sentinel `sessionID: "ses_workspace"`.
+Optional `seeds` contain at most 512 `{sessionID, running, waiting: requestID[]}`
+entries; `shells` contains at most 512 `{id, sessionID?}` entries. These seed current
+observations; later server events take precedence. Session routes remain supported
+for existing clients, and a route cannot change scope after attachment. Summaries
+include at most three attention-first root-session rows and an optional total count.
+An incomplete seed or restarted observer omits the exact count and does not claim completion.
+
+Unified activities use `scope: "workspace"`. Their push requests carry `event:
+"update"` and `settled: boolean`; a source must never end the shared system activity
+on its own. The gateway groups source routes using device-owner registration,
+serializes their APNs timestamps, and emits the system end only after all expected
+sources settle. The widget caches separately authenticated encrypted fragments, so
+one source does not replace another's view. This requires the gateway's advertised
+`workspace_activities` capability and migration `0003_workspace_activities.sql`.
+
+Expected RPC failures have type `invalid` and a safe `data.code`, such as
+`subscription_not_found`, `subscription_revoked`, `stale_revision`, `revision_conflict`,
+`invalid_relay_origin`, `activity_ended` or `content_too_large`. Status never returns
+keys, sender tokens, relay credentials or notification content.
+
+## Event and delivery behavior
+
+- Observes native execution/status, permission/form and shell events. No token/text
+  deltas, model calls, transcript copies, tool arguments or output are sent.
+- Primary completion/failure alerts wait for observed descendant/background work to
+  settle; permission/form requests notify promptly. Counts describe observed activity.
+- After a new load, a session without an observed execution/status is "Awaiting
+  activity", not inferred complete from a previous run's historical outcome. Existing
+  work that predates plugin activation needs subsequent events to establish live state.
+- A host's Location plugin copies share a runtime, preventing duplicate notifications
+  when multiple projects are open. Separate embedded hosts have independent state.
+- Progress changes coalesce to at most one update per five seconds; attention/end
+  wait only for a strictly newer timestamp if occurring in the same second. A tracked
+  activity gets a 30-second freshness update. Rendering a timer needs no per-second push.
+- Outbox records persist already-encrypted bodies and event UUIDs through server
+  restart. Retries reuse exact ciphertext, respect `Retry-After` and stop at content
+  expiry/12 attempts. Live updates replace superseded pending updates. No exactly-once
+  delivery guarantee is implied; the relay and receiver also deduplicate.
+- Revocation removes pending work. Already-dispatched requests can complete; central
+  relay revocation is the authority for rejecting later sends. Invalid credentials
+  pause sending until device setup is repaired. Ended route IDs cannot be reused.
+- Relay POSTs follow no redirects, have a 15-second deadline and contain only the
+  send capability, ciphertext and necessary activity lifecycle controls.
+- Billing rejection (HTTP 402) drops denied work and briefly suppresses further
+  paid updates without treating the sender credential as invalid. Authorized
+  activity ends remain possible; later activity retries can observe renewed access.
+
+The plugin caps subscriptions at 128 and pending outbox entries at 512 per host.
+Completed alert source IDs retain deduplication receipts for one day. Device subscription
+management remains in the app/relay; this plugin does not create accounts or host an
+additional network listener.
+
+## Encryption and application payload
+
+RFC 8291 `aes128gcm` is implemented using Node-compatible P-256 ECDH, HKDF-SHA256
+and AES-128-GCM. Fresh sender keys and salt are generated for each new message.
+The app's `NotificationShared/NotificationCrypto.swift` uses the same RFC record.
+Both implementations reproduce the published RFC vector byte-for-byte.
+
+Authenticated application JSON contains:
+
+```text
+version, subscriptionID, eventID, installationID, serverID,
+kind (alert | live_activity), producer (server), issuedAt, expiresAt,
+sessionID, directory, content
++ activityID, event (update | end), timestamp for Live Activities
+```
+
+`content` contains bounded `title`, `project`, `phase`, `detail`, `agents`, `shells`,
+`waiting`, optional `cost` / `startedAt`, and `updatedAt`. Freshness is at most one
+hour with 30 seconds allowed future skew. The serialized plaintext has a 2400-byte
+budget; directories are preserved exactly (max 1024 UTF-8 bytes), never truncated
+into another binding. No server URL is needed in the payload.
+
+The relay cannot decrypt this content. Lifecycle fields needed by ActivityKit
+remain visible to APNs/the relay. Ordinary NSE and encrypted Widget implementations
+are in this repository; real APNs and locked-device behavior still need signed
+hardware validation. Remote push-to-start is outside v1; activities start in the app.
+
+## Verify
+
+```sh
+bun run typecheck
+bun test
+bun run build
+python3 scripts/check-upstream.py
+# macOS + Rust/Xcode: unmodified upstream → plugin → real Rust relay → production Swift receiver
+python3 scripts/check-upstream.py --rust-relay --swift
+```
+
+The upstream check creates isolated HOME/config/data/database directories. It loads
+the built plugin through global config, creates disposable sessions/forms without
+any model prompts, tests multiple locations, restarts the host and revokes enrollment.
+The optional Rust target uses the production relay router, storage and APNs payload
+construction with captured APNs output. Swift then decrypts and validates those exact
+envelopes using the production shared receiver. No Apple credentials or existing
+OpenCode sessions are involved. The Rust capture executable is a development example,
+not a mode in the deployed relay binary.
+
+The recorded verification scope and remaining hardware checks are in
+[`VERIFICATION.md`](VERIFICATION.md).

package/VERIFICATION.md

@@ -0,0 +1,59 @@
+# Verification — initial plugin / app integration
+
+## Passed
+
+- TypeScript typecheck and distributable build.
+- Thirteen Bun tests (75 assertions), rechecked on 2026-11-01: published RFC 8291 encryption/decryption,
+  tamper/key rejection, source/device binding, persistent byte-identical retry,
+  revocation/credential revision, parent/child terminal aggregation, activity end,
+  child-session activity completion while its parent continues, relay origin validation,
+  and payment-expiry suppression with terminal cleanup.
+- `npm pack --dry-run`: publishable JS/declaration/README entrypoints only; no
+  development keys, fixtures, dependencies, databases or app data bundled.
+- Installed through ordinary `plugins` configuration on **published upstream
+  `@opencode/sdk@2.0.26` / Bun 1.4.0**, without fork changes. The test uses the
+  upstream HTTP router, plugin loader, RPC registry, storage and form event.
+- The scoped RPC ID `@jdscript/opencode-notify/mobile-push` also passed the complete
+  upstream/Rust/Swift pipeline with the SDK's encoded single-segment routing.
+- Two project Locations produce one alert each. Separate simultaneous SDK hosts
+  cannot see each other's subscription/key state. Restart restores the subscription,
+  and unsubscribe changes its state to revoked.
+- The same upstream test connected to the Rust relay's production HTTP router,
+  SQLite and APNs payload constructor. The current pass captured **six encrypted
+  envelopes**, including automatic workspace aggregation. Production Swift receiver code
+  decrypted all six and verified subscription/server/installation/session/activity
+  binding, alert replay handling and repeat Widget rendering.
+- The iOS app + Notification Service Extension + Live Activity extension compiled
+  in a signed Debug simulator build. A second build from an isolated notification-only
+  candidate also passed, establishing that prior uncommitted composer/inbox changes
+  are not build dependencies. Effective Keychain/App Group entitlements and signatures
+  were checked. Swift tests cover the `development` entitlement → `sandbox` relay
+  environment mapping.
+
+The upstream pipeline uses fresh temporary HOME/config/data/database directories,
+disposable sessions and public form creation. **Zero model prompts.** Temporary
+hosts and capture processes are closed by the driver.
+
+## Run
+
+```sh
+bun install --frozen-lockfile
+bun run build
+bun run typecheck
+bun test
+python3 scripts/check-upstream.py --rust-relay --swift
+```
+
+The final command needs Rust and Xcode's macOS Swift compiler. APNs output is captured
+by a development-only executable; the actual Apple transport is separately covered
+by the relay's HTTP/2/signature test. No Apple credentials are needed for this check.
+
+## Not established by these checks
+
+Real Apple delivery, iOS APNs token registration against a provisioned app, NSE
+invocation while locked, remote Widget rendering while suspended/terminated, and
+real device unpair/recovery fault injection remain hardware integration work.
+Device builds need matching capabilities/provisioning for all three targets.
+Installing this package does not enroll a device or configure sender credentials;
+Kiteyard performs that handoff through the authenticated server connection.
+No user's running OpenCode instance is used as a test fixture.

package/dist/crypto.d.ts

@@ -0,0 +1,8 @@
+/** RFC 8291 + RFC 8188 single-record aes128gcm. All keys stay outside the relay. */
+export declare function encrypt(plaintext: Uint8Array, publicKey: string, authSecret: string, fixture?: {
+    privateKey: Uint8Array;
+    salt: Uint8Array;
+}): string;
+/** Also used by independent interoperability fixtures; not invoked by the sender at runtime. */
+export declare function decrypt(ciphertext: string, privateKey: string, authSecret: string): Buffer<ArrayBuffer>;
+export declare function decode(value: string, length?: number): Buffer<ArrayBuffer>;

package/dist/crypto.js

@@ -0,0 +1,63 @@
+import { createCipheriv, createDecipheriv, createECDH, hkdfSync, randomBytes } from "node:crypto";
+/** RFC 8291 + RFC 8188 single-record aes128gcm. All keys stay outside the relay. */
+export function encrypt(plaintext, publicKey, authSecret, fixture) {
+    const recipient = decode(publicKey, 65);
+    const auth = decode(authSecret, 16);
+    if (recipient[0] !== 4)
+        throw new Error("invalid_recipient_key");
+    const sender = createECDH("prime256v1");
+    if (fixture)
+        sender.setPrivateKey(fixture.privateKey);
+    else
+        sender.generateKeys();
+    const pub = sender.getPublicKey();
+    const salt = fixture ? Buffer.from(fixture.salt) : randomBytes(16);
+    if (salt.length !== 16)
+        throw new Error("invalid_salt");
+    const keys = derive(sender.computeSecret(recipient), auth, recipient, pub, salt);
+    const cipher = createCipheriv("aes-128-gcm", keys.key, keys.nonce);
+    const encrypted = Buffer.concat([
+        cipher.update(Buffer.concat([plaintext, Buffer.from([2])])),
+        cipher.final(),
+        cipher.getAuthTag(),
+    ]);
+    const header = Buffer.alloc(21);
+    salt.copy(header);
+    header.writeUInt32BE(Math.max(4096, encrypted.length + 1), 16);
+    header[20] = pub.length;
+    return Buffer.concat([header, pub, encrypted]).toString("base64url");
+}
+/** Also used by independent interoperability fixtures; not invoked by the sender at runtime. */
+export function decrypt(ciphertext, privateKey, authSecret) {
+    const record = decode(ciphertext);
+    if (record.length < 103 || record.length > 4096 || record[20] !== 65 || record[21] !== 4)
+        throw new Error("invalid_record");
+    const receiver = createECDH("prime256v1");
+    receiver.setPrivateKey(decode(privateKey, 32));
+    const encrypted = record.subarray(86);
+    if (record.readUInt32BE(16) <= encrypted.length)
+        throw new Error("invalid_record_size");
+    const keys = derive(receiver.computeSecret(record.subarray(21, 86)), decode(authSecret, 16), receiver.getPublicKey(), record.subarray(21, 86), record.subarray(0, 16));
+    const decipher = createDecipheriv("aes-128-gcm", keys.key, keys.nonce);
+    decipher.setAuthTag(encrypted.subarray(-16));
+    const result = Buffer.concat([decipher.update(encrypted.subarray(0, -16)), decipher.final()]);
+    const delimiter = result.findLastIndex((byte) => byte !== 0);
+    if (delimiter < 0 || result[delimiter] !== 2)
+        throw new Error("invalid_record_delimiter");
+    return result.subarray(0, delimiter);
+}
+export function decode(value, length) {
+    if (!/^[a-zA-Z0-9_-]+$/u.test(value))
+        throw new Error("invalid_base64url");
+    const bytes = Buffer.from(value, "base64url");
+    if (bytes.toString("base64url") !== value || (length !== undefined && bytes.length !== length))
+        throw new Error("invalid_key_length");
+    return bytes;
+}
+function derive(secret, auth, receiver, sender, salt) {
+    const ikm = Buffer.from(hkdfSync("sha256", secret, auth, Buffer.concat([Buffer.from("WebPush: info\0"), receiver, sender]), 32));
+    return {
+        key: Buffer.from(hkdfSync("sha256", ikm, salt, Buffer.from("Content-Encoding: aes128gcm\0"), 16)),
+        nonce: Buffer.from(hkdfSync("sha256", ikm, salt, Buffer.from("Content-Encoding: nonce\0"), 12)),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from "@opencode/plugin";
+declare const _default: Plugin.Plugin;
+export default _default;

package/dist/index.js

@@ -0,0 +1,96 @@
+import { Plugin } from "@opencode/plugin";
+import { Definition } from "./rpc.js";
+import { Sender, SenderError } from "./sender.js";
+const registryKey = Symbol.for("@jdscript/opencode-notify/runtime/v1");
+// The host can import a fresh module copy for each Location. Module-local state alone
+// duplicates pushes. App metadata is shared within one host; distinct SDK hosts stay isolated.
+const registry = globalThis;
+const runtimes = (registry[registryKey] ??= new WeakMap());
+/** Location plugin instances share one stream consumer and sender per host. */
+function makePlugin() {
+    return Plugin.define({
+        id: "opencode.mobile-push",
+        async setup(ctx) {
+            if (typeof ctx.rpc?.register !== "function" || typeof ctx.storage?.scan !== "function") {
+                throw new Error("Mobile notifications require OpenCode v2 plugin RPC and storage APIs (tested on 2.0.26).");
+            }
+            const shared = runtimes.get(ctx.app) ?? { contexts: new Set() };
+            runtimes.set(ctx.app, shared);
+            const contexts = shared.contexts;
+            contexts.add(ctx);
+            shared.sender ??= (async () => {
+                const runtime = new Sender(ctx.storage, (sessionID) => {
+                    const current = contexts.values().next().value;
+                    if (!current)
+                        return Promise.reject(new SenderError("plugin_stopped"));
+                    return current.session.get({ sessionID });
+                }, (sessionID) => {
+                    const current = contexts.values().next().value;
+                    return current ? current.session.wait({ sessionID }) : Promise.reject(new SenderError("plugin_stopped"));
+                });
+                await runtime.start();
+                return runtime;
+            })();
+            const runtime = await shared.sender;
+            const registration = await ctx.rpc.register(Definition, {
+                info: async () => ({ version: 1, encoding: "aes128gcm", applicationVersion: 1, activityScopes: ["session", "server", "workspace"] }),
+                subscribe: async (input, context) => runtime
+                    .subscribe(input)
+                    .catch((error) => context.error("invalid", "Notification setup failed", { code: code(error) })),
+                status: async (input, context) => {
+                    try {
+                        return runtime.status(input.subscriptionID);
+                    }
+                    catch (error) {
+                        return context.error("invalid", "Notification subscription unavailable", { code: code(error) });
+                    }
+                },
+                unsubscribe: async (input, context) => runtime
+                    .unsubscribe(input.subscriptionID)
+                    .catch((error) => context.error("invalid", "Notification removal failed", { code: code(error) })),
+                attach: async (input, context) => runtime
+                    .attach(input)
+                    .catch((error) => context.error("invalid", "Activity attachment failed", { code: code(error) })),
+                detach: async (input, context) => runtime
+                    .detach(input.subscriptionID, input.activityID)
+                    .catch((error) => context.error("invalid", "Activity removal failed", { code: code(error) })),
+            });
+            const controller = new AbortController();
+            const events = (async () => {
+                for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+                    if (controller.signal.aborted)
+                        return;
+                    if (contexts.values().next().value !== ctx)
+                        continue;
+                    await runtime.onEvent(event).catch(() => {
+                        runtime.observationUnavailable();
+                        console.warn("[mobile-push] activity observation unavailable");
+                    });
+                }
+                if (!controller.signal.aborted)
+                    runtime.observationUnavailable();
+            })().catch(() => {
+                if (!controller.signal.aborted) {
+                    runtime.observationUnavailable();
+                    console.warn("[mobile-push] event stream ended");
+                }
+            });
+            return async () => {
+                controller.abort();
+                contexts.delete(ctx);
+                const stopping = contexts.size === 0 ? runtime.stop() : Promise.resolve();
+                if (contexts.size === 0)
+                    runtimes.delete(ctx.app);
+                await registration.dispose();
+                await events;
+                await stopping;
+            };
+        },
+    });
+}
+function code(error) {
+    return error instanceof Error && error.name === "MobilePushError" && "code" in error && typeof error.code === "string"
+        ? error.code
+        : "sender_unavailable";
+}
+export default makePlugin();

package/dist/rpc.d.ts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+export declare const UUID: z.ZodString;
+export declare const Subscribe: z.ZodObject<{
+    subscriptionID: z.ZodString;
+    revision: z.ZodNumber;
+    relayURL: z.ZodString;
+    sendToken: z.ZodString;
+    expiresAt: z.ZodNumber;
+    serverID: z.ZodString;
+    installationID: z.ZodString;
+    recipientPublicKey: z.ZodString;
+    authSecret: z.ZodString;
+    preferences: z.ZodObject<{
+        completed: z.ZodBoolean;
+        requests: z.ZodBoolean;
+        failures: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type Subscribe = z.infer<typeof Subscribe>;
+export declare const Reference: z.ZodObject<{
+    subscriptionID: z.ZodString;
+}, z.core.$strict>;
+export declare const Route: z.ZodObject<{
+    subscriptionID: z.ZodString;
+    activityID: z.ZodString;
+}, z.core.$strict>;
+export declare const Attach: z.ZodObject<{
+    subscriptionID: z.ZodString;
+    activityID: z.ZodString;
+    sessionID: z.ZodString;
+    expiresAt: z.ZodNumber;
+    scope: z.ZodOptional<z.ZodEnum<{
+        session: "session";
+        server: "server";
+        workspace: "workspace";
+    }>>;
+    serverName: z.ZodOptional<z.ZodString>;
+    seedComplete: z.ZodOptional<z.ZodBoolean>;
+    seeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sessionID: z.ZodString;
+        running: z.ZodBoolean;
+        waiting: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    shells: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sessionID: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type Attach = z.infer<typeof Attach>;
+export declare const Status: z.ZodObject<{
+    subscriptionID: z.ZodString;
+    revision: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+    state: z.ZodEnum<{
+        active: "active";
+        revoked: "revoked";
+        expired: "expired";
+        unavailable: "unavailable";
+    }>;
+}, z.core.$strict>;
+export declare const RPC_ID = "@jdscript/opencode-notify/mobile-push";
+export declare const Definition: {
+    readonly id: "@jdscript/opencode-notify/mobile-push";
+    readonly events: {};
+    readonly methods: {
+        readonly info: {
+            readonly input: z.ZodObject<{}, z.core.$strict>;
+            readonly output: z.ZodObject<{
+                version: z.ZodLiteral<1>;
+                encoding: z.ZodLiteral<"aes128gcm">;
+                applicationVersion: z.ZodLiteral<1>;
+                activityScopes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    session: "session";
+                    server: "server";
+                    workspace: "workspace";
+                }>>>;
+            }, z.core.$strict>;
+            readonly errors: {
+                invalid: z.ZodObject<{
+                    code: z.ZodString;
+                }, z.core.$strict>;
+            };
+        };
+        readonly subscribe: {
+            readonly input: z.ZodObject<{
+                subscriptionID: z.ZodString;
+                revision: z.ZodNumber;
+                relayURL: z.ZodString;
+                sendToken: z.ZodString;
+                expiresAt: z.ZodNumber;
+                serverID: z.ZodString;
+                installationID: z.ZodString;
+                recipientPublicKey: z.ZodString;
+                authSecret: z.ZodString;
+                preferences: z.ZodObject<{
+                    completed: z.ZodBoolean;
+                    requests: z.ZodBoolean;
+                    failures: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            readonly output: z.ZodObject<{
+                subscriptionID: z.ZodString;
+                revision: z.ZodNumber;
+                expiresAt: z.ZodNumber;
+                state: z.ZodEnum<{
+                    active: "active";
+                    revoked: "revoked";
+                    expired: "expired";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strict>;
+            readonly errors: {
+                invalid: z.ZodObject<{
+                    code: z.ZodString;
+                }, z.core.$strict>;
+            };
+        };
+        readonly unsubscribe: {
+            readonly input: z.ZodObject<{
+                subscriptionID: z.ZodString;
+            }, z.core.$strict>;
+            readonly output: z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+            readonly errors: {
+                invalid: z.ZodObject<{
+                    code: z.ZodString;
+                }, z.core.$strict>;
+            };
+        };
+        readonly status: {
+            readonly input: z.ZodObject<{
+                subscriptionID: z.ZodString;
+            }, z.core.$strict>;
+            readonly output: z.ZodObject<{
+                subscriptionID: z.ZodString;
+                revision: z.ZodNumber;
+                expiresAt: z.ZodNumber;
+                state: z.ZodEnum<{
+                    active: "active";
+                    revoked: "revoked";
+                    expired: "expired";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strict>;
+            readonly errors: {
+                invalid: z.ZodObject<{
+                    code: z.ZodString;
+                }, z.core.$strict>;
+            };
+        };
+        readonly attach: {
+            readonly input: z.ZodObject<{
+                subscriptionID: z.ZodString;
+                activityID: z.ZodString;
+                sessionID: z.ZodString;
+                expiresAt: z.ZodNumber;
+                scope: z.ZodOptional<z.ZodEnum<{
+                    session: "session";
+                    server: "server";
+                    workspace: "workspace";
+                }>>;
+                serverName: z.ZodOptional<z.ZodString>;
+                seedComplete: z.ZodOptional<z.ZodBoolean>;
+                seeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    sessionID: z.ZodString;
+                    running: z.ZodBoolean;
+                    waiting: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>>;
+                shells: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    sessionID: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            readonly output: z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+            readonly errors: {
+                invalid: z.ZodObject<{
+                    code: z.ZodString;
+                }, z.core.$strict>;
+            };
+        };
+        readonly detach: {
+            readonly input: z.ZodObject<{
+                subscriptionID: z.ZodString;
+                activityID: z.ZodString;
+            }, z.core.$strict>;
+            readonly output: z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+            readonly errors: {
+                invalid: z.ZodObject<{
+                    code: z.ZodString;
+                }, z.core.$strict>;
+            };
+        };
+    };
+};