@miadi/connector 0.1.7 → 0.1.8

package/dist/approve.d.ts

@@ -52,6 +52,8 @@ export declare function runBrief(record: ConnectorRecord, approver: MiadiPerson,
     to: string;
     brief: string;
 };
+/** A request's refs as episode references: an `owner/repo#n` becomes its issue link, anything else stays as written. */
+export declare function episodeReferences(record: ConnectorRecord): string[];
 export declare function executeApproved(record: ConnectorRecord, approver: MiadiPerson, deps: ApprovalDeps, instructions?: string): Promise<Record<string, unknown>>;
 /**
  * Record a person's decision on a request and, when approved, run it once as
@@ -71,6 +73,22 @@ export declare function decide(r: ConnectorRecord, person: MiadiPerson, choice:
     state: ConnectorRecord["state"];
     receipt: Record<string, unknown>;
 }>;
+/** Whether a request was approved and its run failed, so a person may run it again. */
+export declare function isRerunnable(r: ConnectorRecord | undefined): boolean;
+/**
+ * Run an approved request again when its run failed (state `blocked`): a door
+ * it called was down or refused, and was fixed since. It runs as the person
+ * who asks, with the instructions it was approved with. The approval stays the
+ * decider's; the new receipt names who ran it again and keeps the failed
+ * outcome it replaces. jgwill/Miadi#884
+ */
+export declare function rerun(r: ConnectorRecord, person: MiadiPerson, deps: ApprovalDeps, opts: {
+    via: string;
+}): Promise<{
+    decision: "approved";
+    state: ConnectorRecord["state"];
+    receipt: Record<string, unknown>;
+}>;
 export declare function isApprovable(r: ConnectorRecord | undefined): r is ConnectorRecord;
 /** What approving a request does, in one sentence, for the card a person decides on. */
 export declare function consequenceOf(r: ConnectorRecord): string;

package/dist/approve.js

