@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/scripts/dev.mjs

@@ -0,0 +1,158 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_START_PORT = 8787;
+const MAX_PORT_ATTEMPTS = 200;
+
+const parseStartPort = (value) => {
+  if (!value) {
+    return DEFAULT_START_PORT;
+  }
+
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+    return DEFAULT_START_PORT;
+  }
+
+  return parsed;
+};
+
+const isPortInUseError = (error) =>
+  Boolean(error) &&
+  typeof error === "object" &&
+  "code" in error &&
+  (error.code === "EADDRINUSE" || error.code === "EACCES");
+
+const canListenOnPort = (port) =>
+  new Promise((resolve) => {
+    const probeServer = createServer();
+
+    const closeAndResolve = (result) => {
+      probeServer.removeAllListeners();
+      probeServer.close(() => {
+        resolve(result);
+      });
+    };
+
+    probeServer.once("error", (error) => {
+      if (isPortInUseError(error)) {
+        resolve(false);
+        return;
+      }
+
+      resolve(false);
+    });
+
+    probeServer.once("listening", () => {
+      closeAndResolve(true);
+    });
+
+    probeServer.listen(port, "127.0.0.1");
+  });
+
+const findOpenPort = async (startPort) => {
+  for (let offset = 0; offset < MAX_PORT_ATTEMPTS; offset += 1) {
+    const port = startPort + offset;
+    if (port > 65535) {
+      break;
+    }
+
+    // eslint-disable-next-line no-await-in-loop
+    const isAvailable = await canListenOnPort(port);
+    if (isAvailable) {
+      return port;
+    }
+  }
+
+  throw new Error(`Unable to find an open port starting from ${startPort}`);
+};
+
+const pnpmCommand = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+const startPort = parseStartPort(process.env.OCTOGENT_DEV_START_PORT);
+const apiPort = await findOpenPort(startPort);
+const apiOrigin = `http://127.0.0.1:${apiPort}`;
+
+console.log(`[octogent-dev] using api port ${apiPort}`);
+
+const monorepoRoot = new URL("..", import.meta.url).pathname.replace(/\/$/, "");
+
+// Resolve project state dir from global registry.
+const resolveProjectStateDir = (workspaceCwd) => {
+  if (process.env.OCTOGENT_PROJECT_STATE_DIR) {
+    return process.env.OCTOGENT_PROJECT_STATE_DIR;
+  }
+  const projectConfigPath = join(workspaceCwd, ".octogent", "project.json");
+  if (existsSync(projectConfigPath)) {
+    try {
+      const projectConfig = JSON.parse(readFileSync(projectConfigPath, "utf-8"));
+      if (
+        typeof projectConfig.projectId === "string" &&
+        projectConfig.projectId.trim().length > 0
+      ) {
+        return join(homedir(), ".octogent", "projects", projectConfig.projectId);
+      }
+    } catch {
+      // fall through
+    }
+  }
+  const projectsFile = join(homedir(), ".octogent", "projects.json");
+  if (existsSync(projectsFile)) {
+    try {
+      const registry = JSON.parse(readFileSync(projectsFile, "utf-8"));
+      const project = registry.projects?.find((p) => p.path === workspaceCwd);
+      if (project) {
+        if (typeof project.id === "string" && project.id.trim().length > 0) {
+          return join(homedir(), ".octogent", "projects", project.id);
+        }
+        if (typeof project.name === "string" && project.name.trim().length > 0) {
+          return join(homedir(), ".octogent", "projects", project.name);
+        }
+      }
+    } catch {
+      // fall through
+    }
+  }
+  return `${workspaceCwd}/.octogent`;
+};
+
+const workspaceCwd = process.env.OCTOGENT_WORKSPACE_CWD ?? monorepoRoot;
+const projectStateDir = resolveProjectStateDir(workspaceCwd);
+
+const child = spawn(
+  pnpmCommand,
+  ["-r", "--parallel", "--filter", "@octogent/api", "--filter", "@octogent/web", "dev"],
+  {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      OCTOGENT_API_PORT: String(apiPort),
+      OCTOGENT_API_ORIGIN: apiOrigin,
+      OCTOGENT_WORKSPACE_CWD: workspaceCwd,
+      OCTOGENT_PROJECT_STATE_DIR: projectStateDir,
+      OCTOGENT_PROMPTS_DIR: process.env.OCTOGENT_PROMPTS_DIR ?? `${monorepoRoot}/prompts`,
+    },
+  },
+);
+
+const forwardSignal = (signal) => {
+  if (child.killed) {
+    return;
+  }
+
+  child.kill(signal);
+};
+
+process.on("SIGINT", () => forwardSignal("SIGINT"));
+process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+
+  process.exit(code ?? 0);
+});

