@lightward/mechanic-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lightward
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,424 @@
+# Mechanic CLI
+
+Develop Mechanic tasks locally: pull Shopify automation tasks from Mechanic,
+edit Liquid and docs in normal files, preview changes safely, review diffs, and
+publish intentionally.
+
+Mechanic is a Shopify automation platform for teams that need flexible,
+code-backed workflows. Install Mechanic from the Shopify App Store at
+<https://apps.shopify.com/mechanic>, read the docs at
+<https://learn.mechanic.dev/>, or start with the CLI guide at
+<https://learn.mechanic.dev/platform/mechanic-cli>.
+
+This CLI is built around the same task export shape used by Mechanic, so tasks
+move cleanly between the app, local files, version control, and pull requests.
+
+Use it to:
+
+- pull tasks from Mechanic into a local repository
+- edit Liquid, Markdown, and task configuration in normal files
+- preview task changes before saving them to Mechanic
+- diff local files against the current Mechanic task
+- publish one task intentionally, with dry-run and conflict protection
+- automate single-shop task updates with optional GitHub Actions workflows
+
+Mechanic is made by Lightward. You can also meet Lightward AI at
+<https://lightward.com>.
+
+## Requirements
+
+- Node 22 or newer
+- A Mechanic shop with an API token created in the Mechanic app
+
+## Install
+
+Install from npm:
+
+```bash
+npm install -g @lightward/mechanic-cli
+```
+
+## Quick Start
+
+Create an API token in Mechanic:
+
+1. Open the shop in Mechanic.
+2. Go to Settings -> API tokens.
+3. Create a token named for the place it will be used, like `Laptop` or `GitHub Actions`.
+4. Copy the token immediately. Mechanic only shows it once.
+
+Initialize a local project for that Shopify shop, then paste the token when
+prompted:
+
+```bash
+mechanic init --shop example.myshopify.com
+```
+
+Pull existing Mechanic tasks into local JSON files:
+
+```bash
+mechanic tasks pull
+```
+
+For most Liquid or documentation edits, unbundle one task into helper files,
+edit those files, then bundle the helper directory back into its canonical JSON
+file. The JSON file remains the deployable source of truth; the helper directory
+is the comfortable editing view beside it.
+
+```bash
+mechanic tasks unbundle tasks/order-tagger.json
+# edit tasks/order-tagger/script.liquid, docs.md, or task.json
+mechanic tasks bundle tasks/order-tagger.json
+mechanic tasks status
+mechanic tasks preview tasks/order-tagger.json
+mechanic tasks diff tasks/order-tagger.json
+mechanic tasks publish tasks/order-tagger.json --dry-run
+mechanic tasks publish tasks/order-tagger.json
+```
+
+For normal setup, paste the token into the masked prompt or run
+`mechanic auth login` after `mechanic init`. In CI, store the token as
+`MECHANIC_API_TOKEN`. The `--token` flag exists for controlled automation, but
+avoid typing secrets into shared shells because shell history or process listings
+can expose them.
+
+To check whether the shop is currently busy or backlogged:
+
+```bash
+mechanic shop status
+```
+
+Most commands that editor integrations or agents would call support `--json`.
+Use JSON output for automation instead of parsing tables or colored text.
+
+## Commands
+
+```bash
+mechanic init --shop example.myshopify.com [--token <token>] [--api-base-url <url>] [--app-url <url>] [--force]
+mechanic help [command]
+mechanic doctor
+mechanic auth login [--token <token>]
+mechanic auth logout
+mechanic github init [--force]
+mechanic shop status [--json]
+mechanic tasks list [--verbose] [--json]
+mechanic tasks open <task>
+mechanic tasks status [task] [--remote] [--json]
+mechanic tasks pull [--force]
+mechanic tasks pull <task> [--force]
+mechanic tasks pull --all [--force]
+mechanic tasks preview <task> [--remote] [--verbose] [--json]
+mechanic tasks diff <task> [--exit-code] [--json]
+mechanic tasks diff --all [--exit-code] [--json]
+mechanic tasks publish <task> [--force] [--dry-run] [--json]
+mechanic tasks publish --all [--force] [--dry-run] [--json]
+mechanic tasks unbundle <task> [--out <dir>] [--json]
+mechanic tasks bundle <dir|file> [--out <file>] [--json]
+mechanic tasks validate <file|dir> [--json]
+```
+
+Most task commands accept a `<task>` selector. A task selector can be a local
+JSON file, a helper directory, a linked remote task ID, or a unique local task
+slug:
+
+```bash
+mechanic tasks preview tasks/order-tagger.json
+mechanic tasks preview tasks/order-tagger
+mechanic tasks preview order-tagger
+mechanic tasks preview 171578bf-79e2-46af-857a-dbd71c6b7b2b
+```
+
+The local file is the working copy. The remote task ID is the Mechanic app's
+address for that task. `tasks list` shows linked local files when the CLI knows
+them. If a short selector matches more than one local file, the CLI asks for the
+full file path.
+
+`tasks pull` pulls every task when you run it without arguments. Pass a task
+selector when you only want one task. `tasks diff` and `tasks publish` operate
+on one task when you pass a selector. They operate on every task only when you
+explicitly pass `--all`.
+
+`shop status` shows the current Mechanic run queue for the configured shop:
+running runs, waiting runs, queue lag, and the largest backlog groups by task,
+action, and event topic.
+
+`tasks status` shows whether local task JSON files are linked to remote Mechanic
+tasks and ready to publish. It is local-only by default; add `--remote` to check
+whether linked remote tasks are unchanged, locally changed, or conflicted.
+Add `--json` when an editor integration needs task readiness, link state, and
+remote sync state without parsing table output.
+
+`tasks diff` compares the current remote task to your local file, groups output
+by changed field, and only shows nearby changed lines. Differences are
+informational by default; add `--exit-code` when a script or CI job should treat
+differences as a nonzero result.
+
+`tasks preview` is the confidence check before publishing. It sends one local
+task to Mechanic's preview engine without saving it, then reports whether the
+sample events passed, which actions would run, validation errors, and Shopify
+permissions detected by the previewed paths. Add `--remote` to preview the
+current task already in Mechanic instead of your local draft. Add `--verbose`
+to show event, task run, and action run result details in the terminal. Add
+`--json` when an agent, script, or CI job needs the raw preview response.
+Missing Shopify permissions are approved in the Mechanic app after publishing
+or enabling the task.
+
+`tasks publish` sends local task JSON back to Mechanic.
+
+`tasks publish --dry-run` validates the selected files, checks for unbundled
+helper changes, fetches linked remote tasks, checks unlinked files against
+existing remote task names, and prints what would create, update, stay
+unchanged, or conflict. It does not write to Mechanic, `.mechanic/links.json`,
+or local task JSON. New tasks created by `tasks publish` are created disabled;
+review and enable them in Mechanic when they are ready to run.
+
+For automation or editor integrations, add `--json` to `tasks list`, `tasks
+status`, `tasks diff`, `tasks validate`, `tasks bundle`, `tasks unbundle`,
+`tasks publish`, or `shop status`.
+
+`tasks unbundle` and `tasks bundle` operate on one task at a time. By default,
+`mechanic tasks unbundle tasks/order-tagger.json` writes to
+`tasks/order-tagger/`, and `mechanic tasks bundle tasks/order-tagger.json`
+writes back to `tasks/order-tagger.json`.
+
+When a task has `subscriptions_template`, the editable helper file is
+`subscriptions.liquid`. Mechanic renders that template into `subscriptions`, so
+the CLI treats `subscriptions` as generated state instead of something to edit
+or publish by hand.
+
+`mechanic init` accepts `--token`, reads `MECHANIC_API_TOKEN`, or prompts for an
+API token in an interactive terminal. It verifies the token and stores it
+outside the project. `mechanic auth login` does the same thing later if you skip
+token setup during init. For automation, set `MECHANIC_API_TOKEN`; it takes
+precedence over any locally stored token for authenticated commands.
+
+`mechanic doctor` checks the local project config, token source, verified shop,
+and task API access. Run it after `mechanic auth login` or when a project stops
+syncing cleanly.
+
+`mechanic init` defaults to `https://api.mechanic.dev` for the API and refuses
+to overwrite an existing project unless you pass `--force`. The CLI only sends
+API tokens to trusted Mechanic API hosts by default. Use `--api-base-url` or
+`MECHANIC_API_BASE_URL` only for a staging or dedicated Mechanic API host you
+control; set `MECHANIC_TRUST_API_BASE_URL=1` only when you intentionally trust
+that host. Task IDs in command output link back to the Mechanic embedded app in
+terminals that support hyperlinks; use `mechanic tasks open` when you want to
+open a task explicitly. Use `--app-url` or `MECHANIC_APP_URL` if your shop uses
+a non-production Shopify app alias.
+
+Use `mechanic tasks open <task>` to open a task in the Mechanic app from its
+remote ID, linked local task JSON file, helper directory, or unique local task
+slug.
+
+## Advanced: GitHub Actions Task Workflows
+
+Local CLI usage works without GitHub Actions. If you want optional single-shop
+Git sync automation, start from a populated Mechanic CLI project, then generate
+the recommended workflows:
+
+```bash
+mechanic tasks pull
+mechanic github init
+```
+
+This creates:
+
+```text
+.github/workflows/mechanic-validate.yml
+.github/workflows/mechanic-deploy.yml
+.github/workflows/mechanic-sync-from-app.yml
+```
+
+Re-run with `--force` only when you intentionally want to replace those
+workflow files.
+
+Add one repository or organization secret named `MECHANIC_API_TOKEN` containing
+a Mechanic API token for the shop in `mechanic.json`.
+
+From the task repository, the safest repository-secret setup is:
+
+```bash
+gh secret set MECHANIC_API_TOKEN
+```
+
+Paste the token when prompted. If you are not running the command from the task
+repository checkout, add `--repo OWNER/REPO`.
+
+The generated workflows install the same `@lightward/mechanic-cli` version that
+generated them and use the `api_base_url` committed in `mechanic.json`.
+
+Only enable the deploy and sync workflows in repos whose maintainers you trust.
+Those workflows use the Mechanic API token, and the sync workflow also needs
+repository write permissions so it can open or update sync-back pull requests.
+
+The generated workflows do three jobs:
+
+- `mechanic-validate.yml` runs on pull requests and manually, with no Mechanic
+  token, validates `tasks/`, and fails if helper task directories need bundling.
+- `mechanic-deploy.yml` runs manually. It requires either `task_path` or
+  `deploy_all=true`, always runs `mechanic tasks publish ... --dry-run`, and only
+  writes to Mechanic when you choose `mode=deploy`. The default is `dry-run`;
+  inspect that plan first, then rerun with `mode=deploy` when you mean to publish.
+  After a deploy, the workflow opens or updates a sync-state PR so
+  `.mechanic/links.json` and task hashes stay current.
+- `mechanic-sync-from-app.yml` runs manually, pulls app updates with
+  `mechanic tasks pull --all --force`, validates the result, and opens or
+  updates a PR from `mechanic-sync/from-app` when files changed. The PR body
+  includes a changed-file summary and the V1 deletion caveat. Add a schedule to
+  this workflow later only if you want automatic app-to-Git sync PRs.
+
+The pull-from-app workflow is intentionally update-only in V1: it does not prune
+local files or links for tasks that were deleted in Mechanic.
+
+## Project Layout
+
+```text
+mechanic.json
+.mechanic/
+  links.json
+tasks/
+  order-tagger.json
+```
+
+`mechanic.json` stores the Shopify shop domain, API base URL, embedded app URL
+for task links, and tasks directory. Because this file is repo-controlled, the
+CLI validates configured API and app URLs before using them with a token.
+
+`.mechanic/links.json` maps local task slugs to remote Mechanic task IDs and
+the last known remote content hash. Commit this file when the repo represents a
+shared source of truth for that shop.
+
+API tokens are stored outside the project under the local user config directory,
+not in `mechanic.json`. Token files are written with owner-only permissions.
+
+## Task Files
+
+Canonical task files are JSON files at `tasks/<slug>.json`. They use Mechanic's
+task export fields, including:
+
+- `name`
+- `script`
+- `docs`
+- `subscriptions_template`
+- `subscriptions`
+- `options`
+- `preview_event_definitions`
+- `tags`
+- `shopify_api_version`
+- `online_store_javascript`
+- `order_status_javascript`
+
+Remote IDs are never written into task JSON. `mechanic tasks publish` also
+removes `enabled` from the API payload so local sync cannot accidentally enable
+or disable a production task.
+
+Direct-subscription tasks may use `null` for `script`, `docs`, and
+`subscriptions_template`.
+
+## Bundle And Unbundle
+
+JSON is the canonical file format, but editing long Liquid and Markdown strings
+inside JSON is unpleasant. The helper workflow splits a task into separate
+editable files:
+
+```bash
+mechanic tasks unbundle tasks/order-tagger.json --out order-tagger
+```
+
+`tasks unbundle` also accepts the same local task selectors as preview, diff,
+and publish:
+
+```bash
+mechanic tasks unbundle order-tagger
+mechanic tasks unbundle tasks/order-tagger
+mechanic tasks unbundle 171578bf-79e2-46af-857a-dbd71c6b7b2b
+```
+
+```text
+order-tagger/
+  task.json
+  script.liquid
+  docs.md
+  subscriptions.liquid
+  online_store_javascript.js.liquid
+  order_status_javascript.js.liquid
+```
+
+After editing, bundle the helper directory back to canonical JSON:
+
+```bash
+mechanic tasks bundle tasks/order-tagger.json
+mechanic tasks validate tasks/order-tagger.json
+```
+
+`tasks bundle` accepts either side of the pair. `mechanic tasks bundle
+tasks/order-tagger` writes `tasks/order-tagger.json`, and `mechanic tasks bundle
+tasks/order-tagger.json` reads `tasks/order-tagger/` and writes back to that JSON
+file.
+
+When unbundling, helper files are written only for string fields. `null` fields
+stay in `task.json`, and stale helper files for non-string fields are removed.
+
+When publishing a JSON file, the CLI checks for a matching helper directory. If
+`tasks/order-tagger/` has changes that are not bundled into
+`tasks/order-tagger.json`, publishing stops before making any API request.
+
+`mechanic init` adds Mechanic Liquid helper files to `.prettierignore`.
+Formatter rewrites can change task behavior, especially for newline-delimited
+`subscriptions.liquid` and exact Liquid string quotes in `script.liquid`.
+
+## Sync Safety
+
+The CLI uses remote content hashes to avoid overwriting task edits made in the
+Mechanic app or by another local checkout.
+
+- `tasks pull` records the latest remote content hash in `.mechanic/links.json`.
+- `tasks pull <task>` can refresh a linked local file without `--force` when the
+  local file still matches the last pulled hash. If local edits would be lost,
+  it stops and asks for an explicit `--force`.
+- `tasks publish` sends that hash as `previous_content_hash`.
+- The API rejects stale publishes with a conflict.
+- `tasks diff` warns when the remote task changed since your last pull, then
+  compares the current Mechanic task with your local file.
+- `tasks publish --all` checks every linked remote task before writing anything,
+  so one stale task blocks the whole publish instead of partially publishing
+  earlier files first.
+- `tasks publish --force` bypasses the hash guard when you intentionally want
+  the local file to win.
+
+Creating a new remote task sends a deterministic idempotency key for the local
+shop and task slug, so retrying after a timeout returns the same remote task
+instead of creating duplicates.
+
+Before creating a task from an unlinked local file, the CLI checks existing
+remote task names for the same normalized slug. If a likely match already exists
+in Mechanic, publishing stops and asks you to pull/link the remote task first.
+
+`tasks publish --all` rejects local files whose names normalize to the same task
+slug, for example `foo-bar.json` and `foo_bar.json`.
+
+## Task Sync API
+
+This package targets Mechanic's v1 task sync API. The CLI is the recommended
+client; direct HTTP use is intended for trusted, CLI-compatible automation.
+
+- `GET /v1/auth/verify`
+- `GET /v1/shop/status`
+- `GET /v1/tasks`
+- `GET /v1/tasks/:id`
+- `POST /v1/tasks/preview`
+- `POST /v1/tasks/:id/preview`
+- `POST /v1/tasks`
+- `PUT /v1/tasks/:id`
+
+Preview endpoints run local or remote task content through Mechanic's preview
+engine without creating, updating, or saving a task.
+
+Requests use Bearer token auth with API tokens created in the Mechanic app.
+The CLI does not make separate telemetry calls. Authenticated API requests
+include a `MechanicCLI/<version>` user agent so Mechanic can observe CLI usage
+from server-side operational logs.
+
+This API surface is intentionally narrow: task sync, task preview, and shop
+status for the authenticated shop. It is not a general Mechanic API for
+arbitrary integrations.

