@myagentroam/node 0.1.7 → 0.1.8

package/dist/config.d.ts

@@ -2,19 +2,17 @@ export interface NodeConfig {
     readonly serverUrl: string;
     /** Explicit roots or the platform default resolved while loading the config. */
     readonly allowedRoots: readonly string[];
-    /** Absolute or config-relative location of this Node's private runtime SQLite. */
-    readonly databasePath?: string;
+    /** Absolute or config-relative root for SQLite, upgrades and other private Node data. */
+    readonly dataDirectory?: string;
     readonly nodeId?: string;
     readonly credential?: string;
     readonly registrationToken?: string;
-    readonly upgrade?: {
-        readonly registryUrl?: string;
-    };
 }
 export declare function nodeConfigPath(): string;
 export declare function loadNodeConfig(path?: string): Promise<NodeConfig>;
 /** Uses the Node service account's scope when no Workspace roots are configured. */
 export declare function defaultAllowedRoots(platform?: NodeJS.Platform, homePath?: string, currentDirectory?: string): readonly string[];
 export declare function nodeDatabasePath(config: NodeConfig, configPath?: string): string;
+export declare function nodeDataDirectory(config: NodeConfig, configPath?: string): string;
 /** Credentials are always written with owner-only POSIX permissions where supported. */
 export declare function saveNodeConfig(config: NodeConfig, path?: string): Promise<void>;

package/dist/config.js

@@ -10,6 +10,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         parsed === null ||
         !('serverUrl' in parsed) ||
         typeof parsed.serverUrl !== 'string' ||
+        'databasePath' in parsed ||
         ('allowedRoots' in parsed &&
             (!Array.isArray(parsed.allowedRoots) ||
                 !parsed.allowedRoots.every((root) => typeof root === 'string')))) {
@@ -20,15 +21,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
     const nodeId = optionalString('nodeId');
     const credential = optionalString('credential');
     const registrationToken = optionalString('registrationToken');
-    const databasePath = optionalString('databasePath');
-    const upgradeInput = input['upgrade'];
-    if (upgradeInput !== undefined &&
-        (upgradeInput === null ||
-            typeof upgradeInput !== 'object' ||
-            Array.isArray(upgradeInput) ||
-            ('registryUrl' in upgradeInput &&
-                typeof upgradeInput['registryUrl'] !== 'string')))
-        throw new Error('NODE_CONFIG_INVALID');
+    const dataDirectory = optionalString('dataDirectory');
     const allowedRoots = Array.isArray(input['allowedRoots'])
         ? input['allowedRoots']
         : defaultAllowedRoots();
@@ -38,16 +31,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         ...(nodeId === undefined ? {} : { nodeId }),
         ...(credential === undefined ? {} : { credential }),
         ...(registrationToken === undefined ? {} : { registrationToken }),
-        ...(databasePath === undefined ? {} : { databasePath }),
-        ...(upgradeInput === undefined
-            ? {}
-            : {
-                upgrade: {
-                    ...(upgradeInput['registryUrl'] === undefined
-                        ? {}
-                        : { registryUrl: upgradeInput['registryUrl'] })
-                }
-            })
+        ...(dataDirectory === undefined ? {} : { dataDirectory })
     };
 }
 /** Uses the Node service account's scope when no Workspace roots are configured. */
