@auroraflow/code 0.0.6 → 0.0.7

package/lib/aurora-api.js

@@ -0,0 +1,100 @@
+import { readState, writeState } from "./state.js";
+
+export async function login(email, password) {
+  const state = await readState();
+  const response = await fetch(`${trimSlash(state.controlPlaneURL)}/auth/login`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-aurora-client": "cli"
+    },
+    body: JSON.stringify({ email, password })
+  });
+  const payload = await readJSON(response);
+  if (!response.ok) throw new Error(payload?.message || payload?.error?.message || `login failed: ${response.status}`);
+  const token = payload?.session?.token;
+  if (!token) throw new Error("login response did not include session token");
+  await writeState({ ...state, account: { sessionToken: token, user: payload.user ?? null } });
+  return payload;
+}
+
+export async function listModels() {
+  const state = await readState();
+  const response = await fetch(`${trimSlash(state.gatewayURL)}/v1/aurora-cli/models`, {
+    headers: selectedRuntimeHeaders(state)
+  });
+  const payload = await readJSON(response);
+  if (!response.ok) throw new Error(payload?.message || payload?.error?.message || `list models failed: ${response.status}`);
+  return Array.isArray(payload.data) ? payload.data : [];
+}
+
+export async function listKeys() {
+  const state = await readState();
+  const response = await fetch(`${trimSlash(state.controlPlaneURL)}/aurora-cli/api-keys`, {
+    headers: sessionHeaders(state)
+  });
+  const payload = await readJSON(response);
+  if (!response.ok) throw new Error(payload?.message || payload?.error?.message || `list keys failed: ${response.status}`);
+  return payload;
+}
+
+export async function revealKey(keyID) {
+  const state = await readState();
+  const response = await fetch(`${trimSlash(state.controlPlaneURL)}/aurora-cli/api-keys/${encodeURIComponent(keyID)}/reveal`, {
+    method: "POST",
+    headers: sessionHeaders(state)
+  });
+  const payload = await readJSON(response);
+  if (!response.ok) throw new Error(payload?.message || payload?.error?.message || `reveal key failed: ${response.status}`);
+  return payload;
+}
+
+export async function createKey({ keyKind, organizationID, label }) {
+  const state = await readState();
+  const body = {
+    key_kind: keyKind,
+    label
+  };
+  if (organizationID) {
+    body.organization_id = organizationID;
+  }
+  const response = await fetch(`${trimSlash(state.controlPlaneURL)}/aurora-cli/api-keys`, {
+    method: "POST",
+    headers: {
+      ...sessionHeaders(state),
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const payload = await readJSON(response);
+  if (!response.ok) throw new Error(payload?.message || payload?.error?.message || `create key failed: ${response.status}`);
+  return payload;
+}
+
+function selectedRuntimeHeaders(state) {
+  const key = state.selectedKey?.presentedKey;
+  return key ? { authorization: `Bearer ${key}` } : {};
+}
+
+function sessionHeaders(state) {
+  const token = state.account?.sessionToken;
+  if (!token) throw new Error("Aurora login required. Run `aurora ctl login` first.");
+  return {
+    authorization: `Bearer ${token}`,
+    "x-aurora-client": "cli"
+  };
+}
+
+async function readJSON(response) {
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { message: text };
+  }
+}
+
+function trimSlash(value) {
+  return String(value).replace(/\/+$/, "");
+}

package/lib/commands.js

@@ -0,0 +1,27 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CLAUDE_HOME } from "./state.js";
+
+export async function installClaudeCommands() {
+  const commandsDir = join(CLAUDE_HOME, "commands");
+  await mkdir(commandsDir, { recursive: true });
+  await writeFile(join(commandsDir, "aurora.md"), commandFile("Open Aurora controls", "aurora ctl $ARGUMENTS"));
+  await writeFile(join(commandsDir, "aurora-model.md"), commandFile("Select Aurora model", "aurora ctl model $ARGUMENTS"));
+  await writeFile(join(commandsDir, "aurora-key.md"), commandFile("Select Aurora key", "aurora ctl key $ARGUMENTS"));
+  await writeFile(join(commandsDir, "aurora-status.md"), commandFile("Show Aurora status", "aurora ctl status"));
+  console.log(`Installed Claude commands into ${commandsDir}`);
+}
+
+function commandFile(description, command) {
+  return `---
+description: ${description}
+allowed-tools: Bash(aurora *)
+---
+
+Run this command and report the result to the user:
+
+\`\`\`bash
+${command}
+\`\`\`
+`;
+}

package/lib/launcher.js

@@ -0,0 +1,9 @@
+import { runClient } from "../packages/clients/src/index.js";
+
+export async function runClaude(args) {
+  await runClient("claude", args);
+}
+
+export async function runCodex(args) {
+  await runClient("codex", args);
+}

package/lib/pickers.js

@@ -0,0 +1,137 @@
+import { createKey, listKeys, listModels, login, revealKey } from "./aurora-api.js";
+import { promptChoice, promptFields, promptLine } from "./prompt.js";
+import { readState, writeState } from "./state.js";
+
+export async function pickModel(args = []) {
+  const direct = args.join(" ").trim();
+  const state = await readState();
+  if (direct) {
+    await writeState({ ...state, selectedModel: { alias: direct, source: "manual" } });
+    console.log(`Selected model: ${direct}`);
+    return;
+  }
+  const models = await listModels();
+  if (models.length === 0) throw new Error("Aurora model catalog is empty");
+  const providers = unique(models.map(item => item.provider || "aurora")).sort();
+  const provider = await promptChoice("Provider", providers.map(value => ({ label: value, value })));
+  const providerModels = models
+    .filter(item => (item.provider || "aurora") === provider)
+    .sort((a, b) => String(a.model_id || a.alias || a.id).localeCompare(String(b.model_id || b.alias || b.id)));
+  const model = await promptChoice("Model", providerModels.map(item => ({
+    label: `${item.model_id || item.alias || item.id}  ${item.display_name || ""}`.trim(),
+    value: item
+  })));
+  const alias = model.alias || model.id;
+  await writeState({ ...state, selectedModel: { alias, provider, modelID: model.model_id, source: "picker" } });
+  console.log(`Selected model: ${alias}`);
+}
+
+export async function pickKey(args = []) {
+  const direct = args.join(" ").trim();
+  const state = await readState();
+  if (direct) {
+    await writeState({ ...state, selectedKey: { presentedKey: direct, source: "manual" } });
+    console.log("Selected key updated.");
+    return;
+  }
+  const catalog = await listKeys();
+  const groups = Array.isArray(catalog.key_groups) ? catalog.key_groups : [];
+  const memberships = Array.isArray(catalog.memberships) ? catalog.memberships : [];
+  if (groups.length === 0) throw new Error("No Aurora key groups returned");
+  const group = await promptChoice("Key kind", groups.map(item => ({
+    label: keyKindLabel(item, memberships),
+    value: item
+  })));
+
+  let keys = Array.isArray(group.api_keys) ? group.api_keys : [];
+  let organization = null;
+  if (group.key_kind === "org") {
+    if (memberships.length === 0) throw new Error("No organization memberships are available");
+    organization = await promptChoice("Organization", memberships.map(item => {
+      const orgKeys = keys.filter(key => key.organization_id === item.organization_id);
+      return {
+        label: `${item.organization_name || item.organization_id} (${item.role || "member"} / ${orgKeys.length} keys)`,
+        value: item
+      };
+    }));
+    keys = keys.filter(key => key.organization_id === organization.organization_id);
+  }
+  const action = await promptChoice("Key", [
+    ...keys.map(item => ({
+      label: keyLabel(item),
+      value: { type: "existing", key: item }
+    })),
+    {
+      label: `Create new ${keyKindName(group.key_kind)} key`,
+      value: { type: "create" }
+    }
+  ]);
+
+  if (action.type === "create") {
+    const defaultLabel = `Aurora CLI ${Math.floor(Date.now() / 1000)}`;
+    const label = await promptLine(`New ${group.key_kind} key label`, defaultLabel);
+    const created = await createKey({
+      keyKind: group.key_kind,
+      organizationID: organization?.organization_id,
+      label
+    });
+    if (!created.api_key) throw new Error("create response did not include api_key");
+    if (!created.presented_key) throw new Error("create response did not include presented_key");
+    await saveSelectedKey(state, created.api_key, created.presented_key, "created");
+    console.log(`Created and selected key: ${created.api_key.label || created.api_key.id}`);
+    return;
+  }
+
+  const revealed = await revealKey(action.key.id);
+  if (!revealed.presented_key) throw new Error("reveal response did not include presented_key");
+  await saveSelectedKey(state, revealed.api_key || action.key, revealed.presented_key, "picker");
+  console.log(`Selected key: ${action.key.label || action.key.id}`);
+}
+
+function keyKindLabel(group, memberships) {
+  const keys = Array.isArray(group.api_keys) ? group.api_keys : [];
+  if (group.key_kind === "org") {
+    return `org (${memberships.length} organizations / ${keys.length} keys)`;
+  }
+  return `${group.key_kind} (${keys.length} keys)`;
+}
+
+export async function loginInteractive() {
+  const state = await readState();
+  const answers = await promptFields([
+    { name: "email", label: "Aurora email", defaultValue: state.account?.user?.email ?? "" },
+    { name: "password", label: "Aurora password", defaultValue: "" }
+  ]);
+  const payload = await login(answers.email, answers.password);
+  console.log(`Logged in as ${payload.user?.email || payload.user?.id || "Aurora user"}.`);
+}
+
+function keyLabel(item) {
+  const org = item.organization_name ? ` / ${item.organization_name}` : "";
+  const label = item.label || item.id;
+  const masked = item.masked_key ? ` ${item.masked_key}` : "";
+  return `${label}${org}${masked}`;
+}
+
+async function saveSelectedKey(state, key, presentedKey, source) {
+  await writeState({
+    ...state,
+    selectedKey: {
+      apiKeyID: key.id,
+      keyKind: key.key_kind,
+      organizationID: key.organization_id,
+      label: key.label,
+      presentedKey,
+      source
+    }
+  });
+}
+
+function keyKindName(value) {
+  if (value === "org") return "organization";
+  return value || "Aurora";
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}

package/lib/prompt.js

@@ -0,0 +1,136 @@
+import { readFileSync } from "node:fs";
+import * as readline from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+let pipedLines = null;
+let pipedIndex = 0;
+
+export async function promptLine(label, defaultValue = "") {
+  if (!input.isTTY) {
+    return nextPipedLine(defaultValue);
+  }
+  const rl = createInterface({ input, output });
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  const answer = await rl.question(`${label}${suffix}: `);
+  rl.close();
+  return answer.trim() || defaultValue;
+}
+
+export async function promptFields(fields) {
+  if (!input.isTTY) {
+    const out = {};
+    fields.forEach(field => {
+      const answer = nextPipedLine(field.defaultValue || "");
+      out[field.name] = answer || field.defaultValue || "";
+    });
+    return out;
+  }
+  const rl = createInterface({ input, output });
+  const out = {};
+  for (const field of fields) {
+    const suffix = field.defaultValue ? ` [${field.defaultValue}]` : "";
+    const answer = await rl.question(`${field.label}${suffix}: `);
+    out[field.name] = answer.trim() || field.defaultValue || "";
+  }
+  rl.close();
+  return out;
+}
+
+export async function chooseClient() {
+  if (!input.isTTY) {
+    const answer = nextPipedLine("claude").toLowerCase();
+    return answer === "codex" ? "codex" : "claude";
+  }
+  return terminalSelect("Choose client", [
+    { label: "Claude", value: "claude" },
+    { label: "Codex", value: "codex" }
+  ]);
+}
+
+export async function promptChoice(label, choices) {
+  if (!choices.length) throw new Error(`${label}: no choices available`);
+  if (!input.isTTY) {
+    const answer = nextPipedLine("1");
+    const index = Number(answer) - 1;
+    if (!Number.isInteger(index) || index < 0 || index >= choices.length) {
+      throw new Error(`invalid selection: ${answer}`);
+    }
+    return choices[index].value;
+  }
+  return terminalSelect(label, choices);
+}
+
+function terminalSelect(label, choices, defaultIndex = 0) {
+  if (!choices.length) throw new Error(`${label}: no choices available`);
+  let index = clamp(defaultIndex, 0, choices.length - 1);
+  let rendered = false;
+  const wasRaw = Boolean(input.isRaw);
+
+  readline.emitKeypressEvents(input);
+  if (input.setRawMode) input.setRawMode(true);
+  input.resume();
+  output.write("\x1b[?25l");
+  output.write(`${label}\n`);
+  renderChoices();
+
+  return new Promise(resolve => {
+    const onKeypress = (_chunk, key = {}) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        output.write("\n");
+        process.exit(130);
+      }
+      if (key.name === "up" || key.name === "k") {
+        index = (index + choices.length - 1) % choices.length;
+        renderChoices();
+        return;
+      }
+      if (key.name === "down" || key.name === "j" || key.name === "tab") {
+        index = (index + 1) % choices.length;
+        renderChoices();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter" || key.name === "space") {
+        const selected = choices[index].value;
+        cleanup();
+        output.write(`${selected}\n`);
+        resolve(selected);
+      }
+    };
+
+    input.on("keypress", onKeypress);
+
+    function cleanup() {
+      input.off("keypress", onKeypress);
+      if (input.setRawMode) input.setRawMode(wasRaw);
+      if (!wasRaw) input.pause();
+      output.write("\x1b[?25h");
+    }
+  });
+
+  function renderChoices() {
+    if (rendered) output.write(`\x1b[${choices.length}A`);
+    for (let i = 0; i < choices.length; i += 1) {
+      const selected = i === index;
+      const marker = selected ? "›" : " ";
+      const labelText = choices[i].label;
+      const line = selected ? `\x1b[36m${marker} ${labelText}\x1b[0m` : `${marker} ${labelText}`;
+      output.write(`\x1b[2K\r${line}\n`);
+    }
+    rendered = true;
+  }
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function nextPipedLine(defaultValue = "") {
+  if (pipedLines == null) {
+    pipedLines = readFileSync(0, "utf8").split(/\r?\n/);
+  }
+  const line = (pipedLines[pipedIndex] ?? "").trim();
+  pipedIndex += 1;
+  return line || defaultValue;
+}

