@caido/sdk-frontend 0.0.1-beta.0

package/src/types/backend.d.ts

@@ -0,0 +1,20 @@
+import type { PromisifiedReturnType } from "./utils";
+export type BackendEndpoints = {
+    [key: string]: (...args: any[]) => any;
+};
+export type BackendEvents = {
+    [key: string]: (...args: any[]) => void;
+};
+export type ToBackendRPC<T extends BackendEndpoints, E extends BackendEvents> = {
+    [K in keyof T]: (...args: Parameters<T[K]>) => PromisifiedReturnType<T[K]>;
+} & {
+    /**
+     * Subscribe to a backend event.
+     * @param event The event to subscribe to.
+     * @param callback The callback to call when the event is emitted.
+     * @returns An object with a `stop` method that can be called to stop listening to the event.
+     */
+    onEvent: <K extends keyof E>(event: K, callback: E[K]) => {
+        stop: () => void;
+    };
+};

package/src/types/commands.d.ts

@@ -0,0 +1,55 @@
+export type Commands = {
+    register: (id: string, options: CommandOptions) => void;
+};
+type CommandOptions = {
+    name: string;
+    run: (context: CommandContext) => void;
+    group?: string;
+    when?: (context: CommandContext) => boolean;
+};
+type CommandContextBase = {
+    type: "BaseContext";
+};
+type CommandContextRequestRow = {
+    type: "RequestRowContext";
+    requests: {
+        id: string;
+        host: string;
+        port: number;
+        path: string;
+        query: string;
+        isTls: boolean;
+    }[];
+};
+type CommandContextRequest = {
+    type: "RequestContext";
+    request: {
+        host: string;
+        port: number;
+        path: string;
+        query: string;
+        isTls: boolean;
+        raw: string;
+    };
+    selection: string;
+};
+type CommandContextResponse = {
+    type: "ResponseContext";
+    request: {
+        id: string;
+        host: string;
+        port: number;
+        path: string;
+        query: string;
+        isTls: boolean;
+    };
+    response: {
+        id: string;
+        raw: string;
+        statusCode: number;
+        roundtripTime: number;
+    };
+    selection: string;
+};
+export type CommandContext = CommandContextBase | CommandContextRequestRow | CommandContextRequest | CommandContextResponse;
+export {};

package/src/types/findings.d.ts

@@ -0,0 +1,18 @@
+export type Findings = {
+    createFinding: (requestId: string, options: CreateFindingsOptions) => Promise<Finding | undefined>;
+};
+type Finding = {
+    id: string;
+    title: string;
+    description?: string;
+    reporter: string;
+    host: string;
+    path: string;
+};
+type CreateFindingsOptions = {
+    title: string;
+    description?: string;
+    reporter: string;
+    dedupeKey?: string;
+};
+export {};

package/src/types/index.d.ts

@@ -0,0 +1,40 @@
+import type { Sdk } from "./__generated__/graphql-sdk";
+import type { BackendEndpoints, BackendEvents, ToBackendRPC } from "./backend";
+import type { Commands } from "./commands";
+import type { Findings } from "./findings";
+import type { Menu } from "./menu";
+import type { Navigation } from "./navigation";
+import type { Scopes } from "./scopes";
+import type { Storage } from "./storage";
+import type { UI } from "./ui";
+import type { Window } from "./window";
+export type { CommandContext } from "./commands";
+export type API<T extends BackendEndpoints = Record<string, never>, E extends BackendEvents = Record<string, never>> = {
+    ui: UI;
+    backend: ToBackendRPC<T, E>;
+    scopes: Scopes;
+    findings: Findings;
+    commands: Commands;
+    menu: Menu;
+    navigation: Navigation;
+    window: Window;
+    storage: Storage;
+    shortcuts: {
+        register: (commandId: string, keys: string[]) => void;
+    };
+    commandPalette: {
+        register: (commandId: string) => void;
+    };
+    sidebar: {
+        registerItem: (name: string, path: string, options?: SidebarItemOptions) => SidebarItem;
+    };
+    graphql: Sdk;
+};
+type SidebarItemOptions = {
+    icon?: string;
+    group?: string;
+    isExternal?: boolean;
+};
+type SidebarItem = {
+    setCount: (count: number) => void;
+};