@@ -55,7 +39,12 @@ export function defaultAllowedRoots(platform = process.platform, homePath = home
     return platform === 'win32' ? [win32.parse(currentDirectory).root] : [homePath];
 }
 export function nodeDatabasePath(config, configPath = nodeConfigPath()) {
-    return config.databasePath ?? resolve(dirname(configPath), 'node-runtime.sqlite');
+    return resolve(nodeDataDirectory(config, configPath), 'node-runtime.sqlite');
+}
+export function nodeDataDirectory(config, configPath = nodeConfigPath()) {
+    if (config.dataDirectory !== undefined)
+        return resolve(dirname(configPath), config.dataDirectory);
+    return resolve(dirname(configPath));
 }
 /** Credentials are always written with owner-only POSIX permissions where supported. */
 export async function saveNodeConfig(config, path = nodeConfigPath()) {

package/dist/connector.js

@@ -18,6 +18,7 @@ import { RunnerRegistry } from './runner/runner-registry.js';
 import { OpenCodeRunner } from './runner/opencode-runner.js';
 import { OpenCodeManagedRunController } from './runner/opencode/managed-run-controller.js';
 import { NodeOperationRouter } from './connector/node-operation-router.js';
+import { SkillNodeOperationService } from './service/skill-node-operation-service.js';
 import { RunnerService } from './service/runner-service.js';
 import { TerminalService } from './service/terminal-service.js';
 import { WorkspaceService } from './service/workspace-service.js';
@@ -313,9 +314,9 @@ export class NodeConnector {
             commandStates: (sessionId) => this.commandStates.list(sessionId)
         });
         this.runners = new RunnerRegistry([
+            this.openCodeClient,
             this.codexClient,
             this.claudeClient,
-            this.openCodeClient,
             ...(this.fakeRunner === undefined ? [] : [this.fakeRunner])
         ]);
         this.managedRunnerSessions = new ManagedRunnerSessionService(this.runtime, this.runners, (session) => this.emitWorkbenchEvent('session', {
@@ -708,6 +709,11 @@ export class NodeConnector {
         this.operationRouter.registerAll(this.sessionCatalogService.operations());
         this.operationRouter.registerAll(this.sessionCommandService.operations());
         this.operationRouter.registerAll(this.workspaceQueueWorkbenchService.operations());
+        this.operationRouter.registerAll(new SkillNodeOperationService(requireDatabase, () => {
+            if (this.config === undefined)
+                throw new Error('NODE_CONFIG_UNAVAILABLE');
+            return this.config;
+        }).operations());
         this.operationRouter.register('node.metrics', () => ({
             metrics: {
                 ...this.metrics.snapshot(),

package/dist/main.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { dirname, resolve } from 'node:path';
 import { NodeConnector } from './connector.js';
-import { loadNodeConfig, nodeConfigPath, nodeDatabasePath } from './config.js';
+import { loadNodeConfig, nodeConfigPath, nodeDatabasePath, nodeDataDirectory } from './config.js';
 import { getNodeHealth } from './health.js';
 import { removeServiceDefinition, writeServiceDefinition } from './service.js';
 import { superviseNode } from './supervisor.js';
+import { configureNodeLog } from './rotating-log.js';
 const [command = 'status', ...args] = process.argv.slice(2);
 const config = readOption(args, '--config') ?? nodeConfigPath();
 const output = readOption(args, '--output') ?? defaultServicePath();
 if (command === 'run') {
+    configureNodeLog(nodeDataDirectory(await loadNodeConfig(config), config));
     const connector = new NodeConnector({ configPath: config });
     await connector.start();
     for (const signal of ['SIGINT', 'SIGTERM']) {
@@ -18,6 +20,7 @@ if (command === 'run') {
 else if (command === 'supervise') {
     if (process.argv[1] === undefined)
         throw new Error('NODE_ENTRYPOINT_UNAVAILABLE');
+    configureNodeLog(nodeDataDirectory(await loadNodeConfig(config), config));
     await superviseNode(config, process.argv[1]);
 }
 else if (command === 'install') {

package/dist/opencode-server.js

@@ -1,7 +1,6 @@
 import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { createServer } from 'node:net';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2/client';
 import { minimalRunnerEnvironment, platformCliInvocation } from './operational.js';
 import { terminateProcessTree } from './process-tree.js';
 const START_TIMEOUT_MS = 10_000;
@@ -35,6 +34,7 @@ export class OpenCodeServerClient {
         }
     }
     async startServer() {
+        const { createOpencodeClient } = await import('@opencode-ai/sdk/v2/client');
         const port = await availablePort();
         const password = randomBytes(24).toString('base64url');
         const invocation = platformCliInvocation(this.options.command ?? 'opencode', [

package/dist/operational.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { writeNodeLog } from './rotating-log.js';
 const secretKey = /(?:password|credential|token|cookie|authorization|secret|api[_-]?key)/i;
 export function runRunnerProbe(command, args, options) {
     return new Promise((resolve) => {
@@ -115,5 +116,7 @@ export function platformCliInvocation(command, args, platform = process.platform
 }
 export function nodeLog(event, fields = {}) {
     const safeFields = redactLogValue(fields);
-    process.stdout.write(`${JSON.stringify({ timestamp: new Date().toISOString(), level: 'info', component: 'mar-node', event, ...safeFields })}\n`);
+    const line = `${JSON.stringify({ timestamp: new Date().toISOString(), level: 'info', component: 'mar-node', event, ...safeFields })}\n`;
+    process.stdout.write(line);
+    writeNodeLog(line);
 }

package/dist/rotating-log.d.ts

@@ -0,0 +1,17 @@
+export declare function configureNodeLog(dataDirectory: string): void;
+export declare function writeNodeLog(content: string): void;
+export declare class RotatingNodeLog {
+    private readonly maxBytes;
+    private readonly retentionMs;
+    private readonly now;
+    private readonly activePath;
+    private bytes;
+    private day;
+    private rotation;
+    private lastCleanup;
+    constructor(directory: string, maxBytes?: number, retentionMs?: number, now?: () => number);
+    write(content: string): void;
+    private currentDay;
+    private rotate;
+    private cleanup;
+}

package/dist/rotating-log.js

@@ -0,0 +1,67 @@
+import { appendFileSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+const DAY_MS = 24 * 60 * 60 * 1_000;
+let sink;
+export function configureNodeLog(dataDirectory) {
+    sink = new RotatingNodeLog(resolve(dataDirectory, 'logs'));
+}
+export function writeNodeLog(content) {
+    sink?.write(content);
+}
+export class RotatingNodeLog {
+    maxBytes;
+    retentionMs;
+    now;
+    activePath;
+    bytes = 0;
+    day = '';
+    rotation = 0;
+    lastCleanup = 0;
+    constructor(directory, maxBytes = 100 * 1024 * 1024, retentionMs = 7 * DAY_MS, now = Date.now) {
+        this.maxBytes = maxBytes;
+        this.retentionMs = retentionMs;
+        this.now = now;
+        mkdirSync(directory, { recursive: true });
+        this.activePath = resolve(directory, 'node.log');
+        try {
+            const stat = statSync(this.activePath);
+            this.bytes = stat.size;
+            this.day = new Date(stat.mtimeMs).toISOString().slice(0, 10);
+        }
+        catch {
+            this.day = this.currentDay();
+        }
+        this.cleanup();
+    }
+    write(content) {
+        const length = Buffer.byteLength(content);
+        const day = this.currentDay();
+        if (this.bytes > 0 && (this.bytes + length > this.maxBytes || day !== this.day))
+            this.rotate();
+        appendFileSync(this.activePath, content, { encoding: 'utf8', mode: 0o600 });
+        this.bytes += length;
+        this.day = day;
+        if (this.now() - this.lastCleanup >= DAY_MS)
+            this.cleanup();
+    }
+    currentDay() {
+        return new Date(this.now()).toISOString().slice(0, 10);
+    }
+    rotate() {
+        const suffix = `${this.day}-${this.now()}-${String(this.rotation++).padStart(3, '0')}`;
+        renameSync(this.activePath, resolve(this.activePath, '..', `node-${suffix}.log`));
+        this.bytes = 0;
+    }
+    cleanup() {
+        const directory = resolve(this.activePath, '..');
+        const cutoff = this.now() - this.retentionMs;
+        for (const entry of readdirSync(directory)) {
+            if (!entry.startsWith('node-') || !entry.endsWith('.log'))
+                continue;
+            const path = resolve(directory, entry);
+            if (statSync(path).mtimeMs < cutoff)
+                unlinkSync(path);
+        }
+        this.lastCleanup = this.now();
+    }
+}

package/dist/service/node-connection-lifecycle-service.js

@@ -33,8 +33,7 @@ export class NodeConnectionLifecycleService {
         const registered = {
             serverUrl: config.serverUrl,
             allowedRoots: config.allowedRoots,
-            ...(config.databasePath === undefined ? {} : { databasePath: config.databasePath }),
-            ...(config.upgrade === undefined ? {} : { upgrade: config.upgrade }),
+            ...(config.dataDirectory === undefined ? {} : { dataDirectory: config.dataDirectory }),
             nodeId,
             credential
         };

package/dist/service/runner-service.d.ts

@@ -20,16 +20,16 @@ export declare class RunnerService {
         }[];
         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/service/skill-directory-service.d.ts

@@ -0,0 +1,17 @@
+import { type SkillInstallMetadata } from '@myagentroam/protocol';
+export type LocalSkillStatus = 'VALID' | 'UNKNOWN_VERSION' | 'PARTIAL' | 'INVALID' | 'INVALID_LINK' | 'GIT_EXCLUDE_BROKEN';
+export interface LocalSkillInspection {
+    readonly name: string;
+    readonly description: string;
+    readonly localStatus: LocalSkillStatus;
+    readonly install?: SkillInstallMetadata;
+}
+export interface LocalSkillTargetInspection {
+    readonly targetKind: 'NODE' | 'WORKSPACE';
+    readonly compatibilityMode: 'SYMLINK' | 'JUNCTION' | 'MANAGED_COPY' | 'UNAVAILABLE';
+    readonly skills: readonly LocalSkillInspection[];
+}
+export declare class SkillDirectoryService {
+    inspectNodeHome(home: string): Promise<LocalSkillTargetInspection>;
+    inspectWorkspace(workspace: string): Promise<LocalSkillTargetInspection>;
+}

package/dist/service/skill-directory-service.js

@@ -0,0 +1,203 @@
+import { lstat, open, readFile, readdir, readlink, realpath } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { skillInstallMetadataSchema } from '@myagentroam/protocol';
+const MAX_METADATA_BYTES = 64 * 1024;
+const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
+export class SkillDirectoryService {
+    async inspectNodeHome(home) {
+        const agentsRoot = path.join(home, '.agents', 'skills');
+        const claudeRoot = path.join(home, '.claude', 'skills');
+        const skills = await scanRoot(agentsRoot, 'AGENTS');
+        return {
+            targetKind: 'NODE',
+            compatibilityMode: await nodeCompatibilityMode(agentsRoot, claudeRoot),
+            skills
+        };
+    }
+    async inspectWorkspace(workspace) {
+        const agents = await scanRoot(path.join(workspace, '.agents', 'skills'), 'AGENTS');
+        const claude = await scanRoot(path.join(workspace, '.claude', 'skills'), 'CLAUDE');
+        const skills = mergeWorkspaceCopies(agents, claude);
+        const gitExcludeBroken = await hasBrokenGitExclude(workspace, skills.map((skill) => skill.name));
+        return {
+            targetKind: 'WORKSPACE',
+            compatibilityMode: 'MANAGED_COPY',
+            skills: gitExcludeBroken
+                ? skills.map((skill) => ({ ...skill, localStatus: 'GIT_EXCLUDE_BROKEN' }))
+                : skills
+        };
+    }
+}
+async function hasBrokenGitExclude(workspace, names) {
+    if (names.length === 0)
+        return false;
+    try {
+        await lstat(path.join(workspace, '.git'));
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        return true;
+    }
+    try {
+        const result = await promisify(execFile)('git', ['-C', workspace, 'rev-parse', '--git-path', 'info/exclude'], { timeout: 5_000, windowsHide: true });
+        const exclude = path.resolve(workspace, result.stdout.trim());
+        const content = await readFile(exclude, 'utf8');
+        return names.some((name) => !content.includes(`/.agents/skills/${name}/`) ||
+            !content.includes(`/.claude/skills/${name}/`));
+    }
+    catch {
+        return true;
+    }
+}
+async function scanRoot(root, source) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissing(error))
+            return [];
+        throw error;
+    }
+    const results = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (entry.name.startsWith('.mar-'))
+            continue;
+        const itemPath = path.join(root, entry.name);
+        const stat = await lstat(itemPath);
+        if (stat.isSymbolicLink() || (!stat.isDirectory() && process.platform === 'win32')) {
+            results.push({ name: entry.name, description: '', localStatus: 'INVALID_LINK', source });
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        if (!SKILL_NAME.test(entry.name) || WINDOWS_DEVICE_NAME.test(entry.name)) {
+            results.push({ name: entry.name, description: '', localStatus: 'INVALID', source });
+            continue;
+        }
+        results.push({ ...(await inspectSkill(itemPath, entry.name)), source });
+    }
+    return results;
+}
+async function inspectSkill(directory, directoryName) {
+    try {
+        const frontmatter = parseSkillFrontmatter(await readBounded(path.join(directory, 'SKILL.md')));
+        if (frontmatter.name !== directoryName ||
+            !SKILL_NAME.test(frontmatter.name) ||
+            WINDOWS_DEVICE_NAME.test(frontmatter.name))
+            return { name: directoryName, description: frontmatter.description, localStatus: 'INVALID' };
+        const install = await readInstallMetadata(path.join(directory, '.mar-skill-install.json'));
+        return {
+            name: directoryName,
+            description: frontmatter.description,
+            localStatus: install === undefined ? 'UNKNOWN_VERSION' : 'VALID',
+            ...(install === undefined ? {} : { install })
+        };
+    }
+    catch {
+        return { name: directoryName, description: '', localStatus: 'INVALID' };
+    }
+}
+async function readInstallMetadata(file) {
+    try {
+        return skillInstallMetadataSchema.parse(JSON.parse(await readBounded(file)));
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        return undefined;
+    }
+}
+async function readBounded(file) {
+    const handle = await open(file, 'r');
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > MAX_METADATA_BYTES)
+            throw new Error('SKILL_METADATA_INVALID');
+        const buffer = Buffer.alloc(stat.size);
+        await handle.read(buffer, 0, buffer.length, 0);
+        return buffer.toString('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+function parseSkillFrontmatter(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(content);
+    if (match === null)
+        throw new Error('SKILL_METADATA_INVALID');
+    const values = new Map();
+    for (const line of match[1].split(/\r?\n/u)) {
+        const field = /^(name|description):\s*(.*?)\s*$/u.exec(line);
+        if (field !== null)
+            values.set(field[1], unquote(field[2]));
+    }
+    const name = values.get('name');
+    const description = values.get('description');
+    if (name === undefined || description === undefined || description.length > 4096)
+        throw new Error('SKILL_METADATA_INVALID');
+    return { name, description };
+}
+function unquote(value) {
+    if (value.length >= 2 &&
+        ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))))
+        return value.slice(1, -1);
+    return value;
+}
+function mergeWorkspaceCopies(agents, claude) {
+    const byName = new Map();
+    for (const item of agents)
+        byName.set(item.name, { agents: item });
+    for (const item of claude)
+        byName.set(item.name, { ...byName.get(item.name), claude: item });
+    return [...byName.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, copies]) => {
+        if (copies.agents === undefined || copies.claude === undefined)
+            return {
+                ...withoutSource((copies.agents ?? copies.claude)),
+                name,
+                localStatus: 'PARTIAL'
+            };
+        if (copies.agents.localStatus !== copies.claude.localStatus ||
+            JSON.stringify(copies.agents.install) !== JSON.stringify(copies.claude.install))
+            return { name, description: copies.agents.description, localStatus: 'PARTIAL' };
+        return withoutSource(copies.agents);
+    });
+}
+function withoutSource(entry) {
+    return {
+        name: entry.name,
+        description: entry.description,
+        localStatus: entry.localStatus,
+        ...(entry.install === undefined ? {} : { install: entry.install })
+    };
+}
+async function nodeCompatibilityMode(agentsRoot, claudeRoot) {
+    try {
+        const stat = await lstat(claudeRoot);
+        if (stat.isSymbolicLink()) {
+            const target = await realpath(path.resolve(path.dirname(claudeRoot), await readlink(claudeRoot)));
+            const agents = await realpath(agentsRoot);
+            return target === agents
+                ? process.platform === 'win32'
+                    ? 'JUNCTION'
+                    : 'SYMLINK'
+                : 'UNAVAILABLE';
+        }
+        return stat.isDirectory() ? 'MANAGED_COPY' : 'UNAVAILABLE';
+    }
+    catch (error) {
+        if (isMissing(error))
+            return 'UNAVAILABLE';
+        return 'UNAVAILABLE';
+    }
+}
+function isMissing(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}

package/dist/service/skill-install-service.d.ts

@@ -0,0 +1,21 @@
+import { type SkillInstallMetadata } from '@myagentroam/protocol';
+export interface SkillBundleFile {
+    readonly path: string;
+    readonly contentBase64: string;
+}
+export interface InstallableSkillBundle {
+    readonly schemaVersion: 1;
+    readonly files: readonly SkillBundleFile[];
+}
+export declare class SkillInstallService {
+    recoverNodeHome(home: string): Promise<void>;
+    recoverWorkspace(workspace: string): Promise<void>;
+    installNodeHome(home: string, name: string, bundle: InstallableSkillBundle, metadata: SkillInstallMetadata): Promise<void>;
+    installWorkspace(workspace: string, name: string, bundle: InstallableSkillBundle, metadata: SkillInstallMetadata, options?: {
+        readonly confirmTracked?: boolean;
+    }): Promise<void>;
+    removeWorkspace(workspace: string, name: string): Promise<void>;
+    removeNodeHome(home: string, name: string): Promise<void>;
+    repairWorkspaceGitExclude(workspace: string): Promise<void>;
+}
+export declare function workspaceSkillTracked(workspace: string, name: string): Promise<boolean>;