@pome-sh/cli 0.1.0 → 0.1.1

package/dist/src/twin-slack/errors.d.ts

@@ -1,16 +0,0 @@
-export declare class TwinError extends Error {
-    readonly status: number;
-    readonly code: string;
-    readonly extra?: Record<string, unknown> | undefined;
-    constructor(message: string, status: number, code: string, extra?: Record<string, unknown> | undefined);
-}
-export declare function slackError(code: string, status?: number, extra?: Record<string, unknown>): never;
-export declare function notFound(code?: string): never;
-export declare function validationFailed(code?: string, extra?: Record<string, unknown>): never;
-export declare function buildSlackErrorPayload(err: TwinError): {
-    ok: boolean;
-    error: string;
-};
-export declare function isSqliteConstraintError(err: unknown): boolean;
-/** Map SQLite UNIQUE violations to Slack-shaped domain errors for concurrent requests. */
-export declare function twinErrorFromSqliteConstraint(method: string, err: unknown): TwinError | null;

package/dist/src/twin-slack/errors.js

@@ -1,60 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// TwinError carries an HTTP status + Slack-shaped error code. The HTTP layer
-// in `app.ts` translates this into `{ok:false, error:<code>}` with the right
-// status. Common codes pulled from real Slack docs:
-//   - channel_not_found, user_not_found, message_not_found
-//   - not_in_channel, already_in_channel, cant_kick_self, cant_leave_general
-//   - is_archived, name_taken, restricted_action
-//   - invalid_auth, not_authed, missing_scope
-//   - cant_delete_message, cant_update_message, edit_window_closed
-//   - invalid_arguments, invalid_array_arg, invalid_cursor
-//   - rate_limited, internal_error
-export class TwinError extends Error {
-    status;
-    code;
-    extra;
-    constructor(message, status, code, extra) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.extra = extra;
-    }
-}
-export function slackError(code, status = 400, extra) {
-    throw new TwinError(code, status, code, extra);
-}
-export function notFound(code = "not_found") {
-    throw new TwinError(code, 404, code);
-}
-export function validationFailed(code = "invalid_arguments", extra) {
-    throw new TwinError(code, 400, code, extra);
-}
-export function buildSlackErrorPayload(err) {
-    return {
-        ok: false,
-        error: err.code,
-        ...(err.extra ?? {}),
-    };
-}
-export function isSqliteConstraintError(err) {
-    if (!err || typeof err !== "object")
-        return false;
-    const code = err.code ?? "";
-    return code.startsWith("SQLITE_CONSTRAINT");
-}
-/** Map SQLite UNIQUE violations to Slack-shaped domain errors for concurrent requests. */
-export function twinErrorFromSqliteConstraint(method, err) {
-    if (!isSqliteConstraintError(err))
-        return null;
-    const message = err instanceof Error ? err.message : String(err);
-    if (method === "conversations.create" || message.includes("channels_name_idx")) {
-        return new TwinError("name_taken", 409, "name_taken");
-    }
-    if (method.startsWith("reactions.") || message.includes("reactions")) {
-        return new TwinError("already_reacted", 400, "already_reacted");
-    }
-    if (method.startsWith("pins.") || message.includes("pins")) {
-        return new TwinError("already_pinned", 400, "already_pinned");
-    }
-    return new TwinError("internal_error", 500, "internal_error", { warning: message });
-}

package/dist/src/twin-slack/index.d.ts

@@ -1,8 +0,0 @@
-export { createSlackTwinApp } from "./app.js";
-export { SlackDomain } from "./domain.js";
-export { openSlackTwinDatabase, migrate, resetDatabase } from "./db.js";
-export { createRecorder } from "./recorder.js";
-export { seedSchema, parseSeed, loadSeedFromEnv, defaultSeedState } from "./seed.js";
-export { toolDefinitions, listTools, listToolsForMcp, executeTool, MUTATING_TOOL_NAMES, isMutatingTool } from "./tools.js";
-export { twinBuildInfo } from "./build-info.js";
-export type { BookmarkRow, ChannelMemberRow, ChannelRow, FileRow, MessageRow, PinRow, ReactionRow, Recorder, RecorderEvent, ScheduledMessageRow, SlackStateSeed, SlackTwinDatabase, UserRow, WorkspaceRow, } from "./types.js";