package/bin/mechanic.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { execute } from "@oclif/core";
+
+await execute({ dir: import.meta.url });

package/dist/auth.d.ts

@@ -0,0 +1,10 @@
+export declare function saveToken(shopDomain: string, token: string): Promise<void>;
+export declare function loadToken(shopDomain: string): Promise<string | null>;
+export declare function requireToken(shopDomain: string): Promise<string>;
+export declare function deleteToken(shopDomain: string): Promise<void>;
+export declare function canPromptForToken(): boolean;
+export declare function promptForToken({ allowBlank, prompt, }?: {
+    allowBlank?: boolean;
+    prompt?: string;
+}): Promise<string | null>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAwBA,wBAAsB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhF;AAED,wBAAsB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAG1E;AAED,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBtE;AAED,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAInE;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED,wBAAsB,cAAc,CAAC,EACnC,UAAkB,EAClB,MAA+B,GAChC,GAAE;IACD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmE9B"}

package/dist/auth.js

@@ -0,0 +1,104 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { CliError } from "./errors.js";
+import { appConfigPath, ensureDir, readJson } from "./fs.js";
+import { stableStringify } from "./json.js";
+async function readStore() {
+    return readJson(appConfigPath("auth.json"), { shops: {} });
+}
+async function writeStore(store) {
+    const authPath = path.normalize(appConfigPath("auth.json"));
+    await ensureDir(path.dirname(authPath));
+    await fs.writeFile(authPath, `${stableStringify(store)}\n`, { encoding: "utf8", mode: 0o600 });
+    await fs.chmod(authPath, 0o600);
+}
+export async function saveToken(shopDomain, token) {
+    const store = await readStore();
+    store.shops[shopDomain] = { token };
+    await writeStore(store);
+}
+export async function loadToken(shopDomain) {
+    const store = await readStore();
+    return store.shops[shopDomain]?.token || null;
+}
+export async function requireToken(shopDomain) {
+    const envToken = process.env.MECHANIC_API_TOKEN?.trim();
+    if (envToken) {
+        return envToken;
+    }
+    const token = await loadToken(shopDomain);
+    if (!token) {
+        throw new CliError(`No API token available for ${shopDomain}. Set MECHANIC_API_TOKEN or run "mechanic auth login" first.`);
+    }
+    return token;
+}
+export async function deleteToken(shopDomain) {
+    const store = await readStore();
+    delete store.shops[shopDomain];
+    await writeStore(store);
+}
+export function canPromptForToken() {
+    return Boolean(stdin.isTTY);
+}
+export async function promptForToken({ allowBlank = false, prompt = "Mechanic API token: ", } = {}) {
+    if (!stdin.isTTY) {
+        throw new CliError("Provide a token with --token <token> or MECHANIC_API_TOKEN.");
+    }
+    let maskingToken = false;
+    let maskedLength = 0;
+    const maskedStdout = new Writable({
+        write(chunk, _encoding, callback) {
+            if (!maskingToken) {
+                stdout.write(chunk);
+                callback();
+                return;
+            }
+            const text = chunk.toString();
+            if (text === "\b \b" && maskedLength > 0) {
+                maskedLength -= 1;
+                stdout.write("\b \b");
+                callback();
+                return;
+            }
+            let maskedText = "";
+            for (const character of text) {
+                if (character === "\r" || character === "\n") {
+                    continue;
+                }
+                if (character === "\b" || character === "\u007f") {
+                    if (maskedLength > 0) {
+                        maskedLength -= 1;
+                        maskedText += "\b \b";
+                    }
+                    continue;
+                }
+                maskedLength += 1;
+                maskedText += "•";
+            }
+            stdout.write(maskedText);
+            callback();
+        },
+    });
+    const readline = createInterface({
+        input: stdin,
+        output: maskedStdout,
+        terminal: true,
+    });
+    try {
+        const tokenPromise = readline.question(prompt);
+        maskingToken = true;
+        const token = (await tokenPromise).trim();
+        maskingToken = false;
+        stdout.write("\n");
+        if (!token && !allowBlank) {
+            throw new CliError("API token cannot be blank.");
+        }
+        return token || null;
+    }
+    finally {
+        readline.close();
+    }
+}

