@opencoreai/opencore 0.2.2

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@opencoreai/opencore",
+  "version": "0.2.2",
+  "private": false,
+  "type": "module",
+  "license": "LicenseRef-OpenCore-Personal-Use-1.0",
+  "description": "OpenCore terminal agent for ChatGPT computer use on macOS.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "src/credential-store.mjs",
+    "src/dashboard-server.ts",
+    "src/index.ts",
+    "src/mac-controller.mjs",
+    "src/opencore-indicator.js",
+    "src/skill-catalog.mjs",
+    "scripts",
+    "templates",
+    "opencore dashboard",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "opencore": "bin/opencore.mjs"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "engage": "node bin/opencore.mjs engage"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "express": "^4.21.2",
+    "figlet": "^1.10.0",
+    "openai": "^5.20.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tsx": "^4.21.0",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,448 @@
+import "dotenv/config";
+import os from "node:os";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { execFile } from "node:child_process";
+import * as readlineCore from "node:readline";
+import { promisify } from "node:util";
+import { stdin as input, stdout as output } from "node:process";
+import { fileURLToPath } from "node:url";
+import { SKILL_CATALOG } from "../src/skill-catalog.mjs";
+import { ensureCredentialStore } from "../src/credential-store.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, "..");
+const TEMPLATE_DIR = path.join(ROOT_DIR, "templates");
+const OPENCORE_HOME = path.join(os.homedir(), ".opencore");
+const SETTINGS_PATH = path.join(OPENCORE_HOME, "configs", "settings.json");
+const GUIDELINES_PATH = path.join(OPENCORE_HOME, "guidelines.md");
+const INSTRUCTIONS_PATH = path.join(OPENCORE_HOME, "instructions.md");
+const HEARTBEAT_PATH = path.join(OPENCORE_HOME, "heartbeat.md");
+const SOUL_PATH = path.join(OPENCORE_HOME, "soul.md");
+const PROFILE_SECTION_START = "<!-- OPENCORE_INSTALL_PROFILE_START -->";
+const PROFILE_SECTION_END = "<!-- OPENCORE_INSTALL_PROFILE_END -->";
+const DIRECTORIES = [
+  OPENCORE_HOME,
+  path.join(OPENCORE_HOME, "configs"),
+  path.join(OPENCORE_HOME, "logs"),
+  path.join(OPENCORE_HOME, "cache"),
+  path.join(OPENCORE_HOME, "skills"),
+];
+const execFileAsync = promisify(execFile);
+
+const LEGACY_DEFAULT_MEMORY = `# OpenCore Memory
+
+This file stores durable notes and user preferences for both the Manager Agent and Computer Agent.
+
+## Notes
+- Reserved for future memory features
+`;
+
+const DEFAULT_CONFIG = {
+  name: "OpenCore",
+  platform: "macOS",
+  provider: "chatgpt",
+  openai_api_key: "",
+  telegram_enabled: false,
+  telegram_bot_token: "",
+  telegram_chat_id: "",
+  telegram_user_id: "",
+  telegram_pairing_code: "",
+  telegram_paired: false,
+  telegram_last_update_id: 0,
+  user_display_name: "",
+  assistant_tone: "",
+  created_at: new Date().toISOString(),
+  schema_version: 1,
+};
+
+async function readSettingsOrDefault() {
+  try {
+    const raw = await fs.readFile(SETTINGS_PATH, "utf8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw || "{}") };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+async function writeSettings(next) {
+  await fs.writeFile(SETTINGS_PATH, `${JSON.stringify({ ...DEFAULT_CONFIG, ...next }, null, 2)}\n`, "utf8");
+}
+
+function upsertMarkedSection(text, startMarker, endMarker, body) {
+  const nextSection = `${startMarker}\n${body.trim()}\n${endMarker}`;
+  const pattern = new RegExp(`${startMarker}[\\s\\S]*?${endMarker}`, "m");
+  if (pattern.test(text)) {
+    return text.replace(pattern, nextSection);
+  }
+  const base = String(text || "").trimEnd();
+  return `${base}\n\n${nextSection}\n`;
+}
+
+async function applyInstallProfile(settings) {
+  const displayName = String(settings.user_display_name || "").trim();
+  const tone = String(settings.assistant_tone || "").trim();
+  if (!displayName && !tone) return;
+
+  const soulRaw = await fs.readFile(SOUL_PATH, "utf8").catch(() => "# OpenCore Soul\n");
+  const instructionsRaw = await fs.readFile(INSTRUCTIONS_PATH, "utf8").catch(() => "# OpenCore Instructions\n");
+
+  const soulSection = `## Installed User Defaults\n- Call the user: ${displayName || "User"}\n- Preferred response tone: ${tone || "clear, direct, calm"}`;
+  const instructionsSection = `## Installed User Preferences\n- Address the user as: ${displayName || "User"}.\n- Default tone: ${tone || "clear, direct, calm"}.\n- If the user does not specify a different style, keep responses aligned with this default tone.`;
+
+  await fs.writeFile(
+    SOUL_PATH,
+    upsertMarkedSection(soulRaw, PROFILE_SECTION_START, PROFILE_SECTION_END, soulSection),
+    "utf8",
+  );
+  await fs.writeFile(
+    INSTRUCTIONS_PATH,
+    upsertMarkedSection(instructionsRaw, PROFILE_SECTION_START, PROFILE_SECTION_END, instructionsSection),
+    "utf8",
+  );
+}
+
+async function promptOnboardingProfile(currentSettings) {
+  if (!(input.isTTY && output.isTTY)) return currentSettings;
+  const rl = readlineCore.createInterface({ input, output });
+  const settings = { ...currentSettings };
+  try {
+    const currentName = String(settings.user_display_name || "").trim();
+    const currentTone = String(settings.assistant_tone || "").trim();
+    console.log("[OpenCore] A few defaults help OpenCore stay consistent across sessions.");
+    const displayName = (
+      await new Promise((resolve) =>
+        rl.question(
+          `OpenCore> What should I call you?${currentName ? ` [${currentName}]` : ""} `,
+          resolve,
+        ),
+      )
+    ).trim();
+    const tone = (
+      await new Promise((resolve) =>
+        rl.question(
+          `OpenCore> What tone should I use?${currentTone ? ` [${currentTone}]` : " [clear, direct, calm]"} `,
+          resolve,
+        ),
+      )
+    ).trim();
+    settings.user_display_name = displayName || currentName;
+    settings.assistant_tone = tone || currentTone || "clear, direct, calm";
+    return settings;
+  } finally {
+    rl.close();
+  }
+}
+
+async function telegramApi(token, method, params = {}, signal) {
+  const url = new URL(`https://api.telegram.org/bot${token}/${method}`);
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === undefined || value === null || value === "") return;
+    url.searchParams.set(key, String(value));
+  });
+  const res = await fetch(url, { signal });
+  if (!res.ok) {
+    throw new Error(`Telegram API ${method} failed with HTTP ${res.status}`);
+  }
+  const json = await res.json();
+  if (!json?.ok) {
+    throw new Error(json?.description || `Telegram API ${method} failed.`);
+  }
+  return json.result;
+}
+
+async function configureTelegram(currentSettings) {
+  if (!(input.isTTY && output.isTTY)) return currentSettings;
+  const rl = readlineCore.createInterface({ input, output });
+  let settings = { ...currentSettings };
+  try {
+    const existingEnabled = Boolean(settings.telegram_enabled && settings.telegram_bot_token);
+    const enableAnswer = (
+      await new Promise((resolve) =>
+        rl.question(
+          `Connect Telegram so you can send tasks from your phone? ${existingEnabled ? "[Y/n]" : "[y/N]"} `,
+          resolve,
+        ),
+      )
+    )
+      .trim()
+      .toLowerCase();
+
+    const wantsTelegram = existingEnabled
+      ? !["n", "no"].includes(enableAnswer)
+      : ["y", "yes"].includes(enableAnswer);
+
+    if (!wantsTelegram) {
+      settings.telegram_enabled = false;
+      settings.telegram_bot_token = "";
+      settings.telegram_chat_id = "";
+      settings.telegram_user_id = "";
+      settings.telegram_pairing_code = "";
+      settings.telegram_paired = false;
+      settings.telegram_last_update_id = 0;
+      console.log("[OpenCore] Telegram setup skipped.");
+      return settings;
+    }
+
+    let botToken = String(settings.telegram_bot_token || "").trim();
+    while (!botToken) {
+      botToken = (
+        await new Promise((resolve) => rl.question("Enter your Telegram bot token: ", resolve))
+      ).trim();
+      if (!botToken) console.log("[OpenCore] Telegram bot token cannot be blank.");
+    }
+
+    const me = await telegramApi(botToken, "getMe");
+    console.log(`[OpenCore] Connected bot: @${me?.username || "unknown"}`);
+    settings.telegram_enabled = true;
+    settings.telegram_bot_token = botToken;
+    settings.telegram_chat_id = "";
+    settings.telegram_user_id = "";
+    settings.telegram_pairing_code = "";
+    settings.telegram_paired = false;
+    settings.telegram_last_update_id = 0;
+    console.log("[OpenCore] Telegram bot token saved.");
+    console.log("[OpenCore] Next: start OpenCore, send /start to the bot, then give the Telegram user ID and pairing code from Telegram back to OpenCore.");
+    return settings;
+  } finally {
+    rl.close();
+  }
+}
+
+async function installSelectedSkills(skillIds) {
+  await ensureDir(path.join(OPENCORE_HOME, "skills"));
+  const installed = [];
+  const skipped = [];
+  for (const id of skillIds) {
+    const skill = SKILL_CATALOG.find((item) => item.id === id);
+    if (!skill) continue;
+    const dir = path.join(OPENCORE_HOME, "skills", skill.id);
+    const skillFile = path.join(dir, "SKILL.md");
+    const configFile = path.join(dir, "config.json");
+    try {
+      await fs.access(skillFile);
+      skipped.push(skill.id);
+      continue;
+    } catch {}
+    await ensureDir(dir);
+    await fs.writeFile(skillFile, `${skill.markdown.trim()}\n`, "utf8");
+    await fs.writeFile(
+      configFile,
+      `${JSON.stringify(
+        {
+          id: skill.id,
+          name: skill.name,
+          description: skill.description,
+          ...skill.config,
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+    installed.push(skill.id);
+  }
+  return { installed, skipped };
+}
+
+async function promptSkillInstallation() {
+  if (!(input.isTTY && output.isTTY)) return;
+  const choices = [
+    ...SKILL_CATALOG.filter((skill) => !skill.config?.builtin).map((skill) => ({ ...skill, isSkip: false })),
+    { id: "__skip__", name: "Skip for now", description: "Continue without installing optional skills.", isSkip: true },
+  ];
+  let cursor = 0;
+  const selected = new Set();
+
+  const render = () => {
+    readlineCore.cursorTo(output, 0, 0);
+    readlineCore.clearScreenDown(output);
+    const lines = [
+      "[OpenCore] Optional skills available to install",
+      "Use Up/Down to move, Space to select, Enter to confirm.",
+      "",
+    ];
+    choices.forEach((choice, idx) => {
+      const isActive = idx === cursor;
+      const isSelected = selected.has(choice.id);
+      const pointer = isActive ? ">" : " ";
+      const circle = isSelected ? "◉" : "◯";
+      lines.push(`${pointer} ${circle} ${choice.name}${choice.isSkip ? "" : ` (${choice.id})`}`);
+      lines.push(`    ${choice.description}`);
+    });
+    output.write(`${lines.join("\n")}\n`);
+  };
+
+  const chosenIds = await new Promise((resolve, reject) => {
+    const onData = (buf) => {
+      const key = String(buf);
+      if (key === "\u0003") {
+        cleanup();
+        reject(new Error("Skill selection interrupted by user."));
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(Array.from(selected));
+        return;
+      }
+      if (key === "\x1b[A") {
+        cursor = (cursor - 1 + choices.length) % choices.length;
+        render();
+        return;
+      }
+      if (key === "\x1b[B") {
+        cursor = (cursor + 1) % choices.length;
+        render();
+        return;
+      }
+      if (key === " ") {
+        const current = choices[cursor];
+        if (current.isSkip) {
+          selected.clear();
+          selected.add(current.id);
+        } else {
+          selected.delete("__skip__");
+          if (selected.has(current.id)) selected.delete(current.id);
+          else selected.add(current.id);
+        }
+        render();
+      }
+    };
+
+    const cleanup = () => {
+      input.off("data", onData);
+      if (typeof input.setRawMode === "function") input.setRawMode(false);
+      input.pause();
+    };
+
+    try {
+      if (typeof input.setRawMode === "function") input.setRawMode(true);
+      input.resume();
+      input.on("data", onData);
+      render();
+    } catch (error) {
+      cleanup();
+      reject(error);
+    }
+  });
+
+  const ids = chosenIds.filter((id) => id !== "__skip__");
+  if (!ids.length) {
+    console.log("[OpenCore] Skill install skipped for now.");
+    return;
+  }
+  const result = await installSelectedSkills(ids);
+  if (result.installed.length) {
+    console.log(`[OpenCore] Installed skills: ${result.installed.join(", ")}`);
+  } else {
+    console.log("[OpenCore] No new skills installed.");
+  }
+  if (result.skipped.length) {
+    console.log(`[OpenCore] Already installed (unchanged): ${result.skipped.join(", ")}`);
+  }
+}
+
+async function ensureDefaultSkillsInstalled() {
+  const defaultIds = SKILL_CATALOG.filter((skill) => skill.config?.builtin).map((skill) => skill.id);
+  if (!defaultIds.length) return;
+  await installSelectedSkills(defaultIds);
+}
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function ensureFile(filePath, contents) {
+  try {
+    await fs.access(filePath);
+  } catch {
+    await fs.writeFile(filePath, contents, "utf8");
+  }
+}
+
+async function readTemplate(name, fallback) {
+  try {
+    return await fs.readFile(path.join(TEMPLATE_DIR, name), "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+async function ensureTemplateApplied(filePath, template, legacyDefaults = []) {
+  try {
+    const existing = await fs.readFile(filePath, "utf8");
+    const normalized = existing.trim();
+    const isLegacy = legacyDefaults.some((value) => normalized === String(value || "").trim());
+    if (isLegacy) {
+      await fs.writeFile(filePath, template, "utf8");
+    }
+  } catch {
+    await fs.writeFile(filePath, template, "utf8");
+  }
+}
+
+async function run() {
+  const defaultSoul = await readTemplate("default-soul.md", "# OpenCore Soul\nName: OpenCore\n");
+  const defaultMemory = await readTemplate("default-memory.md", LEGACY_DEFAULT_MEMORY);
+  const defaultGuidelines = await readTemplate("default-guidelines.md", "# OpenCore Guidelines\n");
+  const defaultInstructions = await readTemplate("default-instructions.md", "# OpenCore Instructions\n");
+  const defaultHeartbeat = await readTemplate("default-heartbeat.md", "# OpenCore Heartbeat\n");
+
+  for (const dir of DIRECTORIES) {
+    await ensureDir(dir);
+  }
+
+  await ensureTemplateApplied(path.join(OPENCORE_HOME, "soul.md"), defaultSoul, ["# OpenCore Soul\nName: OpenCore\n"]);
+  await ensureTemplateApplied(path.join(OPENCORE_HOME, "memory.md"), defaultMemory, [LEGACY_DEFAULT_MEMORY]);
+  await ensureTemplateApplied(HEARTBEAT_PATH, defaultHeartbeat, ["# OpenCore Heartbeat\n"]);
+  await ensureTemplateApplied(GUIDELINES_PATH, defaultGuidelines, ["# OpenCore Guidelines\n"]);
+  await ensureTemplateApplied(INSTRUCTIONS_PATH, defaultInstructions, ["# OpenCore Instructions\n"]);
+  await ensureFile(SETTINGS_PATH, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`);
+  await ensureCredentialStore();
+  await ensureDefaultSkillsInstalled();
+
+  let settings = DEFAULT_CONFIG;
+  try {
+    const raw = await fs.readFile(SETTINGS_PATH, "utf8");
+    settings = { ...DEFAULT_CONFIG, ...JSON.parse(raw || "{}") };
+  } catch {
+    settings = { ...DEFAULT_CONFIG };
+  }
+
+  settings.provider = "chatgpt";
+  let openaiKey = String(process.env.OPENAI_API_KEY || settings.openai_api_key || "").trim();
+  if (!openaiKey) {
+    if (!(input.isTTY && output.isTTY)) {
+      throw new Error("Missing OPENAI_API_KEY. Re-run install in interactive terminal to enter a key.");
+    }
+    const rl = readlineCore.createInterface({ input, output });
+    try {
+      while (!openaiKey) {
+        openaiKey = (
+          await new Promise((resolve) => rl.question("Enter your OpenAI API key (required): ", resolve))
+        ).trim();
+        if (!openaiKey) console.log("[OpenCore] API key cannot be blank.");
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  settings.openai_api_key = openaiKey;
+  settings = await promptOnboardingProfile(settings);
+  await writeSettings(settings);
+  await applyInstallProfile(settings);
+  console.log("[OpenCore] ChatGPT configuration saved to ~/.opencore/configs/settings.json");
+
+  settings = await configureTelegram(settings);
+  await writeSettings(settings);
+
+  await promptSkillInstallation();
+
+  console.log(`[OpenCore] Initialized local home at ${OPENCORE_HOME}`);
+}
+
+run().catch((error) => {
+  console.warn(`[OpenCore] postinstall setup warning: ${error instanceof Error ? error.message : String(error)}`);
+});

package/src/credential-store.mjs

@@ -0,0 +1,209 @@
+import os from "node:os";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+
+const OPENCORE_HOME = path.join(os.homedir(), ".opencore");
+const CREDENTIALS_PATH = path.join(OPENCORE_HOME, "configs", "credentials.json");
+
+export function defaultCredentialsStore() {
+  return {
+    default_email: "",
+    default_email_provider: "",
+    auto_email_activation_enabled: false,
+    entries: [],
+    schema_version: 1,
+  };
+}
+
+export function credentialStorePath() {
+  return CREDENTIALS_PATH;
+}
+
+export async function ensureCredentialStore() {
+  await fs.mkdir(path.dirname(CREDENTIALS_PATH), { recursive: true });
+  try {
+    await fs.access(CREDENTIALS_PATH);
+  } catch {
+    await fs.writeFile(CREDENTIALS_PATH, `${JSON.stringify(defaultCredentialsStore(), null, 2)}\n`, "utf8");
+  }
+}
+
+export async function readCredentialStore() {
+  await ensureCredentialStore();
+  try {
+    const raw = await fs.readFile(CREDENTIALS_PATH, "utf8");
+    const parsed = JSON.parse(raw || "{}");
+    return normalizeCredentialStore(parsed);
+  } catch {
+    return defaultCredentialsStore();
+  }
+}
+
+export async function writeCredentialStore(next) {
+  const normalized = normalizeCredentialStore(next);
+  await fs.writeFile(CREDENTIALS_PATH, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+  return normalized;
+}
+
+export function normalizeWebsite(value) {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return "";
+  try {
+    const withProto = raw.includes("://") ? raw : `https://${raw}`;
+    const hostname = new URL(withProto).hostname.toLowerCase();
+    return hostname.replace(/^www\./, "");
+  } catch {
+    return raw
+      .replace(/^https?:\/\//, "")
+      .replace(/^www\./, "")
+      .split(/[/?#]/)[0]
+      .trim();
+  }
+}
+
+function normalizeEntry(entry) {
+  const website = normalizeWebsite(entry?.website || entry?.site || "");
+  return {
+    id: String(entry?.id || `${website || "credential"}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`).trim(),
+    website,
+    email: String(entry?.email || "").trim(),
+    password: String(entry?.password || "").trim(),
+    email_provider: String(entry?.email_provider || "").trim(),
+    notes: String(entry?.notes || "").trim(),
+    generated_by_ai: Boolean(entry?.generated_by_ai),
+    created_at: String(entry?.created_at || new Date().toISOString()),
+    updated_at: String(entry?.updated_at || new Date().toISOString()),
+  };
+}
+
+export function normalizeCredentialStore(store) {
+  const base = defaultCredentialsStore();
+  const entries = Array.isArray(store?.entries) ? store.entries.map(normalizeEntry).filter((item) => item.website) : [];
+  return {
+    ...base,
+    ...store,
+    default_email: String(store?.default_email || "").trim(),
+    default_email_provider: String(store?.default_email_provider || "").trim(),
+    auto_email_activation_enabled: Boolean(store?.auto_email_activation_enabled),
+    entries,
+  };
+}
+
+export async function upsertCredentialEntry(entry) {
+  const store = await readCredentialStore();
+  const normalized = normalizeEntry(entry);
+  const byIdIndex = store.entries.findIndex((item) => item.id === normalized.id);
+  const byWebsiteIndex = store.entries.findIndex((item) => item.website === normalized.website);
+  const index = byIdIndex >= 0 ? byIdIndex : byWebsiteIndex;
+  if (index >= 0) {
+    const existing = store.entries[index];
+    store.entries[index] = {
+      ...existing,
+      ...normalized,
+      created_at: existing.created_at,
+      updated_at: new Date().toISOString(),
+    };
+  } else {
+    store.entries.unshift(normalized);
+  }
+  return writeCredentialStore(store);
+}
+
+export async function deleteCredentialEntry(idOrWebsite) {
+  const needle = String(idOrWebsite || "").trim();
+  const store = await readCredentialStore();
+  store.entries = store.entries.filter((item) => item.id !== needle && item.website !== normalizeWebsite(needle));
+  return writeCredentialStore(store);
+}
+
+export async function updateCredentialDefaults(patch) {
+  const store = await readCredentialStore();
+  const next = {
+    ...store,
+    default_email: String(patch?.default_email ?? store.default_email ?? "").trim(),
+    default_email_provider: String(patch?.default_email_provider ?? store.default_email_provider ?? "").trim(),
+    auto_email_activation_enabled:
+      patch?.auto_email_activation_enabled === undefined
+        ? Boolean(store.auto_email_activation_enabled)
+        : Boolean(patch.auto_email_activation_enabled),
+  };
+  return writeCredentialStore(next);
+}
+
+export function summarizeCredentialStoreForPrompt(store) {
+  const normalized = normalizeCredentialStore(store);
+  const siteLines = normalized.entries
+    .slice(0, 40)
+    .map((entry) => `- ${entry.website} | email=${entry.email ? "***saved***" : "none"} | password=${entry.password ? "***saved***" : "none"} | provider=${entry.email_provider || "none"} | generated_by_ai=${entry.generated_by_ai ? "yes" : "no"}`);
+  return [
+    `Default email saved: ${normalized.default_email ? "***saved***" : "no"}`,
+    `Default email provider: ${normalized.default_email_provider || "none"}`,
+    `Automatic account email activation enabled: ${normalized.auto_email_activation_enabled ? "yes" : "no"}`,
+    "Stored website credentials:",
+    ...(siteLines.length ? siteLines : ["- none"]),
+  ].join("\n");
+}
+
+export function buildCredentialExecutionContext(store, taskText) {
+  const normalized = normalizeCredentialStore(store);
+  const text = String(taskText || "").toLowerCase();
+  const matched = normalized.entries.filter((entry) => {
+    if (!entry.website) return false;
+    const site = entry.website.toLowerCase();
+    const root = site.split(".")[0];
+    return text.includes(site) || (root && text.includes(root));
+  });
+  const signUpLike =
+    text.includes("sign up") ||
+    text.includes("signup") ||
+    text.includes("create account") ||
+    text.includes("register");
+
+  const lines = [];
+  if (matched.length) {
+    lines.push("Stored credentials relevant to this task:");
+    for (const entry of matched.slice(0, 3)) {
+      lines.push(`- website: ${entry.website}`);
+      lines.push(`  email: ${entry.email || "(none saved)"}`);
+      lines.push(`  password: ${entry.password || "(none saved)"}`);
+      lines.push(`  email_provider: ${entry.email_provider || "(none saved)"}`);
+      if (entry.notes) lines.push(`  notes: ${entry.notes}`);
+    }
+  }
+  if (signUpLike && normalized.default_email) {
+    lines.push("Default account-creation email available:");
+    lines.push(`- email: ${normalized.default_email}`);
+    lines.push(`- provider: ${normalized.default_email_provider || "(none set)"}`);
+    lines.push(
+      `- automatic email activation enabled: ${normalized.auto_email_activation_enabled ? "yes" : "no"}`,
+    );
+  }
+  if (!lines.length) return "";
+  lines.push(
+    "If you create a new account or update credentials during this task, include one line in the final response exactly in this format:",
+  );
+  lines.push(
+    'CREDENTIAL_SAVE {"website":"example.com","email":"user@example.com","password":"secret","email_provider":"gmail","notes":"optional","generated_by_ai":true}',
+  );
+  return lines.join("\n");
+}
+
+export function extractCredentialSaveCandidates(text) {
+  const lines = String(text || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const candidates = [];
+  for (const line of lines) {
+    const match = line.match(/^CREDENTIAL_SAVE\s+(\{.+\})$/);
+    if (!match) continue;
+    try {
+      const parsed = JSON.parse(match[1]);
+      const normalized = normalizeEntry(parsed);
+      if (normalized.website && (normalized.email || normalized.password)) {
+        candidates.push(normalized);
+      }
+    } catch {}
+  }
+  return candidates;
+}