@bakers-build/addon-dropsh 0.0.0-stage → 0.1.0-next.38

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 keytec GmbH
+
+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

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @bakers-build/addon-dropsh
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+bakers.build dropsh command plugin: the `bakers dropsh` JSON:API shell bound to the split connection config.
+
+Part of the bakers.build CLI. Install the meta package `@bakers-build/bakers` to get the `bakers` CLI with all addons. Source: https://git.key-tec.de/bakers-build/bakers-build (bakers-cli/).

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+import { type BbCommandHost, type BbCommandPlugin, type WorkspaceRecoveryOptions } from '@bakers-build/core';
+export declare function dropshConfigHint(resolvedPath?: string): string;
+export interface DropshDispatchOptions extends WorkspaceRecoveryOptions {
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+/** Build the actual plugin registrations after the final connection is ready. */
+export declare function dispatchBbDropsh(host: BbCommandHost, argv: string[], options?: DropshDispatchOptions): Promise<void>;
+declare const dropshCommandPlugin: BbCommandPlugin;
+export default dropshCommandPlugin;

package/dist/src/index.js

@@ -0,0 +1,148 @@
+import { createBbConnectionContext, discoverBbWorkspaces, loadBbConnectionBootstrap, loadReadyBbConnection, } from '@bakers-build/core';
+import { buildProgram as buildDropshProgram } from 'dropsh';
+import { registerTemplateCommand } from './template.js';
+import { hideUnpublishedComments } from './unpublished-comments.js';
+export function dropshConfigHint(resolvedPath) {
+    return `bakers dropsh: no connection config at ${resolvedPath ?? '~/.bakers/bakers.config.js'}. Use --config <path> or run bakers config init --scope connection.`;
+}
+/** Consume only wrapper flags; forward all actual dropsh arguments unchanged. */
+function invocation(argv) {
+    const forwarded = [];
+    let explicit;
+    let connection;
+    let format;
+    let yes = false;
+    let profile;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--yes') {
+            yes = true;
+            continue;
+        }
+        if (token === '--config' ||
+            token === '--connection' ||
+            token === '--format' ||
+            token === '--auth-profile') {
+            const value = argv[i + 1];
+            if (value !== undefined) {
+                if (token === '--config')
+                    explicit = value;
+                else if (token === '--connection')
+                    connection = value;
+                else if (token === '--format')
+                    format = value;
+                else
+                    profile = value;
+                forwarded.push(token, value);
+                i++;
+                continue;
+            }
+        }
+        if (token.startsWith('--config='))
+            explicit = token.slice(9);
+        if (token.startsWith('--connection='))
+            connection = token.slice(13);
+        if (token.startsWith('--format='))
+            format = token.slice(9);
+        forwarded.push(token);
+    }
+    // Global options can appear late, after the command's positional arguments.
+    const positional = forwarded.filter((token, i) => ![
+        '--config',
+        '--connection',
+        '--format',
+        '--auth-profile',
+        '--view-mode',
+    ].includes(token) &&
+        !/^--(?:config|connection|format|auth-profile|view-mode)=/.test(token) &&
+        ![
+            '--config',
+            '--connection',
+            '--format',
+            '--auth-profile',
+            '--view-mode',
+        ].includes(forwarded[i - 1] ?? ''));
+    return { forwarded, explicit, connection, format, yes, profile, positional };
+}
+/** Build the actual plugin registrations after the final connection is ready. */
+export async function dispatchBbDropsh(host, argv, options = {}) {
+    const args = invocation(argv);
+    const opts = {
+        ...options,
+        ...(args.explicit ? { explicit: args.explicit } : {}),
+        ...(args.connection ? { connection: args.connection } : {}),
+        ...(args.format ? { format: args.format } : {}),
+        yes: options.yes || args.yes,
+    };
+    const help = argv.includes('--help') || argv.includes('-h') || argv.length === 0;
+    const auth = args.positional[0] === 'auth';
+    const search = args.positional[0] === 'search' &&
+        args.positional[1] === 'bb_workspace' &&
+        args.positional.length === 2 &&
+        (!args.format || ['md', 'json'].includes(args.format));
+    if (search) {
+        const connection = await loadBbConnectionBootstrap(host, opts);
+        const rows = await discoverBbWorkspaces(connection, opts);
+        const stdout = options.stdout ?? ((s) => process.stdout.write(s));
+        if (args.format === 'md')
+            stdout(`| Workspace | UUID |\n| --- | --- |\n${rows.map((r) => `| ${r.name.replace(/[|\r\n]/g, ' ')} | ${r.id} |`).join('\n')}\n`);
+        else
+            stdout(`${JSON.stringify(rows, null, 2)}\n`);
+        return;
+    }
+    const connection = help
+        ? undefined
+        : auth
+            ? await loadBbConnectionBootstrap(host, opts)
+            : await loadReadyBbConnection(host, opts);
+    const program = buildDropshProgram({
+        plugins: connection?.plugins ?? [],
+        ...(options.stdout ? { stdout: options.stdout } : {}),
+        ...(options.stderr ? { stderr: options.stderr } : {}),
+        ...(connection
+            ? {
+                contextFactory: () => createBbConnectionContext(connection, {
+                    ...opts,
+                    ...(args.profile ? { profile: args.profile } : {}),
+                    wrapHttp: hideUnpublishedComments,
+                }),
+            }
+            : {}),
+    });
+    if (connection) {
+        registerTemplateCommand(program, {
+            contextFactory: () => createBbConnectionContext(connection, {
+                ...opts,
+                ...(args.profile ? { profile: args.profile } : {}),
+                wrapHttp: hideUnpublishedComments,
+            }),
+            stdout: options.stdout ?? ((s) => process.stdout.write(s)),
+            stderr: options.stderr ?? ((s) => process.stderr.write(s)),
+            setExitCode: (code) => {
+                process.exitCode = code;
+            },
+        });
+    }
+    // Auth commands perform their own reload; bind it explicitly to the same path.
+    const forwarded = connection
+        ? ['--config', connection.config_path, ...args.forwarded]
+        : args.forwarded;
+    await program.parseAsync(forwarded, { from: 'user' });
+}
+const dropshCommandPlugin = {
+    kind: 'command',
+    name: 'dropsh',
+    describe: 'JSON:API shell (dropsh) bound to the bakers.build connection config',
+    register(program, host) {
+        program
+            .command('dropsh')
+            .description('JSON:API shell bound to the bakers.build connection')
+            .helpOption(false)
+            .allowUnknownOption()
+            .argument('[args...]')
+            .action(async (args) => {
+            await dispatchBbDropsh(host, args);
+        });
+    },
+};
+export default dropshCommandPlugin;

