blinkai 0.1.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "blinkai",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "BlinkAI command line client",
+  "bin": {
+    "blinkai": "src/index.js"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "start": "node ./src/index.js",
+    "pack:check": "npm pack --dry-run",
+    "link:global": "npm link"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/api.js

@@ -0,0 +1,122 @@
+function trimSlash(value) {
+  return String(value || "").replace(/\/$/, "");
+}
+
+export class BlinkApiClient {
+  constructor({ apiBaseUrl, token = "" }) {
+    this.apiBaseUrl = trimSlash(apiBaseUrl);
+    this.token = token;
+  }
+
+  setToken(token) {
+    this.token = token;
+  }
+
+  async request(path, init = {}) {
+    const headers = new Headers(init.headers || {});
+    if (this.token) {
+      headers.set("Authorization", `Bearer ${this.token}`);
+    }
+    if (init.body !== undefined && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+
+    const response = await fetch(`${this.apiBaseUrl}${path}`, {
+      ...init,
+      headers,
+      body: init.body !== undefined ? JSON.stringify(init.body) : undefined,
+    });
+    const raw = await response.text();
+    let payload = null;
+    try {
+      payload = raw ? JSON.parse(raw) : null;
+    } catch {
+      payload = raw;
+    }
+    if (!response.ok) {
+      const detail = payload && typeof payload === "object"
+        ? payload.detail || payload.error?.message || payload.error
+        : payload;
+      throw new Error(String(detail || response.statusText || "Request failed"));
+    }
+    return payload;
+  }
+
+  login(email, password) {
+    return this.request("/auth/login", {
+      method: "POST",
+      body: { email, password },
+    });
+  }
+
+  register(email, username, password) {
+    return this.request("/auth/register", {
+      method: "POST",
+      body: { email, username, password },
+    });
+  }
+
+  getSession() {
+    return this.request("/cli/session");
+  }
+
+  connectProvider(payload) {
+    return this.request("/cli/provider/connect", {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  setAgentName(name) {
+    return this.request("/cli/agent/name", {
+      method: "POST",
+      body: { name },
+    });
+  }
+
+  sendChat(body, surface = "cli") {
+    return this.request("/cli/chat", {
+      method: "POST",
+      body: { body, surface },
+    });
+  }
+
+  registerGateway(payload) {
+    return this.request("/cli/gateways/register", {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  heartbeatGateway(gatewayId) {
+    return this.request(`/cli/gateways/${encodeURIComponent(gatewayId)}/heartbeat`, {
+      method: "POST",
+    });
+  }
+
+  nextGatewayCommand(gatewayId) {
+    return this.request(`/cli/gateways/${encodeURIComponent(gatewayId)}/commands/next`, {
+      method: "POST",
+    });
+  }
+
+  completeGatewayCommand(commandId, payload) {
+    return this.request(`/cli/gateways/commands/${encodeURIComponent(commandId)}/complete`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  startCodexOauth(providerModel = "") {
+    const suffix = providerModel ? `?provider_model=${encodeURIComponent(providerModel)}` : "";
+    return this.request(`/mobile/oauth/openai-codex/start${suffix}`, {
+      method: "POST",
+    });
+  }
+
+  completeCodexOauth(authorizationInput) {
+    return this.request(`/mobile/oauth/openai-codex/complete?authorization_input=${encodeURIComponent(authorizationInput)}`, {
+      method: "POST",
+    });
+  }
+}

package/src/config.js

@@ -0,0 +1,43 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const CURRENT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_CLI_ROOT = path.resolve(CURRENT_DIR, "..");
+const CONFIG_ROOT = process.env.OPENAGORA_CLI_HOME
+  ? path.resolve(process.env.OPENAGORA_CLI_HOME)
+  : path.join(PROJECT_CLI_ROOT, ".state");
+const CONFIG_PATH = path.join(CONFIG_ROOT, "config.json");
+const RUNTIME_ROOT = path.join(CONFIG_ROOT, "runtime");
+
+export function getConfigRoot() {
+  fs.mkdirSync(CONFIG_ROOT, { recursive: true });
+  fs.mkdirSync(RUNTIME_ROOT, { recursive: true });
+  return CONFIG_ROOT;
+}
+
+export function getRuntimeRoot() {
+  getConfigRoot();
+  return RUNTIME_ROOT;
+}
+
+export function loadConfig() {
+  getConfigRoot();
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return {
+      apiBaseUrl: process.env.BLINK_API_BASE_URL || "https://api.blinkai.online/api/v1",
+      token: "",
+      gatewayId: crypto.randomUUID(),
+      gatewayName: os.hostname(),
+      machineId: `${os.hostname()}-${os.userInfo().username}`,
+    };
+  }
+  return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+}
+
+export function saveConfig(config) {
+  getConfigRoot();
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+}

package/src/index.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import readline from "node:readline/promises";
+
+import { BlinkApiClient } from "./api.js";
+import { loadConfig, saveConfig } from "./config.js";
+
+const HELP = [
+  "/help",
+  "/session",
+  "/quit",
+  "",
+  "Any other line is sent to the shared BlinkAI account agent session.",
+].join("\n");
+
+async function main() {
+  const config = loadConfig();
+  const api = new BlinkApiClient({ apiBaseUrl: config.apiBaseUrl, token: config.token });
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let background = null;
+
+  try {
+    await ensureAuthenticated(api, config, rl);
+    const session = await ensureAccountAgentReady(api, rl);
+    const runtime = createGatewayRuntime();
+    let gateway = null;
+
+    if (runtime.enabled) {
+      runtime.start({ autonomous: false });
+      gateway = await api.registerGateway({
+        gateway_id: config.gatewayId,
+        name: config.gatewayName,
+        machine_id: config.machineId,
+        platform: `${process.platform}/${os.release()}`,
+        current_workspace: process.cwd(),
+        capabilities: {
+          browser: true,
+          shell: true,
+          filesystem: true,
+          screen: true,
+          provider: runtime.provider,
+          model: runtime.client?.model || "",
+          localTools: runtime.tools.spec().map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+          })),
+        },
+      });
+      config.gatewayId = gateway.gateway_id;
+      config.gatewayName = gateway.name;
+      saveConfig(config);
+      background = startBackgroundLoops(api, config, runtime);
+    }
+
+    process.stdout.write(
+      [
+        `BlinkAI CLI connected as @${session.user.username}`,
+        `Agent: ${session.mobile_agent.profile.agentName || "[unnamed]"}`,
+        `API: ${config.apiBaseUrl}`,
+        runtime.enabled
+          ? `Gateway: ${gateway.name} (${gateway.gateway_id})`
+          : "Gateway: disabled in standalone npm package",
+        "",
+      ].join("\n"),
+    );
+
+    process.stdout.write(`${HELP}\n\n`);
+
+    while (true) {
+      const line = (await rl.question("> ")).trim();
+      if (!line) {
+        continue;
+      }
+      if (line === "/quit" || line === "/exit") {
+        break;
+      }
+      if (line === "/help") {
+        process.stdout.write(`${HELP}\n`);
+        continue;
+      }
+      if (line === "/session") {
+        const next = await api.getSession();
+        process.stdout.write(JSON.stringify(next.mobile_agent.profile, null, 2) + "\n");
+        continue;
+      }
+
+      const result = await api.sendChat(line, "cli");
+      const reply = result.assistantMessage?.body || "[empty reply]";
+      process.stdout.write(`\n${reply}\n\n`);
+    }
+
+    background?.stop();
+  } finally {
+    background?.stop();
+    rl.close();
+  }
+}
+
+function createGatewayRuntime() {
+  return {
+    enabled: false,
+    provider: "",
+    client: null,
+    start() {},
+    tools: {
+      spec() {
+        return [];
+      },
+      async execute() {
+        throw new Error("Local gateway runtime is not bundled with the standalone BlinkAI CLI package.");
+      },
+    },
+  };
+}
+
+async function ensureAuthenticated(api, config, rl) {
+  if (config.token) {
+    try {
+      await api.getSession();
+      return;
+    } catch {
+    }
+  }
+
+  process.stdout.write("No valid BlinkAI session found.\n");
+  const mode = (await rl.question("Choose auth mode: [1] sign in, [2] register\n> ")).trim();
+  const email = (await rl.question("Email: ")).trim();
+  const password = (await rl.question("Password: ")).trim();
+
+  let auth;
+  if (mode === "2") {
+    const username = (await rl.question("Username: ")).trim();
+    auth = await api.register(email, username, password);
+  } else {
+    auth = await api.login(email, password);
+  }
+
+  config.token = auth.access_token;
+  api.setToken(auth.access_token);
+  saveConfig(config);
+}
+
+async function ensureAccountAgentReady(api, rl) {
+  let session = await api.getSession();
+  const profile = session.mobile_agent.profile;
+
+  if (!profile.providerName) {
+    process.stdout.write("No provider is connected to this BlinkAI account agent.\n");
+    const providerChoice = (await rl.question("Provider: [1] openai-codex, [2] local.starlidigital.com, [3] custom api-key provider\n> ")).trim();
+    if (providerChoice === "1") {
+      const start = await api.startCodexOauth("");
+      process.stdout.write(`Open this URL in a browser:\n${start.authUrl}\n\n`);
+      const authorizationInput = (await rl.question("Paste the final redirect URL or code: ")).trim();
+      await api.completeCodexOauth(authorizationInput);
+    } else if (providerChoice === "2") {
+      await api.connectProvider({
+        provider_name: "local.starlidigital.com",
+        provider_base_url: "https://local.starlidigital.com/v1",
+        provider_model: "joji",
+        provider_api_key: "local-starlidigital",
+      });
+    } else {
+      const providerName = (await rl.question("Provider name: ")).trim();
+      const providerBaseUrl = (await rl.question("Provider base URL (optional): ")).trim();
+      const providerModel = (await rl.question("Provider model (optional): ")).trim();
+      const providerApiKey = (await rl.question("Provider API key/token: ")).trim();
+      await api.connectProvider({
+        provider_name: providerName,
+        provider_base_url: providerBaseUrl || null,
+        provider_model: providerModel || null,
+        provider_api_key: providerApiKey || null,
+      });
+    }
+    session = await api.getSession();
+  }
+
+  if (session.mobile_agent.profile.onboardingRequired || !session.mobile_agent.profile.agentName) {
+    const agentName = (await rl.question("Agent name: ")).trim();
+    await api.setAgentName(agentName);
+    session = await api.getSession();
+  }
+
+  return session;
+}
+
+function startBackgroundLoops(api, config, runtime) {
+  let stopped = false;
+
+  const heartbeatTimer = setInterval(() => {
+    if (stopped) {
+      return;
+    }
+    void api.heartbeatGateway(config.gatewayId).catch(() => {});
+  }, 30_000);
+
+  const commandTimer = setInterval(() => {
+    if (stopped) {
+      return;
+    }
+    void pollGatewayCommand(api, config, runtime);
+  }, 3_000);
+
+  void pollGatewayCommand(api, config, runtime);
+
+  return {
+    stop() {
+      stopped = true;
+      clearInterval(heartbeatTimer);
+      clearInterval(commandTimer);
+    },
+  };
+}
+
+let commandInFlight = false;
+
+async function pollGatewayCommand(api, config, runtime) {
+  if (commandInFlight) {
+    return;
+  }
+  commandInFlight = true;
+  try {
+    const next = await api.nextGatewayCommand(config.gatewayId);
+    const command = next.item;
+    if (!command) {
+      return;
+    }
+
+    const toolName = String(command.payload?.toolName || "").trim();
+    const toolInput = command.payload?.input && typeof command.payload.input === "object" ? command.payload.input : {};
+    const taskSummary = String(command.payload?.taskSummary || "").trim();
+    if (!toolName) {
+      await api.completeGatewayCommand(command.command_id, {
+        ok: false,
+        error: "Gateway command was missing a tool name.",
+      });
+      return;
+    }
+
+    process.stdout.write(`\n[gateway:${command.gateway_name}] ${taskSummary || toolName}\n`);
+    try {
+      const result = await executeGatewayTool(runtime, toolName, toolInput);
+      await api.completeGatewayCommand(command.command_id, {
+        ok: true,
+        result: { output: result },
+      });
+      process.stdout.write(`[gateway:${command.gateway_name}] completed\n> `);
+    } catch (error) {
+      const publicError = formatGatewayError(error);
+      await api.completeGatewayCommand(command.command_id, {
+        ok: false,
+        error: publicError,
+      });
+      process.stdout.write(`[gateway:${command.gateway_name}] failed\n> `);
+    }
+  } finally {
+    commandInFlight = false;
+  }
+}
+
+async function executeGatewayTool(runtime, toolName, toolInput) {
+  const normalizedTool = String(toolName || "").trim();
+  const normalizedInput = toolInput && typeof toolInput === "object" ? toolInput : {};
+  if (normalizedTool === "write_file") {
+    normalizedInput.path = normalizeGatewayPath(normalizedInput.path);
+  }
+  const result = await runtime.tools.execute(normalizedTool, normalizedInput);
+  return typeof result === "string" ? result : JSON.stringify(result);
+}
+
+function formatGatewayError(error) {
+  const message = String(error?.message || error || "").trim();
+  if (!message) {
+    return "Gateway task failed.";
+  }
+  const normalized = message.toLowerCase();
+  if (
+    normalized.includes("configuration is incomplete") ||
+    normalized.includes("missing provider cookie") ||
+    normalized.includes("missing provider csrf token") ||
+    normalized.includes("missing provider conversation id") ||
+    normalized.includes("missing provider api url")
+  ) {
+    return "Gateway runtime is not configured for that provider.";
+  }
+  return message;
+}
+
+function normalizeGatewayPath(value) {
+  const raw = String(value || "").trim();
+  if (!raw) {
+    return raw;
+  }
+  return raw
+    .replace(/\[desktop\]/gi, path.join(os.homedir(), "Desktop"))
+    .replace(/\[home\]/gi, os.homedir())
+    .replace(/\//g, path.sep);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${String(error?.message || error)}\n`);
+  process.exitCode = 1;
+});