@pipefy/pipefy-process-coder 0.1.1 → 0.1.3

package/dist/pipefy/toolkit.js

@@ -95,41 +95,56 @@ export const inspectToolkit = async () => {
     cachedInterpreter ??= await findInterpreter();
     if (!cachedInterpreter)
         return { installed: false };
-    const credential = await readBearer();
-    if (!credential)
+    const run = await runHelper();
+    if (!run)
         return { installed: false };
+    if ('error' in run) {
+        return { installed: true, usable: false, cliPath: toolkitBinary('pipefy'), interpreter: cachedInterpreter.command, error: run.error };
+    }
     return {
         installed: true,
+        usable: true,
         cliPath: toolkitBinary('pipefy'),
         mcpServerPath: toolkitBinary('pipefy-mcp-server'),
         interpreter: cachedInterpreter.command,
-        credential,
+        credential: run.result,
     };
 };
 /**
- * Ask the toolkit for a bearer. `null` means the toolkit could not be used at
- * all — distinct from a `{ ok: false }` result, which is the toolkit answering
- * that it holds no credential.
+ * Run the helper. `null` means there is nothing to run it with; `{ error }`
+ * means it ran and could not use the toolkit, carrying its own explanation
+ * (the helper prints which `pipefy_auth` version it found and what it lacks).
  */
