copillm 0.2.3 → 0.2.5

package/dist/cli/shared/debug.js

@@ -0,0 +1,44 @@
+import { debugLogPath } from "../../config/home.js";
+// The root Command and root logger are constructed in cli/index.ts and
+// registered here so any command module can resolve "is debug globally on?"
+// without taking a Command parameter through every call. This preserves the
+// previous behavior where helpers reached for the module-level `program` and
+// `logger` directly.
+let rootProgram = null;
+let rootLogger = null;
+export function setRootProgram(program) {
+    rootProgram = program;
+}
+export function setRootLogger(logger) {
+    rootLogger = logger;
+}
+export function getRootLogger() {
+    if (!rootLogger) {
+        throw new Error("Root logger not initialized — cli/index.ts must call setRootLogger() first.");
+    }
+    return rootLogger;
+}
+function getGlobalDebug() {
+    if (!rootProgram) {
+        return false;
+    }
+    return Boolean(rootProgram.opts().debug);
+}
+export function resolveCopillmDebug(commandDebug) {
+    return Boolean(commandDebug) || getGlobalDebug();
+}
+export function enableRuntimeDebug(debug) {
+    if (!debug) {
+        return;
+    }
+    process.env.COPILLM_LOG_LEVEL = "debug";
+    if (rootLogger) {
+        rootLogger.level = "debug";
+    }
+}
+export function currentDebugLogPath(debug) {
+    if (!debug) {
+        return null;
+    }
+    return process.env.COPILLM_LOG_FILE ?? debugLogPath();
+}

package/dist/cli/shared/deprecation.js

@@ -0,0 +1,7 @@
+export function emitDeprecation(_opts, oldCmd, newCmd) {
+    // JSON consumers still get the deprecation on stderr so stdout stays pure;
+    // human consumers also get it on stderr. The branches are intentionally
+    // identical (preserving the original code shape) so future divergence is
+    // explicit.
+    process.stderr.write(`note: \`copillm ${oldCmd}\` is deprecated; use \`copillm ${newCmd}\`\n`);
+}

package/dist/cli/shared/exitCodes.js

@@ -0,0 +1,9 @@
+// Named exit codes used by the CLI. Behavior must match the previous inline
+// `process.exit(...)` literals exactly — these constants are documentation,
+// not policy changes.
+export const EXIT_OK = 0;
+export const EXIT_ERROR = 1;
+// Used for "not running" and "not logged in" — terminal states where the
+// command completed successfully but the asked-about resource is absent.
+export const EXIT_NOT_RUNNING = 2;
+export const EXIT_NOT_LOGGED_IN = 2;

package/dist/cli/shared/output.js

@@ -0,0 +1,14 @@
+export function writeCommandOutput(opts, humanLine, payload) {
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+        return;
+    }
+    process.stdout.write(`${humanLine}\n`);
+}
+export function writeHealthOutput(opts, payload) {
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+        return;
+    }
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}

package/dist/cli/shared/parseAgent.js

@@ -0,0 +1,6 @@
+export function parseAgentName(raw) {
+    const v = raw.trim().toLowerCase();
+    if (v === "codex" || v === "claude" || v === "pi")
+        return v;
+    throw new Error(`Unknown agent: ${raw}. Expected "codex", "claude", or "pi".`);
+}

package/dist/cli/updateNotifier.js

