@4yi-dev/cli 0.1.5

package/README.md

@@ -0,0 +1,36 @@
+# 4YI CLI
+
+4YI CLI signs in through the 4YI web app and launches OpenCode with 4YI model routing.
+
+## Install
+
+Temporary dev environment:
+
+```bash
+npm install -g @4yi-dev/cli
+```
+
+Production environment:
+
+```bash
+npm install -g @4yi-dev/cli
+```
+
+Both packages install the `4yi` command. The dev package points at `https://xclaw-dev.bieases.com`; the production package points at `https://app.4yi.ai`.
+
+## Commands
+
+```bash
+4yi login
+4yi whoami
+4yi code
+```
+
+`4yi code` installs OpenCode under `~/.4yi/vendor/opencode`, writes an OpenCode config under `~/.4yi/opencode/opencode.json`, and launches OpenCode with a 4YI provider.
+
+For local development:
+
+```bash
+FOURYI_BASE_URL=http://localhost:3000 node packages/cli/bin/4yi.mjs login
+node packages/cli/bin/4yi.mjs code
+```

package/bin/4yi.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { login, loadSession, clearSession } from "../src/auth.mjs";
+import { runCode } from "../src/opencode.mjs";
+
+const command = process.argv[2] || "help";
+
+if (command === "help" || command === "--help" || command === "-h") {
+  console.log("Usage: 4yi <login|whoami|logout|code>");
+  process.exit(0);
+}
+
+if (command === "--version" || command === "-v") {
+  const pkg = await import("../package.json", { with: { type: "json" } });
+  console.log(pkg.default.version);
+  process.exit(0);
+}
+
+try {
+  if (command === "login") {
+    await login();
+  } else if (command === "whoami") {
+    const session = loadSession();
+    if (!session.token) throw new Error("Not signed in. Run `4yi login`.");
+    console.log(`${session.user?.email || "4yi user"} in ${session.org?.name || session.org?.id}`);
+  } else if (command === "logout") {
+    clearSession();
+    console.log("Signed out.");
+  } else if (command === "code") {
+    const session = loadSession();
+    const code = await runCode({ session, argv: process.argv.slice(3) });
+    process.exit(Number(code || 0));
+  } else {
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+  }
+} catch (err) {
+  console.error(err.message || String(err));
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@4yi-dev/cli",
+  "version": "0.1.5",
+  "description": "4YI command-line launcher for OAuth login and OpenCode runtime",
+  "type": "module",
+  "bin": {
+    "4yi": "bin/4yi.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "pack:dry": "npm pack --dry-run",
+    "stage:dev": "node scripts/stage-package.mjs dev",
+    "stage:prod": "node scripts/stage-package.mjs prod",
+    "pack:dev": "node scripts/stage-package.mjs dev --pack",
+    "pack:prod": "node scripts/stage-package.mjs prod --pack",
+    "publish:dev": "node scripts/stage-package.mjs dev --publish",
+    "publish:prod": "node scripts/stage-package.mjs prod --publish"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "UNLICENSED"
+}

package/src/auth.mjs

@@ -0,0 +1,57 @@
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { normalizeBaseUrl, readConfig, writeConfig } from "./config.mjs";
+import { requestJson } from "./http.mjs";
+
+export function loadSession(home = os.homedir()) {
+  return readConfig(home);
+}
+
+export function saveSession(session, home = os.homedir()) {
+  writeConfig(session, home);
+}
+
+export function clearSession(home = os.homedir()) {
+  const current = readConfig(home);
+  writeConfig({ baseUrl: current.baseUrl }, home);
+}
+
+export function openBrowser(url) {
+  const command = process.platform === "darwin"
+    ? "open"
+    : process.platform === "win32"
+      ? "cmd"
+      : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, { stdio: "ignore", detached: true });
+  child.unref();
+}
+
+export async function login({
+  baseUrl = process.env.FOURYI_BASE_URL,
+  home = os.homedir(),
+  open = openBrowser,
+  stdout = console.log,
+} = {}) {
+  const resolvedBaseUrl = normalizeBaseUrl(baseUrl);
+  const start = await requestJson(resolvedBaseUrl, "/api/cli/auth/start", { method: "POST" });
+  stdout("Opening browser for OAuth web verification...");
+  stdout(`If it does not open, visit: ${start.verification_uri_complete}`);
+  open(start.verification_uri_complete);
+
+  const started = Date.now();
+  while (Date.now() - started < start.expires_in * 1000) {
+    await new Promise((resolve) => setTimeout(resolve, start.interval * 1000));
+    const poll = await requestJson(resolvedBaseUrl, "/api/cli/auth/poll", {
+      method: "POST",
+      body: JSON.stringify({ device_code: start.device_code }),
+    });
+    if (poll.status === "approved" && poll.token) {
+      const session = await requestJson(resolvedBaseUrl, "/api/cli/session", { token: poll.token });
+      saveSession({ baseUrl: resolvedBaseUrl, token: poll.token, org: session.org, user: session.user }, home);
+      stdout(`Signed in to ${session.org.name}`);
+      return session;
+    }
+  }
+  throw new Error("OAuth verification expired");
+}

