@simplysm/sd-claude 13.0.69 → 13.0.71

package/tests/auth-remove.spec.ts

@@ -0,0 +1,74 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { runAuthRemove } from "../src/commands/auth-remove";
+
+describe("runAuthRemove", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-claude-auth-remove-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  test("removes profile directory successfully", () => {
+    // Set up a profile directory with auth.json
+    const profileDir = path.join(tmpDir, ".sd-claude", "auth", "work");
+    fs.mkdirSync(profileDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(profileDir, "auth.json"),
+      JSON.stringify({ userID: "user-123", oauthAccount: {} }),
+    );
+    fs.writeFileSync(
+      path.join(profileDir, "credentials.json"),
+      JSON.stringify({ accessToken: "abc" }),
+    );
+
+    // Set up .claude.json with a DIFFERENT userID (not active)
+    fs.writeFileSync(path.join(tmpDir, ".claude.json"), JSON.stringify({ userID: "user-999" }));
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    runAuthRemove("work", tmpDir);
+
+    expect(fs.existsSync(profileDir)).toBe(false);
+    expect(logSpy).toHaveBeenCalledWith("Removed profile 'work'");
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  test("warns when removing active profile (still removes it)", () => {
+    // Set up a profile directory with auth.json
+    const profileDir = path.join(tmpDir, ".sd-claude", "auth", "work");
+    fs.mkdirSync(profileDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(profileDir, "auth.json"),
+      JSON.stringify({ userID: "user-123", oauthAccount: {} }),
+    );
+
+    // Set up .claude.json with the SAME userID (active)
+    fs.writeFileSync(path.join(tmpDir, ".claude.json"), JSON.stringify({ userID: "user-123" }));
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    runAuthRemove("work", tmpDir);
+
+    expect(fs.existsSync(profileDir)).toBe(false);
+    expect(warnSpy).toHaveBeenCalledWith("Warning: 'work' is currently active.");
+    expect(logSpy).toHaveBeenCalledWith("Removed profile 'work'");
+  });
+
+  test("throws when profile not found", () => {
+    expect(() => runAuthRemove("nonexistent", tmpDir)).toThrow("Profile 'nonexistent' not found.");
+  });
+
+  test("throws with invalid name", () => {
+    expect(() => runAuthRemove("BAD NAME!", tmpDir)).toThrow("Invalid name");
+  });
+});

package/tests/auth-use.spec.ts

@@ -0,0 +1,153 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { runAuthUse } from "../src/commands/auth-use";
+
+describe("runAuthUse", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-claude-auth-use-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+    vi.restoreAllMocks();
+  });
+
+  function setupProfile(name: string, opts?: { expiresAt?: number }): void {
+    const profileDir = path.join(tmpDir, ".sd-claude", "auth", name);
+    fs.mkdirSync(profileDir, { recursive: true });
+
+    const authJson = {
+      oauthAccount: { emailAddress: "work@example.com", token: "oauth-work" },
+      userID: "user-work-456",
+    };
+    fs.writeFileSync(path.join(profileDir, "auth.json"), JSON.stringify(authJson));
+
+    const credJson = {
+      claudeAiOauth: {
+        accessToken: "saved-access-token",
+        refreshToken: "saved-refresh-token",
+        expiresAt: opts?.expiresAt ?? Date.now() + 3_600_000,
+      },
+    };
+    fs.writeFileSync(path.join(profileDir, "credentials.json"), JSON.stringify(credJson));
+  }
+
+  function setupClaudeJson(extra?: Record<string, unknown>): void {
+    const claudeJson = {
+      oauthAccount: { emailAddress: "old@example.com", token: "old-token" },
+      userID: "user-old-111",
+      someCustomSetting: "preserve-me",
+      anotherField: 42,
+      ...extra,
+    };
+    fs.writeFileSync(path.join(tmpDir, ".claude.json"), JSON.stringify(claudeJson));
+  }
+
+  function setupCredentialsJson(): void {
+    const claudeDir = path.join(tmpDir, ".claude");
+    fs.mkdirSync(claudeDir, { recursive: true });
+    const credentials = { oldKey: "old-value", claudeAiOauth: { accessToken: "old-access" } };
+    fs.writeFileSync(path.join(claudeDir, ".credentials.json"), JSON.stringify(credentials));
+  }
+
+  test("replaces oauthAccount and userID while preserving other fields in ~/.claude.json", () => {
+    setupProfile("work");
+    setupClaudeJson();
+    setupCredentialsJson();
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    runAuthUse("work", tmpDir);
+
+    const result = JSON.parse(
+      fs.readFileSync(path.join(tmpDir, ".claude.json"), "utf-8"),
+    ) as Record<string, unknown>;
+
+    // oauthAccount and userID should be replaced
+    expect(result["oauthAccount"]).toEqual({
+      emailAddress: "work@example.com",
+      token: "oauth-work",
+    });
+    expect(result["userID"]).toBe("user-work-456");
+
+    // Other fields must be preserved
+    expect(result["someCustomSetting"]).toBe("preserve-me");
+    expect(result["anotherField"]).toBe(42);
+
+    logSpy.mockRestore();
+  });
+
+  test("replaces credentials.json entirely", () => {
+    setupProfile("work");
+    setupClaudeJson();
+    setupCredentialsJson();
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    runAuthUse("work", tmpDir);
+
+    const result = JSON.parse(
+      fs.readFileSync(path.join(tmpDir, ".claude", ".credentials.json"), "utf-8"),
+    ) as Record<string, unknown>;
+
+    // Should be entirely replaced with saved credentials (no oldKey)
+    expect(result).toEqual({
+      claudeAiOauth: {
+        accessToken: "saved-access-token",
+        refreshToken: "saved-refresh-token",
+        expiresAt: expect.any(Number) as number,
+      },
+    });
+    expect(result["oldKey"]).toBeUndefined();
+
+    logSpy.mockRestore();
+  });
+
+  test("warns when token is expired (should not throw)", () => {
+    const expiredTime = Date.now() - 1_000;
+    setupProfile("work", { expiresAt: expiredTime });
+    setupClaudeJson();
+    setupCredentialsJson();
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    // Should NOT throw
+    expect(() => runAuthUse("work", tmpDir)).not.toThrow();
+
+    // Should warn about expired token
+    expect(warnSpy).toHaveBeenCalledWith("Warning: Token expired. Run /login after switching.");
+
+    warnSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  test("throws when profile not found", () => {
+    setupClaudeJson();
+    setupCredentialsJson();
+
+    expect(() => runAuthUse("nonexistent", tmpDir)).toThrow("Profile 'nonexistent' not found.");
+  });
+
+  test("throws with invalid name", () => {
+    expect(() => runAuthUse("BAD NAME!", tmpDir)).toThrow("Invalid name");
+  });
+
+  test("logs switched message with name and email", () => {
+    setupProfile("work");
+    setupClaudeJson();
+    setupCredentialsJson();
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    runAuthUse("work", tmpDir);
+
+    expect(logSpy).toHaveBeenCalledWith("Switched to work (work@example.com)");
+
+    logSpy.mockRestore();
+  });
+});