package/lib/sidecar-client.js

@@ -0,0 +1,10 @@
+import { readSidecarInfo } from "./state.js";
+
+export async function sidecarStatus() {
+  const info = await readSidecarInfo();
+  const response = await fetch(`${info.baseURL}/aurora/status`, {
+    headers: { authorization: `Bearer ${info.token}` }
+  });
+  if (!response.ok) throw new Error(`sidecar status failed: ${response.status}`);
+  return response.json();
+}

package/lib/sidecar.js

@@ -0,0 +1 @@
+export * from "../packages/sidecar/src/index.js";

package/lib/state.js

@@ -0,0 +1 @@
+export * from "../packages/state/src/index.js";

package/package.json

@@ -1,34 +1,25 @@
 {
   "name": "@auroraflow/code",
-  "version": "0.0.6",
-  "description": "Aurora Code is Aurora's local coding agent.",
-  "license": "Apache-2.0",
+  "version": "0.0.7",
+  "type": "module",
+  "description": "Aurora launcher and sidecar for official Codex and Claude Code clients.",
   "bin": {
-    "aurora": "bin/aurora.js"
+    "aurora": "bin/aurora.js",
+    "aurora-claude": "bin/aurora-claude.js",
+    "aurora-codex": "bin/aurora-codex.js",
+    "aurora-sidecar": "bin/aurora-sidecar.js"
   },
-  "type": "module",
   "scripts": {
-    "postinstall": "node scripts/install_posix_launcher.js"
+    "postinstall": "node bin/aurora-postinstall.js",
+    "check": "find bin lib packages -name '*.js' -print0 | xargs -0 -n1 node --check"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=24"
   },
   "files": [
-    "bin/aurora.js",
-    "scripts/install_posix_launcher.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/auroraflowintl/code.git",
-    "directory": "codex-cli"
-  },
-  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319",
-  "optionalDependencies": {
-    "@auroraflow/code-linux-x64": "0.0.6",
-    "@auroraflow/code-linux-arm64": "0.0.6",
-    "@auroraflow/code-darwin-x64": "0.0.6",
-    "@auroraflow/code-darwin-arm64": "0.0.6",
-    "@auroraflow/code-win32-x64": "0.0.6",
-    "@auroraflow/code-win32-arm64": "0.0.6"
-  }
+    "README.md",
+    "bin",
+    "packages",
+    "lib"
+  ]
 }

