typeclaw 0.48.12 → 0.49.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +6 -3
- package/scripts/dump-system-prompt.ts +52 -110
- package/src/agent/attention-escalation.ts +8 -5
- package/src/agent/auth-reloadable.ts +2 -3
- package/src/agent/auth.ts +59 -79
- package/src/agent/compaction.ts +2 -2
- package/src/agent/index.ts +173 -85
- package/src/agent/live-sessions.ts +2 -2
- package/src/agent/live-subagents.ts +1 -0
- package/src/agent/llm-replay-sanitizer.ts +1 -1
- package/src/agent/model-overrides.ts +1 -1
- package/src/agent/multimodal/look-at.ts +3 -3
- package/src/agent/multimodal/read-redirect.ts +1 -1
- package/src/agent/plugin-tools.ts +76 -39
- package/src/agent/prompt-cache-key.ts +42 -0
- package/src/agent/provider-error.ts +179 -10
- package/src/agent/reload-tool.ts +1 -1
- package/src/agent/restart-handoff/index.ts +7 -14
- package/src/agent/reviewer-activity.ts +68 -0
- package/src/agent/session-origin.ts +33 -0
- package/src/agent/subagents.ts +14 -2
- package/src/agent/system-prompt.ts +68 -202
- package/src/agent/todo/continuation-policy.ts +12 -4
- package/src/agent/tool-error-remediation.ts +1 -1
- package/src/agent/tool-file-safety.ts +113 -14
- package/src/agent/tool-not-found-nudge.ts +1 -1
- package/src/agent/tool-result-budget.ts +2 -2
- package/src/agent/tools/channel-disengage.ts +2 -2
- package/src/agent/tools/channel-edit.ts +2 -2
- package/src/agent/tools/channel-fetch-attachment.ts +2 -2
- package/src/agent/tools/channel-history-render.ts +2 -1
- package/src/agent/tools/channel-history.ts +2 -2
- package/src/agent/tools/channel-react.ts +2 -2
- package/src/agent/tools/channel-read.ts +2 -2
- package/src/agent/tools/channel-reply.ts +25 -7
- package/src/agent/tools/channel-send.ts +51 -9
- package/src/agent/tools/curl-impersonate.ts +11 -2
- package/src/agent/tools/grant-role.ts +2 -2
- package/src/agent/tools/post-github-review.ts +79 -17
- package/src/agent/tools/restart.ts +2 -2
- package/src/agent/tools/skip-response.ts +4 -4
- package/src/agent/tools/spawn-subagent.ts +165 -14
- package/src/agent/tools/stream-snapshot.ts +2 -2
- package/src/agent/tools/subagent-cancel.ts +2 -2
- package/src/agent/tools/subagent-output.ts +10 -2
- package/src/agent/tools/todo/index.ts +2 -2
- package/src/agent/tools/webfetch/tool.ts +2 -2
- package/src/agent/tools/websearch.ts +2 -2
- package/src/bundled-plugins/backup/README.md +10 -9
- package/src/bundled-plugins/backup/runner.ts +140 -58
- package/src/bundled-plugins/backup/subagents.ts +58 -26
- package/src/bundled-plugins/github-cli-auth/gh-command.ts +34 -2
- package/src/bundled-plugins/github-cli-auth/granted-push.ts +135 -0
- package/src/bundled-plugins/github-cli-auth/index.ts +83 -11
- package/src/bundled-plugins/github-cli-auth/review-account.ts +23 -0
- package/src/bundled-plugins/github-cli-auth/review-checkout.ts +9 -2
- package/src/bundled-plugins/github-cli-auth/review-recorder.ts +45 -7
- package/src/bundled-plugins/operator/operator.ts +15 -4
- package/src/bundled-plugins/reviewer/skills/code-review.ts +1 -1
- package/src/bundled-plugins/security/index.ts +50 -2
- package/src/bundled-plugins/security/policies/git-exfil.ts +24 -12
- package/src/channels/adapters/discord-bot-reactions.ts +18 -0
- package/src/channels/adapters/discord-bot.ts +122 -67
- package/src/channels/adapters/discord-reactions.ts +18 -0
- package/src/channels/adapters/discord.ts +114 -8
- package/src/channels/adapters/github/inbound.ts +103 -8
- package/src/channels/adapters/github/index.ts +251 -19
- package/src/channels/adapters/github/last-alive.ts +27 -0
- package/src/channels/adapters/github/outbound.ts +54 -18
- package/src/channels/adapters/github/pending-review-store.ts +141 -0
- package/src/channels/adapters/github/permission-guidance.ts +1 -0
- package/src/channels/adapters/github/reactions.ts +100 -0
- package/src/channels/adapters/github/reconcile-cooldown-store.ts +197 -67
- package/src/channels/adapters/github/reconcile-open-prs.ts +418 -33
- package/src/channels/adapters/github/recovery.ts +106 -0
- package/src/channels/adapters/github/review-check.ts +510 -0
- package/src/channels/adapters/github/review-submitter.ts +34 -2
- package/src/channels/adapters/instagram.ts +32 -14
- package/src/channels/adapters/kakaotalk.ts +22 -7
- package/src/channels/adapters/line.ts +18 -3
- package/src/channels/adapters/outbound-account.ts +20 -0
- package/src/channels/adapters/own-reactions.ts +66 -0
- package/src/channels/adapters/recovery-correlation.ts +214 -0
- package/src/channels/adapters/slack-bot-classify.ts +18 -11
- package/src/channels/adapters/slack-bot-dedupe.ts +111 -28
- package/src/channels/adapters/slack-bot-reactions.ts +18 -0
- package/src/channels/adapters/slack-bot.ts +125 -57
- package/src/channels/adapters/slack-classify.ts +25 -4
- package/src/channels/adapters/slack-inbound-revision.ts +96 -0
- package/src/channels/adapters/slack-reactions.ts +18 -0
- package/src/channels/adapters/slack-thread-ts.ts +6 -0
- package/src/channels/adapters/slack.ts +48 -3
- package/src/channels/adapters/teams.ts +14 -4
- package/src/channels/adapters/telegram-bot.ts +56 -10
- package/src/channels/adapters/webex-bot.ts +12 -2
- package/src/channels/adapters/webex.ts +12 -2
- package/src/channels/background-handoff.ts +434 -0
- package/src/channels/background-obligations.ts +893 -0
- package/src/channels/continuity-types.ts +271 -0
- package/src/channels/github-review-check.ts +598 -0
- package/src/channels/github-review-turn-ledger.ts +102 -28
- package/src/channels/github-review-verdict-coordinator.ts +96 -13
- package/src/channels/github-token-bridge.ts +11 -5
- package/src/channels/inbound-journal.ts +1738 -0
- package/src/channels/index.ts +6 -1
- package/src/channels/manager.ts +17 -7
- package/src/channels/recovery-dispatcher.ts +264 -0
- package/src/channels/recovery-notice.ts +94 -0
- package/src/channels/recovery-outbox.ts +459 -0
- package/src/channels/router.ts +2582 -633
- package/src/channels/schema.ts +8 -1
- package/src/channels/subagent-completion-bridge.ts +17 -14
- package/src/channels/types.ts +121 -16
- package/src/channels/waiting-reactions.ts +664 -0
- package/src/cli/compose.ts +7 -4
- package/src/cli/hostd.ts +49 -3
- package/src/cli/inspect.ts +11 -14
- package/src/cli/model.ts +7 -5
- package/src/cli/oauth-callbacks.ts +38 -23
- package/src/coding-agent/broker-body.ts +38 -0
- package/src/coding-agent/broker.ts +290 -0
- package/src/coding-agent/claude.ts +95 -0
- package/src/coding-agent/codex.ts +104 -0
- package/src/coding-agent/index.ts +506 -0
- package/src/coding-agent/omo-state.ts +69 -0
- package/src/coding-agent/omo-stream.ts +98 -0
- package/src/coding-agent/omo.ts +192 -0
- package/src/coding-agent/runner.ts +263 -0
- package/src/coding-agent/tool.ts +62 -0
- package/src/coding-agent/worktree.ts +355 -0
- package/src/compose/restart.ts +10 -3
- package/src/compose/start.ts +20 -3
- package/src/config/config.ts +70 -26
- package/src/config/providers.ts +278 -50
- package/src/container/exit-reason.ts +44 -0
- package/src/container/index.ts +5 -0
- package/src/container/log-archive.ts +51 -13
- package/src/container/memory-limit.ts +1 -1
- package/src/container/memory-oversubscription.ts +36 -6
- package/src/container/oom-events.ts +86 -0
- package/src/container/restart.ts +2 -0
- package/src/container/shared.ts +8 -1
- package/src/container/start.ts +25 -13
- package/src/container/stop.ts +6 -2
- package/src/container/tool-oom-priority.ts +32 -0
- package/src/cron/consumer.ts +10 -4
- package/src/cron/reloadable.ts +23 -2
- package/src/doctor/checks.ts +14 -2
- package/src/hostd/daemon.ts +20 -10
- package/src/hostd/spawn.ts +106 -5
- package/src/hostd/version.ts +20 -0
- package/src/hostd/watchdog.ts +241 -0
- package/src/init/dockerfile.ts +57 -592
- package/src/init/index.ts +6 -7
- package/src/init/oauth-login.ts +57 -17
- package/src/inspect/transcript-view.ts +6 -3
- package/src/mcp/client.ts +3 -1
- package/src/operations/classify-tool-outcome.ts +45 -1
- package/src/operations/incidents.ts +10 -5
- package/src/plugin/core-tool-names.ts +1 -1
- package/src/plugin/define.ts +1 -0
- package/src/plugin/index.ts +1 -0
- package/src/plugin/types.ts +6 -1
- package/src/run/background-handoff-boot.ts +86 -0
- package/src/run/channel-session-factory.ts +5 -4
- package/src/run/index.ts +93 -93
- package/src/run/resource-sample.ts +19 -0
- package/src/sandbox/build.ts +4 -0
- package/src/sandbox/coding-agent.ts +214 -0
- package/src/sandbox/policy.ts +1 -0
- package/src/sandbox/runtime-private.ts +4 -1
- package/src/secrets/coding-agent-auth.ts +97 -0
- package/src/secrets/index.ts +0 -16
- package/src/secrets/refresh-provider-oauth.ts +30 -76
- package/src/secrets/schema.ts +3 -4
- package/src/secrets/storage.ts +133 -234
- package/src/server/command-runner.ts +6 -2
- package/src/server/index.ts +102 -41
- package/src/sessions/index.ts +1 -1
- package/src/skills/typeclaw-channel-github/SKILL.md +7 -5
- package/src/skills/typeclaw-claude-code/SKILL.md +25 -260
- package/src/skills/typeclaw-claude-code/references/auth-flow.md +7 -23
- package/src/skills/typeclaw-claude-code/references/headless-sessions.md +11 -0
- package/src/skills/typeclaw-claude-code/references/results-and-worktrees.md +13 -0
- package/src/skills/typeclaw-codex-cli/SKILL.md +35 -270
- package/src/skills/typeclaw-codex-cli/references/auth-flow.md +13 -20
- package/src/skills/typeclaw-codex-cli/references/headless-sessions.md +26 -0
- package/src/skills/typeclaw-codex-cli/references/results-and-worktrees.md +28 -0
- package/src/skills/typeclaw-config/SKILL.md +24 -24
- package/src/skills/typeclaw-config/references/dockerfile.md +14 -13
- package/src/skills/typeclaw-cron/SKILL.md +1 -1
- package/src/skills/typeclaw-github-contributing/SKILL.md +2 -2
- package/src/skills/typeclaw-memory/SKILL.md +3 -3
- package/src/skills/typeclaw-omo-cli/SKILL.md +52 -0
- package/src/skills/typeclaw-omo-cli/references/auth-flow.md +11 -0
- package/src/skills/typeclaw-omo-cli/references/headless-sessions.md +11 -0
- package/src/skills/typeclaw-omo-cli/references/results-and-worktrees.md +23 -0
- package/src/skills/typeclaw-plugins/SKILL.md +20 -20
- package/src/skills/typeclaw-skills/SKILL.md +19 -2
- package/src/skills/typeclaw-troubleshooting/SKILL.md +15 -2
- package/src/tui/index.ts +5 -3
- package/src/tui/theme.ts +1 -1
- package/typeclaw.schema.json +44 -2
- package/src/agent/adaptive-thinking-compat.ts +0 -79
- package/src/secrets/claude-credentials-json.ts +0 -129
- package/src/secrets/codex-auth-json.ts +0 -102
- package/src/secrets/export-claude-credentials-file.ts +0 -270
- package/src/secrets/export-codex-auth-file.ts +0 -250
- package/src/secrets/oauth-xai.ts +0 -348
- package/src/skills/typeclaw-claude-code/references/stop-hook.md +0 -101
- package/src/skills/typeclaw-claude-code/references/tmux-driving.md +0 -243
- package/src/skills/typeclaw-codex-cli/references/stop-hook.md +0 -92
- package/src/skills/typeclaw-codex-cli/references/tmux-driving.md +0 -239
|
@@ -0,0 +1,664 @@
|
|
|
1
|
+
import { createHash, randomUUID } from 'node:crypto'
|
|
2
|
+
import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
|
|
3
|
+
import { readdir } from 'node:fs/promises'
|
|
4
|
+
import { join } from 'node:path'
|
|
5
|
+
import { setImmediate } from 'node:timers/promises'
|
|
6
|
+
|
|
7
|
+
import type {
|
|
8
|
+
ChannelKey,
|
|
9
|
+
OwnReactionTarget,
|
|
10
|
+
ReactionRef,
|
|
11
|
+
ReactionRequest,
|
|
12
|
+
ReactionResult,
|
|
13
|
+
RemoveOwnReactionRequest,
|
|
14
|
+
RemoveOwnReactionResult,
|
|
15
|
+
} from './types'
|
|
16
|
+
|
|
17
|
+
export interface WaitingReactionHandle {
|
|
18
|
+
readonly req: ReactionRequest
|
|
19
|
+
readonly ownerId: string
|
|
20
|
+
readonly ready: Promise<ReactionRef | null>
|
|
21
|
+
readonly generation: number
|
|
22
|
+
readonly epoch: string
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
export interface ProtectedAcknowledgmentScope {
|
|
26
|
+
conversation: ChannelKey
|
|
27
|
+
kind: string
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
interface ProtectedAcknowledgmentIdentity extends ProtectedAcknowledgmentScope {
|
|
31
|
+
id: string
|
|
32
|
+
target: ReactionRef
|
|
33
|
+
emoji: string
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
function sameConversation(first: ChannelKey, second: ChannelKey): boolean {
|
|
37
|
+
return (
|
|
38
|
+
first.adapter === second.adapter &&
|
|
39
|
+
first.workspace === second.workspace &&
|
|
40
|
+
first.chat === second.chat &&
|
|
41
|
+
(first.thread ?? null) === (second.thread ?? null)
|
|
42
|
+
)
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
function acknowledgmentIdentity(
|
|
46
|
+
scope: ProtectedAcknowledgmentScope,
|
|
47
|
+
prepared: OwnReactionTarget,
|
|
48
|
+
): ProtectedAcknowledgmentIdentity {
|
|
49
|
+
const conversation = { ...scope.conversation, thread: scope.conversation.thread ?? null }
|
|
50
|
+
const target = { ...prepared.target }
|
|
51
|
+
return {
|
|
52
|
+
conversation,
|
|
53
|
+
kind: scope.kind,
|
|
54
|
+
target,
|
|
55
|
+
emoji: prepared.emoji,
|
|
56
|
+
id: createHash('sha256')
|
|
57
|
+
.update(
|
|
58
|
+
JSON.stringify([
|
|
59
|
+
conversation.adapter,
|
|
60
|
+
conversation.workspace,
|
|
61
|
+
conversation.chat,
|
|
62
|
+
conversation.thread,
|
|
63
|
+
target.adapter,
|
|
64
|
+
target.value,
|
|
65
|
+
prepared.emoji,
|
|
66
|
+
scope.kind,
|
|
67
|
+
]),
|
|
68
|
+
)
|
|
69
|
+
.digest('hex'),
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
interface Owner {
|
|
74
|
+
ownerId: string
|
|
75
|
+
generation: number
|
|
76
|
+
epoch: string
|
|
77
|
+
protected: boolean
|
|
78
|
+
acknowledgment?: ProtectedAcknowledgmentIdentity
|
|
79
|
+
}
|
|
80
|
+
interface TupleRecord {
|
|
81
|
+
schemaVersion: 1
|
|
82
|
+
desired: 'present' | 'absent'
|
|
83
|
+
key: string
|
|
84
|
+
req: ReactionRequest
|
|
85
|
+
prepared: OwnReactionTarget
|
|
86
|
+
generation: number
|
|
87
|
+
owners: Owner[]
|
|
88
|
+
phase: 'adding' | 'present' | 'removing' | 'blocked' | 'absent'
|
|
89
|
+
failure?: RemoveOwnReactionResult
|
|
90
|
+
retryAt?: number
|
|
91
|
+
}
|
|
92
|
+
interface Reservation {
|
|
93
|
+
handle: WaitingReactionHandle
|
|
94
|
+
protected: boolean
|
|
95
|
+
acknowledgmentScope?: ProtectedAcknowledgmentScope
|
|
96
|
+
released: boolean
|
|
97
|
+
key?: string
|
|
98
|
+
prepared?: OwnReactionTarget
|
|
99
|
+
preparation: Promise<void>
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/** One runtime owns this journal. A new epoch takes over only after the old runtime stops. */
|
|
103
|
+
export function createWaitingReactionCoordinator(options: {
|
|
104
|
+
agentDir: string
|
|
105
|
+
epoch?: string
|
|
106
|
+
add: (req: ReactionRequest, prepared: OwnReactionTarget) => Promise<ReactionResult>
|
|
107
|
+
prepare: (req: ReactionRequest) => Promise<OwnReactionTarget | null>
|
|
108
|
+
remove: (req: RemoveOwnReactionRequest) => Promise<RemoveOwnReactionResult>
|
|
109
|
+
}) {
|
|
110
|
+
const epoch = options.epoch ?? randomUUID()
|
|
111
|
+
const directory = join(options.agentDir, 'channels', 'waiting-reactions')
|
|
112
|
+
let ownerGeneration = 0
|
|
113
|
+
const reservations = new Map<string, Reservation>()
|
|
114
|
+
const tupleReservations = new Map<string, Set<Reservation>>()
|
|
115
|
+
const preparing = new Set<Reservation>()
|
|
116
|
+
const retiredOwners = new Set<string>()
|
|
117
|
+
const lanes = new Map<string, Promise<unknown>>()
|
|
118
|
+
const snapshots = new WeakMap<TupleRecord, string>()
|
|
119
|
+
|
|
120
|
+
function lane<T>(key: string, operation: () => Promise<T>): Promise<T> {
|
|
121
|
+
const next = (lanes.get(key) ?? Promise.resolve()).catch(() => {}).then(operation)
|
|
122
|
+
lanes.set(key, next)
|
|
123
|
+
void next
|
|
124
|
+
.finally(() => {
|
|
125
|
+
if (lanes.get(key) === next) lanes.delete(key)
|
|
126
|
+
})
|
|
127
|
+
.catch(() => {})
|
|
128
|
+
return next
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
function path(key: string): string {
|
|
132
|
+
return join(directory, `${key}.json`)
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
function syncDirectory(directoryPath: string): void {
|
|
136
|
+
// Windows dev cannot fsync directories; ordinary file fsync remains mandatory.
|
|
137
|
+
if (process.platform === 'win32') return
|
|
138
|
+
const fd = openSync(directoryPath, 'r')
|
|
139
|
+
try {
|
|
140
|
+
fsyncSync(fd)
|
|
141
|
+
} finally {
|
|
142
|
+
closeSync(fd)
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
function saveIfChanged(record: TupleRecord): void {
|
|
147
|
+
record.desired = record.owners.length > 0 ? 'present' : 'absent'
|
|
148
|
+
if (snapshots.get(record) !== JSON.stringify(record)) save(record)
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
function retireAbsent(record: TupleRecord): void {
|
|
152
|
+
if (record.phase !== 'absent' || record.owners.length > 0 || live(record.key).length > 0) return
|
|
153
|
+
if ([...preparing].some((owner) => !owner.released && owner.handle.req.adapter === record.req.adapter)) return
|
|
154
|
+
const latest = load(record.key)
|
|
155
|
+
if (
|
|
156
|
+
!latest ||
|
|
157
|
+
latest.phase !== 'absent' ||
|
|
158
|
+
latest.generation !== record.generation ||
|
|
159
|
+
latest.owners.length > 0 ||
|
|
160
|
+
live(record.key).length > 0
|
|
161
|
+
)
|
|
162
|
+
return
|
|
163
|
+
try {
|
|
164
|
+
unlinkSync(path(record.key))
|
|
165
|
+
} catch (error) {
|
|
166
|
+
if ((error as NodeJS.ErrnoException).code === 'ENOENT') return
|
|
167
|
+
throw error
|
|
168
|
+
}
|
|
169
|
+
syncDirectory(directory)
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
function save(record: TupleRecord): void {
|
|
173
|
+
record.desired = record.owners.length > 0 ? 'present' : 'absent'
|
|
174
|
+
const createdDirectory = mkdirSync(directory, { recursive: true, mode: 0o700 })
|
|
175
|
+
const temp = join(directory, `${record.key}.${randomUUID()}.tmp`)
|
|
176
|
+
try {
|
|
177
|
+
const fd = openSync(temp, 'wx', 0o600)
|
|
178
|
+
try {
|
|
179
|
+
writeFileSync(fd, JSON.stringify(record))
|
|
180
|
+
fsyncSync(fd)
|
|
181
|
+
} finally {
|
|
182
|
+
closeSync(fd)
|
|
183
|
+
}
|
|
184
|
+
renameSync(temp, path(record.key))
|
|
185
|
+
syncDirectory(directory)
|
|
186
|
+
if (createdDirectory) {
|
|
187
|
+
for (const parent of [join(options.agentDir, 'channels'), options.agentDir]) {
|
|
188
|
+
syncDirectory(parent)
|
|
189
|
+
}
|
|
190
|
+
}
|
|
191
|
+
snapshots.set(record, JSON.stringify(record))
|
|
192
|
+
} catch (error) {
|
|
193
|
+
try {
|
|
194
|
+
unlinkSync(temp)
|
|
195
|
+
} catch (cleanupError) {
|
|
196
|
+
if ((cleanupError as NodeJS.ErrnoException).code !== 'ENOENT') report(cleanupError)
|
|
197
|
+
}
|
|
198
|
+
throw error
|
|
199
|
+
}
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
function load(key: string): TupleRecord | undefined {
|
|
203
|
+
try {
|
|
204
|
+
const record = JSON.parse(readFileSync(path(key), 'utf8')) as TupleRecord
|
|
205
|
+
const validRef = (ref: ReactionRef | undefined) =>
|
|
206
|
+
ref !== null &&
|
|
207
|
+
typeof ref === 'object' &&
|
|
208
|
+
typeof ref.adapter === 'string' &&
|
|
209
|
+
typeof ref.value === 'string' &&
|
|
210
|
+
ref.value.length > 0
|
|
211
|
+
const validString = (value: unknown) => typeof value === 'string' && value.length > 0
|
|
212
|
+
const validAcknowledgment = (owner: Owner): boolean => {
|
|
213
|
+
const acknowledgment = owner.acknowledgment
|
|
214
|
+
if (acknowledgment === undefined) return true
|
|
215
|
+
if (
|
|
216
|
+
!owner.protected ||
|
|
217
|
+
!acknowledgment ||
|
|
218
|
+
!validString(acknowledgment.kind) ||
|
|
219
|
+
!validString(acknowledgment.id) ||
|
|
220
|
+
!validRef(acknowledgment.target) ||
|
|
221
|
+
!acknowledgment.conversation ||
|
|
222
|
+
acknowledgment.conversation.adapter !== record.req?.adapter ||
|
|
223
|
+
!validString(acknowledgment.conversation.workspace) ||
|
|
224
|
+
!validString(acknowledgment.conversation.chat) ||
|
|
225
|
+
(acknowledgment.conversation.thread != null && typeof acknowledgment.conversation.thread !== 'string') ||
|
|
226
|
+
acknowledgment.target.adapter !== record.prepared?.target.adapter ||
|
|
227
|
+
acknowledgment.target.value !== record.prepared?.target.value ||
|
|
228
|
+
acknowledgment.emoji !== record.prepared?.emoji
|
|
229
|
+
)
|
|
230
|
+
return false
|
|
231
|
+
return acknowledgment.id === acknowledgmentIdentity(acknowledgment, record.prepared).id
|
|
232
|
+
}
|
|
233
|
+
if (
|
|
234
|
+
!record ||
|
|
235
|
+
record.schemaVersion !== 1 ||
|
|
236
|
+
record.key !== key ||
|
|
237
|
+
!Number.isSafeInteger(record.generation) ||
|
|
238
|
+
record.generation < 0 ||
|
|
239
|
+
!['adding', 'present', 'removing', 'blocked', 'absent'].includes(record.phase) ||
|
|
240
|
+
!['present', 'absent'].includes(record.desired) ||
|
|
241
|
+
!record.req ||
|
|
242
|
+
!validString(record.req.adapter) ||
|
|
243
|
+
!validString(record.req.workspace) ||
|
|
244
|
+
!validString(record.req.chat) ||
|
|
245
|
+
!validString(record.req.emoji) ||
|
|
246
|
+
!validRef(record.req.reactionRef) ||
|
|
247
|
+
(record.req.thread != null && typeof record.req.thread !== 'string') ||
|
|
248
|
+
!record.prepared ||
|
|
249
|
+
!validString(record.prepared.accountIdentity) ||
|
|
250
|
+
!validString(record.prepared.emoji) ||
|
|
251
|
+
!validRef(record.prepared.target) ||
|
|
252
|
+
record.prepared.target.adapter !== record.req.adapter ||
|
|
253
|
+
record.req.reactionRef.adapter !== record.req.adapter ||
|
|
254
|
+
!Array.isArray(record.owners) ||
|
|
255
|
+
record.owners.some(
|
|
256
|
+
(owner) =>
|
|
257
|
+
!owner ||
|
|
258
|
+
!validString(owner.ownerId) ||
|
|
259
|
+
!validString(owner.epoch) ||
|
|
260
|
+
typeof owner.protected !== 'boolean' ||
|
|
261
|
+
!Number.isSafeInteger(owner.generation) ||
|
|
262
|
+
owner.generation < 1 ||
|
|
263
|
+
!validAcknowledgment(owner),
|
|
264
|
+
) ||
|
|
265
|
+
record.desired !== (record.owners.length > 0 ? 'present' : 'absent') ||
|
|
266
|
+
new Set(record.owners.map((owner) => owner.ownerId)).size !== record.owners.length ||
|
|
267
|
+
(record.retryAt !== undefined && (!Number.isFinite(record.retryAt) || record.retryAt < 0)) ||
|
|
268
|
+
(record.failure !== undefined &&
|
|
269
|
+
(record.failure.ok !== false ||
|
|
270
|
+
!['unsupported', 'transient', 'rate-limit', 'permission', 'identity'].includes(record.failure.code) ||
|
|
271
|
+
typeof record.failure.error !== 'string' ||
|
|
272
|
+
(record.failure.retryAfter !== undefined &&
|
|
273
|
+
(!Number.isFinite(record.failure.retryAfter) || record.failure.retryAfter < 0)))) ||
|
|
274
|
+
createHash('sha256')
|
|
275
|
+
.update(
|
|
276
|
+
JSON.stringify([
|
|
277
|
+
record.req.adapter,
|
|
278
|
+
record.prepared.accountIdentity,
|
|
279
|
+
record.prepared.target.adapter,
|
|
280
|
+
record.prepared.target.value,
|
|
281
|
+
record.prepared.emoji,
|
|
282
|
+
]),
|
|
283
|
+
)
|
|
284
|
+
.digest('hex') !== key
|
|
285
|
+
) {
|
|
286
|
+
throw new Error('Invalid waiting reaction journal')
|
|
287
|
+
}
|
|
288
|
+
snapshots.set(record, JSON.stringify(record))
|
|
289
|
+
record.owners = record.owners.filter(
|
|
290
|
+
(owner) => !retiredOwners.has(owner.ownerId) && (owner.protected || owner.epoch === epoch),
|
|
291
|
+
)
|
|
292
|
+
return record
|
|
293
|
+
} catch (error) {
|
|
294
|
+
if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined
|
|
295
|
+
throw error
|
|
296
|
+
}
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
function live(key: string): Reservation[] {
|
|
300
|
+
return [...(tupleReservations.get(key) ?? [])].filter((owner) => !owner.released)
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
function mergeOwners(record: TupleRecord): void {
|
|
304
|
+
for (const owner of live(record.key)) {
|
|
305
|
+
if (
|
|
306
|
+
!record.owners.some(
|
|
307
|
+
(item) => item.ownerId === owner.handle.ownerId && item.generation === owner.handle.generation,
|
|
308
|
+
)
|
|
309
|
+
) {
|
|
310
|
+
record.owners.push({
|
|
311
|
+
ownerId: owner.handle.ownerId,
|
|
312
|
+
generation: owner.handle.generation,
|
|
313
|
+
epoch,
|
|
314
|
+
protected: owner.protected,
|
|
315
|
+
...(owner.acknowledgmentScope
|
|
316
|
+
? { acknowledgment: acknowledgmentIdentity(owner.acknowledgmentScope, record.prepared) }
|
|
317
|
+
: {}),
|
|
318
|
+
})
|
|
319
|
+
}
|
|
320
|
+
}
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
async function ensurePresent(
|
|
324
|
+
record: TupleRecord,
|
|
325
|
+
acquiredPreparation?: OwnReactionTarget,
|
|
326
|
+
): Promise<ReactionRef | null> {
|
|
327
|
+
mergeOwners(record)
|
|
328
|
+
record.generation++
|
|
329
|
+
if (record.phase === 'present') {
|
|
330
|
+
saveIfChanged(record)
|
|
331
|
+
return record.prepared.target
|
|
332
|
+
}
|
|
333
|
+
const captured = acquiredPreparation ?? live(record.key).find((owner) => owner.prepared)?.prepared
|
|
334
|
+
const prepared = captured ?? (await options.prepare(record.req))
|
|
335
|
+
if (
|
|
336
|
+
!prepared ||
|
|
337
|
+
prepared.accountIdentity !== record.prepared.accountIdentity ||
|
|
338
|
+
prepared.target.adapter !== record.prepared.target.adapter ||
|
|
339
|
+
prepared.target.value !== record.prepared.target.value ||
|
|
340
|
+
prepared.emoji !== record.prepared.emoji
|
|
341
|
+
)
|
|
342
|
+
return null
|
|
343
|
+
record.prepared = prepared
|
|
344
|
+
record.phase = 'adding'
|
|
345
|
+
delete record.failure
|
|
346
|
+
delete record.retryAt
|
|
347
|
+
// Fsync the intent before the transport can observe the add, including a crash inside add.
|
|
348
|
+
save(record)
|
|
349
|
+
if (record.owners.length === 0) return null
|
|
350
|
+
const result = await options.add(record.req, record.prepared)
|
|
351
|
+
if (!result.ok) {
|
|
352
|
+
// Unsupported is a definite preflight refusal, not an uncertain transport outcome.
|
|
353
|
+
if (result.code === 'unsupported') {
|
|
354
|
+
record.phase = 'absent'
|
|
355
|
+
save(record)
|
|
356
|
+
}
|
|
357
|
+
return null
|
|
358
|
+
}
|
|
359
|
+
record.phase = 'present'
|
|
360
|
+
save(record)
|
|
361
|
+
return record.prepared.target
|
|
362
|
+
}
|
|
363
|
+
|
|
364
|
+
async function ensureAbsent(record: TupleRecord): Promise<void> {
|
|
365
|
+
// Preparation publishes canonical reservations before it queues work on this lane.
|
|
366
|
+
await Promise.all(
|
|
367
|
+
[...preparing]
|
|
368
|
+
.filter((owner) => owner.handle.req.adapter === record.req.adapter)
|
|
369
|
+
.map((owner) => owner.preparation),
|
|
370
|
+
)
|
|
371
|
+
mergeOwners(record)
|
|
372
|
+
if (record.owners.length > 0) {
|
|
373
|
+
if (live(record.key).length > 0 && record.phase !== 'present') await ensurePresent(record)
|
|
374
|
+
else saveIfChanged(record)
|
|
375
|
+
return
|
|
376
|
+
}
|
|
377
|
+
if (record.phase === 'absent') {
|
|
378
|
+
retireAbsent(record)
|
|
379
|
+
return
|
|
380
|
+
}
|
|
381
|
+
if (record.retryAt !== undefined && Date.now() < record.retryAt) {
|
|
382
|
+
saveIfChanged(record)
|
|
383
|
+
return
|
|
384
|
+
}
|
|
385
|
+
record.generation++
|
|
386
|
+
record.phase = 'removing'
|
|
387
|
+
save(record)
|
|
388
|
+
const generation = record.generation
|
|
389
|
+
// No await between the final owner/generation check and transport invocation.
|
|
390
|
+
const latest = load(record.key)
|
|
391
|
+
if (!latest || latest.generation !== generation || latest.owners.length > 0 || live(record.key).length > 0) return
|
|
392
|
+
let result: RemoveOwnReactionResult
|
|
393
|
+
try {
|
|
394
|
+
result = await options.remove({
|
|
395
|
+
adapter: record.req.adapter,
|
|
396
|
+
workspace: record.req.workspace,
|
|
397
|
+
chat: record.req.chat,
|
|
398
|
+
thread: record.req.thread,
|
|
399
|
+
target: record.prepared.target,
|
|
400
|
+
emoji: record.prepared.emoji,
|
|
401
|
+
expectedAccountIdentity: record.prepared.accountIdentity,
|
|
402
|
+
})
|
|
403
|
+
} catch (error) {
|
|
404
|
+
result = { ok: false, code: 'transient', error: String(error) }
|
|
405
|
+
}
|
|
406
|
+
if (!result.ok) {
|
|
407
|
+
record.phase = 'blocked'
|
|
408
|
+
record.failure = result
|
|
409
|
+
const delay = result.retryAfter ?? (result.code === 'transient' || result.code === 'rate-limit' ? 1_000 : 0)
|
|
410
|
+
record.retryAt = Date.now() + Math.max(0, delay)
|
|
411
|
+
save(record)
|
|
412
|
+
return
|
|
413
|
+
}
|
|
414
|
+
// Publish absence before retirement; pending canonical owners still rely on this tuple.
|
|
415
|
+
record.phase = 'absent'
|
|
416
|
+
delete record.failure
|
|
417
|
+
delete record.retryAt
|
|
418
|
+
save(record)
|
|
419
|
+
if (live(record.key).length > 0) await ensurePresent(record)
|
|
420
|
+
else retireAbsent(record)
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
function report(error: unknown): void {
|
|
424
|
+
console.warn('[waiting-reactions] Durable reaction operation failed:', error)
|
|
425
|
+
}
|
|
426
|
+
|
|
427
|
+
function acquire(
|
|
428
|
+
req: ReactionRequest,
|
|
429
|
+
protectedPresence = false,
|
|
430
|
+
acknowledgmentScope?: ProtectedAcknowledgmentScope,
|
|
431
|
+
): WaitingReactionHandle {
|
|
432
|
+
const ownerId = randomUUID()
|
|
433
|
+
let resolveReady!: (ref: ReactionRef | null) => void
|
|
434
|
+
const ready = new Promise<ReactionRef | null>((resolve) => {
|
|
435
|
+
resolveReady = resolve
|
|
436
|
+
})
|
|
437
|
+
const handle: WaitingReactionHandle = {
|
|
438
|
+
req: { ...req, reactionRef: { ...req.reactionRef } },
|
|
439
|
+
ownerId,
|
|
440
|
+
generation: ++ownerGeneration,
|
|
441
|
+
epoch,
|
|
442
|
+
ready,
|
|
443
|
+
}
|
|
444
|
+
const reservation: Reservation = {
|
|
445
|
+
handle,
|
|
446
|
+
protected: protectedPresence,
|
|
447
|
+
...(protectedPresence && acknowledgmentScope
|
|
448
|
+
? {
|
|
449
|
+
acknowledgmentScope: {
|
|
450
|
+
conversation: { ...acknowledgmentScope.conversation },
|
|
451
|
+
kind: acknowledgmentScope.kind,
|
|
452
|
+
},
|
|
453
|
+
}
|
|
454
|
+
: {}),
|
|
455
|
+
released: false,
|
|
456
|
+
preparation: Promise.resolve(),
|
|
457
|
+
}
|
|
458
|
+
// Reserve synchronously: release/recovery must see this owner even before prepare resolves.
|
|
459
|
+
reservations.set(ownerId, reservation)
|
|
460
|
+
preparing.add(reservation)
|
|
461
|
+
const preparationKey = `prepare:${JSON.stringify(handle.req)}`
|
|
462
|
+
reservation.preparation = lane(preparationKey, async () => {
|
|
463
|
+
const prepared = await options.prepare(handle.req)
|
|
464
|
+
if (!prepared) return
|
|
465
|
+
const key = createHash('sha256')
|
|
466
|
+
.update(
|
|
467
|
+
JSON.stringify([
|
|
468
|
+
handle.req.adapter,
|
|
469
|
+
prepared.accountIdentity,
|
|
470
|
+
prepared.target.adapter,
|
|
471
|
+
prepared.target.value,
|
|
472
|
+
prepared.emoji,
|
|
473
|
+
]),
|
|
474
|
+
)
|
|
475
|
+
.digest('hex')
|
|
476
|
+
reservation.key = key
|
|
477
|
+
reservation.prepared = prepared
|
|
478
|
+
let owners = tupleReservations.get(key)
|
|
479
|
+
if (!owners) {
|
|
480
|
+
owners = new Set()
|
|
481
|
+
tupleReservations.set(key, owners)
|
|
482
|
+
}
|
|
483
|
+
owners.add(reservation)
|
|
484
|
+
void lane(key, async () => {
|
|
485
|
+
if (reservation.released) return null
|
|
486
|
+
const record: TupleRecord = load(key) ?? {
|
|
487
|
+
schemaVersion: 1,
|
|
488
|
+
desired: 'present',
|
|
489
|
+
key,
|
|
490
|
+
req: handle.req,
|
|
491
|
+
prepared,
|
|
492
|
+
generation: 0,
|
|
493
|
+
owners: [],
|
|
494
|
+
phase: 'adding',
|
|
495
|
+
}
|
|
496
|
+
record.prepared = prepared
|
|
497
|
+
return ensurePresent(record, prepared)
|
|
498
|
+
}).then(resolveReady, (error) => {
|
|
499
|
+
report(error)
|
|
500
|
+
resolveReady(null)
|
|
501
|
+
})
|
|
502
|
+
})
|
|
503
|
+
.catch((error) => {
|
|
504
|
+
report(error)
|
|
505
|
+
})
|
|
506
|
+
.finally(() => {
|
|
507
|
+
preparing.delete(reservation)
|
|
508
|
+
if (!reservation.key) resolveReady(null)
|
|
509
|
+
})
|
|
510
|
+
return handle
|
|
511
|
+
}
|
|
512
|
+
|
|
513
|
+
async function release(handle: WaitingReactionHandle): Promise<void> {
|
|
514
|
+
const owner = reservations.get(handle.ownerId)
|
|
515
|
+
// Handles are capability tokens: a stale/foreign callback cannot retire another owner.
|
|
516
|
+
if (!owner || owner.handle !== handle || owner.released) return
|
|
517
|
+
owner.released = true
|
|
518
|
+
retiredOwners.add(handle.ownerId)
|
|
519
|
+
await owner.preparation
|
|
520
|
+
if (!owner.key) {
|
|
521
|
+
reservations.delete(handle.ownerId)
|
|
522
|
+
retiredOwners.delete(handle.ownerId)
|
|
523
|
+
return
|
|
524
|
+
}
|
|
525
|
+
try {
|
|
526
|
+
await lane(owner.key, async () => {
|
|
527
|
+
const record = load(owner.key!)
|
|
528
|
+
if (!record) return
|
|
529
|
+
record.owners = record.owners.filter(
|
|
530
|
+
(item) =>
|
|
531
|
+
item.ownerId !== handle.ownerId || item.generation !== handle.generation || item.epoch !== handle.epoch,
|
|
532
|
+
)
|
|
533
|
+
await ensureAbsent(record)
|
|
534
|
+
})
|
|
535
|
+
retiredOwners.delete(handle.ownerId)
|
|
536
|
+
} catch (error) {
|
|
537
|
+
report(error)
|
|
538
|
+
}
|
|
539
|
+
const owners = tupleReservations.get(owner.key)
|
|
540
|
+
owners?.delete(owner)
|
|
541
|
+
if (owners?.size === 0) tupleReservations.delete(owner.key)
|
|
542
|
+
reservations.delete(handle.ownerId)
|
|
543
|
+
}
|
|
544
|
+
|
|
545
|
+
// Only the router's genuine-reply decision may use this path. Capture live
|
|
546
|
+
// capabilities now; future acknowledgments in the same conversation survive.
|
|
547
|
+
async function retireAcknowledgments(conversation: ChannelKey): Promise<void> {
|
|
548
|
+
const capturedConversation = { ...conversation }
|
|
549
|
+
const current = [...reservations.values()].filter(
|
|
550
|
+
(owner) =>
|
|
551
|
+
!owner.released &&
|
|
552
|
+
owner.protected &&
|
|
553
|
+
owner.acknowledgmentScope &&
|
|
554
|
+
sameConversation(owner.acknowledgmentScope.conversation, capturedConversation),
|
|
555
|
+
)
|
|
556
|
+
const capturedIds = new Set(current.map((owner) => owner.handle.ownerId))
|
|
557
|
+
const releases = current.map((owner) => release(owner.handle))
|
|
558
|
+
let files: string[]
|
|
559
|
+
try {
|
|
560
|
+
files = await readdir(directory)
|
|
561
|
+
} catch (error) {
|
|
562
|
+
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') report(error)
|
|
563
|
+
await Promise.all(releases)
|
|
564
|
+
return
|
|
565
|
+
}
|
|
566
|
+
for (let offset = 0; offset < files.length; offset += 16) {
|
|
567
|
+
await setImmediate()
|
|
568
|
+
await Promise.all(
|
|
569
|
+
files
|
|
570
|
+
.slice(offset, offset + 16)
|
|
571
|
+
.filter((file) => /^[a-f0-9]{64}\.json$/.test(file))
|
|
572
|
+
.map(async (file) => {
|
|
573
|
+
const key = file.slice(0, -5)
|
|
574
|
+
try {
|
|
575
|
+
const record = load(key)
|
|
576
|
+
if (!record) return
|
|
577
|
+
const claims = record.owners.filter(
|
|
578
|
+
(owner) =>
|
|
579
|
+
owner.protected &&
|
|
580
|
+
owner.acknowledgment &&
|
|
581
|
+
sameConversation(owner.acknowledgment.conversation, capturedConversation) &&
|
|
582
|
+
(owner.epoch !== epoch || capturedIds.has(owner.ownerId) || !reservations.has(owner.ownerId)),
|
|
583
|
+
)
|
|
584
|
+
if (claims.length === 0) return
|
|
585
|
+
await lane(key, async () => {
|
|
586
|
+
const latest = load(key)
|
|
587
|
+
if (!latest) return
|
|
588
|
+
latest.owners = latest.owners.filter(
|
|
589
|
+
(owner) =>
|
|
590
|
+
!claims.some(
|
|
591
|
+
(claim) =>
|
|
592
|
+
owner.ownerId === claim.ownerId &&
|
|
593
|
+
owner.generation === claim.generation &&
|
|
594
|
+
owner.epoch === claim.epoch &&
|
|
595
|
+
owner.acknowledgment?.id === claim.acknowledgment?.id,
|
|
596
|
+
),
|
|
597
|
+
)
|
|
598
|
+
await ensureAbsent(latest)
|
|
599
|
+
})
|
|
600
|
+
} catch (error) {
|
|
601
|
+
report(error)
|
|
602
|
+
}
|
|
603
|
+
}),
|
|
604
|
+
)
|
|
605
|
+
}
|
|
606
|
+
await Promise.all(releases)
|
|
607
|
+
}
|
|
608
|
+
|
|
609
|
+
const recoveries = new Map<string, Promise<void>>()
|
|
610
|
+
const recoveringTuples = new Map<string, Promise<void>>()
|
|
611
|
+
|
|
612
|
+
async function recoverRecords(adapter?: ReactionRequest['adapter']): Promise<void> {
|
|
613
|
+
await Promise.all(
|
|
614
|
+
[...preparing]
|
|
615
|
+
.filter((owner) => !adapter || owner.handle.req.adapter === adapter)
|
|
616
|
+
.map((owner) => owner.preparation),
|
|
617
|
+
)
|
|
618
|
+
let files: string[]
|
|
619
|
+
try {
|
|
620
|
+
files = await readdir(directory)
|
|
621
|
+
} catch (error) {
|
|
622
|
+
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') report(error)
|
|
623
|
+
return
|
|
624
|
+
}
|
|
625
|
+
for (let offset = 0; offset < files.length; offset += 16) {
|
|
626
|
+
// Bound synchronous tuple work and give reply timers a turn even for protected history.
|
|
627
|
+
await setImmediate()
|
|
628
|
+
await Promise.all(
|
|
629
|
+
files
|
|
630
|
+
.slice(offset, offset + 16)
|
|
631
|
+
.filter((file) => /^[a-f0-9]{64}\.json$/.test(file))
|
|
632
|
+
.map((file) => {
|
|
633
|
+
const key = file.slice(0, -5)
|
|
634
|
+
const existing = recoveringTuples.get(key)
|
|
635
|
+
if (existing) return existing
|
|
636
|
+
const pending = lane(key, async () => {
|
|
637
|
+
const record = load(key)
|
|
638
|
+
if (!record || (adapter && record.req.adapter !== adapter)) return
|
|
639
|
+
await ensureAbsent(record)
|
|
640
|
+
})
|
|
641
|
+
.catch(report)
|
|
642
|
+
.finally(() => {
|
|
643
|
+
recoveringTuples.delete(key)
|
|
644
|
+
})
|
|
645
|
+
recoveringTuples.set(key, pending)
|
|
646
|
+
return pending
|
|
647
|
+
}),
|
|
648
|
+
)
|
|
649
|
+
}
|
|
650
|
+
}
|
|
651
|
+
|
|
652
|
+
function recover(adapter?: ReactionRequest['adapter']): Promise<void> {
|
|
653
|
+
const key = adapter ?? '*'
|
|
654
|
+
const existing = recoveries.get(key)
|
|
655
|
+
if (existing) return existing
|
|
656
|
+
const pending = recoverRecords(adapter).finally(() => {
|
|
657
|
+
recoveries.delete(key)
|
|
658
|
+
})
|
|
659
|
+
recoveries.set(key, pending)
|
|
660
|
+
return pending
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
return { acquire, release, recover, retireAcknowledgments }
|
|
664
|
+
}
|