{

  "name": "@openagentsinc/cli",

  "version": "0.2.1",

  "version": "0.3.2",

  "private": false,

  "description": "Effect TypeScript command-line client for OpenAgents repositories",

  "keywords": [

  return { stdout: result.stdout, stderr: result.stderr };

};

/** Subcommand names from `--help`, which lists them one per line after SUBCOMMANDS. */

const subcommands = (help) => {

  const section = help.split("SUBCOMMANDS")[1];

  if (section === undefined) return [];

  return [...section.matchAll(/^\s{2}([a-z][a-z-]*)\s{2,}/gm)].map((match) => match[1]).sort();

};

try {

  mkdirSync(tarballDirectory);

  mkdirSync(consumerDirectory);

    throw new Error("The packed repository import help output is incomplete");

  }

  process.stdout.write("Packed npm install and CLI entry point passed.\n");

  // The published package once carried a `forum` command that existed in no

  // source file, because nothing compared what shipped against what a clean

  // build produces. Comparing the two command surfaces is that check.

  const packedSubcommands = subcommands(help);

  const localHelp = run("node", [join(packageRoot, "dist", "main.js"), "--help"]).stdout;

  const localSubcommands = subcommands(localHelp);

  const onlyPacked = packedSubcommands.filter((name) => !localSubcommands.includes(name));

  const onlyLocal = localSubcommands.filter((name) => !packedSubcommands.includes(name));

  if (onlyPacked.length > 0 || onlyLocal.length > 0) {

    throw new Error(

      "The packed CLI and a clean build disagree about their commands. " +

        `Only in the tarball: ${onlyPacked.join(", ") || "none"}. ` +

        `Only in the build: ${onlyLocal.join(", ") || "none"}.`,

    );

  }

  process.stdout.write(

    `Packed npm install, CLI entry point, and command surface passed (${packedSubcommands.join(", ")}).\n`,

  );

} finally {

  rmSync(temporaryRoot, { recursive: true, force: true });

}

import { findToken, resolveApiEndpoint, resolveApiSession } from "./session.js";

import { TerminalSession } from "./terminal-session.js";

export const VERSION = "0.1.7";

// The version lives in `package.json`; see `version.ts`.

export { VERSION } from "./version.js";

import { VERSION as CLI_VERSION } from "./version.js";

const profileFlag = Flag.choice("profile", ["production", "staging", "local"]).pipe(

  Flag.withSchema(Profile),

  ]),

);

export const runCliWith = Command.runWith(openagentsCommand, { version: VERSION });

export const runCliWith = Command.runWith(openagentsCommand, { version: CLI_VERSION });

/**

 * The CLI's version, read from `package.json` rather than restated.

 *

 * A hand-edited constant drifted: the published package reported `0.3.0` while

 * the committed constant said `0.1.7` and `package.json` said `0.2.1`, so

 * `openagents --version` named a release that was never published and nothing

 * failed. There is one place a version can live, and it is the manifest npm

 * publishes from.

 *

 * `package.json` sits one directory above the compiled output in both layouts

 * that matter: `dist/version.js` in a local build, and `dist/version.js` beside

 * the manifest in the published tarball. npm always includes `package.json`

 * regardless of the `files` list.

 */

import { readFileSync } from "node:fs";

import { dirname, join } from "node:path";

import { fileURLToPath } from "node:url";

/**

 * Reported when the manifest cannot be read. It is deliberately not a version:

 * a wrong number is worse than an obvious absence, because a number gets

 * believed and pasted into a bug report.

 */

const UNKNOWN = "unknown";

export const VERSION: string = readVersion();

export function manifestPath(): string {

  return join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");

}

function readVersion(): string {

  try {

    const manifest = JSON.parse(readFileSync(manifestPath(), "utf8")) as Record<string, unknown>;

    const version = manifest["version"];

    return typeof version === "string" && version.length > 0 ? version : UNKNOWN;

  } catch {

    return UNKNOWN;

  }

}

import { execFileSync } from "node:child_process";

import { existsSync, readFileSync } from "node:fs";

import { dirname, join } from "node:path";

import { fileURLToPath } from "node:url";

import { describe, expect, it } from "vitest";

import { VERSION, manifestPath } from "../src/version.js";

const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");

const manifest = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")) as {

  version: string;

};

describe("VERSION", () => {

  it("is the version in package.json", () => {

    // The defect this replaces: a hand-edited constant said 0.1.7 while the

    // manifest said 0.2.1 and npm served 0.3.0, and nothing failed.

    expect(VERSION).toBe(manifest.version);

  });

  it("is a real version rather than the unknown marker", () => {

    expect(VERSION).not.toBe("unknown");

    expect(VERSION).toMatch(/^\d+\.\d+\.\d+/);

  });

  it("resolves the manifest from the compiled layout, not only from source", () => {

    // `dist/version.js` must find `package.json` one directory up, which is

    // also the published tarball's layout.

    expect(existsSync(manifestPath())).toBe(true);

  });

  it("reports the manifest version through the built binary", () => {

    const built = join(packageRoot, "dist", "main.js");

    if (!existsSync(built)) return; // `pnpm run test` may run before a build.

    const printed = execFileSync("node", [built, "--version"], { encoding: "utf8" }).trim();

    expect(printed).toContain(manifest.version);

  });

  it("does not sit behind the version already published to npm", () => {

    // The published package was ahead of source once, which is how a shipped

    // command came to exist in no source file. A source version below the

    // registry's is the signal that it happened again.

    let published: string;

    try {

      published = execFileSync("npm", ["view", "@openagentsinc/cli", "version"], {

        encoding: "utf8",

        stdio: ["ignore", "pipe", "ignore"],

        timeout: 15_000,

      }).trim();

    } catch {

      return; // Offline, or the registry is unreachable. Not this test's failure.

    }

    expect(compare(manifest.version, published)).toBeGreaterThanOrEqual(0);

  });

});

/** Compare two `major.minor.patch` versions, ignoring any prerelease suffix. */

function compare(left: string, right: string): number {

  const parse = (value: string) =>

    (value.split("-")[0] ?? "").split(".").map((part) => Number.parseInt(part, 10) || 0);

  const a = parse(left);

  const b = parse(right);

  for (let index = 0; index < 3; index += 1) {

    const difference = (a[index] ?? 0) - (b[index] ?? 0);

    if (difference !== 0) return difference;

  }

  return 0;

}