@zalosai/zalos-cli 0.2.13

package/dist/utils/developer-db.js

@@ -0,0 +1,78 @@
+import { spawn } from 'node:child_process';
+export const DATABASE_INSTALL = 'npm install --global @zalos-io/developer-db@0.3.2';
+const MAX_OUTPUT_BYTES = 64 * 1024;
+export class DatabaseToolError extends Error {
+    code;
+    constructor(code) {
+        super(code === 'NOT_INSTALLED'
+            ? `zalos-db is missing. Authenticate to GitHub Packages, then run: ${DATABASE_INSTALL}`
+            : 'Database access check failed. Run zalos-db login and doctor with the selected environment.');
+        this.code = code;
+    }
+}
+/** The child owns AWS and database credentials; never echo its arbitrary output. */
+export function runDatabaseTool(args) {
+    return new Promise((resolve, reject) => {
+        const env = { ...process.env };
+        delete env.ZL_API_TOKEN;
+        const child = spawn('zalos-db', args, { shell: false, env, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let bytes = 0;
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            reject(new DatabaseToolError('TIMEOUT'));
+        }, 60_000);
+        const capture = (chunk, retain) => {
+            bytes += chunk.byteLength;
+            if (bytes > MAX_OUTPUT_BYTES) {
+                child.kill('SIGTERM');
+                reject(new DatabaseToolError('OUTPUT_LIMIT'));
+            }
+            else if (retain)
+                stdout += chunk.toString('utf8');
+            else
+                stderr += chunk.toString('utf8');
+        };
+        child.stdout.on('data', (chunk) => capture(chunk, true));
+        child.stderr.on('data', (chunk) => capture(chunk, false));
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            reject(new DatabaseToolError(error.code === 'ENOENT' ? 'NOT_INSTALLED' : 'CHECK_FAILED'));
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                let failure = 'CHECK_FAILED';
+                try {
+                    const payload = JSON.parse(stderr);
+                    const known = [
+                        'aws_session',
+                        'aws_identity',
+                        'sso_login',
+                        'database_connect',
+                        'database_identity',
+                        'database_secret',
+                        'tunnel_start',
+                        'tunnel_readiness',
+                        'ca_bundle',
+                    ];
+                    if (typeof payload.code === 'string' && known.includes(payload.code))
+                        failure = payload.code;
+                }
+                catch {
+                    /* No arbitrary child output escapes this boundary. */
+                }
+                reject(new DatabaseToolError(failure));
+                return;
+            }
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch {
+                reject(new DatabaseToolError('INVALID_RESPONSE'));
+            }
+        });
+    });
+}
+//# sourceMappingURL=developer-db.js.map

package/dist/utils/download-file.js

@@ -0,0 +1,65 @@
+import { open, unlink } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { ApiError, ValidationError } from './errors.js';
+function validateDownloadUrl(value, options) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new ApiError(502, 'The file API returned an invalid download URL');
+    }
+    const protocolAllowed = url.protocol === 'https:' ||
+        url.protocol === 'http:' ||
+        (options.allowDataUrl === true && url.protocol === 'data:');
+    if (!protocolAllowed) {
+        throw new ApiError(502, 'The file API returned an unsupported download URL');
+    }
+    return url;
+}
+export async function downloadToNewFile(urlValue, output, options = {}) {
+    if (!output.trim())
+        throw new ValidationError('output', '--output must not be empty');
+    const url = validateDownloadUrl(urlValue, options);
+    const destination = resolve(output);
+    let handle;
+    try {
+        handle = await open(destination, 'wx', 0o600);
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            throw new ValidationError('output', `Output already exists: ${destination}`);
+        }
+        throw error;
+    }
+    let bytes = 0;
+    try {
+        const response = await fetch(url, {
+            redirect: 'error',
+            signal: AbortSignal.timeout(10 * 60_000),
+        });
+        if (!response.ok) {
+            throw new ApiError(response.status, `File download failed with HTTP ${response.status}`);
+        }
+        if (!response.body) {
+            await handle.close();
+            return { output: destination, bytes: 0 };
+        }
+        const counter = new Transform({
+            transform(chunk, _encoding, callback) {
+                bytes += chunk.length;
+                callback(null, chunk);
+            },
+        });
+        await pipeline(Readable.from(response.body), counter, handle.createWriteStream());
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        await unlink(destination).catch(() => undefined);
+        throw error;
+    }
+    return { output: destination, bytes };
+}
+//# sourceMappingURL=download-file.js.map