package/apps/octogent/scripts/smoke-public-install.mjs

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+import { spawn, spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = dirname(scriptDir);
+const tempRoot = mkdtempSync(join(tmpdir(), "octogent-public-install-"));
+const packDir = join(tempRoot, "pack");
+const installDir = join(tempRoot, "install");
+const workspaceDir = join(tempRoot, "workspace");
+const homeDir = join(tempRoot, "home");
+const binDir = join(tempRoot, "bin");
+const npmCacheDir = join(tempRoot, "npm-cache");
+
+mkdirSync(packDir, { recursive: true });
+mkdirSync(installDir, { recursive: true });
+mkdirSync(workspaceDir, { recursive: true });
+mkdirSync(homeDir, { recursive: true });
+mkdirSync(binDir, { recursive: true });
+mkdirSync(npmCacheDir, { recursive: true });
+
+const canonicalWorkspaceDir = realpathSync(workspaceDir);
+
+const runtimeEnv = {
+  ...process.env,
+  HOME: homeDir,
+  npm_config_cache: npmCacheDir,
+};
+const npmEnv = {
+  ...process.env,
+  npm_config_logs_dir: join(npmCacheDir, "_logs"),
+};
+
+npmEnv.npm_config_verify_deps_before_run = undefined;
+
+const formatCommand = (command, args) => [command, ...args].join(" ");
+
+const runChecked = (command, args, options = {}) => {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: "pipe",
+    ...options,
+  });
+
+  if (result.status !== 0) {
+    throw new Error(
+      [
+        `Command failed: ${formatCommand(command, args)}`,
+        result.stdout ? `stdout:\n${result.stdout.trimEnd()}` : "",
+        result.stderr ? `stderr:\n${result.stderr.trimEnd()}` : "",
+      ]
+        .filter(Boolean)
+        .join("\n\n"),
+    );
+  }
+
+  return result.stdout.trim();
+};
+
+const writeProviderStub = () => {
+  if (process.platform === "win32") {
+    writeFileSync(join(binDir, "codex.cmd"), "@echo off\r\nexit /b 0\r\n", "utf8");
+    return;
+  }
+
+  const stubPath = join(binDir, "codex");
+  writeFileSync(stubPath, "#!/bin/sh\nexit 0\n", "utf8");
+  chmodSync(stubPath, 0o755);
+};
+
+const assertFile = (filePath, description) => {
+  if (!existsSync(filePath)) {
+    throw new Error(`Missing ${description}: ${filePath}`);
+  }
+};
+
+const main = async () => {
+  let serverProcess;
+  let keepArtifacts = false;
+
+  try {
+    writeProviderStub();
+
+    console.log("Building package artifacts...");
+    runChecked("pnpm", ["build"], {
+      cwd: repoRoot,
+      env: process.env,
+    });
+
+    console.log("Packing npm tarball...");
+    const packed = JSON.parse(
+      runChecked("npm", ["pack", "--json", "--pack-destination", packDir], {
+        cwd: repoRoot,
+        env: npmEnv,
+      }),
+    );
+    const tarballFilename = packed[0]?.filename;
+    if (typeof tarballFilename !== "string" || tarballFilename.length === 0) {
+      throw new Error("`npm pack --json` did not return a tarball filename.");
+    }
+    const tarballPath = join(packDir, tarballFilename);
+
+    console.log("Installing packed CLI into a clean temp project...");
+    runChecked("npm", ["init", "-y"], {
+      cwd: installDir,
+      env: npmEnv,
+    });
+    runChecked("npm", ["install", tarballPath], {
+      cwd: installDir,
+      env: npmEnv,
+    });
+
+    console.log("Launching packaged Octogent in a fresh workspace...");
+    const octogentBin =
+      process.platform === "win32"
+        ? join(installDir, "node_modules", ".bin", "octogent.cmd")
+        : join(installDir, "node_modules", ".bin", "octogent");
+
+    let stdout = "";
+    let stderr = "";
+
+    serverProcess = spawn(octogentBin, [], {
+      cwd: workspaceDir,
+      env: {
+        ...runtimeEnv,
+        OCTOGENT_NO_OPEN: "1",
+        PATH: `${binDir}${delimiter}${runtimeEnv.PATH ?? ""}`,
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    serverProcess.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    serverProcess.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    const runtimeMetadataPath = join(homeDir, ".octogent", "projects");
+
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+      if (serverProcess.exitCode !== null) {
+        break;
+      }
+
+      const projectConfigPath = join(workspaceDir, ".octogent", "project.json");
+      if (existsSync(projectConfigPath)) {
+        const projectConfig = JSON.parse(readFileSync(projectConfigPath, "utf8"));
+        const candidateRuntimePath = join(
+          runtimeMetadataPath,
+          projectConfig.projectId,
+          "state",
+          "runtime.json",
+        );
+
+        if (existsSync(candidateRuntimePath)) {
+          const runtimeMetadata = JSON.parse(readFileSync(candidateRuntimePath, "utf8"));
+          try {
+            const response = await fetch(runtimeMetadata.apiBaseUrl);
+            if (response.ok) {
+              const html = await response.text();
+              if (!html.includes("<title>Octogent</title>")) {
+                throw new Error("Packaged UI responded, but the returned HTML was not Octogent.");
+              }
+              break;
+            }
+          } catch {
+            // Server may still be binding even after runtime metadata is written.
+          }
+        }
+      }
+
+      await delay(250);
+    }
+
+    if (serverProcess.exitCode !== null) {
+      throw new Error(
+        [
+          `Packaged CLI exited before startup completed (exit ${serverProcess.exitCode}).`,
+          stdout ? `stdout:\n${stdout.trimEnd()}` : "",
+          stderr ? `stderr:\n${stderr.trimEnd()}` : "",
+        ]
+          .filter(Boolean)
+          .join("\n\n"),
+      );
+    }
+
+    const projectConfigPath = join(workspaceDir, ".octogent", "project.json");
+    const gitignorePath = join(workspaceDir, ".gitignore");
+    const projectsRegistryPath = join(homeDir, ".octogent", "projects.json");
+
+    assertFile(projectConfigPath, "local project config");
+    assertFile(gitignorePath, "workspace .gitignore");
+    assertFile(projectsRegistryPath, "global projects registry");
+
+    const projectConfig = JSON.parse(readFileSync(projectConfigPath, "utf8"));
+    const projectsRegistry = JSON.parse(readFileSync(projectsRegistryPath, "utf8"));
+    const registeredProject = projectsRegistry.projects.find(
+      (project) => project.id === projectConfig.projectId && project.path === canonicalWorkspaceDir,
+    );
+
+    if (!registeredProject) {
+      throw new Error("Global projects registry did not include the fresh workspace.");
+    }
+
+    const runtimePath = join(
+      homeDir,
+      ".octogent",
+      "projects",
+      projectConfig.projectId,
+      "state",
+      "runtime.json",
+    );
+    assertFile(runtimePath, "runtime metadata");
+
+    const runtime = JSON.parse(readFileSync(runtimePath, "utf8"));
+    if (runtime.workspaceCwd !== canonicalWorkspaceDir) {
+      throw new Error(
+        `Runtime metadata pointed at ${runtime.workspaceCwd}, expected ${canonicalWorkspaceDir}.`,
+      );
+    }
+
+    const gitignoreContent = readFileSync(gitignorePath, "utf8");
+    if (!gitignoreContent.split(/\r?\n/).includes(".octogent")) {
+      throw new Error("Workspace .gitignore did not include the .octogent entry.");
+    }
+
+    console.log("Public install smoke test passed.");
+    console.log(`  Tarball:   ${tarballPath}`);
+    console.log(`  Workspace: ${workspaceDir}`);
+    console.log(`  API:       ${runtime.apiBaseUrl}`);
+  } catch (error) {
+    keepArtifacts = true;
+    console.error("Public install smoke test failed.");
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error(String(error));
+    }
+    console.error(`Artifacts preserved at: ${tempRoot}`);
+    process.exitCode = 1;
+  } finally {
+    if (serverProcess && serverProcess.exitCode === null) {
+      serverProcess.kill("SIGTERM");
+      await delay(500);
+      if (serverProcess.exitCode === null) {
+        serverProcess.kill("SIGKILL");
+      }
+    }
+
+    if (!keepArtifacts) {
+      rmSync(tempRoot, { force: true, recursive: true });
+    }
+  }
+};
+
+void main();

package/apps/octogent/tsconfig.base.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "useDefineForClassFields": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true
+  }
+}

