@yagni-app/code 1.0.6 → 1.0.7

package/dist/pluginStore.js

@@ -0,0 +1,554 @@
+/**
+ * YAGNI Code's own plugin ledger — the state behind `yagni plugin …`.
+ *
+ * Layout under `~/.yagni-code/plugins/` (Claude Code's shape, our own files —
+ * we never write into `~/.claude`, whose ledger format is versioned and
+ * undocumented; we only read it, see claudePlugins.ts):
+ *
+ *   known_marketplaces.json    marketplace name → source + local checkout
+ *   installed_plugins.json     `name@marketplace` → installed entries
+ *   marketplaces/<name>/       git checkout of a marketplace repo
+ *   cache/<mp>/<plugin>/<ver>/ the installed copy of a plugin
+ *
+ * Marketplace sources: `owner/repo` (GitHub over HTTPS, the developer's own
+ * git credentials), any git URL (ssh or https), or a local directory (its
+ * catalog is read in place; installs still copy into the cache, so edits land
+ * on the next `plugin update`). Only marketplace entries with relative-path
+ * sources install;
+ * object sources (github/url/npm/archive) are network installs of a second
+ * repo and are reported as unsupported rather than fetched.
+ *
+ * All git calls go through an injectable runner so tests never touch the
+ * network. Writes are atomic (temp + rename).
+ */
+import { execFile } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { isSafeSegment, readMarketplace, resolveLocalPluginRoot, } from "./claudePlugins.js";
+export const defaultGit = (args, opts) => new Promise((resolveResult) => {
+    execFile("git", args, {
+        cwd: opts.cwd,
+        // Never hang on a credential prompt inside a non-interactive install.
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+        maxBuffer: 16 * 1024 * 1024,
+    }, (err, stdout, stderr) => {
+        resolveResult({ ok: !err, stdout: String(stdout ?? ""), stderr: String(stderr ?? (err?.message ?? "")) });
+    });
+});
+export class PluginStoreError extends Error {
+}
+/**
+ * Every path we delete, copy into, or rename to must sit inside the plugin
+ * home. Names/versions are already segment-checked at parse time; this is the
+ * belt-and-braces guard right before the destructive call.
+ */
+function assertInside(home, path, what) {
+    const base = resolve(home);
+    const real = resolve(path);
+    if (real !== base && !real.startsWith(base + sep)) {
+        throw new PluginStoreError(`Refusing to touch ${what} outside the plugin home: ${real}`);
+    }
+    return real;
+}
+// ── paths ───────────────────────────────────────────────────────────────────
+export function pluginsHome(env = process.env, userHome = homedir()) {
+    return join(env.YAGNI_CODE_HOME ?? join(userHome, ".yagni-code"), "plugins");
+}
+function knownMarketplacesPath(home) {
+    return join(home, "known_marketplaces.json");
+}
+function ledgerPath(home) {
+    return join(home, "installed_plugins.json");
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJsonAtomic(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    renameSync(tmp, path);
+}
+// ── known marketplaces ──────────────────────────────────────────────────────
+export function readKnownMarketplaces(home) {
+    const parsed = readJson(knownMarketplacesPath(home));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+    const out = {};
+    for (const [name, value] of Object.entries(parsed)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const v = value;
+        if (typeof v.installLocation !== "string" || !v.source || typeof v.source !== "object")
+            continue;
+        out[name] = {
+            source: v.source,
+            installLocation: v.installLocation,
+            addedAt: typeof v.addedAt === "string" ? v.addedAt : "",
+        };
+    }
+    return out;
+}
+export function writeKnownMarketplaces(home, value) {
+    writeJsonAtomic(knownMarketplacesPath(home), value);
+}
+// ── installed-plugin ledger ─────────────────────────────────────────────────
+export function readLedger(home) {
+    const parsed = readJson(ledgerPath(home));
+    const empty = { version: 1, plugins: {} };
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return empty;
+    const plugins = parsed.plugins;
+    if (!plugins || typeof plugins !== "object" || Array.isArray(plugins))
+        return empty;
+    const out = { version: 1, plugins: {} };
+    for (const [key, value] of Object.entries(plugins)) {
+        if (!Array.isArray(value))
+            continue;
+        const entries = [];
+        for (const item of value) {
+            if (!item || typeof item !== "object")
+                continue;
+            const e = item;
+            if (typeof e.installPath !== "string" || (e.scope !== "user" && e.scope !== "project"))
+                continue;
+            entries.push({
+                scope: e.scope,
+                installPath: e.installPath,
+                version: typeof e.version === "string" ? e.version : "unknown",
+                ...(typeof e.projectPath === "string" ? { projectPath: e.projectPath } : {}),
+                enabled: e.enabled !== false,
+                installedAt: typeof e.installedAt === "string" ? e.installedAt : "",
+            });
+        }
+        if (entries.length > 0)
+            out.plugins[key] = entries;
+    }
+    return out;
+}
+export function writeLedger(home, ledger) {
+    writeJsonAtomic(ledgerPath(home), ledger);
+}
+// ── sources ─────────────────────────────────────────────────────────────────
+const GITHUB_SHORTHAND = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const GIT_URL = /^(https?:\/\/|git@|ssh:\/\/|git:\/\/|file:\/\/)/;
+/** Interpret the `marketplace add` argument. Null when it is none of the shapes. */
+export function parseMarketplaceSource(input, cwd) {
+    const trimmed = input.trim();
+    if (!trimmed || trimmed.startsWith("-"))
+        return null;
+    const asPath = isAbsolute(trimmed) ? trimmed : resolve(cwd, trimmed);
+    if (isDirectory(asPath))
+        return { source: "directory", path: asPath };
+    if (GIT_URL.test(trimmed) || trimmed.endsWith(".git"))
+        return { source: "git", url: trimmed };
+    if (GITHUB_SHORTHAND.test(trimmed) && !trimmed.startsWith("."))
+        return { source: "github", repo: trimmed };
+    return null;
+}
+export function cloneUrl(source) {
+    if (source.source === "github")
+        return `https://github.com/${source.repo}.git`;
+    if (source.source === "git")
+        return source.url;
+    return null;
+}
+export function describeSource(source) {
+    if (source.source === "github")
+        return `github:${source.repo}`;
+    if (source.source === "git")
+        return source.url;
+    return source.path;
+}
+function stamp(deps) {
+    return (deps.now ?? (() => new Date()))().toISOString();
+}
+function marketplaceOrThrow(root, label) {
+    const mp = readMarketplace(root);
+    if (!mp) {
+        throw new PluginStoreError(`${label} has no usable .claude-plugin/marketplace.json (expected a "name" and a "plugins" array).`);
+    }
+    return mp;
+}
+export async function addMarketplace(source, deps) {
+    const known = readKnownMarketplaces(deps.home);
+    if (source.source === "directory") {
+        const mp = marketplaceOrThrow(source.path, source.path);
+        if (known[mp.name])
+            throw new PluginStoreError(`Marketplace "${mp.name}" is already added (${describeSource(known[mp.name].source)}).`);
+        known[mp.name] = { source, installLocation: source.path, addedAt: stamp(deps) };
+        writeKnownMarketplaces(deps.home, known);
+        return { name: mp.name, marketplace: mp, installLocation: source.path };
+    }
+    const url = cloneUrl(source);
+    const git = deps.git ?? defaultGit;
+    const marketplacesDir = join(deps.home, "marketplaces");
+    mkdirSync(marketplacesDir, { recursive: true });
+    const tmp = join(marketplacesDir, `.tmp-${process.pid}-${Date.now()}`);
+    // `--` so a URL can never be read as a git option.
+    const result = await git(["clone", "--quiet", "--", url, tmp], {});
+    if (!result.ok) {
+        rmSync(tmp, { recursive: true, force: true });
+        const hint = source.source === "github" && /authentication|could not read username|permission denied|403|404/i.test(result.stderr)
+            ? `\nIf your GitHub access is over SSH, add it as: git@github.com:${source.repo}.git`
+            : "";
+        throw new PluginStoreError(`git clone failed for ${url}:\n${result.stderr.trim()}${hint}`);
+    }
+    let mp;
+    try {
+        mp = marketplaceOrThrow(tmp, url);
+    }
+    catch (err) {
+        rmSync(tmp, { recursive: true, force: true });
+        throw err;
+    }
+    const dest = assertInside(marketplacesDir, join(marketplacesDir, mp.name), "a marketplace checkout");
+    if (known[mp.name] || existsSync(dest)) {
+        rmSync(tmp, { recursive: true, force: true });
+        throw new PluginStoreError(`Marketplace "${mp.name}" is already added. Run \`marketplace update ${mp.name}\` to refresh it.`);
+    }
+    renameSync(tmp, dest);
+    known[mp.name] = { source, installLocation: dest, addedAt: stamp(deps) };
+    writeKnownMarketplaces(deps.home, known);
+    return { name: mp.name, marketplace: readMarketplace(dest) ?? { ...mp, root: dest }, installLocation: dest };
+}
+export function knownMarketplaceOrThrow(name, deps) {
+    const known = readKnownMarketplaces(deps.home);
+    const entry = known[name];
+    if (!entry) {
+        const names = Object.keys(known);
+        throw new PluginStoreError(names.length === 0
+            ? `No marketplaces added yet. Run \`plugin marketplace add <owner/repo | git-url | path>\` first.`
+            : `Unknown marketplace "${name}". Known: ${names.join(", ")}.`);
+    }
+    return entry;
+}
+/** Pull a git marketplace; a directory marketplace is always current. Returns whether anything changed. */
+export async function updateMarketplace(name, deps) {
+    const entry = knownMarketplaceOrThrow(name, deps);
+    if (entry.source.source === "directory")
+        return { changed: false, head: null };
+    const git = deps.git ?? defaultGit;
+    const before = await git(["rev-parse", "HEAD"], { cwd: entry.installLocation });
+    const pull = await git(["pull", "--ff-only", "--quiet"], { cwd: entry.installLocation });
+    if (!pull.ok)
+        throw new PluginStoreError(`git pull failed for marketplace "${name}":\n${pull.stderr.trim()}`);
+    const after = await git(["rev-parse", "HEAD"], { cwd: entry.installLocation });
+    const head = after.ok ? after.stdout.trim() : null;
+    return { changed: !before.ok || !after.ok || before.stdout.trim() !== after.stdout.trim(), head };
+}
+export function removeMarketplace(name, deps) {
+    const entry = knownMarketplaceOrThrow(name, deps);
+    const ledger = readLedger(deps.home);
+    const removedPlugins = [];
+    for (const key of Object.keys(ledger.plugins)) {
+        if (splitKey(key).marketplace === name) {
+            for (const inst of ledger.plugins[key] ?? [])
+                dropCacheDir(inst.installPath, deps.home);
+            delete ledger.plugins[key];
+            removedPlugins.push(key);
+        }
+    }
+    writeLedger(deps.home, ledger);
+    const known = readKnownMarketplaces(deps.home);
+    delete known[name];
+    writeKnownMarketplaces(deps.home, known);
+    if (entry.source.source !== "directory") {
+        rmSync(assertInside(join(deps.home, "marketplaces"), entry.installLocation, "a marketplace checkout"), {
+            recursive: true,
+            force: true,
+        });
+    }
+    return { removedPlugins };
+}
+// ── plugin operations ───────────────────────────────────────────────────────
+export function splitKey(key) {
+    const at = key.lastIndexOf("@");
+    if (at <= 0)
+        return { plugin: key, marketplace: null };
+    return { plugin: key.slice(0, at), marketplace: key.slice(at + 1) };
+}
+/**
+ * Find `<plugin>[@marketplace]` across known marketplaces. Without an
+ * explicit marketplace the name must be unique across them.
+ */
+export async function resolvePluginSpec(spec, deps) {
+    const { plugin, marketplace } = splitKey(spec);
+    const known = readKnownMarketplaces(deps.home);
+    if (Object.keys(known).length === 0) {
+        throw new PluginStoreError(`No marketplaces added yet. Run \`plugin marketplace add <owner/repo | git-url | path>\` first.`);
+    }
+    const candidates = [];
+    for (const [name, entry] of Object.entries(known)) {
+        if (marketplace && name !== marketplace)
+            continue;
+        const mp = readMarketplace(entry.installLocation);
+        if (!mp)
+            continue;
+        const found = mp.plugins.find((p) => p.name === plugin);
+        if (!found)
+            continue;
+        const sourceRoot = resolveLocalPluginRoot(mp, found);
+        if (!sourceRoot) {
+            throw new PluginStoreError(`Plugin "${plugin}" in marketplace "${name}" uses a source YAGNI cannot install (${describeEntrySource(found)}). ` +
+                `Only relative-path sources inside the marketplace repo are supported.`);
+        }
+        candidates.push({
+            key: `${plugin}@${name}`,
+            plugin,
+            marketplace: name,
+            marketplaceRoot: entry.installLocation,
+            entry: found,
+            sourceRoot,
+            version: await pluginVersion(found, entry, deps),
+        });
+    }
+    if (candidates.length === 0) {
+        if (marketplace && !known[marketplace]) {
+            throw new PluginStoreError(`Unknown marketplace "${marketplace}". Known: ${Object.keys(known).join(", ")}.`);
+        }
+        throw new PluginStoreError(`Plugin "${plugin}" not found in ${marketplace ? `marketplace "${marketplace}"` : "any known marketplace"}.`);
+    }
+    if (candidates.length > 1) {
+        throw new PluginStoreError(`Plugin "${plugin}" exists in several marketplaces (${candidates.map((c) => c.marketplace).join(", ")}). ` +
+            `Use ${plugin}@<marketplace>.`);
+    }
+    return candidates[0];
+}
+function describeEntrySource(entry) {
+    const src = entry.source;
+    if (typeof src === "string")
+        return `"${src}"`;
+    if (src && typeof src === "object") {
+        const kind = src.source;
+        return typeof kind === "string" ? `${kind} source` : "object source";
+    }
+    return "missing source";
+}
+async function pluginVersion(entry, mp, deps) {
+    if (isSafeSegment(entry.version))
+        return entry.version;
+    if (mp.source.source !== "directory") {
+        const git = deps.git ?? defaultGit;
+        const head = await git(["rev-parse", "--short", "HEAD"], { cwd: mp.installLocation });
+        if (head.ok && head.stdout.trim())
+            return head.stdout.trim();
+    }
+    return "local";
+}
+function cacheDir(home, resolved) {
+    for (const [label, value] of [
+        ["marketplace", resolved.marketplace],
+        ["plugin", resolved.plugin],
+        ["version", resolved.version],
+    ]) {
+        if (!isSafeSegment(value))
+            throw new PluginStoreError(`Refusing to install: unsafe ${label} name "${value}".`);
+    }
+    return assertInside(join(home, "cache"), join(home, "cache", resolved.marketplace, resolved.plugin, resolved.version), "a cache dir");
+}
+/** Copy the plugin source into its cache dir (replacing any stale copy). */
+function materialize(resolved, deps) {
+    const dest = cacheDir(deps.home, resolved);
+    rmSync(dest, { recursive: true, force: true });
+    mkdirSync(dirname(dest), { recursive: true });
+    cpSync(resolved.sourceRoot, dest, { recursive: true, dereference: true });
+    return dest;
+}
+function dropCacheDir(installPath, home) {
+    const cacheRoot = resolve(join(home, "cache"));
+    const real = resolve(installPath);
+    if (real !== cacheRoot && real.startsWith(cacheRoot + sep))
+        rmSync(real, { recursive: true, force: true });
+}
+function sameTarget(a, scope, projectPath) {
+    if (a.scope !== scope)
+        return false;
+    return scope === "user" || a.projectPath === projectPath;
+}
+export async function installPlugin(spec, opts, deps) {
+    if (opts.scope === "project" && !opts.projectPath)
+        throw new PluginStoreError("A project-scope install needs a project path.");
+    const resolved = await resolvePluginSpec(spec, deps);
+    const installPath = materialize(resolved, deps);
+    const ledger = readLedger(deps.home);
+    const entries = ledger.plugins[resolved.key] ?? [];
+    const replaced = entries.find((e) => sameTarget(e, opts.scope, opts.projectPath)) ?? null;
+    const next = {
+        scope: opts.scope,
+        installPath,
+        version: resolved.version,
+        ...(opts.scope === "project" ? { projectPath: opts.projectPath } : {}),
+        enabled: true,
+        installedAt: stamp(deps),
+    };
+    ledger.plugins[resolved.key] = [...entries.filter((e) => e !== replaced), next];
+    writeLedger(deps.home, ledger);
+    if (replaced && replaced.installPath !== installPath && !isReferenced(ledger, replaced.installPath)) {
+        dropCacheDir(replaced.installPath, deps.home);
+    }
+    return { resolved, installPath, replaced };
+}
+function isReferenced(ledger, installPath) {
+    return Object.values(ledger.plugins).some((list) => list.some((e) => e.installPath === installPath));
+}
+/** The ledger key an uninstall/enable/disable spec refers to; must be unambiguous. */
+export function resolveInstalledKey(spec, deps) {
+    const ledger = readLedger(deps.home);
+    const { plugin, marketplace } = splitKey(spec);
+    const keys = Object.keys(ledger.plugins).filter((k) => {
+        const s = splitKey(k);
+        return s.plugin === plugin && (!marketplace || s.marketplace === marketplace);
+    });
+    if (keys.length === 0)
+        throw new PluginStoreError(`Plugin "${spec}" is not installed here.`);
+    if (keys.length > 1)
+        throw new PluginStoreError(`"${plugin}" is installed from several marketplaces (${keys.join(", ")}). Use ${plugin}@<marketplace>.`);
+    return keys[0];
+}
+export function uninstallPlugin(spec, opts, deps) {
+    const key = resolveInstalledKey(spec, deps);
+    const ledger = readLedger(deps.home);
+    const entries = ledger.plugins[key] ?? [];
+    const removed = entries.filter((e) => {
+        if (opts.scope)
+            return sameTarget(e, opts.scope, opts.projectPath);
+        // No scope: everything that applies here — the user-scope install plus
+        // this project's install.
+        return e.scope === "user" || e.projectPath === opts.projectPath;
+    });
+    if (removed.length === 0) {
+        throw new PluginStoreError(`Plugin "${key}" is not installed at ${opts.scope ?? "user or project"} scope here.`);
+    }
+    const kept = entries.filter((e) => !removed.includes(e));
+    if (kept.length > 0)
+        ledger.plugins[key] = kept;
+    else
+        delete ledger.plugins[key];
+    writeLedger(deps.home, ledger);
+    for (const e of removed) {
+        if (!isReferenced(ledger, e.installPath))
+            dropCacheDir(e.installPath, deps.home);
+    }
+    return { key, removed };
+}
+export function setPluginEnabled(spec, enabled, deps) {
+    const key = resolveInstalledKey(spec, deps);
+    const ledger = readLedger(deps.home);
+    const entries = ledger.plugins[key] ?? [];
+    for (const e of entries)
+        e.enabled = enabled;
+    writeLedger(deps.home, ledger);
+    return { key, count: entries.length };
+}
+/**
+ * Refresh marketplaces and re-sync installed plugins from them. Every
+ * installed plugin is re-copied (a content change with no version bump still
+ * lands), and version changes are reported.
+ */
+export async function updatePlugins(spec, deps) {
+    const ledger = readLedger(deps.home);
+    const keys = spec ? [resolveInstalledKey(spec, deps)] : Object.keys(ledger.plugins);
+    const marketplaces = [...new Set(keys.map((k) => splitKey(k).marketplace).filter((m) => !!m))];
+    const out = { marketplaces: [], plugins: [], errors: [] };
+    for (const name of marketplaces) {
+        try {
+            const { changed } = await updateMarketplace(name, deps);
+            out.marketplaces.push({ name, changed });
+        }
+        catch (err) {
+            out.errors.push(err instanceof Error ? err.message : String(err));
+        }
+    }
+    for (const key of keys) {
+        const entries = ledger.plugins[key] ?? [];
+        let resolved;
+        try {
+            resolved = await resolvePluginSpec(key, deps);
+        }
+        catch (err) {
+            out.errors.push(err instanceof Error ? err.message : String(err));
+            continue;
+        }
+        const installPath = materialize(resolved, deps);
+        const stale = new Set();
+        const from = [...new Set(entries.map((e) => e.version))].join("/");
+        for (const e of entries) {
+            if (e.installPath !== installPath)
+                stale.add(e.installPath);
+            e.installPath = installPath;
+            e.version = resolved.version;
+        }
+        out.plugins.push({ key, from, to: resolved.version, refreshed: true });
+        writeLedger(deps.home, ledger);
+        for (const path of stale) {
+            if (!isReferenced(ledger, path))
+                dropCacheDir(path, deps.home);
+        }
+    }
+    return out;
+}
+/** Marketplace catalog entries with their install status (for `plugin list --available`). */
+export function catalog(deps) {
+    const known = readKnownMarketplaces(deps.home);
+    const out = [];
+    for (const [name, entry] of Object.entries(known)) {
+        const mp = readMarketplace(entry.installLocation);
+        if (!mp) {
+            out.push({ marketplace: name, entries: [] });
+            continue;
+        }
+        out.push({
+            marketplace: name,
+            entries: mp.plugins.map((p) => {
+                const extra = p;
+                return {
+                    name: p.name,
+                    version: typeof extra.version === "string" ? extra.version : null,
+                    description: typeof extra.description === "string" ? extra.description : null,
+                    installable: resolveLocalPluginRoot(mp, p) !== null,
+                };
+            }),
+        });
+    }
+    return out;
+}
+/** Remove empty cache parents left behind by uninstalls (best effort). */
+export function pruneCache(home) {
+    const root = join(home, "cache");
+    if (!isDirectory(root))
+        return;
+    const prune = (dir, depth) => {
+        if (depth === 0)
+            return;
+        for (const child of readdirSync(dir)) {
+            const path = join(dir, child);
+            if (!isDirectory(path))
+                continue;
+            prune(path, depth - 1);
+            try {
+                if (readdirSync(path).length === 0)
+                    rmSync(path, { recursive: true });
+            }
+            catch {
+                // best effort
+            }
+        }
+    };
+    prune(root, 2);
+}
+//# sourceMappingURL=pluginStore.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -34,13 +34,29 @@
   "main": "./dist/cli.js",
   "types": "./dist/cli.d.ts",
   "dependencies": {
+    "@anthropic-ai/sandbox-runtime": "0.0.74",
     "@earendil-works/pi-coding-agent": "0.84.1",
     "@earendil-works/pi-tui": "0.84.1",
+    "@grpc/grpc-js": "^1.14.4",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "pi-otel": "0.1.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.222.0",
+    "@opentelemetry/exporter-logs-otlp-grpc": "^0.222.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.222.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.222.0",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.222.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.222.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.222.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.222.0",
+    "@opentelemetry/resources": "^2.11.0",
+    "@opentelemetry/sdk-logs": "^0.222.0",
+    "@opentelemetry/sdk-metrics": "^2.11.0",
+    "@opentelemetry/sdk-trace": "^2.11.0",
     "smol-toml": "^1.8.0",
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "09cd57add6ba5c3028cc4f971459d5c7f9d4da97"
+  "yagniSourceSha": "49b4f1be0c81923619b1dd54a977da9653deee1d"
 }