package/dist/utils/errors.js

@@ -0,0 +1,60 @@
+export class AuthError extends Error {
+    code = 'AUTH_ERROR';
+    constructor(message) {
+        super(message);
+        this.name = 'AuthError';
+    }
+}
+export class ApiError extends Error {
+    status;
+    code = 'API_ERROR';
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+export class ValidationError extends Error {
+    field;
+    code = 'VALIDATION_ERROR';
+    constructor(field, message) {
+        super(message);
+        this.field = field;
+        this.name = 'ValidationError';
+    }
+}
+export class NotFoundError extends Error {
+    resource;
+    id;
+    code = 'NOT_FOUND';
+    constructor(resource, id) {
+        super(`${resource} not found: ${id}`);
+        this.resource = resource;
+        this.id = id;
+        this.name = 'NotFoundError';
+    }
+}
+export function handleError(error) {
+    let payload;
+    if (error instanceof AuthError) {
+        payload = { error: error.message, code: error.code };
+    }
+    else if (error instanceof NotFoundError) {
+        payload = { error: error.message, code: error.code, resource: error.resource, id: error.id };
+    }
+    else if (error instanceof ApiError) {
+        payload = { error: error.message, code: error.code, status: error.status };
+    }
+    else if (error instanceof ValidationError) {
+        payload = { error: error.message, code: error.code, field: error.field };
+    }
+    else if (error instanceof Error) {
+        payload = { error: error.message, code: 'UNKNOWN_ERROR' };
+    }
+    else {
+        payload = { error: 'Unknown error', code: 'UNKNOWN_ERROR' };
+    }
+    process.stderr.write(JSON.stringify(payload) + '\n');
+    process.exit(1);
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/output.js

@@ -0,0 +1,30 @@
+export function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+}
+export function filterFields(items, fields) {
+    if (!fields)
+        return items;
+    const allowed = new Set(fields.split(',').map((f) => f.trim()));
+    return items.map((item) => {
+        const filtered = {};
+        for (const key of allowed) {
+            if (Object.prototype.hasOwnProperty.call(item, key)) {
+                filtered[key] = item[key];
+            }
+        }
+        return filtered;
+    });
+}
+export function filterSingle(item, fields) {
+    if (!fields)
+        return item;
+    return filterFields([item], fields)[0];
+}
+export function printList(items, fields, nextCursor) {
+    const data = filterFields(items, fields);
+    const result = { data };
+    if (nextCursor !== undefined)
+        result['nextCursor'] = nextCursor;
+    printJson(result);
+}
+//# sourceMappingURL=output.js.map

package/dist/utils/product-api.js

@@ -0,0 +1,48 @@
+import { ApiError, handleError, ValidationError } from './errors.js';
+import { filterFields, printJson } from './output.js';
+export function isRow(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function dataRow(value) {
+    if (!isRow(value) || !isRow(value.data))
+        throw new ApiError(502, 'Expected API response with object data');
+    return value.data;
+}
+export function dataRows(value) {
+    if (!isRow(value) || !Array.isArray(value.data) || !value.data.every(isRow))
+        throw new ApiError(502, 'Expected API response with array data');
+    return value.data;
+}
+export function integer(value, fallback, minimum = 0, maximum = 10000) {
+    const raw = value ?? String(fallback);
+    const result = Number(raw);
+    if (!/^\d+$/.test(raw) || !Number.isSafeInteger(result) || result < minimum || result > maximum)
+        throw new ValidationError('pagination', `Expected integer between ${minimum} and ${maximum}`);
+    return result;
+}
+export function printPage(rows, options) {
+    const offset = integer(options.offset, 0);
+    const limit = integer(options.limit, 100, 1, 100);
+    printJson({
+        data: filterFields(rows.slice(offset, offset + limit), options.fields),
+        count: rows.length,
+        ...(offset + limit < rows.length ? { nextOffset: offset + limit } : {}),
+    });
+}
+export function resourceId(id) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(id))
+        throw new ValidationError('id', 'Invalid resource ID');
+    return id;
+}
+export function fields(program) {
+    return program.optsWithGlobals();
+}
+export async function action(run) {
+    try {
+        await run();
+    }
+    catch (error) {
+        handleError(error);
+    }
+}
+//# sourceMappingURL=product-api.js.map

