mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-20 09:50:48 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work. > - Core manages chat authorization, AI connection defaults, navigation, and the plugin host. > - Core still writes old default rows and checks an Agent Chat flag that always reads true. > - It also carries a desktop rail that cannot open and private aliases with canonical equivalents. > - This pull request removes those paths and moves their tests onto the paths Core uses. > - The result is fewer Core database operations and less code to maintain. ## Linked Issues or Issue Description **What existing behavior does this improve?** Core AI default writes, Agent Chat execution and delivery, private plugin host and Runner setup, and board navigation. **Subsystem affected** Cross-cutting. Core server, board UI, private Runner helpers, and a repository guard script. **Current behavior** The server writes provider-scoped and per-method AI defaults, then reads only the provider-scoped rows. It reads settings to decide whether to block Agent Chat, although every settings view enables it. The desktop sidebar renders expanded while still tracking requests to open and close a retired icon rail. The agent client retries conflicts that the server already resolves when there is exactly one active match. **Proposed behavior** Write provider-scoped defaults directly. Use the existing Agent Chat authorization and retry checks without the redundant settings reads. Render the current sidebar directly and let the API report true agent reference conflicts. **Reason and benefit** A personal non-custom connection save or explicit default selection sends one fewer SQL statement. It also avoids the provider-default write that the legacy trigger performed when the old statement inserted or updated a row. A successful task-to-chat send or receipt replay avoids two transaction settings SELECTs when the singleton row already exists. Conversation comment, wake release, and retry paths also avoid a transaction settings read when they previously entered the gate. Savings in other settings paths depend on cache hits. Core-to-plugin RPC and plugin-to-Launcher HTTP traffic stay the same. **Breaking changes** The public plugin SDK, host navigation, and organization-switcher fields retain their existing interfaces and behavior. The settings API still accepts and reports the Agent Chat compatibility key. This change needs no schema migration or rollout ordering. **Additional context** Refs #10610 for prior reporting on the retired sidebar rail. Refs #21756 for adjacent Coordinator plugin slots, which remain a separate change. ## What Changed - Stop writing per-method AI defaults. Preserve the provider-scope upsert and first-account behavior. Keep the existing tables and migration trigger. - Remove Agent Chat checks that read a constant true value. Keep conversation ownership, task scope, session, and request-retry checks. - Remove unused lock-owner fields and private plugin lifecycle, secret extraction, Gmail connector, PRP setup, heartbeat resolver, and ACPX aliases. - Use a single API request for agent references. Remove retired sidebar rail state, hooks, and branches across the active and production snapshot layouts. Preserve desktop resizing, mobile drawer controls, contextual navigation, and public plugin slot inputs. - Remove unused FeedCard and AgentDetail inputs and the test-only Git push matcher alias. - Keep the cleanup that erases historical plaintext chat retries from browser storage. Production source in the touched files is 106,800 → 105,633 nonblank lines, down 1,167. The production Git diff adds 251 physical lines and removes 1,480, down 1,229. Those figures exclude tests, fixtures, docs, and Storybook. The entire Git diff adds 482 physical lines and removes 2,325, down 1,843. ## Verification - Merged master at `b56f240f45` into the PR branch as `f73fea4009`. The five sidebar files retain the expanded navigation cleanup and master’s explicit session-replay masking contract. The merge also preserves master’s account-repair recovery guard and GitHub star-prompt behavior. - Focused UI Vitest run passed 361 tests across 11 files. This covers analytics privacy and replay masking, sidebar and layout, GitHub star prompt, and agent detail. - Focused server Vitest run passed 45 tests across three files. This covers restored configuration handling, conversation recovery, and Agent Chat authority and receipt replay. - `pnpm --filter @paperclipai/ui typecheck`, the Git push guard and its 14 tests, and `git diff --check origin/master...HEAD` passed. - `pnpm verify --base origin/master` classified the Git-push guard as a global CI input and returned exit 2. GitHub CI supplied the broader coverage. - GitHub CI and Runner image checks passed on `f73fea4009`. Both required checks, `ci / verify` and `ci / e2e`, passed. [CI workflow](https://github.com/paperclipai/paperclip/actions/runs/44181261752) · [Runner image workflow](https://github.com/paperclipai/paperclip/actions/runs/44181261413) - Standard Greptile reported 5/5 with no actionable findings or open review threads. [Greptile review](https://github.com/paperclipai/paperclip/pull/22055#issuecomment-6959078925) - The optional Superagent Security Scan finished neutral with an inconclusive workflow result and zero annotations. The final rollup had 61 successes, five skips, and one neutral, with no failed or pending checks. [PR checks](https://github.com/paperclipai/paperclip/pull/22055/checks) ## Risks Agent Chat authorization and retry are sensitive to small query changes. The final diff keeps the conversation agent field and all existing authorization and idempotency checks. The tests cover revoked defaults, legacy migration reads, bound-listener authority, and mobile and desktop navigation. Installations that still run software old enough to read the per-method AI table will no longer see new defaults in that table. Current Core reads the provider-scoped table. ## Model Used OpenAI Codex, GPT-6.1 Sol (`gpt-6.1-sol`), with source inspection and shell-based tests. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge --------- Co-authored-by: Paperclip <noreply@paperclip.ing>
781 lines
35 KiB
TypeScript
781 lines
35 KiB
TypeScript
import { createLocalNativeQuestionBridge } from "./local-native-question-bridge.js";
|
|
import { randomUUID } from "node:crypto";
|
|
import { mkdtempSync, rmSync } from "node:fs";
|
|
import { createServer } from "node:http";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
|
|
import { eq, sql } from "drizzle-orm";
|
|
|
|
import {
|
|
activityLog,
|
|
agents,
|
|
authUsers,
|
|
companies,
|
|
companyMemberships,
|
|
createDb,
|
|
heartbeatRuns,
|
|
heartbeatRunEvents,
|
|
issueComments,
|
|
issueQuestionResponseDeliveries,
|
|
issueThreadInteractions,
|
|
issues,
|
|
nativeRunFinalizations,
|
|
} from "@paperclipai/db";
|
|
import type { PrpEvent } from "@paperclipai/paperclip-runner";
|
|
import { respondIssueThreadInteractionSchema } from "@paperclipai/shared";
|
|
|
|
import {
|
|
getEmbeddedPostgresTestSupport,
|
|
startEmbeddedPostgresTestDatabase,
|
|
} from "../../__tests__/helpers/embedded-postgres.js";
|
|
import { drainHeartbeatRunsToQuiescence } from "../../__tests__/helpers/drain-heartbeat-runs.js";
|
|
import { issueThreadInteractionService } from "../issue-thread-interactions.js";
|
|
import {
|
|
deliverNativeQuestionResponse,
|
|
flushNativeQuestionResponses,
|
|
nativeQuestionBridgeInternals,
|
|
nativeQuestionRunToCancel,
|
|
projectNativeRuntimeRequest,
|
|
registerNativeQuestionCommandTarget,
|
|
requestNativeQuestionRunCancellation,
|
|
validateNativeQuestionResponseInput,
|
|
} from "./native-question-bridge.js";
|
|
import {
|
|
executeIssuePostCommitActions,
|
|
issueService,
|
|
type IssuePostCommitAction,
|
|
} from "../issues.js";
|
|
import { questionResponseDeliveryService } from "../question-response-delivery.js";
|
|
import * as questionPatternValidation from "../question-pattern-validation.js";
|
|
import { heartbeatService } from "../heartbeat.js";
|
|
import { DurablePrpControlPlane } from "../../vendor/paperclip-runner/index.js";
|
|
import { PaperclipControlPlanePort } from "./paperclip-control-plane-port.js";
|
|
import { readPendingNativeRuntimeRequest } from "./runtime-request-resolution-authority.js";
|
|
import {
|
|
queueRunnerPrpRuntimeRequestResolution,
|
|
registerRunnerPrpAuthority,
|
|
setupRunnerPrpWebSocketServer,
|
|
} from "../../realtime/runner-prp-ws.js";
|
|
|
|
const embeddedPostgresSupport = await getEmbeddedPostgresTestSupport();
|
|
const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip;
|
|
|
|
if (!embeddedPostgresSupport.supported) {
|
|
console.warn(
|
|
`Skipping native question bridge tests on this host: ${embeddedPostgresSupport.reason ?? "unsupported environment"}`,
|
|
);
|
|
}
|
|
|
|
describeEmbeddedPostgres("native question bridge", () => {
|
|
let temporary: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>> | null = null;
|
|
let db: ReturnType<typeof createDb>;
|
|
let heartbeat: ReturnType<typeof heartbeatService>;
|
|
let companyId: string;
|
|
let issueId: string;
|
|
let agentId: string;
|
|
let runId: string;
|
|
let sessionId: string;
|
|
let runnerInstanceId: string;
|
|
|
|
beforeAll(async () => {
|
|
temporary = await startEmbeddedPostgresTestDatabase("paperclip-native-question-");
|
|
db = createDb(temporary.connectionString);
|
|
heartbeat = heartbeatService(db);
|
|
}, 20_000);
|
|
|
|
afterEach(async () => {
|
|
// A cancelled or reaped run can promote and dispatch its agent's next
|
|
// queued run fire-and-forget (see startNextQueuedRunForAgent in
|
|
// heartbeat.ts), so that dispatch can still be writing heartbeat_runs,
|
|
// issues, or activity_log rows when this hook starts. Drain every
|
|
// in-flight run to quiescence first, or its late write races the
|
|
// TRUNCATE below and can deadlock.
|
|
await drainHeartbeatRunsToQuiescence(db, heartbeat);
|
|
nativeQuestionBridgeInternals.resetForTests();
|
|
await db.execute(sql.raw(`
|
|
TRUNCATE TABLE
|
|
"activity_log",
|
|
"issue_thread_interactions",
|
|
"heartbeat_runs",
|
|
"agent_wakeup_requests",
|
|
"issues",
|
|
"agents",
|
|
"companies"
|
|
RESTART IDENTITY CASCADE
|
|
`));
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await heartbeat.drainActiveRunExecutions();
|
|
await temporary?.cleanup();
|
|
});
|
|
|
|
async function seed() {
|
|
companyId = randomUUID();
|
|
issueId = randomUUID();
|
|
agentId = randomUUID();
|
|
runId = randomUUID();
|
|
sessionId = randomUUID();
|
|
runnerInstanceId = randomUUID();
|
|
await db.insert(companies).values({
|
|
id: companyId,
|
|
name: "Native questions",
|
|
issuePrefix: `NQ${companyId.replaceAll("-", "").slice(0, 6).toUpperCase()}`,
|
|
requireBoardApprovalForNewAgents: false,
|
|
});
|
|
await db.insert(authUsers).values({
|
|
id: "operator-1", name: "Operator", email: "operator-1@example.test",
|
|
createdAt: new Date(), updatedAt: new Date(),
|
|
}).onConflictDoNothing();
|
|
await db.insert(companyMemberships).values({
|
|
companyId, principalType: "user", principalId: "operator-1", status: "active", membershipRole: "member",
|
|
});
|
|
await db.insert(agents).values({
|
|
id: agentId,
|
|
companyId,
|
|
name: "Native Codex",
|
|
adapterType: "paperclip_runner",
|
|
status: "running",
|
|
adapterConfig: { provider: "codex" },
|
|
runtimeConfig: {},
|
|
});
|
|
await db.insert(issues).values({
|
|
id: issueId,
|
|
companyId,
|
|
title: "Answer a native question",
|
|
status: "in_progress",
|
|
assigneeAgentId: agentId,
|
|
responsibleUserId: "operator-1",
|
|
});
|
|
await db.insert(heartbeatRuns).values({
|
|
id: runId,
|
|
companyId,
|
|
agentId,
|
|
status: "running",
|
|
runtimeMode: "native",
|
|
runtimeModeResolvedAt: new Date(),
|
|
nativeIssueId: issueId,
|
|
nativeSessionId: sessionId,
|
|
runnerInstanceId,
|
|
driverKind: "codex",
|
|
contextSnapshot: { issueId },
|
|
});
|
|
await db.insert(nativeRunFinalizations).values({
|
|
runId,
|
|
companyId,
|
|
issueId,
|
|
phase: "observed",
|
|
});
|
|
}
|
|
|
|
function runtimeRequestEvent(): PrpEvent {
|
|
return {
|
|
schema: "paperclip.prp.event.v1",
|
|
sourceEventId: "runtime-question-1",
|
|
sourceSeq: 1,
|
|
sourceInstanceId: runnerInstanceId,
|
|
sourceKind: "runner",
|
|
runId,
|
|
normalizedSessionId: sessionId,
|
|
turnId: "turn-1",
|
|
itemId: "item-1",
|
|
eventType: "runtime_request.created",
|
|
schemaVersion: 1,
|
|
priority: 0,
|
|
emittedAt: "2026-08-25T18:00:00.000Z",
|
|
payload: {
|
|
request: {
|
|
schema: "paperclip.runtime_request.v2",
|
|
requestKind: "runtime",
|
|
requestId: "request-1",
|
|
type: "input",
|
|
status: "pending",
|
|
prompt: "Choose a deployment color",
|
|
input: {
|
|
schema: "paperclip.question_set.v1",
|
|
title: "Deployment",
|
|
questions: [{
|
|
id: "color",
|
|
prompt: "Which color?",
|
|
required: true,
|
|
answerMode: "single_select",
|
|
options: [
|
|
{ id: "blue", label: "Blue" },
|
|
{ id: "green", label: "Green" },
|
|
],
|
|
}],
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
function binding() {
|
|
return {
|
|
companyId,
|
|
issueId,
|
|
runId,
|
|
agentId,
|
|
normalizedSessionId: sessionId,
|
|
runnerSourceInstanceId: runnerInstanceId,
|
|
completionContractId: randomUUID(),
|
|
completionContractSha256: `sha256:${"a".repeat(64)}`,
|
|
completionContractRevision: "1",
|
|
completionContractCriterionIds: [],
|
|
};
|
|
}
|
|
|
|
function permissionRequestEvent(): PrpEvent {
|
|
return { ...runtimeRequestEvent(), payload: { request: {
|
|
schema: "paperclip.runtime_request.v2", requestKind: "permission_approval",
|
|
requestId: "permission-1", turnId: "turn-1", itemId: "item-1",
|
|
type: "permission", status: "pending", prompt: "Allow editing src/example.ts?",
|
|
choices: [{ key: "accept", label: "Allow once" }, { key: "decline", label: "Deny" }],
|
|
details: { toolCallId: "tool-1" },
|
|
origin: { adapter: "acpx-runtime-sidecar", provider: "acpx", method: "session/request_permission" },
|
|
} } };
|
|
}
|
|
|
|
it("commits and acknowledges an ACP permission, then queues only an admin's exact turn-bound decision", async () => {
|
|
await seed();
|
|
const event = permissionRequestEvent();
|
|
const projection = vi.fn(async (committed: PrpEvent) => {
|
|
await projectNativeRuntimeRequest({ db, binding: binding(), event: committed });
|
|
});
|
|
const port = new PaperclipControlPlanePort(db, {
|
|
companyId, issueId, runId, agentId, sessionId,
|
|
completionContractId: binding().completionContractId,
|
|
completionContractSha256: binding().completionContractSha256,
|
|
sourceInstanceId: runnerInstanceId, controlPlaneSourceInstanceId: "control-1",
|
|
}, { onCommittedEvent: projection });
|
|
const receipt = await port.appendEvent(event);
|
|
expect(receipt).toMatchObject({ disposition: "committed", highestContiguousSourceSeq: 1 });
|
|
expect(projection).toHaveBeenCalledOnce();
|
|
expect(await db.select().from(issueThreadInteractions)).toHaveLength(0);
|
|
const [persisted] = await db.select().from(heartbeatRunEvents).where(eq(heartbeatRunEvents.runId, runId));
|
|
expect(persisted?.payload).toEqual({ prpEvent: event }); // task-chat's exact source, with only offered decisions
|
|
expect(await port.appendEvent(event)).toMatchObject({ disposition: "duplicate" });
|
|
const pending = await readPendingNativeRuntimeRequest(db, { companyId, runId, requestId: "permission-1" });
|
|
expect(pending).toMatchObject({ requestKind: "permission_approval", turnId: "turn-1", resolverPolicy: "instance_admin" });
|
|
expect(await readPendingNativeRuntimeRequest(db, { companyId: randomUUID(), runId, requestId: "permission-1" })).toBeNull();
|
|
|
|
const stateDirectory = mkdtempSync(join(tmpdir(), "native-permission-authority-"));
|
|
const server = createServer();
|
|
await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
|
|
setupRunnerPrpWebSocketServer(server);
|
|
const authority = new DurablePrpControlPlane({
|
|
stateDirectory,
|
|
identity: { runnerInstanceId, environmentLeaseId: "lease-1", runId, normalizedSessionId: sessionId, turnId: "turn-1", itemId: "item-1" },
|
|
expectedRunnerVersion: "0.3.0", expectedRunnerDigest: `sha256:${"a".repeat(64)}`,
|
|
});
|
|
const registration = await registerRunnerPrpAuthority({ companyId, runId, authority });
|
|
try {
|
|
const commandInput = { companyId, runId, pendingRequest: pending!, resolution: { action: "accept" as const },
|
|
actor: { type: "user" as const, userId: "admin-1", isInstanceAdmin: true } };
|
|
expect(() => queueRunnerPrpRuntimeRequestResolution({ ...commandInput, actor: { ...commandInput.actor, isInstanceAdmin: false } }))
|
|
.toThrow("native_runtime_request_resolver_denied");
|
|
expect(() => queueRunnerPrpRuntimeRequestResolution({ ...commandInput, companyId: randomUUID() }))
|
|
.toThrow("runner_prp_authority_not_active");
|
|
const queued = queueRunnerPrpRuntimeRequestResolution(commandInput);
|
|
expect(queueRunnerPrpRuntimeRequestResolution(commandInput)).toEqual(queued);
|
|
expect(authority.store.state.commands).toHaveLength(1);
|
|
expect(authority.store.state.commands[0]).toMatchObject({ type: "request.resolve", payload: {
|
|
requestId: "permission-1", requestKind: "permission_approval", turnId: "turn-1",
|
|
resolution: { action: "accept" }, resolutionActor: commandInput.actor,
|
|
} });
|
|
expect(() => queueRunnerPrpRuntimeRequestResolution({ ...commandInput, resolution: { action: "decline" } }))
|
|
.toThrow("runtime_request_resolution_conflict");
|
|
// Queueing is not delivery: only the runner's post-write receipt closes
|
|
// the request. ACP sidecar delivery tests exercise that provider edge.
|
|
expect(await readPendingNativeRuntimeRequest(db, { companyId, runId, requestId: "permission-1" })).toEqual(pending);
|
|
await port.appendEvent({ ...event, sourceEventId: "permission-delivered", sourceSeq: 2,
|
|
eventType: "runtime_request.resolved", payload: { requestId: "permission-1", requestKind: "permission_approval",
|
|
turnId: "turn-1", itemId: "item-1", status: "delivered", action: "accept" } });
|
|
expect(await readPendingNativeRuntimeRequest(db, { companyId, runId, requestId: "permission-1" })).toBeNull();
|
|
} finally {
|
|
await registration.release();
|
|
await authority.stop();
|
|
await new Promise<void>(resolve => server.close(() => resolve()));
|
|
rmSync(stateDirectory, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it.each([
|
|
{ requestKind: "runtime" }, { type: "input" }, { turnId: "stale-turn" }, { itemId: "wrong-item" },
|
|
{ choices: [] }, { choices: [{ key: "allow_forever", label: "Always" }] },
|
|
{ choices: [{ key: "accept", label: "One" }, { key: "accept", label: "Two" }] },
|
|
])("rejects a malformed permission projection %j", async (override) => {
|
|
await seed();
|
|
const event = permissionRequestEvent();
|
|
Object.assign(event.payload.request as object, override);
|
|
await expect(projectNativeRuntimeRequest({ db, binding: binding(), event })).rejects.toThrow(/native_runtime_/);
|
|
});
|
|
|
|
it("projects an executor question immediately and routes its durable answer into the same live turn", async () => {
|
|
await seed();
|
|
const event = runtimeRequestEvent();
|
|
await db.insert(heartbeatRunEvents).values({ companyId, agentId, runId, seq: 1,
|
|
eventType: event.eventType, stream: "system", level: "info", payload: { prpEvent: event } });
|
|
const resolve = vi.fn(async (input: any) => { await input.authorizeBeforeDispatch(); return { commandId: "live-response" }; });
|
|
const bridge = createLocalNativeQuestionBridge({ db, binding: binding(), resolve });
|
|
try {
|
|
await bridge.attach();
|
|
await bridge.observe(event);
|
|
await bridge.observe(event); // replay must not create a second card
|
|
const cards = await issueThreadInteractionService(db).listForIssue(issueId);
|
|
expect(cards).toHaveLength(1);
|
|
expect(cards[0]).toMatchObject({ status: "pending", sourceRunId: runId, continuationPolicy: "none" });
|
|
const answered = await issueThreadInteractionService(db).answerQuestions(
|
|
{ id: issueId, companyId, status: "in_progress" }, cards[0]!.id,
|
|
{ answers: [{ questionId: "color", optionIds: ["green"] }] }, { userId: "operator-1" },
|
|
);
|
|
if (answered.kind !== "ask_user_questions") throw new Error("wrong question kind");
|
|
expect(await deliverNativeQuestionResponse(db, answered)).toBe("queued");
|
|
expect(resolve).toHaveBeenCalledWith(expect.objectContaining({ runId, requestId: "request-1", turnId: "turn-1", commandId: `question_${cards[0]!.id}`,
|
|
resolution: { action: "submit", response: { schema: "paperclip.question_response.v1", answers: { color: { selectedOptionIds: ["green"] } } } },
|
|
}));
|
|
await db.update(heartbeatRuns).set({ status: "cancelled" }).where(eq(heartbeatRuns.id, runId));
|
|
await expect(resolve.mock.calls[0]![0].authorizeBeforeDispatch()).rejects.toThrow("native_question_not_pending");
|
|
} finally { bridge.close(); }
|
|
});
|
|
|
|
it("delivers saved answers without entering pattern validation again", async () => {
|
|
await seed();
|
|
const event = runtimeRequestEvent();
|
|
(event.payload.request as any).input.questions = [{ id: "url", prompt: "URL?", required: true, answerMode: "text" }];
|
|
const interaction = await projectNativeRuntimeRequest({ db, binding: binding(), event });
|
|
const answered = await issueThreadInteractionService(db).answerQuestions(
|
|
{ id: issueId, companyId, status: "in_progress" }, interaction!.id,
|
|
{ answers: [{ questionId: "url", optionIds: [], otherText: "https://example.test" }] }, { userId: "operator-1" },
|
|
);
|
|
if (answered.kind !== "ask_user_questions") throw new Error("expected questions");
|
|
const queueCommand = vi.fn(() => ({ commandId: "question", controllerSeq: 1 }));
|
|
const release = registerNativeQuestionCommandTarget({ binding: { companyId, issueId, runId, agentId }, queueCommand });
|
|
const busy = vi.spyOn(questionPatternValidation, "validateQuestionPatterns").mockRejectedValue(new Error("Question format validation is busy; try again"));
|
|
try {
|
|
await flushNativeQuestionResponses(db, runId);
|
|
expect(queueCommand).toHaveBeenCalledWith("request.resolve", expect.objectContaining({
|
|
response: { schema: "paperclip.question_response.v1", answers: { url: { text: "https://example.test" } } },
|
|
}), `question_${interaction!.id}`);
|
|
expect(busy).not.toHaveBeenCalled();
|
|
const [delivery] = await db.select().from(issueQuestionResponseDeliveries);
|
|
expect(delivery).toMatchObject({ status: "delivered" });
|
|
} finally {
|
|
busy.mockRestore();
|
|
release();
|
|
}
|
|
});
|
|
|
|
it.each(["codex", "claude"])("materializes, validates, and durably resumes a %s question response", async (provider) => {
|
|
await seed();
|
|
const interaction = await projectNativeRuntimeRequest({
|
|
db,
|
|
binding: binding(),
|
|
event: { ...runtimeRequestEvent(), payload: {
|
|
request: { ...(runtimeRequestEvent().payload.request as Record<string, unknown>),
|
|
origin: { adapter: provider === "claude" ? "acpx-runtime-sidecar" : "codex-app-server", provider,
|
|
method: provider === "claude" ? "elicitation/create" : "item/tool/requestUserInput" },
|
|
},
|
|
} },
|
|
});
|
|
|
|
expect(interaction).toMatchObject({
|
|
kind: "ask_user_questions",
|
|
status: "pending",
|
|
sourceRunId: runId,
|
|
continuationPolicy: "none",
|
|
effectiveResolverPolicy: "human_only",
|
|
payload: {
|
|
runtimeRequestId: "request-1",
|
|
supersedeOnUserComment: false,
|
|
questionSet: { schema: "paperclip.question_set.v1" },
|
|
questions: [{
|
|
id: "color",
|
|
selectionMode: "single",
|
|
allowOther: false,
|
|
options: [{ id: "blue", label: "Blue" }, { id: "green", label: "Green" }],
|
|
}],
|
|
},
|
|
});
|
|
expect(await db.select().from(activityLog)).toHaveLength(1);
|
|
|
|
const answer = { answers: [{ questionId: "color", optionIds: ["blue"] }] };
|
|
await validateNativeQuestionResponseInput(interaction!, answer);
|
|
await expect(validateNativeQuestionResponseInput(interaction!, {
|
|
answers: [{ questionId: "color", optionIds: ["red"] }],
|
|
})).rejects.toThrow(/unknown option red/);
|
|
|
|
const answered = await issueThreadInteractionService(db).answerQuestions(
|
|
{ id: issueId, companyId, status: "in_progress" },
|
|
interaction!.id,
|
|
answer,
|
|
{ userId: "operator-1" },
|
|
);
|
|
const queueCommand = vi.fn(() => ({ commandId: "question", controllerSeq: 1 }));
|
|
const release = registerNativeQuestionCommandTarget({
|
|
binding: { companyId, issueId, runId, agentId },
|
|
queueCommand,
|
|
});
|
|
|
|
await flushNativeQuestionResponses(db, runId);
|
|
expect(queueCommand).toHaveBeenCalledWith(
|
|
"request.resolve",
|
|
{
|
|
requestId: "request-1",
|
|
response: {
|
|
schema: "paperclip.question_response.v1",
|
|
answers: { color: { selectedOptionIds: ["blue"] } },
|
|
},
|
|
},
|
|
`question_${interaction!.id}`,
|
|
);
|
|
expect(queueCommand).toHaveBeenCalledTimes(1);
|
|
const [delivery] = await db.select().from(issueQuestionResponseDeliveries);
|
|
expect(delivery).toMatchObject({
|
|
interactionId: interaction!.id,
|
|
status: "delivered",
|
|
deliveryMode: "steered",
|
|
targetRunId: runId,
|
|
});
|
|
expect(answered.kind).toBe("ask_user_questions");
|
|
if (answered.kind !== "ask_user_questions") throw new Error("expected question interaction");
|
|
await expect(nativeQuestionRunToCancel(db, answered)).resolves.toBe(runId);
|
|
release();
|
|
});
|
|
|
|
it.each(["legacy", "canonical_select"])("keeps %s custom-answer normalization and rejects blank public answers", async (mode) => {
|
|
await seed();
|
|
const event = runtimeRequestEvent();
|
|
const input = (event.payload.request as { input: { questions: Record<string, unknown>[] } }).input;
|
|
input.questions[0]!.customAnswer = { enabled: true };
|
|
const interaction = await projectNativeRuntimeRequest({ db, binding: binding(), event });
|
|
if (mode === "legacy") {
|
|
const payload = { ...interaction!.payload };
|
|
if ("questionSet" in payload) delete payload.questionSet;
|
|
await db.update(issueThreadInteractions).set({ payload }).where(eq(issueThreadInteractions.id, interaction!.id));
|
|
}
|
|
const service = issueThreadInteractionService(db);
|
|
await expect(service.answerQuestions({ id: issueId, companyId, status: "in_progress" }, interaction!.id,
|
|
respondIssueThreadInteractionSchema.parse({ answers: [{ questionId: "color", optionIds: [], otherText: " \n " }] }), { userId: "operator-1" },
|
|
)).rejects.toThrow(/requires an answer/);
|
|
const answered = await service.answerQuestions({ id: issueId, companyId, status: "in_progress" }, interaction!.id,
|
|
respondIssueThreadInteractionSchema.parse({ answers: [{ questionId: "color", optionIds: [], otherText: " Extra\\nline " }] }), { userId: "operator-1" },
|
|
);
|
|
expect(answered.result).toMatchObject({ answers: [{ questionId: "color", otherText: "Extra\nline" }] });
|
|
});
|
|
|
|
it("persists initial text without resolving and delivers only an explicit edited answer", async () => {
|
|
await seed();
|
|
const initialText = " Editable draft\n漢字\n";
|
|
const event = runtimeRequestEvent();
|
|
const request = event.payload.request as Record<string, unknown>;
|
|
request.input = { schema: "paperclip.question_set.v1", questions: [{ id: "draft", prompt: "Edit", required: true, answerMode: "text", initialText }] };
|
|
const interaction = await projectNativeRuntimeRequest({ db, binding: binding(), event });
|
|
expect(interaction).toMatchObject({ status: "pending", payload: { questionSet: { questions: [{ initialText }] } } });
|
|
const [stored] = await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.id, interaction!.id));
|
|
expect(stored).toMatchObject({ status: "pending", result: null, payload: { questionSet: { questions: [{ initialText }] } } });
|
|
const queueCommand = vi.fn(() => ({ commandId: "edited", controllerSeq: 1 }));
|
|
const release = registerNativeQuestionCommandTarget({ binding: { companyId, issueId, runId, agentId }, queueCommand });
|
|
try {
|
|
await flushNativeQuestionResponses(db, runId);
|
|
expect(queueCommand).not.toHaveBeenCalled();
|
|
const edited = "\n Operator 漢字 edited\n\nLiteral \\n stays literal. \n";
|
|
await issueThreadInteractionService(db).answerQuestions(
|
|
{ id: issueId, companyId, status: "in_progress" }, interaction!.id,
|
|
respondIssueThreadInteractionSchema.parse({ answers: [{ questionId: "draft", optionIds: [], otherText: edited }] }), { userId: "operator-1" },
|
|
);
|
|
await flushNativeQuestionResponses(db, runId);
|
|
expect(queueCommand).toHaveBeenCalledExactlyOnceWith("request.resolve", {
|
|
requestId: "request-1", response: { schema: "paperclip.question_response.v1", answers: { draft: { text: edited } } },
|
|
}, `question_${interaction!.id}`);
|
|
} finally { release(); }
|
|
});
|
|
|
|
it.each(["succeeded", "failed", "cancelled", "timed_out"])("delivers a historical answer exactly once after a %s native run", async status => {
|
|
await seed();
|
|
await db.update(issues).set({ conversationAgentId: agentId, conversationUserId: "operator-1", conversationState: "active", conversationSessionGeneration: 1, executionRunId: null }).where(eq(issues.id, issueId));
|
|
const interaction = await projectNativeRuntimeRequest({ db, binding: binding(), event: runtimeRequestEvent() });
|
|
await db.update(heartbeatRuns).set({ status, finishedAt: new Date() }).where(eq(heartbeatRuns.id, runId));
|
|
await issueThreadInteractionService(db).answerQuestions({ id: issueId, companyId, status: "in_progress" }, interaction!.id,
|
|
{ answers: [{ questionId: "color", optionIds: ["green"] }] }, { userId: "operator-1" });
|
|
const queueCommand = vi.fn();
|
|
const release = registerNativeQuestionCommandTarget({ binding: { companyId, issueId, runId, agentId }, queueCommand });
|
|
const targetRunId = randomUUID();
|
|
const wakeup = vi.fn(async () => db.insert(heartbeatRuns).values({ id: targetRunId, companyId, agentId, status: "queued",
|
|
contextSnapshot: { issueId } }).returning().then(rows => rows[0]!));
|
|
const service = questionResponseDeliveryService(db, { heartbeat: { wakeup } as never,
|
|
resolveNativeQuestion: candidate => deliverNativeQuestionResponse(db, candidate) });
|
|
expect(await service.deliver(interaction!.id)).toMatchObject({ status: "fallback_queued", targetRunId });
|
|
expect((await service.deliver(interaction!.id))?.duplicate).toBe(true);
|
|
expect(wakeup).toHaveBeenCalledTimes(1);
|
|
expect(JSON.stringify(wakeup.mock.calls)).toContain(interaction!.id);
|
|
const [saved] = await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.id, interaction!.id));
|
|
expect(saved).toMatchObject({ status: "answered", result: { answers: [{ questionId: "color", optionIds: ["green"] }] } });
|
|
const [delivery] = await db.select().from(issueQuestionResponseDeliveries).where(eq(issueQuestionResponseDeliveries.interactionId, interaction!.id));
|
|
expect(delivery).toMatchObject({ targetRunId, sourceRunId: runId, deliveryMode: "wake_fallback", status: "fallback_queued" });
|
|
expect(queueCommand).not.toHaveBeenCalled();
|
|
release();
|
|
});
|
|
|
|
it("binds projection to the persisted native run and ignores legacy delivery", async () => {
|
|
await seed();
|
|
const mismatched = runtimeRequestEvent();
|
|
mismatched.runId = randomUUID();
|
|
await expect(projectNativeRuntimeRequest({ db, binding: binding(), event: mismatched }))
|
|
.rejects.toThrow("native_runtime_request_binding_mismatch");
|
|
|
|
const interaction = await projectNativeRuntimeRequest({
|
|
db,
|
|
binding: binding(),
|
|
event: runtimeRequestEvent(),
|
|
});
|
|
const answered = await issueThreadInteractionService(db).answerQuestions(
|
|
{ id: issueId, companyId, status: "in_progress" },
|
|
interaction!.id,
|
|
{ answers: [{ questionId: "color", optionIds: ["green"] }] },
|
|
{ userId: "operator-1" },
|
|
);
|
|
await db.update(heartbeatRuns).set({ runtimeMode: "legacy" }).where(eq(heartbeatRuns.id, runId));
|
|
expect(answered.kind).toBe("ask_user_questions");
|
|
if (answered.kind !== "ask_user_questions") throw new Error("expected question interaction");
|
|
await expect(deliverNativeQuestionResponse(db, answered)).resolves.toBe("not_native");
|
|
await expect(nativeQuestionRunToCancel(db, answered)).resolves.toBeNull();
|
|
});
|
|
|
|
it("does not duplicate the task card when the runner replays a request", async () => {
|
|
await seed();
|
|
const first = await projectNativeRuntimeRequest({ db, binding: binding(), event: runtimeRequestEvent() });
|
|
const second = await projectNativeRuntimeRequest({ db, binding: binding(), event: runtimeRequestEvent() });
|
|
expect(second?.id).toBe(first?.id);
|
|
expect(await db.select().from(issueThreadInteractions)).toHaveLength(1);
|
|
expect(await db.select().from(activityLog)).toHaveLength(1);
|
|
});
|
|
|
|
async function addLaterHumanDirection(interactionId: string) {
|
|
const [question] = await db.select().from(issueThreadInteractions)
|
|
.where(eq(issueThreadInteractions.id, interactionId));
|
|
await db.insert(issueComments).values({ companyId, issueId, authorType: "user", authorUserId: "operator-1",
|
|
body: "Continue with the configuration already selected.", createdAt: new Date(question.createdAt.getTime() + 1000) });
|
|
}
|
|
|
|
it.each([false, true])("cancels the active native run when the task is cancelled (historical=%s)", async historical => {
|
|
await seed();
|
|
const interaction = await projectNativeRuntimeRequest({
|
|
db,
|
|
binding: binding(),
|
|
event: runtimeRequestEvent(),
|
|
});
|
|
if (historical) await addLaterHumanDirection(interaction!.id);
|
|
await issueService(db).update(issueId, { status: "cancelled" });
|
|
|
|
const [persistedInteraction] = await db.select({ status: issueThreadInteractions.status })
|
|
.from(issueThreadInteractions)
|
|
.where(eq(issueThreadInteractions.id, interaction!.id));
|
|
const [persistedRun] = await db.select({
|
|
status: heartbeatRuns.status,
|
|
resultJson: heartbeatRuns.resultJson,
|
|
}).from(heartbeatRuns).where(eq(heartbeatRuns.id, runId));
|
|
expect(persistedInteraction?.status).toBe("expired");
|
|
expect(persistedRun).toMatchObject({
|
|
status: "cancelled",
|
|
resultJson: {
|
|
cancelledByIssueStatus: "cancelled",
|
|
cancelledIssueId: issueId,
|
|
},
|
|
});
|
|
});
|
|
|
|
it.each([false, true])("defers native cancellation until task completion commits (historical=%s)", async historical => {
|
|
await seed();
|
|
const interaction = await projectNativeRuntimeRequest({
|
|
db,
|
|
binding: binding(),
|
|
event: runtimeRequestEvent(),
|
|
});
|
|
if (historical) await addLaterHumanDirection(interaction!.id);
|
|
const postCommitActions: IssuePostCommitAction[] = [];
|
|
await db.transaction(async (tx) => {
|
|
await issueService(db).update(
|
|
issueId,
|
|
{ status: "done" },
|
|
tx,
|
|
undefined,
|
|
postCommitActions,
|
|
);
|
|
const [runInsideTransaction] = await tx.select({ status: heartbeatRuns.status })
|
|
.from(heartbeatRuns)
|
|
.where(eq(heartbeatRuns.id, runId));
|
|
expect(runInsideTransaction?.status).toBe("running");
|
|
});
|
|
|
|
expect(postCommitActions).toHaveLength(1);
|
|
await executeIssuePostCommitActions(db, postCommitActions);
|
|
const [persistedRun] = await db.select({ status: heartbeatRuns.status })
|
|
.from(heartbeatRuns)
|
|
.where(eq(heartbeatRuns.id, runId));
|
|
expect(persistedRun?.status).toBe("cancelled");
|
|
const [question] = await db.select().from(issueThreadInteractions)
|
|
.where(eq(issueThreadInteractions.id, interaction!.id));
|
|
expect(question.status).toBe(historical ? "pending" : "expired");
|
|
if (historical) {
|
|
await issueThreadInteractionService(db).answerQuestions({ id: issueId, companyId, status: "done" }, interaction!.id,
|
|
{ answers: [{ questionId: "color", optionIds: ["green"] }] }, { userId: "operator-1" });
|
|
expect(await db.select().from(issueQuestionResponseDeliveries)).toEqual([]);
|
|
expect((await db.select().from(issues).where(eq(issues.id, issueId)))[0].status).toBe("done");
|
|
}
|
|
});
|
|
|
|
it.each([false, true])("recovers task closure cancellation after process exit (historical=%s)", async historical => {
|
|
await seed();
|
|
const interaction = await projectNativeRuntimeRequest({
|
|
db,
|
|
binding: binding(),
|
|
event: runtimeRequestEvent(),
|
|
});
|
|
if (historical) await addLaterHumanDirection(interaction!.id);
|
|
const postCommitActions: IssuePostCommitAction[] = [];
|
|
await db.transaction(async (tx) => {
|
|
await issueService(db).update(
|
|
issueId,
|
|
{ status: "done" },
|
|
tx,
|
|
undefined,
|
|
postCommitActions,
|
|
);
|
|
});
|
|
|
|
const [markedRun] = await db.select({
|
|
status: heartbeatRuns.status,
|
|
contextSnapshot: heartbeatRuns.contextSnapshot,
|
|
}).from(heartbeatRuns).where(eq(heartbeatRuns.id, runId));
|
|
expect(markedRun).toMatchObject({
|
|
status: "running",
|
|
contextSnapshot: {
|
|
nativeQuestionCancellation: {
|
|
version: 1,
|
|
issueId,
|
|
issueStatus: "done",
|
|
},
|
|
},
|
|
});
|
|
|
|
// Simulate process exit before executeIssuePostCommitActions can run.
|
|
await heartbeat.reapOrphanedRuns();
|
|
|
|
const [persistedRun] = await db.select({
|
|
status: heartbeatRuns.status,
|
|
resultJson: heartbeatRuns.resultJson,
|
|
}).from(heartbeatRuns).where(eq(heartbeatRuns.id, runId));
|
|
expect(persistedRun).toMatchObject({
|
|
status: "cancelled",
|
|
resultJson: {
|
|
cancelledByIssueStatus: "done",
|
|
cancelledIssueId: issueId,
|
|
},
|
|
});
|
|
const [question] = await db.select().from(issueThreadInteractions)
|
|
.where(eq(issueThreadInteractions.id, interaction!.id));
|
|
expect(question.status).toBe(historical ? "pending" : "expired");
|
|
});
|
|
|
|
it("recovers an explicit question withdrawal committed with its cancellation intent", async () => {
|
|
await seed();
|
|
const interaction = await projectNativeRuntimeRequest({
|
|
db,
|
|
binding: binding(),
|
|
event: runtimeRequestEvent(),
|
|
});
|
|
await issueThreadInteractionService(db).withdrawInteraction(
|
|
{ id: issueId, companyId },
|
|
interaction!.id,
|
|
{ reason: "No longer needed" },
|
|
{ userId: "operator-1" },
|
|
{
|
|
afterResolveInTransaction: async (tx, withdrawn) => {
|
|
await expect(requestNativeQuestionRunCancellation(tx, withdrawn, {
|
|
kind: "interaction_withdrawn",
|
|
interactionId: withdrawn.id,
|
|
})).resolves.toBe(runId);
|
|
},
|
|
},
|
|
);
|
|
|
|
const [markedRun] = await db.select({ contextSnapshot: heartbeatRuns.contextSnapshot })
|
|
.from(heartbeatRuns)
|
|
.where(eq(heartbeatRuns.id, runId));
|
|
expect(markedRun?.contextSnapshot).toMatchObject({
|
|
nativeQuestionCancellation: {
|
|
version: 1,
|
|
kind: "interaction_withdrawn",
|
|
interactionId: interaction!.id,
|
|
issueId,
|
|
},
|
|
});
|
|
|
|
await heartbeat.reapOrphanedRuns();
|
|
|
|
const [cancelledRun] = await db.select({
|
|
status: heartbeatRuns.status,
|
|
resultJson: heartbeatRuns.resultJson,
|
|
}).from(heartbeatRuns).where(eq(heartbeatRuns.id, runId));
|
|
expect(cancelledRun).toMatchObject({
|
|
status: "cancelled",
|
|
resultJson: {
|
|
withdrawnInteractionId: interaction!.id,
|
|
cancelledIssueId: issueId,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("removes the UI-only marker from a canonical custom response", async () => {
|
|
await seed();
|
|
const event = runtimeRequestEvent();
|
|
const request = event.payload.request as Record<string, unknown>;
|
|
const input = request.input as Record<string, unknown>;
|
|
input.questions = [{
|
|
id: "color",
|
|
prompt: "Which color?",
|
|
required: true,
|
|
answerMode: "single_select",
|
|
options: [{ id: "blue", label: "Blue" }],
|
|
customAnswer: { enabled: true, label: "Another color" },
|
|
}];
|
|
const interaction = await projectNativeRuntimeRequest({ db, binding: binding(), event });
|
|
const answer = {
|
|
answers: [{
|
|
questionId: "color",
|
|
optionIds: ["paperclip_custom_answer"],
|
|
otherText: "purple",
|
|
}],
|
|
};
|
|
await validateNativeQuestionResponseInput(interaction!, answer);
|
|
const answered = await issueThreadInteractionService(db).answerQuestions(
|
|
{ id: issueId, companyId, status: "in_progress" },
|
|
interaction!.id,
|
|
answer,
|
|
{ userId: "operator-1" },
|
|
);
|
|
expect(answered.kind).toBe("ask_user_questions");
|
|
if (answered.kind !== "ask_user_questions") throw new Error("expected question interaction");
|
|
|
|
const queueCommand = vi.fn(() => ({ commandId: "question", controllerSeq: 1 }));
|
|
registerNativeQuestionCommandTarget({
|
|
binding: { companyId, issueId, runId, agentId },
|
|
queueCommand,
|
|
});
|
|
await expect(deliverNativeQuestionResponse(db, answered)).resolves.toBe("queued");
|
|
expect(queueCommand).toHaveBeenCalledWith(
|
|
"request.resolve",
|
|
{
|
|
requestId: "request-1",
|
|
response: {
|
|
schema: "paperclip.question_response.v1",
|
|
answers: { color: { selectedOptionIds: [], customText: "purple" } },
|
|
},
|
|
},
|
|
`question_${interaction!.id}`,
|
|
);
|
|
});
|
|
});
|