@onyx-robotics/agent 0.1.0

package/src/onyx.ts

@@ -0,0 +1,92 @@
+// Public surface barrel: keeps `bin/onyx.ts` and tests importing from "./onyx"
+// while the implementation lives in focused modules under lib/ and commands/.
+export { parseArgs, type Args } from "./lib/args"
+export { parseMetricLines, primaryMetric, summarizeOutput } from "./lib/metrics"
+export {
+  branchMetadata,
+  resolveBranchName,
+  type BranchMetadata,
+  type MetricDirection,
+} from "./lib/markdown"
+export {
+  branchStateKey,
+  normalizeProjectPath,
+  onyxPath,
+  resolveProjectPath,
+  scopedRoot,
+} from "./lib/project"
+export {
+  appendOutbox,
+  clearLastRun,
+  clientRunRef,
+  lastRunPath,
+  onyxStateDir,
+  outboxPath,
+  readLastRun,
+  readOutbox,
+  readState,
+  rewriteOutbox,
+  statePath,
+  writeLastRun,
+  writeState,
+  type CliState,
+  type LastRunRecord,
+} from "./lib/outbox"
+export {
+  appendHistory,
+  apiExperimentToHistory,
+  applyHistorySyncUpdates,
+  experimentRecordToHistory,
+  historyPath,
+  hydrateHistoryFromApi,
+  mergeHistory,
+  readHistory,
+  rewriteHistory,
+  type HistorySyncUpdate,
+  type HydrateResult,
+} from "./lib/history"
+export { emitEvent, eventsPath, readEvents, truncateEvents } from "./lib/events"
+export {
+  formatAge,
+  formatMetricCell,
+  formatMetricValue,
+  pad,
+  renderExperimentTable,
+  renderFrame,
+  spinnerChar,
+  stripAnsi,
+  truncate,
+  truncateAnsi,
+  type ExperimentRow,
+  type ListenModel,
+} from "./lib/tui"
+export { flushOutbox, type FlushResult } from "./lib/sync"
+export {
+  gitBranchForName,
+  currentBranch,
+  currentCommit,
+  gitDir,
+  nameFromGitBranch,
+  normalizeRepositoryUrl,
+  repoRoot,
+} from "./lib/git"
+export {
+  defaultSkillInstallRoot,
+  displaySkillPath,
+  installOnyxSkill,
+  packagedSkillPath,
+} from "./lib/skill"
+export * from "./protocol"
+export { commandAgent } from "./commands/agent"
+export { commandLogin } from "./commands/login"
+export {
+  commandProfile,
+  commandProfileList,
+  commandProfileSetApiKeyEnv,
+  commandProfileUse,
+} from "./commands/profile"
+export { commandBranchCreate } from "./commands/branch"
+export { commandExpList, commandExpLog, commandExpRun } from "./commands/exp"
+export { commandListen } from "./commands/listen"
+export { commandPush, commandStatus, commandSync } from "./commands/sync"
+export { USAGE, main } from "./main"

package/src/profile.test.ts