package/tests/auth-utils.spec.ts

@@ -0,0 +1,173 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import {
+  validateName,
+  getProfileDir,
+  profileExists,
+  listProfiles,
+  readCurrentAuth,
+  readCurrentCredentials,
+  getCurrentUserID,
+} from "../src/commands/auth-utils";
+
+describe("auth-utils", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-claude-auth-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  describe("validateName", () => {
+    test("accepts lowercase letters", () => {
+      expect(() => validateName("abc")).not.toThrow();
+    });
+
+    test("accepts digits", () => {
+      expect(() => validateName("123")).not.toThrow();
+    });
+
+    test("accepts hyphens and underscores", () => {
+      expect(() => validateName("my-profile_1")).not.toThrow();
+    });
+
+    test("rejects uppercase letters", () => {
+      expect(() => validateName("ABC")).toThrow();
+    });
+
+    test("rejects spaces", () => {
+      expect(() => validateName("my profile")).toThrow();
+    });
+
+    test("rejects special characters", () => {
+      expect(() => validateName("my@profile")).toThrow();
+    });
+
+    test("rejects empty string", () => {
+      expect(() => validateName("")).toThrow();
+    });
+
+    test("error message includes the invalid name", () => {
+      expect(() => validateName("BAD!")).toThrow(/BAD!/);
+    });
+  });
+
+  describe("getProfileDir", () => {
+    test("returns correct path with homeDir", () => {
+      const result = getProfileDir("work", tmpDir);
+      expect(result).toBe(path.join(tmpDir, ".sd-claude", "auth", "work"));
+    });
+
+    test("uses os.homedir when homeDir is not provided", () => {
+      const result = getProfileDir("test");
+      expect(result).toBe(path.join(os.homedir(), ".sd-claude", "auth", "test"));
+    });
+  });
+
+  describe("profileExists", () => {
+    test("returns false when profile directory does not exist", () => {
+      expect(profileExists("nonexistent", tmpDir)).toBe(false);
+    });
+
+    test("returns true when profile directory exists", () => {
+      const profileDir = path.join(tmpDir, ".sd-claude", "auth", "work");
+      fs.mkdirSync(profileDir, { recursive: true });
+      expect(profileExists("work", tmpDir)).toBe(true);
+    });
+  });
+
+  describe("listProfiles", () => {
+    test("returns empty array when auth directory does not exist", () => {
+      expect(listProfiles(tmpDir)).toEqual([]);
+    });
+
+    test("returns subdirectory names", () => {
+      const authDir = path.join(tmpDir, ".sd-claude", "auth");
+      fs.mkdirSync(path.join(authDir, "work"), { recursive: true });
+      fs.mkdirSync(path.join(authDir, "personal"), { recursive: true });
+
+      const result = listProfiles(tmpDir);
+      expect(result.sort()).toEqual(["personal", "work"]);
+    });
+
+    test("ignores files in auth directory", () => {
+      const authDir = path.join(tmpDir, ".sd-claude", "auth");
+      fs.mkdirSync(authDir, { recursive: true });
+      fs.writeFileSync(path.join(authDir, "some-file.txt"), "data");
+      fs.mkdirSync(path.join(authDir, "profile1"), { recursive: true });
+
+      expect(listProfiles(tmpDir)).toEqual(["profile1"]);
+    });
+  });
+
+  describe("readCurrentAuth", () => {
+    test("reads oauthAccount and userID from .claude.json", () => {
+      const claudeJson = {
+        oauthAccount: { email: "test@example.com", token: "abc" },
+        userID: "user-123",
+      };
+      fs.writeFileSync(path.join(tmpDir, ".claude.json"), JSON.stringify(claudeJson));
+
+      const result = readCurrentAuth(tmpDir);
+      expect(result.oauthAccount).toEqual({ email: "test@example.com", token: "abc" });
+      expect(result.userID).toBe("user-123");
+    });
+
+    test("throws when .claude.json does not exist", () => {
+      expect(() => readCurrentAuth(tmpDir)).toThrow();
+    });
+
+    test("throws when oauthAccount is missing", () => {
+      fs.writeFileSync(path.join(tmpDir, ".claude.json"), JSON.stringify({ userID: "user-123" }));
+      expect(() => readCurrentAuth(tmpDir)).toThrow("Not logged in");
+    });
+
+    test("throws when userID is missing", () => {
+      fs.writeFileSync(
+        path.join(tmpDir, ".claude.json"),
+        JSON.stringify({ oauthAccount: { email: "test@example.com" } }),
+      );
+      expect(() => readCurrentAuth(tmpDir)).toThrow("Not logged in");
+    });
+  });
+
+  describe("readCurrentCredentials", () => {
+    test("reads credentials from .claude/.credentials.json", () => {
+      const credentials = { key: "value", secret: "s3cret" };
+      const claudeDir = path.join(tmpDir, ".claude");
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, ".credentials.json"), JSON.stringify(credentials));
+
+      const result = readCurrentCredentials(tmpDir);
+      expect(result).toEqual({ key: "value", secret: "s3cret" });
+    });
+
+    test("throws when .credentials.json does not exist", () => {
+      expect(() => readCurrentCredentials(tmpDir)).toThrow();
+    });
+  });
+
+  describe("getCurrentUserID", () => {
+    test("returns userID from .claude.json", () => {
+      fs.writeFileSync(path.join(tmpDir, ".claude.json"), JSON.stringify({ userID: "user-456" }));
+      expect(getCurrentUserID(tmpDir)).toBe("user-456");
+    });
+
+    test("returns undefined when .claude.json does not exist", () => {
+      expect(getCurrentUserID(tmpDir)).toBeUndefined();
+    });
+
+    test("returns undefined when userID is missing from .claude.json", () => {
+      fs.writeFileSync(
+        path.join(tmpDir, ".claude.json"),
+        JSON.stringify({ someOtherField: "value" }),
+      );
+      expect(getCurrentUserID(tmpDir)).toBeUndefined();
+    });
+  });
+});