package/src/config.mjs

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const PACKAGE_NAME = "@4yi-dev/cli";
+
+const PACKAGE_BASE_URLS = {
+  "@4yi-dev/cli": "https://xclaw-dev.bieases.com",
+  "@4yi/cli": "https://app.4yi.ai",
+};
+
+export function defaultBaseUrlForPackage(packageName = PACKAGE_NAME) {
+  return PACKAGE_BASE_URLS[packageName] || PACKAGE_BASE_URLS["@4yi/cli"];
+}
+
+export const DEFAULT_BASE_URL = defaultBaseUrlForPackage(PACKAGE_NAME);
+
+export function normalizeBaseUrl(value) {
+  return String(value || DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+
+export function pathsForHome(home = os.homedir()) {
+  const homeDir = path.join(home, ".4yi");
+  const opencodeDir = path.join(homeDir, "vendor", "opencode");
+  const opencodeConfigDir = path.join(homeDir, "opencode");
+  return {
+    homeDir,
+    configFile: path.join(homeDir, "config.json"),
+    opencodeDir,
+    opencodePackageFile: path.join(opencodeDir, "package.json"),
+    opencodeConfigDir,
+    opencodeConfigFile: path.join(opencodeConfigDir, "opencode.json"),
+  };
+}
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+
+export function readConfig(home = os.homedir()) {
+  const { configFile } = pathsForHome(home);
+  if (!fs.existsSync(configFile)) return {};
+  return JSON.parse(fs.readFileSync(configFile, "utf8"));
+}
+
+export function writeConfig(config, home = os.homedir()) {
+  const paths = pathsForHome(home);
+  ensureDir(paths.homeDir);
+  fs.writeFileSync(paths.configFile, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}

package/src/http.mjs

@@ -0,0 +1,29 @@
+export async function requestJson(baseUrl, path, options = {}) {
+  const url = `${baseUrl}${path}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      "content-type": "application/json",
+      ...(options.token ? { authorization: `Bearer ${options.token}` } : {}),
+      ...(options.headers || {}),
+    },
+  });
+  const text = await res.text();
+  let body = null;
+  if (text) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      const contentType = res.headers.get("content-type") || "unknown content type";
+      throw new Error(`Expected JSON from ${url} but received ${contentType} (HTTP ${res.status})`);
+    }
+  }
+  if (!res.ok) {
+    const message = body?.error?.message || body?.error || `HTTP ${res.status}`;
+    const err = new Error(message);
+    err.status = res.status;
+    err.body = body;
+    throw err;
+  }
+  return body;
+}

package/src/opencode.mjs

@@ -0,0 +1,127 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { pathsForHome, ensureDir } from "./config.mjs";
+import { requestJson } from "./http.mjs";
+
+const DEFAULT_OPENCODE_PACKAGE = "opencode-ai";
+const DEFAULT_CONTEXT_LIMIT = 200000;
+const DEFAULT_OUTPUT_LIMIT = 8192;
+
+function isClaudeModel(model) {
+  const id = model?.id || "";
+  const name = model?.display_name || "";
+  return /claude/i.test(id) || /claude/i.test(name);
+}
+
+function modelContextLimit(model) {
+  return model.context_length || model.context_limit || model.input_limit || DEFAULT_CONTEXT_LIMIT;
+}
+
+function modelOutputLimit(model) {
+  return model.output_limit || model.max_output_tokens || model.max_tokens || DEFAULT_OUTPUT_LIMIT;
+}
+
+export function buildOpenCodeConfig({ modelConfig, tokenEnv = "FOURYI_CLI_TOKEN", orgEnv = "FOURYI_ORG_ID" }) {
+  const models = {};
+  const claudeModels = (modelConfig.models || []).filter(isClaudeModel);
+  for (const model of claudeModels) {
+    models[model.id] = {
+      name: model.display_name || model.id,
+      limit: {
+        context: modelContextLimit(model),
+        output: modelOutputLimit(model),
+      },
+    };
+  }
+  const defaultModel = claudeModels.some((model) => model.id === modelConfig.default_model)
+    ? modelConfig.default_model
+    : claudeModels[0]?.id;
+
+  return {
+    "$schema": "https://opencode.ai/config.json",
+    model: defaultModel ? `4yi/${defaultModel}` : undefined,
+    enabled_providers: ["4yi"],
+    provider: {
+      "4yi": {
+        name: "4YI",
+        npm: "@ai-sdk/openai-compatible",
+        options: {
+          baseURL: modelConfig.base_url,
+          apiKey: `{env:${tokenEnv}}`,
+          headers: {
+            "X-4YI-Org-ID": `{env:${orgEnv}}`,
+          },
+        },
+        models,
+      },
+    },
+  };
+}
+
+export function opencodeEnv({ home = os.homedir(), token, orgId = "", configFile, baseEnv = process.env } = {}) {
+  const xdgRoot = path.join(pathsForHome(home).opencodeConfigDir, "xdg");
+  return {
+    ...baseEnv,
+    FOURYI_CLI_TOKEN: token,
+    FOURYI_ORG_ID: orgId,
+    OPENCODE_CONFIG: configFile,
+    XDG_CONFIG_HOME: path.join(xdgRoot, "config"),
+    XDG_DATA_HOME: path.join(xdgRoot, "data"),
+    XDG_CACHE_HOME: path.join(xdgRoot, "cache"),
+    XDG_STATE_HOME: path.join(xdgRoot, "state"),
+  };
+}
+
+export function ensureOpenCodeRuntime({ home = os.homedir(), stdout = console.log } = {}) {
+  const paths = pathsForHome(home);
+  ensureDir(paths.opencodeDir);
+  if (!fs.existsSync(paths.opencodePackageFile)) {
+    fs.writeFileSync(paths.opencodePackageFile, JSON.stringify({
+      private: true,
+      type: "module",
+      dependencies: {},
+    }, null, 2));
+  }
+
+  const bin = path.join(paths.opencodeDir, "node_modules", ".bin", process.platform === "win32" ? "opencode.cmd" : "opencode");
+  if (fs.existsSync(bin)) return bin;
+
+  const opencodePackage = process.env.FOURYI_OPENCODE_PACKAGE || DEFAULT_OPENCODE_PACKAGE;
+  stdout(`Installing OpenCode runtime into ${paths.opencodeDir}...`);
+  const result = spawnSync("npm", ["install", "--prefix", paths.opencodeDir, opencodePackage, "@ai-sdk/openai-compatible"], {
+    stdio: "inherit",
+  });
+  if (result.status !== 0) throw new Error("OpenCode runtime install failed");
+  if (!fs.existsSync(bin)) throw new Error(`OpenCode binary not found at ${bin}`);
+  stdout("OpenCode runtime installed.");
+  return bin;
+}
+
+export async function runCode({ session, home = os.homedir(), argv = [], stdout = console.log } = {}) {
+  if (!session?.token) throw new Error("Not signed in. Run `4yi login`.");
+  const modelConfig = await requestJson(session.baseUrl, "/api/cli/models", { token: session.token });
+  if (!modelConfig.default_model) throw new Error("No chat models available for this organization.");
+  if (!(modelConfig.models || []).some(isClaudeModel)) throw new Error("No Claude models available for this organization.");
+
+  const paths = pathsForHome(home);
+  ensureDir(paths.opencodeConfigDir);
+  for (const dir of ["config", "data", "cache", "state"]) {
+    ensureDir(path.join(paths.opencodeConfigDir, "xdg", dir));
+  }
+  fs.writeFileSync(paths.opencodeConfigFile, `${JSON.stringify(buildOpenCodeConfig({ modelConfig }), null, 2)}\n`, { mode: 0o600 });
+
+  const bin = ensureOpenCodeRuntime({ home, stdout });
+  stdout("Launching OpenCode with 4YI models...");
+  const child = spawn(bin, argv, {
+    stdio: "inherit",
+    env: opencodeEnv({
+      home,
+      token: session.token,
+      orgId: session.org?.id || "",
+      configFile: paths.opencodeConfigFile,
+    }),
+  });
+  return new Promise((resolve) => child.on("exit", (code) => resolve(code ?? 0)));
+}