jitsu-cli 2.14.0-canary.20260128.21613fb → 2.14.0

package/bin/jitsu

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/main.js");

package/compiled/package.json

@@ -1,13 +1,19 @@
 {
     "name": "jitsu-cli",
-    "version": "2.14.0-canary.20260128.21613fb",
+    "version": "2.14.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/jitsucom/jitsu",
+        "directory": "cli/jitsu-cli"
+    },
     "description": "",
     "author": "Jitsu Dev Team <dev@jitsu.com>",
     "publishConfig": {
         "access": "public"
     },
     "bin": {
-        "jitsu-cli": "./bin/jitsu-cli"
+        "jitsu-cli": "./bin/jitsu-cli",
+        "jitsu": "./bin/jitsu"
     },
     "license": "MIT",
     "private": false,
@@ -15,6 +21,7 @@
         "clean": "rm -rf ./dist ./compiled",
         "typecheck": "tsc --noEmit",
         "build": "tsc && tsx build.mts",
+        "cli": "tsx src/index.ts",
         "run": "pnpm build && node dist/main.js",
         "login": "pnpm build && node dist/main.js login",
         "init child": "pnpm build && node dist/main.js init",
@@ -48,12 +55,15 @@
         "etag": "^1.8.1",
         "inquirer": "^9.2.11",
         "jest": "^29.7.0",
+        "js-yaml": "^4.2.0",
+        "@types/js-yaml": "^4.0.9",
         "json5": "^2.2.3",
         "juava": "workspace:*",
         "lodash": "catalog:",
         "prismjs": "^1.30.0",
         "semver": "^7.5.4",
         "tsx": "catalog:",
-        "vitest": "catalog:"
+        "vitest": "catalog:",
+        "vite": "^6.4.3"
     }
 }

package/compiled/src/commands/config/handlers.js

