@rho-workspace/rho 0.5.4 → 0.5.5

package/dist/contracts/owners.generated.js

@@ -7259,6 +7259,360 @@ export const ownerContracts = {
                     },
                     "requires": []
                 },
+                "agent.sessions.list": {
+                    "effect": "read",
+                    "inputSchema": {
+                        "additionalProperties": false,
+                        "properties": {},
+                        "required": [],
+                        "type": "object"
+                    },
+                    "outputSchema": {
+                        "additionalProperties": false,
+                        "properties": {
+                            "omitted": {
+                                "minimum": 0,
+                                "type": "integer"
+                            },
+                            "sessions": {
+                                "items": {
+                                    "additionalProperties": false,
+                                    "properties": {
+                                        "id": {
+                                            "pattern": "^x-[a-f0-9]{64}$",
+                                            "type": "string"
+                                        },
+                                        "inputOwner": {
+                                            "const": "external"
+                                        },
+                                        "lastAt": {
+                                            "type": "string"
+                                        },
+                                        "observedAt": {
+                                            "type": "string"
+                                        },
+                                        "omittedTurns": {
+                                            "minimum": 0,
+                                            "type": "integer"
+                                        },
+                                        "problem": {
+                                            "type": "string"
+                                        },
+                                        "producer": {
+                                            "type": "string"
+                                        },
+                                        "sessionId": {
+                                            "type": "string"
+                                        },
+                                        "sourceCursor": {
+                                            "minimum": 0,
+                                            "type": "integer"
+                                        },
+                                        "state": {
+                                            "enum": [
+                                                "running",
+                                                "completed",
+                                                "failed",
+                                                "stopped",
+                                                "unknown"
+                                            ]
+                                        },
+                                        "title": {
+                                            "type": "string"
+                                        },
+                                        "turns": {
+                                            "minimum": 0,
+                                            "type": "integer"
+                                        }
+                                    },
+                                    "required": [
+                                        "id",
+                                        "producer",
+                                        "sessionId",
+                                        "title",
+                                        "lastAt",
+                                        "observedAt",
+                                        "state",
+                                        "turns",
+                                        "sourceCursor",
+                                        "omittedTurns",
+                                        "inputOwner"
+                                    ],
+                                    "type": "object"
+                                },
+                                "maxItems": 64,
+                                "type": "array"
+                            }
+                        },
+                        "required": [
+                            "sessions",
+                            "omitted"
+                        ],
+                        "type": "object"
+                    },
+                    "requires": []
+                },
+                "agent.sessions.read": {
+                    "effect": "read",
+                    "inputSchema": {
+                        "additionalProperties": false,
+                        "properties": {
+                            "before": {
+                                "minimum": 0,
+                                "type": "integer"
+                            },
+                            "limit": {
+                                "maximum": 20,
+                                "minimum": 1,
+                                "type": "integer"
+                            },
+                            "session": {
+                                "pattern": "^x-[a-f0-9]{64}$",
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "session"
+                        ],
+                        "type": "object"
+                    },
+                    "outputSchema": {
+                        "additionalProperties": false,
+                        "properties": {
+                            "first": {
+                                "minimum": 0,
+                                "type": "integer"
+                            },
+                            "session": {
+                                "additionalProperties": false,
+                                "properties": {
+                                    "id": {
+                                        "pattern": "^x-[a-f0-9]{64}$",
+                                        "type": "string"
+                                    },
+                                    "inputOwner": {
+                                        "const": "external"
+                                    },
+                                    "lastAt": {
+                                        "type": "string"
+                                    },
+                                    "observedAt": {
+                                        "type": "string"
+                                    },
+                                    "omittedTurns": {
+                                        "minimum": 0,
+                                        "type": "integer"
+                                    },
+                                    "problem": {
+                                        "type": "string"
+                                    },
+                                    "producer": {
+                                        "type": "string"
+                                    },
+                                    "sessionId": {
+                                        "type": "string"
+                                    },
+                                    "sourceCursor": {
+                                        "minimum": 0,
+                                        "type": "integer"
+                                    },
+                                    "state": {
+                                        "enum": [
+                                            "running",
+                                            "completed",
+                                            "failed",
+                                            "stopped",
+                                            "unknown"
+                                        ]
+                                    },
+                                    "title": {
+                                        "type": "string"
+                                    },
+                                    "turns": {
+                                        "minimum": 0,
+                                        "type": "integer"
+                                    }
+                                },
+                                "required": [
+                                    "id",
+                                    "producer",
+                                    "sessionId",
+                                    "title",
+                                    "lastAt",
+                                    "observedAt",
+                                    "state",
+                                    "turns",
+                                    "sourceCursor",
+                                    "omittedTurns",
+                                    "inputOwner"
+                                ],
+                                "type": "object"
+                            },
+                            "turns": {
+                                "items": {
+                                    "additionalProperties": false,
+                                    "properties": {
+                                        "at": {
+                                            "type": "string"
+                                        },
+                                        "endedAt": {
+                                            "type": "string"
+                                        },
+                                        "id": {
+                                            "type": "string"
+                                        },
+                                        "messages": {
+                                            "items": {
+                                                "additionalProperties": false,
+                                                "properties": {
+                                                    "at": {
+                                                        "type": "string"
+                                                    },
+                                                    "text": {
+                                                        "type": "string"
+                                                    }
+                                                },
+                                                "required": [
+                                                    "at",
+                                                    "text"
+                                                ],
+                                                "type": "object"
+                                            },
+                                            "maxItems": 200,
+                                            "type": "array"
+                                        },
+                                        "omittedChars": {
+                                            "minimum": 0,
+                                            "type": "integer"
+                                        },
+                                        "omittedTools": {
+                                            "minimum": 0,
+                                            "type": "integer"
+                                        },
+                                        "prompt": {
+                                            "type": "string"
+                                        },
+                                        "reply": {
+                                            "type": "string"
+                                        },
+                                        "results": {
+                                            "items": {
+                                                "additionalProperties": false,
+                                                "properties": {
+                                                    "id": {
+                                                        "type": "string"
+                                                    },
+                                                    "path": {
+                                                        "type": "string"
+                                                    },
+                                                    "projectId": {
+                                                        "type": "string"
+                                                    },
+                                                    "toolId": {
+                                                        "type": "string"
+                                                    },
+                                                    "version": {
+                                                        "type": "string"
+                                                    }
+                                                },
+                                                "required": [
+                                                    "path",
+                                                    "toolId"
+                                                ],
+                                                "type": "object"
+                                            },
+                                            "maxItems": 64,
+                                            "type": "array"
+                                        },
+                                        "state": {
+                                            "enum": [
+                                                "running",
+                                                "completed",
+                                                "failed",
+                                                "stopped",
+                                                "unknown"
+                                            ]
+                                        },
+                                        "tools": {
+                                            "items": {
+                                                "additionalProperties": false,
+                                                "properties": {
+                                                    "at": {
+                                                        "type": "string"
+                                                    },
+                                                    "detail": {
+                                                        "type": "string"
+                                                    },
+                                                    "exitCode": {
+                                                        "type": "integer"
+                                                    },
+                                                    "id": {
+                                                        "type": "string"
+                                                    },
+                                                    "name": {
+                                                        "type": "string"
+                                                    },
+                                                    "outcome": {
+                                                        "enum": [
+                                                            "requested",
+                                                            "returned",
+                                                            "failed",
+                                                            "unknown"
+                                                        ]
+                                                    },
+                                                    "output": {
+                                                        "type": "string"
+                                                    },
+                                                    "paths": {
+                                                        "items": {
+                                                            "type": "string"
+                                                        },
+                                                        "maxItems": 32,
+                                                        "type": "array"
+                                                    }
+                                                },
+                                                "required": [
+                                                    "id",
+                                                    "at",
+                                                    "name",
+                                                    "detail",
+                                                    "output",
+                                                    "outcome",
+                                                    "paths"
+                                                ],
+                                                "type": "object"
+                                            },
+                                            "maxItems": 256,
+                                            "type": "array"
+                                        }
+                                    },
+                                    "required": [
+                                        "id",
+                                        "at",
+                                        "state",
+                                        "prompt",
+                                        "reply",
+                                        "messages",
+                                        "tools",
+                                        "results",
+                                        "omittedTools",
+                                        "omittedChars"
+                                    ],
+                                    "type": "object"
+                                },
+                                "maxItems": 20,
+                                "type": "array"
+                            }
+                        },
+                        "required": [
+                            "session",
+                            "first",
+                            "turns"
+                        ],
+                        "type": "object"
+                    },
+                    "requires": []
+                },
                 "binding.activity": {
                     "effect": "read",
                     "inputSchema": {
@@ -24849,17 +25203,17 @@ export const ownerContracts = {
         },
         "agent": {
             "package": "@rho-workspace/plugin-agent",
-            "packageVersion": "0.4.28",
+            "packageVersion": "0.4.29",
             "entry": "./operations",
             "entryPath": "@rho-workspace/plugin-agent/dist/operations.js",
-            "entrySha256": "08bb1c852cb89a17a2e307831ed2df5d6d16cbccaaf2971ec251bb9a1a34261f",
+            "entrySha256": "3fd6d6999950895852bea81e744e74a5c9104c8f97c2c90ff0d4dbd54a990a57",
             "exports": {
-                "operationContracts": "59b4465ecd7f62a59fc19c9bb49143c0c587fc9f3ca06839b8c73ee6dc9e8902"
+                "operationContracts": "0286460194d99bf9ca79abd2a088317dad41f4dd3a7f3a02d75f047aed4238fb"
             }
         },
         "agent-feedback": {
             "package": "@rho-workspace/plugin-agent",
-            "packageVersion": "0.4.28",
+            "packageVersion": "0.4.29",
             "entry": "./feedback-contract",
             "entryPath": "@rho-workspace/plugin-agent/dist/feedback-contract.js",
             "entrySha256": "ecb1561d92b5953d2b786d29cfb57f6f8085d214dc1dec76f6e7bd7a5257cb75",
@@ -24869,7 +25223,7 @@ export const ownerContracts = {
         },
         "agent-native": {
             "package": "@rho-workspace/plugin-agent",
-            "packageVersion": "0.4.28",
+            "packageVersion": "0.4.29",
             "entry": "./contract",
             "entryPath": "@rho-workspace/plugin-agent/dist/contract.js",
             "entrySha256": "9e926081cb755a98d2b00d2a8488d8f4c6d25b3d5f1ec526d334ade633fe8a65",
@@ -24879,7 +25233,7 @@ export const ownerContracts = {
         },
         "agent-session": {
             "package": "@rho-workspace/plugin-agent",
-            "packageVersion": "0.4.28",
+            "packageVersion": "0.4.29",
             "entry": "./session-contract",
             "entryPath": "@rho-workspace/plugin-agent/dist/session-contract.js",
             "entrySha256": "bb5b118f965e208617781af3e8ad6b6739869bcc19f0092eab14468824693123",

package/dist/discovery.d.ts

@@ -1,5 +1,6 @@
 import type { Principal, Project } from './state.js';
 import type { Plugins } from './plugins.js';
+export declare const applicationEffects: Record<string, string>;
 export declare class Discovery {
     plugins: Plugins;
     project: Project;

package/dist/discovery.js

@@ -3,11 +3,11 @@ import { Capabilities, rhoWorkspaceSkill } from './capabilities.js';
 import { protocol } from './protocol.js';
 import { schemaClosure } from './protocol-discovery.js';
 const size = (v) => Buffer.byteLength(JSON.stringify(v)) + 64;
-const applicationEffects = Object.fromEntries([
-    ...['protocol.describe', 'protocol.validate', 'project.entries', 'capability.list', 'skill.list', 'skill.read', 'action.lookup', 'action.observe', 'action.output', 'action.list', 'composition.read', 'observation.snapshot', 'interaction.selection.read', 'workspace.observe', 'task.map.read'].map(m => [m, 'read']),
+export const applicationEffects = Object.fromEntries([
+    ...['extension.list', 'extension.describe', 'extension.content', 'extension.read', 'protocol.describe', 'protocol.validate', 'project.entries', 'capability.list', 'skill.list', 'skill.read', 'action.lookup', 'action.observe', 'action.output', 'action.list', 'composition.read', 'observation.snapshot', 'interaction.selection.read', 'workspace.observe', 'task.map.read'].map(m => [m, 'read']),
     ...['composition.put', 'view.close', 'capability.configure', 'composition.apply', 'composition.undo', 'view.protection.set', 'interaction.selection.set', 'selection.set', 'workspace.enhance', 'task.map.declare', 'task.map.present', 'task.map.respond'].map(m => [m, 'metadata']),
     ...['workspace.save', 'workspace.export', 'workspace.restore', 'action.export'].map(m => [m, 'file']),
-    ...['action.retry', 'action.cancel'].map(m => [m, 'native']),
+    ...['extension.call', 'extension.install', 'extension.manage', 'action.retry', 'action.cancel'].map(m => [m, 'native']),
 ]);
 const rhoSummary = 'The project in Rho: its folder\'s entries, managed runs, the views on the person\'s screen and what is selected in them, the task map, and which plugins are on.';
 const metadata = new Set(['capability.index', 'capability.resolve', 'binding.activity.append', 'task.routing.put', 'feedback.submit', 'view.observe', 'view.observations.read']);

package/dist/extension-contract.d.ts

@@ -0,0 +1,99 @@
+export declare const extensionOperations: {
+    'extension.list': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.describe': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.content': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.call': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.read': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.install': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.manage': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+export declare const extensionResponses: {
+    'extension.list': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.describe': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.install': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.content': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.call': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.read': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.manage': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+export declare const extensionDescriptions: {
+    'extension.list': string;
+    'extension.describe': string;
+    'extension.content': string;
+    'extension.call': string;
+    'extension.read': string;
+    'extension.install': string;
+    'extension.manage': string;
+};
+export declare const extensionManagement: string[];
+export declare const extensionMethods: string[];

package/dist/extension-contract.js

@@ -0,0 +1,52 @@
+// Installed third-party packages are application assembly, independent of the
+// functional owners compiled into Rho. This protocol never imports their code.
+const str = { type: 'string', minLength: 1, maxLength: 1024 };
+const id = { type: 'string', pattern: '^[a-z0-9][a-z0-9._-]{0,95}$' };
+const sha = { type: 'string', pattern: '^[a-f0-9]{64}$' };
+const object = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
+const json = { type: 'object', additionalProperties: true };
+const project = { projectId: str };
+const selected = { ...project, pluginId: id, expectedDigest: sha };
+export const extensionOperations = {
+    'extension.list': object(project, []),
+    'extension.describe': object({ ...project, pluginId: id }),
+    'extension.content': object({ ...selected, kind: { enum: ['skill', 'view'] }, entryId: id }),
+    'extension.call': object({ ...selected, operation: id, input: json, changeId: { type: 'string', pattern: '^[A-Za-z0-9._:@-]{1,128}$' } }),
+    'extension.read': object({ ...project, invocationId: sha }),
+    'extension.install': object({ source: str, replace: id, expectedDigest: sha }, ['source']),
+    'extension.manage': object({ pluginId: id, expectedDigest: sha, action: { enum: ['enable', 'disable', 'remove'] } }),
+};
+const array = (items) => ({ type: 'array', items });
+const text = { type: 'string' };
+const entry = { ...object({ id, title: text, file: text }), additionalProperties: true };
+const manifest = { ...object({ apiVersion: { const: 1 }, id, title: text, description: text, host: text,
+        operations: array({ ...object({ id, title: text, description: text, effect: { enum: ['read', 'native'] }, methods: array(text), inputSchema: json }), additionalProperties: true }),
+        skills: array(entry), views: array(entry),
+    }, ['apiVersion', 'id', 'title', 'description', 'operations', 'skills', 'views']), additionalProperties: true };
+const installed = { id, name: text, version: text, title: text, description: text, digest: sha, source: text, sourceCommit: text, enabled: { type: 'boolean' }, installedAt: text };
+const installedRequired = Object.keys(installed).filter(key => key !== 'sourceCommit');
+const descriptor = object({ ...installed, manifest }, [...installedRequired, 'manifest']);
+const receipt = object({ invocationId: sha, caller: text, projectId: text, pluginId: id, packageDigest: sha, operation: id, requestDigest: sha,
+    state: { enum: ['pending', 'completed', 'unknown'] }, startedAt: text, endedAt: text, value: {}, error: text,
+    delegations: array(object({ method: text, request: {}, state: { enum: ['pending', 'completed', 'unknown'] }, value: {}, error: text }, ['method', 'request', 'state'])),
+}, ['invocationId', 'caller', 'projectId', 'pluginId', 'packageDigest', 'operation', 'requestDigest', 'state', 'startedAt']);
+export const extensionResponses = {
+    'extension.list': object({ plugins: array(object(installed, installedRequired)), directory: array(object({ id, title: text, version: text, description: text, source: text, repository: text, needs: text })), limits: json }),
+    'extension.describe': descriptor,
+    'extension.install': descriptor,
+    'extension.content': object({ pluginId: id, packageDigest: sha, entryId: id, kind: { enum: ['skill', 'view'] }, title: text, text }),
+    'extension.call': receipt,
+    'extension.read': receipt,
+    'extension.manage': object({ pluginId: id, action: { enum: ['enable', 'disable', 'remove'] }, retained: text }),
+};
+export const extensionDescriptions = {
+    'extension.list': 'List independently installed third-party packages and their enabled state, source and immutable digest. Reads start no plugin or runtime. Use extension.describe to discover operation schemas and Skills.',
+    'extension.describe': 'Read an installed third-party package manifest, operation input schemas, required Rho methods, Skills and views. Read its Skill with extension.content before use. Disabled packages cannot run.',
+    'extension.content': 'Read one installed plugin Skill or standalone HTML view at its selected package digest. Reading starts no plugin or runtime.',
+    'extension.call': 'Call an enabled third-party operation at the described package digest, under the caller and project. The package runs trusted native code. Non-read calls retain the original changeId: repeat observes that invocation, including unknown outcomes, without re-execution. Completion is not scientific validity.',
+    'extension.read': 'Observe an original plugin invocation, including pending or unknown outcomes. Never reruns code. Only its original caller can read it.',
+    'extension.install': 'Local person/operator: install a trusted prebuilt npm package, local folder, tarball, or Git source. Lifecycle scripts are disabled. Replacement stages and checks the new package before switching; use replace and expectedDigest for updates.',
+    'extension.manage': 'Local person/operator: enable, disable or remove an installed third-party package at the expected digest. Existing native tasks, R sessions, project files and retained receipts are preserved.',
+};
+export const extensionManagement = ['extension.install', 'extension.manage'];
+export const extensionMethods = Object.keys(extensionOperations);

package/dist/extension-directory.d.ts

@@ -0,0 +1,9 @@
+export declare const extensionDirectory: {
+    id: string;
+    title: string;
+    version: string;
+    description: string;
+    source: string;
+    repository: string;
+    needs: string;
+}[];

package/dist/extension-directory.js

@@ -0,0 +1,11 @@
+// Optional discovery, not a registration requirement. Packages keep their own
+// repositories/releases; an entry records the source a maintainer actually checked.
+export const extensionDirectory = [
+    {
+        id: 'yulab.sclet', title: 'sclet', version: '0.1.0',
+        description: 'State-aware single-cell analysis using sclet in your shared R Notebook.',
+        source: 'git+https://github.com/YuLab-SMU/Rho-plugins.git#82df99f8cbab868c30949692172c6cf11db2f5c0:examples/sclet-plugin',
+        repository: 'https://github.com/YuLab-SMU/Rho-plugins/tree/82df99f8cbab868c30949692172c6cf11db2f5c0/examples/sclet-plugin',
+        needs: 'R, sclet, SingleCellExperiment and jsonlite in the selected R environment.',
+    },
+];

package/dist/extension-worker.d.ts

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

package/dist/extension-worker.js

@@ -0,0 +1,36 @@
+// A process boundary for crashes/timeouts, NOT an OS sandbox. An installed host
+// has this user's native permissions. Never send it service credentials.
+import { pathToFileURL } from 'node:url';
+const pending = new Map();
+let next = 0;
+process.on('message', async (message) => {
+    if (message.type === 'reply') {
+        const waiter = pending.get(message.id);
+        pending.delete(message.id);
+        if (message.error)
+            waiter?.reject(new Error(message.error));
+        else
+            waiter?.resolve(message.value);
+    }
+    if (message.type !== 'start')
+        return;
+    try {
+        const plugin = await import(pathToFileURL(message.entry).href);
+        if (typeof plugin.run !== 'function')
+            throw new Error('The plugin host must export run(operation, input, context).');
+        const value = await plugin.run(message.operation, message.input, {
+            projectRoot: message.projectRoot,
+            invocationId: message.invocationId,
+            changeId: (label) => 'ext:' + message.invocationId + ':' + String(label).slice(0, 40),
+            call: (method, body) => new Promise((resolve, reject) => {
+                const id = ++next;
+                pending.set(id, { resolve, reject });
+                process.send?.({ type: 'call', id, method, body });
+            }),
+        });
+        process.send?.({ type: 'result', value }, () => process.exit(0));
+    }
+    catch (error) {
+        process.send?.({ type: 'error', error: error instanceof Error ? error.message : String(error) }, () => process.exit(1));
+    }
+});