amalgm 0.0.0 → 0.0.1

package/runtime/lib/local/amalgmStore.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/local/amalgmStore.ts
+var amalgmStore_exports = {};
+__export(amalgmStore_exports, {
+  ensureAmalgmDir: () => ensureAmalgmDir,
+  getAmalgmDir: () => getAmalgmDir,
+  getHomeDir: () => getHomeDir,
+  readResource: () => readResource,
+  writeResource: () => writeResource
+});
+module.exports = __toCommonJS(amalgmStore_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var AMALGM_DIR = import_path.default.join(import_os.default.homedir(), ".amalgm");
+var DIRECTORIES = [
+  "",
+  // ~/.amalgm/
+  "browser",
+  // ~/.amalgm/browser/
+  "browser/local-storage",
+  // ~/.amalgm/browser/local-storage/
+  "agents",
+  // ~/.amalgm/agents/
+  "instructions",
+  // ~/.amalgm/instructions/
+  ".memories",
+  // ~/.amalgm/.memories/
+  "conversations",
+  // ~/.amalgm/conversations/
+  "conversations/active",
+  // ~/.amalgm/conversations/active/
+  "conversations/saved"
+  // ~/.amalgm/conversations/saved/
+];
+var DEFAULT_FILES = {
+  "config.json": {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  },
+  "browser/cookies.json": {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cookies: []
+  },
+  "agents/discovery.json": {
+    version: 1,
+    lastScan: null,
+    discovered: []
+  }
+};
+function ensureAmalgmDir() {
+  let created = false;
+  for (const dir of DIRECTORIES) {
+    const fullPath = import_path.default.join(AMALGM_DIR, dir);
+    if (!import_fs.default.existsSync(fullPath)) {
+      import_fs.default.mkdirSync(fullPath, { recursive: true });
+      created = true;
+    }
+  }
+  for (const [filePath, defaultContent] of Object.entries(DEFAULT_FILES)) {
+    const fullPath = import_path.default.join(AMALGM_DIR, filePath);
+    if (!import_fs.default.existsSync(fullPath)) {
+      import_fs.default.writeFileSync(fullPath, JSON.stringify(defaultContent, null, 2));
+      created = true;
+    }
+  }
+  return { created, path: AMALGM_DIR };
+}
+function readResource(resourcePath) {
+  const fullPath = import_path.default.join(AMALGM_DIR, resourcePath);
+  try {
+    const content = import_fs.default.readFileSync(fullPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeResource(resourcePath, data) {
+  const fullPath = import_path.default.join(AMALGM_DIR, resourcePath);
+  const dir = import_path.default.dirname(fullPath);
+  if (!import_fs.default.existsSync(dir)) {
+    import_fs.default.mkdirSync(dir, { recursive: true });
+  }
+  import_fs.default.writeFileSync(fullPath, JSON.stringify(data, null, 2));
+}
+function getAmalgmDir() {
+  return AMALGM_DIR;
+}
+function getHomeDir() {
+  return import_os.default.homedir();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureAmalgmDir,
+  getAmalgmDir,
+  getHomeDir,
+  readResource,
+  writeResource
+});

package/runtime/lib/local/credentialResolver.js

@@ -0,0 +1,425 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/local/credentialResolver.ts
+var credentialResolver_exports = {};
+__export(credentialResolver_exports, {
+  discoverAgents: () => discoverAgents,
+  getReauthCommand: () => getReauthCommand,
+  resolveAgentEnv: () => resolveAgentEnv
+});
+module.exports = __toCommonJS(credentialResolver_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_child_process = require("child_process");
+var CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+var CLAUDE_KEYCHAIN_CACHE_TTL_MS = 3e4;
+var CLAUDE_STATUS_CACHE_TTL_MS = 3e4;
+var LOCAL_CLI_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "XDG_CONFIG_HOME",
+  "XDG_CACHE_HOME",
+  "XDG_DATA_HOME"
+];
+var claudeCliStatusCache = null;
+var claudeKeychainStatusCache = null;
+function localCliEnv() {
+  const env = { NODE_ENV: process.env.NODE_ENV || "production" };
+  for (const key of LOCAL_CLI_ENV_ALLOWLIST) {
+    const value = process.env[key];
+    if (typeof value === "string" && value.length > 0) env[key] = value;
+  }
+  return env;
+}
+function compareVersionStringsDesc(a, b) {
+  const parse = (value) => value.split(".").map((part) => Number(part) || 0);
+  const left = parse(a);
+  const right = parse(b);
+  const length = Math.max(left.length, right.length);
+  for (let i = 0; i < length; i += 1) {
+    const delta = (right[i] || 0) - (left[i] || 0);
+    if (delta !== 0) return delta;
+  }
+  return 0;
+}
+function findClaudeCodeExecutable() {
+  const home = import_os.default.homedir();
+  if (process.platform === "darwin") {
+    const claudeCodeBase = import_path.default.join(home, "Library", "Application Support", "Claude", "claude-code");
+    if (import_fs.default.existsSync(claudeCodeBase)) {
+      try {
+        const versions = import_fs.default.readdirSync(claudeCodeBase).filter((dir) => /^\d+\.\d+(\.\d+)?/.test(dir)).sort(compareVersionStringsDesc);
+        for (const version of versions) {
+          const appBinary = import_path.default.join(claudeCodeBase, version, "claude.app", "Contents", "MacOS", "claude");
+          if (import_fs.default.existsSync(appBinary)) return appBinary;
+          const directBinary = import_path.default.join(claudeCodeBase, version, "claude");
+          if (import_fs.default.existsSync(directBinary)) return directBinary;
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const resolved = (0, import_child_process.execFileSync)("which", ["claude"], {
+      encoding: "utf-8",
+      env: localCliEnv(),
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return resolved || null;
+  } catch {
+    return null;
+  }
+}
+function readClaudeCliStatus() {
+  if (claudeCliStatusCache && claudeCliStatusCache.expiresAt > Date.now()) {
+    return claudeCliStatusCache.result;
+  }
+  const executable = findClaudeCodeExecutable();
+  if (!executable) {
+    const result = { known: false, status: { hasAuth: false } };
+    claudeCliStatusCache = {
+      expiresAt: Date.now() + CLAUDE_STATUS_CACHE_TTL_MS,
+      result
+    };
+    return result;
+  }
+  try {
+    const raw = (0, import_child_process.execFileSync)(executable, ["auth", "status"], {
+      encoding: "utf-8",
+      env: localCliEnv(),
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    const parsed = JSON.parse(raw);
+    const isLoggedIn = parsed?.loggedIn === true;
+    const authMethod = typeof parsed?.authMethod === "string" ? parsed.authMethod : "configured";
+    const subscriptionType = typeof parsed?.subscriptionType === "string" ? parsed.subscriptionType : "";
+    const hint = subscriptionType ? `${authMethod}:${subscriptionType}` : authMethod;
+    const result = {
+      known: true,
+      status: {
+        hasAuth: isLoggedIn,
+        authDetails: { type: "oauth", hint }
+      }
+    };
+    claudeCliStatusCache = {
+      expiresAt: Date.now() + CLAUDE_STATUS_CACHE_TTL_MS,
+      result
+    };
+    return result;
+  } catch (error) {
+    const stderr = error instanceof Error ? `${error.message}` : String(error);
+    const authFailed = /401|Please run \/login|Not logged in/i.test(stderr);
+    const result = {
+      known: authFailed,
+      status: {
+        hasAuth: false,
+        authDetails: authFailed ? { type: "oauth", hint: "reauth required" } : void 0
+      }
+    };
+    claudeCliStatusCache = {
+      expiresAt: Date.now() + CLAUDE_STATUS_CACHE_TTL_MS,
+      result
+    };
+    return result;
+  }
+}
+function readClaudeKeychainStatus() {
+  if (claudeKeychainStatusCache && claudeKeychainStatusCache.expiresAt > Date.now()) {
+    return claudeKeychainStatusCache.result;
+  }
+  let result = {
+    hasAuth: false
+  };
+  try {
+    (0, import_child_process.execFileSync)(
+      "security",
+      ["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-a", import_os.default.userInfo().username],
+      { stdio: "ignore" }
+    );
+    result = {
+      hasAuth: true,
+      authDetails: { type: "oauth", hint: "keychain" }
+    };
+    try {
+      const raw = (0, import_child_process.execFileSync)(
+        "security",
+        ["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-a", import_os.default.userInfo().username, "-w"],
+        { encoding: "utf-8" }
+      ).trim();
+      const parsed = JSON.parse(raw);
+      const accessToken = typeof parsed?.claudeAiOauth?.accessToken === "string" ? parsed.claudeAiOauth.accessToken : "";
+      const expiresAt = Number(parsed?.claudeAiOauth?.expiresAt || 0);
+      const isExpired = expiresAt > 0 && expiresAt <= Date.now() + 6e4;
+      if (!accessToken || isExpired) {
+        result = {
+          hasAuth: false,
+          authDetails: { type: "oauth", hint: isExpired ? "expired" : "missing token" }
+        };
+      }
+    } catch {
+    }
+  } catch {
+    result = { hasAuth: false };
+  }
+  claudeKeychainStatusCache = {
+    expiresAt: Date.now() + CLAUDE_KEYCHAIN_CACHE_TTL_MS,
+    result
+  };
+  return result;
+}
+function detectClaudeCode() {
+  const configDir = import_path.default.join(import_os.default.homedir(), ".claude");
+  if (!import_fs.default.existsSync(configDir)) return null;
+  const entry = {
+    id: "claude_code",
+    name: "Claude Code",
+    configDir,
+    hasAuth: false
+  };
+  if (process.platform !== "darwin") {
+    return entry;
+  }
+  const cliStatus = readClaudeCliStatus();
+  if (cliStatus.known) {
+    entry.hasAuth = cliStatus.status.hasAuth;
+    entry.authDetails = cliStatus.status.authDetails;
+    return entry;
+  }
+  const keychainStatus = readClaudeKeychainStatus();
+  entry.hasAuth = keychainStatus.hasAuth;
+  entry.authDetails = keychainStatus.authDetails;
+  return entry;
+}
+function detectCodex() {
+  const configDir = import_path.default.join(import_os.default.homedir(), ".codex");
+  const authPath = import_path.default.join(configDir, "auth.json");
+  if (!import_fs.default.existsSync(authPath)) return null;
+  const entry = {
+    id: "codex",
+    name: "Codex",
+    configDir,
+    hasAuth: false
+  };
+  try {
+    const parsed = JSON.parse(import_fs.default.readFileSync(authPath, "utf-8"));
+    if (parsed.tokens && typeof parsed.tokens === "object") {
+      entry.hasAuth = true;
+      entry.authDetails = { type: "oauth", hint: parsed.auth_mode || "configured" };
+    } else if (typeof parsed.OPENAI_API_KEY === "string" && parsed.OPENAI_API_KEY.length > 0) {
+      entry.hasAuth = true;
+      entry.authDetails = { type: "api_key", hint: parsed.OPENAI_API_KEY.slice(-4) };
+    }
+  } catch {
+  }
+  return entry;
+}
+function hasNonEmptyFile(filePath) {
+  try {
+    const stat = import_fs.default.statSync(filePath);
+    return stat.isFile() && stat.size > 0;
+  } catch {
+    return false;
+  }
+}
+function firstExistingPath(paths) {
+  return paths.find((candidate) => import_fs.default.existsSync(candidate)) ?? null;
+}
+function detectOpenCode() {
+  const home = import_os.default.homedir();
+  const configDir = import_path.default.join(home, ".config", "opencode");
+  const authPath = import_path.default.join(home, ".local", "share", "opencode", "auth.json");
+  if (!import_fs.default.existsSync(configDir) && !import_fs.default.existsSync(authPath)) return null;
+  const hasAuth = hasNonEmptyFile(authPath);
+  return {
+    id: "opencode",
+    name: "OpenCode",
+    configDir,
+    hasAuth,
+    authDetails: hasAuth ? { type: "oauth", hint: "configured" } : void 0
+  };
+}
+function detectPi() {
+  const configDir = import_path.default.join(import_os.default.homedir(), ".pi");
+  const credentialPaths = [
+    import_path.default.join(configDir, "agent", "auth.json"),
+    import_path.default.join(configDir, "agent", "models.json")
+  ];
+  if (!import_fs.default.existsSync(configDir) && !firstExistingPath(credentialPaths)) return null;
+  const hasAuth = credentialPaths.some(hasNonEmptyFile);
+  return {
+    id: "pi",
+    name: "Pi",
+    configDir,
+    hasAuth,
+    authDetails: hasAuth ? { type: "unknown", hint: "configured" } : void 0
+  };
+}
+function detectAmp() {
+  const home = import_os.default.homedir();
+  const configDir = import_path.default.join(home, ".config", "amp");
+  const credentialPaths = [
+    import_path.default.join(configDir, "settings.json"),
+    import_path.default.join(home, ".amp", "config.json"),
+    import_path.default.join(home, ".amp", "auth.json")
+  ];
+  const hasEnvKey = typeof process.env.AMP_API_KEY === "string" && process.env.AMP_API_KEY.length > 0;
+  if (!hasEnvKey && !import_fs.default.existsSync(configDir) && !firstExistingPath(credentialPaths)) return null;
+  const hasAuth = hasEnvKey || credentialPaths.some(hasNonEmptyFile);
+  return {
+    id: "amp",
+    name: "Amp",
+    configDir,
+    hasAuth,
+    authDetails: hasAuth ? { type: hasEnvKey ? "api_key" : "unknown", hint: hasEnvKey ? process.env.AMP_API_KEY.slice(-4) : "configured" } : void 0
+  };
+}
+function detectCursor() {
+  const home = import_os.default.homedir();
+  const configDir = import_path.default.join(home, ".cursor");
+  const credentialPaths = [
+    import_path.default.join(configDir, "credentials.json"),
+    import_path.default.join(home, ".config", "cursor", "credentials.json"),
+    import_path.default.join(home, ".local", "share", "cursor-agent", "auth.json")
+  ];
+  const hasEnvKey = typeof process.env.CURSOR_API_KEY === "string" && process.env.CURSOR_API_KEY.length > 0;
+  let statusAuth = false;
+  if (!hasEnvKey) {
+    const executable = firstExistingPath([
+      import_path.default.join(home, ".local", "bin", "cursor-agent"),
+      "/usr/local/bin/cursor-agent"
+    ]) ?? "cursor-agent";
+    try {
+      const raw = (0, import_child_process.execFileSync)(executable, ["status"], {
+        encoding: "utf-8",
+        env: localCliEnv(),
+        timeout: 3e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      statusAuth = /authenticated|logged in|signed in/i.test(raw) && !/not authenticated|logged out/i.test(raw);
+    } catch {
+      statusAuth = false;
+    }
+  }
+  if (!hasEnvKey && !statusAuth && !import_fs.default.existsSync(configDir) && !firstExistingPath(credentialPaths)) return null;
+  const hasAuth = hasEnvKey || statusAuth || credentialPaths.some(hasNonEmptyFile);
+  return {
+    id: "cursor",
+    name: "Cursor",
+    configDir,
+    hasAuth,
+    authDetails: hasAuth ? { type: hasEnvKey ? "api_key" : "oauth", hint: hasEnvKey ? process.env.CURSOR_API_KEY.slice(-4) : "configured" } : void 0
+  };
+}
+function discoverAgents() {
+  const discovered = [];
+  for (const detector of [detectClaudeCode, detectCodex, detectOpenCode, detectPi, detectAmp, detectCursor]) {
+    const result = detector();
+    if (result) discovered.push(result);
+  }
+  return discovered;
+}
+function getReauthCommand(agentId) {
+  switch (agentId) {
+    case "claude_code":
+      return {
+        shell: "claude",
+        description: "Run `claude`, then type /login to authenticate."
+      };
+    case "codex":
+      return {
+        shell: "codex login",
+        description: "`codex login` walks through OAuth or API-key setup."
+      };
+    case "opencode":
+      return {
+        shell: "opencode auth login",
+        description: "`opencode auth login` walks through provider setup."
+      };
+    case "pi":
+      return {
+        shell: "pi --terminal-login",
+        description: "`pi --terminal-login` authenticates Pi in the terminal."
+      };
+    case "amp":
+      return {
+        shell: "amp --setup",
+        description: "`amp --setup` configures Amp credentials."
+      };
+    case "cursor":
+      return {
+        shell: 'if command -v cursor-agent >/dev/null 2>&1; then cursor-agent login; else "$HOME/.local/bin/cursor-agent" login; fi',
+        description: "`cursor-agent login` opens the browser login flow."
+      };
+    default:
+      return null;
+  }
+}
+function resolveAgentEnv(agentId, authMode, proxyToken, proxyBaseUrl) {
+  const env = {};
+  if (authMode === "amalgm" && proxyToken && proxyBaseUrl) {
+    switch (agentId) {
+      case "claude_code":
+        env.ANTHROPIC_API_KEY = proxyToken;
+        env.ANTHROPIC_BASE_URL = `${proxyBaseUrl}/anthropic`;
+        break;
+      case "codex":
+        env.OPENAI_API_KEY = proxyToken;
+        env.OPENAI_BASE_URL = `${proxyBaseUrl}/openai/v1`;
+        break;
+      case "opencode":
+        env.AI_GATEWAY_API_KEY = proxyToken;
+        env.AI_GATEWAY_BASE_URL = `${proxyBaseUrl}/ai_gateway/v3/ai`;
+        break;
+      case "pi":
+        env.AI_GATEWAY_API_KEY = proxyToken;
+        env.AI_GATEWAY_BASE_URL = `${proxyBaseUrl}/ai_gateway/v1`;
+        break;
+    }
+  }
+  return env;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  discoverAgents,
+  getReauthCommand,
+  resolveAgentEnv
+});