@tacitai/mcp-server 0.1.0

package/dist/setup.js

@@ -0,0 +1,211 @@
+"use strict";
+// SPDX-License-Identifier: MIT
+/**
+ * setup — wizard subcommand for @tacit/mcp-server
+ *
+ * Usage:
+ *   node dist/index.js setup [--dry-run] [--api-url <url>] [--token <token>] [--smoke]
+ *
+ * Contract (§2.1 of sparc_specification.md, Phase-2 QE resolutions):
+ *   F1 smoke   — calls tacit_synthesize via getClient()/postSSE; exits non-zero on empty/error.
+ *   F2 env-ref — writes TACIT_TOKEN as the LITERAL placeholder "${TACIT_TOKEN}" (never the real value).
+ *   Merge      — deep-merges ONLY mcpServers.tacit; all other keys preserved.
+ *   Idempotent — same --api-url → byte-identical mcp.json.
+ *   Secrets    — token NEVER written to any output stream.
+ *
+ * Security invariants:
+ *   - Token is NEVER logged or written to disk.
+ *   - Authorization header value excluded from all logging paths.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = setup;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const client_js_1 = require("./client.js");
+function parseArgs(argv) {
+    const opts = {
+        dryRun: false,
+        apiUrl: null,
+        token: null,
+        smoke: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--dry-run') {
+            opts.dryRun = true;
+        }
+        else if (arg === '--smoke') {
+            opts.smoke = true;
+        }
+        else if (arg === '--api-url') {
+            const next = argv[i + 1];
+            if (!next || next.startsWith('--')) {
+                process.stderr.write('Error: --api-url requires a value\n');
+                process.exit(1);
+            }
+            opts.apiUrl = next;
+            i++;
+        }
+        else if (arg === '--token') {
+            const next = argv[i + 1];
+            if (!next || next.startsWith('--')) {
+                process.stderr.write('Error: --token requires a value\n');
+                process.exit(1);
+            }
+            opts.token = next;
+            i++;
+        }
+    }
+    return opts;
+}
+function claudeDir() {
+    return path.join(os.homedir(), '.claude');
+}
+function mcpJsonPath() {
+    return path.join(claudeDir(), 'mcp.json');
+}
+function readExistingConfig() {
+    const p = mcpJsonPath();
+    if (!fs.existsSync(p)) {
+        return {};
+    }
+    try {
+        const raw = fs.readFileSync(p, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        // Non-parseable file — start fresh but preserve as-is would corrupt; warn and start fresh.
+        process.stderr.write(`Warning: ~/.claude/mcp.json could not be parsed; will overwrite with merged config.\n`);
+        return {};
+    }
+}
+function buildTacitEntry(apiUrl) {
+    return {
+        command: 'npx',
+        args: ['-y', '@tacit/mcp-server'],
+        env: {
+            // F2: literal placeholder — Claude Code expands ${VAR} at launch; real token NEVER on disk.
+            TACIT_TOKEN: '${TACIT_TOKEN}',
+            // TACIT_API_URL is a non-secret URL; written as-is.
+            TACIT_API_URL: apiUrl,
+        },
+    };
+}
+function mergeConfig(existing, tacitEntry) {
+    const servers = existing.mcpServers ?? {};
+    // Deep-merge ONLY tacit key; all other mcpServers entries and top-level keys preserved.
+    const merged = {
+        ...existing,
+        mcpServers: {
+            ...servers,
+            tacit: tacitEntry,
+        },
+    };
+    return merged;
+}
+function configToBytes(cfg) {
+    return JSON.stringify(cfg, null, 2) + '\n';
+}
+// ─── Smoke synthesis ──────────────────────────────────────────────────────────
+const SMOKE_QUERY = 'What is in this knowledge base?';
+async function runSmoke(apiUrl, token) {
+    const client = new client_js_1.TacitClient({
+        apiUrl,
+        token: token ?? process.env['TACIT_TOKEN'] ?? '',
+    });
+    let body = '';
+    try {
+        // F1: use existing postSSE path (NOT a raw fetch).
+        for await (const chunk of client.postSSE('/api/v1/mind/synthesize/stream', {
+            query: SMOKE_QUERY,
+        })) {
+            body += chunk;
+        }
+    }
+    catch (err) {
+        const msg = err instanceof client_js_1.TacitApiError
+            ? `API error ${err.statusCode}: ${err.body}`
+            : err instanceof Error ? err.message : String(err);
+        process.stderr.write(`SMOKE_SYNTH_FAIL: ${msg}\n`);
+        process.exit(1);
+    }
+    if (!body || body.length === 0) {
+        process.stderr.write('SMOKE_SYNTH_FAIL: empty response body\n');
+        process.exit(1);
+    }
+    // Print charcount for oracle D6 verification.
+    process.stdout.write(`SMOKE_SYNTH_OK:${body.length}\n`);
+    process.exit(0);
+}
+// ─── Main export ──────────────────────────────────────────────────────────────
+async function setup(argv) {
+    const opts = parseArgs(argv);
+    // Resolve api-url: flag > env. Token: flag > env (never logged).
+    const apiUrl = opts.apiUrl ?? process.env['TACIT_API_URL'] ?? null;
+    const token = opts.token ?? process.env['TACIT_TOKEN'] ?? null;
+    if (!apiUrl) {
+        process.stderr.write('Error: no API URL configured.\n' +
+            'Provide --api-url <url> or set TACIT_API_URL environment variable.\n' +
+            'Example: node dist/index.js setup --api-url http://localhost:7473 --token <your-token>\n');
+        process.exit(1);
+    }
+    const tacitEntry = buildTacitEntry(apiUrl);
+    const existing = readExistingConfig();
+    const merged = mergeConfig(existing, tacitEntry);
+    const output = configToBytes(merged);
+    // D10: emit confirmation string BEFORE writing (also printed in dry-run).
+    process.stdout.write('Writing tacit entry to ~/.claude/mcp.json...\n');
+    if (opts.dryRun) {
+        process.stdout.write('(dry-run) Would write:\n');
+        process.stdout.write(output);
+        process.exit(0);
+        return;
+    }
+    // Create ~/.claude with mode 0700 if absent.
+    const dir = claudeDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    const dest = mcpJsonPath();
+    fs.writeFileSync(dest, output, { encoding: 'utf-8', mode: 0o600 });
+    if (opts.smoke) {
+        await runSmoke(apiUrl, token);
+        // runSmoke calls process.exit internally; return here for type safety.
+        return;
+    }
+    process.exit(0);
+}

package/dist/tools/artifacts.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Artifact tools:
+ *   tacit_artifact_list    — GET  /api/v1/artifacts
+ *   tacit_artifact_create  — POST /api/v1/artifacts  (career-scoped handler)
+ *   tacit_artifact_update  — PATCH /api/v1/artifacts/:id
+ *   tacit_artifact_publish — POST  /api/v1/artifacts/:id/publish
+ *
+ * No public single-GET /api/v1/artifacts/:id (HMAC-internal only; excluded per brief).
+ *
+ * tacit_artifact_create constraints (D-19/brief KR1):
+ *   - Routes to handlers::artifacts_career::create_artifact
+ *   - Backend CreateArtifactRequest accepts ONLY: title, domain, output_format,
+ *     portfolio_id, structured_metadata. portfolio_id is REQUIRED (403 without it).
+ *   - artifact_kind is hardcoded server-side (GENERIC) — the client must NOT send it.
+ *   - The artifact body is populated server-side from structured_metadata
+ *     (e.g. full_posting_text); the client does NOT send a content field.
+ *   - This tool always sends "domain":"CAREER" in the request body.
+ */
+import { z } from 'zod';
+import { TacitClient } from '../client.js';
+export interface ToolRequest {
+    execute(): Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+export declare const artifactListInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    status?: string | undefined;
+    offset?: number | undefined;
+}, {
+    limit?: number | undefined;
+    status?: string | undefined;
+    offset?: number | undefined;
+}>;
+export type ArtifactListInput = z.infer<typeof artifactListInputSchema>;
+export declare const ARTIFACT_LIST_TOOL_DEF: {
+    name: "tacit_artifact_list";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            limit: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            status: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+};
+export declare function buildArtifactListRequest(client: TacitClient, input: ArtifactListInput): ToolRequest;
+export declare function handleArtifactList(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const artifactCreateInputSchema: z.ZodObject<{
+    title: z.ZodString;
+    domain: z.ZodOptional<z.ZodString>;
+    portfolio_id: z.ZodString;
+    structured_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    portfolio_id: string;
+    title: string;
+    domain?: string | undefined;
+    structured_metadata?: Record<string, unknown> | undefined;
+}, {
+    portfolio_id: string;
+    title: string;
+    domain?: string | undefined;
+    structured_metadata?: Record<string, unknown> | undefined;
+}>;
+export type ArtifactCreateInput = z.infer<typeof artifactCreateInputSchema>;
+export declare const ARTIFACT_CREATE_TOOL_DEF: {
+    name: "tacit_artifact_create";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            title: {
+                type: string;
+                description: string;
+            };
+            domain: {
+                type: string;
+                description: string;
+            };
+            portfolio_id: {
+                type: string;
+                description: string;
+            };
+            structured_metadata: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildArtifactCreateRequest(client: TacitClient, input: ArtifactCreateInput): ToolRequest;
+export declare function handleArtifactCreate(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const artifactUpdateInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    content?: string | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+}, {
+    id: string;
+    content?: string | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+}>;
+export type ArtifactUpdateInput = z.infer<typeof artifactUpdateInputSchema>;
+export declare const ARTIFACT_UPDATE_TOOL_DEF: {
+    name: "tacit_artifact_update";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            tags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildArtifactUpdateRequest(client: TacitClient, input: ArtifactUpdateInput): ToolRequest;
+export declare function handleArtifactUpdate(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const artifactPublishInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type ArtifactPublishInput = z.infer<typeof artifactPublishInputSchema>;
+export declare const ARTIFACT_PUBLISH_TOOL_DEF: {
+    name: "tacit_artifact_publish";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildArtifactPublishRequest(client: TacitClient, input: ArtifactPublishInput): ToolRequest;
+export declare function handleArtifactPublish(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools/artifacts.js

@@ -0,0 +1,241 @@
+"use strict";
+// SPDX-License-Identifier: MIT
+/**
+ * Artifact tools:
+ *   tacit_artifact_list    — GET  /api/v1/artifacts
+ *   tacit_artifact_create  — POST /api/v1/artifacts  (career-scoped handler)
+ *   tacit_artifact_update  — PATCH /api/v1/artifacts/:id
+ *   tacit_artifact_publish — POST  /api/v1/artifacts/:id/publish
+ *
+ * No public single-GET /api/v1/artifacts/:id (HMAC-internal only; excluded per brief).
+ *
+ * tacit_artifact_create constraints (D-19/brief KR1):
+ *   - Routes to handlers::artifacts_career::create_artifact
+ *   - Backend CreateArtifactRequest accepts ONLY: title, domain, output_format,
+ *     portfolio_id, structured_metadata. portfolio_id is REQUIRED (403 without it).
+ *   - artifact_kind is hardcoded server-side (GENERIC) — the client must NOT send it.
+ *   - The artifact body is populated server-side from structured_metadata
+ *     (e.g. full_posting_text); the client does NOT send a content field.
+ *   - This tool always sends "domain":"CAREER" in the request body.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTIFACT_PUBLISH_TOOL_DEF = exports.artifactPublishInputSchema = exports.ARTIFACT_UPDATE_TOOL_DEF = exports.artifactUpdateInputSchema = exports.ARTIFACT_CREATE_TOOL_DEF = exports.artifactCreateInputSchema = exports.ARTIFACT_LIST_TOOL_DEF = exports.artifactListInputSchema = void 0;
+exports.buildArtifactListRequest = buildArtifactListRequest;
+exports.handleArtifactList = handleArtifactList;
+exports.buildArtifactCreateRequest = buildArtifactCreateRequest;
+exports.handleArtifactCreate = handleArtifactCreate;
+exports.buildArtifactUpdateRequest = buildArtifactUpdateRequest;
+exports.handleArtifactUpdate = handleArtifactUpdate;
+exports.buildArtifactPublishRequest = buildArtifactPublishRequest;
+exports.handleArtifactPublish = handleArtifactPublish;
+const zod_1 = require("zod");
+const client_js_1 = require("../client.js");
+// ─── List ────────────────────────────────────────────────────────────────────
+exports.artifactListInputSchema = zod_1.z.object({
+    limit: zod_1.z.number().int().positive().optional().describe('Maximum artifacts to return'),
+    offset: zod_1.z.number().int().nonnegative().optional().describe('Pagination offset'),
+    status: zod_1.z.string().optional().describe('Filter by status (e.g. PUBLISHED, DRAFT)'),
+});
+exports.ARTIFACT_LIST_TOOL_DEF = {
+    name: 'tacit_artifact_list',
+    description: 'List artifacts from the Tacit workspace. Route: GET /api/v1/artifacts.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            limit: { type: 'number', description: 'Maximum artifacts to return' },
+            offset: { type: 'number', description: 'Pagination offset' },
+            status: { type: 'string', description: 'Filter by status' },
+        },
+        required: [],
+    },
+};
+function buildArtifactListRequest(client, input) {
+    return {
+        async execute() {
+            const { limit, offset, status } = input;
+            try {
+                const params = {};
+                if (limit !== undefined)
+                    params['limit'] = limit;
+                if (offset !== undefined)
+                    params['offset'] = offset;
+                if (status)
+                    params['status'] = status;
+                // GET /api/v1/artifacts
+                const result = await client.get('/api/v1/artifacts', params);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts');
+            }
+        },
+    };
+}
+async function handleArtifactList(args) {
+    const parsed = exports.artifactListInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildArtifactListRequest((0, client_js_1.getClient)(), parsed.data).execute();
+}
+// ─── Create ──────────────────────────────────────────────────────────────────
+exports.artifactCreateInputSchema = zod_1.z.object({
+    title: zod_1.z.string().min(1).describe('Artifact title'),
+    domain: zod_1.z.string().optional().describe('Domain (always overridden to CAREER by this tool)'),
+    portfolio_id: zod_1.z.string().min(1).describe('Portfolio to associate with (REQUIRED by the backend; 403 without it)'),
+    structured_metadata: zod_1.z
+        .record(zod_1.z.unknown())
+        .optional()
+        .describe('Structured metadata; the artifact body is populated server-side from this (e.g. full_posting_text)'),
+});
+exports.ARTIFACT_CREATE_TOOL_DEF = {
+    name: 'tacit_artifact_create',
+    description: 'Create a career-scoped artifact in Tacit (always domain CAREER). ' +
+        'Accepts a title plus an optional structured_metadata object; portfolio_id is required. ' +
+        'The artifact body is populated server-side from structured_metadata (e.g. full_posting_text), ' +
+        'and artifact_kind is hardcoded server-side — neither is sent by this tool. ' +
+        'Route: POST /api/v1/artifacts (handlers::artifacts_career::create_artifact).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            title: { type: 'string', description: 'Artifact title' },
+            domain: { type: 'string', description: 'Domain (always CAREER for this tool)' },
+            portfolio_id: { type: 'string', description: 'Portfolio to associate with (REQUIRED; 403 without it)' },
+            structured_metadata: {
+                type: 'object',
+                description: 'Structured metadata; artifact body is populated server-side from this (e.g. full_posting_text)',
+            },
+        },
+        required: ['title', 'portfolio_id'],
+    },
+};
+function buildArtifactCreateRequest(client, input) {
+    return {
+        async execute() {
+            const { title, portfolio_id, structured_metadata } = input;
+            try {
+                // Backend CreateArtifactRequest accepts only title/domain/output_format/portfolio_id/structured_metadata.
+                // artifact_kind is hardcoded server-side; the body comes from structured_metadata.full_posting_text.
+                const body = {
+                    title,
+                    domain: 'CAREER',
+                    portfolio_id,
+                };
+                if (structured_metadata !== undefined)
+                    body['structured_metadata'] = structured_metadata;
+                // POST /api/v1/artifacts
+                const result = await client.post('/api/v1/artifacts', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts');
+            }
+        },
+    };
+}
+async function handleArtifactCreate(args) {
+    const parsed = exports.artifactCreateInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildArtifactCreateRequest((0, client_js_1.getClient)(), parsed.data).execute();
+}
+// ─── Update ──────────────────────────────────────────────────────────────────
+exports.artifactUpdateInputSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).describe('Artifact UUID to update'),
+    title: zod_1.z.string().optional().describe('New title'),
+    content: zod_1.z.string().optional().describe('New content body'),
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Updated tags'),
+});
+exports.ARTIFACT_UPDATE_TOOL_DEF = {
+    name: 'tacit_artifact_update',
+    description: 'Update a career artifact by id. Route: PATCH /api/v1/artifacts/:id.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Artifact UUID to update' },
+            title: { type: 'string', description: 'New title' },
+            content: { type: 'string', description: 'New content body' },
+            tags: { type: 'array', items: { type: 'string' }, description: 'Updated tags' },
+        },
+        required: ['id'],
+    },
+};
+function buildArtifactUpdateRequest(client, input) {
+    return {
+        async execute() {
+            const { id, title, content, tags } = input;
+            try {
+                const body = {};
+                if (title !== undefined)
+                    body['title'] = title;
+                // API field is content_body (not content) — map here.
+                if (content !== undefined)
+                    body['content_body'] = content;
+                if (tags !== undefined)
+                    body['tags'] = tags;
+                // PATCH /api/v1/artifacts/:id
+                const result = await client.patch(`/api/v1/artifacts/${id}`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts/:id');
+            }
+        },
+    };
+}
+async function handleArtifactUpdate(args) {
+    const parsed = exports.artifactUpdateInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildArtifactUpdateRequest((0, client_js_1.getClient)(), parsed.data).execute();
+}
+// ─── Publish ─────────────────────────────────────────────────────────────────
+exports.artifactPublishInputSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).describe('Artifact UUID to publish'),
+});
+exports.ARTIFACT_PUBLISH_TOOL_DEF = {
+    name: 'tacit_artifact_publish',
+    description: 'Publish an artifact by id. Route: POST /api/v1/artifacts/:id/publish.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Artifact UUID to publish' },
+        },
+        required: ['id'],
+    },
+};
+function buildArtifactPublishRequest(client, input) {
+    return {
+        async execute() {
+            const { id } = input;
+            try {
+                // POST /api/v1/artifacts/:id/publish
+                const result = await client.post(`/api/v1/artifacts/${id}/publish`, {});
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts/:id/publish');
+            }
+        },
+    };
+}
+async function handleArtifactPublish(args) {
+    const parsed = exports.artifactPublishInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildArtifactPublishRequest((0, client_js_1.getClient)(), parsed.data).execute();
+}
+// ─── Shared error helper ──────────────────────────────────────────────────────
+function apiErrorResult(err, endpoint) {
+    if (err instanceof client_js_1.TacitApiError) {
+        return {
+            content: [{ type: 'text', text: `API error ${err.statusCode} on ${endpoint}: ${err.body}` }],
+            isError: true,
+        };
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+}