@remotedraw/cli 0.1.2 → 0.2.0

package/dist/telemetry.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Crash reporting for the published CLI.
+ *
+ * Deliberately dependency-free: `remotedraw` is installed globally by customers,
+ * and pulling `@sentry/node` into it would add tens of megabytes and a native
+ * OpenTelemetry stack to what is otherwise a small package. Sentry's envelope
+ * endpoint is a plain POST, so the whole client is the function below.
+ *
+ * It only ever sends a crash — never a command's arguments, never file
+ * contents, never a project name. Anything that could carry a credential is
+ * scrubbed before it leaves the machine, and the whole path is opt-out.
+ */
+export type TelemetryEnvironment = {
+    env: Record<string, string | undefined>;
+    version: string;
+    platform: string;
+    nodeVersion: string;
+    /** Injected by the test suite so no suite run can reach the network. */
+    fetch?: typeof fetch | undefined;
+};
+/**
+ * Off whenever the user says so, and off in CI, where a crash report has no
+ * human behind it and the environment is usually a fresh container.
+ * DO_NOT_TRACK is the cross-vendor convention; we honor it without a flag.
+ */
+export declare function telemetryDisabled(env: Record<string, string | undefined>): boolean;
+/**
+ * Removes the two things a CLI error message realistically leaks: credentials
+ * pasted into a flag or read from the environment, and the absolute path of the
+ * user's home directory, which usually contains their name.
+ */
+export declare function scrubTelemetryText(value: string, env?: Record<string, string | undefined>): string;
+/**
+ * Builds the Sentry event for a crash. Exported so tests can assert exactly
+ * what would go over the wire without one leaving the machine.
+ */
+export declare function crashEvent(error: unknown, command: string, environment: TelemetryEnvironment): {
+    event_id: string;
+    timestamp: number;
+    platform: string;
+    level: string;
+    logger: string;
+    release: string;
+    environment: string;
+    transaction: string;
+    tags: {
+        command: string;
+        cli_version: string;
+        node_version: string;
+        os: string;
+    };
+    exception: {
+        values: {
+            type: string;
+            value: string;
+            mechanism: {
+                handled: boolean;
+            };
+        }[];
+    };
+    extra: {
+        stack: string;
+    } | undefined;
+};
+/**
+ * Reports a CLI crash. Never throws, never rejects, and never delays the exit
+ * by more than the timeout: a command's outcome must be identical whether or
+ * not Sentry is reachable.
+ */
+export declare function reportCliCrash(error: unknown, command: string, environment: TelemetryEnvironment): Promise<void>;
+/** The environment description used by the real CLI process. */
+export declare function nodeTelemetryEnvironment(version: string): TelemetryEnvironment;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,KAAK,CAAC,EAAE,OAAO,KAAK,GAAG,SAAS,CAAC;CAClC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,WAOxE;AAMD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAM,UAW7C;AAmBD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsClC;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,oBAAoB,iBA+BlC;AAED,gEAAgE;AAChE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,GACd,oBAAoB,CAOtB"}

package/dist/telemetry.js

