@ohos-ports/redux-devtools-cli 5.0.0-beta.0

package/dist/db/migrations/index.js

@@ -0,0 +1,84 @@
+export function up(knex) {
+    return Promise.all([
+        knex.schema.createTable('remotedev_reports', function (table) {
+            table.uuid('id').primary();
+            table.string('type');
+            table.string('title');
+            table.string('description');
+            table.string('action');
+            table.text('payload', 'longtext');
+            table.text('preloadedState', 'longtext');
+            table.text('screenshot', 'longtext');
+            table.string('userAgent');
+            table.string('version');
+            table.string('user');
+            table.string('userId');
+            table.string('instanceId');
+            table.string('meta');
+            table.string('exception');
+            table.timestamp('added').defaultTo(knex.fn.now());
+            table
+                .uuid('appId')
+                .references('id')
+                .inTable('remotedev_apps')
+                .onDelete('CASCADE')
+                .onUpdate('CASCADE')
+                .defaultTo('78626c31-e16b-4528-b8e5-f81301b627f4');
+        }),
+        knex.schema.createTable('remotedev_payloads', function (table) {
+            table.uuid('id').primary();
+            table.text('state');
+            table.text('action');
+            table.timestamp('added').defaultTo(knex.fn.now());
+            table
+                .uuid('reportId')
+                .references('id')
+                .inTable('remotedev_reports')
+                .onDelete('CASCADE')
+                .onUpdate('CASCADE');
+        }),
+        knex.schema.createTable('remotedev_apps', function (table) {
+            table.uuid('id').primary();
+            table.string('title');
+            table.string('description');
+            table.string('url');
+            table.timestamps(false, true);
+        }),
+        knex.schema.createTable('remotedev_users', function (table) {
+            table.uuid('id').primary();
+            table.string('name');
+            table.string('login');
+            table.string('email');
+            table.string('avatarUrl');
+            table.string('profileUrl');
+            table.string('oauthId');
+            table.string('oauthType');
+            table.string('token');
+            table.timestamps(false, true);
+        }),
+        knex.schema.createTable('remotedev_users_apps', function (table) {
+            table.boolean('readOnly').defaultTo(false);
+            table.uuid('userId');
+            table.uuid('appId');
+            table.primary(['userId', 'appId']);
+            table
+                .foreign('userId')
+                .references('id')
+                .inTable('remotedev_users')
+                .onDelete('CASCADE')
+                .onUpdate('CASCADE');
+            table
+                .foreign('appId')
+                .references('id')
+                .inTable('remotedev_apps')
+                .onDelete('CASCADE')
+                .onUpdate('CASCADE');
+        }),
+    ]);
+}
+export function down(knex) {
+    return Promise.all([
+        knex.schema.dropTable('remotedev_reports'),
+        knex.schema.dropTable('remotedev_apps'),
+    ]);
+}

package/dist/db/seeds/index.d.ts

@@ -0,0 +1,2 @@
+import { Knex } from 'knex';
+export declare function seed(knex: Knex): Promise<[number[]]>;

package/dist/db/seeds/index.js