@@ -133,6 +133,13 @@ function plainName(name) {
     const n = name.replace(/[^\w .'-]/g, "").trim().slice(0, 40);
     return /^[^\W_]/.test(n) ? n : "Miadi connector";
 }
+/** A request's refs as episode references: an `owner/repo#n` becomes its issue link, anything else stays as written. */
+export function episodeReferences(record) {
+    return (record.refs ?? []).map((ref) => {
+        const m = /^([\w.-]+)\/([\w.-]+)#(\d+)$/.exec(ref);
+        return m ? `https://github.com/${m[1]}/${m[2]}/issues/${m[3]}` : ref;
+    });
+}
 export async function executeApproved(record, approver, deps, instructions) {
     const f = deps.fetchImpl ?? fetch;
     const b = record.body;
@@ -198,7 +205,9 @@ export async function executeApproved(record, approver, deps, instructions) {
             const inquiry = { artefact: b.artefact, ...(b.issue ? { issue: b.issue } : {}) };
             try {
                 if (b.new_episode) {
-                    const res = await deps.miadi.request(approver.token, "POST", "/api/chronicle/episodes", { title: b.new_episode.title, ...(b.new_episode.goal ? { goal: b.new_episode.goal } : {}), inquiry }, 120_000);
+                    const res = await deps.miadi.request(approver.token, "POST", "/api/chronicle/episodes", 
+                    // The mint needs at least one reference: the request's own refs, an owner/repo#n made a link (jgwill/Miadi#884).
+                    { title: b.new_episode.title, ...(b.new_episode.goal ? { goal: b.new_episode.goal } : {}), inquiry, references: episodeReferences(record) }, 120_000);
                     return { outcome: "minted_and_woven", response: res };
                 }
                 const res = await deps.miadi.request(approver.token, "POST", `/api/chronicle/episodes/${encodeURIComponent(b.episode)}/inquiry`, inquiry, 120_000);
@@ -287,6 +296,68 @@ export async function decide(r, person, choice, deps, opts) {
         deciding.delete(r.id);
     }
 }
+/** Whether a request was approved and its run failed, so a person may run it again. */
+export function isRerunnable(r) {
+    return !!r && r.approval_state === "approved" && r.state === "blocked";
+}
+/**
+ * Run an approved request again when its run failed (state `blocked`): a door
+ * it called was down or refused, and was fixed since. It runs as the person
+ * who asks, with the instructions it was approved with. The approval stays the
+ * decider's; the new receipt names who ran it again and keeps the failed
+ * outcome it replaces. jgwill/Miadi#884
+ */
+export async function rerun(r, person, deps, opts) {
+    const live = current(deps.ledger.all()).find((x) => x.id === r.id);
+    if (!isRerunnable(live) || deciding.has(r.id)) {
+        throw new AlreadyDecided(deciding.has(r.id) ? "This request is being run." : `This request is ${live?.approval_state ?? "gone"} and ${live?.state ?? "unknown"}; only an approved request whose run failed is run again.`);
+    }
+    deciding.add(r.id);
+    try {
+        const prior = (live.completion_receipt ?? {});
+        const instructions = typeof prior.instructions === "string" ? prior.instructions : undefined;
+        let receipt = {
+            decided_by: prior.decided_by,
+            decided_at: prior.decided_at,
+            decision: prior.decision,
+            ...(instructions ? { instructions } : {}),
+            rerun_by: { person_id: person.id, name: person.name },
+            rerun_at: new Date().toISOString(),
+            via: opts.via,
+            replaces: { outcome: prior.outcome, ...(prior.status !== undefined ? { status: prior.status } : {}), ...(prior.response !== undefined ? { response: prior.response } : {}) },
+        };
+        let state = "completed";
+        try {
+            const outcome = await executeApproved(live, person, deps, instructions);
+            receipt = { ...receipt, ...outcome };
+            if (outcome.outcome === "failed")
+                state = "blocked";
+            if (outcome.outcome === "queued")
+                state = "in_progress";
+        }
+        catch (error) {
+            receipt = { ...receipt, outcome: "failed", message: error instanceof Error ? error.message : String(error) };
+            state = "blocked";
+        }
+        deps.ledger.append({
+            id: newRecordId(r.kind),
+            kind: r.kind,
+            created_at: new Date().toISOString(),
+            actor: { person_id: person.id, name: person.name, client_id: opts.via },
+            refs: r.refs,
+            evidence_refs: [],
+            supersedes: r.id,
+            approval_state: "approved",
+            state,
+            completion_receipt: receipt,
+            body: { decision: "rerun" },
+        });
+        return { decision: "approved", state, receipt };
+    }
+    finally {
+        deciding.delete(r.id);
+    }
+}
 async function decideOnce(r, person, choice, deps, opts) {
     const { instructions } = opts;
     const decision = choice === "approve" || choice === "approve_with_changes" ? "approved" : choice === "request_revision" ? "revision_requested" : "declined";
@@ -391,6 +462,19 @@ export function registerApprovalRoutes(app, deps) {
             return void res.type("html").send(approvePage(r, { token: writer ? token : undefined }));
         if (!writer)
             return void res.status(403).type("html").send(approvePage(r, { error: `Deciding needs Miadi's write tier; ${person.name} has ${person.api_tier ?? "no API tier"}.` }));
+        if (body.decision === "rerun") {
+            let ran;
+            try {
+                ran = await rerun(r, person, deps, { via: String(body.via ?? "approval-page").slice(0, 60) });
+            }
+            catch (error) {
+                if (error instanceof AlreadyDecided)
+                    return void res.status(409).type("html").send(approvePage(find(r.id), { token, error: error.message }));
+                throw error;
+            }
+            const failedAgain = ran.receipt.outcome === "failed";
+            return void res.type("html").send(page("Recorded", `<h1>${failedAgain ? "Run again, and it failed again" : "Run again"}</h1>${summary(find(r.id))}<pre>${escapeHtml(JSON.stringify(ran.receipt, null, 2))}</pre>`));
+        }
         if (r.approval_state !== "awaiting_approval") {
             return void res.status(409).type("html").send(approvePage(r, { error: `This request is already ${r.approval_state}.` }));
         }
@@ -478,7 +562,12 @@ ${r.approval_state === "awaiting_approval" && o.token
 </div></form>`
         : r.approval_state === "awaiting_approval"
             ? "<p>A person with Miadi's write tier decides this request.</p>"
-            : ""}`);
+            : isRerunnable(r) && o.token
+                ? `<p>It was approved, and running it failed. When what it calls has been fixed, it can be run again with the same approval and instructions; the ledger records who ran it again.</p>
+<form method="post">
+<input type="hidden" name="person_token" value="${escapeHtml(o.token)}">
+<div class="row"><button class="primary" type="submit" name="decision" value="rerun">Run it again</button></div></form>`
+                : ""}`);
 }
 /** How a request is named to a person. */
 export const KIND_LABELS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miadi/connector",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "The Miadi connector: one remote MCP service through which a person signed in with their Miadi person token, from ChatGPT or any MCP client, reads sessions, reviews, episodes and circles and records observations, inquiries, handoffs and proposals with their name on each record.",
   "license": "MIT",
   "author": "Miadi",