package/dist/src/twin-slack/index.js

@@ -1,8 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-export { createSlackTwinApp } from "./app.js";
-export { SlackDomain } from "./domain.js";
-export { openSlackTwinDatabase, migrate, resetDatabase } from "./db.js";
-export { createRecorder } from "./recorder.js";
-export { seedSchema, parseSeed, loadSeedFromEnv, defaultSeedState } from "./seed.js";
-export { toolDefinitions, listTools, listToolsForMcp, executeTool, MUTATING_TOOL_NAMES, isMutatingTool } from "./tools.js";
-export { twinBuildInfo } from "./build-info.js";

package/dist/src/twin-slack/mcp.d.ts

@@ -1,17 +0,0 @@
-import type { Context } from "hono";
-import type { SlackDomain } from "./domain.js";
-import type { Recorder } from "./types.js";
-export type McpDeps = {
-    domain: SlackDomain;
-    recorder?: Recorder;
-    runId: string;
-};
-export declare function mcpMethodNotAllowed(c: Context): Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: null;
-    error: {
-        code: number;
-        message: string;
-    };
-}, 405, "json">;
-export declare function handleMcpRequest(c: Context, deps: McpDeps): Promise<Response>;

package/dist/src/twin-slack/mcp.js

@@ -1,226 +0,0 @@
-import { z } from "zod";
-import { twinBuildInfo } from "./build-info.js";
-import { TwinError, twinErrorFromSqliteConstraint } from "./errors.js";
-import { executeTool, isMutatingTool, listToolsForMcp, toolDefinitions } from "./tools.js";
-import { requestId } from "./util.js";
-const PARSE_ERROR = -32700;
-const INVALID_REQUEST = -32600;
-const METHOD_NOT_FOUND = -32601;
-const INVALID_PARAMS = -32602;
-const INTERNAL_ERROR = -32603;
-const DEFAULT_PROTOCOL_VERSION = "2025-06-18";
-const SUPPORTED_PROTOCOL_VERSIONS = new Set(["2024-11-05", "2025-03-26", "2025-06-18"]);
-export function mcpMethodNotAllowed(c) {
-    return c.json({ jsonrpc: "2.0", id: null, error: { code: METHOD_NOT_FOUND, message: "Method not allowed in stateless mode" } }, 405, { Allow: "POST" });
-}
-export async function handleMcpRequest(c, deps) {
-    let body;
-    try {
-        body = await c.req.json();
-    }
-    catch {
-        return jsonRpcErrorResponse(null, PARSE_ERROR, "Problems parsing JSON");
-    }
-    if (Array.isArray(body)) {
-        if (body.length === 0) {
-            return jsonRpcErrorResponse(null, INVALID_REQUEST, "Invalid Request");
-        }
-        const out = [];
-        for (const message of body) {
-            const response = await dispatch(message, deps, c);
-            if (response)
-                out.push(response);
-        }
-        if (out.length === 0)
-            return new Response(null, { status: 202 });
-        return Response.json(out, { status: 200, headers: { "content-type": "application/json" } });
-    }
-    const response = await dispatch(body, deps, c);
-    if (!response)
-        return new Response(null, { status: 202 });
-    return Response.json(response, { status: 200, headers: { "content-type": "application/json" } });
-}
-async function dispatch(message, deps, c) {
-    if (!isObject(message))
-        return errorEnvelope(null, INVALID_REQUEST, "Invalid Request");
-    if (message.jsonrpc !== "2.0" || typeof message.method !== "string") {
-        return errorEnvelope(idOf(message), INVALID_REQUEST, "Invalid Request");
-    }
-    const method = message.method;
-    const params = isObject(message.params) ? message.params : {};
-    const rawId = message.id;
-    if (rawId === undefined || rawId === null)
-        return null;
-    if (typeof rawId !== "string" && typeof rawId !== "number") {
-        return errorEnvelope(null, INVALID_REQUEST, "Invalid Request: id must be string or number");
-    }
-    const id = rawId;
-    try {
-        switch (method) {
-            case "initialize":
-                return { jsonrpc: "2.0", id, result: buildInitializeResult(params) };
-            case "ping":
-                return { jsonrpc: "2.0", id, result: {} };
-            case "tools/list":
-                return { jsonrpc: "2.0", id, result: { tools: listToolsForMcp() } };
-            case "tools/call":
-                return await handleToolsCall(id, params, deps, c);
-            default:
-                return errorEnvelope(id, METHOD_NOT_FOUND, `Method not found: ${method}`);
-        }
-    }
-    catch (err) {
-        return errorEnvelope(id, INTERNAL_ERROR, err instanceof Error ? err.message : "Internal error");
-    }
-}
-function buildInitializeResult(params) {
-    const requested = typeof params.protocolVersion === "string" ? params.protocolVersion : undefined;
-    const protocolVersion = requested && SUPPORTED_PROTOCOL_VERSIONS.has(requested) ? requested : DEFAULT_PROTOCOL_VERSION;
-    return {
-        protocolVersion,
-        capabilities: { tools: { listChanged: false } },
-        serverInfo: { name: "twin-slack", version: twinBuildInfo().version },
-    };
-}
-async function handleToolsCall(id, params, deps, c) {
-    const name = params.name;
-    const args = params.arguments === undefined || params.arguments === null
-        ? {}
-        : isObject(params.arguments)
-            ? params.arguments
-            : undefined;
-    if (typeof name !== "string" || name.length === 0 || args === undefined) {
-        return errorEnvelope(id, INVALID_PARAMS, "Invalid params: expected { name: string, arguments?: object }");
-    }
-    if (!toolDefinitions.some((t) => t.name === name)) {
-        return {
-            jsonrpc: "2.0",
-            id,
-            result: makeToolErrorResult({ ok: false, error: "unknown_tool" }),
-        };
-    }
-    const started = Date.now();
-    const recordedRequestBody = { tool: name, arguments: args };
-    let delta = null;
-    let status = 200;
-    let responseBody = null;
-    let toolError = null;
-    let mcpResult;
-    try {
-        const session = c.get("session");
-        const actor = { login: session?.login };
-        const value = executeTool(deps.domain, name, args, (d) => {
-            delta = d;
-        }, actor);
-        responseBody = wrapSlackOk(value);
-        mcpResult = { content: [{ type: "text", text: jsonText(responseBody) }] };
-    }
-    catch (err) {
-        if (err instanceof TwinError) {
-            status = err.status;
-            const slackErr = { ok: false, error: err.code };
-            responseBody = slackErr;
-            toolError = err.code;
-            mcpResult = { content: [{ type: "text", text: jsonText(slackErr) }], isError: true };
-        }
-        else if (err instanceof z.ZodError) {
-            status = 422;
-            const slackErr = {
-                ok: false,
-                error: "invalid_arguments",
-                response_metadata: {
-                    messages: err.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`),
-                },
-            };
-            responseBody = slackErr;
-            toolError = "invalid_arguments";
-            mcpResult = { content: [{ type: "text", text: jsonText(slackErr) }], isError: true };
-        }
-        else {
-            const mapped = twinErrorFromSqliteConstraint(name, err);
-            if (mapped) {
-                status = mapped.status;
-                const slackErr = { ok: false, error: mapped.code };
-                responseBody = slackErr;
-                toolError = mapped.code;
-                mcpResult = { content: [{ type: "text", text: jsonText(slackErr) }], isError: true };
-            }
-            else {
-                status = 500;
-                const message = err instanceof Error ? err.message : "Internal Server Error";
-                const slackErr = { ok: false, error: "internal_error", warning: message };
-                responseBody = slackErr;
-                toolError = message;
-                mcpResult = { content: [{ type: "text", text: jsonText(slackErr) }], isError: true };
-            }
-        }
-    }
-    recordToolCall(c, deps, {
-        started,
-        status,
-        requestBody: recordedRequestBody,
-        responseBody,
-        mutation: status < 400 && isMutatingTool(name),
-        stateDelta: status < 400 ? delta : null,
-        error: toolError,
-    });
-    return { jsonrpc: "2.0", id, result: mcpResult };
-}
-function recordToolCall(c, deps, fields) {
-    if (!deps.recorder)
-        return;
-    const reqId = requestId();
-    deps.recorder.record({
-        ts: new Date().toISOString(),
-        run_id: deps.runId,
-        twin: "slack",
-        request_id: reqId,
-        correlation_id: reqId,
-        scenario_step_id: c.req.header("x-pome-scenario-step-id") ?? null,
-        step_id: null,
-        tool_call_id: null,
-        method: c.req.method,
-        path: new URL(c.req.url).pathname,
-        request_body: fields.requestBody,
-        status: fields.status,
-        response_body: fields.responseBody,
-        latency_ms: Date.now() - fields.started,
-        fidelity: "semantic",
-        state_mutation: fields.mutation,
-        state_delta: fields.stateDelta,
-        error: fields.error,
-    });
-}
-function makeToolErrorResult(payload) {
-    return { content: [{ type: "text", text: jsonText(payload) }], isError: true };
-}
-function wrapSlackOk(value) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        const obj = value;
-        if ("ok" in obj)
-            return obj;
-        return { ok: true, ...obj };
-    }
-    return { ok: true, result: value };
-}
-function errorEnvelope(id, code, message) {
-    return { jsonrpc: "2.0", id, error: { code, message } };
-}
-function jsonRpcErrorResponse(id, code, message) {
-    return Response.json(errorEnvelope(id, code, message), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-    });
-}
-function idOf(message) {
-    const id = message.id;
-    if (typeof id === "string" || typeof id === "number")
-        return id;
-    return null;
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function jsonText(value) {
-    return JSON.stringify(value);
-}

package/dist/src/twin-slack/recorder.d.ts

@@ -1,2 +0,0 @@
-import type { Recorder } from "./types.js";
-export declare function createRecorder(): Recorder;

package/dist/src/twin-slack/recorder.js

@@ -1,15 +0,0 @@
-import { redactEvent } from "../recorder/redaction.js";
-// In-memory, run-scoped recorder for the twin pod. Events live for the
-// lifetime of the machine — discarded when the sandbox shuts down (DELETE
-// /v1/sessions/:id or 30-min TTL).
-export function createRecorder() {
-    const items = [];
-    return {
-        record(event) {
-            items.push(redactEvent(event));
-        },
-        events() {
-            return [...items];
-        },
-    };
-}

package/dist/src/twin-slack/seed.d.ts

@@ -1,49 +0,0 @@
-import { z } from "zod";
-import type { SlackStateSeed } from "./types.js";
-export declare const seedSchema: z.ZodObject<{
-    team: z.ZodPrefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodDefault<z.ZodString>;
-        domain: z.ZodDefault<z.ZodString>;
-    }, z.core.$strip>>;
-    users: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        real_name: z.ZodDefault<z.ZodString>;
-        email: z.ZodOptional<z.ZodString>;
-        is_bot: z.ZodDefault<z.ZodBoolean>;
-        is_admin: z.ZodDefault<z.ZodBoolean>;
-        tz: z.ZodDefault<z.ZodString>;
-        profile: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>>;
-    channels: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        is_private: z.ZodDefault<z.ZodBoolean>;
-        topic: z.ZodDefault<z.ZodString>;
-        purpose: z.ZodDefault<z.ZodString>;
-        creator: z.ZodOptional<z.ZodString>;
-        members: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        messages: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            ts: z.ZodOptional<z.ZodString>;
-            user: z.ZodString;
-            text: z.ZodString;
-            thread_ts: z.ZodOptional<z.ZodString>;
-            reactions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                user: z.ZodString;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export declare function parseSeed(input: unknown): SlackStateSeed;
-/**
- * Boot-time seed loader: prefer `POME_SEED_JSON` env (set by the cloud
- * control-plane from the CLI-supplied scenario seed). Accepts both the flat
- * shape and the cloud's provider-scoped envelope `{slack:{seed:...}}`. Falls
- * back to `defaultSeedState()` when env is absent. Throws on malformed JSON
- * or schema-invalid seed so a misconfigured cloud deploy fails healthz
- * rather than silently booting with the default world.
- */
-export declare function loadSeedFromEnv(env?: NodeJS.ProcessEnv): SlackStateSeed;
-export declare function defaultSeedState(): SlackStateSeed;

package/dist/src/twin-slack/seed.js

@@ -1,139 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-import { z } from "zod";
-// Slack seed schema. Matches `slackSeedStateSchema` in `@pome-sh/shared-types`
-// shape-for-shape. Minimum bootstrap is `{}` — every nested field has defaults
-// and every top-level list defaults to `[]`.
-export const seedSchema = z.object({
-    team: z
-        .object({
-        id: z.string().regex(/^T[A-Z0-9_]+$/).optional(),
-        name: z.string().default("Pome Twin Workspace"),
-        domain: z.string().default("pome-twin"),
-    })
-        .prefault({}),
-    users: z
-        .array(z.object({
-        id: z.string().regex(/^[UB][A-Z0-9_]+$/).optional(),
-        name: z.string().min(1),
-        real_name: z.string().default(""),
-        email: z.string().email().optional(),
-        is_bot: z.boolean().default(false),
-        is_admin: z.boolean().default(false),
-        tz: z.string().default("America/Los_Angeles"),
-        profile: z.record(z.string(), z.unknown()).default({}),
-    }))
-        .default([]),
-    channels: z
-        .array(z.object({
-        id: z.string().regex(/^[CGDM][A-Z0-9_]+$/).optional(),
-        name: z.string().regex(/^[a-z0-9_-]{1,80}$/),
-        is_private: z.boolean().default(false),
-        topic: z.string().default(""),
-        purpose: z.string().default(""),
-        creator: z.string().optional(),
-        members: z.array(z.string()).default([]),
-        messages: z
-            .array(z.object({
-            ts: z.string().optional(),
-            user: z.string(),
-            text: z.string(),
-            thread_ts: z.string().optional(),
-            reactions: z
-                .array(z.object({ name: z.string(), user: z.string() }))
-                .default([]),
-        }))
-            .default([]),
-    }))
-        .default([]),
-});
-export function parseSeed(input) {
-    return seedSchema.parse(input);
-}
-/**
- * Boot-time seed loader: prefer `POME_SEED_JSON` env (set by the cloud
- * control-plane from the CLI-supplied scenario seed). Accepts both the flat
- * shape and the cloud's provider-scoped envelope `{slack:{seed:...}}`. Falls
- * back to `defaultSeedState()` when env is absent. Throws on malformed JSON
- * or schema-invalid seed so a misconfigured cloud deploy fails healthz
- * rather than silently booting with the default world.
- */
-export function loadSeedFromEnv(env = process.env) {
-    const raw = env.POME_SEED_JSON;
-    if (raw === undefined || raw === "") {
-        return defaultSeedState();
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        throw new Error(`POME_SEED_JSON is not valid JSON: ${err.message}`);
-    }
-    // Unwrap provider-scoped envelope if present.
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        const obj = parsed;
-        if (obj.slack && typeof obj.slack === "object" && obj.slack !== null) {
-            const slack = obj.slack;
-            if ("seed" in slack) {
-                return parseSeed(slack.seed);
-            }
-        }
-    }
-    return parseSeed(parsed);
-}
-export function defaultSeedState() {
-    return {
-        team: {
-            id: "T_POME",
-            name: "Pome Twin Workspace",
-            domain: "pome-twin",
-        },
-        users: [
-            {
-                id: "U_PRIMARY",
-                name: "pome-agent",
-                real_name: "Pome Agent",
-                email: "pome-agent@pome-twin.slack.com",
-                is_bot: false,
-                is_admin: true,
-            },
-            {
-                id: "U_ALICE",
-                name: "alice",
-                real_name: "Alice",
-                email: "alice@pome-twin.slack.com",
-            },
-            {
-                id: "U_BOB",
-                name: "bob",
-                real_name: "Bob",
-                email: "bob@pome-twin.slack.com",
-            },
-        ],
-        channels: [
-            {
-                id: "C_GENERAL",
-                name: "general",
-                is_private: false,
-                topic: "Company-wide announcements and chatter.",
-                purpose: "This channel is for company-wide communication.",
-                creator: "U_PRIMARY",
-                members: ["U_PRIMARY", "U_ALICE", "U_BOB"],
-                messages: [
-                    { user: "U_ALICE", text: "morning team" },
-                    { user: "U_BOB", text: "morning :wave:" },
-                ],
-            },
-            {
-                id: "C_RANDOM",
-                name: "random",
-                is_private: false,
-                topic: "Non-work chatter and water cooler talk.",
-                purpose: "A place for non-work-related flimflam.",
-                creator: "U_PRIMARY",
-                members: [],
-                messages: [],
-            },
-        ],
-    };
-}