package/dist/utils/stdin.js

@@ -0,0 +1,23 @@
+export async function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        const onData = (chunk) => {
+            data += chunk;
+        };
+        const onEnd = () => {
+            process.stdin.off('data', onData);
+            process.stdin.off('error', onError);
+            resolve(data);
+        };
+        const onError = (err) => {
+            process.stdin.off('data', onData);
+            process.stdin.off('end', onEnd);
+            reject(err);
+        };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', onData);
+        process.stdin.once('end', onEnd);
+        process.stdin.once('error', onError);
+    });
+}
+//# sourceMappingURL=stdin.js.map

package/dist/utils/validate.js

@@ -0,0 +1,39 @@
+import { ValidationError } from './errors.js';
+const DANGEROUS_CHARS_RE = /[?#%]/;
+const PATH_TRAVERSAL_RE = /(^|[\\/])\.\.($|[\\/])/;
+function hasControlChars(value, allowWhitespace = false) {
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x20) {
+            if (allowWhitespace && (code === 0x09 || code === 0x0a || code === 0x0d))
+                continue;
+            return true;
+        }
+    }
+    return false;
+}
+export function validateId(id, label = 'ID') {
+    if (!id || DANGEROUS_CHARS_RE.test(id) || hasControlChars(id) || PATH_TRAVERSAL_RE.test(id)) {
+        throw new ValidationError(label, `Invalid ${label}: contains forbidden characters`);
+    }
+}
+export function validateString(value, label, maxLength = 10_000) {
+    if (hasControlChars(value, true)) {
+        throw new ValidationError(label, `${label} contains control characters`);
+    }
+    if (PATH_TRAVERSAL_RE.test(value)) {
+        throw new ValidationError(label, `${label} contains path traversal`);
+    }
+    if (value.length > maxLength) {
+        throw new ValidationError(label, `${label} exceeds max length of ${maxLength}`);
+    }
+}
+export function parseJson(raw, label = '--json') {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new ValidationError(label, `${label} is not valid JSON`);
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/workflow-file.js

@@ -0,0 +1,34 @@
+import { readFile } from 'node:fs/promises';
+import { ValidationError } from './utils/errors.js';
+import { isRow } from './utils/product-api.js';
+export function parseWorkflowFile(raw, expectedId) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new ValidationError('input', 'Workflow file is not valid JSON');
+    }
+    if (!isRow(value) ||
+        !Array.isArray(value.nodes) ||
+        !value.nodes.every(isRow) ||
+        !isRow(value.connections))
+        throw new ValidationError('input', 'Workflow requires nodes array and connections object');
+    if (expectedId && value.id !== undefined && value.id !== expectedId)
+        throw new ValidationError('id', 'Workflow file ID does not match requested ID');
+    return value;
+}
+export async function readWorkflowFile(path, expectedId) {
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch {
+        throw new ValidationError('input', 'Cannot read workflow file');
+    }
+    return parseWorkflowFile(raw, expectedId);
+}
+export function serializeWorkflow(value, pretty = false) {
+    return JSON.stringify(value, null, pretty ? 2 : undefined) + '\n';
+}
+//# sourceMappingURL=workflow-file.js.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@zalosai/zalos-cli",
+  "version": "0.2.13",
+  "description": "API-only product command-line interface for Zalos",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Zalos-io/mesh.git",
+    "directory": "packages/zalos-cli"
+  },
+  "type": "module",
+  "main": "dist/main.js",
+  "bin": {
+    "zl": "dist/main.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md",
+    "PUBLISHING.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@tiptap/core": "3.27.1",
+    "@tiptap/extension-heading": "3.27.1",
+    "@tiptap/extension-image": "3.27.1",
+    "@tiptap/extension-list": "3.27.1",
+    "@tiptap/extension-paragraph": "3.27.1",
+    "@tiptap/markdown": "3.27.1",
+    "@tiptap/pm": "3.27.1",
+    "@tiptap/static-renderer": "3.27.1",
+    "@tiptap/starter-kit": "3.27.1",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.8"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "clean": "tsc --build --clean && rm -rf dist",
+    "dev": "tsx src/main.ts",
+    "smoke:package": "node scripts/smoke-package.mjs",
+    "test": "vitest run",
+    "typecheck": "tsgo --noEmit --types node --incremental --tsBuildInfoFile dist/tsconfig.typecheck.tsbuildinfo"
+  }
+}