package/dist/src/preset.d.ts

@@ -0,0 +1,2 @@
+import type { BbPreset } from '@bakers-build/core';
+export declare const commands: BbPreset['commands'];

package/dist/src/preset.js

@@ -0,0 +1,8 @@
+export const commands = (acc) => [
+    ...acc,
+    {
+        name: 'dropsh',
+        plugin: '@bakers-build/addon-dropsh',
+        describe: 'JSON:API shell (dropsh) bound to the bakers.build connection config',
+    },
+];

package/dist/src/template.d.ts

@@ -0,0 +1,32 @@
+import type { Command } from 'commander';
+import type { CommandContext } from 'dropsh';
+export interface TemplateRunResult {
+    ticket_uuid: string;
+    identifier: string | null;
+    created: true;
+}
+/** Per-field overrides of the template defaults; relationships by uuid. */
+export interface TemplateOverrides {
+    title?: string;
+    description?: string;
+    workflow?: string;
+    project_id?: string;
+    conductor_id?: string;
+    labels?: string[];
+    target_state?: string;
+}
+/** The instantiate body: `{}` without overrides, else a ticket document. */
+export declare function overrideDocument(overrides: TemplateOverrides): Record<string, unknown>;
+/**
+ * Run a ticket template: exactly one POST. The authenticated client sends
+ * writes without transport retries; a failed send stays uncertain here.
+ */
+export declare function runTemplate(client: Pick<CommandContext['client'], 'post'>, uuid: string, overrides?: TemplateOverrides): Promise<TemplateRunResult>;
+export interface TemplateCommandDeps {
+    contextFactory: () => Promise<CommandContext>;
+    stdout: (text: string) => void;
+    stderr: (text: string) => void;
+    setExitCode: (code: number) => void;
+}
+/** `bakers dropsh template run <uuid> [--<field> <value>]…`. */
+export declare function registerTemplateCommand(program: Command, deps: TemplateCommandDeps): void;

