@myagentroam/node 0.1.7 → 0.9.0

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>;