package/src/types/menu.d.ts

@@ -0,0 +1,26 @@
+export type Menu = {
+    registerItem: (item: MenuItem) => void;
+};
+type MenuItem = RequestRowMenuItem | SettingsMenuItem | RequestMenuItem | ResponseMenuItem;
+type RequestRowMenuItem = {
+    type: "RequestRow";
+    commandId: string;
+    leadingIcon?: string;
+};
+type RequestMenuItem = {
+    type: "Request";
+    commandId: string;
+    leadingIcon?: string;
+};
+type ResponseMenuItem = {
+    type: "Response";
+    commandId: string;
+    leadingIcon?: string;
+};
+type SettingsMenuItem = {
+    type: "Settings";
+    label: string;
+    path: string;
+    leadingIcon?: string;
+};
+export {};

package/src/types/navigation.d.ts

@@ -0,0 +1,9 @@
+export type { CommandContext } from "./commands";
+export type Navigation = {
+    goTo: (path: string) => void;
+    addPage: (path: string, options: PageOptions) => void;
+};
+type PageOptions = {
+    body: HTMLElement;
+    topbar?: HTMLElement;
+};

package/src/types/scopes.d.ts

@@ -0,0 +1,23 @@
+export type Scopes = {
+    getScopes: () => Scope[];
+    createScope: (options: CreateScopeOptions) => Promise<Scope | undefined>;
+    updateScope: (id: string, options: UpdateScopeOptions) => Promise<Scope | undefined>;
+    deleteScope: (id: string) => Promise<boolean>;
+};
+type Scope = {
+    id: string;
+    name: string;
+    allowlist: string[];
+    denylist: string[];
+};
+type CreateScopeOptions = {
+    name: string;
+    allowlist: string[];
+    denylist: string[];
+};
+type UpdateScopeOptions = {
+    name?: string;
+    allowlist?: string[];
+    denylist?: string[];
+};
+export {};

package/src/types/storage.d.ts

@@ -0,0 +1,6 @@
+import type { JSONCompatible, JSONValue } from "./utils";
+export type Storage = {
+    get: () => JSONValue;
+    set: <T>(value: JSONCompatible<T>) => Promise<void>;
+    onChange: (callback: (value: JSONValue) => void) => void;
+};

package/src/types/ui.d.ts

@@ -0,0 +1,23 @@
+export type UI = {
+    button: (options?: ButtonOptions) => HTMLElement;
+    card: (options?: CardOptions) => HTMLElement;
+    well: (options?: WellOptions) => HTMLElement;
+};
+type ButtonOptions = {
+    variant?: "primary" | "secondary" | "tertiary";
+    label?: string;
+    leadingIcon?: string;
+    trailingIcon?: string;
+    size?: "small" | "medium" | "large";
+};
+type CardOptions = {
+    header?: HTMLElement;
+    body?: HTMLElement;
+    footer?: HTMLElement;
+};
+type WellOptions = {
+    header?: HTMLElement;
+    body?: HTMLElement;
+    footer?: HTMLElement;
+};
+export {};

package/src/types/utils.d.ts

@@ -0,0 +1,10 @@
+type JSONPrimitive = string | number | boolean | null | undefined;
+export type JSONValue = JSONPrimitive | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+type NotAssignableToJson = bigint | symbol | Function;
+export type JSONCompatible<T> = unknown extends T ? never : {
+    [P in keyof T]: T[P] extends JSONValue ? T[P] : T[P] extends NotAssignableToJson ? never : JSONCompatible<T[P]>;
+};
+export type PromisifiedReturnType<T extends (...args: unknown[]) => unknown> = ReturnType<T> extends Promise<infer U> ? Promise<U> : Promise<ReturnType<T>>;
+export {};

package/src/types/window.d.ts

@@ -0,0 +1,15 @@
+export type Window = {
+    getActiveEditor: () => Editor | undefined;
+    showToast: (message: string, options?: ToastOptions) => void;
+};
+type ToastOptions = {
+    variant?: "success" | "error" | "warning" | "info";
+    duration?: number;
+};
+type Editor = {
+    getSelectedText: () => string;
+    replaceSelectedText: (text: string) => void;
+    isReadOnly: () => boolean;
+    focus: () => void;
+};
+export {};