package/dist/base-command.d.ts

@@ -0,0 +1,20 @@
+import { Command } from "@oclif/core";
+import { MechanicClient } from "./client.js";
+import type { Project } from "./types.js";
+export declare abstract class BaseCommand extends Command {
+    loadProject(): Promise<Project>;
+    clientForProject(project: Project): Promise<MechanicClient>;
+    verifiedClientForProject(project: Project): Promise<MechanicClient>;
+    verifyClientShop(project: Project, client: MechanicClient): Promise<void>;
+    accent(text: string): string;
+    actionLabel(action: string): string;
+    color(color: string, text: string): string;
+    muted(text: string): string;
+    outputJson(value: unknown): void;
+    success(text: string): string;
+    lightwardAiLine(): string;
+    taskName(text: string): string;
+    taskId(project: Project, taskId: string): string;
+    table(rows: string[][]): void;
+}
+//# sourceMappingURL=base-command.d.ts.map

package/dist/base-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-command.d.ts","sourceRoot":"","sources":["../src/base-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAM,MAAM,aAAa,CAAC;AAI1C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,8BAAsB,WAAY,SAAQ,OAAO;IACzC,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAI/B,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IAO3D,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IAMnE,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAY/E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI5B,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAenC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAI1C,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI3B,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAIhC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI7B,eAAe,IAAI,MAAM;IAQzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI9B,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAIhD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI;CAgB9B"}

