@aflueza/dsh-notes 0.0.0-stage → 0.2.1-rc.2

package/lib/index.js

@@ -0,0 +1,259 @@
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import z from '@deepseek-ai/schemastery';
+import { NotesDatabase } from './database/notes-database.js';
+import { LABEL_COLOR_KEYS, RPC_CHANNEL, } from './shared/notes.js';
+export const name = 'dsh-notes';
+export const inject = ['connection', 'webServer'];
+export const Config = z.object({}).default({});
+export function apply(ctx, config) {
+    ctx.inject(['connection', 'webServer'], (rpcCtx) => {
+        const webServer = rpcCtx.webServer;
+        const database = new NotesDatabase(dshHomePath('plugins', 'dsh-notes', 'dsh-notes.sqlite'));
+        rpcCtx.effect(() => {
+            const unregister = webServer.register({
+                kind: 'prefix',
+                path: RPC_CHANNEL,
+                handler: (request, response) => handleRpcRequest(rpcCtx.connection, request, response, database),
+            });
+            return () => {
+                unregister();
+                database.close();
+            };
+        }, 'dsh-notes: RPC route');
+    });
+}
+async function handleRpcRequest(connection, request, response, database) {
+    const rejection = connection.requestRejection(request);
+    if (rejection !== undefined) {
+        response.writeHead(rejection);
+        response.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+        return;
+    }
+    const endpoint = endpointFromRequest(request);
+    if (request.method !== 'POST' || endpoint === null) {
+        response.writeHead(404);
+        response.end('not found');
+        return;
+    }
+    const mediaType = request.headers['content-type']?.split(';', 1)[0]?.trim().toLowerCase();
+    if (mediaType !== 'application/json') {
+        response.writeHead(415);
+        response.end('content type must be application/json');
+        return;
+    }
+    let message;
+    try {
+        message = parseClientRequest(await readJsonBody(request));
+    }
+    catch {
+        response.writeHead(400);
+        response.end('invalid rpc request');
+        return;
+    }
+    if (message.method !== endpoint) {
+        writeRpcResult(response, message.rpcId, fail('invalid-payload', `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`));
+        return;
+    }
+    writeRpcResult(response, message.rpcId, await dispatch(database, endpoint, message.payload));
+}
+function parseClientRequest(value) {
+    if (!isRecord(value))
+        throw new TypeError('request must be an object');
+    if (value.type !== 'client-request' ||
+        typeof value.rpcId !== 'string' ||
+        typeof value.method !== 'string' ||
+        !('payload' in value)) {
+        throw new TypeError('invalid client request envelope');
+    }
+    return {
+        type: 'client-request',
+        rpcId: value.rpcId,
+        method: value.method,
+        payload: value.payload,
+    };
+}
+function endpointFromRequest(request) {
+    const pathname = new URL(request.url ?? '/', 'http://x').pathname;
+    const prefix = `${RPC_CHANNEL}/`;
+    if (!pathname.startsWith(prefix))
+        return null;
+    const endpoint = pathname.slice(prefix.length);
+    return endpoint || null;
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > 1024 * 1024)
+            throw new RangeError('request body exceeds 1 MiB');
+        chunks.push(buffer);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+function writeRpcResult(response, rpcId, result) {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ type: 'server-response', rpcId, result }));
+}
+async function dispatch(database, endpoint, payload) {
+    try {
+        switch (endpoint) {
+            case 'notes/index':
+                return ok(database.index());
+            case 'notes/list':
+                return ok(database.list(parseFilter(payload)));
+            case 'labels/map':
+                return ok(database.labelMap(parseLabelMapView(payload)));
+            case 'notes/get':
+                return ok(database.get(requiredString(payload, 'id')));
+            case 'notes/create':
+                return ok(await database.create(parseCreateNote(payload)));
+            case 'notes/update':
+                return ok(await database.update(parseUpdateNote(payload)));
+            case 'notes/trash':
+                return ok(await database.trash(requiredString(payload, 'id')));
+            case 'notes/restore':
+                return ok(await database.restore(requiredString(payload, 'id')));
+            case 'notes/trash/empty':
+                return ok(await database.emptyTrash());
+            case 'notebooks/create':
+                return ok(await database.createNotebook(parseCreateNotebook(payload)));
+            case 'notebooks/rename':
+                return ok(await database.renameNotebook(parseRenameNotebook(payload)));
+            case 'notebooks/delete':
+                return ok(await database.deleteNotebook(requiredString(payload, 'id')));
+            case 'labels/create':
+                return ok(await database.createLabel(parseLabel(payload)));
+            case 'labels/update':
+                return ok(await database.updateLabel({ id: requiredString(payload, 'id'), ...parseLabel(payload) }));
+            case 'labels/delete':
+                return ok(await database.deleteLabel(requiredString(payload, 'id')));
+            case 'notes/import-markdown':
+                return ok(await database.importMarkdown(parseMarkdownImport(payload)));
+            default:
+                return fail('unknown-endpoint', `unknown endpoint "${endpoint}"`);
+        }
+    }
+    catch (error) {
+        const known = isRecord(error) ? error : {};
+        const code = typeof known.code === 'string' ? known.code : 'internal';
+        const message = typeof known.message === 'string' ? known.message : String(error);
+        const details = isRecord(known.details) ? known.details : {};
+        return fail(code, message, details);
+    }
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function fail(code, message, details) {
+    return { ok: false, error: { code, message, details: details ?? {} } };
+}
+function requiredString(payload, key) {
+    if (!isRecord(payload) || typeof payload[key] !== 'string' || !payload[key].trim()) {
+        throw new NotesInputError('invalid-payload', `${key} must be a non-empty string`);
+    }
+    return payload[key];
+}
+function parseFilter(payload) {
+    if (!isRecord(payload))
+        throw new NotesInputError('invalid-payload', 'filter must be an object');
+    const view = payload.view;
+    if (view !== 'all' && view !== 'pinned' && view !== 'archived' && view !== 'trash') {
+        throw new NotesInputError('invalid-payload', 'view is invalid');
+    }
+    return {
+        view: view,
+        query: typeof payload.query === 'string' ? payload.query : '',
+        notebookId: typeof payload.notebookId === 'string' ? payload.notebookId : undefined,
+        labelIds: Array.isArray(payload.labelIds) && payload.labelIds.every((id) => typeof id === 'string')
+            ? payload.labelIds
+            : [],
+    };
+}
+function parseLabelMapView(payload) {
+    if (!isRecord(payload))
+        throw new NotesInputError('invalid-payload', 'view must be an object');
+    const view = payload.view;
+    if (view !== 'all' && view !== 'pinned' && view !== 'archived' && view !== 'trash') {
+        throw new NotesInputError('invalid-payload', 'view is invalid');
+    }
+    return view;
+}
+function parseCreateNote(payload) {
+    if (payload === null || payload === undefined)
+        return {};
+    if (!isRecord(payload))
+        throw new NotesInputError('invalid-payload', 'note must be an object');
+    return {
+        notebookId: typeof payload.notebookId === 'string' ? payload.notebookId : undefined,
+        title: typeof payload.title === 'string' ? payload.title : '',
+        body: typeof payload.body === 'string' ? payload.body : '',
+    };
+}
+function parseUpdateNote(payload) {
+    if (!isRecord(payload))
+        throw new NotesInputError('invalid-payload', 'note must be an object');
+    const labelIds = payload.labelIds;
+    if (!Array.isArray(labelIds) || !labelIds.every((id) => typeof id === 'string')) {
+        throw new NotesInputError('invalid-payload', 'labelIds must be an array of strings');
+    }
+    if (!Number.isInteger(payload.revision) || payload.revision < 1) {
+        throw new NotesInputError('invalid-payload', 'revision must be a positive integer');
+    }
+    if (typeof payload.title !== 'string' || typeof payload.body !== 'string') {
+        throw new NotesInputError('invalid-payload', 'title and body must be strings');
+    }
+    if (typeof payload.isPinned !== 'boolean' || typeof payload.isArchived !== 'boolean') {
+        throw new NotesInputError('invalid-payload', 'pin and archive flags must be booleans');
+    }
+    return {
+        id: requiredString(payload, 'id'),
+        revision: payload.revision,
+        notebookId: requiredString(payload, 'notebookId'),
+        title: payload.title,
+        body: payload.body,
+        labelIds,
+        isPinned: payload.isPinned,
+        isArchived: payload.isArchived,
+    };
+}
+function parseLabel(payload) {
+    if (!isRecord(payload) || typeof payload.name !== 'string' || !payload.name.trim()) {
+        throw new NotesInputError('invalid-payload', 'label name is required');
+    }
+    if (!LABEL_COLOR_KEYS.includes(payload.colorKey)) {
+        throw new NotesInputError('invalid-payload', 'label colorKey is invalid');
+    }
+    return { name: payload.name, colorKey: payload.colorKey };
+}
+function parseCreateNotebook(payload) {
+    return { name: requiredString(payload, 'name') };
+}
+function parseRenameNotebook(payload) {
+    return { id: requiredString(payload, 'id'), name: requiredString(payload, 'name') };
+}
+function parseMarkdownImport(payload) {
+    if (!isRecord(payload) ||
+        typeof payload.filename !== 'string' ||
+        typeof payload.body !== 'string') {
+        throw new NotesInputError('invalid-payload', 'filename and body are required');
+    }
+    return {
+        filename: payload.filename,
+        body: payload.body,
+        notebookId: typeof payload.notebookId === 'string' ? payload.notebookId : undefined,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+class NotesInputError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "@aflueza/dsh-notes",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1-rc.2",
+  "description": "A local Markdown notes plugin for DeepSeek Harness.",
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.inline.js",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.inline.js",
+    "cordis.patch.yml",
+    "README.md",
+    "package.json"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-ui-theme"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && pnpm run build:client",
+    "build:client": "node scripts/clean-client-output.mjs && tsdown && node scripts/inline-css.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "check": "pnpm run typecheck && pnpm run build && node --check lib/index.js && node --check lib/client.inline.js && node --test tests/*.spec.mjs"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.5",
+    "@deepseek-ai/dsh-client-connection": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-theme": "0.2.1-rc.2",
+    "@tsdown/css": "^0.23.5",
+    "@types/node": "^22.10.0",
+    "@types/react": "^18.2.0",
+    "react": "^18.2.0",
+    "tsdown": "^0.23.5",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-home-paths": "0.2.1-rc.2",
+    "@deepseek-ai/schemastery": "3.18.5",
+    "monaco-editor": "^0.55.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.5",
+    "@deepseek-ai/dsh-client-connection": ">=0.2.1-rc.2 <0.2.3-0",
+    "@deepseek-ai/dsh-client-ui-primitives": ">=0.2.1-rc.2 <0.2.3-0",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": ">=0.2.1-rc.2 <0.2.3-0",
+    "@deepseek-ai/dsh-client-ui-slots": ">=0.2.1-rc.2 <0.2.3-0",
+    "@deepseek-ai/dsh-client-ui-theme": ">=0.2.1-rc.2 <0.2.3-0"
+  }
+}