stagent 0.9.6 → 0.11.0

package/src/lib/instance/__tests__/detect.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir, homedir } from "os";
+
+let tempDir: string;
+let gitDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "stagent-detect-"));
+  gitDir = join(tempDir, ".git");
+  mkdirSync(gitDir, { recursive: true });
+  vi.resetModules();
+  vi.unstubAllEnvs();
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+async function loadDetect() {
+  return await import("../detect");
+}
+
+describe("isDevMode", () => {
+  it("returns true when STAGENT_DEV_MODE=true", async () => {
+    vi.stubEnv("STAGENT_DEV_MODE", "true");
+    const { isDevMode } = await loadDetect();
+    expect(isDevMode(tempDir)).toBe(true);
+  });
+
+  it("returns true when .git/stagent-dev-mode sentinel file exists", async () => {
+    writeFileSync(join(gitDir, "stagent-dev-mode"), "");
+    const { isDevMode } = await loadDetect();
+    expect(isDevMode(tempDir)).toBe(true);
+  });
+
+  it("returns false when neither gate is set", async () => {
+    const { isDevMode } = await loadDetect();
+    expect(isDevMode(tempDir)).toBe(false);
+  });
+
+  it("returns false when STAGENT_INSTANCE_MODE=true overrides env gate", async () => {
+    vi.stubEnv("STAGENT_DEV_MODE", "true");
+    vi.stubEnv("STAGENT_INSTANCE_MODE", "true");
+    const { isDevMode } = await loadDetect();
+    expect(isDevMode(tempDir)).toBe(false);
+  });
+
+  it("returns false when STAGENT_INSTANCE_MODE=true overrides sentinel gate", async () => {
+    writeFileSync(join(gitDir, "stagent-dev-mode"), "");
+    vi.stubEnv("STAGENT_INSTANCE_MODE", "true");
+    const { isDevMode } = await loadDetect();
+    expect(isDevMode(tempDir)).toBe(false);
+  });
+});
+
+describe("hasGitDir", () => {
+  it("returns true when .git directory exists", async () => {
+    const { hasGitDir } = await loadDetect();
+    expect(hasGitDir(tempDir)).toBe(true);
+  });
+
+  it("returns false when .git is absent", async () => {
+    rmSync(gitDir, { recursive: true, force: true });
+    const { hasGitDir } = await loadDetect();
+    expect(hasGitDir(tempDir)).toBe(false);
+  });
+});
+
+describe("isPrivateInstance", () => {
+  it("returns false when STAGENT_DATA_DIR is unset", async () => {
+    vi.stubEnv("STAGENT_DATA_DIR", "");
+    const { isPrivateInstance } = await loadDetect();
+    expect(isPrivateInstance()).toBe(false);
+  });
+
+  it("returns false when STAGENT_DATA_DIR equals default ~/.stagent", async () => {
+    vi.stubEnv("STAGENT_DATA_DIR", join(homedir(), ".stagent"));
+    const { isPrivateInstance } = await loadDetect();
+    expect(isPrivateInstance()).toBe(false);
+  });
+
+  it("returns true when STAGENT_DATA_DIR is a custom path", async () => {
+    vi.stubEnv("STAGENT_DATA_DIR", "/Users/navam/.stagent-wealth");
+    const { isPrivateInstance } = await loadDetect();
+    expect(isPrivateInstance()).toBe(true);
+  });
+
+  it("returns false when STAGENT_DATA_DIR equals default with trailing slash", async () => {
+    vi.stubEnv("STAGENT_DATA_DIR", join(homedir(), ".stagent") + "/");
+    const { isPrivateInstance } = await loadDetect();
+    expect(isPrivateInstance()).toBe(false);
+  });
+});
+
+describe("detectRebaseInProgress", () => {
+  it("returns true when .git/rebase-merge exists", async () => {
+    mkdirSync(join(gitDir, "rebase-merge"));
+    const { detectRebaseInProgress } = await loadDetect();
+    expect(detectRebaseInProgress(tempDir)).toBe(true);
+  });
+
+  it("returns true when .git/rebase-apply exists", async () => {
+    mkdirSync(join(gitDir, "rebase-apply"));
+    const { detectRebaseInProgress } = await loadDetect();
+    expect(detectRebaseInProgress(tempDir)).toBe(true);
+  });
+
+  it("returns false when no rebase state directories exist", async () => {
+    const { detectRebaseInProgress } = await loadDetect();
+    expect(detectRebaseInProgress(tempDir)).toBe(false);
+  });
+});

