@jdscript/opencode-notify 0.0.0-stage → 0.1.0

package/dist/rpc.js

@@ -0,0 +1,60 @@
+import { Rpc } from "@opencode/plugin";
+import { z } from "zod";
+export const UUID = z
+    .string()
+    .uuid()
+    .regex(/^[0-9a-f-]{36}$/u);
+const seconds = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+export const Subscribe = z
+    .object({
+    subscriptionID: UUID,
+    revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    relayURL: z.string().url().max(2048),
+    sendToken: z.string().min(32).max(256),
+    expiresAt: seconds,
+    serverID: UUID,
+    installationID: UUID,
+    recipientPublicKey: z.string().length(87),
+    authSecret: z.string().length(22),
+    preferences: z.object({ completed: z.boolean(), requests: z.boolean(), failures: z.boolean() }).strict(),
+})
+    .strict();
+export const Reference = z.object({ subscriptionID: UUID }).strict();
+export const Route = z.object({ subscriptionID: UUID, activityID: UUID }).strict();
+export const Attach = Route.extend({
+    sessionID: z.string().startsWith("ses").max(200), expiresAt: seconds,
+    scope: z.enum(["session", "server", "workspace"]).optional(),
+    serverName: z.string().max(160).optional(),
+    seedComplete: z.boolean().optional(),
+    seeds: z.array(z.object({ sessionID: z.string().startsWith("ses").max(200), running: z.boolean(), waiting: z.array(z.string().max(200)).max(64) }).strict()).max(512).optional(),
+    shells: z.array(z.object({ id: z.string().max(200), sessionID: z.string().startsWith("ses").max(200).optional() }).strict()).max(512).optional(),
+}).strict();
+export const Status = z
+    .object({
+    subscriptionID: UUID,
+    revision: z.number().int().nonnegative(),
+    expiresAt: seconds,
+    state: z.enum(["active", "revoked", "expired", "unavailable"]),
+})
+    .strict();
+const errors = { invalid: z.object({ code: z.string() }).strict() };
+const ok = z.object({ ok: z.literal(true) }).strict();
+export const RPC_ID = "@jdscript/opencode-notify/mobile-push";
+export const Definition = Rpc.define({
+    id: RPC_ID,
+    events: {},
+    methods: {
+        info: {
+            input: z.object({}).strict(),
+            output: z
+                .object({ version: z.literal(1), encoding: z.literal("aes128gcm"), applicationVersion: z.literal(1), activityScopes: z.array(z.enum(["session", "server", "workspace"])).optional() })
+                .strict(),
+            errors,
+        },
+        subscribe: { input: Subscribe, output: Status, errors },
+        unsubscribe: { input: Reference, output: ok, errors },
+        status: { input: Reference, output: Status, errors },
+        attach: { input: Attach, output: ok, errors },
+        detach: { input: Route, output: ok, errors },
+    },
+});

package/dist/sender.d.ts

@@ -0,0 +1,73 @@
+import { Subscribe, type Attach } from "./rpc.js";
+import type { Event, SessionInfo, Storage } from "./types.js";
+export declare class SenderError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/** One process-wide sender, shared by the plugin's location registrations. */
+export declare class Sender {
+    private readonly storage;
+    private readonly getSession;
+    private readonly waitSession?;
+    private readonly subscriptions;
+    private readonly activities;
+    private readonly jobs;
+    private readonly nodes;
+    private readonly shells;
+    private readonly observedShells;
+    private readonly dirty;
+    private readonly receipts;
+    private cleanedAt;
+    private chain;
+    private timer?;
+    private flushing;
+    private stopped;
+    private workspaceKnown;
+    private quietSince?;
+    private readonly waitingForIdle;
+    private waitGeneration;
+    private readonly abort;
+    constructor(storage: Storage, getSession: (id: string) => Promise<SessionInfo>, waitSession?: ((id: string) => Promise<void>) | undefined);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    status(id: string): {
+        subscriptionID: string;
+        revision: number;
+        expiresAt: number;
+        state: "active" | "revoked" | "expired" | "unavailable";
+    };
+    subscribe(input: Subscribe): Promise<{
+        subscriptionID: string;
+        revision: number;
+        expiresAt: number;
+        state: "active" | "revoked" | "expired" | "unavailable";
+    }>;
+    unsubscribe(id: string): Promise<{
+        ok: true;
+    }>;
+    attach(input: Attach): Promise<{
+        ok: true;
+    }>;
+    detach(subscriptionID: string, activityID: string): Promise<{
+        ok: true;
+    }>;
+    /** Semantic events only: no reasoning/text deltas, transcripts, tool arguments or outputs. */
+    onEvent(event: Event): Promise<void>;
+    private node;
+    observationUnavailable(): void;
+    private root;
+    private within;
+    private content;
+    private queueAlert;
+    private watchIdle;
+    private workspaceContent;
+    private queueActivity;
+    private queue;
+    private schedule;
+    tick(): Promise<void>;
+    private requireSubscription;
+    private serial;
+    private save;
+    private removeJob;
+    private removeJobIfCurrent;
+}