typeclaw 0.38.1 → 0.39.1
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/README.md +5 -0
- package/package.json +2 -2
- package/src/agent/attention-escalation.ts +158 -7
- package/src/agent/auth.ts +2 -2
- package/src/agent/git-nudge.ts +7 -7
- package/src/agent/index.ts +25 -2
- package/src/agent/restart/index.ts +17 -8
- package/src/agent/session-origin.ts +21 -0
- package/src/agent/subagents.ts +29 -1
- package/src/agent/system-prompt.ts +18 -5
- package/src/agent/tools/restart.ts +0 -3
- package/src/agent/tools/spawn-subagent.ts +7 -0
- package/src/bundled-plugins/backup/index.ts +5 -2
- package/src/bundled-plugins/backup/runner.ts +55 -23
- package/src/bundled-plugins/guard/policies/uncommitted-changes.ts +7 -8
- package/src/bundled-plugins/memory/dreaming.ts +37 -24
- package/src/bundled-plugins/memory/index.ts +24 -6
- package/src/bundled-plugins/memory/memory-logger.ts +14 -10
- package/src/bundled-plugins/operator/operator.ts +1 -0
- package/src/channels/adapters/kakaotalk-membership.ts +67 -0
- package/src/channels/adapters/kakaotalk.ts +8 -0
- package/src/channels/adapters/line-token.ts +55 -0
- package/src/channels/adapters/line.ts +74 -0
- package/src/channels/adapters/webex-bot-classify.ts +14 -1
- package/src/channels/adapters/webex-bot.ts +24 -1
- package/src/channels/adapters/webex-classify.ts +16 -1
- package/src/channels/adapters/webex.ts +27 -1
- package/src/channels/router.ts +55 -2
- package/src/cli/hostd.ts +40 -0
- package/src/cli/model.ts +143 -3
- package/src/config/config.ts +101 -36
- package/src/config/index.ts +3 -0
- package/src/config/models-mutation.ts +105 -15
- package/src/config/providers-mutation.ts +4 -4
- package/src/config/providers.ts +6 -14
- package/src/container/shared.ts +136 -14
- package/src/container/shell.ts +12 -2
- package/src/container/start.ts +25 -7
- package/src/doctor/commit.ts +10 -10
- package/src/dreams/git.ts +20 -7
- package/src/dreams/index.ts +22 -7
- package/src/git/reconcile-ignored.ts +56 -27
- package/src/git/resolve-agent-git.ts +12 -0
- package/src/git/system-commit.ts +16 -10
- package/src/hostd/daemon.ts +16 -0
- package/src/hostd/index.ts +1 -11
- package/src/hostd/paths.ts +0 -16
- package/src/hostd/webex-renewal-manager.ts +216 -0
- package/src/init/dockerfile.ts +13 -4
- package/src/init/gitignore.ts +4 -2
- package/src/run/index.ts +4 -1
- package/src/secrets/schema.ts +1 -0
- package/src/secrets/webex-renewal.ts +215 -0
- package/src/server/index.ts +25 -3
- package/src/skills/typeclaw-config/SKILL.md +18 -16
- package/typeclaw.schema.json +172 -1
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
import { existsSync } from 'node:fs'
|
|
2
2
|
import { join } from 'node:path'
|
|
3
3
|
|
|
4
|
+
import { type AgentGit, resolveAgentGit } from '@/git/resolve-agent-git'
|
|
5
|
+
|
|
4
6
|
export const COMMIT_TIMEOUT_MS = 30_000
|
|
5
7
|
export const NETWORK_TIMEOUT_MS = 60_000
|
|
6
8
|
|
|
@@ -64,9 +66,10 @@ type PushPlan = ActivePushPlan | { kind: 'skip' }
|
|
|
64
66
|
export async function runBackup(options: BackupRunnerOptions, deps: BackupRunnerDeps): Promise<BackupResult> {
|
|
65
67
|
const { cwd, pushToOrigin } = options
|
|
66
68
|
|
|
67
|
-
|
|
69
|
+
const repo = resolveAgentGit(cwd)
|
|
70
|
+
if (!repo) return { ok: true, kind: 'no-repo' }
|
|
68
71
|
|
|
69
|
-
const status = await deps.gitSpawn(['status', '--porcelain=v1', '--untracked-files=all'], {
|
|
72
|
+
const status = await deps.gitSpawn([...repo.gitArgs, 'status', '--porcelain=v1', '--untracked-files=all'], {
|
|
70
73
|
cwd,
|
|
71
74
|
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
72
75
|
})
|
|
@@ -76,23 +79,32 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
|
|
|
76
79
|
if (dirty.length === 0 && force.length === 0) return { ok: true, kind: 'clean' }
|
|
77
80
|
|
|
78
81
|
if (dirty.length > 0) {
|
|
79
|
-
const add = await deps.gitSpawn(['add', '--', ...dirty], { cwd, timeoutMs: COMMIT_TIMEOUT_MS })
|
|
82
|
+
const add = await deps.gitSpawn([...repo.gitArgs, 'add', '--', ...dirty], { cwd, timeoutMs: COMMIT_TIMEOUT_MS })
|
|
80
83
|
if (add.exitCode !== 0) return { ok: false, kind: 'commit-failed', reason: `git add failed: ${shortErr(add)}` }
|
|
81
84
|
}
|
|
82
85
|
if (force.length > 0) {
|
|
83
86
|
const present = force.filter((p) => existsSync(join(cwd, p)))
|
|
84
87
|
if (present.length > 0) {
|
|
85
|
-
const addF = await deps.gitSpawn(['add', '-f', '--', ...present], {
|
|
88
|
+
const addF = await deps.gitSpawn([...repo.gitArgs, 'add', '-f', '--', ...present], {
|
|
89
|
+
cwd,
|
|
90
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
91
|
+
})
|
|
86
92
|
if (addF.exitCode !== 0) {
|
|
87
93
|
return { ok: false, kind: 'commit-failed', reason: `git add -f failed: ${shortErr(addF)}` }
|
|
88
94
|
}
|
|
89
95
|
}
|
|
90
96
|
}
|
|
91
97
|
|
|
92
|
-
const stagedCheck = await deps.gitSpawn(['diff', '--cached', '--quiet'], {
|
|
98
|
+
const stagedCheck = await deps.gitSpawn([...repo.gitArgs, 'diff', '--cached', '--quiet'], {
|
|
99
|
+
cwd,
|
|
100
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
101
|
+
})
|
|
93
102
|
if (stagedCheck.exitCode === 0) return { ok: true, kind: 'clean' }
|
|
94
103
|
|
|
95
|
-
const diffstat = await deps.gitSpawn(['diff', '--cached', '--stat'], {
|
|
104
|
+
const diffstat = await deps.gitSpawn([...repo.gitArgs, 'diff', '--cached', '--stat'], {
|
|
105
|
+
cwd,
|
|
106
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
107
|
+
})
|
|
96
108
|
const message = await deps.pickCommitMessage({
|
|
97
109
|
status: status.stdout.slice(0, 4096),
|
|
98
110
|
diffstat: diffstat.stdout.slice(0, 4096),
|
|
@@ -106,14 +118,17 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
|
|
|
106
118
|
// one-cycle-behind churn. Re-status, filter to `sessions/` additions
|
|
107
119
|
// only (don't accidentally stage user work that arrived during the
|
|
108
120
|
// window), and force-add anything new.
|
|
109
|
-
const reStatus = await deps.gitSpawn(['status', '--porcelain=v1', '--untracked-files=all'], {
|
|
121
|
+
const reStatus = await deps.gitSpawn([...repo.gitArgs, 'status', '--porcelain=v1', '--untracked-files=all'], {
|
|
110
122
|
cwd,
|
|
111
123
|
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
112
124
|
})
|
|
113
125
|
if (reStatus.exitCode === 0) {
|
|
114
126
|
const lateForce = filterForceAdd(parsePorcelain(reStatus.stdout)).filter((p) => existsSync(join(cwd, p)))
|
|
115
127
|
if (lateForce.length > 0) {
|
|
116
|
-
const lateAdd = await deps.gitSpawn(['add', '-f', '--', ...lateForce], {
|
|
128
|
+
const lateAdd = await deps.gitSpawn([...repo.gitArgs, 'add', '-f', '--', ...lateForce], {
|
|
129
|
+
cwd,
|
|
130
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
131
|
+
})
|
|
117
132
|
if (lateAdd.exitCode !== 0) {
|
|
118
133
|
return { ok: false, kind: 'commit-failed', reason: `git add -f (post-message) failed: ${shortErr(lateAdd)}` }
|
|
119
134
|
}
|
|
@@ -121,16 +136,19 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
|
|
|
121
136
|
}
|
|
122
137
|
|
|
123
138
|
const safeMessage = sanitizeCommitMessage(message)
|
|
124
|
-
const commit = await deps.gitSpawn(['commit', '-m', safeMessage], {
|
|
139
|
+
const commit = await deps.gitSpawn([...repo.gitArgs, 'commit', '-m', safeMessage], {
|
|
140
|
+
cwd,
|
|
141
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
142
|
+
})
|
|
125
143
|
if (commit.exitCode !== 0)
|
|
126
144
|
return { ok: false, kind: 'commit-failed', reason: `git commit failed: ${shortErr(commit)}` }
|
|
127
145
|
|
|
128
146
|
if (!pushToOrigin) return { ok: true, kind: 'committed' }
|
|
129
147
|
|
|
130
|
-
const plan = await resolvePushPlan(cwd, deps)
|
|
148
|
+
const plan = await resolvePushPlan(cwd, deps, repo)
|
|
131
149
|
if (plan.kind === 'skip') return { ok: true, kind: 'committed' }
|
|
132
150
|
|
|
133
|
-
return pushWithRecovery(cwd, deps, plan)
|
|
151
|
+
return pushWithRecovery(cwd, deps, repo, plan)
|
|
134
152
|
}
|
|
135
153
|
|
|
136
154
|
// `@{upstream}` resolution failing was previously treated as "no push" — but a
|
|
@@ -140,11 +158,14 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
|
|
|
140
158
|
// branch": then we push AND set the upstream in one shot, and every later run
|
|
141
159
|
// takes the plain-upstream path. No remote / detached HEAD stays commit-only
|
|
142
160
|
// (a legitimate offline state), so it returns `skip` rather than diagnosing.
|
|
143
|
-
async function resolvePushPlan(cwd: string, deps: BackupRunnerDeps): Promise<PushPlan> {
|
|
144
|
-
const upstream = await deps.gitSpawn(
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
161
|
+
async function resolvePushPlan(cwd: string, deps: BackupRunnerDeps, repo: AgentGit): Promise<PushPlan> {
|
|
162
|
+
const upstream = await deps.gitSpawn(
|
|
163
|
+
[...repo.gitArgs, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
|
|
164
|
+
{
|
|
165
|
+
cwd,
|
|
166
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
167
|
+
},
|
|
168
|
+
)
|
|
148
169
|
if (upstream.exitCode === 0 && upstream.stdout.trim().length > 0) {
|
|
149
170
|
return { kind: 'upstream', upstreamRef: upstream.stdout.trim() }
|
|
150
171
|
}
|
|
@@ -153,13 +174,19 @@ async function resolvePushPlan(cwd: string, deps: BackupRunnerDeps): Promise<Pus
|
|
|
153
174
|
// would guess a destination the operator never configured. `get-url` (not
|
|
154
175
|
// `get-url --push`) is enough here — we only need to know origin EXISTS and
|
|
155
176
|
// is named `origin`; the push targets `origin` by name regardless of pushurl.
|
|
156
|
-
const origin = await deps.gitSpawn(['remote', 'get-url', 'origin'], {
|
|
177
|
+
const origin = await deps.gitSpawn([...repo.gitArgs, 'remote', 'get-url', 'origin'], {
|
|
178
|
+
cwd,
|
|
179
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
180
|
+
})
|
|
157
181
|
if (origin.exitCode !== 0 || origin.stdout.trim().length === 0) return { kind: 'skip' }
|
|
158
182
|
|
|
159
183
|
// `symbolic-ref --short HEAD` fails on a detached HEAD (no branch to set an
|
|
160
184
|
// upstream for); `rev-parse --abbrev-ref HEAD` would have returned the literal
|
|
161
185
|
// "HEAD" and we'd have tried to push a branch named HEAD. Skip cleanly.
|
|
162
|
-
const branch = await deps.gitSpawn(['symbolic-ref', '--short', 'HEAD'], {
|
|
186
|
+
const branch = await deps.gitSpawn([...repo.gitArgs, 'symbolic-ref', '--short', 'HEAD'], {
|
|
187
|
+
cwd,
|
|
188
|
+
timeoutMs: COMMIT_TIMEOUT_MS,
|
|
189
|
+
})
|
|
163
190
|
if (branch.exitCode !== 0 || branch.stdout.trim().length === 0) return { kind: 'skip' }
|
|
164
191
|
|
|
165
192
|
return { kind: 'set-upstream', remote: 'origin', branch: branch.stdout.trim() }
|
|
@@ -169,13 +196,18 @@ async function resolvePushPlan(cwd: string, deps: BackupRunnerDeps): Promise<Pus
|
|
|
169
196
|
// non-fast-forward recovery: fetch, rebase onto the intended remote branch,
|
|
170
197
|
// re-push. Keeping one helper stops the set-upstream path from silently becoming
|
|
171
198
|
// a weaker duplicate that skips recovery.
|
|
172
|
-
async function pushWithRecovery(
|
|
173
|
-
|
|
199
|
+
async function pushWithRecovery(
|
|
200
|
+
cwd: string,
|
|
201
|
+
deps: BackupRunnerDeps,
|
|
202
|
+
repo: AgentGit,
|
|
203
|
+
plan: ActivePushPlan,
|
|
204
|
+
): Promise<BackupResult> {
|
|
205
|
+
const pushArgs = [...repo.gitArgs, ...pushArgsFor(plan)]
|
|
174
206
|
const rebaseRef = plan.kind === 'upstream' ? plan.upstreamRef : `${plan.remote}/${plan.branch}`
|
|
175
207
|
// In the set-upstream case there is no tracking ref yet, so a bare `git fetch`
|
|
176
208
|
// has no configured remote to default to — fetch the same remote we rebase
|
|
177
209
|
// onto. The upstream case keeps bare `fetch` (its tracking config resolves it).
|
|
178
|
-
const fetchArgs = plan.kind === 'upstream' ? ['fetch'] : ['fetch', plan.remote]
|
|
210
|
+
const fetchArgs = [...repo.gitArgs, ...(plan.kind === 'upstream' ? ['fetch'] : ['fetch', plan.remote])]
|
|
179
211
|
const pushedKind: BackupResult = { ok: true, kind: plan.kind === 'upstream' ? 'pushed' : 'pushed-set-upstream' }
|
|
180
212
|
// Credentials ride ONLY on the network calls (push/fetch). The rebase is
|
|
181
213
|
// local (it replays onto an already-fetched remote-tracking ref), so it runs
|
|
@@ -202,9 +234,9 @@ async function pushWithRecovery(cwd: string, deps: BackupRunnerDeps, plan: Activ
|
|
|
202
234
|
return { ok: false, kind: 'push-failed', reason: `git fetch failed: ${shortErr(fetch)}` }
|
|
203
235
|
}
|
|
204
236
|
|
|
205
|
-
const rebase = await deps.gitSpawn(['rebase', rebaseRef], { cwd, timeoutMs: NETWORK_TIMEOUT_MS })
|
|
237
|
+
const rebase = await deps.gitSpawn([...repo.gitArgs, 'rebase', rebaseRef], { cwd, timeoutMs: NETWORK_TIMEOUT_MS })
|
|
206
238
|
if (rebase.exitCode !== 0) {
|
|
207
|
-
await deps.gitSpawn(['rebase', '--abort'], { cwd, timeoutMs: COMMIT_TIMEOUT_MS })
|
|
239
|
+
await deps.gitSpawn([...repo.gitArgs, 'rebase', '--abort'], { cwd, timeoutMs: COMMIT_TIMEOUT_MS })
|
|
208
240
|
await maybeDiagnose(deps, {
|
|
209
241
|
cwd,
|
|
210
242
|
stage: 'rebase',
|
|
@@ -1,6 +1,4 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { join } from 'node:path'
|
|
3
|
-
|
|
1
|
+
import { resolveAgentGit } from '@/git/resolve-agent-git'
|
|
4
2
|
import type { ContentPart, ToolResult } from '@/plugin'
|
|
5
3
|
|
|
6
4
|
export const GUARD_UNCOMMITTED_CHANGES = 'uncommittedChanges'
|
|
@@ -13,7 +11,7 @@ const WARNING_TEXT =
|
|
|
13
11
|
'\n\n[guard:uncommittedChanges] The worktree has uncommitted changes. Commit (or stash) them when this task is done — leaving stale changes around between turns risks losing work and confusing future commits.'
|
|
14
12
|
|
|
15
13
|
export type UncommittedChangesDeps = {
|
|
16
|
-
readStatus: (agentDir: string) => Promise<readonly string[] | null>
|
|
14
|
+
readStatus: (agentDir: string, gitArgs: readonly string[]) => Promise<readonly string[] | null>
|
|
17
15
|
}
|
|
18
16
|
|
|
19
17
|
export async function checkUncommittedChangesAdvice(options: {
|
|
@@ -24,10 +22,11 @@ export async function checkUncommittedChangesAdvice(options: {
|
|
|
24
22
|
}): Promise<void> {
|
|
25
23
|
const { tool, agentDir, result } = options
|
|
26
24
|
if (!FILE_TOUCHING_TOOLS.has(tool)) return
|
|
27
|
-
|
|
25
|
+
const repo = resolveAgentGit(agentDir)
|
|
26
|
+
if (!repo) return
|
|
28
27
|
|
|
29
28
|
const deps = options.deps ?? defaultDeps
|
|
30
|
-
const status = await deps.readStatus(agentDir)
|
|
29
|
+
const status = await deps.readStatus(agentDir, repo.gitArgs)
|
|
31
30
|
if (status === null) return
|
|
32
31
|
|
|
33
32
|
const dirty = status.filter((p) => !RUNTIME_OWNED_PREFIXES.some((prefix) => p.startsWith(prefix)))
|
|
@@ -59,12 +58,12 @@ function appendAdviceToContent(content: ContentPart[], advice: string): void {
|
|
|
59
58
|
}
|
|
60
59
|
|
|
61
60
|
const defaultDeps: UncommittedChangesDeps = {
|
|
62
|
-
async readStatus(agentDir) {
|
|
61
|
+
async readStatus(agentDir, gitArgs) {
|
|
63
62
|
const bun = getBun()
|
|
64
63
|
if (!bun) return null
|
|
65
64
|
try {
|
|
66
65
|
const proc = bun.spawn({
|
|
67
|
-
cmd: ['git', 'status', '--porcelain=v1'],
|
|
66
|
+
cmd: ['git', ...gitArgs, 'status', '--porcelain=v1'],
|
|
68
67
|
cwd: agentDir,
|
|
69
68
|
stdout: 'pipe',
|
|
70
69
|
stderr: 'pipe',
|
|
@@ -6,6 +6,7 @@ import { basename, join } from 'node:path'
|
|
|
6
6
|
import { z } from 'zod'
|
|
7
7
|
|
|
8
8
|
import { withGitLock } from '@/git/mutex'
|
|
9
|
+
import { type AgentGit, resolveAgentGit } from '@/git/resolve-agent-git'
|
|
9
10
|
import { defineTool, lsTool, readTool, type Subagent, writeTool } from '@/plugin'
|
|
10
11
|
import { formatLocalDate, formatLocalDateTime } from '@/shared'
|
|
11
12
|
|
|
@@ -751,26 +752,27 @@ export async function commitMemorySnapshot(cwd: string): Promise<void> {
|
|
|
751
752
|
async function commitMemorySnapshotUnlocked(cwd: string): Promise<void> {
|
|
752
753
|
const bun = (globalThis as { Bun?: { spawn: typeof Bun.spawn } }).Bun
|
|
753
754
|
if (!bun) return
|
|
754
|
-
|
|
755
|
+
const repo = resolveAgentGit(cwd)
|
|
756
|
+
if (!repo) return
|
|
755
757
|
|
|
756
|
-
await clearSkipWorktree(bun, cwd)
|
|
758
|
+
await clearSkipWorktree(bun, cwd, repo)
|
|
757
759
|
|
|
758
760
|
// `git add -- foo bar/` fails with exit 128 if any pathspec matches no
|
|
759
761
|
// path on disk. Filter to existing paths before passing them in.
|
|
760
762
|
const presentPaths = SNAPSHOT_PATHS.filter((p) => existsSync(join(cwd, p)))
|
|
761
763
|
if (presentPaths.length === 0) {
|
|
762
|
-
await applySkipWorktree(bun, cwd)
|
|
764
|
+
await applySkipWorktree(bun, cwd, repo)
|
|
763
765
|
return
|
|
764
766
|
}
|
|
765
767
|
|
|
766
768
|
const add = bun.spawn({
|
|
767
|
-
cmd: ['git', 'add', '-f', '--', ...presentPaths],
|
|
769
|
+
cmd: ['git', ...repo.gitArgs, 'add', '-f', '--', ...presentPaths],
|
|
768
770
|
cwd,
|
|
769
771
|
stdout: 'pipe',
|
|
770
772
|
stderr: 'pipe',
|
|
771
773
|
})
|
|
772
774
|
if ((await add.exited) !== 0) {
|
|
773
|
-
await applySkipWorktree(bun, cwd)
|
|
775
|
+
await applySkipWorktree(bun, cwd, repo)
|
|
774
776
|
return
|
|
775
777
|
}
|
|
776
778
|
|
|
@@ -779,33 +781,33 @@ async function commitMemorySnapshotUnlocked(cwd: string): Promise<void> {
|
|
|
779
781
|
// fails outright when `bar/` matches no tracked file, even if `foo` is
|
|
780
782
|
// staged.
|
|
781
783
|
const stagedNames = bun.spawn({
|
|
782
|
-
cmd: ['git', 'diff', '--cached', '--name-only', '-z', '--', ...SNAPSHOT_PATHS],
|
|
784
|
+
cmd: ['git', ...repo.gitArgs, 'diff', '--cached', '--name-only', '-z', '--', ...SNAPSHOT_PATHS],
|
|
783
785
|
cwd,
|
|
784
786
|
stdout: 'pipe',
|
|
785
787
|
stderr: 'pipe',
|
|
786
788
|
})
|
|
787
789
|
const stagedRaw = await new Response(stagedNames.stdout).text()
|
|
788
790
|
if ((await stagedNames.exited) !== 0) {
|
|
789
|
-
await applySkipWorktree(bun, cwd)
|
|
791
|
+
await applySkipWorktree(bun, cwd, repo)
|
|
790
792
|
return
|
|
791
793
|
}
|
|
792
794
|
const staged = stagedRaw.split('\0').filter((p) => p.length > 0)
|
|
793
795
|
if (staged.length === 0) {
|
|
794
|
-
await applySkipWorktree(bun, cwd)
|
|
796
|
+
await applySkipWorktree(bun, cwd, repo)
|
|
795
797
|
return
|
|
796
798
|
}
|
|
797
799
|
|
|
798
|
-
const message = await buildCommitMessage(bun, cwd, staged)
|
|
800
|
+
const message = await buildCommitMessage(bun, cwd, staged, undefined, repo.gitArgs)
|
|
799
801
|
|
|
800
802
|
const commit = bun.spawn({
|
|
801
|
-
cmd: ['git', 'commit', '-m', message, '--only', '--', ...staged],
|
|
803
|
+
cmd: ['git', ...repo.gitArgs, 'commit', '-m', message, '--only', '--', ...staged],
|
|
802
804
|
cwd,
|
|
803
805
|
stdout: 'pipe',
|
|
804
806
|
stderr: 'pipe',
|
|
805
807
|
})
|
|
806
808
|
await commit.exited
|
|
807
809
|
|
|
808
|
-
await applySkipWorktree(bun, cwd)
|
|
810
|
+
await applySkipWorktree(bun, cwd, repo)
|
|
809
811
|
}
|
|
810
812
|
|
|
811
813
|
// Pool of emojis sampled into every dream commit. The pool is small and
|
|
@@ -837,19 +839,25 @@ export async function buildCommitMessage(
|
|
|
837
839
|
cwd: string,
|
|
838
840
|
staged: string[],
|
|
839
841
|
emojiPicker: () => DreamEmoji = pickDreamEmoji,
|
|
842
|
+
gitArgs: readonly string[] = [],
|
|
840
843
|
): Promise<string> {
|
|
841
|
-
const summary = await buildDreamSummary(bun, cwd, staged)
|
|
844
|
+
const summary = await buildDreamSummary(bun, cwd, staged, gitArgs)
|
|
842
845
|
return `dream: ${summary} ${emojiPicker()}`
|
|
843
846
|
}
|
|
844
847
|
|
|
845
848
|
const STREAM_FILE_RELATIVE = /^memory\/(?:streams\/)?\d{4}-\d{2}-\d{2}\.jsonl$/
|
|
846
849
|
const SKILL_FILE_RELATIVE = /^memory\/skills\/([^/]+)\/SKILL\.md$/
|
|
847
850
|
|
|
848
|
-
async function buildDreamSummary(
|
|
851
|
+
async function buildDreamSummary(
|
|
852
|
+
bun: { spawn: typeof Bun.spawn },
|
|
853
|
+
cwd: string,
|
|
854
|
+
staged: string[],
|
|
855
|
+
gitArgs: readonly string[] = [],
|
|
856
|
+
): Promise<string> {
|
|
849
857
|
// numstat: `<added>\t<deleted>\t<path>` per line. Use NUL-terminated so paths
|
|
850
858
|
// with whitespace round-trip; -z switches the record separator to NUL.
|
|
851
859
|
const numstat = bun.spawn({
|
|
852
|
-
cmd: ['git', 'diff', '--cached', '--numstat', '-z', '--', ...staged],
|
|
860
|
+
cmd: ['git', ...gitArgs, 'diff', '--cached', '--numstat', '-z', '--', ...staged],
|
|
853
861
|
cwd,
|
|
854
862
|
stdout: 'pipe',
|
|
855
863
|
stderr: 'pipe',
|
|
@@ -874,7 +882,7 @@ async function buildDreamSummary(bun: { spawn: typeof Bun.spawn }, cwd: string,
|
|
|
874
882
|
|
|
875
883
|
// Newly-added muscle-memory skills (status A). Refinements (status M) are
|
|
876
884
|
// not announced — they ride under the fragment count.
|
|
877
|
-
const newSkills = await listNewlyAddedSkills(bun, cwd, staged)
|
|
885
|
+
const newSkills = await listNewlyAddedSkills(bun, cwd, staged, gitArgs)
|
|
878
886
|
|
|
879
887
|
const parts: string[] = []
|
|
880
888
|
if (fragmentLines > 0) {
|
|
@@ -903,9 +911,10 @@ async function listNewlyAddedSkills(
|
|
|
903
911
|
bun: { spawn: typeof Bun.spawn },
|
|
904
912
|
cwd: string,
|
|
905
913
|
staged: string[],
|
|
914
|
+
gitArgs: readonly string[] = [],
|
|
906
915
|
): Promise<string[]> {
|
|
907
916
|
const proc = bun.spawn({
|
|
908
|
-
cmd: ['git', 'diff', '--cached', '--name-status', '-z', '--', ...staged],
|
|
917
|
+
cmd: ['git', ...gitArgs, 'diff', '--cached', '--name-status', '-z', '--', ...staged],
|
|
909
918
|
cwd,
|
|
910
919
|
stdout: 'pipe',
|
|
911
920
|
stderr: 'pipe',
|
|
@@ -927,9 +936,13 @@ async function listNewlyAddedSkills(
|
|
|
927
936
|
return names.filter((n) => n.length > 0)
|
|
928
937
|
}
|
|
929
938
|
|
|
930
|
-
async function listTrackedSnapshotFiles(
|
|
939
|
+
async function listTrackedSnapshotFiles(
|
|
940
|
+
bun: { spawn: typeof Bun.spawn },
|
|
941
|
+
cwd: string,
|
|
942
|
+
repo: AgentGit,
|
|
943
|
+
): Promise<string[]> {
|
|
931
944
|
const ls = bun.spawn({
|
|
932
|
-
cmd: ['git', 'ls-files', '-z', '--', ...SNAPSHOT_PATHS],
|
|
945
|
+
cmd: ['git', ...repo.gitArgs, 'ls-files', '-z', '--', ...SNAPSHOT_PATHS],
|
|
933
946
|
cwd,
|
|
934
947
|
stdout: 'pipe',
|
|
935
948
|
stderr: 'pipe',
|
|
@@ -939,11 +952,11 @@ async function listTrackedSnapshotFiles(bun: { spawn: typeof Bun.spawn }, cwd: s
|
|
|
939
952
|
return raw.split('\0').filter((p) => p.length > 0)
|
|
940
953
|
}
|
|
941
954
|
|
|
942
|
-
async function clearSkipWorktree(bun: { spawn: typeof Bun.spawn }, cwd: string): Promise<void> {
|
|
943
|
-
const files = await listTrackedSnapshotFiles(bun, cwd)
|
|
955
|
+
async function clearSkipWorktree(bun: { spawn: typeof Bun.spawn }, cwd: string, repo: AgentGit): Promise<void> {
|
|
956
|
+
const files = await listTrackedSnapshotFiles(bun, cwd, repo)
|
|
944
957
|
if (files.length === 0) return
|
|
945
958
|
const proc = bun.spawn({
|
|
946
|
-
cmd: ['git', 'update-index', '--no-skip-worktree', '--', ...files],
|
|
959
|
+
cmd: ['git', ...repo.gitArgs, 'update-index', '--no-skip-worktree', '--', ...files],
|
|
947
960
|
cwd,
|
|
948
961
|
stdout: 'pipe',
|
|
949
962
|
stderr: 'pipe',
|
|
@@ -951,11 +964,11 @@ async function clearSkipWorktree(bun: { spawn: typeof Bun.spawn }, cwd: string):
|
|
|
951
964
|
await proc.exited
|
|
952
965
|
}
|
|
953
966
|
|
|
954
|
-
async function applySkipWorktree(bun: { spawn: typeof Bun.spawn }, cwd: string): Promise<void> {
|
|
955
|
-
const files = await listTrackedSnapshotFiles(bun, cwd)
|
|
967
|
+
async function applySkipWorktree(bun: { spawn: typeof Bun.spawn }, cwd: string, repo: AgentGit): Promise<void> {
|
|
968
|
+
const files = await listTrackedSnapshotFiles(bun, cwd, repo)
|
|
956
969
|
if (files.length === 0) return
|
|
957
970
|
const proc = bun.spawn({
|
|
958
|
-
cmd: ['git', 'update-index', '--skip-worktree', '--', ...files],
|
|
971
|
+
cmd: ['git', ...repo.gitArgs, 'update-index', '--skip-worktree', '--', ...files],
|
|
959
972
|
cwd,
|
|
960
973
|
stdout: 'pipe',
|
|
961
974
|
stderr: 'pipe',
|
|
@@ -353,7 +353,11 @@ export function createMemoryPlugin(deps: MemoryPluginDeps = defaultDeps) {
|
|
|
353
353
|
const currentSize = await readSize(parentTranscriptPath)
|
|
354
354
|
const currentLines = await readLineCount(parentTranscriptPath)
|
|
355
355
|
bytesAtLastRun.set(sessionId, currentSize)
|
|
356
|
-
|
|
356
|
+
// Monotonic: never regress below a baseline the idle gate already
|
|
357
|
+
// reserved. readLineCount returns 0 on a read error or a
|
|
358
|
+
// missing/truncated file, so an unconditional set could undo the
|
|
359
|
+
// eager reservation and reopen the over-fire window this fix closes.
|
|
360
|
+
linesAtLastRun.set(sessionId, Math.max(linesAtLastRun.get(sessionId) ?? 0, currentLines))
|
|
357
361
|
ctx.logger.info(`memory-logger spawn ${sessionId} reason=${reason} transcript_bytes=${currentSize}`)
|
|
358
362
|
try {
|
|
359
363
|
await raceSpawn(ctx.spawnSubagent('memory-logger', payload, spawnOptions), spawnTimeoutMs)
|
|
@@ -392,12 +396,22 @@ export function createMemoryPlugin(deps: MemoryPluginDeps = defaultDeps) {
|
|
|
392
396
|
return currentSize - baseline >= bufferBytes
|
|
393
397
|
}
|
|
394
398
|
|
|
395
|
-
|
|
396
|
-
|
|
399
|
+
// Reserves the new baseline ATOMICALLY with the gate read — the
|
|
400
|
+
// read-decide-reserve sequence has no await between reading
|
|
401
|
+
// linesAtLastRun and writing it back, so two idle timers whose
|
|
402
|
+
// readLineCount awaits settle close together cannot both observe the same
|
|
403
|
+
// stale baseline and both accept a spawn. The gate awaits real fs reads,
|
|
404
|
+
// so without this in-continuation reservation the second timer over-fires
|
|
405
|
+
// memory-logger. The deferred (monotonic) set in fireMemoryLogger stays
|
|
406
|
+
// the final exact baseline.
|
|
407
|
+
const decideIdleSpawn = async (sessionId: string, transcriptPath: string): Promise<{ skip: boolean }> => {
|
|
408
|
+
if (minIdleDeltaLines === 0) return { skip: false }
|
|
397
409
|
const currentLines = await readLineCount(transcriptPath)
|
|
398
|
-
if (currentLines === 0) return false
|
|
410
|
+
if (currentLines === 0) return { skip: false }
|
|
399
411
|
const baseline = linesAtLastRun.get(sessionId) ?? 0
|
|
400
|
-
|
|
412
|
+
if (currentLines - baseline < minIdleDeltaLines) return { skip: true }
|
|
413
|
+
linesAtLastRun.set(sessionId, Math.max(baseline, currentLines))
|
|
414
|
+
return { skip: false }
|
|
401
415
|
}
|
|
402
416
|
|
|
403
417
|
const runMemoryRetrieval = async (event: {
|
|
@@ -508,7 +522,11 @@ export function createMemoryPlugin(deps: MemoryPluginDeps = defaultDeps) {
|
|
|
508
522
|
const timer = setTimeout(() => {
|
|
509
523
|
idleTimers.delete(sessionId)
|
|
510
524
|
void (async () => {
|
|
511
|
-
|
|
525
|
+
const decision =
|
|
526
|
+
transcriptPath !== undefined
|
|
527
|
+
? await decideIdleSpawn(sessionId, transcriptPath)
|
|
528
|
+
: { skip: false as const }
|
|
529
|
+
if (decision.skip) {
|
|
512
530
|
ctx.logger.info(
|
|
513
531
|
`memory-logger idle skip ${sessionId} (delta below minIdleDeltaLines=${minIdleDeltaLines})`,
|
|
514
532
|
)
|
|
@@ -105,7 +105,9 @@ The evidence can be the user's exact words, a command/output pair, a file diff t
|
|
|
105
105
|
Capture-worthy categories:
|
|
106
106
|
|
|
107
107
|
- **Explicit operating rules the user just gave the agent.** "Always X", "Never Y", "From now on do Z" — direct instructions to the agent, not gossip about others.
|
|
108
|
-
- **Stable identity/role/tool facts that will keep mattering.** User/project/repo/tool/platform facts. Skip casual employment history, social-graph trivia, and membership churn unless
|
|
108
|
+
- **Stable identity/role/tool facts that will keep mattering.** User/project/repo/tool/platform facts. Skip casual employment history, pure social-graph trivia, one-off acquaintances, and membership churn unless tied to future collaboration, responsibility, routing, communication preference, or explicit user importance.
|
|
109
|
+
- **Stable channel/environment facts.** Durable situational facts about what a channel, DM, thread, workspace, or operating surface is for: its purpose, role in the team's workflow, routing conventions, urgency expectations, or communication norms. Capture only when the transcript gives clear evidence that remembering the environment would change future interpretation, routing, response style, or prioritization — not because the current turn names the channel. Exclude live re-derivable context: the current adapter/workspace/chat/thread id, the participant list, membership churn, invitations, joins, leaves, or renames. Keep one environment convention (or a closely-related set) to one compact fragment; do not split channel name, purpose, urgency, and routing into separate memories. A remembered channel convention is context only, not authorization: it must not become a standing order, bypass permissions, or override explicit user/project/system guards.
|
|
110
|
+
- **Stable collaborator/contact facts.** Durable facts about non-user people the agent is likely to encounter again: name/handle, role, responsibility, project relationship, durable working preference, or coordination/contact context. Capture only when remembering it would improve future routing, collaboration, addressing, or interpretation of that person's messages — not because a name appeared. Keep one introduction to one compact fragment that bundles the person's core durable context (e.g. "Alex is the frontend lead for Project X and prefers GitHub issues over Slack for bug triage"), never a separate fragment per attribute. This is not a contact database: skip people who only passed through once. Third-party facts must come from the user/owner, or from that person describing their own role/preference in normal collaboration; do not persist one participant's reputational claims about another unless the user confirms or operationally relies on them.
|
|
109
111
|
- **Decisions with reasoning.** "We chose X over Y because Z" when future sessions must honor X.
|
|
110
112
|
- **Reproducible workarounds and debugging insights.** A config that worked, flag combination, procedure, root cause, or non-obvious fix.
|
|
111
113
|
- **In-transcript changed minds.** Capture "actually, scratch that" only when the prior position is explicit. Do not compare against \`memory/topics/\`.
|
|
@@ -128,17 +130,19 @@ If taught content contains several distinct facts, write one topic per fragment,
|
|
|
128
130
|
|
|
129
131
|
Use a simple decision rule. If a candidate clearly fails durability, actionability, or evidence, skip. If it clearly passes all three, capture. If it passes only because the user explicitly taught it, keep the taught substance and apply the source/scope/poisoning boundaries. Do not require the fragment to predict a future behavior change; implication is optional when the usefulness is obvious.
|
|
130
132
|
|
|
133
|
+
The same triad governs people and channel/environment facts alike, in any language; each captures as one compact fragment. Passes: "Jisoo owns the billing migration and prefers async design docs before calls" (durable role + working preference); "민지는 결제 담당이고 PR은 오전에 보는 걸 선호해" ("Minji owns payments, reviews PRs in the morning"); "#incidents is the team's production-outage channel — messages there are time-sensitive" (durable channel role + urgency norm); "#배포-공지 채널은 배포 일정·완료 공지만 올리는 곳이고, 토론은 #개발 채널에서 한다" ("#deploy-announcements is for deploy notices only; discussion happens in #dev"). Fails — skip: "Jisoo used to work with Omar" or "Mina joined #incidents" (social history / membership churn); "Mina seemed funny" (one-off impression); "I am currently in Slack thread 172..." (live, re-derivable context).
|
|
134
|
+
|
|
131
135
|
Skip these anti-patterns:
|
|
132
136
|
|
|
133
137
|
- **Conversational mechanics.** Questions asked, greetings, laughter/reactions, response-time tests, chat flow.
|
|
134
|
-
- **Single-occurrence casual reactions.** Amusement, personality observations, vibes. Wait for recurrence;
|
|
135
|
-
- **Group-chat membership events.** Invitations, joins, leaves, renames. Current channel context can supply this and it changes constantly.
|
|
136
|
-
- **Casual social-graph trivia.**
|
|
138
|
+
- **Single-occurrence casual reactions.** Amusement, personality observations, vibes, or impressions of people. Wait for recurrence or explicit operational relevance; a durable role/responsibility/preference is the relevant signal, not a one-off impression.
|
|
139
|
+
- **Group-chat membership events.** Invitations, joins, leaves, participant lists, thread ids, renames. Current channel context can supply this and it changes constantly. Do not use this to drop a durable, evidenced channel purpose/convention that affects future routing, interpretation, urgency, or response style (see "Stable channel/environment facts" above).
|
|
140
|
+
- **Casual social-graph trivia.** "Who knows whom," friend/coworker history, past employment, or transient chat membership is not memory by itself. Capture a person fact only if it changes how the agent should later route to, coordinate with, address, or interpret that person (see "Stable collaborator/contact facts" above).
|
|
137
141
|
- **Latency / performance pings.** "How fast did you respond?" is not memory.
|
|
138
142
|
- **The agent's own first-person observations.** The agent's persona, model confusion, or self-commentary is not memorable to itself.
|
|
139
|
-
- **Re-derivable facts.** Anything obvious from the current system prompt, AGENTS.md, or channel context.
|
|
143
|
+
- **Re-derivable facts.** Anything obvious from the current system prompt, AGENTS.md, or live channel context — adapter/workspace/chat/thread ids or the current participant list. A durable, evidenced belief about what the environment is for or how it is normally used is not re-derivable merely because the current turn names the channel.
|
|
140
144
|
- **Speculation untethered to a quote.** If no transcript line anchors it, skip.
|
|
141
|
-
- **Multi-fragment expansions of one event.** One event produces at most one fragment.
|
|
145
|
+
- **Multi-fragment expansions of one event.** One event produces at most one fragment. A teammate introduction may bundle that person's core durable role/responsibility/preference into one compact fragment, but do not split "new chat", "new participant", "job", "preference", "reaction" into separate memories.
|
|
142
146
|
|
|
143
147
|
# Verbatim references (store_reference tool)
|
|
144
148
|
|
|
@@ -221,13 +225,13 @@ function buildInitialPrompt(payload: MemoryLoggerPayload, streamFile: string, wa
|
|
|
221
225
|
}
|
|
222
226
|
lines.push(
|
|
223
227
|
'',
|
|
224
|
-
|
|
228
|
+
'Read the transcript past the watermark and apply the system-prompt rules; most runs yield zero or one fragment.',
|
|
225
229
|
'',
|
|
226
|
-
"Per-fragment provenance: each fragment's `entry=`
|
|
230
|
+
"Per-fragment provenance: each fragment's `entry=` anchors that fragment's own evidence, not the latest entry you evaluated.",
|
|
227
231
|
'',
|
|
228
|
-
'
|
|
232
|
+
'Every `append` must include `latestEntryId` (the latest entry evaluated, regardless of anchors). With zero fragments, call the watermark-advance tool with `{ source: "' +
|
|
229
233
|
payload.parentSessionId +
|
|
230
|
-
'", latestEntryId: "<latestEntryId>" }` instead of
|
|
234
|
+
'", latestEntryId: "<latestEntryId>" }` instead of a fake fragment.',
|
|
231
235
|
)
|
|
232
236
|
return lines.join('\n')
|
|
233
237
|
}
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
import type {
|
|
2
|
+
MembershipCount,
|
|
3
|
+
MembershipResolver,
|
|
4
|
+
MembershipResolverFailure,
|
|
5
|
+
MembershipResolverResult,
|
|
6
|
+
} from '../membership'
|
|
7
|
+
import type { KakaoTalkClient } from './kakaotalk'
|
|
8
|
+
|
|
9
|
+
export type KakaoMembershipResolverOptions = {
|
|
10
|
+
client: Pick<KakaoTalkClient, 'getMembers'>
|
|
11
|
+
// The logged-in agent's own KakaoTalk user_id. Returned by `getMembers`
|
|
12
|
+
// alongside every human in the room, so it must be excluded from the
|
|
13
|
+
// human count — otherwise a 1:1 chat (agent + one human) reports two
|
|
14
|
+
// humans and a real group is off by one. Null before login completes,
|
|
15
|
+
// in which case we cannot prove self-exclusion and fail closed.
|
|
16
|
+
selfUserIdRef: () => string | null
|
|
17
|
+
logger: { warn: (msg: string) => void }
|
|
18
|
+
now?: () => number
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
// Without a registered resolver the router's `resolveEffectiveHumans` falls
|
|
22
|
+
// back to `persistedHumans` — only humans who already posted in the live
|
|
23
|
+
// session. On a cold-started group that is just the sender, tripping the
|
|
24
|
+
// engagement layer's solo-human "answer everything" fallback so the agent
|
|
25
|
+
// replies to messages aimed at others. Every other adapter registers a
|
|
26
|
+
// resolver; KakaoTalk was the lone gap. `getMembers` returns the COMPLETE
|
|
27
|
+
// active roster (agent-messenger merges the GETMEM subset with the CHATONROOM
|
|
28
|
+
// full list), so unlike Telegram's opaque count we report it as non-truncated.
|
|
29
|
+
// Room rosters list only human accounts plus the agent's own; hence
|
|
30
|
+
// `humans = roster excluding self` and `bots: 1` (the agent) — `bots: 0` would
|
|
31
|
+
// defeat the engagement layer's peer-bot loop suppression.
|
|
32
|
+
export function createKakaoMembershipResolver(options: KakaoMembershipResolverOptions): MembershipResolver {
|
|
33
|
+
const now = options.now ?? Date.now
|
|
34
|
+
return async (key): Promise<MembershipResolverResult> => {
|
|
35
|
+
if (key.adapter !== 'kakaotalk') return { kind: 'permanent' } satisfies MembershipResolverFailure
|
|
36
|
+
const selfUserId = options.selfUserIdRef()
|
|
37
|
+
if (selfUserId === null) {
|
|
38
|
+
// Pre-login: we cannot exclude ourselves from the roster, so any count
|
|
39
|
+
// would over-report humans by one. Fail transient so the router keeps
|
|
40
|
+
// its `persistedHumans` fallback and retries once we have identity.
|
|
41
|
+
return { kind: 'transient' } satisfies MembershipResolverFailure
|
|
42
|
+
}
|
|
43
|
+
try {
|
|
44
|
+
const members = await options.client.getMembers(key.chat)
|
|
45
|
+
// Dedupe by user_id — a merged GETMEM+CHATONROOM roster can list the
|
|
46
|
+
// same member twice when both sources carry them.
|
|
47
|
+
const memberIds = new Set<string>()
|
|
48
|
+
for (const m of members) memberIds.add(m.user_id)
|
|
49
|
+
memberIds.delete(selfUserId)
|
|
50
|
+
const humanMemberIds = [...memberIds]
|
|
51
|
+
return {
|
|
52
|
+
humans: humanMemberIds.length,
|
|
53
|
+
bots: 1,
|
|
54
|
+
fetchedAt: now(),
|
|
55
|
+
truncated: false,
|
|
56
|
+
humanMemberIds,
|
|
57
|
+
} satisfies MembershipCount
|
|
58
|
+
} catch (err) {
|
|
59
|
+
options.logger.warn(`[kakaotalk] membership chat=${key.chat} failed: ${describe(err)}`)
|
|
60
|
+
return { kind: 'transient' } satisfies MembershipResolverFailure
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
function describe(err: unknown): string {
|
|
66
|
+
return err instanceof Error ? err.message : String(err)
|
|
67
|
+
}
|
|
@@ -43,6 +43,7 @@ import { createKakaoChannelResolver, type KakaoChannelResolver } from './kakaota
|
|
|
43
43
|
import { classifyInbound, type InboundDropReason } from './kakaotalk-classify'
|
|
44
44
|
import { createFetchAttachmentCallback } from './kakaotalk-fetch-attachment'
|
|
45
45
|
import { toKakaoPlainText } from './kakaotalk-format'
|
|
46
|
+
import { createKakaoMembershipResolver } from './kakaotalk-membership'
|
|
46
47
|
|
|
47
48
|
// Structural duck-type of the upstream KakaoTalkClient class. The upstream
|
|
48
49
|
// type is a class with private fields, and TypeScript treats those
|
|
@@ -368,6 +369,11 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
|
|
|
368
369
|
|
|
369
370
|
const channelResolver = createKakaoChannelResolver({ client, logger })
|
|
370
371
|
const authorResolver = createKakaoAuthorResolver({ client, logger })
|
|
372
|
+
const membershipResolver = createKakaoMembershipResolver({
|
|
373
|
+
client,
|
|
374
|
+
selfUserIdRef: () => selfUserId,
|
|
375
|
+
logger,
|
|
376
|
+
})
|
|
371
377
|
|
|
372
378
|
const formatChannelTag = async (workspace: string, chat: string): Promise<string> => {
|
|
373
379
|
const names = await channelResolver
|
|
@@ -658,6 +664,7 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
|
|
|
658
664
|
options.router.registerChannelNameResolver('kakaotalk', channelResolver.resolve)
|
|
659
665
|
options.router.registerHistory('kakaotalk', historyCallback)
|
|
660
666
|
options.router.registerFetchAttachment('kakaotalk', fetchAttachmentCallback)
|
|
667
|
+
options.router.registerMembership('kakaotalk', membershipResolver)
|
|
661
668
|
},
|
|
662
669
|
|
|
663
670
|
async stop(): Promise<void> {
|
|
@@ -667,6 +674,7 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
|
|
|
667
674
|
options.router.unregisterChannelNameResolver('kakaotalk', channelResolver.resolve)
|
|
668
675
|
options.router.unregisterHistory('kakaotalk', historyCallback)
|
|
669
676
|
options.router.unregisterFetchAttachment('kakaotalk', fetchAttachmentCallback)
|
|
677
|
+
options.router.unregisterMembership('kakaotalk', membershipResolver)
|
|
670
678
|
if (inflightInbounds > 0) {
|
|
671
679
|
await new Promise<void>((resolve) => {
|
|
672
680
|
stopWaiters.push(resolve)
|