package/src/lib/instance/__tests__/fingerprint.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+beforeEach(() => {
+  vi.resetModules();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("getMachineFingerprint", () => {
+  it("returns a 64-character hex SHA-256 string", async () => {
+    const { getMachineFingerprint, _resetFingerprintCache } = await import("../fingerprint");
+    _resetFingerprintCache();
+    const fp = getMachineFingerprint();
+    expect(fp).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it("is stable across multiple calls in the same process (memoized)", async () => {
+    const { getMachineFingerprint, _resetFingerprintCache } = await import("../fingerprint");
+    _resetFingerprintCache();
+    const fp1 = getMachineFingerprint();
+    const fp2 = getMachineFingerprint();
+    const fp3 = getMachineFingerprint();
+    expect(fp1).toBe(fp2);
+    expect(fp2).toBe(fp3);
+  });
+
+  it("does not contain the raw hostname, username, or MAC address", async () => {
+    const os = await import("os");
+    const host = os.hostname();
+    const user = os.userInfo().username;
+
+    const { getMachineFingerprint, _resetFingerprintCache } = await import("../fingerprint");
+    _resetFingerprintCache();
+    const fp = getMachineFingerprint();
+
+    expect(fp).not.toContain(host);
+    expect(fp).not.toContain(user);
+    expect(fp).not.toMatch(/[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}/i); // no MAC pattern
+  });
+
+  // Note: an ideal test here would mock os.hostname() to verify the
+  // fingerprint changes when hostname changes, but Node's "os" module
+  // exports are non-configurable in ESM and vi.spyOn throws
+  // "Cannot redefine property: hostname". The behavior is covered
+  // indirectly by the memoization and composition tests above.
+});

package/src/lib/instance/__tests__/git-ops.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { execFileSync } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+let tempDir: string;
+
+function runGit(args: string[], cwd: string) {
+  execFileSync("git", args, { cwd, stdio: "pipe" });
+}
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "stagent-git-ops-"));
+  runGit(["init", "-b", "main"], tempDir);
+  runGit(["config", "user.email", "test@example.com"], tempDir);
+  runGit(["config", "user.name", "Test"], tempDir);
+  writeFileSync(join(tempDir, "README.md"), "# test\n");
+  runGit(["add", "README.md"], tempDir);
+  runGit(["commit", "-m", "initial"], tempDir);
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("RealGitOps", () => {
+  it("isGitRepo returns true in a real repo", async () => {
+    const { createGitOps } = await import("../git-ops");
+    const ops = createGitOps(tempDir);
+    expect(ops.isGitRepo()).toBe(true);
+  });
+
+  it("isGitRepo returns false outside a git repo", async () => {
+    const nonRepo = mkdtempSync(join(tmpdir(), "stagent-nogit-"));
+    try {
+      const { createGitOps } = await import("../git-ops");
+      const ops = createGitOps(nonRepo);
+      expect(ops.isGitRepo()).toBe(false);
+    } finally {
+      rmSync(nonRepo, { recursive: true, force: true });
+    }
+  });
+
+  it("getCurrentBranch returns main after init", async () => {
+    const { createGitOps } = await import("../git-ops");
+    const ops = createGitOps(tempDir);
+    expect(ops.getCurrentBranch()).toBe("main");
+  });
+
+  it("branchExists returns true for main, false for missing", async () => {
+    const { createGitOps } = await import("../git-ops");
+    const ops = createGitOps(tempDir);
+    expect(ops.branchExists("main")).toBe(true);
+    expect(ops.branchExists("local")).toBe(false);
+  });
+
+  it("createAndCheckoutBranch creates local at current HEAD", async () => {
+    const { createGitOps } = await import("../git-ops");
+    const ops = createGitOps(tempDir);
+    const mainSha = execFileSync("git", ["rev-parse", "main"], { cwd: tempDir, encoding: "utf-8" }).trim();
+    ops.createAndCheckoutBranch("local");
+    expect(ops.getCurrentBranch()).toBe("local");
+    expect(ops.branchExists("local")).toBe(true);
+    const localSha = execFileSync("git", ["rev-parse", "local"], { cwd: tempDir, encoding: "utf-8" }).trim();
+    expect(localSha).toBe(mainSha);
+    // main is not modified
+    const mainShaAfter = execFileSync("git", ["rev-parse", "main"], { cwd: tempDir, encoding: "utf-8" }).trim();
+    expect(mainShaAfter).toBe(mainSha);
+  });
+
+  it("setConfig writes branch.local.pushRemote", async () => {
+    const { createGitOps } = await import("../git-ops");
+    const ops = createGitOps(tempDir);
+    ops.createAndCheckoutBranch("local");
+    ops.setConfig("branch.local.pushRemote", "no_push");
+    const value = execFileSync("git", ["config", "--get", "branch.local.pushRemote"], { cwd: tempDir, encoding: "utf-8" }).trim();
+    expect(value).toBe("no_push");
+  });
+
+  it("getGitDir returns absolute path to .git directory", async () => {
+    const { createGitOps } = await import("../git-ops");
+    const ops = createGitOps(tempDir);
+    expect(ops.getGitDir()).toBe(join(tempDir, ".git"));
+  });
+
+  it("getCurrentBranch returns null when HEAD is detached", async () => {
+    // Detach HEAD by checking out the commit SHA directly
+    const sha = execFileSync("git", ["rev-parse", "HEAD"], { cwd: tempDir, encoding: "utf-8" }).trim();
+    execFileSync("git", ["checkout", sha], { cwd: tempDir, stdio: "pipe" });
+    const { createGitOps } = await import("../git-ops");
+    const ops = createGitOps(tempDir);
+    expect(ops.getCurrentBranch()).toBeNull();
+  });
+});

package/src/lib/instance/__tests__/settings.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "stagent-instance-settings-"));
+  vi.resetModules();
+  vi.stubEnv("STAGENT_DATA_DIR", tempDir);
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+async function loadModule() {
+  return await import("../settings");
+}
+
+describe("getInstanceConfig / setInstanceConfig", () => {
+  it("returns null before any config is written", async () => {
+    const { getInstanceConfig } = await loadModule();
+    expect(getInstanceConfig()).toBeNull();
+  });
+
+  it("round-trips a config through set/get", async () => {
+    const { setInstanceConfig, getInstanceConfig } = await loadModule();
+    await setInstanceConfig({
+      instanceId: "abc-123",
+      branchName: "local",
+      isPrivateInstance: false,
+      createdAt: 1700000000,
+    });
+    const config = getInstanceConfig();
+    expect(config).toEqual({
+      instanceId: "abc-123",
+      branchName: "local",
+      isPrivateInstance: false,
+      createdAt: 1700000000,
+    });
+  });
+
+  it("returns null when stored value is corrupt JSON", async () => {
+    const { setSetting } = await import("@/lib/settings/helpers");
+    await setSetting("instance", "not-valid-json");
+    const { getInstanceConfig } = await loadModule();
+    expect(getInstanceConfig()).toBeNull();
+  });
+});
+
+describe("getGuardrails / setGuardrails", () => {
+  it("returns defaults before any guardrails are written", async () => {
+    const { getGuardrails } = await loadModule();
+    expect(getGuardrails()).toEqual({
+      prePushHookInstalled: false,
+      prePushHookVersion: "",
+      pushRemoteBlocked: [],
+      consentStatus: "not_yet",
+      firstBootCompletedAt: null,
+    });
+  });
+
+  it("round-trips guardrails through set/get", async () => {
+    const { setGuardrails, getGuardrails } = await loadModule();
+    await setGuardrails({
+      prePushHookInstalled: true,
+      prePushHookVersion: "1.0.0",
+      pushRemoteBlocked: ["local", "wealth-mgr"],
+      consentStatus: "enabled",
+      firstBootCompletedAt: 1700000000,
+    });
+    expect(getGuardrails()).toEqual({
+      prePushHookInstalled: true,
+      prePushHookVersion: "1.0.0",
+      pushRemoteBlocked: ["local", "wealth-mgr"],
+      consentStatus: "enabled",
+      firstBootCompletedAt: 1700000000,
+    });
+  });
+});

