@yagni-app/code 1.0.7 → 1.0.8

package/dist/extension/settingsFiles.js

@@ -0,0 +1,206 @@
+/**
+ * Shared settings-file plumbing for the three YAGNI Code settings tiers:
+ *   user    ~/.yagni-code/config.json                 (always trusted)
+ *   project .yagni-code/config.json under the cwd    (shared, committed)
+ *   local   .yagni-code/config.local.json under cwd  (personal, gitignored)
+ *
+ * Owns the atomic config mutation (promoted from sandbox/session.ts, the
+ * single copy now) and the global-gitignore helper (Claude Code
+ * addFileGlobRuleToGitignore parity): on the first write to the local file,
+ * the LOCAL_GITIGNORE_ENTRY glob lands in the GLOBAL git ignore file so
+ * personal settings are never committed. Fail-soft by design — a gitignore
+ * failure never fails the settings write.
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, appendFileSync, writeFileSync, renameSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { logEvent } from "./errorSink.js";
+const LOCAL_GITIGNORE_ENTRY = "**/.yagni-code/config.local.json";
+function isPlainRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Safe config-file mutation shared by every settings writer:
+ *  - a PARSE FAILURE aborts (never treats a corrupt/half-written file as
+ *    empty — that would wipe activeProfile/permissions);
+ *  - the write is ATOMIC (tmp file + rename) so a crash never truncates;
+ *  - symlinked targets are rejected (a hostile repo's config symlink must
+ *    not redirect writes to arbitrary paths);
+ *  - the mutator runs only on a parsed object; a thrown mutator aborts.
+ * Throws on any failure — callers decide fail-soft messaging.
+ */
+/**
+ * Reject when the target's EXISTING parent directory is a symlink — a
+ * hostile repo can commit a symlinked `.yagni-code` DIRECTORY, and every
+ * local-settings write would then land outside the repo via the symlinked
+ * parent (the final-component lstat guard cannot see this). The parent is
+ * the repo-committable component (`.yagni-code` for project/local targets,
+ * the state home for user targets); ancestors above it are the user's own
+ * filesystem, not repo-controlled. Absent parent is fine — mkdirSync
+ * creates it fresh, and mkdir does not follow a symlinked path segment it
+ * creates itself. Fail closed.
+ */
+function assertRealParentDir(target) {
+    const dir = dirname(target);
+    try {
+        const st = lstatSync(dir);
+        if (!st.isDirectory() || st.isSymbolicLink()) {
+            throw new Error(`${dir} is not a real directory (symlinked parent?) — refusing to write through it`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return; // absent — created fresh below
+        throw err;
+    }
+}
+export function mutateConfigJson(target, mutate) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(target, "utf-8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            parsed = {}; // genuinely fresh file — fine
+        }
+        else {
+            throw new Error(`config at ${target} is not valid JSON — refusing to rewrite it`);
+        }
+    }
+    if (!isPlainRecord(parsed))
+        throw new Error(`config at ${target} is not an object`);
+    const config = { ...parsed };
+    mutate(config);
+    mkdirSync(dirname(target), { recursive: true });
+    // Reject symlinked targets: lstat must show a regular file (or absent).
+    try {
+        const st = lstatSync(target);
+        if (!st.isFile())
+            throw new Error(`${target} is not a regular file (symlink?) — refusing`);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    // And a symlinked PARENT directory: a committed symlinked .yagni-code
+    // dir would redirect the write outside the project — the final-component
+    // guard above cannot see it.
+    assertRealParentDir(target);
+    const tmp = `${target}.yagni-tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+    writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+    // chmod: writeFile honors mode only on create — guarantee 0600 even when a
+    // same-pid retry reuses an existing tmp file.
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, target);
+}
+/** The project-local settings path for a session cwd. */
+export function localConfigPath(cwd) {
+    return join(cwd, ".yagni-code", "config.local.json");
+}
+/**
+ * Mutate the project-local settings file. Every write fire-and-forgets
+ * ensureLocalGitignored (Claude parity: the local tier is added to the
+ * global git ignore on write, not on session start). The helper is
+ * fire-and-forget BY DESIGN — the write's success notice is not gated on
+ * two git spawns; when the gitignore step is skipped or fails, the sink
+ * warn (gitignore_skipped / gitignore_update_failed) is the designed
+ * signal, surfaced via the diagnostics trail.
+ *
+ * `sinkSource` attributes those sink events to the caller's surface
+ * ("permission-rules" for rule saves, "sandbox" for panel/toggle writes) —
+ * the diagnostics trail then says which surface's write failed to get
+ * ignore-protected, not a blanket permission-rules line for every write.
+ */
+export function mutateLocalConfig(cwd, mutate, sinkSource = "permission-rules") {
+    mutateConfigJson(localConfigPath(cwd), mutate);
+    void ensureLocalGitignored(cwd, process.env, sinkSource);
+}
+// ---------------------------------------------------------------------------
+// Global-gitignore helper (Claude addFileGlobRuleToGitignore parity)
+// ---------------------------------------------------------------------------
+/** Run git <args> in cwd; resolves exit code (never throws). env threads
+ * through so the caller's PATH governs git resolution. */
+function git(cwd, args, env) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn("git", args, { cwd, env, stdio: "ignore" });
+            child.on("error", () => resolve(GIT_NOT_INSTALLED));
+            child.on("exit", (code) => resolve(code ?? GIT_NOT_INSTALLED));
+        }
+        catch {
+            resolve(GIT_NOT_INSTALLED);
+        }
+    });
+}
+const GIT_NOT_INSTALLED = -1;
+/**
+ * The global git ignore path git actually reads. Git consults
+ * $XDG_CONFIG_HOME/git/ignore (defaulting ~/.config/git/ignore) — honoring
+ * XDG is a deliberate divergence from Claude (which hardcodes ~/.config):
+ * writing a file git will not read when XDG is set would be a silent no-op.
+ */
+export function globalGitignorePath(env = process.env) {
+    const xdg = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.trim() !== "" ? env.XDG_CONFIG_HOME : null;
+    return join(xdg ?? join(homedir(), ".config"), "git", "ignore");
+}
+/**
+ * Ensure the LOCAL_GITIGNORE_ENTRY glob (covering config.local.json at any
+ * depth) is ignored by the user's GLOBAL git config so local settings are
+ * never committed. Skip when:
+ *  - cwd is not inside a git repo (nothing to protect);
+ *  - `git check-ignore` already matches (local or global patterns cover it);
+ *  - the global ignore file already carries the literal entry.
+ * Any failure logs one warn sink event and returns — the settings write it
+ * accompanies has already succeeded and must not be walked back.
+ */
+export async function ensureLocalGitignored(cwd, env = process.env, sinkSource = "permission-rules") {
+    try {
+        const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], env);
+        // -1 = git missing or failed to spawn — protection silently skipped; a
+        // warn makes that visible (the file exists un-ignored). 128 = cleanly
+        // not a repo — the documented skip, nothing to surface.
+        if (inside === GIT_NOT_INSTALLED) {
+            logEvent({
+                source: sinkSource,
+                level: "warn",
+                event: "gitignore_skipped",
+                fields: { reason: "git-unavailable" },
+            });
+            return;
+        }
+        // Not inside a repo (128) or a failed rev-parse: skip, nothing to do.
+        if (inside !== 0)
+            return;
+        // 0 = already ignored by some pattern (project .gitignore or global).
+        if ((await git(cwd, ["check-ignore", ".yagni-code/config.local.json"], env)) === 0)
+            return;
+        const path = globalGitignorePath(env);
+        mkdirSync(dirname(path), { recursive: true });
+        if (existsSync(path)) {
+            const content = readFileSync(path, "utf-8");
+            if (content.includes(LOCAL_GITIGNORE_ENTRY))
+                return;
+            appendFileSync(path, `${content.endsWith("\n") ? "" : "\n"}${LOCAL_GITIGNORE_ENTRY}\n`);
+        }
+        else {
+            writeFileSync(path, `${LOCAL_GITIGNORE_ENTRY}\n`, { mode: 0o644 });
+        }
+    }
+    catch (err) {
+        logEvent({
+            source: sinkSource,
+            level: "warn",
+            event: "gitignore_update_failed",
+            fields: {
+                path: globalGitignorePath(env),
+                // The thrown message names the failing operation and the local
+                // filesystem path (mkdir/append of the ignore file) — no secret
+                // surface, and it makes EACCES-vs-ENOSPC diagnosable.
+                error: err instanceof Error ? err.message : String(err),
+            },
+        });
+    }
+}
+//# sourceMappingURL=settingsFiles.js.map

package/dist/extension/telemetry/config.d.ts

@@ -37,7 +37,11 @@ export interface SignalConfig {
 export interface TelemetryIdentity {
     /** Bound workspace id (YAGNI_WORKSPACE_ID) → `organization.id`. */
     organizationId?: string;
-    /** The signed-in user's email when the launcher forwards it → `user.email`. */
+    /**
+     * The signed-in user's email → `user.email`. From `YAGNI_USER_EMAIL` when
+     * the launcher forwards it; otherwise learned from the /context boot fetch
+     * (`TelemetryHandle.setUserEmail`). Gated by `includeAccountId`.
+     */
     userEmail?: string;
     /** Shipping CLI version (YAGNI_CODE_VERSION) → `app.version`. */
     appVersion?: string;

package/dist/extension/telemetry/register.d.ts

@@ -27,6 +27,13 @@ export interface TelemetryHandle {
     toolDecision(input: ToolDecisionInput): void;
     /** The mode holder calls this on every /mode (or shift-tab) change. */
     permissionModeChanged(fromMode: string, toMode: string): void;
+    /**
+     * The entry calls this with the account email the /context boot fetch
+     * returned. A launcher-forwarded `YAGNI_USER_EMAIL` wins; otherwise every
+     * span, metric, and event from here on carries `user.email` (still subject
+     * to the `includeAccountId` gate).
+     */
+    setUserEmail(email: string | undefined): void;
     /** Test/introspection seam: the live tracker once the SDK is up. */
     readonly tracker: SessionTelemetry | null;
 }

package/dist/extension/telemetry/register.js

@@ -27,6 +27,7 @@ const NOOP_HANDLE = (config) => ({
     config,
     toolDecision: () => { },
     permissionModeChanged: () => { },
+    setUserEmail: () => { },
     tracker: null,
 });
 export function registerTelemetry(pi, deps = {}) {
@@ -187,6 +188,20 @@ export function registerTelemetry(pi, deps = {}) {
         },
         toolDecision: guard("tool_decision", (input) => tracker?.toolDecision(input)),
         permissionModeChanged: guard("permission_mode_changed", (from, to) => tracker?.permissionModeChanged(from, to)),
+        // Precedence, lowest to highest: this call (the /context boot fetch) <
+        // the launcher's YAGNI_USER_EMAIL, which resolveTelemetryConfig already
+        // placed on `identity`. So an identity that is set is never overwritten,
+        // whichever writer set it; a new writer must slot into this order
+        // explicitly rather than rely on call timing. The tracker reads
+        // `config.identity` on every attribute set, so this applies whether the
+        // SDK is already up or still lazy-loading.
+        setUserEmail: (email) => {
+            if (config.identity.userEmail)
+                return;
+            const trimmed = typeof email === "string" ? email.trim() : "";
+            if (trimmed)
+                config.identity.userEmail = trimmed;
+        },
     };
 }
 //# sourceMappingURL=register.js.map

package/dist/upgrade.js

@@ -249,13 +249,22 @@ export function parseUpgradeArgs(args) {
     }
     return { ok: true, target, method };
 }
+// npm's informational channels (deprecation warnings, the funding notice,
+// and npm ≥11.13's `allowScripts` notice) are noise under an upgrade the user
+// explicitly asked for; errors and the added-packages summary stay visible.
+// Note the allowScripts notice is advisory only: with the default (non-strict)
+// policy npm still runs the listed scripts, so quieting it changes nothing
+// functionally. Audit findings go to stdout, unaffected by --loglevel.
+const NPM_QUIET_FLAGS = ["--loglevel=error", "--no-fund", "--no-audit"];
 function installArgv(method, target) {
     // brew upgrades to whatever the tap formula publishes; it cannot pin a
     // version, so `target` only tells us an upgrade is worthwhile.
     if (method === "brew")
         return ["upgrade", BREW_FORMULA];
     const spec = `${PACKAGE_NAME}@${target}`;
-    return method === "npm" ? ["install", "-g", spec] : ["add", "-g", spec];
+    return method === "npm"
+        ? ["install", "-g", ...NPM_QUIET_FLAGS, spec]
+        : ["add", "-g", spec];
 }
 function failureHint(method) {
     if (method === "brew") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "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)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "49b4f1be0c81923619b1dd54a977da9653deee1d"
+  "yagniSourceSha": "9b213ea65690a4544d0cdf093b6903aab8a1456b"
 }