@myagentroam/node 0.1.6 → 0.1.8

package/dist/service/skill-node-operation-service.js

@@ -0,0 +1,203 @@
+import { homedir } from 'node:os';
+import { createHash, randomUUID } from 'node:crypto';
+import { skillInstallMetadataSchema } from '@myagentroam/protocol';
+import { SkillDirectoryService } from './skill-directory-service.js';
+import { SkillInstallService, workspaceSkillTracked } from './skill-install-service.js';
+export class SkillNodeOperationService {
+    database;
+    config;
+    directories = new SkillDirectoryService();
+    installer = new SkillInstallService();
+    activeTargets = new Set();
+    jobs = new Map();
+    constructor(database, config) {
+        this.database = database;
+        this.config = config;
+    }
+    operations() {
+        return {
+            'node.skills.inspect': async () => {
+                await this.installer.recoverNodeHome(homedir());
+                return this.directories.inspectNodeHome(homedir());
+            },
+            'node.skills.install': (data) => this.install('NODE', data),
+            'node.skills.remove': (data) => this.remove('NODE', data),
+            'workspace.skills.inspect': async (data) => {
+                const workspace = this.workspacePath(record(data)['workspaceId']);
+                await this.installer.recoverWorkspace(workspace);
+                return this.directories.inspectWorkspace(workspace);
+            },
+            'workspace.skills.install': (data) => this.install('WORKSPACE', data),
+            'workspace.skills.remove': (data) => this.remove('WORKSPACE', data),
+            'workspace.skills.git-exclude-repair': async (data) => {
+                const workspace = this.workspacePath(record(data)['workspaceId']);
+                await this.installer.recoverWorkspace(workspace);
+                await this.installer.repairWorkspaceGitExclude(workspace);
+                return { repaired: true };
+            },
+            'skill.install.job.get': (data) => this.job(data)
+        };
+    }
+    async install(target, data) {
+        const input = record(data);
+        const name = text(input['name'], 'SKILL_NAME_CONFLICT');
+        const ticket = text(input['artifactTicket'], 'SKILL_INSTALL_FAILED');
+        const metadata = skillInstallMetadataSchema.parse(input['metadata']);
+        const workspace = target === 'WORKSPACE' ? this.workspacePath(input['workspaceId']) : undefined;
+        if (workspace === undefined)
+            await this.installer.recoverNodeHome(homedir());
+        else
+            await this.installer.recoverWorkspace(workspace);
+        if (workspace !== undefined &&
+            input['confirmTracked'] !== true &&
+            (await workspaceSkillTracked(workspace, name)))
+            throw new Error('WORKSPACE_SKILL_TRACKED_CONFIRM_REQUIRED');
+        const targetKey = `${target}:${workspace ?? homedir()}`;
+        this.cleanupJobs();
+        if (this.activeTargets.has(targetKey))
+            throw new Error('WORKSPACE_BUSY');
+        if (this.activeTargets.size >= 50)
+            throw new Error('SKILL_TARGET_LIMIT_EXCEEDED');
+        const installJobId = randomUUID();
+        this.activeTargets.add(targetKey);
+        this.jobs.set(installJobId, { status: 'RUNNING', expiresAt: Date.now() + 5 * 60_000 });
+        void (async () => {
+            let terminal;
+            try {
+                await this.performInstall({
+                    target,
+                    name,
+                    ticket,
+                    metadata,
+                    ...(workspace === undefined ? {} : { workspace })
+                });
+                terminal = { status: 'SUCCEEDED' };
+            }
+            catch (error) {
+                terminal = {
+                    status: 'FAILED',
+                    errorCode: error instanceof Error ? error.message : 'SKILL_INSTALL_FAILED'
+                };
+            }
+            this.activeTargets.delete(targetKey);
+            this.jobs.set(installJobId, { ...terminal, expiresAt: Date.now() + 5 * 60_000 });
+        })();
+        return { accepted: true, installJobId };
+    }
+    job(data) {
+        const installJobId = text(record(data)['installJobId'], 'MESSAGE_INVALID');
+        this.cleanupJobs();
+        const job = this.jobs.get(installJobId);
+        if (job === undefined)
+            throw new Error('SKILL_INSTALL_FAILED');
+        return {
+            installJobId,
+            status: job.status,
+            ...(job.errorCode === undefined ? {} : { errorCode: job.errorCode })
+        };
+    }
+    cleanupJobs() {
+        const now = Date.now();
+        for (const [id, job] of this.jobs)
+            if (job.expiresAt < now)
+                this.jobs.delete(id);
+        while (this.jobs.size > 1_000)
+            this.jobs.delete(this.jobs.keys().next().value);
+    }
+    async performInstall(input) {
+        const bundle = await this.download(input.ticket, input.metadata.contentHash);
+        if (input.target === 'NODE')
+            await this.installer.installNodeHome(homedir(), input.name, bundle, input.metadata);
+        else
+            await this.installer.installWorkspace(input.workspace, input.name, bundle, input.metadata, {
+                confirmTracked: true
+            });
+    }
+    async remove(target, data) {
+        const input = record(data);
+        const name = text(input['name'], 'SKILL_NAME_CONFLICT');
+        const workspace = target === 'WORKSPACE' ? this.workspacePath(input['workspaceId']) : undefined;
+        const targetKey = `${target}:${workspace ?? homedir()}`;
+        if (this.activeTargets.has(targetKey))
+            throw new Error('WORKSPACE_BUSY');
+        this.activeTargets.add(targetKey);
+        try {
+            if (target === 'NODE') {
+                await this.installer.recoverNodeHome(homedir());
+                await this.installer.removeNodeHome(homedir(), name);
+            }
+            else {
+                await this.installer.recoverWorkspace(workspace);
+                await this.installer.removeWorkspace(workspace, name);
+            }
+        }
+        finally {
+            this.activeTargets.delete(targetKey);
+        }
+        return { removed: true };
+    }
+    workspacePath(value) {
+        const workspace = this.database().getWorkspace(text(value, 'WORKSPACE_INVALID'));
+        if (workspace === undefined)
+            throw new Error('WORKSPACE_INVALID');
+        return workspace.path;
+    }
+    async download(ticket, expectedContentHash) {
+        const config = this.config();
+        if (config.nodeId === undefined || config.credential === undefined)
+            throw new Error('NODE_UNAUTHENTICATED');
+        const response = await fetch(`${config.serverUrl.replace(/\/$/u, '')}/api/skill-artifacts/${encodeURIComponent(ticket)}`, {
+            headers: {
+                'x-mar-node-id': config.nodeId,
+                authorization: `Bearer ${config.credential}`
+            },
+            signal: AbortSignal.timeout(60_000)
+        });
+        if (!response.ok)
+            throw new Error('SKILL_INSTALL_FAILED');
+        const bundle = (await response.json());
+        validateBundle(bundle, expectedContentHash);
+        return bundle;
+    }
+}
+function validateBundle(bundle, expectedContentHash) {
+    if (bundle === null ||
+        typeof bundle !== 'object' ||
+        bundle.schemaVersion !== 1 ||
+        !Array.isArray(bundle.files) ||
+        bundle.files.length < 1 ||
+        bundle.files.length > 1_000)
+        throw new Error('SKILL_CONTENT_INVALID');
+    let total = 0;
+    const paths = new Set();
+    for (const file of bundle.files) {
+        if (file === null ||
+            typeof file !== 'object' ||
+            typeof file.path !== 'string' ||
+            typeof file.contentBase64 !== 'string' ||
+            paths.has(file.path))
+            throw new Error('SKILL_CONTENT_INVALID');
+        paths.add(file.path);
+        const content = Buffer.from(file.contentBase64, 'base64');
+        if (content.toString('base64') !== file.contentBase64 || content.length > 5 * 1024 * 1024)
+            throw new Error('SKILL_CONTENT_INVALID');
+        total += content.length;
+        if (total > 25 * 1024 * 1024)
+            throw new Error('SKILL_CONTENT_INVALID');
+    }
+    if (!paths.has('SKILL.md') || paths.has('.mar-skill-install.json'))
+        throw new Error('SKILL_CONTENT_INVALID');
+    const canonical = bundle.files.map((file) => `${file.path}\0${file.contentBase64}`).join('\0');
+    if (createHash('sha256').update(canonical).digest('hex') !== expectedContentHash)
+        throw new Error('SKILL_CONTENT_INVALID');
+}
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('MESSAGE_INVALID');
+    return value;
+}
+function text(value, code) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error(code);
+    return value;
+}