package/dist/base-command.js

@@ -0,0 +1,82 @@
+import { Command, ux } from "@oclif/core";
+import { stripVTControlCharacters } from "node:util";
+import terminalLink from "terminal-link";
+import { requireToken } from "./auth.js";
+import { MechanicClient } from "./client.js";
+import { loadProject, taskAdminUrl } from "./config.js";
+import { CliError } from "./errors.js";
+export class BaseCommand extends Command {
+    async loadProject() {
+        return loadProject(process.cwd());
+    }
+    async clientForProject(project) {
+        return new MechanicClient({
+            baseUrl: project.apiBaseUrl,
+            token: await requireToken(project.shopDomain),
+        });
+    }
+    async verifiedClientForProject(project) {
+        const client = await this.clientForProject(project);
+        await this.verifyClientShop(project, client);
+        return client;
+    }
+    async verifyClientShop(project, client) {
+        const verification = await client.verifyAuth();
+        const verifiedShopDomain = verification.shop?.shopify_domain;
+        if (verifiedShopDomain !== project.shopDomain) {
+            throw new CliError(`API token belongs to ${verifiedShopDomain || "an unknown shop"}, but mechanic.json is configured for ${project.shopDomain}.`, 2);
+        }
+    }
+    accent(text) {
+        return this.color("#ff4fd8", text);
+    }
+    actionLabel(action) {
+        switch (action) {
+            case "created":
+                return this.success(action);
+            case "updated":
+                return this.color("cyan", action);
+            case "forced":
+                return this.color("yellow", action);
+            case "skipped":
+                return this.muted(action);
+            default:
+                return action;
+        }
+    }
+    color(color, text) {
+        return ux.colorize(color, text);
+    }
+    muted(text) {
+        return this.color("dim", text);
+    }
+    outputJson(value) {
+        this.log(JSON.stringify(value, null, 2));
+    }
+    success(text) {
+        return this.color("green", text);
+    }
+    lightwardAiLine() {
+        const lightwardAi = terminalLink(this.color("cyan", "Lightward AI"), "https://lightward.com", {
+            fallback: (text, url) => `${text}: ${this.color("cyan", url)}`,
+        });
+        return `${this.muted("Mechanic is made by Lightward. Meet")} ${lightwardAi}`;
+    }
+    taskName(text) {
+        return this.color("cyan", text);
+    }
+    taskId(project, taskId) {
+        return terminalLink(this.muted(taskId), taskAdminUrl(project, taskId), { fallback: false });
+    }
+    table(rows) {
+        const displayRows = rows.map((row, rowIndex) => (rowIndex === 0 ? row.map((cell) => this.muted(cell)) : row));
+        const visibleLength = (cell) => stripVTControlCharacters(cell).length;
+        const widths = displayRows[0].map((_, index) => (Math.max(...displayRows.map((row) => visibleLength(row[index] || "")))));
+        for (const row of displayRows) {
+            this.log(row.map((cell, index) => {
+                const padding = Math.max(0, widths[index] - visibleLength(cell));
+                return `${cell}${" ".repeat(padding)}`;
+            }).join("  ").trimEnd());
+        }
+    }
+}