package/claude/skills/sd-explore/SKILL.md

@@ -1,78 +0,0 @@
----
-name: sd-explore
-description: Deep codebase analysis - execution paths, architecture, dependencies
-disable-model-invocation: true
-model: sonnet
-context: fork
-allowed-tools: Read, Glob, Grep
-user-invocable: false
----
-
-# sd-explore
-
-You are an expert code analyst specializing in tracing and understanding feature implementations across codebases.
-
-## Target Selection
-
-**When invoked with `$ARGUMENTS`:**
-
-- If path is provided → **Immediately start analysis** (don't ask clarifying questions)
-- If path is a package directory → Trace all major features, architecture, and patterns
-- If path is a single file → Trace its role, dependencies, and usage
-
-**Critical**: This skill is `user-invocable: false` — you are called programmatically by other agents. Start analysis immediately without user interaction.
-
-## Core Mission
-
-Provide a complete understanding of how the target code works by tracing its implementation from entry points to data storage, through all abstraction layers. **Analysis only — no code modifications.**
-
-When analyzing a package/directory, cover:
-
-- Overall architecture and design patterns
-- Major features and entry points
-- Key abstractions and interfaces
-- Cross-cutting concerns
-- Critical files with file:line references
-
-## Analysis Approach
-
-### 1. Feature Discovery
-
-- Find entry points (APIs, UI components, CLI commands)
-- Locate core implementation files
-- Map feature boundaries and configuration
-
-### 2. Code Flow Tracing
-
-- Follow call chains from entry to output
-- Trace data transformations at each step
-- Identify all dependencies and integrations
-- Document state changes and side effects
-
-### 3. Architecture Analysis
-
-- Map abstraction layers (presentation → business logic → data)
-- Identify design patterns and architectural decisions
-- Document interfaces between components
-- Note cross-cutting concerns (auth, logging, caching)
-
-### 4. Implementation Details
-
-- Key algorithms and data structures
-- Error handling and edge cases
-- Performance considerations
-- Technical debt or improvement areas
-
-## Output Guidance
-
-Provide a comprehensive analysis that helps developers understand the code deeply enough to modify or extend it. Include:
-
-- Entry points with file:line references
-- Step-by-step execution flow with data transformations
-- Key components and their responsibilities
-- Architecture insights: patterns, layers, design decisions
-- Dependencies (external and internal)
-- Observations about strengths, issues, or opportunities
-- List of files absolutely essential to understanding the target
-
-Structure your response for maximum clarity and usefulness. Always include specific file paths and line numbers.