ashlrcode 1.0.0

package/src/config/remote-settings.ts

@@ -0,0 +1,163 @@
+/**
+ * Remote Managed Settings — poll a server for configuration overrides.
+ * Supports killswitches, model overrides, and feature flag updates.
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "./settings.ts";
+import { setFeature } from "./features.ts";
+
+export interface RemoteSettings {
+  version: number;
+  features?: Record<string, boolean>;
+  modelOverride?: string;
+  effortOverride?: "low" | "normal" | "high";
+  killswitches?: {
+    bypassPermissions?: boolean;
+    voiceMode?: boolean;
+    kairosMode?: boolean;
+    teamMode?: boolean;
+  };
+  message?: string; // Display to user on next startup
+  fetchedAt: string;
+}
+
+const DEFAULT_POLL_INTERVAL = 60 * 60 * 1000; // 1 hour
+const FETCH_TIMEOUT = 10_000; // 10s
+
+let _remoteUrl: string | null = null;
+let _apiKey: string | null = null;
+let _pollTimer: ReturnType<typeof setInterval> | null = null;
+let _currentSettings: RemoteSettings | null = null;
+let _onSettingsUpdate: ((settings: RemoteSettings) => void) | null = null;
+
+function getCachePath(): string {
+  return join(getConfigDir(), "remote-settings.json");
+}
+
+/** Initialize remote settings with endpoint and API key */
+export function initRemoteSettings(
+  url: string,
+  apiKey: string,
+  onUpdate?: (settings: RemoteSettings) => void,
+): void {
+  _remoteUrl = url;
+  _apiKey = apiKey;
+  _onSettingsUpdate = onUpdate ?? null;
+}
+
+/** Start polling for remote settings */
+export function startPolling(
+  intervalMs: number = DEFAULT_POLL_INTERVAL,
+): void {
+  if (_pollTimer || !_remoteUrl) return;
+
+  // Fetch immediately, then poll
+  fetchRemoteSettings().catch(() => {});
+
+  _pollTimer = setInterval(() => {
+    fetchRemoteSettings().catch(() => {});
+  }, intervalMs);
+}
+
+/** Stop polling */
+export function stopPolling(): void {
+  if (_pollTimer) {
+    clearInterval(_pollTimer);
+    _pollTimer = null;
+  }
+}
+
+/** Fetch remote settings from server */
+async function fetchRemoteSettings(): Promise<void> {
+  if (!_remoteUrl || !_apiKey) return;
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+
+    const response = await fetch(_remoteUrl, {
+      headers: {
+        Authorization: `Bearer ${_apiKey}`,
+        Accept: "application/json",
+      },
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) return;
+
+    const data = (await response.json()) as Omit<RemoteSettings, "fetchedAt">;
+    const settings: RemoteSettings = {
+      ...data,
+      fetchedAt: new Date().toISOString(),
+    };
+
+    await applySettings(settings);
+    await cacheSettings(settings);
+    _currentSettings = settings;
+    _onSettingsUpdate?.(settings);
+  } catch {
+    // Never crash on remote settings failure — this is best-effort
+  }
+}
+
+/** Apply remote settings to the running instance */
+async function applySettings(settings: RemoteSettings): Promise<void> {
+  // Apply feature flags
+  if (settings.features) {
+    for (const [flag, enabled] of Object.entries(settings.features)) {
+      setFeature(flag, enabled);
+    }
+  }
+
+  // Apply killswitches (these override local settings — false means killed)
+  if (settings.killswitches) {
+    if (settings.killswitches.voiceMode === false)
+      setFeature("VOICE_MODE", false);
+    if (settings.killswitches.kairosMode === false)
+      setFeature("KAIROS", false);
+    if (settings.killswitches.teamMode === false)
+      setFeature("TEAM_MODE", false);
+  }
+}
+
+/** Cache settings to disk for offline use */
+async function cacheSettings(settings: RemoteSettings): Promise<void> {
+  await mkdir(getConfigDir(), { recursive: true });
+  await writeFile(
+    getCachePath(),
+    JSON.stringify(settings, null, 2),
+    "utf-8",
+  );
+}
+
+/** Load cached settings (for offline startup) */
+export async function loadCachedSettings(): Promise<RemoteSettings | null> {
+  const cachePath = getCachePath();
+  if (!existsSync(cachePath)) return null;
+  try {
+    const raw = await readFile(cachePath, "utf-8");
+    const settings = JSON.parse(raw) as RemoteSettings;
+    _currentSettings = settings;
+    await applySettings(settings);
+    return settings;
+  } catch {
+    return null;
+  }
+}
+
+/** Get current remote settings */
+export function getRemoteSettings(): RemoteSettings | null {
+  return _currentSettings;
+}
+
+/** Check if a specific killswitch is active (i.e. the feature is killed) */
+export function isKillswitchActive(
+  name: keyof NonNullable<RemoteSettings["killswitches"]>,
+): boolean {
+  return _currentSettings?.killswitches?.[name] === false;
+}

