@yagni-app/code 1.0.5 → 1.0.7

package/dist/goHeadless.d.ts

@@ -65,7 +65,7 @@ export declare function buildHeadlessChildEnv(opts: {
     workspaceId?: string;
     cliVersion?: string;
     sessionId?: string;
-    /** Resolved OTel export config; stage children load pi-otel when present. */
+    /** Resolved OTel export config; stage children export when present. */
     otel?: OtelLaunchConfig;
 }): NodeJS.ProcessEnv;
 /**

package/dist/goHeadless.js

@@ -55,8 +55,8 @@ export function buildHeadlessChildEnv(opts) {
         PI_CODING_AGENT_DIR: piAgentDir,
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
-        // OTel export: pin metadata-only capture and forward pi-otel's path so
-        // every stage child spawns with it (see otel.ts for the policy).
+        // OTel export: the gate plus the OTLP env, inherited by every stage child
+        // (see otel.ts for the policy).
         ...(opts.otel ? otelChildEnv(opts.otel, opts.baseEnv) : {}),
     };
 }

package/dist/launch.d.ts

@@ -95,9 +95,10 @@ export interface BuildLaunchOptions {
     extraEnv?: Record<string, string>;
     /**
      * Resolved OTel export config (see `otel.ts`). When present, the session
-     * loads pi-otel alongside our extension and the env pins metadata-only
-     * capture; absent means no OTLP endpoint is configured and the launch is
-     * byte-for-byte what it was before OTel support existed.
+     * env carries the export gate and the OTLP variables and the bundled
+     * extension exports traces, metrics, and log events; absent means no OTLP
+     * endpoint is configured and the launch is byte-for-byte what it was
+     * before OTel support existed.
      */
     otel?: OtelLaunchConfig;
 }

package/dist/launch.js

@@ -9,6 +9,7 @@ import { randomUUID } from "node:crypto";
 import { agentDirEnvVar } from "./branding.js";
 import { otelChildEnv } from "./otel.js";
 import { PAD_X_ENV, resolvePadX } from "./padding.js";