@@ -0,0 +1,223 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeFileSecureAtomic } from "../config/fsSecurity.js";
+import { getCopillmHome } from "../config/home.js";
+const DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
+const UPDATE_CHECK_TIMEOUT_MS = 3_000;
+export async function maybeNotifyAboutUpdate(options) {
+    const argv = options.argv ?? process.argv;
+    const env = options.env ?? process.env;
+    const stderr = options.stderr ?? process.stderr;
+    const now = options.now ?? Date.now;
+    const packageInfo = options.packageInfo;
+    const cacheFile = options.cacheFilePath ?? updateCachePath();
+    if (!shouldRunUpdateCheck({ argv, env, moduleUrl: options.moduleUrl ?? import.meta.url, packageInfo, stderr })) {
+        return;
+    }
+    const cache = readUpdateCache(cacheFile, packageInfo.name);
+    const checkedAt = now();
+    const latestVersion = await fetchLatestNpmVersion(packageInfo.name, {
+        fetchImpl: options.fetchImpl,
+        registryUrl: env.COPILLM_UPDATE_REGISTRY_URL,
+        timeoutMs: UPDATE_CHECK_TIMEOUT_MS
+    });
+    if (latestVersion) {
+        writeUpdateCache(cacheFile, {
+            version: 1,
+            packageName: packageInfo.name,
+            latestVersion,
+            checkedAt
+        });
+        notifyIfNewer(stderr, packageInfo, latestVersion);
+        return;
+    }
+    writeUpdateCache(cacheFile, {
+        version: 1,
+        packageName: packageInfo.name,
+        latestVersion: cache?.latestVersion ?? null,
+        checkedAt
+    });
+    notifyIfNewer(stderr, packageInfo, cache?.latestVersion ?? null);
+}
+export async function fetchLatestNpmVersion(packageName, options = {}) {
+    const registryUrl = options.registryUrl && options.registryUrl.trim().length > 0
+        ? options.registryUrl.trim()
+        : DEFAULT_REGISTRY_URL;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const timeoutMs = options.timeoutMs ?? UPDATE_CHECK_TIMEOUT_MS;
+    const signal = AbortSignal.timeout(timeoutMs);
+    try {
+        const response = await fetchImpl(distTagsUrl(packageName, registryUrl), {
+            headers: { accept: "application/json" },
+            signal
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return latestFromDistTags(await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+export function distTagsUrl(packageName, registryUrl = DEFAULT_REGISTRY_URL) {
+    return `${registryUrl.replace(/\/+$/, "")}/-/package/${encodeURIComponent(packageName)}/dist-tags`;
+}
+export function isNewerVersion(candidate, current) {
+    return compareSemver(candidate, current) > 0;
+}
+function shouldRunUpdateCheck(opts) {
+    if (opts.stderr.isTTY !== true)
+        return false;
+    if (isTruthyCi(opts.env.CI) || isTruthyCi(opts.env.CONTINUOUS_INTEGRATION))
+        return false;
+    if (opts.env.NODE_ENV === "test")
+        return false;
+    if ("NO_UPDATE_NOTIFIER" in opts.env)
+        return false;
+    if (hasArg(opts.argv, "--no-update-notifier"))
+        return false;
+    if (hasArg(opts.argv, "--version") || hasArg(opts.argv, "-V") || hasArg(opts.argv, "--help") || hasArg(opts.argv, "-h"))
+        return false;
+    if (hasArg(opts.argv, "--json"))
+        return false;
+    if (opts.argv.slice(2).includes("daemon"))
+        return false;
+    const override = parseBooleanOverride(opts.env.COPILLM_UPDATE_CHECK);
+    if (override !== null) {
+        return override;
+    }
+    return isNpmInstalledRuntime(opts.moduleUrl, opts.packageInfo.name);
+}
+function isNpmInstalledRuntime(moduleUrl, packageName) {
+    let modulePath;
+    try {
+        modulePath = fileURLToPath(moduleUrl);
+    }
+    catch {
+        return false;
+    }
+    const normalized = modulePath.split(path.sep).join("/").toLowerCase();
+    const marker = `/node_modules/${packageName.toLowerCase()}/`;
+    return normalized.includes(marker);
+}
+function updateCachePath() {
+    return path.join(getCopillmHome(), "update-check.json");
+}
+function readUpdateCache(filePath, packageName) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return parseUpdateCache(parsed, packageName);
+    }
+    catch {
+        return null;
+    }
+}
+function writeUpdateCache(filePath, cache) {
+    try {
+        writeFileSecureAtomic(filePath, `${JSON.stringify(cache, null, 2)}\n`, 0o600);
+    }
+    catch {
+        // Update checks are advisory and must never prevent the CLI from starting.
+    }
+}
+function parseUpdateCache(value, packageName) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const candidate = value;
+    if (candidate.version !== 1 || candidate.packageName !== packageName) {
+        return null;
+    }
+    if (candidate.latestVersion !== null && typeof candidate.latestVersion !== "string") {
+        return null;
+    }
+    if (typeof candidate.checkedAt !== "number" || !Number.isFinite(candidate.checkedAt)) {
+        return null;
+    }
+    return {
+        version: 1,
+        packageName,
+        latestVersion: candidate.latestVersion,
+        checkedAt: candidate.checkedAt
+    };
+}
+function latestFromDistTags(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const latest = value.latest;
+    return typeof latest === "string" && latest.trim().length > 0 ? latest.trim() : null;
+}
+function notifyIfNewer(stderr, packageInfo, latestVersion) {
+    if (!latestVersion || !isNewerVersion(latestVersion, packageInfo.version)) {
+        return;
+    }
+    stderr.write([
+        "",
+        `copillm ${latestVersion} is available (current ${packageInfo.version}).`,
+        "Update with: npm install -g copillm",
+        "Release notes: https://github.com/jcjc-dev/copillm/releases/latest",
+        ""
+    ].join("\n"));
+}
+function hasArg(argv, arg) {
+    return argv.slice(2).includes(arg);
+}
+function parseBooleanOverride(value) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return null;
+}
+function isTruthyCi(value) {
+    if (value === undefined) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "0" && normalized !== "false";
+}
+function compareSemver(left, right) {
+    const parsedLeft = parseSemver(left);
+    const parsedRight = parseSemver(right);
+    if (!parsedLeft || !parsedRight) {
+        return 0;
+    }
+    for (let i = 0; i < 3; i += 1) {
+        const delta = parsedLeft.core[i] - parsedRight.core[i];
+        if (delta !== 0) {
+            return delta;
+        }
+    }
+    if (parsedLeft.prerelease === parsedRight.prerelease) {
+        return 0;
+    }
+    if (parsedLeft.prerelease === null) {
+        return 1;
+    }
+    if (parsedRight.prerelease === null) {
+        return -1;
+    }
+    return parsedLeft.prerelease.localeCompare(parsedRight.prerelease);
+}
+function parseSemver(value) {
+    const match = value.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease: match[4] ?? null
+    };
+}