@meistrari/tela-cli 1.8.0 → 1.9.0

package/dist/commands/ingredients.js

@@ -145,7 +145,7 @@ async function callIngredientApi(args, _options, io) {
     const url = new URL((0, tela_pantry_1.joinUrl)(environment.url, routePath));
     for (const [key, value] of request.queryParams)
         url.searchParams.append(key, value);
-    for (const [key, value] of Object.entries(requestHeaders(targetSession.credential))) {
+    for (const [key, value] of Object.entries((0, tela_pantry_1.serviceCredentialHeaders)(targetSession.credential))) {
         if (!request.headers.has(key))
             request.headers.set(key, value);
     }
@@ -368,27 +368,6 @@ async function loadIngredient(slug, flags) {
     const { client } = await (0, session_1.loadPantry)(flags);
     return { client, detail: await (0, tela_pantry_1.fetchIngredientDetail)(client, slug) };
 }
-/**
- * Only `tela service api` still builds its own headers — every Pantry route now
- * goes through the generated client, which sends `Authorization: Bearer` and
- * nothing else. The `x-data-token` branch stays because arbitrary ingredient
- * APIs may accept it; Pantry itself demonstrably does not.
- */
-function requestHeaders(credential) {
-    if (credential.kind === 'data-token' && credential.dataToken) {
-        return {
-            'Accept': 'application/json',
-            'x-data-token': credential.dataToken,
-        };
-    }
-    if (credential.accessToken) {
-        return {
-            Accept: 'application/json',
-            Authorization: `Bearer ${credential.accessToken}`,
-        };
-    }
-    throw new Error(`Credential ${credential.kind} does not contain usable token material`);
-}
 async function fetchIngredientCatalog(credential, baseUrl = tela_pantry_1.DEFAULT_PANTRY_BASE_URL) {
     return await (0, tela_pantry_1.fetchIngredientCatalog)((0, tela_pantry_1.createPantryClient)(baseUrl, credential), baseUrl);
 }

package/dist/commands/skills.d.ts

@@ -1,4 +1,4 @@
-import type { PantrySkillManifestEntry, PantrySkillSummary } from '@meistrari/tela-pantry';
+import type { PantrySkillManifestEntry, PantrySkillSummary, SkillManagerDiagnostic } from '@meistrari/tela-pantry';
 import type { InstalledSkill } from '@meistrari/tela-local-config';
 import type { CliIo, GlobalOptions } from '../output';
 export declare function runSkillsCommand(args: string[], options: GlobalOptions, io: CliIo): Promise<number>;
@@ -12,22 +12,5 @@ export declare function annotateInstalled(skills: readonly PantrySkillSummary[],
 export declare function formatSkillList(entries: readonly SkillListEntry[]): string[];
 export declare function formatManifestTree(entries: readonly PantrySkillManifestEntry[]): string[];
 export declare function formatBytes(size: number): string;
-/**
- * No slugs means every installed skill: upgrading is additive, and "all of
- * them" is the only reading of a bare `skills upgrade`.
- *
- * A named slug the registry does not know is refused for the whole command
- * rather than skipped, so a typo among several cannot leave some skills
- * upgraded and report success.
- */
-export declare function selectUpgradeTargets(installed: readonly InstalledSkill[], slugs: readonly string[]): InstalledSkill[];
-/**
- * Is this the same installation, rather than one that replaced it?
- *
- * `slug` and `dir` are both derived from the slug, so neither moves across a
- * reinstall; `installedAt` and `sha` are what actually distinguish one install
- * from the next.
- */
-export declare function isSameInstall(left: InstalledSkill, right: InstalledSkill): boolean;
-export declare function scriptFailureMessage(entry: Pick<InstalledSkill, 'slug' | 'dir'>, phase: 'install' | 'uninstall'): string;
+export declare function writeSkillManagerDiagnostic(io: CliIo, diagnostic: SkillManagerDiagnostic): void;
 export {};

package/dist/commands/skills.js

@@ -5,16 +5,12 @@ exports.annotateInstalled = annotateInstalled;
 exports.formatSkillList = formatSkillList;
 exports.formatManifestTree = formatManifestTree;
 exports.formatBytes = formatBytes;
-exports.selectUpgradeTargets = selectUpgradeTargets;
-exports.isSameInstall = isSameInstall;
-exports.scriptFailureMessage = scriptFailureMessage;
-const promises_1 = require("node:fs/promises");
+exports.writeSkillManagerDiagnostic = writeSkillManagerDiagnostic;
 const tela_pantry_1 = require("@meistrari/tela-pantry");
 const tela_local_config_1 = require("@meistrari/tela-local-config");
 const markdown_1 = require("../markdown");
 const output_1 = require("../output");
 const session_1 = require("../session");
-const skills_1 = require("../skills");
 async function runSkillsCommand(args, options, io) {
     const [command, ...rest] = args;
     if (!command || command === 'help' || command === '--help' || command === '-h') {
@@ -172,18 +168,15 @@ async function installSkills(args, options, io) {
         return usageError(flags.error, io);
     if (flags.rest.length === 0)
         return usageError('Usage: tela skills install <slug...> [--force] [--no-symlink] [--ignore-scripts]', io);
-    // Every slug is validated before any of them is installed: one bad slug
-    // among several must stop the command before the safe ones are already on
-    // disk, and before an unvalidated slug reaches a request path.
-    for (const slug of flags.rest)
-        (0, skills_1.assertSafeSlug)(slug, 'install');
-    const pantry = await (0, session_1.loadPantry)(flags);
-    const installed = [];
-    for (const slug of flags.rest) {
-        const entry = await installOne(pantry, slug, flags, io);
-        if (entry)
-            installed.push(entry);
-    }
+    const manager = (0, tela_pantry_1.createSkillManager)({
+        getClient: async () => (await (0, session_1.loadPantry)(flags)).client,
+        onDiagnostic: diagnostic => writeSkillManagerDiagnostic(io, diagnostic),
+    });
+    const { installed } = await manager.installSkills(flags.rest, {
+        force: flags.force,
+        ignoreScripts: flags.ignoreScripts,
+        ...(flags.symlink ? {} : { targets: [] }),
+    });
     if (options.json) {
         (0, output_1.writeJson)(io, { installed });
         return 0;
@@ -192,148 +185,29 @@ async function installSkills(args, options, io) {
         (0, output_1.writeLine)(io, `Installed ${entry.slug}@${entry.sha.slice(0, 7)} to ${entry.dir}`);
     return 0;
 }
-async function installOne(pantry, slug, flags, io, expectedCurrent) {
-    const roots = (0, skills_1.resolveSkillRoots)();
-    const target = (0, skills_1.resolveInstallDir)(roots, slug);
-    const { ingredient, snapshot } = await (0, tela_pantry_1.fetchSkillFile)(pantry.client, slug);
-    // Verified before anything is written: the order is the security property.
-    // Nothing is removed from disk until every file in the archive has been
-    // checked against the manifest, so a tampered or truncated download can
-    // never delete a working install. Downloading outside the lock also keeps
-    // the network round-trip out of the critical section.
-    const files = (0, tela_pantry_1.verifySnapshotFiles)((0, tela_pantry_1.parseTarGz)(await (0, tela_pantry_1.downloadSkillArchive)(snapshot.archiveUrl)), snapshot.manifest);
-    const stagedInstalls = [];
-    let skippedReason = null;
-    let entry = null;
-    try {
-        entry = await (0, tela_local_config_1.updateInstalledSkill)(slug, async (registered) => {
-            if (expectedCurrent && (registered === null || !isSameInstall(registered, expectedCurrent))) {
-                skippedReason = `Skipped ${slug}: it was changed while this upgrade ran`;
-                return registered;
-            }
-            // Re-checked against the registry as it stands inside the lock. Read
-            // before acquiring it, this guard would answer for a moment that has
-            // passed by the time the files are written.
-            //
-            // An upgrade needs no exemption here: the entry it is upgrading names
-            // this very directory, so the guard already recognises it as ours.
-            if ((0, skills_1.isUnownedInstallDir)(target, registered?.dir ?? null) && !flags.force) {
-                throw new Error(`${target} already exists and was not installed by tela.\n`
-                    + `Run \`tela skills install ${slug} --force\` to replace it, or remove it by hand.`);
-            }
-            const staged = await (0, skills_1.stageSkillFiles)(target, files);
-            stagedInstalls.push(staged);
-            const link = flags.symlink
-                ? await (0, skills_1.linkSkill)(roots, slug, target, flags.force)
-                : await removeRecordedSymlinks(registered?.symlinks ?? [], target, io);
-            if (link.skipped)
-                (0, output_1.writeError)(io, `Skipped symlink: ${link.skipped}`);
-            return {
-                slug,
-                dir: target,
-                sha: snapshot.sha,
-                bundle: ingredient.bundle,
-                symlinks: link.linked,
-                scripts: ingredient.scripts,
-                installedAt: new Date().toISOString(),
-            };
-        });
-    }
-    catch (error) {
-        await rollbackStagedInstall(stagedInstalls.at(-1) ?? null, error);
-    }
-    if (skippedReason) {
-        (0, output_1.writeError)(io, skippedReason);
-        return null;
-    }
-    for (const staged of stagedInstalls)
-        await staged.commit();
-    if (!entry)
-        return null;
-    // Outside the lock on purpose: the script is arbitrary shell from the
-    // catalog and may run for as long as it likes, which is exactly what must
-    // not happen while every other tela process waits on the inventory.
-    //
-    // That leaves a window, knowingly: a concurrent install of the same slug
-    // can replace this directory once the lock is released, and this script
-    // would then run against the newer install's files. Reaching it takes two
-    // tela processes on one slug, overlapping, a skill that declares an install
-    // script, and two snapshots whose scripts differ enough for the older to do
-    // damage. Guarding it was tried and reverted: the check costs a registry
-    // read on every install to catch only the case where the replacement has
-    // already finished, and a replacement landing mid-script is undetectable
-    // without holding the lock across arbitrary shell — which the refresh now
-    // sustains for as long as the script runs, so every other tela process
-    // would wait behind it instead of the lock ageing out.
-    await runLifecycleScript(entry, 'install', flags.ignoreScripts, io);
-    return entry;
-}
-async function removeRecordedSymlinks(symlinks, target, io) {
-    for (const linkPath of symlinks) {
-        const outcome = await (0, skills_1.removeManagedSymlink)(linkPath, target);
-        if (outcome.reason)
-            (0, output_1.writeError)(io, outcome.reason);
-    }
-    return { linked: [], skipped: null };
-}
-async function rollbackStagedInstall(staged, error) {
-    if (!staged)
-        throw error;
-    try {
-        await staged.rollback();
-    }
-    catch (cleanupError) {
-        throw new Error(`${formatError(error)}\nCleanup failed: ${formatError(cleanupError)}`);
-    }
-    throw error;
-}
-/**
- * No slugs means every installed skill: upgrading is additive, and "all of
- * them" is the only reading of a bare `skills upgrade`.
- *
- * A named slug the registry does not know is refused for the whole command
- * rather than skipped, so a typo among several cannot leave some skills
- * upgraded and report success.
- */
-function selectUpgradeTargets(installed, slugs) {
-    if (slugs.length === 0)
-        return [...installed];
-    const bySlug = new Map(installed.map(entry => [entry.slug, entry]));
-    const missing = slugs.filter(slug => !bySlug.has(slug));
-    if (missing.length > 0)
-        throw new Error(`${missing.join(', ')} not installed by tela. Nothing to upgrade.`);
-    return slugs.map(slug => bySlug.get(slug));
+function writeSkillManagerDiagnostic(io, diagnostic) {
+    (0, output_1.writeError)(io, diagnostic.message);
 }
 async function upgradeSkills(args, options, io) {
     const flags = parseSkillFlags(args);
     if ('error' in flags)
         return usageError(flags.error, io);
-    const targets = selectUpgradeTargets(await (0, tela_local_config_1.listInstalledSkills)(), flags.rest);
-    if (targets.length === 0) {
+    const manager = (0, tela_pantry_1.createSkillManager)({
+        getClient: async () => (await (0, session_1.loadPantry)(flags)).client,
+        onDiagnostic: diagnostic => writeSkillManagerDiagnostic(io, diagnostic),
+    });
+    const { upgraded, unchanged } = await manager.upgradeSkills(flags.rest, {
+        force: flags.force,
+        ignoreScripts: flags.ignoreScripts,
+        ...(flags.symlink ? {} : { targets: [] }),
+    });
+    if (upgraded.length === 0 && unchanged.length === 0) {
         if (options.json)
             (0, output_1.writeJson)(io, { upgraded: [], unchanged: [] });
         else
             (0, output_1.writeLine)(io, 'No skills installed.');
         return 0;
     }
-    const pantry = await (0, session_1.loadPantry)(flags);
-    const upgraded = [];
-    const unchanged = [];
-    for (const entry of targets) {
-        const { snapshot } = await (0, tela_pantry_1.fetchSkillFile)(pantry.client, entry.slug);
-        // Same snapshot means the same bytes: reinstalling would re-run the
-        // install script for no change.
-        if (snapshot.sha === entry.sha) {
-            unchanged.push(entry.slug);
-            continue;
-        }
-        // `flags` as the user gave them. Synthesising `force: true` here would
-        // reach past the install directory the upgrade owns and into the link
-        // path, where a directory another tool put there would be deleted.
-        const upgradedEntry = await installOne(pantry, entry.slug, flags, io, entry);
-        if (upgradedEntry)
-            upgraded.push(upgradedEntry);
-    }
     if (options.json) {
         (0, output_1.writeJson)(io, { upgraded, unchanged });
         return 0;
@@ -350,57 +224,13 @@ async function uninstallSkills(args, options, io) {
         return usageError(flags.error, io);
     if (flags.rest.length === 0)
         return usageError('Usage: tela skills uninstall <slug...> [--ignore-scripts]', io);
-    const installed = await (0, tela_local_config_1.listInstalledSkills)();
-    const bySlug = new Map(installed.map(entry => [entry.slug, entry]));
-    const missing = flags.rest.filter(slug => !bySlug.has(slug));
-    // Refused before anything is deleted rather than skipped over: with several
-    // slugs, removing the ones that resolved and ignoring a typo leaves a
-    // partial uninstall behind a success exit code.
-    if (missing.length > 0)
-        return usageError(`${missing.join(', ')} not installed by tela. Nothing to remove.`, io);
-    const removed = [];
-    const roots = (0, skills_1.resolveSkillRoots)();
-    for (const slug of flags.rest) {
-        // Registry-driven: an unregistered slug never reaches this loop, so a
-        // recursive delete can only ever be pointed at a directory tela
-        // recorded writing.
-        const entry = bySlug.get(slug);
-        if (!entry)
-            continue;
-        assertManagedInstallDir(slug, entry, roots);
-        // Before the lock: the script is arbitrary shell, it runs in the
-        // directory about to be deleted, and holding the inventory for its
-        // duration would block every other tela process.
-        await runLifecycleScript(entry, 'uninstall', flags.ignoreScripts, io);
-        let gone = false;
-        await (0, tela_local_config_1.updateInstalledSkill)(slug, async (registered) => {
-            // The entry read before the script ran may be stale: a concurrent
-            // uninstall already finished, or a concurrent install replaced it.
-            if (registered === null)
-                return null;
-            // Compared whole rather than by `dir`, which is derived from the
-            // slug and so is the same string for a reinstall — it cannot tell
-            // "still the entry whose script just ran" from "someone reinstalled
-            // while it ran". A reinstall carries a fresh `installedAt`, and an
-            // entry matching in every field describes the same sha recorded at
-            // the same instant, which this uninstall is entitled to remove.
-            if (!isSameInstall(registered, entry)) {
-                (0, output_1.writeError)(io, `Skipped ${slug}: it was reinstalled while this uninstall ran`);
-                return registered;
-            }
-            assertManagedInstallDir(slug, registered, roots);
-            for (const linkPath of registered.symlinks) {
-                const outcome = await (0, skills_1.removeManagedSymlink)(linkPath, registered.dir);
-                if (outcome.reason)
-                    (0, output_1.writeError)(io, outcome.reason);
-            }
-            await (0, promises_1.rm)(registered.dir, { recursive: true, force: true });
-            gone = true;
-            return null;
-        });
-        if (gone)
-            removed.push(slug);
-    }
+    const manager = (0, tela_pantry_1.createSkillManager)({
+        getClient: async () => (await (0, session_1.loadPantry)(flags)).client,
+        onDiagnostic: diagnostic => writeSkillManagerDiagnostic(io, diagnostic),
+    });
+    const { removed } = await manager.uninstallSkills(flags.rest, {
+        ignoreScripts: flags.ignoreScripts,
+    });
     if (options.json) {
         (0, output_1.writeJson)(io, { removed });
         return 0;
@@ -409,58 +239,6 @@ async function uninstallSkills(args, options, io) {
         (0, output_1.writeLine)(io, `Removed ${slug}`);
     return 0;
 }
-function assertManagedInstallDir(slug, entry, roots) {
-    const expectedDir = (0, skills_1.resolveInstallDir)(roots, slug);
-    if (entry.slug !== slug || entry.dir !== expectedDir) {
-        throw new Error(`${slug} is recorded at ${entry.dir}, not the managed install directory ${expectedDir}. `
-            + 'Refusing to remove it.');
-    }
-}
-/**
- * Is this the same installation, rather than one that replaced it?
- *
- * `slug` and `dir` are both derived from the slug, so neither moves across a
- * reinstall; `installedAt` and `sha` are what actually distinguish one install
- * from the next.
- */
-function isSameInstall(left, right) {
-    return left.installedAt === right.installedAt
-        && left.sha === right.sha
-        && left.dir === right.dir;
-}
-/**
- * Run a skill's install or uninstall script, unless asked not to.
- *
- * A failing install script does not undo the install: by the time it runs the
- * files are already on disk, and dropping the registry entry would strand a
- * directory `uninstall` could no longer be pointed at. The failure is reported
- * and the command exits non-zero instead.
- */
-async function runLifecycleScript(entry, phase, ignoreScripts, io) {
-    const script = entry.scripts?.[phase];
-    if (!script)
-        return;
-    if (ignoreScripts) {
-        (0, output_1.writeError)(io, `Skipped ${phase} script for ${entry.slug}: ${script}`);
-        return;
-    }
-    (0, output_1.writeError)(io, `Running ${phase} script for ${entry.slug}: ${script}`);
-    const outcome = await (0, skills_1.runSkillScript)(script, entry.dir);
-    if (outcome.output)
-        (0, output_1.writeError)(io, outcome.output);
-    if (!outcome.ok)
-        throw new Error(scriptFailureMessage(entry, phase));
-}
-function scriptFailureMessage(entry, phase) {
-    const opener = `${phase} script failed for ${entry.slug}.`;
-    if (phase === 'uninstall')
-        return `${opener}\n${entry.slug} was left in place. Re-run with --ignore-scripts to remove it anyway.`;
-    return `${opener}\n`
-        + `${entry.slug} was installed to ${entry.dir} and recorded, but its install script did not `
-        + 'finish, so the skill may not work.\n'
-        + `Remove it with \`tela skills uninstall ${entry.slug}\`, or reinstall without the script: `
-        + `\`tela skills install ${entry.slug} --ignore-scripts\`.`;
-}
 function parseSkillFlags(args) {
     const flags = { force: false, symlink: true, ignoreScripts: false, rest: [] };
     for (let index = 0; index < args.length; index += 1) {