+import { resolveCliPath } from "./paths.js";
 import { ENGINEERING_PRACTICE_SECTION, promptEnrichmentDisabled } from "./promptEnrichment.js";
 /**
  * How close to expiry the token can be before launch warns. A coding session
@@ -76,6 +77,9 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // the launcher read (0600). Absent when the caller can't resolve it.
         ...(opts.profilePath ? { YAGNI_PROFILE_PATH: opts.profilePath } : {}),
         ...(opts.stateDir ? { YAGNI_CODE_HOME: opts.stateDir } : {}),
+        // The launcher's own entry, so the in-session /plugin panel and
+        // /reload-plugins can run `yagni plugin …` with the same binary.
+        YAGNI_CLI_PATH: resolveCliPath(),
         // Forward the launcher's version so the extension's crash reports carry
         // the shipping version (the bundled extension has no package.json to read).
         ...(opts.cliVersion ? { YAGNI_CODE_VERSION: opts.cliVersion } : {}),
@@ -106,9 +110,9 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // the editor (which the launcher pads by seeding editorPaddingX). The
         // footer can't read pi's settings, so the value crosses over env.
         [PAD_X_ENV]: String(resolvePadX()),
-        // OTel export (gated in otel.ts): pin metadata-only capture and forward
-        // pi-otel's path so /go stage children and subagents load it too. Placed
-        // after baseEnv on purpose — the capture pin must beat a user env override.
+        // OTel export (gated in otel.ts): the YAGNI_OTEL_EXPORT gate plus the
+        // workspace's OTLP env; the bundled extension does the exporting, and
+        // /go stage children and subagents inherit this env so they export too.
         ...(opts.otel ? otelChildEnv(opts.otel, opts.baseEnv ?? {}) : {}),
     };
     // Always load our extension. Default the provider to `yagni` unless the user
@@ -130,7 +134,6 @@ export function buildLaunch(creds, passthroughArgs, opts) {
     const argv = [
         "-e",
         opts.extensionPath,
-        ...(opts.otel ? ["-e", opts.otel.extensionPath] : []),
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
         ...(userChoseModel ? [] : ["--model", "advanced"]),
         ...(enrichmentOff ? [] : ["--append-system-prompt", ENGINEERING_PRACTICE_SECTION]),

package/dist/mcpCommand.d.ts

@@ -0,0 +1,122 @@
+/**
+ * `yagni mcp …` — configure MCP servers for YAGNI Code, mirroring Claude
+ * Code's CLI surface (add / add-json / remove / get / list /
+ * reset-project-choices / add-from-claude).
+ *
+ * The config module itself lives in pi-extension-yagni (`src/mcp/config.ts`)
+ * so the extension session and this CLI read and write the exact same files
+ * through the exact same code — loaded here by file path, the same pattern as
+ * the session-worktree and headless-go entries. `list` and `get` run real
+ * health-check connections (stdio servers are spawned), so they carry the
+ * same caution Claude Code prints: only run in directories you trust.
+ *
+ * Not implemented (deliberate deviations from Claude Code):
+ *   serve   — the YAGNI backend already exposes an MCP endpoint
+ *   login   — enterprise-IdP only in Claude Code; not applicable
+ */
+export interface McpDeps {
+    cwd?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+    /** Test seam: the extension module to import (defaults to the built copy). */
+    loadMcpModule?: () => Promise<McpCliModule>;
+    /**
+     * Test seam: the plugin MCP payload the launcher would hand a session
+     * (defaults to running the real, non-interactive discovery). Lets `list`
+     * and `get` show plugin-bundled servers outside a session.
+     */
+    pluginMcpEnv?: () => Promise<string | undefined>;
+    /** Test seam: health probe override (defaults to mod.probeServer). */
+    probeServer?: (name: string, config: unknown, opts?: {
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<{
+        status: "connected" | "needs_auth" | "failed";
+        error?: string;
+    }>;
+}
+/** The structural slice of the extension's mcp config surface this file needs. */
+export interface McpCliModule {
+    loadMcpServers(cwd: string, env: NodeJS.ProcessEnv): McpLoadResult;
+    mcpConfigPath(): string;
+    PROJECT_CONFIG_FILENAME: string;
+    writeUserMcpConfig(file: unknown): void;
+    readUserMcpConfig(): {
+        file: unknown;
+        errors: unknown[];
+    };
+    resolveProjectRoot(cwd: string): string;
+    resetProjectChoices(repoRoot: string): {
+        errors: unknown[];
+    };
+    decisionFor(state: unknown, serverName: string): "enabled" | "disabled" | "undecided";
+    readProjectApproval(repoRoot: string): {
+        state: unknown;
+        errors: unknown[];
+    };
+    updateStoredOAuthEntry(serverName: string, config: unknown, mutate: (entry: {
+        clientSecret?: string;
+    }) => void): {
+        errors: unknown[];
+    };
+    revokeTokensOnRemove(serverName: string, config: unknown, deps?: {
+        fetch?: typeof fetch;
+    }): Promise<void>;
+    getStoredOAuthEntry(serverName: string, config: unknown): {
+        clientSecret?: string;
+    } | undefined;
+    probeServer(name: string, config: unknown, opts?: {
+        connectTimeoutMs?: number;
+        env?: NodeJS.ProcessEnv;
+    }): Promise<{
+        status: "connected" | "needs_auth" | "failed";
+        error?: string;
+    }>;
+    /** ${VAR} expansion over a full server config (url, headers, command, args, env values). */
+    expandServerEnv?(config: unknown, env?: NodeJS.ProcessEnv): {
+        config: unknown;
+        missingVars: string[];
+    };
+}
+export type McpListScope = "user" | "project" | "local" | "plugin";
+export interface McpLoadResult {
+    servers: {
+        name: string;
+        scope: McpListScope;
+        config: Record<string, unknown>;
+        sourcePath: string;
+        plugin?: string;
+        gated?: boolean;
+    }[];
+    errors: {
+        sourcePath: string;
+        serverName?: string;
+        message: string;
+    }[];
+}
+export declare function resolveMcpConfigPath(): string;
+export interface ParsedMcpArgs {
+    subcommand: string | undefined;
+    name?: string;
+    rest: string[];
+    scope: "local" | "user" | "project";
+    /** Whether -s/--scope appeared explicitly (remove without it acts across scopes). */
+    scopeExplicit: boolean;
+    transport: "stdio" | "sse" | "http";
+    /** Whether -t/--transport appeared explicitly (drives the URL-misread warning). */
+    transportExplicit: boolean;
+    env: Record<string, string>;
+    headers: Record<string, string>;
+    /** Positionals after the subcommand's own first two (stdio command args). */
+    commandArgs: string[];
+    /** OAuth client id (-only). */
+    clientId?: string;
+    /** Whether --client-secret was passed (prompt/env-read the secret). */
+    clientSecret: boolean;
+    /** Fixed loopback callback port. */
+    callbackPort?: number;
+}
+export declare function parseMcpArgs(argv: string[]): ParsedMcpArgs;
+export declare function mcpCommand(args: string[], deps?: McpDeps): Promise<number>;
+//# sourceMappingURL=mcpCommand.d.ts.map