package/dist/service/workbench-manifest-service.d.ts

@@ -36,16 +36,16 @@ export declare class WorkbenchManifestService {
             }[];
             accessOptions: {
                 id: string;
-                label: string;
                 description: string;
+                label: string;
             }[];
             commands: {
                 id: string;
+                description: string;
                 available: boolean;
                 runner: "codex" | "claude-code" | "opencode";
                 reasonCode: string | null;
                 label: string;
-                description: string;
                 inputHint: string;
                 source: "CODEX_APP_SERVER" | "CLAUDE_AGENT_SDK" | "OPENCODE_SERVER";
                 interaction: "RUNNER_TEXT" | "IMMEDIATE_ACTION" | "TOGGLE" | "VALUE";

package/dist/supervisor.js

@@ -35,7 +35,6 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
             const prefix = resolve(dataDirectory, 'node-versions', targetVersion);
             await rm(prefix, { recursive: true, force: true });
             await mkdir(prefix, { recursive: true, mode: 0o700 });
-            const registry = validatedRegistry(config.upgrade?.registryUrl);
             const invocation = platformCliInvocation('npm', [
                 'install',
                 '--prefix',
@@ -43,7 +42,6 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
                 '--ignore-scripts',
                 '--no-audit',
                 '--no-fund',
-                ...(registry === undefined ? [] : ['--registry', registry]),
                 `@myagentroam/node@${targetVersion}`
             ]);
             const installResult = await runProcess(invocation.command, invocation.args, false);
@@ -53,13 +51,7 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
             }
             if (installResult.code !== 0)
                 throw new Error('NODE_UPGRADE_INSTALL_FAILED');
-            const rebuild = platformCliInvocation('npm', [
-                'rebuild',
-                '--prefix',
-                prefix,
-                ...(registry === undefined ? [] : ['--registry', registry]),
-                'node-pty'
-            ]);
+            const rebuild = platformCliInvocation('npm', ['rebuild', '--prefix', prefix, 'node-pty']);
             const rebuildResult = await runProcess(rebuild.command, rebuild.args, false);
             if (rebuildResult.signalled) {
                 stopping = true;
@@ -138,17 +130,6 @@ async function writeAtomic(path, contents) {
     await writeFile(temporary, contents, { mode: 0o600 });
     await rename(temporary, path);
 }
-function validatedRegistry(value) {
-    if (value === undefined)
-        return undefined;
-    const url = new URL(value);
-    if (url.protocol !== 'https:' &&
-        !(url.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(url.hostname)))
-        throw new Error('NODE_UPGRADE_REGISTRY_INVALID');
-    if (url.username !== '' || url.password !== '' || url.search !== '' || url.hash !== '')
-        throw new Error('NODE_UPGRADE_REGISTRY_INVALID');
-    return url.toString().replace(/\/$/u, '');
-}
 function delay(milliseconds) {
     return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.1.6"
+    "@myagentroam/protocol": "^0.1.8"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"