package/dist/src/template.js

@@ -0,0 +1,105 @@
+import { HttpError } from 'dropsh/plugin';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const RELATIONSHIP_TYPES = {
+    project_id: 'bb_project--bb_project',
+    conductor_id: 'bb_conductor--bb_conductor',
+    labels: 'bb_term--bb_labels',
+};
+/** The instantiate body: `{}` without overrides, else a ticket document. */
+export function overrideDocument(overrides) {
+    const attributes = {};
+    for (const key of ['title', 'description', 'workflow']) {
+        if (overrides[key] !== undefined)
+            attributes[key] = overrides[key];
+    }
+    const relationships = {};
+    for (const key of ['project_id', 'conductor_id']) {
+        const id = overrides[key];
+        if (id !== undefined)
+            relationships[key] = { data: { type: RELATIONSHIP_TYPES[key], id } };
+    }
+    if (overrides.labels !== undefined) {
+        relationships.labels = {
+            data: overrides.labels.map((id) => ({
+                type: RELATIONSHIP_TYPES.labels,
+                id,
+            })),
+        };
+    }
+    const data = { type: 'bb_ticket--bb_ticket' };
+    if (Object.keys(attributes).length > 0)
+        data.attributes = attributes;
+    if (Object.keys(relationships).length > 0)
+        data.relationships = relationships;
+    const document = { data };
+    if (overrides.target_state !== undefined)
+        document.meta = { target_state: overrides.target_state };
+    return Object.keys(data).length > 1 || document.meta ? document : {};
+}
+const REASONS = {
+    400: 'The server rejected the request',
+    403: 'You are not allowed to run this template',
+    404: 'Template not found',
+    422: 'The template or its overrides are invalid and cannot produce a ticket',
+};
+function detail(body) {
+    const errors = body?.errors;
+    const first = errors?.[0]?.detail;
+    return typeof first === 'string' ? ` (${first})` : '';
+}
+/**
+ * Run a ticket template: exactly one POST. The authenticated client sends
+ * writes without transport retries; a failed send stays uncertain here.
+ */
+export async function runTemplate(client, uuid, overrides = {}) {
+    if (!UUID.test(uuid)) {
+        throw new Error(`template must be a uuid, got "${uuid}"`);
+    }
+    let document;
+    try {
+        document = (await client.post(`bb_ticket_template/bb_ticket_template/${uuid}/instantiate`, overrideDocument(overrides)));
+    }
+    catch (error) {
+        if (error instanceof HttpError) {
+            if (error.status === 0) {
+                throw new Error('Network failure: the ticket may have been created. Check the project before running the template again.');
+            }
+            throw new Error(`${REASONS[error.status] ?? `HTTP ${error.status}`}${detail(error.body)}`);
+        }
+        throw error;
+    }
+    const id = document.data?.id;
+    if (!id)
+        throw new Error('The server answered without a ticket.');
+    return {
+        ticket_uuid: id,
+        identifier: document.data?.attributes?.identifier ?? null,
+        created: true,
+    };
+}
+/** `bakers dropsh template run <uuid> [--<field> <value>]…`. */
+export function registerTemplateCommand(program, deps) {
+    program
+        .command('template')
+        .description('Ticket templates')
+        .command('run <uuid>')
+        .description('Create a ticket from a template; each flag overrides one template default')
+        .option('--project_id <uuid>', 'project to create the ticket in (required for a workspace template)')
+        .option('--title <title>', 'ticket title; {{date}} and {{month}} are rendered')
+        .option('--description <text>', 'ticket description; {{date}} and {{month}} are rendered')
+        .option('--workflow <id>', 'ticket workflow, e.g. bb_feature')
+        .option('--labels <uuid...>', 'label uuids, replacing the template labels')
+        .option('--conductor_id <uuid>', 'conductor of the ticket project')
+        .option('--target_state <id>', 'state the new ticket is moved to')
+        .action(async (uuid, overrides) => {
+        try {
+            const { client } = await deps.contextFactory();
+            deps.stdout(`${JSON.stringify(await runTemplate(client, uuid, overrides))}\n`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            deps.stderr(`${JSON.stringify({ error: { message } })}\n`);
+            deps.setExitCode(1);
+        }
+    });
+}

package/dist/src/unpublished-comments.d.ts

@@ -0,0 +1,12 @@
+import { type HttpClient } from 'dropsh/plugin';
+/**
+ * Agent reads through `bakers dropsh` never see an unpublished comment.
+ *
+ * Accounts cannot tell an agent from its human, so the server lets the
+ * assignee read submitted reviews; the agent-facing shell filters them from
+ * GET collections, single reads, includes and the linkages pointing at them.
+ * A single read of one fails as dropsh's own client fails a 404.
+ * ponytail: keys on `attributes.status`; a sparse fieldset without `status`
+ * passes through.
+ */
+export declare function hideUnpublishedComments(http: HttpClient): HttpClient;

package/dist/src/unpublished-comments.js

@@ -0,0 +1,76 @@
+import { HttpError } from 'dropsh/plugin';
+/** An unpublished bakers.build comment: a review the ticket's assignee has not accepted. */
+function unpublished(resource) {
+    return (typeof resource?.type === 'string' &&
+        resource.type.startsWith('bb_comment--') &&
+        resource.attributes?.status === false);
+}
+/**
+ * Agent reads through `bakers dropsh` never see an unpublished comment.
+ *
+ * Accounts cannot tell an agent from its human, so the server lets the
+ * assignee read submitted reviews; the agent-facing shell filters them from
+ * GET collections, single reads, includes and the linkages pointing at them.
+ * A single read of one fails as dropsh's own client fails a 404.
+ * ponytail: keys on `attributes.status`; a sparse fieldset without `status`
+ * passes through.
+ */
+export function hideUnpublishedComments(http) {
+    return {
+        async send(request) {
+            const response = await http.send(request);
+            return request.method === 'GET' ? filter(response) : response;
+        },
+    };
+}
+function filter(response) {
+    let document;
+    try {
+        document = JSON.parse(response.body);
+    }
+    catch {
+        return response;
+    }
+    if (!document || typeof document !== 'object' || !('data' in document)) {
+        return response;
+    }
+    if (document.data &&
+        !Array.isArray(document.data) &&
+        unpublished(document.data)) {
+        const errors = [
+            {
+                status: '404',
+                title: 'Not Found',
+                detail: 'The comment is not published.',
+            },
+        ];
+        throw new HttpError(404, 'HTTP 404', { errors });
+    }
+    const hidden = new Set();
+    const keep = (list) => list.filter((resource) => {
+        if (!unpublished(resource))
+            return true;
+        hidden.add(`${resource.type}:${resource.id}`);
+        return false;
+    });
+    if (Array.isArray(document.data))
+        document.data = keep(document.data);
+    if (Array.isArray(document.included))
+        document.included = keep(document.included);
+    if (hidden.size === 0)
+        return response;
+    const primary = Array.isArray(document.data)
+        ? document.data
+        : [document.data];
+    for (const resource of [
+        ...primary,
+        ...(document.included ?? []),
+    ]) {
+        for (const relationship of Object.values(resource?.relationships ?? {})) {
+            if (Array.isArray(relationship?.data)) {
+                relationship.data = relationship.data.filter((link) => !hidden.has(`${link.type}:${link.id}`));
+            }
+        }
+    }
+    return { ...response, body: JSON.stringify(document) };
+}

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@bakers-build/addon-dropsh",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-next.38",
+  "description": "bakers.build dropsh command plugin: the `bakers dropsh` JSON:API shell bound to the split connection config.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./preset": "./dist/src/preset.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.key-tec.de/bakers-build/bakers-build.git",
+    "directory": "bakers-cli/addons/dropsh"
+  },
+  "dependencies": {
+    "@dropsh/plugin-jsonapi-schema": "^0.7.1",
+    "@dropsh/plugin-oauth2": "^0.7.5",
+    "commander": "^12.1.0",
+    "dropsh": "^0.7.5"
+  },
+  "peerDependencies": {
+    "@bakers-build/core": "^0.1.0-next.38"
+  }
+}