@@ -0,0 +1,10 @@
+export function seed(knex) {
+    return Promise.all([knex('remotedev_apps').del()]).then(function () {
+        return Promise.all([
+            knex('remotedev_apps').insert({
+                id: '78626c31-e16b-4528-b8e5-f81301b627f4',
+                title: 'Default',
+            }),
+        ]);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export default function (argv: {
+    [arg: string]: any;
+}): Promise<{
+    portAlreadyUsed?: boolean;
+    ready: Promise<void>;
+}>;

package/dist/index.js

@@ -0,0 +1,125 @@
+import express from 'express';
+import http from 'http';
+import getPort from 'get-port';
+import socketClusterServer from 'socketcluster-server';
+import getOptions from './options.js';
+import routes from './routes.js';
+import createStore from './store.js';
+// const LOG_LEVEL_NONE = 0;
+// const LOG_LEVEL_ERROR = 1;
+const LOG_LEVEL_WARN = 2;
+const LOG_LEVEL_INFO = 3;
+export default async function (argv) {
+    const options = Object.assign(getOptions(argv), {
+        allowClientPublish: false,
+    });
+    const port = options.port;
+    const logLevel = options.logLevel === undefined ? LOG_LEVEL_INFO : options.logLevel;
+    // Check port already used
+    const p = await getPort({ port });
+    if (port !== p) {
+        if (logLevel >= LOG_LEVEL_WARN) {
+            console.log(`[ReduxDevTools] Server port ${port} is already used.`);
+        }
+        return {
+            portAlreadyUsed: true,
+            ready: Promise.resolve(),
+        };
+    }
+    if (logLevel >= LOG_LEVEL_INFO) {
+        console.log('[ReduxDevTools] Start server...');
+        console.log('-'.repeat(80) + '\n');
+    }
+    const httpServer = http.createServer();
+    const agServer = socketClusterServer.attach(httpServer, options);
+    const app = express();
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    httpServer.on('request', app);
+    const store = createStore(options);
+    app.use(routes(options, store, agServer));
+    agServer.setMiddleware(agServer.MIDDLEWARE_INBOUND, 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    async (middlewareStream) => {
+        for await (const action of middlewareStream) {
+            if (action.type === action.TRANSMIT) {
+                const channel = action.receiver;
+                const data = action.data;
+                if (channel.substring(0, 3) === 'sc-' ||
+                    channel === 'respond' ||
+                    channel === 'log') {
+                    void agServer.exchange.transmitPublish(channel, data);
+                }
+                else if (channel === 'log-noid') {
+                    void agServer.exchange.transmitPublish('log', {
+                        id: action.socket.id,
+                        data: data,
+                    });
+                }
+            }
+            else if (action.type === action.SUBSCRIBE) {
+                if (action.channel === 'report') {
+                    store
+                        .list()
+                        .then(function (data) {
+                        void agServer.exchange.transmitPublish('report', {
+                            type: 'list',
+                            data: data,
+                        });
+                    })
+                        .catch(function (error) {
+                        console.error(error);
+                    });
+                }
+            }
+            action.allow();
+        }
+    });
+    void (async () => {
+        for await (const { socket } of agServer.listener('connection')) {
+            let channelToWatch, channelToEmit;
+            void (async () => {
+                for await (const request of socket.procedure('login')) {
+                    const credentials = request.data;
+                    if (credentials === 'master') {
+                        channelToWatch = 'respond';
+                        channelToEmit = 'log';
+                    }
+                    else {
+                        channelToWatch = 'log';
+                        channelToEmit = 'respond';
+                    }
+                    request.end(channelToWatch);
+                }
+            })();
+            void (async () => {
+                for await (const request of socket.procedure('getReport')) {
+                    const id = request.data;
+                    store
+                        .get(id)
+                        .then(function (data) {
+                        request.end(data);
+                    })
+                        .catch(function (error) {
+                        console.error(error);
+                    });
+                }
+            })();
+            void (async () => {
+                for await (const data of socket.listener('disconnect')) {
+                    const channel = agServer.exchange.channel('sc-' + socket.id);
+                    channel.unsubscribe();
+                    void agServer.exchange.transmitPublish(channelToEmit, {
+                        id: socket.id,
+                        type: 'DISCONNECTED',
+                    });
+                }
+            })();
+        }
+    })();
+    httpServer.listen(options.port);
+    return {
+        ready: (async () => {
+            await agServer.listener('ready').once();
+        })(),
+    };
+}

package/dist/options.d.ts

@@ -0,0 +1,29 @@
+interface ProtocolOptions {
+    key: string | undefined;
+    cert: string | undefined;
+    passphrase: string | undefined;
+}
+interface DbOptions {
+    client: string;
+    connection: {
+        filename: string;
+    };
+    useNullAsDefault: boolean;
+    debug: boolean;
+    migrate: boolean;
+}
+export interface Options {
+    host: string | undefined;
+    port: number;
+    protocol: 'http' | 'https';
+    protocolOptions: ProtocolOptions | undefined;
+    dbOptions: DbOptions;
+    maxRequestBody: string;
+    logHTTPRequests?: boolean;
+    logLevel: 0 | 1 | 3 | 2;
+    wsEngine: string;
+}
+export default function getOptions(argv: {
+    [arg: string]: any;
+}): Options;
+export {};

package/dist/options.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+export default function getOptions(argv) {
+    let dbOptions = argv.dbOptions;
+    if (typeof dbOptions === 'string') {
+        dbOptions = JSON.parse(fs.readFileSync(dbOptions, 'utf8'));
+    }
+    else if (typeof dbOptions === 'undefined') {
+        dbOptions = JSON.parse(fs.readFileSync(new URL('../defaultDbOptions.json', import.meta.url), 'utf8'));
+    }
+    return {
+        host: argv.hostname || process.env.npm_package_remotedev_hostname || undefined,
+        port: Number(argv.port || process.env.npm_package_remotedev_port) || 8000,
+        protocol: argv.protocol || process.env.npm_package_remotedev_protocol || 'http',
+        protocolOptions: !(argv.protocol === 'https')
+            ? undefined
+            : {
+                key: argv.key || process.env.npm_package_remotedev_key || undefined,
+                cert: argv.cert || process.env.npm_package_remotedev_cert || undefined,
+                passphrase: argv.passphrase ||
+                    process.env.npm_package_remotedev_passphrase ||
+                    undefined,
+            },
+        dbOptions: dbOptions,
+        maxRequestBody: argv.passphrase || '16mb',
+        logHTTPRequests: argv.logHTTPRequests,
+        logLevel: argv.logLevel || 3,
+        wsEngine: argv.wsEngine || process.env.npm_package_remotedev_wsengine || 'ws',
+    };
+}

package/dist/routes.d.ts

@@ -0,0 +1,5 @@
+import type { Router } from 'express';
+import { AGServer } from 'socketcluster-server';
+import type { Store } from './store.js';
+declare function routes(options: AGServer.AGServerOptions, store: Store, scServer: AGServer): Router;
+export default routes;

package/dist/routes.js

@@ -0,0 +1,100 @@
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import express from 'express';
+import morgan from 'morgan';
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import { ApolloServer } from '@apollo/server';
+import { expressMiddleware } from '@as-integrations/express5';
+import { resolvers, schema } from './api/schema.js';
+const app = express.Router();
+const require = createRequire(import.meta.url);
+function serveUmdModule(name) {
+    app.use(express.static(path.dirname(require.resolve(name + '/package.json')) + '/umd'));
+}
+function routes(options, store, scServer) {
+    const limit = options.maxRequestBody;
+    const logHTTPRequests = options.logHTTPRequests;
+    if (logHTTPRequests) {
+        if (typeof logHTTPRequests === 'object')
+            app.use(morgan('combined', logHTTPRequests));
+        else
+            app.use(morgan('combined'));
+    }
+    const server = new ApolloServer({
+        typeDefs: schema,
+        resolvers,
+    });
+    server
+        .start()
+        .then(() => {
+        app.use('/graphql', cors(), bodyParser.json(), expressMiddleware(server, {
+            context: () => Promise.resolve({ store }),
+        }));
+    })
+        .catch((error) => {
+        console.error(error);
+    });
+    serveUmdModule('react');
+    serveUmdModule('react-dom');
+    serveUmdModule('@redux-devtools/app');
+    app.get('/port.js', function (req, res) {
+        res.send(`reduxDevToolsPort = ${options.port}`);
+    });
+    app.get('/{*splat}', function (req, res) {
+        res.sendFile(path.join(path.dirname(fileURLToPath(import.meta.url)), '../app/index.html'));
+    });
+    app.use(cors({ methods: 'POST' }));
+    app.use(bodyParser.json({ limit: limit }));
+    app.use(bodyParser.urlencoded({ limit: limit, extended: false }));
+    app.post('/', function (req, res) {
+        if (!req.body) {
+            res.status(404).end();
+            return;
+        }
+        switch (req.body.op) {
+            case 'get':
+                store
+                    .get(req.body.id)
+                    .then(function (r) {
+                    res.send(r || {});
+                })
+                    .catch(function (error) {
+                    console.error(error);
+                    res.sendStatus(500);
+                });
+                break;
+            case 'list':
+                store
+                    .list(req.body.query, req.body.fields)
+                    .then(function (r) {
+                    res.send(r);
+                })
+                    .catch(function (error) {
+                    console.error(error);
+                    res.sendStatus(500);
+                });
+                break;
+            default:
+                store
+                    .add(req.body)
+                    .then(function (r) {
+                    res.send({
+                        id: r.id,
+                        error: r.error,
+                    });
+                    void scServer.exchange.transmitPublish('report', {
+                        type: 'add',
+                        data: r,
+                    });
+                })
+                    .catch(function (error) {
+                    console.error(error);
+                    res.status(500).send({});
+                });
+        }
+    });
+    return app;
+}
+export default routes;

package/dist/store.d.ts

@@ -0,0 +1,57 @@
+import { AGServer } from 'socketcluster-server';
+type ReportType = 'STATE' | 'ACTION' | 'STATES' | 'ACTIONS';
+export interface Report {
+    id: string;
+    type: ReportType | null;
+    title: string | null;
+    description: string | null;
+    action: string | null;
+    payload: string;
+    preloadedState: string | null;
+    screenshot: string | null;
+    userAgent: string | null;
+    version: string | null;
+    userId: string | null;
+    user: string | null;
+    meta: string | null;
+    exception: string | null;
+    instanceId: string | null;
+    added: string | null;
+    appId?: string | null;
+}
+export interface ReportBaseFields {
+    id: string;
+    title: string | null;
+    added: string | null;
+}
+export interface AddData {
+    type: ReportType | null;
+    title: string | null;
+    description: string | null;
+    action: string | null;
+    payload: string;
+    preloadedState: string | null;
+    screenshot: string | null;
+    version: string | null;
+    userAgent: string | null;
+    userId: string | null;
+    user: {
+        id: string;
+    } | string | null;
+    instanceId: string | null;
+    meta: string | null;
+    exception?: Error;
+    appId?: string | null;
+}
+export interface Store {
+    list: (query?: string, fields?: string[]) => Promise<ReportBaseFields[]>;
+    listAll: (query?: string) => Promise<Report[]>;
+    get: (id: string) => Promise<Report | {
+        error: string;
+    }>;
+    add: (data: AddData) => Promise<ReportBaseFields | {
+        error: string;
+    }>;
+}
+declare function createStore(options: AGServer.AGServerOptions): Store;
+export default createStore;

package/dist/store.js

@@ -0,0 +1,97 @@
+import { v4 as uuidV4 } from 'uuid';
+import { pick } from 'lodash-es';
+import connector from './db/connector.js';
+const reports = 'remotedev_reports';
+// var payloads = 'remotedev_payloads';
+let knex;
+const baseFields = ['id', 'title', 'added'];
+function error(msg) {
+    return new Promise(function (resolve) {
+        return resolve({ error: msg });
+    });
+}
+function list(query, fields) {
+    const r = knex.select(fields || baseFields).from(reports);
+    if (query)
+        return r.where(query);
+    return r;
+}
+function listAll(query) {
+    const r = knex.select().from(reports);
+    if (query)
+        return r.where(query);
+    return r;
+}
+function get(id) {
+    if (!id)
+        return error('No id specified.');
+    return knex(reports).where('id', id).first();
+}
+function add(data) {
+    if (!data.type || !data.payload) {
+        return error("Required parameters aren't specified.");
+    }
+    if (data.type !== 'ACTIONS' && data.type !== 'STATE') {
+        return error('Type ' + data.type + ' is not supported yet.');
+    }
+    const reportId = uuidV4();
+    const report = {
+        id: reportId,
+        type: data.type,
+        title: data.title || (data.exception && data.exception.message) || data.action,
+        description: data.description,
+        action: data.action,
+        payload: data.payload,
+        preloadedState: data.preloadedState,
+        screenshot: data.screenshot,
+        version: data.version,
+        userAgent: data.userAgent,
+        user: data.user,
+        userId: typeof data.user === 'object'
+            ? data.user.id
+            : data.user,
+        instanceId: data.instanceId,
+        meta: data.meta,
+        exception: composeException(data.exception),
+        added: new Date().toISOString(),
+    };
+    if (data.appId)
+        report.appId = data.appId; // TODO check if the id exists and we have access to link it
+    /*
+    var payload = {
+      id: uuid.v4(),
+      reportId: reportId,
+      state: data.payload
+    };
+    */
+    return knex
+        .insert(report)
+        .into(reports)
+        .then(function () {
+        return byBaseFields(report);
+    });
+}
+function byBaseFields(data) {
+    return pick(data, baseFields);
+}
+function createStore(options) {
+    knex = connector(options);
+    return {
+        list: list,
+        listAll: listAll,
+        get: get,
+        add: add,
+    };
+}
+function composeException(exception) {
+    let message = '';
+    if (exception) {
+        message = 'Exception thrown: ';
+        if (exception.message)
+            message += exception.message;
+        if (exception.stack)
+            message += '\n' + exception.stack;
+    }
+    return message;
+}
+export default createStore;

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@ohos-ports/redux-devtools-cli",
+  "version": "5.0.0-beta.0",
+  "description": "CLI for remote debugging with Redux DevTools.",
+  "homepage": "https://github.com/reduxjs/redux-devtools/tree/master/packages/redux-devtools-cli",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "license": "MIT",
+  "author": "Mihail Diordiev <zalmoxisus@gmail.com> (https://github.com/zalmoxisus)",
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "app",
+    "index.js",
+    "defaultDbOptions.json"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "redux-devtools": "bin/redux-devtools.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/redux-devtools-cli/5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@apollo/server": "^5.2.0",
+    "@as-integrations/express5": "^1.1.2",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.1",
+    "@reduxjs/toolkit": "^2.11.2",
+    "@types/react": "^19.2.14",
+    "body-parser": "^2.2.2",
+    "chalk": "^5.6.2",
+    "cors": "^2.8.6",
+    "cross-spawn": "^7.0.6",
+    "electron": "^31.7.7",
+    "express": "^5.2.1",
+    "get-port": "^7.1.0",
+    "graphql": "^16.13.0",
+    "knex": "^3.1.0",
+    "lodash-es": "^4.17.23",
+    "minimist": "^1.2.8",
+    "morgan": "^1.10.1",
+    "open": "^11.0.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-is": "^19.2.4",
+    "semver": "^7.7.4",
+    "socketcluster-server": "^20.0.0",
+    "@ohos-ports/sqlite3": "^5.1.7-beta.0",
+    "uuid": "^13.0.0",
+    "@redux-devtools/app": "^8.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "@types/body-parser": "^1.19.6",
+    "@types/cors": "^2.8.19",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/express": "^5.0.6",
+    "@types/jest": "^30.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/minimist": "^1.2.5",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^24.11.0",
+    "@types/semver": "^7.7.1",
+    "@types/socketcluster-client": "^20.0.0",
+    "@types/socketcluster-server": "^20.0.0",
+    "@types/supertest": "^7.2.0",
+    "@types/uuid": "^11.0.0",
+    "globals": "^17.4.0",
+    "jest": "^30.2.0",
+    "ncp": "^2.0.0",
+    "rimraf": "^6.1.3",
+    "socketcluster-client": "^20.0.1",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.4.6",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "build": "tsc && ncp ./src/api/schema_def.graphql ./dist/api/schema_def.graphql",
+    "start": "node ./bin/redux-devtools.js",
+    "start:electron": "node ./bin/redux-devtools.js --open",
+    "clean": "rimraf dist",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit",
+    "prepublish": "pnpm run type-check && pnpm run lint && pnpm run test"
+  }
+}

package/src/api/schema.ts

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import type { Store } from '../store.js';
+
+export const schema = fs.readFileSync(
+  new URL('./schema_def.graphql', import.meta.url),
+  'utf8',
+);
+
+export const resolvers = {
+  Query: {
+    reports: function report(
+      source: unknown,
+      args: unknown,
+      context: { store: Store },
+    ) {
+      return context.store.listAll();
+    },
+    report: function report(
+      source: unknown,
+      args: { id: string },
+      context: { store: Store },
+    ) {
+      return context.store.get(args.id);
+    },
+  },
+};