@opencoreai/opencore 0.2.2

package/LICENSE

@@ -0,0 +1,62 @@
+OpenCore Personal Use License 1.0
+Copyright (c) 2026 Eli Abdeen. All rights reserved.
+
+1. Grant of License
+
+Subject to the terms of this License, you are granted a limited, personal,
+non-exclusive, non-transferable, non-sublicensable, revocable license to
+install and use this software solely for your own personal, internal use.
+
+2. No Commercial Use
+
+You may not sell, rent, lease, sublicense, distribute for a fee, offer as a
+service, bundle for sale, or otherwise commercially exploit the software or any
+copy of it.
+
+3. No Modification or Derivative Works
+
+You may not modify, adapt, translate, reverse engineer, decompile, disassemble,
+create derivative works from, merge, repackage, alter branding of, or otherwise
+prepare modified versions of the software, except to the extent such a
+restriction is prohibited by applicable law and cannot be contractually waived.
+
+4. No Redistribution
+
+You may not copy, publish, distribute, share, transfer, assign, or make the
+software available to any third party, except that you may download and install
+an authorized copy for your own personal use.
+
+5. No Resale
+
+You may not resell the software, any copy of the software, any access to the
+software, or any service built from or around the software.
+
+6. Ownership
+
+The software is licensed, not sold. All rights, title, and interest in and to
+the software, including all intellectual property rights, remain exclusively
+with the copyright holder.
+
+7. Termination
+
+This License terminates automatically if you violate any term of this License.
+Upon termination, you must stop using the software and destroy all copies in
+your possession or control.
+
+8. No Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT.
+
+9. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE COPYRIGHT HOLDER SHALL NOT BE
+LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+10. Acceptance
+
+By installing, copying, or using the software, you agree to be bound by this
+License.

package/README.md

@@ -0,0 +1,205 @@
+# OpenCore
+
+OpenCore is a macOS assistant that can carry out tasks on your computer through a local app experience with a CLI and dashboard.
+
+OpenCore can help with:
+- using apps and websites on your Mac
+- handling repetitive workflows
+- sending tasks from the terminal, dashboard, or Telegram
+- creating scheduled tasks
+- storing local website login details for reuse
+
+## Requirements
+
+- macOS
+- Node.js and npm
+- a ChatGPT API key
+- Terminal access
+
+## Install
+
+Install OpenCore globally:
+
+```bash
+npm i -g @opencoreai/opencore
+```
+
+Run first-time onboarding:
+
+```bash
+opencore onboard
+```
+
+Start OpenCore:
+
+```bash
+opencore engage
+```
+
+## Onboarding
+
+On first use, run `opencore onboard`. If onboarding has not been completed yet, `opencore engage` will start onboarding automatically.
+
+OpenCore will ask for:
+- your ChatGPT API key
+- the name OpenCore should use for you
+- the tone OpenCore should use
+- optional Telegram connection
+- optional skill selection
+
+## Permissions
+
+To let OpenCore control your Mac, allow your terminal app in:
+
+1. `System Settings -> Privacy & Security -> Accessibility`
+2. `System Settings -> Privacy & Security -> Screen Recording`
+
+## Use
+
+Run OpenCore:
+
+```bash
+opencore engage
+```
+
+Stop OpenCore:
+
+```text
+/exit
+```
+
+While OpenCore is running, you can:
+- send tasks in the terminal
+- use the dashboard in your browser
+- send tasks from Telegram if connected
+
+Dashboard address:
+
+```text
+http://127.0.0.1:4111/dashboard/
+```
+
+## Dashboard
+
+The dashboard lets you:
+- send tasks
+- view activity
+- manage Telegram
+- manage saved login details
+- manage skills
+- view screenshots
+
+All dashboard data stays local on the user’s Mac.
+
+## Saved Logins
+
+OpenCore can save website login details locally so they can be reused later.
+
+You can:
+- save an email and password for a website
+- set a default email for new account creation
+- set an email provider
+- choose whether automatic email activation is allowed
+
+Automatic email activation is off by default.
+
+If you turn it on, OpenCore may open your email provider to read verification codes or links needed to complete sign-up flows.
+
+Only enable that if you trust the current machine and session.
+
+## Telegram
+
+OpenCore can connect to Telegram so you can send tasks from your phone while the CLI is running.
+
+## Scheduled Tasks
+
+OpenCore can create scheduled tasks and check whether missed work needs to be completed.
+
+Useful commands:
+
+```text
+/schedules
+/check-heartbeat
+/unschedule <schedule-id>
+```
+
+## Commands
+
+Start OpenCore:
+
+```bash
+opencore engage
+```
+
+Run onboarding again:
+
+```bash
+opencore onboard
+```
+
+Run setup manually:
+
+```bash
+opencore setup
+```
+
+Update OpenCore:
+
+```bash
+opencore update
+```
+
+Set ChatGPT API key:
+
+```bash
+opencore config set-key chatgpt
+```
+
+Show current config:
+
+```bash
+opencore config show
+```
+
+Reconnect Telegram:
+
+```text
+/telegram reconnect
+```
+
+Disconnect Telegram:
+
+```text
+/telegram disconnect
+```
+
+## Update
+
+To update OpenCore:
+
+```bash
+opencore update
+```
+
+Or install the newest published version directly:
+
+```bash
+npm install -g @opencoreai/opencore@latest
+```
+
+OpenCore does not require the GitHub repository to be public in order for the npm package to work. Only the published npm package needs to be available to the installing user.
+
+## License
+
+OpenCore is distributed under the `OpenCore Personal Use License 1.0`.
+
+It is not open source.
+
+The license prohibits:
+- modification
+- redistribution
+- resale
+- creating derivative works
+- commercial use
+
+See [`LICENSE`](/Users/eli/dev/computer-use-mac-agent/LICENSE) for full terms.