@@ -0,0 +1,472 @@
+import { mkdtemp } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { beforeEach, describe, expect, test } from "bun:test"
+
+import {
+  DEFAULT_API_URL,
+  apiBaseUrl,
+  apiKey,
+  readConfig,
+  writeConfig,
+  type CliProfile,
+} from "./lib/config"
+import { cliLoginCompleteHtml } from "./lib/login"
+import {
+  buildCliLoginUrl,
+  loginProfileManifest,
+  profileNameForTeam,
+  saveLoginProfile,
+} from "./commands/login"
+import {
+  commandProfileList,
+  commandProfileSetApiKeyEnv,
+  commandProfileUse,
+} from "./commands/profile"
+
+const ALPHA_API_KEY_ENV = "ONYX_ALPHA_API_KEY"
+const BETA_API_KEY_ENV = "ONYX_BETA_API_KEY"
+
+function profile(overrides: Partial<CliProfile> = {}): CliProfile {
+  return {
+    apiUrl: "https://app.onyx.test",
+    apiKey: "onyx_key",
+    teamId: "22222222-2222-4222-8222-222222222222",
+    teamName: "Alpha Team",
+    updatedAt: "2026-06-06T12:00:00.000Z",
+    ...overrides,
+  }
+}
+
+async function captureLogs(fn: () => Promise<void>) {
+  const previous = console.log
+  const logs: string[] = []
+  console.log = (...args: unknown[]) => {
+    logs.push(args.map(String).join(" "))
+  }
+  try {
+    await fn()
+  } finally {
+    console.log = previous
+  }
+  return logs.join("\n")
+}
+
+describe("CLI profiles", () => {
+  beforeEach(async () => {
+    process.env.XDG_CONFIG_HOME = await mkdtemp(
+      join(tmpdir(), "onyx-cli-config-test-")
+    )
+    delete process.env.ONYX_API_KEY
+    delete process.env.ONYX_API_URL
+    delete process.env[ALPHA_API_KEY_ENV]
+    delete process.env[BETA_API_KEY_ENV]
+  })
+
+  test("stores login results as the current profile", async () => {
+    const saved = await saveLoginProfile({
+      baseUrl: "http://localhost:3000",
+      result: {
+        apiKey: "onyx_secret",
+        apiKeyId: "44444444-4444-4444-8444-444444444444",
+        apiUrl: "https://app.onyx.test",
+        teamId: "22222222-2222-4222-8222-222222222222",
+        teamName: "Alpha Team",
+        alreadyConfigured: false,
+      },
+    })
+
+    expect(saved).toEqual({
+      profileName: "alpha",
+      alreadyConfigured: false,
+    })
+    const config = await readConfig()
+    expect(config.currentProfile).toBe("alpha")
+    expect(config.profiles.alpha).toMatchObject({
+      apiUrl: "https://app.onyx.test",
+      apiKey: "onyx_secret",
+      apiKeyId: "44444444-4444-4444-8444-444444444444",
+      teamId: "22222222-2222-4222-8222-222222222222",
+      teamName: "Alpha Team",
+    })
+  })
+
+  test("builds the browser login URL with a non-secret profile manifest", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({
+          apiKey: "alpha-secret",
+          apiKeyId: "44444444-4444-4444-8444-444444444444",
+        }),
+      },
+    })
+
+    const config = await readConfig()
+    const loginUrl = buildCliLoginUrl({
+      baseUrl: "https://app.onyx.test",
+      redirectUri: "http://127.0.0.1:8765/callback",
+      state: "state-123",
+      profiles: loginProfileManifest(config),
+      refresh: true,
+    })
+
+    expect(loginUrl.pathname).toBe("/cli/login")
+    expect(loginUrl.searchParams.get("redirect_uri")).toBe(
+      "http://127.0.0.1:8765/callback"
+    )
+    expect(loginUrl.searchParams.get("refresh")).toBe("true")
+    const manifest = JSON.parse(
+      Buffer.from(
+        loginUrl.searchParams.get("profiles") ?? "",
+        "base64url"
+      ).toString("utf8")
+    )
+    expect(manifest).toEqual([
+      {
+        profileName: "alpha",
+        teamId: "22222222-2222-4222-8222-222222222222",
+        apiUrl: "https://app.onyx.test",
+        apiKeyId: "44444444-4444-4444-8444-444444444444",
+      },
+    ])
+    expect(JSON.stringify(manifest)).not.toContain("alpha-secret")
+  })
+
+  test("renders a branded login completion page", () => {
+    const html = cliLoginCompleteHtml()
+
+    expect(html).toContain("Onyx CLI login complete. You can close this tab.")
+    expect(html).toContain("<span>Onyx</span>")
+    expect(html).toContain('<section class="card"')
+    expect(html).toContain("--background: oklch(0.96 0 0)")
+    expect(html).toContain("width: 60px")
+    expect(html).toContain("font-size: 48px")
+  })
+
+  test("generates first-word profile names and handles empty names", () => {
+    expect(profileNameForTeam("Acme Research Lab")).toBe("acme")
+    expect(profileNameForTeam("Acme-Research Lab")).toBe("acme-research")
+    expect(profileNameForTeam("!!!")).toBe("team")
+  })
+
+  test("reuses existing team and origin profiles", async () => {
+    await writeConfig({
+      currentProfile: "custom",
+      profiles: {
+        custom: profile({
+          apiKey: "old-key",
+          teamName: "Original Team",
+        }),
+      },
+    })
+
+    const saved = await saveLoginProfile({
+      baseUrl: "https://app.onyx.test",
+      result: {
+        apiKey: "new-key",
+        apiUrl: "https://app.onyx.test",
+        teamId: "22222222-2222-4222-8222-222222222222",
+        teamName: "Renamed Team",
+        alreadyConfigured: false,
+      },
+    })
+
+    expect(saved.profileName).toBe("custom")
+    const config = await readConfig()
+    expect(config.profiles.custom?.apiKey).toBe("new-key")
+    expect(config.profiles.custom?.teamName).toBe("Renamed Team")
+  })
+
+  test("suffixes generated profile names when another team owns the name", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({
+          teamId: "33333333-3333-4333-8333-333333333333",
+          teamName: "Alpha Other",
+        }),
+      },
+    })
+
+    const saved = await saveLoginProfile({
+      baseUrl: "https://app.onyx.test",
+      result: {
+        apiKey: "new-key",
+        apiUrl: "https://app.onyx.test",
+        teamId: "22222222-2222-4222-8222-222222222222",
+        teamName: "Alpha Team",
+        alreadyConfigured: false,
+      },
+    })
+
+    expect(saved.profileName).toBe("alpha-2")
+    expect((await readConfig()).currentProfile).toBe("alpha-2")
+  })
+
+  test("selects already configured profiles without overwriting credentials", async () => {
+    await writeConfig({
+      currentProfile: "beta",
+      profiles: {
+        alpha: profile({ apiKey: "old-key" }),
+        beta: profile({
+          apiKey: "beta-key",
+          teamId: "33333333-3333-4333-8333-333333333333",
+          teamName: "Beta Team",
+        }),
+      },
+    })
+
+    const saved = await saveLoginProfile({
+      baseUrl: "https://app.onyx.test",
+      result: {
+        apiUrl: "https://app.onyx.test",
+        teamId: "22222222-2222-4222-8222-222222222222",
+        teamName: "Alpha Team",
+        profileName: "alpha",
+        alreadyConfigured: true,
+      },
+    })
+
+    const config = await readConfig()
+    expect(saved).toEqual({
+      profileName: "alpha",
+      alreadyConfigured: true,
+    })
+    expect(config.currentProfile).toBe("alpha")
+    expect(config.profiles.alpha?.apiKey).toBe("old-key")
+  })
+
+  test("refresh replaces env-backed profile credentials with the returned stored key", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({
+          apiKey: undefined,
+          apiKeyEnv: ALPHA_API_KEY_ENV,
+        }),
+      },
+    })
+
+    await saveLoginProfile({
+      baseUrl: "https://app.onyx.test",
+      result: {
+        apiKey: "new-stored-key",
+        apiKeyId: "44444444-4444-4444-8444-444444444444",
+        apiUrl: "https://app.onyx.test",
+        teamId: "22222222-2222-4222-8222-222222222222",
+        teamName: "Alpha Team",
+        alreadyConfigured: false,
+      },
+    })
+
+    const alpha = (await readConfig()).profiles.alpha
+    expect(alpha?.apiKey).toBe("new-stored-key")
+    expect(alpha?.apiKeyId).toBe("44444444-4444-4444-8444-444444444444")
+    expect(alpha?.apiKeyEnv).toBeUndefined()
+  })
+
+  test("resolves current and overridden profiles for API calls", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({ apiKey: "alpha-key" }),
+        beta: profile({
+          apiUrl: "https://beta.onyx.test",
+          apiKey: "beta-key",
+          teamName: "Beta Team",
+        }),
+      },
+    })
+
+    expect(await apiBaseUrl()).toBe("https://app.onyx.test")
+    expect(await apiKey()).toBe("alpha-key")
+    expect(
+      await apiBaseUrl({
+        positional: ["status"],
+        options: { profile: "beta" },
+      })
+    ).toBe("https://beta.onyx.test")
+    expect(
+      await apiKey({
+        positional: ["status"],
+        options: { profile: "beta" },
+      })
+    ).toBe("beta-key")
+  })
+
+  test("uses environment credentials before profiles", async () => {
+    process.env.ONYX_API_KEY = "env-key"
+    process.env.ONYX_API_URL = "https://env.onyx.test"
+
+    expect(await apiBaseUrl()).toBe("https://env.onyx.test")
+    expect(await apiKey()).toBe("env-key")
+  })
+
+  test("defaults API URL to the hosted app for standalone installs", async () => {
+    process.env.ONYX_API_KEY = "env-key"
+
+    expect(await apiBaseUrl()).toBe(DEFAULT_API_URL)
+  })
+
+  test("resolves profile API keys from apiKeyEnv before stored profile keys", async () => {
+    process.env[ALPHA_API_KEY_ENV] = "alpha-env-key"
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({
+          apiKey: "alpha-stored-key",
+          apiKeyEnv: ALPHA_API_KEY_ENV,
+        }),
+      },
+    })
+
+    expect(await apiKey()).toBe("alpha-env-key")
+  })
+
+  test("does not fall back to a stored key when apiKeyEnv is missing", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({
+          apiKey: "alpha-stored-key",
+          apiKeyEnv: ALPHA_API_KEY_ENV,
+        }),
+      },
+    })
+
+    await expect(apiKey()).rejects.toThrow(
+      'Profile "alpha" expects API key in ONYX_ALPHA_API_KEY'
+    )
+  })
+
+  test("treats an empty profile API key environment variable as missing", async () => {
+    process.env[ALPHA_API_KEY_ENV] = "  "
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({
+          apiKey: "alpha-stored-key",
+          apiKeyEnv: ALPHA_API_KEY_ENV,
+        }),
+      },
+    })
+
+    await expect(apiKey()).rejects.toThrow(
+      'Profile "alpha" expects API key in ONYX_ALPHA_API_KEY'
+    )
+  })
+
+  test("global environment API key overrides a missing profile apiKeyEnv", async () => {
+    process.env.ONYX_API_KEY = "global-env-key"
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({
+          apiKey: "alpha-stored-key",
+          apiKeyEnv: ALPHA_API_KEY_ENV,
+        }),
+      },
+    })
+
+    expect(await apiKey()).toBe("global-env-key")
+  })
+
+  test("lists profiles and switches the active profile", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({ apiKey: "alpha-key" }),
+        beta: profile({
+          apiKey: "beta-key",
+          teamId: "33333333-3333-4333-8333-333333333333",
+          teamName: "Beta Team",
+        }),
+      },
+    })
+
+    const output = await captureLogs(commandProfileList)
+    expect(output).toContain("* alpha")
+    expect(output).toContain("stored key")
+    expect(output).toContain("  beta")
+
+    await captureLogs(() =>
+      commandProfileUse({
+        positional: ["profile", "use", "beta"],
+        options: {},
+      })
+    )
+    expect((await readConfig()).currentProfile).toBe("beta")
+  })
+
+  test("lists env-backed credential sources", async () => {
+    process.env[ALPHA_API_KEY_ENV] = "alpha-env-key"
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({ apiKeyEnv: ALPHA_API_KEY_ENV }),
+        beta: profile({
+          apiKey: undefined,
+          apiKeyEnv: BETA_API_KEY_ENV,
+          teamName: "Beta Team",
+        }),
+      },
+    })
+
+    const output = await captureLogs(commandProfileList)
+    expect(output).toContain("env:ONYX_ALPHA_API_KEY (set)")
+    expect(output).toContain("env:ONYX_BETA_API_KEY (missing)")
+  })
+
+  test("sets a profile API key environment variable and removes stored key", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({ apiKey: "alpha-stored-key" }),
+      },
+    })
+
+    await captureLogs(() =>
+      commandProfileSetApiKeyEnv({
+        positional: ["profile", "set-api-key-env", "alpha", ALPHA_API_KEY_ENV],
+        options: {},
+      })
+    )
+
+    const config = await readConfig()
+    const alpha = config.profiles.alpha
+    expect(alpha).toBeDefined()
+    expect(alpha?.apiKey).toBeUndefined()
+    expect(alpha?.apiKeyEnv).toBe(ALPHA_API_KEY_ENV)
+  })
+
+  test("rejects unsafe API key environment variable names", async () => {
+    await writeConfig({
+      currentProfile: "alpha",
+      profiles: {
+        alpha: profile({ apiKey: "alpha-stored-key" }),
+      },
+    })
+
+    await expect(
+      commandProfileSetApiKeyEnv({
+        positional: ["profile", "set-api-key-env", "alpha", "onyx_alpha"],
+        options: {},
+      })
+    ).rejects.toThrow("Environment variable name must match")
+  })
+
+  test("errors when a selected profile is missing", async () => {
+    await expect(apiKey()).rejects.toThrow("No Onyx CLI profile selected")
+    await expect(
+      apiKey({ positional: ["status"], options: { profile: "missing" } })
+    ).rejects.toThrow('Unknown Onyx CLI profile "missing"')
+    await expect(
+      commandProfileUse({
+        positional: ["profile", "use", "missing"],
+        options: {},
+      })
+    ).rejects.toThrow('Unknown Onyx CLI profile "missing"')
+  })
+})

package/src/protocol/index.ts

@@ -0,0 +1,2 @@
+export * from "./local-research"
+export * from "./research"