@@ -0,0 +1,292 @@
+import { ApiClient, ApiError } from "../../lib/api-client";
+import { readDefaultWorkspace, resolveAuth } from "../../lib/auth-file";
+import { buildBody } from "../../lib/body-builder";
+import { consumeBodyFields } from "../../lib/body-fields";
+import { print } from "../../lib/renderer";
+async function resolveWorkspaceId(client, idOrSlug) {
+    try {
+        const ws = await client.request({
+            method: "GET",
+            path: `/api/workspace/${encodeURIComponent(idOrSlug)}`,
+        });
+        return ws.id;
+    }
+    catch (e) {
+        if (e instanceof ApiError && e.status === 404) {
+            throw new Error(`Workspace '${idOrSlug}' not found (or you don't have access)`);
+        }
+        throw e;
+    }
+}
+function gatherBody(opts) {
+    const fields = consumeBodyFields();
+    return buildBody({ file: opts.file, json: opts.json, fields });
+}
+function requireWorkspace(opts) {
+    if (opts.workspace)
+        return opts.workspace;
+    const fallback = readDefaultWorkspace();
+    if (fallback)
+        return fallback;
+    throw new Error("--workspace / -w is required (or set a default via `jitsu set-default-workspace <id-or-slug>`)");
+}
+async function requireResolvedWorkspaceId(opts, client) {
+    return resolveWorkspaceId(client, requireWorkspace(opts));
+}
+export async function runList(resource, opts) {
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    switch (resource.kind) {
+        case "workspace": {
+            const data = await client.request({ method: "GET", path: "/api/workspace" });
+            print(data, opts.output);
+            return;
+        }
+        case "configObject": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const data = await client.request({
+                method: "GET",
+                path: `/api/${encodeURIComponent(ws)}/config/${resource.type}`,
+            });
+            print(data.objects ?? data, opts.output);
+            return;
+        }
+        case "link": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const data = await client.request({
+                method: "GET",
+                path: `/api/${encodeURIComponent(ws)}/config/link`,
+            });
+            print(data.links ?? data, opts.output);
+            return;
+        }
+        case "profile-builder": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const data = await client.request({
+                method: "GET",
+                path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+            });
+            print(data.profileBuilders ?? data, opts.output);
+            return;
+        }
+    }
+}
+export async function runGet(resource, id, opts) {
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    switch (resource.kind) {
+        case "workspace": {
+            const data = await client.request({ method: "GET", path: `/api/workspace/${encodeURIComponent(id)}` });
+            print(data, opts.output);
+            return;
+        }
+        case "configObject": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const data = await client.request({
+                method: "GET",
+                path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/${encodeURIComponent(id)}`,
+            });
+            print(data, opts.output);
+            return;
+        }
+        default:
+            throw new Error(`get is not supported for ${resource.noun}`);
+    }
+}
+export async function runCreate(resource, opts) {
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    const body = gatherBody(opts) ?? {};
+    switch (resource.kind) {
+        case "workspace": {
+            const data = await client.request({ method: "POST", path: "/api/workspace", body });
+            print(data, opts.output);
+            return;
+        }
+        case "configObject": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const data = await client.request({
+                method: "POST",
+                path: `/api/${encodeURIComponent(ws)}/config/${resource.type}`,
+                body,
+            });
+            print(data, opts.output);
+            return;
+        }
+        case "link": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const data = await client.request({
+                method: "POST",
+                path: `/api/${encodeURIComponent(ws)}/config/link`,
+                body,
+            });
+            print(data, opts.output);
+            return;
+        }
+        case "profile-builder": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const data = await client.request({
+                method: "POST",
+                path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+                body,
+            });
+            print(data, opts.output);
+            return;
+        }
+    }
+}
+export async function runUpdate(resource, id, opts) {
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    const body = gatherBody(opts);
+    if (body === undefined) {
+        throw new Error("update requires at least one of -f, --json, or --field.path=value flags");
+    }
+    switch (resource.kind) {
+        case "workspace": {
+            if (!id)
+                throw new Error("workspace id or slug is required");
+            const data = await client.request({
+                method: "PUT",
+                path: `/api/workspace/${encodeURIComponent(id)}`,
+                body,
+            });
+            print(data, opts.output);
+            return;
+        }
+        case "configObject": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            if (!id)
+                throw new Error("id is required");
+            const data = await client.request({
+                method: "PUT",
+                path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/${encodeURIComponent(id)}`,
+                body,
+            });
+            print(data ?? { ok: true }, opts.output);
+            return;
+        }
+        case "link": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const finalBody = mergePositionalId(body, id, "id");
+            const data = await client.request({
+                method: "PUT",
+                path: `/api/${encodeURIComponent(ws)}/config/link`,
+                body: finalBody,
+            });
+            print(data, opts.output);
+            return;
+        }
+        case "profile-builder": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            if (!id)
+                throw new Error("id is required");
+            const finalBody = mergeNestedPositionalId(body, id, "profileBuilder", "id");
+            const data = await client.request({
+                method: "PUT",
+                path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+                body: finalBody,
+            });
+            print(data, opts.output);
+            return;
+        }
+    }
+}
+function mergePositionalId(body, id, key) {
+    if (id === undefined)
+        return body;
+    if (body && typeof body === "object" && body[key] !== undefined && body[key] !== id) {
+        throw new Error(`positional id '${id}' conflicts with body.${key} '${body[key]}'`);
+    }
+    return { ...(body && typeof body === "object" ? body : {}), [key]: id };
+}
+function mergeNestedPositionalId(body, id, outer, inner) {
+    const base = body && typeof body === "object" ? body : {};
+    const nested = base[outer] && typeof base[outer] === "object" ? base[outer] : {};
+    if (nested[inner] !== undefined && nested[inner] !== id) {
+        throw new Error(`positional id '${id}' conflicts with body.${outer}.${inner} '${nested[inner]}'`);
+    }
+    return { ...base, [outer]: { ...nested, [inner]: id } };
+}
+export async function runDelete(resource, id, opts) {
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    switch (resource.kind) {
+        case "workspace": {
+            if (!id)
+                throw new Error("workspace id is required");
+            const data = await client.request({
+                method: "DELETE",
+                path: "/api/workspace",
+                body: { workspaceId: id },
+            });
+            print(data, opts.output);
+            return;
+        }
+        case "configObject": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            if (!id)
+                throw new Error("id is required");
+            const query = {};
+            if (opts.cascade)
+                query.cascade = "true";
+            if (opts.strict)
+                query.strict = "true";
+            const data = await client.request({
+                method: "DELETE",
+                path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/${encodeURIComponent(id)}`,
+                query,
+            });
+            print(data ?? { ok: true }, opts.output);
+            return;
+        }
+        case "link": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            const query = {};
+            if (id) {
+                query.id = id;
+            }
+            else if (opts.from && opts.to) {
+                query.fromId = opts.from;
+                query.toId = opts.to;
+            }
+            else {
+                throw new Error("connection delete requires either <id> or both --from and --to");
+            }
+            const data = await client.request({
+                method: "DELETE",
+                path: `/api/${encodeURIComponent(ws)}/config/link`,
+                query,
+            });
+            print(data ?? { ok: true }, opts.output);
+            return;
+        }
+        case "profile-builder": {
+            const ws = await requireResolvedWorkspaceId(opts, client);
+            if (!id)
+                throw new Error("id is required");
+            const data = await client.request({
+                method: "DELETE",
+                path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+                query: { id },
+            });
+            print(data ?? { ok: true }, opts.output);
+            return;
+        }
+    }
+}
+export async function runTest(resource, opts) {
+    if (resource.kind !== "configObject" || !resource.supportsTest) {
+        throw new Error(`test is not supported for ${resource.noun}`);
+    }
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    const ws = await requireResolvedWorkspaceId(opts, client);
+    const body = gatherBody(opts) ?? {};
+    const data = await client.request({
+        method: "POST",
+        path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/test`,
+        body,
+    });
+    print(data, opts.output);
+}

package/compiled/src/commands/config/index.js

@@ -0,0 +1,148 @@
+import { Command } from "commander";
+import { red } from "../../lib/chalk-code-highlight";
+import { DEFAULT_OUTPUT, SUPPORTED_OUTPUTS } from "../../lib/renderer";
+import { resources, verbsFor } from "./resources";
+import { runCreate, runDelete, runGet, runList, runTest, runUpdate } from "./handlers";
+function withCommonOpts(cmd) {
+    return cmd
+        .option("-w, --workspace <id-or-slug>", "Target workspace id or slug")
+        .option("-o, --output <format>", `Output format: ${SUPPORTED_OUTPUTS.join(", ")}`, DEFAULT_OUTPUT)
+        .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+        .option("-k, --apikey <api-key>", "API key in form keyId:secret (overrides ~/.jitsu/jitsu-cli.json)");
+}
+function withBodyOpts(cmd) {
+    return cmd
+        .option("-f, --file <path>", "Read body from yaml or json file (use `-` for stdin)")
+        .option("--json <json>", "Inline JSON body")
+        .addHelpText("after", [
+        "",
+        "Body fields can also be set ad-hoc via --<path>=<value> flags.",
+        "Examples:",
+        "  --name=my-destination",
+        "  --destinationType=postgres",
+        "  --credentials.host=db.example.com",
+        "  --credentials.password=secret",
+        '  --credentials.keys=\'["a","b"]\'',
+        'Values starting with [, {, " or matching number/boolean/null are parsed as JSON;',
+        "everything else is a plain string. -f, --json, and --field flags merge in that order.",
+    ].join("\n"));
+}
+function action(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(red(`Error: ${msg}`));
+            process.exit(1);
+        }
+    };
+}
+function buildLeaf(resource, verb) {
+    switch (verb) {
+        case "list": {
+            const cmd = withCommonOpts(new Command("list"))
+                .description(`List ${resource.noun}`)
+                .action(action(async (opts) => runList(resource, opts)));
+            return cmd;
+        }
+        case "get": {
+            const idLabel = resource.kind === "workspace" ? "<id-or-slug>" : "<id>";
+            const cmd = withCommonOpts(new Command("get"))
+                .description(`Get a single ${singular(resource)} by id`)
+                .argument(idLabel, `Identifier of the ${singular(resource)}`)
+                .action(action(async (id, opts) => runGet(resource, id, opts)));
+            return cmd;
+        }
+        case "create": {
+            const cmd = withBodyOpts(withCommonOpts(new Command("create")))
+                .description(`Create a ${singular(resource)}`)
+                .action(action(async (opts) => runCreate(resource, opts)));
+            return cmd;
+        }
+        case "update": {
+            const idLabel = resource.kind === "link" ? "[id]" : "<id>";
+            const idDesc = resource.kind === "link"
+                ? `Link id (optional — connections are upserts identified by fromId+toId)`
+                : `Identifier of the ${singular(resource)}`;
+            const cmd = withBodyOpts(withCommonOpts(new Command("update")))
+                .description(`Update a ${singular(resource)} (deep-merge into existing)`)
+                .argument(idLabel, idDesc)
+                .action(action(async (id, opts) => runUpdate(resource, id, opts)));
+            return cmd;
+        }
+        case "delete": {
+            const idLabel = resource.kind === "link" ? "[id]" : "<id>";
+            let cmd = withCommonOpts(new Command("delete"))
+                .alias("rm")
+                .description(`Delete a ${singular(resource)}`)
+                .argument(idLabel, `Identifier of the ${singular(resource)}`);
+            if (resource.kind === "configObject") {
+                cmd = cmd
+                    .option("--cascade", "Also delete linked connections that reference this object")
+                    .option("--strict", "Refuse to delete if linked connections exist");
+            }
+            if (resource.kind === "link") {
+                cmd = cmd
+                    .option("--from <streamOrServiceId>", "Source id (use with --to instead of <id>)")
+                    .option("--to <destinationId>", "Destination id (use with --from instead of <id>)");
+            }
+            cmd = cmd.action(action(async (id, opts) => runDelete(resource, id, opts)));
+            return cmd;
+        }
+        case "test": {
+            const cmd = withBodyOpts(withCommonOpts(new Command("test")))
+                .description(`Test connectivity for a ${singular(resource)} configuration`)
+                .action(action(async (opts) => runTest(resource, opts)));
+            return cmd;
+        }
+    }
+}
+function singular(r) {
+    return r.aliases[0] ?? r.noun.replace(/s$/, "");
+}
+export function buildConfigCommand() {
+    const config = new Command("config")
+        .description("Manage workspace configuration objects (destinations, streams, connections, ...)")
+        .addHelpText("after", [
+        "",
+        "Two equivalent invocation styles are supported:",
+        "  jitsu config <noun> <verb> [args]    e.g. jitsu config destinations list -w ws",
+        "  jitsu config <verb> <noun> [args]    e.g. jitsu config list destinations -w ws",
+        "",
+        "Resources:",
+        ...resources.map(r => `  ${r.noun.padEnd(20)} ${r.description}`),
+    ].join("\n"));
+    for (const resource of resources) {
+        const nounCmd = new Command(resource.noun).description(resource.description);
+        for (const alias of resource.aliases)
+            nounCmd.alias(alias);
+        for (const verb of verbsFor(resource.kind)) {
+            nounCmd.addCommand(buildLeaf(resource, verb));
+        }
+        if (resource.supportsTest) {
+            nounCmd.addCommand(buildLeaf(resource, "test"));
+        }
+        config.addCommand(nounCmd);
+    }
+    const allVerbs = ["list", "get", "create", "update", "delete", "test"];
+    for (const verb of allVerbs) {
+        const verbCmd = new Command(verb).description(`${capitalize(verb)} a configuration object (alias for the noun-first form)`);
+        for (const resource of resources) {
+            const applicable = verbsFor(resource.kind).includes(verb) || (verb === "test" && resource.supportsTest);
+            if (!applicable)
+                continue;
+            const leaf = buildLeaf(resource, verb);
+            leaf.name(resource.noun);
+            for (const alias of resource.aliases)
+                leaf.alias(alias);
+            verbCmd.addCommand(leaf);
+        }
+        config.addCommand(verbCmd);
+    }
+    return config;
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/compiled/src/commands/config/resources.js

@@ -0,0 +1,88 @@
+export const resources = [
+    {
+        noun: "workspaces",
+        aliases: ["workspace"],
+        kind: "workspace",
+        description: "Workspaces accessible to the current user",
+    },
+    {
+        noun: "destinations",
+        aliases: ["destination", "dest"],
+        kind: "configObject",
+        type: "destination",
+        supportsTest: true,
+        description: "Destinations (warehouses, databases, services receiving events)",
+    },
+    {
+        noun: "streams",
+        aliases: ["stream"],
+        kind: "configObject",
+        type: "stream",
+        supportsTest: true,
+        description: "Event streams (formerly known as sources)",
+    },
+    {
+        noun: "functions",
+        aliases: ["function", "fn"],
+        kind: "configObject",
+        type: "function",
+        description: "User-defined functions (UDFs). For dev workflow see `jitsu deploy`.",
+    },
+    {
+        noun: "services",
+        aliases: ["service"],
+        kind: "configObject",
+        type: "service",
+        supportsTest: true,
+        description: "External connector services (Airbyte protocol)",
+    },
+    {
+        noun: "domains",
+        aliases: ["domain"],
+        kind: "configObject",
+        type: "domain",
+        description: "Custom ingestion domains",
+    },
+    {
+        noun: "misc",
+        aliases: [],
+        kind: "configObject",
+        type: "misc",
+        description: "Miscellaneous configuration entities (free-form)",
+    },
+    {
+        noun: "notifications",
+        aliases: ["notification"],
+        kind: "configObject",
+        type: "notification",
+        description: "Alert channels (email/Slack)",
+    },
+    {
+        noun: "connections",
+        aliases: ["connection", "link", "links"],
+        kind: "link",
+        description: "Connections between streams/services and destinations",
+    },
+    {
+        noun: "profile-builders",
+        aliases: ["profile-builder"],
+        kind: "profile-builder",
+        description: "Profile builders (identity stitching)",
+    },
+];
+export function verbsFor(kind) {
+    switch (kind) {
+        case "configObject":
+            return ["list", "get", "create", "update", "delete"];
+        case "workspace":
+            return ["list", "get", "create", "update", "delete"];
+        case "link":
+            return ["list", "create", "update", "delete"];
+        case "profile-builder":
+            return ["list", "create", "update", "delete"];
+    }
+}
+export function findResource(name) {
+    const lower = name.toLowerCase();
+    return resources.find(r => r.noun === lower || r.aliases.includes(lower));
+}

package/compiled/src/commands/default-workspace.js

@@ -0,0 +1,39 @@
+import { ApiClient, ApiError } from "../lib/api-client";
+import { authFilePath, readAuthFile, resolveAuth, updateAuthFile } from "../lib/auth-file";
+import { red } from "../lib/chalk-code-highlight";
+export async function setDefaultWorkspace(idOrSlug, opts) {
+    try {
+        const auth = resolveAuth(opts);
+        const client = new ApiClient(auth);
+        let workspace;
+        try {
+            workspace = await client.request({
+                method: "GET",
+                path: `/api/workspace/${encodeURIComponent(idOrSlug)}`,
+            });
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 404) {
+                throw new Error(`Workspace '${idOrSlug}' not found (or you don't have access)`);
+            }
+            throw e;
+        }
+        updateAuthFile({ defaultWorkspace: workspace.id });
+        const label = workspace.slug ? `${workspace.slug} (${workspace.id})` : workspace.id;
+        console.log(`Default workspace set to ${label}.`);
+        console.log(`Saved to ${authFilePath()}.`);
+    }
+    catch (e) {
+        console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    }
+}
+export async function unsetDefaultWorkspace() {
+    const file = readAuthFile();
+    if (!file?.defaultWorkspace) {
+        console.log("No default workspace is set.");
+        return;
+    }
+    updateAuthFile({ defaultWorkspace: undefined });
+    console.log("Default workspace unset.");
+}