@otonoma/paracord-panels-interface 0.17.1-rc.12

package/dist/client/pncpClient.js

@@ -0,0 +1,234 @@
+// TODO: A lot of this code is copied from the pncpRpcClient found in the main paracord source code.
+// As such, we should refactor that to make use of this code instead. We should likely move this into a more abstract location and not be
+// part of the "panels" library, but something else instead. All of this is totally generic, and it could
+// just live in the paranet-client repo instead, but then we would just need to implement it in the panels
+// library specifically (which already depends on the paranet-client repo, so that would be OK).
+import { ObservationMessageType, ObservationStartPoint, ParanetServiceClient, PncpClient, PncpMessageKind, simplifyObservationCallback, simplifyPncpCallback, Timestamp } from "@otonoma/paranet-client";
+import { AbstractPncpClient } from ".";
+export class PncpRpcClient extends AbstractPncpClient {
+    constructor(init) {
+        super(init.init);
+        this.connectionState = "disconnected";
+        this.client = new PncpClient({
+            endpoint: init.broker,
+            actorId: init.actorId,
+            // TODO: We need to simplify this process of determining the version of client actors.
+            actorVersion: init.actorVersion,
+            token: init.tokens?.access_token,
+            refreshToken: init.tokens?.refresh_token,
+        });
+        this.actorId = init.actorId;
+        this.actorVersion = init.actorVersion;
+        this.svcClient = new ParanetServiceClient({
+            actorId: init.actorId,
+            endpoint: init.service,
+        });
+        this.client.setTokenCb((token, refresh) => {
+            this.svcClient.setTokens(token, refresh);
+        });
+        if (init.tokens) {
+            this.svcClient.setTokens(init.tokens.access_token, init.tokens.refresh_token);
+        }
+        // TODO: Manage connection state, same as PncpRpcClient.
+        const listener = this.client
+            .pncpListener()
+            .onstart(() => {
+            this.connectionState = "connected";
+            // TODO: Trigger a callback here.
+            // useConnectionStore
+            //   .getState()
+            //   .setConnectionState(this.connectionState);
+            // resolve();
+        })
+            .ondisconnect(() => {
+            this.connectionState = "disconnected";
+        })
+            .onreconnect(() => {
+            this.connectionState = "connected";
+        })
+            .onmessage((msg) => {
+            const simplified = simplifyPncpCallback(msg);
+            switch (simplified.type) {
+                case "skill":
+                    {
+                        this.skillCb?.(simplified);
+                    }
+                    break;
+                case "message":
+                    {
+                        this.msgCb?.(simplified);
+                    }
+                    break;
+            }
+        })
+            .onerror((err, isFatal) => {
+            // this.error = decodeURIComponent(err);
+            this.connectionState = isFatal ? "unauthenticated" : "failed";
+            // reject(this.error);
+        })
+            .autoReconnect(true);
+        this.listener = listener;
+        this.observerState = new Map();
+    }
+    async login(creds) {
+        let tokens = await this.client.login(creds);
+        this.svcClient.setTokens(tokens.access_token, tokens.refresh_token);
+    }
+    async pncpRequest(req) {
+        let res = await this.client.pncpRequest(req);
+        const date = res.timeCreated && Timestamp.toDate(res.timeCreated);
+        return {
+            type: "response",
+            messageId: res.messageId,
+            conversationId: res.id,
+            actorId: res.matchedId?.id,
+            actorVersion: res.matchedId?.version,
+            date,
+        };
+    }
+    async pncpResponse(req) {
+        let response = await this.client.pncpMessage({
+            conversation: req.conversation,
+            message: {
+                type: PncpMessageKind.PNCP_RESPONSE,
+                value: {
+                    data: req.data,
+                }
+            },
+        });
+        const date = response.timeCreated && Timestamp.toDate(response.timeCreated);
+        const messageId = response.messageId;
+        const entityId = response.matchedId;
+        const actorId = entityId?.id;
+        const actorVersion = entityId?.version;
+        return { type: "response", date, messageId, actorId, actorVersion };
+    }
+    async pncpMessage(data) {
+        const response = await this.client.pncpMessageObject(data);
+        const date = response.timeCreated && Timestamp.toDate(response.timeCreated);
+        const messageId = response.messageId;
+        const entityId = response.matchedId;
+        const actorId = entityId?.id;
+        const actorVersion = entityId?.version;
+        return { type: "response", date, messageId, actorId, actorVersion };
+    }
+    async registerSkillCallback(_req) {
+        // Nothing to do. We could have the paranet only send skill requests to certain clients,
+        // like the way observers work now - probably a useful feature. But for now, nothing to do here.
+    }
+    async registerObserverCallback(req) {
+        if (!this.obsCb) {
+            throw new Error("Set an observer callback first");
+        }
+        const state = this.createOrGetObserverStream({
+            body: {
+                subject: req.subject,
+                action: req.action,
+                conversationId: req.conversationId,
+                filters: req.filters !== undefined ? req.filters : [{ kind: ObservationMessageType.OBS_MESSAGE_TYPE_SKILL }],
+            },
+            offset: req.offset,
+        });
+        console.log(state);
+        state.observer
+            .onstart(() => {
+            console.log("Started observer stream", req);
+        })
+            .ondisconnect(() => {
+            console.log("Observer disconnected");
+        })
+            .onerror((e) => {
+            console.log("Error from observer:", e);
+        })
+            .onmessage((msg) => {
+            const simplified = simplifyObservationCallback(msg);
+            this.obsCb?.(simplified, req.callback);
+        })
+            .autoReconnect(true)
+            .connect();
+        return {
+            type: "registerObserverCallback",
+            args: {
+                key: state.key
+            }
+        };
+    }
+    createOrGetObserverStream({ body, offset, }) {
+        if (!body.subject || !body.action) {
+            // TODO: Throw an error.
+        }
+        const key = JSON.stringify({ body, offset })
+            .split("")
+            .sort()
+            .join("");
+        let state = this.observerState.get(key);
+        if (state != null) {
+            return state;
+        }
+        // NOTE (JAB, 2025-11-03): We will need to consider if we should allow panels to specify the start point, or just compute
+        // it ourselves. For now, probably better to restrict it.
+        const startPoint = offset
+            ? ObservationStartPoint.OBS_START_OFFSET
+            : body.conversationId
+                ? ObservationStartPoint.OBS_START_BEGINNING
+                : ObservationStartPoint.OBS_START_HEAD;
+        const listener = this.client.observerListener({
+            author: {
+                id: this.actorId,
+                version: this.actorVersion,
+            },
+            body,
+            startPoint,
+            seqOffset: offset ? BigInt(offset) : undefined,
+            // TODO (JAB, 2025-11-04): There may be scenarios where we want to track paracord observers,
+            // but currently this is only used in panels and we never want those to be tracked.
+            untracked: true,
+        });
+        // TODO: Setup the callback information correctly.
+        const newState = {
+            key,
+            observer: listener,
+        };
+        this.observerState.set(key, newState);
+        return newState;
+    }
+    async deleteObserver(key) {
+        console.log("Removing observer ", key);
+        const state = this.observerState.get(key);
+        if (state) {
+            state.observer.disconnect();
+            this.observerState.delete(key);
+        }
+    }
+    async uploadDocument(args) {
+        let response = await this.svcClient.documentUpload(args.body, args.args);
+        return {
+            type: "uploadDocument",
+            body: response,
+        };
+    }
+    async fetchDocument(args) {
+        let stream;
+        let error;
+        try {
+            let response = await this.svcClient.documentFetch(args);
+            stream = response.body;
+        }
+        catch (e) {
+            error = e;
+        }
+        return {
+            type: "fetchDocument",
+            error,
+            stream,
+        };
+    }
+    async graphqlCall(args) {
+        let response = await this.svcClient.graphql(args.query, args.variables);
+        return {
+            type: "graphqlCall",
+            data: response.data,
+            error: response.errors,
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./interface";
+export * from "./client";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./interface";
+export * from "./client";

package/dist/interface/index.d.ts

@@ -0,0 +1,43 @@
+import { ObservationCallbackObject, PncpMessageCallbackObject, PncpRequestCallbackObject } from "@otonoma/paranet-client";
+import { MethodCall, MethodReturn } from "./methods";
+export * from "./methods";
+export declare const PARACORD_PANEL_REVISION: number;
+export interface PanelConnect {
+    apiRevision: number;
+    panelId: string;
+    type: "panelConnect";
+}
+export interface PanelMessage {
+    apiRevision: number;
+    panelId: string;
+    messageId?: number;
+    body: MessageBody;
+}
+export type MessageBody = PanelMethodCall | PanelMethodReturnMessage | PncpMessageBody | PanelParacordError;
+export interface PanelParacordError {
+    type: "paracordError";
+    error: string;
+}
+export interface PanelMethodCall {
+    type: "call";
+    body: MethodCall;
+}
+export interface PanelMethodReturnMessage {
+    type: "callReturn";
+    body: MethodReturn;
+}
+export type PncpMessageBody = PncpSkillCallback | PncpMessageCallback | ObservationCallback;
+export interface PncpSkillCallback {
+    type: "pncpSkillCb";
+    body: PncpRequestCallbackObject;
+}
+export interface PncpMessageCallback {
+    type: "pncpMessageCb";
+    body: PncpMessageCallbackObject;
+}
+export interface ObservationCallback {
+    type: "pncpObservationCb";
+    body: ObservationCallbackObject;
+    callback?: any;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/interface/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interface/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAErD,cAAc,WAAW,CAAC;AAE1B,eAAO,MAAM,uBAAuB,EAAE,MAAU,CAAC;AAGjD,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,cAAc,CAAC;CACtB;AAGD,MAAM,WAAW,YAAY;IAE3B,WAAW,EAAE,MAAM,CAAC;IAEpB,OAAO,EAAE,MAAM,CAAC;IAGhB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,MAAM,MAAM,WAAW,GACnB,eAAe,GACf,wBAAwB,GACxB,eAAe,GACf,kBAAkB,CAAC;AAEvB,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAGD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;CACpB;AAED,MAAM,MAAM,eAAe,GACvB,iBAAiB,GACjB,mBAAmB,GACnB,mBAAmB,CAAC;AAExB,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,yBAAyB,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,yBAAyB,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,EAAE,yBAAyB,CAAC;IAChC,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB"}

package/dist/interface/index.js

@@ -0,0 +1,3 @@
+// Interface types for communication between a panel and paracord.
+export * from "./methods";
+export const PARACORD_PANEL_REVISION = 1;

package/dist/interface/methods.d.ts

@@ -0,0 +1,98 @@
+import { ConversationId, DocumentArgs, DocumentInfo, ObservationMessageFilter, PncpMessageObject, SkillRequest } from "@otonoma/paranet-client";
+export type MethodCall = PncpRequestCall | PncpResponseCall | PncpMessageCall | RegisterSkillCallbackCall | RegisterObserverCallbackCall | UnregisterObserverCallbackCall | UploadDocumentCall | FetchDocumentCall | GraphqlCall;
+export type MethodReturn = PncpCallResponse | GraphqlCallResponse | UploadDocumentResponse | FetchDocumentResponse | RegisterObserverResponse | VoidReturn;
+export type PncpRequestCall = {
+    method: "pncpRequest";
+    args: SkillRequest;
+};
+export type PncpResponseCall = {
+    method: "pncpResponse";
+    args: PncpMessageResponse;
+};
+export type PncpMessageCall = {
+    method: "pncpMessage";
+    args: PncpMessageObject;
+};
+export type RegisterSkillCallbackCall = {
+    method: "registerSkillCallback";
+    args: RegisterSkillCallback;
+};
+export type RegisterObserverCallbackCall = {
+    method: "registerObserverCallback";
+    args: RegisterObserverCallback;
+};
+export type RegisterObserverResponse = {
+    type: "registerObserverCallback";
+    args: {
+        key: string;
+    };
+};
+export type UnregisterObserverCallbackCall = {
+    method: "unregisterObserverCallback";
+    args: {
+        key: string;
+    };
+};
+export type UploadDocumentCall = {
+    method: "uploadDocumentCall";
+    args: UploadDocumentArgs;
+};
+export type UploadDocumentArgs = {
+    args?: DocumentArgs;
+    body: File | any;
+};
+export type UploadDocumentResponse = {
+    type: "uploadDocument";
+    error?: string;
+    body?: DocumentInfo;
+};
+export type FetchDocumentCall = {
+    method: "fetchDocumentCall";
+    args: DocumentArgs;
+};
+export type FetchDocumentResponse = {
+    type: "fetchDocument";
+    stream?: ReadableStream;
+    error?: any;
+};
+export type GraphqlCall = {
+    method: "graphqlCall";
+    args: GraphqlCallArgs;
+};
+export type GraphqlCallArgs = {
+    query: string | any;
+    variables?: any;
+};
+export type RegisterSkillCallback = {
+    subject: string;
+    action: string;
+};
+export type RegisterObserverCallback = {
+    subject: string;
+    action: string;
+    offset?: number;
+    callback?: any;
+    filters?: ObservationMessageFilter[];
+    conversationId?: string;
+};
+export interface PncpCallResponse {
+    type: "response";
+    conversationId?: ConversationId;
+    messageId: string;
+    date?: Date;
+    actorId?: string;
+    actorVersion?: string;
+}
+export interface PncpMessageResponse {
+    conversation: string;
+    data: any;
+}
+export interface GraphqlCallResponse {
+    type: "graphqlCall";
+    data: any;
+    error?: any;
+}
+export interface VoidReturn {
+    type: "void";
+}
+//# sourceMappingURL=methods.d.ts.map

package/dist/interface/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../../src/interface/methods.ts"],"names":[],"mappings":"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"}

package/dist/interface/methods.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@otonoma/paracord-panels-interface",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/otonoma/paracord.git"
+  },
+  "license": "UNLICENSED",
+  "version": "0.17.1-rc.12",
+  "description": "Paracord Panels common interface",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "yarn build -- --watch",
+    "prepublish": "yarn build",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@ai-zen/async-queue": "1.3.1",
+    "@otonoma/paranet-client": "^2.11.0-rc.18"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.9.1",
+    "@protobuf-ts/plugin": "^2.9.4",
+    "@types/eslint__js": "^8.42.3",
+    "eslint": "^9.9.1",
+    "typescript": "^5.5.4",
+    "typescript-eslint": "^8.3.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  }
+}

package/src/channel.ts

@@ -0,0 +1,58 @@
+// A generic channel type.
+import { PanelMessage, MessageBody } from "./interface";
+import { PARACORD_PANEL_REVISION } from "./interface";
+export class Channel {
+  evs: Map<number, (data: any) => void>;
+  evId: number;
+  constructor(
+    private panelId: string,
+    private port: MessagePort,
+    incoming: (msg: PanelMessage) => void
+  ) {
+    this.evs = new Map();
+    this.evId = 0;
+    port.onmessage = (ev) => {
+      const message: PanelMessage = ev.data;
+      if (message.messageId === undefined) {
+        // In this case we need to pass the full message so type disambigation can occur on the other side.
+        incoming(message);
+      } else {
+        const cb = this.evs.get(message.messageId);
+        this.evs.delete(message.messageId);
+        if (cb) {
+          // In this case we can destructure the message.
+          cb(message.body);
+        }
+      }
+    };
+  }
+
+  // TODO (JAB): Figure out the "continuous" callbacks; observers, skill callbacks, etc. need to be able to
+  // receive messages repeatedly.
+  private send(
+    body: MessageBody,
+    cb: (data: MessageBody) => void,
+    transferred?: Transferable[]
+  ) {
+    const id = this.evId++;
+    this.evs.set(id, cb);
+    const message: PanelMessage = {
+      messageId: id,
+      body: body,
+      panelId: this.panelId,
+      apiRevision: PARACORD_PANEL_REVISION,
+    };
+    this.port.postMessage(message, transferred || []);
+  }
+
+  public asyncSend(body: MessageBody): Promise<MessageBody> {
+    const p = new Promise<MessageBody>((r) => this.send(body, (m) => r(m)));
+    return p;
+  }
+
+  public async createStream<T, R>(type: string, msg: T): Promise<Stream<R>> {
+    throw new Error("Unimplemented");
+  }
+}
+
+export class Stream<R> {}

package/src/client/abstractClient.ts

@@ -0,0 +1,63 @@
+
+import {
+  DocumentArgs, LoginCredentials, ObservationCallbackObject, PncpMessageCallbackObject, PncpMessageObject, PncpRequestCallbackObject, SkillRequest,
+} from "@otonoma/paranet-client";
+import {
+  FetchDocumentResponse, GraphqlCallArgs, GraphqlCallResponse, PncpCallResponse, PncpMessageResponse, RegisterObserverCallback, RegisterObserverResponse, RegisterSkillCallback, UploadDocumentArgs, UploadDocumentResponse
+} from "../interface";
+
+export interface PncpClientInit {
+  skill?: (msg: PncpRequestCallbackObject) => void;
+  msg?: (msg: PncpMessageCallbackObject) => void;
+  obs?: (msg: ObservationCallbackObject, callback?: any) => void;
+}
+
+// TODO: Make a better name for this
+// This client represents an abstract wrapper around a managed pncp client.
+export abstract class AbstractPncpClient {
+  skillCb?: (msg: PncpRequestCallbackObject) => void;
+  msgCb?: (msg: PncpMessageCallbackObject) => void;
+  obsCb?: (msg: ObservationCallbackObject, callback?: any) => void;
+  constructor(init?: PncpClientInit) {
+    this.skillCb = init?.skill;
+    this.msgCb = init?.msg;
+    this.obsCb = init?.obs;
+  }
+
+  public abstract login(creds: LoginCredentials): Promise<void>;
+  public abstract pncpRequest(req: SkillRequest): Promise<PncpCallResponse>;
+  public abstract pncpResponse(
+    req: PncpMessageResponse
+  ): Promise<PncpCallResponse>;
+
+  public abstract pncpMessage(
+    req: PncpMessageObject
+  ): Promise<PncpCallResponse>;
+
+
+  public abstract registerSkillCallback(req: RegisterSkillCallback): any;
+  public abstract registerObserverCallback(req: RegisterObserverCallback): Promise<RegisterObserverResponse>;
+  public abstract deleteObserver(key: string): Promise<void>;
+
+  // Set the callback on the local listener for skills.
+  public skillCallback(cb: (msg: PncpRequestCallbackObject) => void): this {
+    this.skillCb = cb;
+    return this;
+  }
+
+  public messageCallback(cb: (msg: PncpMessageCallbackObject) => void): this {
+    this.msgCb = cb;
+    return this;
+  }
+
+  public observationCallback(
+    cb: (msg: ObservationCallbackObject, callback?: any) => void
+  ): this {
+    this.obsCb = cb;
+    return this;
+  }
+
+  public abstract uploadDocument(args: UploadDocumentArgs): Promise<UploadDocumentResponse>;
+  public abstract fetchDocument(args: DocumentArgs): Promise<FetchDocumentResponse>;
+  public abstract graphqlCall(args: GraphqlCallArgs): Promise<GraphqlCallResponse>;
+}

package/src/client/index.ts

@@ -0,0 +1,20 @@
+export * from "./abstractClient";
+export * from "./paracordClient";
+export * from "./managedPncpClient";
+export * from "./pncpClient";
+
+// A function which determines if the application is currently running inside of a paracord panel or as a standalone app.
+// This can be used to present a login page and construct a direct connection as needed for standalone apps and otherwise
+// establish a ParacordClient.
+export function isInParacord(): boolean {
+  // This isn't a guaranteed way to check this, we could achieve that by creating a different encoding of the name though.
+  if (window.top !== window.self) {
+    const name = window.name;
+    const parts = name.split('@');
+    return parts.length == 3 && parts[0].match(/[a-f0-9]*-[a-f0-9]*/) != null;
+  } else {
+    return false;
+  }
+}
+
+