package/src/lib/instance/__tests__/upgrade-poller.test.ts

@@ -0,0 +1,181 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { execFileSync } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+let tempDir: string;
+let dataDir: string;
+
+function runGit(args: string[], cwd: string) {
+  execFileSync("git", args, { cwd, stdio: "pipe" });
+}
+
+function initRepo(dir: string) {
+  runGit(["init", "-b", "main"], dir);
+  runGit(["config", "user.email", "test@example.com"], dir);
+  runGit(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  runGit(["add", "README.md"], dir);
+  runGit(["commit", "-m", "initial"], dir);
+}
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "stagent-upgrade-poller-"));
+  dataDir = mkdtempSync(join(tmpdir(), "stagent-upgrade-poller-data-"));
+  initRepo(tempDir);
+  vi.resetModules();
+  vi.unstubAllEnvs();
+  vi.stubEnv("STAGENT_DATA_DIR", dataDir);
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  rmSync(tempDir, { recursive: true, force: true });
+  rmSync(dataDir, { recursive: true, force: true });
+});
+
+describe("tick", () => {
+  it("returns skipped=dev_mode_or_no_git when STAGENT_DEV_MODE=true", async () => {
+    vi.stubEnv("STAGENT_DEV_MODE", "true");
+    const { tick } = await import("../upgrade-poller");
+    const result = await tick(tempDir);
+    expect(result.skipped).toBe("dev_mode_or_no_git");
+  });
+
+  it("returns skipped=dev_mode_or_no_git when .git is absent", async () => {
+    const noGitDir = mkdtempSync(join(tmpdir(), "stagent-nogit-"));
+    try {
+      const { tick } = await import("../upgrade-poller");
+      const result = await tick(noGitDir);
+      expect(result.skipped).toBe("dev_mode_or_no_git");
+    } finally {
+      rmSync(noGitDir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns skipped=fetch_failed and records failure count when fetch fails (no remote)", async () => {
+    // No origin configured → fetch will fail
+    const { tick } = await import("../upgrade-poller");
+    const result = await tick(tempDir);
+    expect(result.skipped).toBe("fetch_failed");
+    expect(result.error).toBeDefined();
+    const { getUpgradeState } = await import("../settings");
+    const state = getUpgradeState();
+    expect(state.pollFailureCount).toBe(1);
+    expect(state.lastPollError).toBeTruthy();
+    expect(state.lastPolledAt).not.toBeNull();
+  });
+
+  it("increments pollFailureCount on repeated failures", async () => {
+    const { tick } = await import("../upgrade-poller");
+    await tick(tempDir);
+    await tick(tempDir);
+    await tick(tempDir);
+    const { getUpgradeState } = await import("../settings");
+    expect(getUpgradeState().pollFailureCount).toBe(3);
+  });
+
+  it("inserts one failure notification after 3 consecutive failures, dedupes on the 4th, clears on success", async () => {
+    const { tick } = await import("../upgrade-poller");
+    const { db } = await import("@/lib/db");
+    const { notifications } = await import("@/lib/db/schema");
+    const { eq, and, isNull } = await import("drizzle-orm");
+
+    // 2 failures: no notification yet
+    await tick(tempDir);
+    await tick(tempDir);
+    let open = await db
+      .select()
+      .from(notifications)
+      .where(and(eq(notifications.toolName, "upgrade_check_failing"), isNull(notifications.respondedAt)));
+    expect(open).toHaveLength(0);
+
+    // 3rd failure: notification created
+    await tick(tempDir);
+    open = await db
+      .select()
+      .from(notifications)
+      .where(and(eq(notifications.toolName, "upgrade_check_failing"), isNull(notifications.respondedAt)));
+    expect(open).toHaveLength(1);
+    expect(open[0].title).toBe("Upgrade check failing");
+    expect(open[0].body).toContain("Last 3 upgrade checks failed");
+
+    // 4th failure: still exactly one open notification (deduped)
+    await tick(tempDir);
+    open = await db
+      .select()
+      .from(notifications)
+      .where(and(eq(notifications.toolName, "upgrade_check_failing"), isNull(notifications.respondedAt)));
+    expect(open).toHaveLength(1);
+
+    // Success clears the notification
+    const bareDir = mkdtempSync(join(tmpdir(), "stagent-bare-"));
+    try {
+      runGit(["init", "--bare", "-b", "main"], bareDir);
+      runGit(["remote", "add", "origin", bareDir], tempDir);
+      runGit(["push", "origin", "main"], tempDir);
+      await tick(tempDir);
+      open = await db
+        .select()
+        .from(notifications)
+        .where(and(eq(notifications.toolName, "upgrade_check_failing"), isNull(notifications.respondedAt)));
+      expect(open).toHaveLength(0);
+    } finally {
+      rmSync(bareDir, { recursive: true, force: true });
+    }
+  });
+
+  it("successfully updates state with zero commitsBehind when local == origin/main", async () => {
+    // Set up a local 'origin' remote pointing to a bare copy of the same repo
+    const bareDir = mkdtempSync(join(tmpdir(), "stagent-bare-"));
+    try {
+      runGit(["init", "--bare", "-b", "main"], bareDir);
+      runGit(["remote", "add", "origin", bareDir], tempDir);
+      runGit(["push", "origin", "main"], tempDir);
+
+      const { tick } = await import("../upgrade-poller");
+      const result = await tick(tempDir);
+      expect(result.updated).toBeDefined();
+      expect(result.updated!.commitsBehind).toBe(0);
+      expect(result.updated!.upgradeAvailable).toBe(false);
+      expect(result.updated!.pollFailureCount).toBe(0);
+      expect(result.updated!.lastUpstreamSha).toBeTruthy();
+      expect(result.updated!.localMainSha).toBe(result.updated!.lastUpstreamSha);
+    } finally {
+      rmSync(bareDir, { recursive: true, force: true });
+    }
+  });
+
+  it("detects commits-behind when origin has new commits not in local main", async () => {
+    const bareDir = mkdtempSync(join(tmpdir(), "stagent-bare-"));
+    const otherCloneDir = mkdtempSync(join(tmpdir(), "stagent-other-"));
+    try {
+      runGit(["init", "--bare", "-b", "main"], bareDir);
+      runGit(["remote", "add", "origin", bareDir], tempDir);
+      runGit(["push", "origin", "main"], tempDir);
+
+      // Clone, add 2 commits, push back to bare
+      runGit(["clone", bareDir, otherCloneDir], otherCloneDir + "/..");
+      runGit(["config", "user.email", "test@example.com"], otherCloneDir);
+      runGit(["config", "user.name", "Test"], otherCloneDir);
+      writeFileSync(join(otherCloneDir, "a.txt"), "a\n");
+      runGit(["add", "a.txt"], otherCloneDir);
+      runGit(["commit", "-m", "a"], otherCloneDir);
+      writeFileSync(join(otherCloneDir, "b.txt"), "b\n");
+      runGit(["add", "b.txt"], otherCloneDir);
+      runGit(["commit", "-m", "b"], otherCloneDir);
+      runGit(["push", "origin", "main"], otherCloneDir);
+
+      const { tick } = await import("../upgrade-poller");
+      const result = await tick(tempDir);
+      expect(result.updated).toBeDefined();
+      expect(result.updated!.commitsBehind).toBe(2);
+      expect(result.updated!.upgradeAvailable).toBe(true);
+      expect(result.updated!.lastUpstreamSha).not.toBe(result.updated!.localMainSha);
+    } finally {
+      rmSync(bareDir, { recursive: true, force: true });
+      rmSync(otherCloneDir, { recursive: true, force: true });
+    }
+  });
+});