package/packages/cli/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aurora/cli",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  }
+}

package/packages/cli/src/index.js

@@ -0,0 +1,135 @@
+import { ensureLayout, readAccount, readState, writeAccount, writeState } from "../../state/src/index.js";
+import { officialClientStatuses, runClient, updateOfficialClients } from "../../clients/src/index.js";
+import { chooseClient, promptFields } from "../../../lib/prompt.js";
+
+export async function runAuroraCLI(argv = process.argv.slice(2)) {
+  await ensureLayout();
+  const command = argv[0] ?? "";
+  const rest = argv.slice(1);
+  switch (command) {
+    case "":
+    case "start":
+      await startInteractive(rest);
+      return;
+    case "init":
+      await init();
+      return;
+    case "claude":
+      await runClient("claude", rest);
+      return;
+    case "codex":
+      await runClient("codex", rest);
+      return;
+    case "status":
+      console.log(JSON.stringify({
+        account: maskAccount(await readAccount()),
+        runtime: await readState(),
+        officialClients: officialClientStatuses()
+      }, null, 2));
+      return;
+    case "install-clients":
+    case "install-official-clients":
+    case "update-clients":
+    case "upgrade-clients":
+      await updateOfficialClients();
+      console.log(JSON.stringify({ officialClients: officialClientStatuses() }, null, 2));
+      return;
+    default:
+      usage(1);
+  }
+}
+
+export async function runAuroraClaude(argv = process.argv.slice(2)) {
+  await ensureLayout();
+  await runClient("claude", argv);
+}
+
+export async function runAuroraCodex(argv = process.argv.slice(2)) {
+  await ensureLayout();
+  await runClient("codex", argv);
+}
+
+async function startInteractive(args) {
+  const account = await readAccount();
+  if (!account.sessionToken) {
+    await init();
+  }
+  const client = await chooseClient();
+  await runClient(client, args);
+}
+
+async function init() {
+  const existing = await readState();
+  const account = await readAccount();
+  const answers = await promptFields([
+    { name: "controlPlaneURL", label: "Aurora control-plane URL", defaultValue: account.controlPlaneURL ?? existing.controlPlaneURL ?? "https://auroramos.com/api/v1" },
+    { name: "gatewayURL", label: "Aurora gateway URL", defaultValue: account.gatewayURL ?? existing.gatewayURL ?? "https://auroramos.com" },
+    { name: "email", label: "Aurora email", defaultValue: account.user?.email ?? "" },
+    { name: "password", label: "Aurora password", defaultValue: "" },
+    { name: "presentedKey", label: "Initial Aurora API key", defaultValue: existing.selectedKey?.presentedKey ?? "" },
+    { name: "model", label: "Initial Aurora model alias", defaultValue: existing.selectedModel?.alias ?? "" }
+  ]);
+  const login = await loginAurora(answers.controlPlaneURL, answers.email, answers.password);
+  const sessionToken = login.session?.token?.trim();
+  if (!sessionToken) throw new Error("Aurora login did not return session.token");
+  await writeAccount({
+    controlPlaneURL: answers.controlPlaneURL,
+    gatewayURL: answers.gatewayURL,
+    sessionToken,
+    user: login.user ? {
+      id: login.user.id,
+      email: login.user.email,
+      name: login.user.display_name || login.user.email
+    } : null
+  });
+  await writeState({
+    ...existing,
+    controlPlaneURL: answers.controlPlaneURL,
+    gatewayURL: answers.gatewayURL,
+    selectedKey: answers.presentedKey ? { presentedKey: answers.presentedKey, source: "manual" } : existing.selectedKey,
+    selectedModel: answers.model ? { alias: answers.model, source: "manual" } : existing.selectedModel
+  });
+  console.log("Aurora local account and runtime state initialized.");
+}
+
+async function loginAurora(controlPlaneURL, email, password) {
+  if (!email.trim()) throw new Error("Aurora email is required");
+  if (!password.trim()) throw new Error("Aurora password is required");
+  const response = await fetch(`${trimSlash(controlPlaneURL)}/auth/login`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-aurora-client": "cli"
+    },
+    body: JSON.stringify({ email, password })
+  });
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : {};
+  if (!response.ok) {
+    throw new Error(payload?.message || payload?.error?.message || `Aurora login failed: ${response.status}`);
+  }
+  return payload;
+}
+
+function trimSlash(value) {
+  return String(value).replace(/\/+$/, "");
+}
+
+function maskAccount(account) {
+  return {
+    ...account,
+    sessionToken: account.sessionToken ? "***" : null
+  };
+}
+
+function usage(exitCode) {
+  console.error(`Usage:
+  aurora
+  aurora init
+  aurora claude [args...]
+  aurora codex [args...]
+  aurora install-clients
+  aurora update-clients
+  aurora status`);
+  process.exit(exitCode);
+}

package/packages/clients/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aurora/clients",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  }
+}