package/bin/AGI

@@ -0,0 +1,3 @@
+#!/bin/zsh
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$SCRIPT_DIR" && bun run scripts/provider-launch.ts huggingface

package/bin/AGI-install-app

@@ -0,0 +1,71 @@
+#!/bin/bash
+# Creates a double-clickable GOKUL.app in /Applications that launches
+# the Electron voice UI. After running once, Spotlight ⌘Space → "GOKUL"
+# (in ALL CAPS or any case — Spotlight is case-insensitive) opens it.
+set -e
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+# /Applications is the spot Spotlight always indexes. Fall back to
+# ~/Applications if we can't write there (no sudo).
+if [ -w "/Applications" ] || sudo -n true 2>/dev/null; then
+  APP_DIR="/Applications"
+else
+  APP_DIR="$HOME/Applications"
+  mkdir -p "$APP_DIR"
+fi
+
+APP="$APP_DIR/GOKUL.app"
+CONTENTS="$APP/Contents"
+MACOS="$CONTENTS/MacOS"
+RES="$CONTENTS/Resources"
+
+# Wipe any previous install so Spotlight re-indexes cleanly
+rm -rf "$APP" "$APP_DIR/CORTEX.app" 2>/dev/null || true
+mkdir -p "$MACOS" "$RES"
+
+cat > "$CONTENTS/Info.plist" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>CFBundleName</key>                  <string>GOKUL</string>
+  <key>CFBundleDisplayName</key>           <string>GOKUL</string>
+  <key>CFBundleExecutable</key>            <string>gokul-launcher</string>
+  <key>CFBundleIdentifier</key>            <string>com.gokul.cortex</string>
+  <key>CFBundleVersion</key>               <string>1.0</string>
+  <key>CFBundleShortVersionString</key>    <string>1.0</string>
+  <key>CFBundlePackageType</key>           <string>APPL</string>
+  <key>LSMinimumSystemVersion</key>        <string>11.0</string>
+  <key>NSHighResolutionCapable</key>       <true/>
+  <key>LSUIElement</key>                   <false/>
+  <key>NSCameraUsageDescription</key>      <string>CORTEX uses the camera only when you run a vision task.</string>
+  <key>NSMicrophoneUsageDescription</key>  <string>CORTEX needs the mic for voice input.</string>
+  <key>NSAppleEventsUsageDescription</key> <string>Allow CORTEX to open the browser for the dashboard.</string>
+</dict></plist>
+PLIST
+
+# PkgInfo helps LaunchServices recognise this as an app
+printf 'APPL????' > "$CONTENTS/PkgInfo"
+
+cat > "$MACOS/gokul-launcher" <<LAUNCHER
+#!/bin/bash
+# GOKUL — CORTEX AGI launcher (Electron UI only).
+# Web dashboard is auto-opened by the CLI, not this app.
+REPO="$REPO_ROOT"
+export PATH="/opt/homebrew/bin:/usr/local/bin:\$PATH"
+
+# Electron UI in foreground — when the user quits it, script exits
+exec "\$REPO/bin/AGI-ui"
+LAUNCHER
+chmod +x "$MACOS/gokul-launcher"
+
+# Force Spotlight to re-index immediately so ⌘Space → GOKUL works NOW
+/usr/bin/touch "$APP"
+/usr/bin/mdimport "$APP" 2>/dev/null || true
+
+echo "✅ Installed: $APP"
+echo
+echo "   1. ⌘Space → type  GOKUL  → Enter  → app opens"
+echo "   2. Drag $APP onto the Dock to pin it"
+echo "   3. While running:  ⌘⇧A toggle window   ⌘⇧F fullscreen"
+echo
+echo "   Note: Web dashboard auto-opens when you run the CLI (./bin/AGI)."