@@ -0,0 +1,145 @@
+/**
+ * Crash reporting for the published CLI.
+ *
+ * Deliberately dependency-free: `remotedraw` is installed globally by customers,
+ * and pulling `@sentry/node` into it would add tens of megabytes and a native
+ * OpenTelemetry stack to what is otherwise a small package. Sentry's envelope
+ * endpoint is a plain POST, so the whole client is the function below.
+ *
+ * It only ever sends a crash — never a command's arguments, never file
+ * contents, never a project name. Anything that could carry a credential is
+ * scrubbed before it leaves the machine, and the whole path is opt-out.
+ */
+/**
+ * Filled in at release time. Sentry DSNs are public by design (browser bundles
+ * ship them), so a value here is not a secret; it only identifies the project
+ * that receives crashes. Override at runtime with REMOTEDRAW_SENTRY_DSN.
+ */
+const RELEASE_DSN = "";
+/**
+ * Off whenever the user says so, and off in CI, where a crash report has no
+ * human behind it and the environment is usually a fresh container.
+ * DO_NOT_TRACK is the cross-vendor convention; we honor it without a flag.
+ */
+export function telemetryDisabled(env) {
+    return Boolean(env.REMOTEDRAW_TELEMETRY_DISABLED?.trim() ||
+        env.REMOTEDRAW_CLI_OFFLINE?.trim() ||
+        env.DO_NOT_TRACK?.trim() ||
+        env.CI?.trim());
+}
+function dsnFor(env) {
+    return env.REMOTEDRAW_SENTRY_DSN?.trim() || RELEASE_DSN;
+}
+/**
+ * Removes the two things a CLI error message realistically leaks: credentials
+ * pasted into a flag or read from the environment, and the absolute path of the
+ * user's home directory, which usually contains their name.
+ */
+export function scrubTelemetryText(value, env = {}) {
+    let scrubbed = value
+        .replace(/\brd_[a-z]+_[A-Za-z0-9_-]+/g, "rd_***")
+        .replace(/\bsk_[A-Za-z0-9_-]{8,}/g, "sk_***")
+        .replace(/\b(Bearer)\s+\S+/gi, "$1 ***");
+    const home = env.HOME ?? env.USERPROFILE;
+    if (home && home.length > 1) {
+        scrubbed = scrubbed.split(home).join("~");
+    }
+    return scrubbed;
+}
+function parseDsn(value) {
+    try {
+        const url = new URL(value);
+        const projectId = url.pathname.replace(/^\//, "");
+        if (!url.username || !projectId)
+            return null;
+        return {
+            envelopeUrl: `${url.protocol}//${url.host}/api/${projectId}/envelope/`,
+            publicKey: url.username,
+            dsn: value,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Builds the Sentry event for a crash. Exported so tests can assert exactly
+ * what would go over the wire without one leaving the machine.
+ */
+export function crashEvent(error, command, environment) {
+    const isError = error instanceof Error;
+    const eventId = crypto.randomUUID().replace(/-/g, "");
+    return {
+        event_id: eventId,
+        timestamp: Date.now() / 1000,
+        platform: "node",
+        level: "error",
+        logger: "remotedraw.cli",
+        release: `remotedraw-cli@${environment.version}`,
+        environment: "production",
+        // The command name only; flags and values never leave the machine because
+        // any of them may be a key, a path, or a customer's project name.
+        transaction: command,
+        tags: {
+            command,
+            cli_version: environment.version,
+            node_version: environment.nodeVersion,
+            os: environment.platform,
+        },
+        exception: {
+            values: [
+                {
+                    type: isError ? error.name || "Error" : "UnknownError",
+                    value: scrubTelemetryText(isError ? error.message : String(error), environment.env),
+                    mechanism: { handled: true },
+                },
+            ],
+        },
+        extra: isError && error.stack
+            ? { stack: scrubTelemetryText(error.stack, environment.env) }
+            : undefined,
+    };
+}
+/**
+ * Reports a CLI crash. Never throws, never rejects, and never delays the exit
+ * by more than the timeout: a command's outcome must be identical whether or
+ * not Sentry is reachable.
+ */
+export async function reportCliCrash(error, command, environment) {
+    if (telemetryDisabled(environment.env))
+        return;
+    const target = parseDsn(dsnFor(environment.env));
+    if (!target)
+        return;
+    const event = crashEvent(error, command, environment);
+    const envelope = [
+        JSON.stringify({
+            event_id: event.event_id,
+            sent_at: new Date().toISOString(),
+            dsn: target.dsn,
+        }),
+        JSON.stringify({ type: "event" }),
+        JSON.stringify(event),
+    ].join("\n");
+    const send = environment.fetch ?? fetch;
+    try {
+        await send(`${target.envelopeUrl}?sentry_key=${target.publicKey}&sentry_version=7`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-sentry-envelope" },
+            body: envelope,
+            signal: AbortSignal.timeout(2000),
+        });
+    }
+    catch {
+        // A crash report that fails to send is not itself worth reporting.
+    }
+}
+/** The environment description used by the real CLI process. */
+export function nodeTelemetryEnvironment(version) {
+    return {
+        env: process.env,
+        version,
+        platform: process.platform,
+        nodeVersion: process.versions.node,
+    };
+}

package/dist/update.d.ts

@@ -0,0 +1,53 @@
+import { type CloudRuntime } from "./cloud.js";
+export declare const CLI_PACKAGE_NAME = "@remotedraw/cli";
+export type UpdateRuntime = CloudRuntime & {
+    /**
+     * Runs an installer. Absent in unit tests and in any runtime that must not
+     * spawn processes, which makes `remotedraw update` report the command instead
+     * of running it.
+     */
+    spawnCommand?: (command: string, args: string[]) => Promise<{
+        exitCode: number;
+    }>;
+};
+export type InstallMethod = {
+    /** Package manager the binary appears to have been installed with. */
+    manager: "npm" | "pnpm" | "yarn" | "bun";
+    /** True when the binary was resolved by npx/bunx, which never needs updating. */
+    ephemeral: boolean;
+    command: string;
+    args: string[];
+};
+export type UpdateCheck = {
+    current: string;
+    latest: string;
+    updateAvailable: boolean;
+};
+export declare function parseVersion(value: string): {
+    numbers: number[];
+    prerelease: string;
+};
+export declare function compareVersions(a: string, b: string): 1 | 0 | -1;
+/**
+ * Derives the update command from where the running binary lives. Guessing
+ * wrong only prints the wrong suggestion, so the fallback is plain npm.
+ */
+export declare function detectInstallMethod(binPath: string): InstallMethod;
+export declare function installMethodDisplay(method: InstallMethod): string;
+export declare function updateCachePath(runtime: UpdateRuntime): string;
+export declare function latestPublishedVersion(runtime: UpdateRuntime, timeoutMs?: number): Promise<string | undefined>;
+/** True when the environment asked us not to make an update request at all. */
+export declare function updateChecksDisabled(env: Record<string, string | undefined>): boolean;
+export declare function checkForUpdate(runtime: UpdateRuntime, currentVersion: string, options?: {
+    force?: boolean;
+    now?: number;
+}): Promise<UpdateCheck | undefined>;
+export declare function updateNotice(check: UpdateCheck, method: InstallMethod): string;
+export declare function runInstall(runtime: UpdateRuntime, method: InstallMethod): Promise<{
+    ran: false;
+    exitCode?: never;
+} | {
+    ran: true;
+    exitCode: number;
+}>;
+//# sourceMappingURL=update.d.ts.map

package/dist/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../src/update.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAGjE,eAAO,MAAM,gBAAgB,oBAAoB,CAAC;AAOlD,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IACzC;;;;OAIG;IACH,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,KACX,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,sEAAsE;IACtE,OAAO,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;IACzC,iFAAiF;IACjF,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAiBF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM;;;EAczC;AA2BD,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,cASnD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAoClE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,UAEzD;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,UAErD;AAgDD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,aAAa,EACtB,SAAS,SAAmB,+BAoC7B;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,WAO3E;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9C,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CA2BlC;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,UAWrE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa;;;;;;GAM7E"}

package/dist/update.js

@@ -0,0 +1,240 @@
+import path from "node:path";
+import { globalConfigPath } from "./cloud.js";
+import { t } from "./i18n.js";
+export const CLI_PACKAGE_NAME = "@remotedraw/cli";
+const DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** The passive notice must never delay a command; an explicit check may wait. */
+const CHECK_TIMEOUT_MS = 2_000;
+const FORCED_CHECK_TIMEOUT_MS = 10_000;
+/**
+ * npm registry semantics: a globally installed package is a pinned snapshot,
+ * so the CLI has to ask the registry itself to know it is stale.
+ */
+function registryUrl(env) {
+    const configured = env.REMOTEDRAW_CLI_REGISTRY?.trim() || env.npm_config_registry?.trim();
+    return (configured || DEFAULT_REGISTRY_URL).replace(/\/+$/, "");
+}
+export function parseVersion(value) {
+    const trimmed = value.trim().replace(/^v/, "");
+    const separator = trimmed.indexOf("-");
+    const core = separator === -1 ? trimmed : trimmed.slice(0, separator);
+    const prerelease = separator === -1 ? "" : trimmed.slice(separator + 1);
+    const numbers = core
+        .split(".")
+        .slice(0, 3)
+        .map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    while (numbers.length < 3)
+        numbers.push(0);
+    return { numbers, prerelease };
+}
+function comparePrerelease(a, b) {
+    if (a === b)
+        return 0;
+    // A release always outranks any prerelease of the same core version.
+    if (!a)
+        return 1;
+    if (!b)
+        return -1;
+    const left = a.split(".");
+    const right = b.split(".");
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart == null)
+            return -1;
+        if (rightPart == null)
+            return 1;
+        const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : undefined;
+        const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : undefined;
+        if (leftNumber != null && rightNumber != null) {
+            if (leftNumber !== rightNumber)
+                return leftNumber < rightNumber ? -1 : 1;
+            continue;
+        }
+        if (leftNumber != null)
+            return -1;
+        if (rightNumber != null)
+            return 1;
+        if (leftPart !== rightPart)
+            return leftPart < rightPart ? -1 : 1;
+    }
+    return 0;
+}
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    for (let index = 0; index < 3; index += 1) {
+        const leftNumber = left.numbers[index] ?? 0;
+        const rightNumber = right.numbers[index] ?? 0;
+        if (leftNumber !== rightNumber)
+            return leftNumber < rightNumber ? -1 : 1;
+    }
+    return comparePrerelease(left.prerelease, right.prerelease);
+}
+/**
+ * Derives the update command from where the running binary lives. Guessing
+ * wrong only prints the wrong suggestion, so the fallback is plain npm.
+ */
+export function detectInstallMethod(binPath) {
+    const normalized = binPath.replace(/\\/g, "/");
+    const update = `${CLI_PACKAGE_NAME}@latest`;
+    if (/\/(_npx|\.npm\/_npx|\.bun\/install\/cache)\//.test(normalized)) {
+        return { manager: "npm", ephemeral: true, command: "npx", args: [update] };
+    }
+    if (/\/\.bun\//.test(normalized)) {
+        return {
+            manager: "bun",
+            ephemeral: false,
+            command: "bun",
+            args: ["add", "--global", update],
+        };
+    }
+    if (/\/(\.pnpm|pnpm)\//.test(normalized)) {
+        return {
+            manager: "pnpm",
+            ephemeral: false,
+            command: "pnpm",
+            args: ["add", "--global", update],
+        };
+    }
+    if (/\/(\.yarn|Yarn)\//.test(normalized)) {
+        return {
+            manager: "yarn",
+            ephemeral: false,
+            command: "yarn",
+            args: ["global", "add", update],
+        };
+    }
+    return {
+        manager: "npm",
+        ephemeral: false,
+        command: "npm",
+        args: ["install", "--global", update],
+    };
+}
+export function installMethodDisplay(method) {
+    return [method.command, ...method.args].join(" ");
+}
+export function updateCachePath(runtime) {
+    return path.join(path.dirname(globalConfigPath(runtime)), "update-check.json");
+}
+async function readUpdateCache(runtime) {
+    const cachePath = updateCachePath(runtime);
+    if (!(await runtime.exists(cachePath)))
+        return undefined;
+    try {
+        const parsed = JSON.parse(await runtime.readFile(cachePath));
+        if (typeof parsed !== "object" ||
+            parsed === null ||
+            typeof parsed.latest !== "string" ||
+            typeof parsed.checkedAt !== "number") {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        // A corrupt cache is never fatal; the next check rewrites it.
+        return undefined;
+    }
+}
+async function writeUpdateCache(runtime, cache) {
+    try {
+        const cachePath = updateCachePath(runtime);
+        await runtime.mkdir(path.dirname(cachePath));
+        await runtime.writeFile(cachePath, `${JSON.stringify(cache)}\n`);
+    }
+    catch {
+        // A read-only config dir must not break the command the user actually ran.
+    }
+}
+async function registryJson(runtime, url, accept, timeoutMs) {
+    const response = await runtime.fetch?.(url, {
+        headers: { Accept: accept },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response?.ok)
+        return undefined;
+    return (await response.json());
+}
+export async function latestPublishedVersion(runtime, timeoutMs = CHECK_TIMEOUT_MS) {
+    if (!runtime.fetch)
+        return undefined;
+    const base = `${registryUrl(runtime.env)}/${CLI_PACKAGE_NAME}`;
+    try {
+        // `/latest` is one version manifest rather than the whole packument, so it
+        // stays small as releases accumulate. It rejects npm's abbreviated-packument
+        // Accept header with a 406, hence plain JSON here.
+        const manifest = await registryJson(runtime, `${base}/latest`, "application/json", timeoutMs);
+        if (typeof manifest?.version === "string")
+            return manifest.version;
+        // Registries and mirrors that do not serve `/latest` still serve dist-tags
+        // on the abbreviated packument.
+        const packument = await registryJson(runtime, base, "application/vnd.npm.install-v1+json", timeoutMs);
+        const distTags = packument?.["dist-tags"];
+        if (typeof distTags === "object" &&
+            distTags !== null &&
+            typeof distTags.latest === "string") {
+            return distTags.latest;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** True when the environment asked us not to make an update request at all. */
+export function updateChecksDisabled(env) {
+    return Boolean(env.REMOTEDRAW_CLI_OFFLINE === "1" ||
+        env.REMOTEDRAW_CLI_NO_UPDATE_CHECK === "1" ||
+        env.NO_UPDATE_NOTIFIER ||
+        env.CI);
+}
+export async function checkForUpdate(runtime, currentVersion, options = {}) {
+    if (currentVersion === "unknown")
+        return undefined;
+    if (!options.force && updateChecksDisabled(runtime.env))
+        return undefined;
+    const now = options.now ?? Date.now();
+    if (!options.force) {
+        const cached = await readUpdateCache(runtime);
+        if (cached && now - cached.checkedAt < CHECK_INTERVAL_MS) {
+            return {
+                current: currentVersion,
+                latest: cached.latest,
+                updateAvailable: compareVersions(currentVersion, cached.latest) < 0,
+            };
+        }
+    }
+    const latest = await latestPublishedVersion(runtime, options.force ? FORCED_CHECK_TIMEOUT_MS : CHECK_TIMEOUT_MS);
+    if (!latest)
+        return undefined;
+    await writeUpdateCache(runtime, { checkedAt: now, latest });
+    return {
+        current: currentVersion,
+        latest,
+        updateAvailable: compareVersions(currentVersion, latest) < 0,
+    };
+}
+export function updateNotice(check, method) {
+    return [
+        t("notice.update.available", {
+            package: CLI_PACKAGE_NAME,
+            current: check.current,
+            latest: check.latest,
+        }),
+        method.ephemeral
+            ? t("notice.update.ephemeral", { package: CLI_PACKAGE_NAME })
+            : t("notice.update.install", { command: installMethodDisplay(method) }),
+    ].join("\n");
+}
+export async function runInstall(runtime, method) {
+    if (!runtime.spawnCommand) {
+        return { ran: false };
+    }
+    const result = await runtime.spawnCommand(method.command, method.args);
+    return { ran: true, exitCode: result.exitCode };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotedraw/cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Command-line tools for creating and inspecting RemoteDraw integrations.",
   "type": "module",
   "bin": {
@@ -13,6 +13,12 @@
   "engines": {
     "node": ">=20"
   },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AxioSOzo/RemoteDraw.git",
+    "directory": "packages/cli"
+  },
   "bugs": {
     "email": "support@remotedraw.com"
   },
@@ -27,12 +33,13 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "bun run generate:skill && tsc -p tsconfig.json",
     "dev": "bun run src/index.ts",
     "test": "bun test tests/*.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "verify:publish": "bun run build && bun run typecheck && bun run test && node dist/index.js --help && node dist/index.js --version",
-    "prepack": "bun run verify:publish"
+    "verify:publish": "bun run generate:skill && bun run build && bun run typecheck && bun run test && node dist/index.js --help && node dist/index.js --version",
+    "prepack": "bun run verify:publish",
+    "generate:skill": "bun run scripts/generate-agent-skill.ts"
   },
   "devDependencies": {
     "@types/node": "25.6.2",