@nyuchi/mzizi-mcp 0.9.1 → 0.10.1

package/dist/issue-desk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-desk.d.ts","sourceRoot":"","sources":["../src/issue-desk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAGnC,OAAO,EAKL,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,MAAM,EAIZ,MAAM,mBAAmB,CAAA;AAE1B,cAAc,mBAAmB,CAAA;AAsCjC,qBAAa,SAAU,SAAQ,aAAa,CAAC,GAAG,CAAC;gBACnC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,GAAG;IAuD7C;;;;;;;;OAQG;IACG,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBjE,gEAAgE;IAC1D,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAO7C;;;;;;;;;;;;OAYG;IACG,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAwB1E;;;;;;OAMG;IACG,IAAI,CAAC,KAAK,SAAK,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAOzC,sDAAsD;IAChD,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;YAarD,OAAO;IAkDrB;;;;;;;;;;;;;;;OAeG;YACW,SAAS;IAsDvB;;;;;;;;;;;;;;OAcG;YACW,GAAG;IAmCjB,OAAO,CAAC,IAAI;CAWb"}

package/dist/issue-desk.js

@@ -0,0 +1,392 @@
+/**
+ * `IssueDesk` — one Durable Object per signed-in user, holding that person's
+ * issue reports and driving each one from "something is wrong" to an issue
+ * logged with fundi, which files it on GitHub and tracks it from there.
+ *
+ * WHY A DURABLE OBJECT, AND WHY PER USER
+ *
+ * `mzizi_report_issue` used to be a stub that errored on every input (issue
+ * #78). Wiring it to a fire-and-forget write would have fixed the error and
+ * kept the real problem: a bug report is not a message, it is a small piece of
+ * work with stages — reproduce it, write the fix, file it — and each stage is
+ * slow, can fail on its own, and is worth keeping.
+ *
+ * A stateless Worker cannot hold that. Every call would start from nothing, so
+ * a user who reported a flaky button on Tuesday and again on Thursday would be
+ * two strangers, and the second report could not say "this is the third time".
+ *
+ * Per USER rather than per report is the deliberate part. A per-report object
+ * would be simpler and would lose exactly the thing that makes the history
+ * useful: reports cluster by person, not by incident. The people who report
+ * problems tend to report several, in the same area, in the same voice, and the
+ * pattern across them is often the actual bug. Keying on the WorkOS subject
+ * (`idFromName(userId)`) means a returning user's earlier reports are already
+ * loaded when the next one arrives — context, not a lookup.
+ *
+ * It also draws the privacy boundary in the right place. One person's reports
+ * live in one object; there is no shared table to accidentally select across,
+ * and "show me my history" is the natural query rather than a filtered one.
+ *
+ * THE THREE STAGES, AND WHAT ACTUALLY WORKS TODAY
+ *
+ *   1. reproduce — delegate a run to fundi over the existing Service Binding.
+ *   2. draft     — turn the report plus whatever stage 1 learned into an issue
+ *                  body a maintainer can act on.
+ *   3. log       — hand that draft to fundi, which records it in the platform
+ *                  database and files the GitHub issue.
+ *
+ * Stated honestly, because the alternative is a pipeline that looks like it
+ * works: **fundi records a submitted task and parks it.** Its executors are not
+ * built (`executionStatus: "accepted-not-executed"`, see `fundi-a2a.ts`), so
+ * stage 1 today produces a task id and fundi's own note that it did not run.
+ * The desk records exactly that and the drafted issue says so. It does not
+ * claim a reproduction it does not have — a report asserting "reproduced" when
+ * nothing ran is worse than one that says nothing, because a maintainer will
+ * believe it.
+ *
+ * THIS WORKER NO LONGER TOUCHES GITHUB, AND HOLDS NO PAT
+ *
+ * Stage 3 used to be `POST https://api.github.com/repos/…/issues` from here,
+ * authorised with `env.GITHUB_TOKEN`. That secret was never set on this Worker
+ * and was never going to be — it belongs on `mzizi-fundi`, a separate Worker
+ * with a separate secret store, which is exactly why the gap stayed invisible
+ * for so long. Every report therefore reproduced, drafted, and parked at
+ * `drafted` with a note suggesting the reporter paste the body into GitHub by
+ * hand. That is a write sink with extra steps.
+ *
+ * The division of labour now:
+ *
+ *     this desk    reproduce, draft, log      (no GitHub, no PAT, no database)
+ *     fundi        record in D1, file the GitHub issue WITH the healing plan,
+ *                  and write that issue's lifecycle back onto the same row
+ *
+ * So the terminal stage is `logged`, not `filed`: at the instant this desk
+ * finishes, the issue is RECORDED — durably, where a maintainer and the console
+ * can both see it — and the GitHub issue follows on fundi's next heal pass. The
+ * desk learns the issue's number and URL when the report is next read, from
+ * fundi rather than from GitHub.
+ *
+ * An issue is never blocked on this Worker holding a credential again. The one
+ * remaining way stage 3 can fail is fundi being unreachable, and that failure
+ * parks the report at `drafted` with the body in hand and a `retry` that
+ * re-enters at exactly that stage.
+ */
+import { DurableObject } from "cloudflare:workers";
+import { createFundiCaller, fundiConfigured } from "./fundi-client.js";
+import { fetchIssueStatus, isTerminal, logIssueToFundi } from "./issue-log.js";
+import { defaultSkill, renderIssueBody, reproInstruction, issueTitle, } from "./issue-report.js";
+export * from "./issue-report.js";
+function toReport(r) {
+    return {
+        id: r.id,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at,
+        kind: r.kind,
+        component: r.component,
+        severity: r.severity,
+        message: r.message,
+        stage: r.stage,
+        repro: r.repro ? JSON.parse(r.repro) : null,
+        draft: r.draft,
+        fundiIssueId: r.fundi_issue_id,
+        issueStatus: r.issue_status,
+        issueUrl: r.issue_url,
+        error: r.error,
+    };
+}
+export class IssueDesk extends DurableObject {
+    constructor(ctx, env) {
+        super(ctx, env);
+        // `blockConcurrencyWhile` so no RPC observes a half-built schema. The DO is
+        // single-threaded per instance, which is also why the read-modify-write in
+        // `advance` below needs no locking of its own.
+        ctx.blockConcurrencyWhile(async () => {
+            ctx.storage.sql.exec(`
+        CREATE TABLE IF NOT EXISTS reports (
+          id          TEXT PRIMARY KEY,
+          created_at  TEXT NOT NULL,
+          updated_at  TEXT NOT NULL,
+          kind        TEXT NOT NULL,
+          component   TEXT,
+          severity    TEXT,
+          message     TEXT NOT NULL,
+          stage       TEXT NOT NULL,
+          repro       TEXT,
+          draft       TEXT,
+          fundi_issue_id INTEGER,
+          issue_status   TEXT,
+          issue_url   TEXT,
+          error       TEXT
+        );
+        CREATE INDEX IF NOT EXISTS reports_created_at ON reports (created_at DESC);
+      `);
+            // `CREATE TABLE IF NOT EXISTS` does NOTHING to a desk that already
+            // exists, and these desks are live: every person who has ever used
+            // `mzizi_report_issue` has a Durable Object holding their reports in the
+            // shape this class shipped with. The two columns above therefore appear
+            // in the CREATE (for a desk opened from now on) AND are added explicitly
+            // below (for every desk that already exists) — the CREATE alone would
+            // leave existing users on the old schema, with every read of the new
+            // columns throwing "no such column". That is the worst possible
+            // distribution of a failure: it lands only on the people who have used
+            // the feature before.
+            //
+            // So the columns are added explicitly, and `PRAGMA table_info` decides
+            // rather than a try/catch: a swallowed error here cannot tell "already
+            // added" apart from "storage is broken".
+            const existing = new Set(ctx.storage.sql
+                .exec(`PRAGMA table_info(reports)`)
+                .toArray()
+                .map((c) => c.name));
+            if (!existing.has("fundi_issue_id")) {
+                ctx.storage.sql.exec(`ALTER TABLE reports ADD COLUMN fundi_issue_id INTEGER`);
+            }
+            if (!existing.has("issue_status")) {
+                ctx.storage.sql.exec(`ALTER TABLE reports ADD COLUMN issue_status TEXT`);
+            }
+        });
+    }
+    /**
+     * Open a report and drive it as far as it will go in one call.
+     *
+     * Deliberately synchronous end-to-end rather than queued: an MCP tool call is
+     * a conversation turn, and returning "queued, ask again later" to an agent
+     * that has no reason to ask again is how a write sink becomes a black hole.
+     * The stages are bounded — one fundi submit, one fundi log — so the call
+     * stays inside a Worker's budget.
+     */
+    async open(input, caller) {
+        const now = new Date().toISOString();
+        const id = crypto.randomUUID();
+        this.ctx.storage.sql.exec(`INSERT INTO reports (id, created_at, updated_at, kind, component, severity, message, stage)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 'opened')`, id, now, now, input.kind, input.component ?? null, input.severity ?? null, input.message);
+        return this.advance(id, input, caller);
+    }
+    /** One report, or null. Scoped to this user by construction. */
+    async get(id) {
+        const rows = this.ctx.storage.sql
+            .exec(`SELECT * FROM reports WHERE id = ?`, id)
+            .toArray();
+        return rows[0] ? toReport(rows[0]) : null;
+    }
+    /**
+     * One report, with its issue status refreshed from fundi first.
+     *
+     * The desk and fundi hold two halves of one story: the desk knows what the
+     * reporter said, fundi knows what happened to the issue afterwards. Without
+     * this, a report would sit at `logged` for ever and the only honest answer to
+     * "what happened to my bug?" would be "look somewhere else" — which is the
+     * dead end the old GitHub path had, one layer along.
+     *
+     * Only on a single `get`, never on `list`: refreshing a list would be one
+     * fundi round trip per row, on a read someone does casually. And never for a
+     * report whose issue is already closed — there is nothing left to learn.
+     */
+    async getRefreshed(id, caller) {
+        const report = await this.get(id);
+        if (!report)
+            return null;
+        if (report.fundiIssueId == null || isTerminal(report.issueStatus))
+            return report;
+        const userToken = caller.userToken;
+        if (!userToken || !fundiConfigured(this.env))
+            return report;
+        const outcome = await fetchIssueStatus(createFundiCaller(this.env), async () => userToken, report.fundiIssueId);
+        // A refresh that fails costs the refresh. The report is the durable thing
+        // and it is right here; answering an error because a status read failed
+        // would be the tail wagging the dog.
+        if (!outcome.ok)
+            return report;
+        this.save(id, {
+            issue_status: outcome.issue.status,
+            issue_url: outcome.issue.githubIssueUrl,
+        });
+        return (await this.get(id));
+    }
+    /**
+     * This user's reports, newest first.
+     *
+     * The point of the whole design: an agent handling a new report can read what
+     * this person already said, and a maintainer can see whether a complaint is
+     * the first or the fourth.
+     */
+    async list(limit = 20) {
+        const rows = this.ctx.storage.sql
+            .exec(`SELECT * FROM reports ORDER BY created_at DESC LIMIT ?`, Math.min(limit, 100))
+            .toArray();
+        return rows.map(toReport);
+    }
+    /** Re-enter the pipeline at the stage that failed. */
+    async retry(id, caller) {
+        const existing = await this.get(id);
+        if (!existing)
+            return null;
+        return this.advance(id, {
+            kind: existing.kind,
+            message: existing.message,
+            component: existing.component ?? undefined,
+            severity: existing.severity ?? undefined,
+        }, caller);
+    }
+    // ── the pipeline ────────────────────────────────────────────────────────
+    async advance(id, input, caller) {
+        let report = (await this.get(id));
+        // Stage 1 — reproduce. Never fatal: a report whose reproduction could not
+        // run is still a report, and refusing to file it would lose the only
+        // signal a maintainer actually has.
+        if (report.stage === "opened" || report.stage === "failed") {
+            this.save(id, { stage: "reproducing" });
+            const repro = await this.reproduce(input, caller);
+            this.save(id, { repro: JSON.stringify(repro) });
+            report = (await this.get(id));
+        }
+        // Stage 2 — draft. Pure, so it cannot fail on its own.
+        if (report.stage !== "logged") {
+            const history = await this.list(6);
+            const draft = renderIssueBody(report, history, caller.actor);
+            this.save(id, { stage: "drafted", draft, error: null });
+            report = (await this.get(id));
+        }
+        // Stage 3 — log it to fundi.
+        if (report.stage === "drafted") {
+            const logged = await this.log(report, caller);
+            if (logged.ok) {
+                this.save(id, {
+                    stage: "logged",
+                    fundi_issue_id: logged.issue.id,
+                    issue_status: logged.issue.status,
+                    issue_url: logged.issue.githubIssueUrl,
+                    error: null,
+                });
+            }
+            else {
+                // NOT `failed`. The draft is done and in hand; the report is parked at
+                // `drafted` with the reason, and `retry` picks up from here. fundi
+                // deduplicates on the report id, so a retry after a failure that
+                // actually reached D1 returns the existing row rather than logging the
+                // same complaint twice.
+                this.save(id, { error: logged.reason });
+            }
+            report = (await this.get(id));
+        }
+        return report;
+    }
+    /**
+     * Delegate the reproduction to fundi.
+     *
+     * Returns fundi's answer verbatim rather than a verdict of our own. Today
+     * that answer is "accepted, not executed", and passing it through unedited is
+     * what stops the drafted issue claiming a run that did not happen.
+     *
+     * Routed through `createFundiCaller` rather than `FUNDI_SERVICE.fetch`
+     * directly. This used to hand-roll the binding call with a lone
+     * `Content-Type` header, so it never sent `X-Fundi-User-Token` — and fundi,
+     * correctly, refused every one with `403 fundi only acts for an authenticated
+     * user` (AUTH.md §2). The caller is the only code that satisfies that
+     * contract, and it also covers the HTTP + M2M path this method previously
+     * ignored: without a binding it used to give up, even on a Worker configured
+     * to reach fundi over HTTP.
+     */
+    async reproduce(input, caller) {
+        // No skill means no reproduction — see `defaultSkill`. `feedback` reports
+        // take this path unless the caller names one, which is why an unreproduced
+        // report is a normal outcome rather than a failure.
+        const skill = input.skill ?? defaultSkill(input.kind);
+        if (!skill) {
+            return {
+                attempted: false,
+                reason: `no reproduction skill applies to a '${input.kind}' report; pass \`skill\` to force one`,
+            };
+        }
+        if (!fundiConfigured(this.env)) {
+            return { attempted: false, skill, reason: "fundi is not configured on this Worker" };
+        }
+        // Forwarding an absent token would earn the same 403 this method exists to
+        // stop misreporting, so name the real reason instead.
+        const userToken = caller.userToken;
+        if (!userToken) {
+            return {
+                attempted: false,
+                skill,
+                reason: "no signed-in user token to forward to fundi; the report is filed without a reproduction",
+            };
+        }
+        try {
+            const res = await createFundiCaller(this.env).call("/a2a", async () => userToken, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: crypto.randomUUID(),
+                    method: "message/send",
+                    params: {
+                        message: {
+                            role: "user",
+                            parts: [{ kind: "text", text: reproInstruction(input) }],
+                            metadata: { skill },
+                        },
+                    },
+                }),
+            });
+            const body = await res.text();
+            let parsed = body.slice(0, 4000);
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch {
+                // keep the truncated text — a non-JSON body is itself the finding
+            }
+            return { attempted: true, skill, status: res.status, response: parsed };
+        }
+        catch (err) {
+            return { attempted: true, skill, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    /**
+     * Stage 3 — hand the drafted report to fundi.
+     *
+     * This is the only outbound call the desk makes besides the reproduction, and
+     * it goes over the SAME Service Binding: fundi is the Worker that holds the
+     * GitHub PAT and the platform D1 binding, and it already owns `fundi_issues`,
+     * the cron pass that files unfiled rows, and the webhook that tracks them
+     * afterwards. Sending the report there rather than writing D1 from here keeps
+     * one writer on that table and keeps this Worker free of credentials.
+     *
+     * It cannot throw. `logIssueToFundi` turns every failure — no binding, no
+     * user token, fundi 5xx, D1 refusing the insert — into a reason string, and
+     * the caller parks the report at `drafted` with it. The tool call that
+     * reported the issue survives every one of them.
+     */
+    async log(report, caller) {
+        if (!fundiConfigured(this.env)) {
+            return {
+                ok: false,
+                reason: "fundi is not configured on this Worker, so the issue was drafted but not logged. " +
+                    "The full body is in this report's `draft` field. fundi is reached over the " +
+                    "FUNDI_SERVICE binding (or FUNDI_URL + the M2M credentials); it is the Worker that " +
+                    "files the GitHub issue, and this one deliberately holds no GitHub token.",
+            };
+        }
+        const userToken = caller.userToken;
+        if (!userToken) {
+            // fundi refuses a call that acts for nobody (403), and it is right to:
+            // the issue is recorded against the REPORTER, taken from the verified
+            // token rather than from anything this Worker could assert. Naming the
+            // cause beats forwarding nothing and reporting fundi's refusal.
+            return {
+                ok: false,
+                reason: "no signed-in user token to forward to fundi, so the issue was drafted but not logged. " +
+                    "Reconnect the Mzizi MCP server and retry this report.",
+            };
+        }
+        return logIssueToFundi(createFundiCaller(this.env), async () => userToken, report, issueTitle(report));
+    }
+    save(id, fields) {
+        const entries = Object.entries(fields);
+        if (entries.length === 0)
+            return;
+        const sets = entries.map(([k]) => `${k} = ?`).join(", ");
+        this.ctx.storage.sql.exec(`UPDATE reports SET ${sets}, updated_at = ? WHERE id = ?`, ...entries.map(([, v]) => v), new Date().toISOString(), id);
+    }
+}
+//# sourceMappingURL=issue-desk.js.map

package/dist/issue-desk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-desk.js","sourceRoot":"","sources":["../src/issue-desk.ts"],"names":[],"mappings":"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"}

package/dist/issue-log.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Handing a drafted report to fundi, and reading back what became of it.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS IS NOT A GITHUB CALL
+ *
+ * It used to be. `issue-desk.ts` POSTed to `https://api.github.com/repos/…/issues`
+ * with `env.GITHUB_TOKEN` — a secret that was never set on this Worker, and was
+ * never going to be. The result was a pipeline that looked finished and wasn't:
+ * every report reproduced, drafted, then parked at `drafted` inside a per-user
+ * Durable Object with a polite note suggesting the reporter paste the body into
+ * GitHub themselves. Nobody did. No maintainer ever saw one.
+ *
+ * The architecture that replaces it puts each job where the credential and the
+ * data already are:
+ *
+ *     mzizi-mcp    reproduce, draft, and LOG the issue — no GitHub, no PAT
+ *     fundi        record it in D1, file the GitHub issue WITH the fix in it,
+ *                  and track that issue's lifecycle back into the same row
+ *
+ * So this module's whole job is one call over the existing fundi transport. The
+ * MCP holds no GitHub credential and no database binding; it holds a Service
+ * Binding to a Worker that has both.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY IT LIVES HERE RATHER THAN IN THE DURABLE OBJECT
+ *
+ * `issue-desk.ts` imports `cloudflare:workers` for the `DurableObject` base
+ * class, which only resolves inside workerd — so nothing in that file can be
+ * driven by a test running under plain Node. This module is ordinary
+ * TypeScript over a `FundiCaller` interface, which means the behaviour that
+ * MUST hold can actually be asserted:
+ *
+ *     a failure to log an issue NEVER propagates to the tool call.
+ *
+ * That is not a nicety. `mzizi_report_issue` is a conversation turn; if fundi
+ * is down, or its D1 binding is unresolved, or the insert throws, the reporter
+ * must still get their report back with the drafted body in hand and a reason
+ * they can read — not an MCP error. Every path below returns an outcome. None
+ * of them throws.
+ */
+import type { FundiCaller } from "./fundi-client.js";
+import type { Report } from "./issue-report.js";
+/** fundi's view of a logged issue — the row the console reads. */
+export interface LoggedIssue {
+    id: number;
+    status: string;
+    title: string | null;
+    githubIssueNumber: number | null;
+    githubIssueUrl: string | null;
+    githubFiledAt: string | null;
+    workStartedAt: string | null;
+    closedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export type LogOutcome = {
+    ok: true;
+    issue: LoggedIssue;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function isTerminal(status: string | null | undefined): boolean;
+/**
+ * Log a drafted report as a fundi issue.
+ *
+ * `report.id` travels as `reportId` and makes this IDEMPOTENT: the desk's
+ * `retry` action re-enters the pipeline at the stage that failed, so the same
+ * report legitimately arrives twice, and fundi answers with the row it already
+ * has rather than logging the complaint again.
+ *
+ * The reporter is NOT sent. fundi takes it from the verified user token on the
+ * call, because an identity the body can choose is an identity anyone can
+ * forge — and that column is what the console filters a person's own issues by.
+ */
+export declare function logIssueToFundi(caller: FundiCaller, resolveUserToken: () => Promise<string>, report: Report, title: string): Promise<LogOutcome>;
+/** Where a logged issue got to. Same failure contract: never throws. */
+export declare function fetchIssueStatus(caller: FundiCaller, resolveUserToken: () => Promise<string>, issueId: number): Promise<LogOutcome>;
+//# sourceMappingURL=issue-log.d.ts.map

package/dist/issue-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-log.d.ts","sourceRoot":"","sources":["../src/issue-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C,kEAAkE;AAClE,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GAChC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAUjC,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAErE;AAmED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,WAAW,EACnB,gBAAgB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EACvC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,UAAU,CAAC,CAmBrB;AAED,wEAAwE;AACxE,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,WAAW,EACnB,gBAAgB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EACvC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC,CAErB"}

package/dist/issue-log.js

@@ -0,0 +1,146 @@
+/**
+ * Handing a drafted report to fundi, and reading back what became of it.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS IS NOT A GITHUB CALL
+ *
+ * It used to be. `issue-desk.ts` POSTed to `https://api.github.com/repos/…/issues`
+ * with `env.GITHUB_TOKEN` — a secret that was never set on this Worker, and was
+ * never going to be. The result was a pipeline that looked finished and wasn't:
+ * every report reproduced, drafted, then parked at `drafted` inside a per-user
+ * Durable Object with a polite note suggesting the reporter paste the body into
+ * GitHub themselves. Nobody did. No maintainer ever saw one.
+ *
+ * The architecture that replaces it puts each job where the credential and the
+ * data already are:
+ *
+ *     mzizi-mcp    reproduce, draft, and LOG the issue — no GitHub, no PAT
+ *     fundi        record it in D1, file the GitHub issue WITH the fix in it,
+ *                  and track that issue's lifecycle back into the same row
+ *
+ * So this module's whole job is one call over the existing fundi transport. The
+ * MCP holds no GitHub credential and no database binding; it holds a Service
+ * Binding to a Worker that has both.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY IT LIVES HERE RATHER THAN IN THE DURABLE OBJECT
+ *
+ * `issue-desk.ts` imports `cloudflare:workers` for the `DurableObject` base
+ * class, which only resolves inside workerd — so nothing in that file can be
+ * driven by a test running under plain Node. This module is ordinary
+ * TypeScript over a `FundiCaller` interface, which means the behaviour that
+ * MUST hold can actually be asserted:
+ *
+ *     a failure to log an issue NEVER propagates to the tool call.
+ *
+ * That is not a nicety. `mzizi_report_issue` is a conversation turn; if fundi
+ * is down, or its D1 binding is unresolved, or the insert throws, the reporter
+ * must still get their report back with the drafted body in hand and a reason
+ * they can read — not an MCP error. Every path below returns an outcome. None
+ * of them throws.
+ */
+/**
+ * Statuses with nothing left to happen.
+ *
+ * Used to stop asking. A report whose issue is closed does not get a fundi call
+ * every time its reporter looks at it.
+ */
+const TERMINAL = new Set(["resolved", "closed", "wontfix"]);
+export function isTerminal(status) {
+    return status != null && TERMINAL.has(status);
+}
+/** Truncated so a failure reason stays a sentence, not a page of HTML. */
+function snippet(text) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > 300 ? `${flat.slice(0, 297)}…` : flat;
+}
+function readIssue(parsed) {
+    const issue = parsed?.issue;
+    if (!issue || typeof issue !== "object")
+        return null;
+    const row = issue;
+    if (typeof row["id"] !== "number")
+        return null;
+    return {
+        id: row["id"],
+        status: typeof row["status"] === "string" ? row["status"] : "open",
+        title: row["title"] ?? null,
+        githubIssueNumber: row["githubIssueNumber"] ?? null,
+        githubIssueUrl: row["githubIssueUrl"] ?? null,
+        githubFiledAt: row["githubFiledAt"] ?? null,
+        workStartedAt: row["workStartedAt"] ?? null,
+        closedAt: row["closedAt"] ?? null,
+        createdAt: row["createdAt"] ?? null,
+        updatedAt: row["updatedAt"] ?? null,
+    };
+}
+async function call(caller, resolveUserToken, path, init) {
+    let res;
+    try {
+        res = await caller.call(path, resolveUserToken, init);
+    }
+    catch (err) {
+        // The transport itself failed: no binding, a throwing token resolver, a
+        // network error on the HTTP fallback. Named, never rethrown.
+        return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+    const text = await res.text().catch(() => "");
+    if (!res.ok) {
+        return { ok: false, reason: `fundi answered ${res.status}: ${snippet(text)}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return {
+            ok: false,
+            reason: `fundi answered ${res.status} with a body that is not JSON: ${snippet(text)}`,
+        };
+    }
+    const issue = readIssue(parsed);
+    if (!issue) {
+        return {
+            ok: false,
+            reason: `fundi accepted the issue but returned no row: ${snippet(text)}`,
+        };
+    }
+    return { ok: true, issue };
+}
+/**
+ * Log a drafted report as a fundi issue.
+ *
+ * `report.id` travels as `reportId` and makes this IDEMPOTENT: the desk's
+ * `retry` action re-enters the pipeline at the stage that failed, so the same
+ * report legitimately arrives twice, and fundi answers with the row it already
+ * has rather than logging the complaint again.
+ *
+ * The reporter is NOT sent. fundi takes it from the verified user token on the
+ * call, because an identity the body can choose is an identity anyone can
+ * forge — and that column is what the console filters a person's own issues by.
+ */
+export async function logIssueToFundi(caller, resolveUserToken, report, title) {
+    return call(caller, resolveUserToken, "/issues", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            reportId: report.id,
+            kind: report.kind,
+            title,
+            message: report.message,
+            // The drafted body is the point of the desk: the symptom in the
+            // reporter's words, what the reproduction actually returned, and their
+            // earlier reports. fundi renders it into the GitHub issue above its own
+            // healing plan.
+            body: report.draft ?? report.message,
+            component: report.component,
+            severity: report.severity,
+            repro: report.repro,
+        }),
+    });
+}
+/** Where a logged issue got to. Same failure contract: never throws. */
+export async function fetchIssueStatus(caller, resolveUserToken, issueId) {
+    return call(caller, resolveUserToken, `/issues/${issueId}`, { method: "GET" });
+}
+//# sourceMappingURL=issue-log.js.map

package/dist/issue-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-log.js","sourceRoot":"","sources":["../src/issue-log.ts"],"names":[],"mappings":"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"}