package/bin/AGI-ui

@@ -0,0 +1,16 @@
+#!/bin/bash
+# CORTEX Voice UI — always-on-top Electron app with zero-lag voice.
+# Run: ./bin/AGI-ui
+set -e
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+APP_DIR="$REPO_ROOT/apps/voice-ui"
+
+if [ ! -d "$APP_DIR/node_modules/electron" ]; then
+  echo "📦 Installing Electron (one-time, ~2 min, ~150MB)..."
+  cd "$APP_DIR"
+  bun install 2>/dev/null || npm install
+  cd - >/dev/null
+fi
+
+cd "$APP_DIR"
+exec ./node_modules/.bin/electron . "$@"

package/bin/AGI-voice

@@ -0,0 +1,15 @@
+#!/bin/bash
+# CORTEX Voice Loop — hands-free AGI.
+# Just run: ./bin/AGI-voice
+# Or symlink into PATH: ln -s $PWD/bin/AGI-voice /usr/local/bin/AGI-voice
+set -e
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+# Auto-load .env so HF_TOKEN etc. are available
+if [ -f "$REPO_ROOT/.env" ]; then
+  set -a
+  source "$REPO_ROOT/.env"
+  set +a
+fi
+
+exec python3 "$REPO_ROOT/python/cortex_voice_loop.py" "$@"

package/bin/AGI-web

@@ -0,0 +1,16 @@
+#!/bin/bash
+# CORTEX Dashboard — localhost web UI at http://localhost:3737
+# Run: ./bin/AGI-web   (auto-opens browser)
+set -e
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+APP_DIR="$REPO_ROOT/apps/web-ui"
+
+if [ ! -d "$APP_DIR/node_modules/express" ]; then
+  echo "📦 Installing express + ws (one-time, ~15s)..."
+  cd "$APP_DIR"
+  (bun install 2>/dev/null) || npm install --silent
+  cd - >/dev/null
+fi
+
+cd "$APP_DIR"
+exec node server.mjs "$@"