@michaelschnyder/teams-cli 0.1.0

package/dist/policy.js

@@ -0,0 +1,328 @@
+import { randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, readFile, readdir, realpath, rename, stat, writeFile, } from "node:fs/promises";
+import { dirname, isAbsolute, join, matchesGlob, parse, resolve, } from "node:path";
+import { stringify } from "yaml";
+import { parseStrictYaml, rejectUnknownKeys, requireObject } from "./yaml.js";
+const POLICY_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function stringArray(value, label) {
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string" && item.length > 0)) {
+        throw new Error(`${label} must be an array of non-empty strings`);
+    }
+    return value;
+}
+function optionalString(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`${label} must be a non-empty string`);
+    return value;
+}
+function validatePolicyName(name) {
+    if (!POLICY_NAME.test(name)) {
+        throw new Error("Policy name must use 1-64 letters, numbers, dots, underscores, or hyphens");
+    }
+    return name;
+}
+function validateSubjectPaths(value) {
+    const paths = stringArray(value, "Policy.subject.paths");
+    if (paths.length === 0)
+        throw new Error("Policy.subject.paths must contain at least one path glob");
+    for (const pattern of paths) {
+        if (!isAbsolute(pattern))
+            throw new Error(`Policy subject path must be absolute: ${pattern}`);
+        try {
+            matchesGlob(resolve(pattern), pattern);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid policy subject path glob ${pattern}: ${detail}`);
+        }
+    }
+    return paths;
+}
+export function parsePolicy(value) {
+    const root = requireObject(value, "Policy");
+    rejectUnknownKeys(root, ["version", "name", "active", "subject", "identity", "allow"], "Policy");
+    if (root.version !== 1)
+        throw new Error("Policy version must be 1");
+    if (typeof root.name !== "string")
+        throw new Error("Policy.name must be a string");
+    const name = validatePolicyName(root.name);
+    if (typeof root.active !== "boolean")
+        throw new Error("Policy.active must be a boolean");
+    const rawSubject = requireObject(root.subject, "Policy.subject");
+    rejectUnknownKeys(rawSubject, ["paths"], "Policy.subject");
+    const subject = { paths: validateSubjectPaths(rawSubject.paths) };
+    let identity;
+    if (root.identity !== undefined) {
+        const raw = requireObject(root.identity, "Policy.identity");
+        rejectUnknownKeys(raw, ["tenantId", "userId"], "Policy.identity");
+        const tenantId = optionalString(raw.tenantId, "Policy.identity.tenantId");
+        const userId = optionalString(raw.userId, "Policy.identity.userId");
+        identity = { ...(tenantId ? { tenantId } : {}), ...(userId ? { userId } : {}) };
+    }
+    let allow;
+    if (root.allow !== undefined) {
+        const raw = requireObject(root.allow, "Policy.allow");
+        rejectUnknownKeys(raw, ["messageSend", "rawTokenExport"], "Policy.allow");
+        let messageSend;
+        if (raw.messageSend !== undefined) {
+            const message = requireObject(raw.messageSend, "Policy.allow.messageSend");
+            rejectUnknownKeys(message, ["chats", "channels"], "Policy.allow.messageSend");
+            messageSend = {
+                chats: stringArray(message.chats, "Policy.allow.messageSend.chats"),
+                channels: stringArray(message.channels, "Policy.allow.messageSend.channels"),
+            };
+        }
+        if (raw.rawTokenExport !== undefined && typeof raw.rawTokenExport !== "boolean") {
+            throw new Error("Policy.allow.rawTokenExport must be a boolean");
+        }
+        allow = {
+            ...(messageSend ? { messageSend } : {}),
+            ...(typeof raw.rawTokenExport === "boolean" ? { rawTokenExport: raw.rawTokenExport } : {}),
+        };
+    }
+    return {
+        version: 1,
+        name,
+        active: root.active,
+        subject,
+        ...(identity ? { identity } : {}),
+        ...(allow ? { allow } : {}),
+    };
+}
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+export async function canonicalSubjectPath(start = process.cwd()) {
+    return realpath(resolve(start));
+}
+export function policyFile(paths, name) {
+    return join(paths.policiesDirectory, `${validatePolicyName(name)}.yaml`);
+}
+function containsGlob(value) {
+    return /[*?\[\]{}()!]/.test(value);
+}
+async function canonicalSubjectPattern(pattern) {
+    const root = parse(pattern).root;
+    const segments = pattern.slice(root.length).split(process.platform === "win32" ? /[\\/]/ : "/");
+    const firstGlob = segments.findIndex(containsGlob);
+    if (firstGlob === -1) {
+        try {
+            return await realpath(pattern);
+        }
+        catch {
+            return resolve(pattern);
+        }
+    }
+    const prefix = join(root, ...segments.slice(0, firstGlob));
+    const suffix = segments.slice(firstGlob);
+    let canonicalPrefix;
+    try {
+        canonicalPrefix = await realpath(prefix);
+    }
+    catch {
+        canonicalPrefix = resolve(prefix);
+    }
+    return suffix.length > 0 ? join(canonicalPrefix, ...suffix) : canonicalPrefix;
+}
+function ownerCanWrite(fileStats) {
+    const getuid = process.getuid;
+    return process.platform !== "win32" && typeof getuid === "function" &&
+        fileStats.uid === getuid() && (fileStats.mode & 0o200) !== 0;
+}
+async function loadPolicyFile(file, filename) {
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        throw new Error(`Policy denied operation: cannot read ${file}`);
+    }
+    let policy;
+    try {
+        policy = parsePolicy(parseStrictYaml(raw, file));
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Policy denied operation: ${detail}`);
+    }
+    if (filename !== `${policy.name}.yaml`) {
+        throw new Error(`Policy denied operation: ${file} does not match policy name ${policy.name}`);
+    }
+    const permissionWarnings = [];
+    if (policy.active && process.platform !== "win32") {
+        let fileStats;
+        try {
+            fileStats = await stat(file);
+        }
+        catch {
+            throw new Error(`Policy denied operation: cannot inspect permissions for ${file}`);
+        }
+        if ((fileStats.mode & 0o022) !== 0) {
+            throw new Error(`Policy denied operation: active policy ${file} is writable by group or other users`);
+        }
+        if (ownerCanWrite(fileStats)) {
+            permissionWarnings.push(`Active policy ${policy.name} is owner-writable at ${file}; make it read-only outside the CLI`);
+        }
+    }
+    const canonicalSubjectPatterns = await Promise.all(policy.subject.paths.map(canonicalSubjectPattern));
+    return { file, policy, canonicalSubjectPatterns, permissionWarnings };
+}
+export async function loadPolicyStore(paths) {
+    let entries;
+    try {
+        entries = await readdir(paths.policiesDirectory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw new Error(`Policy denied operation: cannot inspect ${paths.policiesDirectory}`);
+    }
+    if (process.platform !== "win32") {
+        let directoryStats;
+        try {
+            directoryStats = await stat(paths.policiesDirectory);
+        }
+        catch {
+            throw new Error(`Policy denied operation: cannot inspect permissions for ${paths.policiesDirectory}`);
+        }
+        if ((directoryStats.mode & 0o022) !== 0) {
+            throw new Error(`Policy denied operation: policy directory ${paths.policiesDirectory} is writable by group or other users`);
+        }
+    }
+    const policies = [];
+    for (const entry of entries.filter(({ name }) => name.endsWith(".yaml")).sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = join(paths.policiesDirectory, entry.name);
+        if (!entry.isFile()) {
+            throw new Error(`Policy denied operation: ${file} is not a regular policy file`);
+        }
+        policies.push(await loadPolicyFile(file, entry.name));
+    }
+    return policies;
+}
+function appliesToPath(record, subjectPath) {
+    return record.canonicalSubjectPatterns.some((pattern) => matchesGlob(subjectPath, pattern));
+}
+export async function resolvePolicies(paths, start = process.cwd()) {
+    const subjectPath = await canonicalSubjectPath(start);
+    const policies = (await loadPolicyStore(paths)).filter((record) => appliesToPath(record, subjectPath));
+    return { subjectPath, policies };
+}
+export async function resolvePolicyByName(paths, name) {
+    const file = policyFile(paths, name);
+    const policy = (await loadPolicyStore(paths)).find((record) => record.file === file);
+    if (!policy)
+        throw new Error(`Policy ${name} does not exist at ${file}`);
+    return policy;
+}
+export function policyStatusWarnings(resolved) {
+    return resolved.policies.flatMap((record) => [
+        ...(!record.policy.active
+            ? [`Policy ${record.policy.name} applies to ${resolved.subjectPath} but is inactive and not enforcing restrictions`]
+            : []),
+        ...record.permissionWarnings,
+    ]);
+}
+function identityDenial(policy, identity) {
+    if (policy.identity?.tenantId && policy.identity.tenantId !== identity.tenantId) {
+        return `tenant ${identity.tenantId} is not allowed`;
+    }
+    if (policy.identity?.userId && policy.identity.userId !== identity.userId) {
+        return `user ${identity.userId} is not allowed`;
+    }
+    return undefined;
+}
+function evaluate(resolved, denial) {
+    const warnings = [];
+    for (const { policy } of resolved.policies) {
+        const reason = denial(policy);
+        if (!reason)
+            continue;
+        if (policy.active)
+            throw new Error(`Policy ${policy.name} denied operation: ${reason}`);
+        warnings.push(`Inactive policy ${policy.name} would deny operation: ${reason}`);
+    }
+    return warnings;
+}
+export function requirePolicyIdentity(resolved, identity) {
+    return evaluate(resolved, (policy) => identityDenial(policy, identity));
+}
+export function requireMessageSend(resolved, identity, target) {
+    return evaluate(resolved, (policy) => {
+        const identityReason = identityDenial(policy, identity);
+        if (identityReason)
+            return identityReason;
+        const allowed = policy.allow?.messageSend;
+        const identifiers = target.kind === "chat" ? allowed?.chats : allowed?.channels;
+        return identifiers?.includes(target.id)
+            ? undefined
+            : `${target.kind} ${target.id} is not allowlisted`;
+    });
+}
+export function requireRawTokenExport(resolved, identity) {
+    return evaluate(resolved, (policy) => {
+        const identityReason = identityDenial(policy, identity);
+        if (identityReason)
+            return identityReason;
+        return policy.allow?.rawTokenExport === true ? undefined : "raw token export is not allowed";
+    });
+}
+export async function initializePolicy(paths, name, context, subjectPaths = [], start = process.cwd()) {
+    await loadPolicyStore(paths);
+    if (!context.tenantId || !context.userId) {
+        throw new Error("Policy initialization requires an effective tenant and user");
+    }
+    const file = policyFile(paths, name);
+    if (await exists(file))
+        throw new Error(`Policy ${name} already exists at ${file}`);
+    const subjectPath = await canonicalSubjectPath(start);
+    const pathsToStore = subjectPaths.length > 0
+        ? validateSubjectPaths([...subjectPaths])
+        : [subjectPath, join(subjectPath, "**")];
+    const policy = {
+        version: 1,
+        name,
+        active: false,
+        subject: { paths: pathsToStore },
+        identity: { tenantId: context.tenantId, userId: context.userId },
+        allow: { messageSend: { chats: [], channels: [] }, rawTokenExport: false },
+    };
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    await chmod(dirname(file), 0o700);
+    await writeFile(file, stringify(policy), { mode: 0o600 });
+    await chmod(file, 0o600);
+    return {
+        file,
+        policy,
+        canonicalSubjectPatterns: await Promise.all(pathsToStore.map(canonicalSubjectPattern)),
+        permissionWarnings: [],
+    };
+}
+export async function activatePolicy(record) {
+    if (!record.policy.active) {
+        const policy = { ...record.policy, active: true };
+        const temporary = `${record.file}.${randomUUID()}.tmp`;
+        await writeFile(temporary, stringify(policy), { mode: 0o600 });
+        await rename(temporary, record.file);
+        await chmod(record.file, 0o600);
+        record = { ...record, policy };
+    }
+    return record;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+export function policyProtectionInstruction(file) {
+    if (process.platform === "win32")
+        return null;
+    return `chmod 400 -- ${shellQuote(file)}`;
+}

package/dist/skills/teams-authentication/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: teams-authentication
+description: Authenticate teams-cli, select profiles, validate identity, and handle stored credentials safely.
+license: MIT
+metadata:
+  version: "0.1.0"
+  author: teams-cli
+---
+
+# Teams CLI authentication
+
+Interactive login is the normal path:
+
+```bash
+teams-cli --profile work --tenant <tenant-id> auth login
+teams-cli --profile work auth whoami
+```
+
+The successful login stores identity-scoped tokens and an isolated browser profile under `~/.teams-cli/`. Profiles are configuration defaults, not security boundaries.
+
+Useful commands:
+
+```bash
+teams-cli profile list
+teams-cli profile show work
+teams-cli --profile work auth refresh
+teams-cli --profile work auth logout
+```
+
+Do not request, display, or export raw tokens unless the user explicitly asks and the applicable policy permits it. Never weaken MFA, conditional access, or tenant security controls. Automated login must use an explicit absolute `--password-command`; passwords are not stored by the CLI.

package/dist/skills/teams-cli/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: teams-cli
+description: Use teams-cli safely for Microsoft Teams authentication, discovery, reading, messaging, profiles, and policies.
+license: MIT
+metadata:
+  version: "0.1.0"
+  author: teams-cli
+---
+
+# Teams CLI
+
+Use `teams-cli` when a task requires command-line access to Microsoft Teams. The CLI uses an authenticated local Edge or Chrome profile and undocumented Microsoft APIs, so confirm organizational approval before use.
+
+## Discover commands
+
+```bash
+teams-cli --help
+teams-cli auth --help
+teams-cli person --help
+teams-cli chat --help
+teams-cli channel --help
+teams-cli message --help
+teams-cli policy --help
+```
+
+Use `--profile <name>` to select a configured tenant and user. Prefer `--json` for machine-readable person, chat, channel, and message results. Keep stdout available for payloads; warnings and diagnostics use stderr.
+
+## Safe workflow
+
+1. Verify the selected identity with `teams-cli --profile <name> auth whoami`.
+2. Discover people, chats, or channels before using identifiers.
+3. Read the applicable policy with `teams-cli policy show`.
+4. Check a write target with `teams-cli policy check send` before sending.
+5. Never copy bearer tokens into prompts, logs, or source files.

package/dist/skills/teams-messaging-policies/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: teams-messaging-policies
+description: Send Teams messages with teams-cli only after verifying identity, target, and applicable workspace policies.
+license: MIT
+metadata:
+  version: "0.1.0"
+  author: teams-cli
+---
+
+# Teams messaging and policies
+
+Sending is externally visible and must be intentional. Before a send:
+
+1. Run `teams-cli auth whoami` for the selected profile.
+2. Resolve the chat or channel from a fresh list operation.
+3. Run `teams-cli policy show` and `teams-cli policy check send --chat <id>` or `--channel <id>`.
+4. Confirm the body and target with the user when either is ambiguous.
+
+Send plain text with exactly one target:
+
+```bash
+teams-cli --profile work message send --chat <chat-id> --body "Hello"
+printf '%s' "Hello" | teams-cli --profile work message send --channel <channel-id>
+```
+
+Never bypass a policy denial by calling Microsoft APIs directly or exporting a token. Inactive policies warn but do not enforce; active matching policies intersect. A malformed policy store fails closed for authenticated operations.

package/dist/skills/teams-reading/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: teams-reading
+description: Discover people, chats, channels, and messages through teams-cli with structured output and pagination.
+license: MIT
+metadata:
+  version: "0.1.0"
+  author: teams-cli
+---
+
+# Read Microsoft Teams data
+
+Verify the profile before reading data:
+
+```bash
+teams-cli --profile work auth whoami
+teams-cli --profile work person search "Alice" --json
+teams-cli --profile work chat list --json
+teams-cli --profile work channel list --json
+```
+
+Read messages from exactly one target type:
+
+```bash
+teams-cli --profile work message list --chat <chat-id> --json
+teams-cli --profile work message list --channel <channel-id> --json
+teams-cli --profile work message get <message-id> --chat <chat-id> --json
+```
+
+When a result contains a cursor, pass it unchanged with `--cursor`. Do not combine a message cursor with `--page-size`. Treat names as display data and use returned IDs for follow-up operations.

package/dist/skills.js

@@ -0,0 +1,156 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, readdir, rename, stat, writeFile, } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const SKILL_PLATFORMS = [
+    { name: "codex", aliases: [], projectDirectory: ".codex/skills", userDirectory: ".codex/skills", markers: [".codex"] },
+    { name: "claude-code", aliases: ["claude"], projectDirectory: ".claude/skills", userDirectory: ".claude/skills", markers: [".claude"] },
+    { name: "cursor", aliases: [], projectDirectory: ".cursor/skills", userDirectory: ".cursor/skills", markers: [".cursor"] },
+    { name: "github-copilot", aliases: ["copilot"], projectDirectory: ".github/skills", userDirectory: ".copilot/skills", markers: [".github/skills", ".copilot"] },
+    { name: "opencode", aliases: [], projectDirectory: ".opencode/skills", userDirectory: ".config/opencode/skills", markers: [".opencode", ".config/opencode"] },
+    { name: "windsurf", aliases: [], projectDirectory: ".windsurf/skills", userDirectory: ".windsurf/skills", markers: [".windsurf"] },
+    { name: "gemini-cli", aliases: ["gemini"], projectDirectory: ".gemini/skills", userDirectory: ".gemini/skills", markers: [".gemini"] },
+    { name: "pi", aliases: ["pi-dev"], projectDirectory: ".pi/skills", userDirectory: ".pi/agent/skills", markers: [".pi"] },
+    { name: "agents", aliases: ["agent-skills"], projectDirectory: ".agents/skills", userDirectory: ".agents/skills", markers: [".agents"] },
+];
+export function skillManifestFile(storageRoot = join(homedir(), ".teams-cli")) {
+    return join(storageRoot, "skill-installations.json");
+}
+export function findProjectRoot(start = process.cwd()) {
+    let current = resolve(start);
+    while (true) {
+        if (existsSync(join(current, ".git")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return resolve(start);
+        current = parent;
+    }
+}
+export function lookupSkillPlatform(input) {
+    const normalized = input.trim().toLowerCase();
+    return SKILL_PLATFORMS.find(({ name, aliases }) => name === normalized || aliases.includes(normalized));
+}
+export function detectSkillPlatforms(projectRoot = findProjectRoot(), userHome = homedir()) {
+    return SKILL_PLATFORMS.filter(({ markers }) => markers.some((marker) => existsSync(join(projectRoot, ...marker.split("/"))) || existsSync(join(userHome, ...marker.split("/")))));
+}
+export function skillDestination(platform, project, projectRoot = findProjectRoot(), userHome = homedir()) {
+    const relative = project ? platform.projectDirectory : platform.userDirectory;
+    return join(project ? projectRoot : userHome, ...relative.split("/"));
+}
+function skillsResourceRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), "skills");
+}
+export async function loadBundledSkills() {
+    const root = skillsResourceRoot();
+    const entries = await readdir(root, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries.filter((candidate) => candidate.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
+        const content = await readFile(join(root, entry.name, "SKILL.md"), "utf8");
+        const description = /^description:\s*(.+)$/m.exec(content)?.[1]?.trim();
+        if (!description)
+            throw new Error(`Skill ${entry.name} has no description`);
+        skills.push({ name: entry.name, description, content });
+    }
+    return skills;
+}
+export async function loadSkillManifest(file = skillManifestFile()) {
+    try {
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || parsed.version !== 1) {
+            throw new Error("Skill installation manifest is invalid");
+        }
+        const installations = parsed.installations;
+        if (!Array.isArray(installations) || !installations.every((item) => {
+            if (!item || typeof item !== "object")
+                return false;
+            const candidate = item;
+            return typeof candidate.destination === "string" && Array.isArray(candidate.skillNames) &&
+                candidate.skillNames.every((name) => typeof name === "string");
+        }))
+            throw new Error("Skill installation manifest is invalid");
+        return { version: 1, installations: installations };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 1, installations: [] };
+        throw error;
+    }
+}
+async function saveSkillManifest(manifest, file) {
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    await chmod(dirname(file), 0o700);
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporary, file);
+    await chmod(file, 0o600);
+}
+export async function installSkills(options) {
+    const bundled = await loadBundledSkills();
+    const selected = options.names?.length
+        ? bundled.filter(({ name }) => options.names?.includes(name))
+        : bundled;
+    if (options.names?.length && selected.length !== new Set(options.names).size) {
+        const known = new Set(bundled.map(({ name }) => name));
+        const missing = options.names.filter((name) => !known.has(name));
+        throw new Error(`Unknown skill${missing.length === 1 ? "" : "s"}: ${missing.join(", ")}`);
+    }
+    const destinations = [...new Set(options.destinations.map((destination) => resolve(destination)))];
+    let filesWritten = 0;
+    const managed = new Map();
+    for (const destination of destinations) {
+        for (const skill of selected) {
+            const directory = join(destination, skill.name);
+            const file = join(directory, "SKILL.md");
+            await mkdir(directory, { recursive: true });
+            let exists = false;
+            try {
+                await stat(file);
+                exists = true;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            if (exists && !options.force)
+                continue;
+            await writeFile(file, skill.content, "utf8");
+            filesWritten += 1;
+            const names = managed.get(destination) ?? new Set();
+            names.add(skill.name);
+            managed.set(destination, names);
+        }
+    }
+    if (managed.size) {
+        const file = options.manifestFile ?? skillManifestFile();
+        const manifest = await loadSkillManifest(file);
+        const records = new Map(manifest.installations.map((entry) => [entry.destination, new Set(entry.skillNames)]));
+        for (const [destination, names] of managed) {
+            const existing = records.get(destination) ?? new Set();
+            for (const name of names)
+                existing.add(name);
+            records.set(destination, existing);
+        }
+        await saveSkillManifest({
+            version: 1,
+            installations: [...records.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([destination, names]) => ({ destination, skillNames: [...names].sort() })),
+        }, file);
+    }
+    return { filesWritten, destinations };
+}
+export async function reinstallSkills(manifestFile = skillManifestFile()) {
+    const manifest = await loadSkillManifest(manifestFile);
+    let filesWritten = 0;
+    for (const installation of manifest.installations) {
+        const result = await installSkills({
+            destinations: [installation.destination],
+            names: installation.skillNames,
+            force: true,
+            manifestFile,
+        });
+        filesWritten += result.filesWritten;
+    }
+    return { filesWritten, installations: manifest.installations.length };
+}