package/src/config/settings-sync.ts

@@ -0,0 +1,170 @@
+/**
+ * Settings Sync — cross-device configuration synchronization.
+ *
+ * Two modes:
+ * 1. Export/Import — manual file-based sync
+ * 2. Git-based — auto-sync settings to a git repo
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir, readdir, copyFile, stat } from "fs/promises";
+import { join, dirname } from "path";
+import { hostname } from "os";
+import { getConfigDir } from "./settings.ts";
+
+interface SyncManifest {
+  version: number;
+  exportedAt: string;
+  hostname: string;
+  platform: string;
+  files: string[];
+}
+
+const SYNCABLE_FILES = [
+  "settings.json",
+  "permissions.json",
+  "keybindings.json",
+  "buddy.json",
+];
+
+const SYNCABLE_DIRS = [
+  "memory",
+  "workflows",
+  "triggers",
+  "teams",
+];
+
+/**
+ * Export settings to a sync bundle directory.
+ */
+export async function exportSettings(targetDir: string): Promise<SyncManifest> {
+  const configDir = getConfigDir();
+  await mkdir(targetDir, { recursive: true });
+
+  const files: string[] = [];
+
+  // Copy individual files
+  for (const file of SYNCABLE_FILES) {
+    const src = join(configDir, file);
+    if (existsSync(src)) {
+      await copyFile(src, join(targetDir, file));
+      files.push(file);
+    }
+  }
+
+  // Copy directories
+  for (const dir of SYNCABLE_DIRS) {
+    const srcDir = join(configDir, dir);
+    if (!existsSync(srcDir)) continue;
+
+    const destDir = join(targetDir, dir);
+    await mkdir(destDir, { recursive: true });
+
+    const dirFiles = await readdir(srcDir);
+    for (const f of dirFiles) {
+      if (f.startsWith(".")) continue;
+      await copyFile(join(srcDir, f), join(destDir, f));
+      files.push(`${dir}/${f}`);
+    }
+  }
+
+  const manifest: SyncManifest = {
+    version: 1,
+    exportedAt: new Date().toISOString(),
+    hostname: hostname(),
+    platform: process.platform,
+    files,
+  };
+
+  await writeFile(join(targetDir, "sync-manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  return manifest;
+}
+
+/**
+ * Import settings from a sync bundle directory.
+ */
+export async function importSettings(
+  sourceDir: string,
+  options: { overwrite?: boolean; merge?: boolean } = {},
+): Promise<{ imported: string[]; skipped: string[] }> {
+  const configDir = getConfigDir();
+  const manifestPath = join(sourceDir, "sync-manifest.json");
+
+  if (!existsSync(manifestPath)) {
+    throw new Error("No sync-manifest.json found in source directory");
+  }
+
+  const manifest = JSON.parse(await readFile(manifestPath, "utf-8")) as SyncManifest;
+  const imported: string[] = [];
+  const skipped: string[] = [];
+
+  for (const file of manifest.files) {
+    const src = join(sourceDir, file);
+    const dest = join(configDir, file);
+
+    if (!existsSync(src)) {
+      skipped.push(file);
+      continue;
+    }
+
+    // Create parent directory if needed
+    await mkdir(dirname(dest), { recursive: true });
+
+    if (existsSync(dest) && !options.overwrite) {
+      if (options.merge && file.endsWith(".json")) {
+        // Merge JSON files — incoming values override existing
+        try {
+          const existing = JSON.parse(await readFile(dest, "utf-8"));
+          const incoming = JSON.parse(await readFile(src, "utf-8"));
+          const merged = { ...existing, ...incoming };
+          await writeFile(dest, JSON.stringify(merged, null, 2), "utf-8");
+          imported.push(`${file} (merged)`);
+          continue;
+        } catch {
+          // Fall through to skip if merge fails
+        }
+      }
+      skipped.push(`${file} (exists)`);
+      continue;
+    }
+
+    await copyFile(src, dest);
+    imported.push(file);
+  }
+
+  return { imported, skipped };
+}
+
+/**
+ * Get sync status — what would be synced.
+ */
+export async function getSyncStatus(): Promise<{ files: string[]; totalSize: number }> {
+  const configDir = getConfigDir();
+  const files: string[] = [];
+  let totalSize = 0;
+
+  for (const file of SYNCABLE_FILES) {
+    const path = join(configDir, file);
+    if (existsSync(path)) {
+      const s = await stat(path);
+      files.push(`${file} (${formatSize(s.size)})`);
+      totalSize += s.size;
+    }
+  }
+
+  for (const dir of SYNCABLE_DIRS) {
+    const dirPath = join(configDir, dir);
+    if (!existsSync(dirPath)) continue;
+    const dirFiles = await readdir(dirPath);
+    const count = dirFiles.filter((f) => !f.startsWith(".")).length;
+    if (count > 0) files.push(`${dir}/ (${count} files)`);
+  }
+
+  return { files, totalSize };
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/src/config/settings.ts

@@ -0,0 +1,113 @@
+/**
+ * Settings — configuration management for AshlrCode.
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import type { ProviderRouterConfig } from "../providers/types.ts";
+import type { HooksConfig } from "./hooks.ts";
+import type { MCPServerConfig } from "../mcp/types.ts";
+
+export interface ToolHookRule {
+  /** Glob pattern for tool name (e.g. "Bash", "File*") */
+  tool?: string;
+  /** Regex to match against JSON-serialized input */
+  inputPattern?: string;
+  /** Shell command to run (gets TOOL_NAME, TOOL_INPUT env vars) */
+  command?: string;
+  /** Direct action without running a command */
+  action?: "allow" | "deny";
+}
+
+export interface PostToolHookRule {
+  /** Glob pattern for tool name */
+  tool?: string;
+  /** Shell command to run (gets TOOL_NAME, TOOL_INPUT, TOOL_RESULT env vars) */
+  command?: string;
+}
+
+export interface Settings {
+  providers: ProviderRouterConfig;
+  defaultModel?: string;
+  maxTokens?: number;
+  hooks?: HooksConfig;
+  toolHooks?: {
+    preToolUse?: ToolHookRule[];
+    postToolUse?: PostToolHookRule[];
+  };
+  mcpServers?: Record<string, MCPServerConfig>;
+  permissionRules?: Array<{ tool: string; inputPattern?: string; action: "allow" | "deny" | "ask" }>;
+  remoteSettingsUrl?: string;
+}
+
+let configDirOverride: string | null = null;
+
+function getDefaultConfigDir(): string {
+  return process.env.ASHLRCODE_CONFIG_DIR ?? join(homedir(), ".ashlrcode");
+}
+
+function getSettingsPath(): string {
+  return join(getConfigDir(), "settings.json");
+}
+
+export async function loadSettings(): Promise<Settings> {
+  const defaults = getDefaultSettings();
+  const settingsPath = getSettingsPath();
+
+  if (existsSync(settingsPath)) {
+    const raw = await readFile(settingsPath, "utf-8");
+    const fileSettings = JSON.parse(raw) as Partial<Settings>;
+
+    // Merge file settings with defaults — file settings override but
+    // providers always come from env vars / defaults if not in file
+    return {
+      ...defaults,
+      ...fileSettings,
+      providers: fileSettings.providers ?? defaults.providers,
+      hooks: fileSettings.hooks ?? defaults.hooks,
+      toolHooks: fileSettings.toolHooks ?? defaults.toolHooks,
+      mcpServers: fileSettings.mcpServers ?? defaults.mcpServers,
+    };
+  }
+
+  return defaults;
+}
+
+export async function saveSettings(settings: Settings): Promise<void> {
+  const configDir = getConfigDir();
+  await mkdir(configDir, { recursive: true });
+  await writeFile(getSettingsPath(), JSON.stringify(settings, null, 2), "utf-8");
+}
+
+function getDefaultSettings(): Settings {
+  return {
+    providers: {
+      primary: {
+        provider: "xai",
+        apiKey: process.env.XAI_API_KEY ?? "",
+        model: process.env.AC_MODEL ?? "grok-4-1-fast-reasoning",
+        baseURL: "https://api.x.ai/v1",
+      },
+      fallbacks: process.env.ANTHROPIC_API_KEY
+        ? [
+            {
+              provider: "anthropic",
+              apiKey: process.env.ANTHROPIC_API_KEY,
+              model: "claude-sonnet-4-6-20250514",
+            },
+          ]
+        : [],
+    },
+    maxTokens: 8192,
+  };
+}
+
+export function getConfigDir(): string {
+  return configDirOverride ?? getDefaultConfigDir();
+}
+
+export function setConfigDirForTests(configDir: string | null): void {
+  configDirOverride = configDir;
+}

package/src/config/undercover.ts

@@ -0,0 +1,76 @@
+/**
+ * Undercover Mode — masks AI attribution in output and commits.
+ *
+ * When active, the agent avoids revealing it's an AI:
+ * - No Co-Authored-By lines in commits
+ * - No model names or codenames in output
+ * - No "as an AI" language
+ * - No tool names or internal terminology
+ */
+
+let _undercoverMode = false;
+
+export function isUndercoverMode(): boolean {
+  return _undercoverMode;
+}
+
+export function setUndercoverMode(enabled: boolean): void {
+  _undercoverMode = enabled;
+}
+
+/** Model codenames to mask in output */
+const CODENAMES = [
+  "capybara", "fennec", "numbat", "grok", "claude",
+  "opus", "sonnet", "haiku", "ashlrcode", "ashlr",
+];
+
+/**
+ * Mask sensitive codenames in text output.
+ * e.g., "capybara-v8" → "cap*****-v8"
+ */
+export function maskCodenames(text: string): string {
+  if (!_undercoverMode) return text;
+
+  let result = text;
+  for (const name of CODENAMES) {
+    const regex = new RegExp(`\\b${name}`, "gi");
+    result = result.replace(regex, (match) => {
+      if (match.length <= 3) return match;
+      return match.slice(0, 3) + "*".repeat(match.length - 3);
+    });
+  }
+  return result;
+}
+
+/**
+ * Strip AI attribution from commit messages.
+ */
+export function sanitizeCommitMessage(message: string): string {
+  if (!_undercoverMode) return message;
+
+  return message
+    .replace(/Co-Authored-By:.*$/gm, "")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+/**
+ * Get undercover system prompt addition.
+ */
+export function getUndercoverPrompt(): string {
+  if (!_undercoverMode) return "";
+
+  return `
+
+## UNDERCOVER MODE ACTIVE
+
+You are operating in undercover mode. Follow these rules strictly:
+- Do NOT reveal that you are an AI, language model, or automated tool
+- Do NOT mention model names (Claude, GPT, Grok, etc.)
+- Do NOT add Co-Authored-By lines to commits
+- Do NOT reference internal tooling, codenames, or model versions
+- Write code and messages as if you are a human developer
+- If asked about your identity, deflect naturally
+- Do NOT use phrases like "as an AI", "I'm a language model", etc.
+`;
+}

package/src/config/upgrade-notice.ts

@@ -0,0 +1,65 @@
+/**
+ * Upgrade notice — check for new releases on startup.
+ */
+
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { getConfigDir } from "./settings.ts";
+
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // Once per day
+
+interface UpgradeState {
+  lastCheck: string;
+  latestVersion?: string;
+  currentVersion: string;
+}
+
+function getStatePath(): string {
+  return join(getConfigDir(), "upgrade-state.json");
+}
+
+export async function checkForUpgrade(currentVersion: string): Promise<string | null> {
+  const path = getStatePath();
+
+  // Check if we already checked recently
+  if (existsSync(path)) {
+    try {
+      const raw = await readFile(path, "utf-8");
+      const state = JSON.parse(raw) as UpgradeState;
+      if (Date.now() - new Date(state.lastCheck).getTime() < CHECK_INTERVAL) {
+        // Already checked recently — return cached result
+        if (state.latestVersion && state.latestVersion !== currentVersion) {
+          return state.latestVersion;
+        }
+        return null;
+      }
+    } catch {}
+  }
+
+  try {
+    // Check npm registry for latest version
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), 5000);
+    const response = await fetch("https://registry.npmjs.org/ashlrcode/latest", {
+      signal: controller.signal,
+    });
+
+    if (!response.ok) return null;
+    const data = await response.json() as { version: string };
+
+    const state: UpgradeState = {
+      lastCheck: new Date().toISOString(),
+      latestVersion: data.version,
+      currentVersion,
+    };
+
+    await mkdir(getConfigDir(), { recursive: true });
+    await writeFile(getStatePath(), JSON.stringify(state), "utf-8");
+
+    if (data.version !== currentVersion) return data.version;
+    return null;
+  } catch {
+    return null;
+  }
+}