package/bin/opencore.mjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { spawn } from "node:child_process";
+import { constants, promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { stdin as input, stdout as output } from "node:process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, "..");
+const tsxCli = path.join(rootDir, "node_modules", "tsx", "dist", "cli.mjs");
+const entry = path.join(rootDir, "src", "index.ts");
+const setupScript = path.join(rootDir, "scripts", "postinstall.mjs");
+const openCoreHome = path.join(os.homedir(), ".opencore");
+const settingsPath = path.join(openCoreHome, "configs", "settings.json");
+const runtimeRoot = path.join(openCoreHome, "runtime");
+const runtimeInstallRoot = path.join(runtimeRoot, "current");
+const localBinDir = path.join(openCoreHome, "bin");
+const zshRcPath = path.join(os.homedir(), ".zshrc");
+const publishedPackageName = "@opencoreai/opencore";
+
+const args = process.argv.slice(2);
+const command = args[0];
+const subcommand = args[1];
+const thirdArg = args[2];
+
+async function ensureSettingsFile() {
+  await fs.mkdir(path.dirname(settingsPath), { recursive: true });
+  try {
+    await fs.access(settingsPath);
+  } catch {
+    const defaults = {
+      name: "OpenCore",
+      platform: "macOS",
+      provider: "chatgpt",
+      openai_api_key: "",
+      schema_version: 1,
+    };
+    await fs.writeFile(settingsPath, `${JSON.stringify(defaults, null, 2)}\n`, "utf8");
+  }
+}
+
+async function readSettings() {
+  await ensureSettingsFile();
+  const raw = await fs.readFile(settingsPath, "utf8");
+  return JSON.parse(raw || "{}");
+}
+
+async function writeSettings(settings) {
+  await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+}
+
+function needsInitialSetup(settings) {
+  const apiKey = String(settings?.openai_api_key || "").trim();
+  const displayName = String(settings?.user_display_name || "").trim();
+  const tone = String(settings?.assistant_tone || "").trim();
+  return !apiKey || !displayName || !tone;
+}
+
+async function runInitialSetupIfNeeded() {
+  const settings = await readSettings();
+  if (!needsInitialSetup(settings)) return;
+
+  if (!(input.isTTY && output.isTTY)) {
+    console.error("Initial OpenCore setup requires an interactive terminal.");
+    console.error("Run `opencore engage` in a normal terminal window to finish setup.");
+    process.exit(1);
+  }
+
+  console.log("Running first-time OpenCore setup...");
+
+  await new Promise((resolve, reject) => {
+    const setup = spawn(process.execPath, [setupScript], {
+      cwd: rootDir,
+      stdio: "inherit",
+      env: process.env,
+    });
+
+    setup.on("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`Setup exited with signal ${signal}`));
+        return;
+      }
+      if ((code ?? 1) !== 0) {
+        reject(new Error(`Setup exited with code ${code ?? 1}`));
+        return;
+      }
+      resolve();
+    });
+
+    setup.on("error", reject);
+  });
+}
+
+async function fileExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(targetPath) {
+  await fs.mkdir(targetPath, { recursive: true });
+}
+
+async function isWritableDirectory(targetPath) {
+  try {
+    await ensureDir(targetPath);
+    await fs.access(targetPath, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function installPersistentRuntime() {
+  await ensureDir(runtimeInstallRoot);
+
+  await new Promise((resolve, reject) => {
+    const installer = spawn(
+      "npm",
+      ["install", "--no-fund", "--no-audit", "--prefix", runtimeInstallRoot, rootDir],
+      {
+        cwd: rootDir,
+        stdio: "inherit",
+        env: process.env,
+      },
+    );
+
+    installer.on("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`Local install exited with signal ${signal}`));
+        return;
+      }
+      if ((code ?? 1) !== 0) {
+        reject(new Error(`Local install exited with code ${code ?? 1}`));
+        return;
+      }
+      resolve();
+    });
+
+    installer.on("error", reject);
+  });
+}
+
+function getPersistentEntryPath() {
+  return path.join(runtimeInstallRoot, "node_modules", publishedPackageName, "bin", "opencore.mjs");
+}
+
+function renderLauncherScript(entryPath) {
+  return `#!/bin/sh
+exec node "${entryPath}" "$@"
+`;
+}
+
+async function findPreferredLauncherDir() {
+  const pathEntries = String(process.env.PATH || "")
+    .split(path.delimiter)
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  const preferred = [
+    ...pathEntries,
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    path.join(os.homedir(), "bin"),
+    path.join(os.homedir(), ".local", "bin"),
+    localBinDir,
+  ];
+
+  const seen = new Set();
+  for (const dir of preferred) {
+    if (seen.has(dir)) continue;
+    seen.add(dir);
+    if (await isWritableDirectory(dir)) {
+      return { dir, alreadyOnPath: pathEntries.includes(dir) };
+    }
+  }
+
+  return { dir: localBinDir, alreadyOnPath: pathEntries.includes(localBinDir) };
+}
+
+async function ensureZshPathEntry(binDir) {
+  const exportLine = `export PATH="${binDir}:$PATH"`;
+  const existing = (await fs.readFile(zshRcPath, "utf8").catch(() => "")).toString();
+  if (existing.includes(exportLine)) return false;
+  const next = existing.trimEnd();
+  const content = `${next ? `${next}\n\n` : ""}# OpenCore CLI\n${exportLine}\n`;
+  await fs.writeFile(zshRcPath, content, "utf8");
+  return true;
+}
+
+async function installPersistentLauncher() {
+  const entryPath = getPersistentEntryPath();
+  if (!(await fileExists(entryPath))) {
+    throw new Error("Persistent OpenCore runtime was not installed correctly.");
+  }
+
+  const { dir, alreadyOnPath } = await findPreferredLauncherDir();
+  await ensureDir(dir);
+
+  const launcherPath = path.join(dir, "opencore");
+  await fs.writeFile(launcherPath, renderLauncherScript(entryPath), "utf8");
+  await fs.chmod(launcherPath, 0o755);
+
+  let zshUpdated = false;
+  if (!alreadyOnPath) {
+    zshUpdated = await ensureZshPathEntry(dir);
+  }
+
+  return { launcherPath, binDir: dir, alreadyOnPath, zshUpdated };
+}
+
+async function runSetupCommand() {
+  try {
+    console.log("Installing persistent OpenCore launcher...");
+    await installPersistentRuntime();
+    const launcher = await installPersistentLauncher();
+    await runInitialSetupIfNeeded();
+    console.log("OpenCore setup is complete.");
+    console.log(`OpenCore launcher: ${launcher.launcherPath}`);
+    if (!launcher.alreadyOnPath) {
+      console.log(`Added ${launcher.binDir} to ~/.zshrc`);
+      console.log("Open a new terminal window or run: source ~/.zshrc");
+    }
+    console.log("You can then run: opencore engage");
+    process.exit(0);
+  } catch (error) {
+    console.error(`OpenCore setup failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+function maskKey(key) {
+  const value = String(key || "");
+  if (!value) return "(not set)";
+  if (value.length <= 8) return "********";
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+if (command === "config" && subcommand === "show") {
+  const settings = await readSettings();
+  const outputConfig = {
+    ...settings,
+    openai_api_key: maskKey(process.env.OPENAI_API_KEY || settings.openai_api_key),
+    settings_path: settingsPath,
+    env_path: path.join(rootDir, ".env"),
+  };
+  console.log(JSON.stringify(outputConfig, null, 2));
+  process.exit(0);
+}
+
+if (command === "config" && subcommand === "set-key") {
+  const settings = await readSettings();
+  const providerArg = String(thirdArg || "").trim().toLowerCase();
+  const fourthArg = String(args[3] || "").trim();
+  let key = providerArg === "chatgpt" ? fourthArg : String(thirdArg || "").trim();
+  if (!key) {
+    if (!(input.isTTY && output.isTTY)) {
+      console.error("No key provided. Use: opencore config set-key [chatgpt] <your-key>");
+      process.exit(1);
+    }
+    const rl = readline.createInterface({ input, output });
+    try {
+      while (!key) {
+        key = (await rl.question("Enter OpenAI API key: ")).trim();
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  settings.provider = "chatgpt";
+  settings.openai_api_key = key;
+  await writeSettings(settings);
+  console.log(`Saved chatgpt API key to ${settingsPath}`);
+  process.exit(0);
+}
+
+if (command === "update") {
+  console.log(`Updating OpenCore from ${publishedPackageName}@latest ...`);
+  console.log("This command updates the published OpenCore CLI package.");
+  console.log("If you are running a local repo checkout, use git/pull or reinstall dependencies there instead.");
+  const updater = spawn("npm", ["install", "-g", `${publishedPackageName}@latest`], {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  updater.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    if ((code ?? 1) !== 0) {
+      console.error("OpenCore update failed.");
+      process.exit(code ?? 1);
+    }
+    console.log("OpenCore updated successfully.");
+    console.log("Run `opencore engage` again to start the newest version.");
+    process.exit(0);
+  });
+
+  process.on("SIGINT", () => updater.kill("SIGINT"));
+  process.on("SIGTERM", () => updater.kill("SIGTERM"));
+} else if (command === "setup" || command === "onboard") {
+  await runSetupCommand();
+} else if (!["engage", "run-scheduled"].includes(String(command || ""))) {
+  console.log("OpenCore CLI");
+  console.log("Usage:");
+  console.log("  opencore engage");
+  console.log("  opencore setup");
+  console.log("  opencore onboard");
+  console.log("  opencore run-scheduled <schedule-id>");
+  console.log("  opencore update");
+  console.log("  opencore config set-key [chatgpt] <api-key>");
+  console.log("  opencore config show");
+  process.exit(command ? 1 : 0);
+}
+
+if (command === "engage" || command === "run-scheduled") {
+  if (command === "engage") {
+    try {
+      await runInitialSetupIfNeeded();
+    } catch (error) {
+      console.error(`OpenCore setup failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  }
+
+  const childArgs = command === "run-scheduled" ? [tsxCli, entry, "--scheduled-id", subcommand || ""] : [tsxCli, entry];
+  const child = spawn(process.execPath, childArgs, {
+    cwd: rootDir,
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exit(code ?? 0);
+  });
+}