-export const readBearer = async () => {
+const runHelper = async () => {
     cachedInterpreter ??= await findInterpreter();
     if (!cachedInterpreter)
         return null;
     if (!existsSync(HELPER)) {
         debug(`toolkit helper missing at ${HELPER}`);
-        return null;
+        return { error: `this install of pipe is missing its toolkit helper (${HELPER})` };
     }
     try {
         const { stdout } = await exec(cachedInterpreter.command, [...cachedInterpreter.args, HELPER], { timeout: 60_000, maxBuffer: 1024 * 1024 });
         const parsed = JSON.parse(stdout.trim());
         debug(`toolkit credential: ${parsed.ok ? parsed.source : parsed.reason}`);
-        return parsed;
+        return { result: parsed };
     }
     catch (e) {
-        debug(`toolkit bearer helper failed: ${e.message}`);
-        return null;
+        const err = e;
+        debug(`toolkit bearer helper failed: ${err.message}`);
+        const said = err.stderr?.trim().split(/\r?\n/).filter(Boolean).pop();
+        return { error: said || err.message.split(/\r?\n/)[0] || 'the toolkit helper failed' };
     }
 };
+/**
+ * Ask the toolkit for a bearer. `null` means the toolkit could not be used at
+ * all — distinct from a `{ ok: false }` result, which is the toolkit answering
+ * that it holds no credential.
+ */
+export const readBearer = async () => {
+    const run = await runHelper();
+    return run && 'result' in run ? run.result : null;
+};
 /** Run `pipefy auth login`, inheriting the terminal so the browser flow works. */
 export const runToolkitLogin = async (extraArgs = []) => {
     const cli = toolkitBinary('pipefy');
@@ -155,4 +170,5 @@ export const toolkitAuthStatus = async () => {
         return null;
     }
 };
+export const UPGRADE_HINT = 'reinstall the toolkit: `uv tool install --force --reinstall pipefy-cli` (any pipefy-auth from 0.3.0a1 to 0.5.4b1 on PyPI works)';
 export const INSTALL_HINT = 'install the Pipefy AI toolkit (github.com/pipefy/ai-toolkit): `uv tool install pipefy-cli`, then `pipefy auth login`';

package/dist/pipefy/toolkit_bearer.py

@@ -31,22 +31,63 @@ def _fail(reason: str, message: str) -> int:
 
 
 def main() -> int:
+    # Import the module, then look the names up one by one, so an incompatible
+    # install says which names it lacks and which version it is — rather than
+    # one ImportError that left `pipe doctor` reporting the toolkit as "not
+    # installed" on a machine where it plainly was. Every pipefy-auth release on
+    # PyPI (0.3.0a1 through 0.5.4b1) exports all of these; a field report of
+    # one that lacked ServiceAccountAuth came from an install none of them
+    # explain, so this names what it found instead of guessing why.
     try:
-        from pipefy_auth import (  # noqa: PLC0415
-            AuthSettings,
-            OidcClient,
-            ServiceAccountAuth,
-            StaticTokenAuth,
-            StoredSessionAuth,
-            configure_keychain_backend,
-            ensure_fresh_session,
-            resolve_pipefy_auth,
-        )
-        from pipefy_auth.resolver import ServiceAccount  # noqa: PLC0415
+        import pipefy_auth  # noqa: PLC0415
     except Exception as exc:  # pragma: no cover - environment problem
         print(f"pipefy_auth is not importable: {exc}", file=sys.stderr)
         return 3
 
+    version = getattr(pipefy_auth, "__version__", None)
+    if version is None:
+        try:
+            from importlib.metadata import version as dist_version  # noqa: PLC0415
+
+            version = dist_version("pipefy-auth")
+        except Exception:
+            version = "unknown"
+    where = getattr(pipefy_auth, "__file__", "?")
+
+    # Required for every credential this helper can return.
+    required = (
+        "AuthSettings",
+        "OidcClient",
+        "StaticTokenAuth",
+        "StoredSessionAuth",
+        "ensure_fresh_session",
+        "resolve_pipefy_auth",
+    )
+    missing = [n for n in required if not hasattr(pipefy_auth, n)]
+    if missing:
+        print(
+            f"pipefy_auth {version} at {where} is incompatible: it lacks {', '.join(missing)}",
+            file=sys.stderr,
+        )
+        return 3
+
+    AuthSettings = pipefy_auth.AuthSettings
+    OidcClient = pipefy_auth.OidcClient
+    StaticTokenAuth = pipefy_auth.StaticTokenAuth
+    StoredSessionAuth = pipefy_auth.StoredSessionAuth
+    ensure_fresh_session = pipefy_auth.ensure_fresh_session
+    resolve_pipefy_auth = pipefy_auth.resolve_pipefy_auth
+    # Only a service-account credential needs these, so their absence costs
+    # that one method, not the static token or the browser session.
+    ServiceAccountAuth = getattr(pipefy_auth, "ServiceAccountAuth", None)
+    ServiceAccount = getattr(pipefy_auth, "ServiceAccount", None)
+    if ServiceAccount is None:
+        try:
+            from pipefy_auth.resolver import ServiceAccount  # noqa: PLC0415
+        except Exception:
+            ServiceAccount = None
+    configure_keychain_backend = getattr(pipefy_auth, "configure_keychain_backend", None)
+
     settings = AuthSettings()
 
     # Select the keyring backend before any session read. On Windows the default
@@ -54,10 +95,15 @@ def main() -> int:
     # ~2.5 KB), so machines set `keychain_backend = "file"` — and a reader that
     # skips this looks in the empty store and reports "not signed in" while
     # `pipefy auth status` says otherwise.
-    configure_keychain_backend(settings.keychain_backend)
+    if configure_keychain_backend is not None:
+        configure_keychain_backend(settings.keychain_backend)
 
     service_account = None
-    if settings.service_account_client_id and settings.service_account_client_secret:
+    if (
+        ServiceAccount is not None
+        and settings.service_account_client_id
+        and settings.service_account_client_secret
+    ):
         service_account = ServiceAccount(
             token_url=settings.service_account_url,
             client_id=settings.service_account_client_id,
@@ -107,7 +153,7 @@ def main() -> int:
         )
         return 0
 
-    if isinstance(resolved, ServiceAccountAuth):
+    if ServiceAccountAuth is not None and isinstance(resolved, ServiceAccountAuth):
         # The client-credentials exchange happens here so the secret never
         # crosses the process boundary — only the short-lived bearer does.
         import httpx  # noqa: PLC0415

package/dist/report/run.js

@@ -3,6 +3,7 @@ import { promises as fs } from 'node:fs';
 import { mkdirp, writeFile, writeJson, exists } from "../util/fsx.js";
 import { paths } from "../workspace/layout.js";
 import { integrationsFrom, renderIntegrations } from "./integrations.js";
+import { TOOL } from "../version.js";
 const stamp = (d = new Date()) => d.toISOString().replace(/[:.]/g, '-').replace(/-\d{3}Z$/, 'Z');
 /**
  * The command as typed, for reproduction — with any token elided. `--token` is
@@ -105,7 +106,7 @@ export class RunRecorder {
             id: this.id,
             kind: this.kind,
             command: this.ctx.command,
-            tool: { name: 'pipefy-process-coder', version: '0.1.0' },
+            tool: { ...TOOL },
             startedAt: this.startedAt.toISOString(),
             finishedAt: finished.toISOString(),
             durationMs: finished.getTime() - this.startedAt.getTime(),

package/dist/util/log.js

@@ -51,13 +51,23 @@ export const step = (s) => {
     process.stderr.write(blue('> ') + s + '\n');
 };
 const CLEAR_LINE = `\r${ESC}2K`;
-/** Single-line progress that collapses to nothing on a non-tty. */
+/**
+ * Single-line progress that collapses to nothing on a non-tty.
+ *
+ * Dropped while a display holds the screen, like `step`: it wrote beneath the
+ * live frame without the frame knowing, and a long automation name wrapped to
+ * a second row, so the next repaint landed a row short. Clipped to the
+ * terminal otherwise, because a `\r` rewrite only reaches back one row too.
+ */
 export const progress = (s) => {
-    if (!process.stderr.isTTY)
+    if (!process.stderr.isTTY || sink)
         return;
-    process.stderr.write(CLEAR_LINE + dim('  ' + s));
+    const line = '  ' + s;
+    const width = process.stderr.columns;
+    const cut = width && [...line].length > width - 1 ? [...line].slice(0, width - 2).join('') + '…' : line;
+    process.stderr.write(CLEAR_LINE + dim(cut));
 };
-export const progressDone = () => { if (process.stderr.isTTY)
+export const progressDone = () => { if (process.stderr.isTTY && !sink)
     process.stderr.write(CLEAR_LINE); };
 export class UserError extends Error {
     hint;

package/dist/util/tui.js

@@ -17,6 +17,42 @@ const HIDE_CURSOR = `${ESC}?25l`;
 const SHOW_CURSOR = `${ESC}?25h`;
 const CLEAR_LINE = `${ESC}2K`;
 const cursorUp = (n) => (n > 0 ? `${ESC}${n}A` : '');
+/**
+ * Cut a line to `max` visible columns, keeping its colour codes intact.
+ *
+ * The repaint moves up as many rows as it drew last time, counting one row per
+ * line. A line wider than the terminal wraps onto two, the cursor then lands
+ * one row short, and every frame leaves its top line behind — on a narrow
+ * PowerShell window a pull scrolled hundreds of copies of its header and cut
+ * the repo line off mid-word. Clipping is what keeps the count true. Every
+ * code point is taken as one column, which holds for everything this tool
+ * prints (the spinner, the dashes, Portuguese pipe names).
+ */
+const ANSI = /\x1b\[[0-9;?]*[A-Za-z]/y;
+export const clipToWidth = (line, max) => {
+    if (max <= 0)
+        return '';
+    if ([...line.replace(new RegExp(ANSI.source, 'g'), '')].length <= max)
+        return line;
+    let out = '';
+    let visible = 0;
+    for (let i = 0; i < line.length;) {
+        ANSI.lastIndex = i;
+        const m = ANSI.exec(line);
+        if (m) {
+            out += m[0];
+            i += m[0].length;
+            continue;
+        }
+        if (visible === max - 1)
+            break;
+        const ch = String.fromCodePoint(line.codePointAt(i));
+        out += ch;
+        visible++;
+        i += ch.length;
+    }
+    return `${out}…${ESC}0m`;
+};
 /** Braille spinner: 8 frames, reads as motion even at 80ms. */
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧'];
 const MARK = {
@@ -256,8 +292,13 @@ export class Progress {
             ...(hiddenBelow > 0 ? [dim(`   … ${hiddenBelow} more`)] : []),
             ...this.notes.map((n) => `   ${n}`),
         ];
-        // Repaint in place: up N lines, then clear-and-write each one.
-        const out = cursorUp(this.linesDrawn) + body.map((l) => CLEAR_LINE + l).join('\n') + '\n';
+        // Repaint in place: up N lines, then clear-and-write each one. Each line is
+        // clipped to the terminal so it occupies exactly one row (see clipToWidth);
+        // the final frame is not, since nothing repaints over it and a warning
+        // should be readable in full.
+        const width = this.stream.columns;
+        const fit = (l) => (final || !width ? l : clipToWidth(l, width - 1));
+        const out = cursorUp(this.linesDrawn) + body.map((l) => CLEAR_LINE + fit(l)).join('\n') + '\n';
         this.stream.write(out);
         this.linesDrawn = final ? 0 : body.length;
     }

package/dist/version.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * The tool's identity as recorded in workspace.json and every run.json.
+ *
+ * The version is read from package.json, the same file `pipe --version` reads,
+ * because it used to be a literal `'0.1.0'` in three places that a release did
+ * not touch — so 0.1.1 stamped 0.1.0 on everything it wrote, and the one field
+ * meant to say which build produced a workspace said the wrong one.
+ *
+ * `dist/` mirrors `src/` one-for-one, so `../package.json` from here is the
+ * package root from either tree.
+ */
+const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'));
+export const PACKAGE_NAME = pkg.name;
+export const TOOL_VERSION = pkg.version;
+export const TOOL = { name: 'pipefy-process-coder', version: TOOL_VERSION };

package/dist/workspace/docs.js

@@ -280,7 +280,7 @@ const CAPABILITIES_MD = (caps) => {
 | \`importRepoSnapshot\` | ${caps.importRepoSnapshot ? 'yes' : 'no'} | Route B is unavailable; writes go through the mutation compiler |
 | internal API | ${caps.internalApi} | automation detail and phase-jump editing depend on it |
 
-${caps.internalApi === 'unavailable' ? '> The internal endpoint did not answer. Automations and phase jumps are reported as **unknown** rather than empty, and any change to them is refused rather than silently skipped.\n' : ''}`
+${caps.internalApi === 'unavailable' ? '> The internal endpoint did not answer. Automations and phase jumps are reported as **unknown** rather than empty, and any change to them is refused rather than silently skipped.\n' : ''}${caps.internalApi === 'incompatible' ? '> The internal endpoint refused one of this tool\'s own queries as invalid — a bug in `pipe`, not an outage. Automations are reported as **unknown** or **partial** rather than empty, and any change to them is refused. `pipe doctor` names the query.\n' : ''}`
         : '';
     return `# Capabilities
 

package/dist/workspace/read.js

@@ -146,6 +146,7 @@ export const readTree = async (dir) => {
             readAt: meta.readAt ?? new Date().toISOString(),
             repoKind: meta.repoKind ?? 'pipe',
             coverage: meta.coverage ?? fullCoverage('unknown'),
+            ...(meta.columns ? { columns: meta.columns } : {}),
             repo_columns: meta.repo_columns ?? 'complete',
             notes: meta.notes ?? [],
         },

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@pipefy/pipefy-process-coder",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Pull a Pipefy pipe to disk as readable JSON, edit it with an agent, diff it, push it back.",
   "type": "module",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Guilherme-CA-Dias/pipefy-process-coder.git"
@@ -15,7 +15,8 @@
     "bin",
     "dist",
     ".agents/skills",
-    "AGENTS.md"
+    "AGENTS.md",
+    "NOTICE"
   ],
   "engines": {
     "node": ">=22.18"