sneakoscope 8.0.2 → 8.0.3
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 +47 -23
- package/config/skills-hash-ledger.v1.json +1 -1
- package/crates/sks-core/Cargo.lock +1 -1
- package/crates/sks-core/Cargo.toml +1 -1
- package/dist/bin/fast-inline.js +55 -13
- package/dist/bin/sks-dispatch.js +1 -1
- package/dist/cli/command-manifest-lite.js +4 -0
- package/dist/cli/command-registry.js +4 -0
- package/dist/cli/install-helpers-codex-lb-chain.js +187 -0
- package/dist/cli/install-helpers-codex-lb-config.js +74 -8
- package/dist/cli/install-helpers.js +89 -44
- package/dist/commands/codex-lb.js +117 -19
- package/dist/commands/doctor.js +697 -37
- package/dist/config/skills-manifest.json +3 -2
- package/dist/core/agents/agent-runner-codex-exec.js +5 -3
- package/dist/core/codex/codex-config-guard.js +238 -52
- package/dist/core/codex-adapter.js +5 -3
- package/dist/core/codex-app/menubar/constants.js +10 -1
- package/dist/core/codex-app/menubar/global-install.js +288 -0
- package/dist/core/codex-app/menubar/installer.js +79 -14
- package/dist/core/codex-app/menubar/launch-agent.js +267 -45
- package/dist/core/codex-app/menubar/paths.js +3 -0
- package/dist/core/codex-app/menubar/rollback.js +55 -7
- package/dist/core/codex-app/menubar/status.js +75 -4
- package/dist/core/codex-control/codex-0139-image-path-real-probe.js +3 -1
- package/dist/core/codex-control/codex-0139-web-search-probe.js +3 -1
- package/dist/core/codex-control/codex-app-server-runtime-env.js +13 -4
- package/dist/core/codex-control/codex-app-server-v2-client.js +3 -3
- package/dist/core/codex-exec-output-schema.js +4 -1
- package/dist/core/codex-lb/codex-lb-env.js +63 -72
- package/dist/core/codex-lb/codex-lb-setup.js +15 -2
- package/dist/core/codex-lb/desktop-center-credentials.js +517 -58
- package/dist/core/codex-lb/desktop-controller.js +153 -24
- package/dist/core/codex-lb/routing-truth.js +327 -0
- package/dist/core/codex-native/core-skill-manifest.js +1 -1
- package/dist/core/commands/basic-cli.js +7 -1
- package/dist/core/commands/qa-loop-command.js +3 -1
- package/dist/core/commands/telegram-command.js +241 -0
- package/dist/core/config-adopt/config-adopt-command.js +35 -0
- package/dist/core/config-adopt/config-adopt.js +346 -0
- package/dist/core/config-adopt/index.js +3 -0
- package/dist/core/doctor/command-alias-cleanup.js +4 -1
- package/dist/core/doctor/current-project-guidance-nested.js +37 -6
- package/dist/core/doctor/current-project-guidance.js +11 -6
- package/dist/core/doctor/doctor-readiness-matrix.js +14 -0
- package/dist/core/doctor/retired-managed-residue-private.js +1 -1
- package/dist/core/doctor/sks-menubar-doctor.js +4 -0
- package/dist/core/feature-fixtures.js +8 -0
- package/dist/core/hooks-runtime/hook-context.js +9 -0
- package/dist/core/hooks-runtime/managed-skill-admission.js +54 -4
- package/dist/core/hooks-runtime/official-subagent-lifecycle.js +69 -1
- package/dist/core/hooks-runtime/subagent-skill-availability-contract.js +2 -2
- package/dist/core/hooks-runtime/subagent-skill-availability-evidence.js +3 -3
- package/dist/core/hooks-runtime/subagent-skill-availability-guards.js +43 -5
- package/dist/core/hooks-runtime/subagent-skill-availability.js +64 -30
- package/dist/core/hooks-runtime/subagent-stop-hook.js +15 -2
- package/dist/core/hooks-runtime.js +148 -4
- package/dist/core/imagegen/imagegen-capability.js +46 -0
- package/dist/core/imagegen/require-imagegen.js +2 -2
- package/dist/core/init/skills.js +17 -3
- package/dist/core/install/installed-package-smoke.js +8 -2
- package/dist/core/naruto/hardware-capacity-probe.js +9 -3
- package/dist/core/naruto/naruto-concurrency-governor.js +68 -24
- package/dist/core/perf/import-graph-budget.js +0 -1
- package/dist/core/product-design-app-server.js +13 -1
- package/dist/core/release/package-size-budget.js +2 -2
- package/dist/core/release/release-pack-receipt.js +1 -2
- package/dist/core/routes/dollar-manifest-lite.js +1 -1
- package/dist/core/routes.js +1 -1
- package/dist/core/security/private-credential-file.js +209 -0
- package/dist/core/subagents/agent-catalog.js +17 -32
- package/dist/core/subagents/naruto-help-contract.js +5 -5
- package/dist/core/subagents/official-subagent-config.js +16 -6
- package/dist/core/subagents/official-subagent-preparation.js +34 -15
- package/dist/core/subagents/official-subagent-prompt.js +4 -4
- package/dist/core/subagents/official-subagent-runner.js +27 -4
- package/dist/core/subagents/thread-budget.js +19 -12
- package/dist/core/subagents/wave-lifecycle.js +18 -6
- package/dist/core/telegram/access.js +54 -0
- package/dist/core/telegram/client.js +144 -0
- package/dist/core/telegram/confirmation.js +37 -0
- package/dist/core/telegram/doctor.js +151 -0
- package/dist/core/telegram/index.js +9 -0
- package/dist/core/telegram/keychain.js +265 -0
- package/dist/core/telegram/liveness.js +109 -0
- package/dist/core/telegram/poller.js +90 -0
- package/dist/core/telegram/redaction.js +15 -0
- package/dist/core/telegram/types.js +1 -0
- package/dist/core/update/update-diagnostics.js +52 -0
- package/dist/core/update/update-migration-state.js +5 -1
- package/dist/core/update/update-operation.js +2 -1
- package/dist/core/update/update-stage-diagnostics.js +38 -0
- package/dist/core/update/update-status.js +2 -9
- package/dist/core/update-check.js +147 -31
- package/dist/core/version.js +1 -1
- package/dist/core/zellij/zellij-launcher.js +23 -4
- package/dist/native/sks-menubar/Sources/AppDelegate.swift +13 -0
- package/dist/native/sks-menubar/Sources/AppIdentity.swift +7 -0
- package/dist/native/sks-menubar/Sources/OperationCoordinator.swift +3 -2
- package/dist/native/sks-menubar/Sources/ProvidersConnectTest.swift +115 -0
- package/dist/native/sks-menubar/Sources/ProvidersFastMode.swift +17 -0
- package/dist/native/sks-menubar/Sources/ProvidersRoutingTruth.swift +190 -0
- package/dist/native/sks-menubar/Sources/ProvidersViewController.swift +100 -59
- package/dist/native/sks-menubar/Sources/SingletonInstanceGuard.swift +328 -0
- package/dist/native/sks-menubar/Sources/TelegramPrivateFileStore.swift +320 -0
- package/dist/native/sks-menubar/Sources/TelegramPrivateFileSupport.swift +303 -0
- package/dist/native/sks-menubar/Sources/TelegramProcessGateway.swift +238 -0
- package/dist/native/sks-menubar/Sources/TelegramRuntimeSupport.swift +56 -0
- package/dist/native/sks-menubar/Sources/TelegramSupport.swift +56 -0
- package/dist/native/sks-menubar/Sources/TelegramTransport.swift +474 -0
- package/dist/native/sks-menubar/Sources/main.swift +15 -1
- package/dist/native/sks-menubar/Tests/OperationCoordinatorTests.swift +4 -3
- package/dist/native/sks-menubar/Tests/ProvidersViewControllerTests.swift +129 -0
- package/dist/native/sks-menubar/Tests/SingletonInstanceGuardTests.swift +183 -0
- package/dist/native/sks-menubar/Tests/TelegramRuntimeSmokeTests.swift +267 -0
- package/dist/native/sks-menubar/Tests/TelegramRuntimeTests.swift +222 -0
- package/dist/scripts/codex-lb-fast-mode-truth-check.js +1 -1
- package/dist/scripts/codex-lb-fast-ui-preservation-check.js +1 -1
- package/dist/scripts/current-command-surface-check.js +2 -4
- package/dist/scripts/official-subagent-workflow-check.js +1 -1
- package/dist/scripts/packlist-performance-check.js +1 -2
- package/package.json +1 -1
|
@@ -0,0 +1,303 @@
|
|
|
1
|
+
import Darwin
|
|
2
|
+
import Foundation
|
|
3
|
+
|
|
4
|
+
enum TelegramPrivateFileError: Error, Equatable {
|
|
5
|
+
case invalidStoredValue
|
|
6
|
+
case insecurePath(String)
|
|
7
|
+
case fileTooLarge(String)
|
|
8
|
+
case tooManyConfirmations
|
|
9
|
+
case systemCall(String, Int32)
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
final class TelegramPrivateFileSupport: @unchecked Sendable {
|
|
13
|
+
static let maximumFileBytes = 1_048_576
|
|
14
|
+
|
|
15
|
+
let tokenURL: URL
|
|
16
|
+
let stateURL: URL
|
|
17
|
+
|
|
18
|
+
private struct Identity {
|
|
19
|
+
let device: dev_t
|
|
20
|
+
let inode: ino_t
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
private let sksDirectory: URL
|
|
24
|
+
private let secretDirectory: URL
|
|
25
|
+
private let stateDirectory: URL
|
|
26
|
+
private let lockDirectoryURL: URL
|
|
27
|
+
private let lock = NSLock()
|
|
28
|
+
|
|
29
|
+
init(homeDirectory: URL?, environment: [String: String]) {
|
|
30
|
+
let home = homeDirectory
|
|
31
|
+
?? environment["HOME"].map { URL(fileURLWithPath: $0, isDirectory: true) }
|
|
32
|
+
?? FileManager.default.homeDirectoryForCurrentUser
|
|
33
|
+
let configuredRoot = environment["SKS_HOME"]?.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
34
|
+
self.sksDirectory = configuredRoot.flatMap {
|
|
35
|
+
$0.isEmpty ? nil : URL(fileURLWithPath: $0, isDirectory: true)
|
|
36
|
+
}?.standardizedFileURL
|
|
37
|
+
?? home.standardizedFileURL.appendingPathComponent(".sneakoscope", isDirectory: true)
|
|
38
|
+
self.secretDirectory = sksDirectory.appendingPathComponent("secrets", isDirectory: true)
|
|
39
|
+
self.stateDirectory = sksDirectory.appendingPathComponent("state", isDirectory: true)
|
|
40
|
+
self.tokenURL = secretDirectory.appendingPathComponent("telegram-bot-token")
|
|
41
|
+
self.stateURL = stateDirectory.appendingPathComponent("telegram.json")
|
|
42
|
+
self.lockDirectoryURL = stateDirectory.appendingPathComponent(".telegram.lock", isDirectory: true)
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
func readTokenData() throws -> Data? {
|
|
46
|
+
try lock.withTelegramFileLock {
|
|
47
|
+
guard try prepareDirectory(sksDirectory, create: false, exactPrivateMode: false),
|
|
48
|
+
try prepareDirectory(secretDirectory, create: false, exactPrivateMode: true) else { return nil }
|
|
49
|
+
return try readPrivateFile(tokenURL)
|
|
50
|
+
}
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
func withStateTransaction<T>(_ operation: () throws -> T) throws -> T {
|
|
54
|
+
try lock.withTelegramFileLock {
|
|
55
|
+
_ = try prepareDirectory(sksDirectory, create: true, exactPrivateMode: false)
|
|
56
|
+
_ = try prepareDirectory(stateDirectory, create: true, exactPrivateMode: true)
|
|
57
|
+
let identity = try acquireStateLock()
|
|
58
|
+
defer { releaseDirectory(lockDirectoryURL, identity: identity) }
|
|
59
|
+
return try operation()
|
|
60
|
+
}
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
func readStateData() throws -> Data? { try readPrivateFile(stateURL) }
|
|
64
|
+
|
|
65
|
+
func writeStateData(_ data: Data) throws {
|
|
66
|
+
guard data.count <= Self.maximumFileBytes else {
|
|
67
|
+
throw TelegramPrivateFileError.fileTooLarge(stateURL.path)
|
|
68
|
+
}
|
|
69
|
+
try writePrivateFileAtomically(data, to: stateURL)
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
private func acquireStateLock() throws -> Identity {
|
|
73
|
+
for attempt in 0..<200 {
|
|
74
|
+
if mkdir(lockDirectoryURL.path, 0o700) == 0 {
|
|
75
|
+
do { return try validatePrivateDirectory(lockDirectoryURL) }
|
|
76
|
+
catch {
|
|
77
|
+
_ = rmdir(lockDirectoryURL.path)
|
|
78
|
+
throw error
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
let code = errno
|
|
82
|
+
guard code == EEXIST else {
|
|
83
|
+
throw TelegramPrivateFileError.systemCall("mkdir_lock", code)
|
|
84
|
+
}
|
|
85
|
+
_ = try inspectPrivateDirectory(lockDirectoryURL)
|
|
86
|
+
guard attempt < 199 else {
|
|
87
|
+
throw TelegramPrivateFileError.systemCall("lock_timeout", EBUSY)
|
|
88
|
+
}
|
|
89
|
+
usleep(25_000)
|
|
90
|
+
}
|
|
91
|
+
throw TelegramPrivateFileError.systemCall("lock_timeout", EBUSY)
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
private func inspectPrivateDirectory(_ url: URL) throws -> Identity {
|
|
95
|
+
var metadata = stat()
|
|
96
|
+
guard lstat(url.path, &metadata) == 0,
|
|
97
|
+
(metadata.st_mode & S_IFMT) == S_IFDIR,
|
|
98
|
+
(metadata.st_mode & 0o777) == 0o700,
|
|
99
|
+
metadata.st_uid == geteuid() else {
|
|
100
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
101
|
+
}
|
|
102
|
+
return Identity(device: metadata.st_dev, inode: metadata.st_ino)
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
private func validatePrivateDirectory(_ url: URL) throws -> Identity {
|
|
106
|
+
let pathIdentity = try inspectPrivateDirectory(url)
|
|
107
|
+
let descriptor = open(url.path, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
|
|
108
|
+
guard descriptor >= 0 else { throw systemCall("open_directory") }
|
|
109
|
+
defer { close(descriptor) }
|
|
110
|
+
var metadata = stat()
|
|
111
|
+
guard fstat(descriptor, &metadata) == 0,
|
|
112
|
+
(metadata.st_mode & S_IFMT) == S_IFDIR,
|
|
113
|
+
(metadata.st_mode & 0o777) == 0o700,
|
|
114
|
+
metadata.st_uid == geteuid(),
|
|
115
|
+
metadata.st_dev == pathIdentity.device,
|
|
116
|
+
metadata.st_ino == pathIdentity.inode else {
|
|
117
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
118
|
+
}
|
|
119
|
+
return pathIdentity
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
private func releaseDirectory(_ url: URL, identity: Identity) {
|
|
123
|
+
var current = stat()
|
|
124
|
+
guard lstat(url.path, ¤t) == 0,
|
|
125
|
+
(current.st_mode & S_IFMT) == S_IFDIR,
|
|
126
|
+
current.st_uid == geteuid(),
|
|
127
|
+
current.st_dev == identity.device,
|
|
128
|
+
current.st_ino == identity.inode else { return }
|
|
129
|
+
_ = rmdir(url.path)
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
@discardableResult
|
|
133
|
+
private func prepareDirectory(_ url: URL, create: Bool, exactPrivateMode: Bool) throws -> Bool {
|
|
134
|
+
var pathMetadata = stat()
|
|
135
|
+
var created = false
|
|
136
|
+
if lstat(url.path, &pathMetadata) != 0 {
|
|
137
|
+
let code = errno
|
|
138
|
+
guard code == ENOENT else { throw TelegramPrivateFileError.systemCall("lstat_directory", code) }
|
|
139
|
+
guard create else { return false }
|
|
140
|
+
if mkdir(url.path, 0o700) == 0 { created = true }
|
|
141
|
+
else if errno != EEXIST { throw systemCall("mkdir") }
|
|
142
|
+
guard lstat(url.path, &pathMetadata) == 0 else { throw systemCall("lstat_directory") }
|
|
143
|
+
}
|
|
144
|
+
guard (pathMetadata.st_mode & S_IFMT) == S_IFDIR else {
|
|
145
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
146
|
+
}
|
|
147
|
+
let descriptor = open(url.path, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
|
|
148
|
+
guard descriptor >= 0 else { throw systemCall("open_directory") }
|
|
149
|
+
defer { close(descriptor) }
|
|
150
|
+
var metadata = stat()
|
|
151
|
+
guard fstat(descriptor, &metadata) == 0 else { throw systemCall("fstat_directory") }
|
|
152
|
+
if created && exactPrivateMode {
|
|
153
|
+
guard fchmod(descriptor, 0o700) == 0, fstat(descriptor, &metadata) == 0 else {
|
|
154
|
+
throw systemCall("fchmod_directory")
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
guard (metadata.st_mode & S_IFMT) == S_IFDIR,
|
|
158
|
+
(exactPrivateMode ? (metadata.st_mode & 0o777) == 0o700 : (metadata.st_mode & 0o022) == 0),
|
|
159
|
+
metadata.st_uid == geteuid(),
|
|
160
|
+
metadata.st_dev == pathMetadata.st_dev,
|
|
161
|
+
metadata.st_ino == pathMetadata.st_ino else {
|
|
162
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
163
|
+
}
|
|
164
|
+
return true
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
private func readPrivateFile(_ url: URL) throws -> Data? {
|
|
168
|
+
var pathMetadata = stat()
|
|
169
|
+
if lstat(url.path, &pathMetadata) != 0 {
|
|
170
|
+
let code = errno
|
|
171
|
+
if code == ENOENT { return nil }
|
|
172
|
+
throw TelegramPrivateFileError.systemCall("lstat_file", code)
|
|
173
|
+
}
|
|
174
|
+
guard (pathMetadata.st_mode & S_IFMT) == S_IFREG else {
|
|
175
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
176
|
+
}
|
|
177
|
+
let descriptor = open(url.path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC)
|
|
178
|
+
guard descriptor >= 0 else { throw systemCall("open_file") }
|
|
179
|
+
defer { close(descriptor) }
|
|
180
|
+
var before = stat()
|
|
181
|
+
guard fstat(descriptor, &before) == 0,
|
|
182
|
+
(before.st_mode & S_IFMT) == S_IFREG,
|
|
183
|
+
(before.st_mode & 0o777) == 0o600,
|
|
184
|
+
before.st_uid == geteuid(),
|
|
185
|
+
before.st_dev == pathMetadata.st_dev,
|
|
186
|
+
before.st_ino == pathMetadata.st_ino else {
|
|
187
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
188
|
+
}
|
|
189
|
+
guard before.st_size <= off_t(Self.maximumFileBytes) else {
|
|
190
|
+
throw TelegramPrivateFileError.fileTooLarge(url.path)
|
|
191
|
+
}
|
|
192
|
+
var data = Data()
|
|
193
|
+
var buffer = [UInt8](repeating: 0, count: 16 * 1024)
|
|
194
|
+
while true {
|
|
195
|
+
let count = Darwin.read(descriptor, &buffer, buffer.count)
|
|
196
|
+
if count == 0 { break }
|
|
197
|
+
guard count > 0 else {
|
|
198
|
+
if errno == EINTR { continue }
|
|
199
|
+
throw systemCall("read_file")
|
|
200
|
+
}
|
|
201
|
+
data.append(contentsOf: buffer.prefix(count))
|
|
202
|
+
guard data.count <= Self.maximumFileBytes else {
|
|
203
|
+
throw TelegramPrivateFileError.fileTooLarge(url.path)
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
var after = stat()
|
|
207
|
+
var pathAfter = stat()
|
|
208
|
+
guard fstat(descriptor, &after) == 0,
|
|
209
|
+
lstat(url.path, &pathAfter) == 0,
|
|
210
|
+
after.st_dev == before.st_dev,
|
|
211
|
+
after.st_ino == before.st_ino,
|
|
212
|
+
after.st_size == before.st_size,
|
|
213
|
+
(after.st_mode & S_IFMT) == S_IFREG,
|
|
214
|
+
(after.st_mode & 0o777) == 0o600,
|
|
215
|
+
after.st_uid == geteuid(),
|
|
216
|
+
pathAfter.st_dev == after.st_dev,
|
|
217
|
+
pathAfter.st_ino == after.st_ino,
|
|
218
|
+
(pathAfter.st_mode & S_IFMT) == S_IFREG,
|
|
219
|
+
(pathAfter.st_mode & 0o777) == 0o600,
|
|
220
|
+
pathAfter.st_uid == geteuid() else {
|
|
221
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
222
|
+
}
|
|
223
|
+
return data
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
private func writePrivateFileAtomically(_ data: Data, to url: URL) throws {
|
|
227
|
+
guard data.count <= Self.maximumFileBytes else {
|
|
228
|
+
throw TelegramPrivateFileError.fileTooLarge(url.path)
|
|
229
|
+
}
|
|
230
|
+
var existing = stat()
|
|
231
|
+
if lstat(url.path, &existing) == 0 {
|
|
232
|
+
guard (existing.st_mode & S_IFMT) == S_IFREG,
|
|
233
|
+
(existing.st_mode & 0o777) == 0o600,
|
|
234
|
+
existing.st_uid == geteuid() else {
|
|
235
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
236
|
+
}
|
|
237
|
+
} else {
|
|
238
|
+
let code = errno
|
|
239
|
+
if code != ENOENT { throw TelegramPrivateFileError.systemCall("lstat_file", code) }
|
|
240
|
+
}
|
|
241
|
+
let temporaryURL = stateDirectory.appendingPathComponent(
|
|
242
|
+
".\(url.lastPathComponent).\(getpid()).\(UUID().uuidString).tmp"
|
|
243
|
+
)
|
|
244
|
+
let descriptor = open(temporaryURL.path, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW | O_CLOEXEC, 0o600)
|
|
245
|
+
guard descriptor >= 0 else { throw systemCall("open_temporary") }
|
|
246
|
+
var descriptorOpen = true
|
|
247
|
+
defer {
|
|
248
|
+
if descriptorOpen { close(descriptor) }
|
|
249
|
+
unlink(temporaryURL.path)
|
|
250
|
+
}
|
|
251
|
+
guard fchmod(descriptor, 0o600) == 0 else { throw systemCall("fchmod_temporary") }
|
|
252
|
+
var metadata = stat()
|
|
253
|
+
guard fstat(descriptor, &metadata) == 0,
|
|
254
|
+
(metadata.st_mode & S_IFMT) == S_IFREG,
|
|
255
|
+
(metadata.st_mode & 0o777) == 0o600,
|
|
256
|
+
metadata.st_uid == geteuid() else {
|
|
257
|
+
throw TelegramPrivateFileError.insecurePath(temporaryURL.path)
|
|
258
|
+
}
|
|
259
|
+
try writeAll(data, descriptor: descriptor)
|
|
260
|
+
guard fsync(descriptor) == 0 else { throw systemCall("fsync_temporary") }
|
|
261
|
+
guard close(descriptor) == 0 else { throw systemCall("close_temporary") }
|
|
262
|
+
descriptorOpen = false
|
|
263
|
+
guard rename(temporaryURL.path, url.path) == 0 else { throw systemCall("rename_state") }
|
|
264
|
+
let directoryDescriptor = open(stateDirectory.path, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
|
|
265
|
+
guard directoryDescriptor >= 0 else { throw systemCall("open_state_directory") }
|
|
266
|
+
guard fsync(directoryDescriptor) == 0 else {
|
|
267
|
+
let code = errno
|
|
268
|
+
close(directoryDescriptor)
|
|
269
|
+
throw TelegramPrivateFileError.systemCall("fsync_state_directory", code)
|
|
270
|
+
}
|
|
271
|
+
guard close(directoryDescriptor) == 0 else { throw systemCall("close_state_directory") }
|
|
272
|
+
guard try readPrivateFile(url) == data else {
|
|
273
|
+
throw TelegramPrivateFileError.insecurePath(url.path)
|
|
274
|
+
}
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
private func writeAll(_ data: Data, descriptor: Int32) throws {
|
|
278
|
+
try data.withUnsafeBytes { bytes in
|
|
279
|
+
var offset = 0
|
|
280
|
+
while offset < bytes.count {
|
|
281
|
+
guard let base = bytes.baseAddress else { break }
|
|
282
|
+
let count = Darwin.write(descriptor, base.advanced(by: offset), bytes.count - offset)
|
|
283
|
+
guard count >= 0 else {
|
|
284
|
+
if errno == EINTR { continue }
|
|
285
|
+
throw systemCall("write_temporary")
|
|
286
|
+
}
|
|
287
|
+
offset += count
|
|
288
|
+
}
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
private func systemCall(_ operation: String) -> TelegramPrivateFileError {
|
|
293
|
+
TelegramPrivateFileError.systemCall(operation, errno)
|
|
294
|
+
}
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
private extension NSLock {
|
|
298
|
+
func withTelegramFileLock<T>(_ body: () throws -> T) rethrows -> T {
|
|
299
|
+
lock()
|
|
300
|
+
defer { unlock() }
|
|
301
|
+
return try body()
|
|
302
|
+
}
|
|
303
|
+
}
|
|
@@ -0,0 +1,238 @@
|
|
|
1
|
+
import Darwin
|
|
2
|
+
import Foundation
|
|
3
|
+
|
|
4
|
+
enum TelegramProcessGatewayError: Error, Equatable {
|
|
5
|
+
case processFailed(String)
|
|
6
|
+
case invalidResponse
|
|
7
|
+
case auditLedgerUnsafe
|
|
8
|
+
case auditLedgerWriteFailed
|
|
9
|
+
}
|
|
10
|
+
|
|
11
|
+
/// Concrete native bridge to the canonical TypeScript command-contract
|
|
12
|
+
/// registry. Only these fixed argv vectors are allowed; user text is bounded
|
|
13
|
+
/// JSON on stdin and is never interpolated into a shell command.
|
|
14
|
+
final class TelegramProcessCommandGateway: TelegramTypedCommandGateway, @unchecked Sendable {
|
|
15
|
+
typealias ProcessRunner = (
|
|
16
|
+
_ arguments: [String], _ stdin: String, _ timeout: TimeInterval,
|
|
17
|
+
_ completion: @escaping (ProcessResult) -> Void
|
|
18
|
+
) -> Void
|
|
19
|
+
private struct Preparation: Decodable {
|
|
20
|
+
let allowed: Bool
|
|
21
|
+
let confirmation_required: Bool
|
|
22
|
+
let public_error: String?
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
private let processRunner: ProcessRunner
|
|
26
|
+
|
|
27
|
+
init(processClient: ProcessClient) {
|
|
28
|
+
self.processRunner = { arguments, stdin, timeout, completion in
|
|
29
|
+
processClient.run(
|
|
30
|
+
arguments,
|
|
31
|
+
stdin: stdin,
|
|
32
|
+
environment: [
|
|
33
|
+
"TELEGRAM_BOT_TOKEN": "",
|
|
34
|
+
"SKS_TELEGRAM_BOT_TOKEN": ""
|
|
35
|
+
],
|
|
36
|
+
timeout: timeout,
|
|
37
|
+
maxOutputBytes: 1024 * 1024,
|
|
38
|
+
logOutput: false,
|
|
39
|
+
completion: completion
|
|
40
|
+
)
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
init(processRunner: @escaping ProcessRunner) {
|
|
45
|
+
self.processRunner = processRunner
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
func prepare(_ request: TelegramTypedCommandRequest) async -> TelegramTypedCommandDecision {
|
|
49
|
+
do {
|
|
50
|
+
let output = try await run(
|
|
51
|
+
arguments: ["telegram", "prepare", "--stdin-json", "--json"],
|
|
52
|
+
request: request,
|
|
53
|
+
timeout: 20
|
|
54
|
+
)
|
|
55
|
+
let decoded = try JSONDecoder().decode(Preparation.self, from: Data(output.utf8))
|
|
56
|
+
return TelegramTypedCommandDecision(
|
|
57
|
+
allowed: decoded.allowed,
|
|
58
|
+
confirmationRequired: decoded.confirmation_required,
|
|
59
|
+
publicError: decoded.public_error
|
|
60
|
+
)
|
|
61
|
+
} catch {
|
|
62
|
+
return TelegramTypedCommandDecision(
|
|
63
|
+
allowed: false,
|
|
64
|
+
confirmationRequired: false,
|
|
65
|
+
publicError: telegramGatewayPublicError(error)
|
|
66
|
+
)
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
func execute(_ request: TelegramTypedCommandRequest) async throws -> String {
|
|
71
|
+
let output = try await run(
|
|
72
|
+
arguments: ["telegram", "execute", "--stdin-json", "--confirmed", "--json"],
|
|
73
|
+
request: request,
|
|
74
|
+
timeout: 190
|
|
75
|
+
)
|
|
76
|
+
guard let data = output.data(using: .utf8),
|
|
77
|
+
let row = try JSONSerialization.jsonObject(with: data) as? [String: Any],
|
|
78
|
+
row["ok"] as? Bool == true,
|
|
79
|
+
let value = row["output"] else { throw TelegramProcessGatewayError.invalidResponse }
|
|
80
|
+
if let string = value as? String { return String(string.prefix(4_000)) }
|
|
81
|
+
guard JSONSerialization.isValidJSONObject(value),
|
|
82
|
+
let encoded = try? JSONSerialization.data(withJSONObject: value, options: [.prettyPrinted, .sortedKeys]),
|
|
83
|
+
let rendered = String(data: encoded, encoding: .utf8) else {
|
|
84
|
+
throw TelegramProcessGatewayError.invalidResponse
|
|
85
|
+
}
|
|
86
|
+
return String(rendered.prefix(4_000))
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
private func run(
|
|
90
|
+
arguments: [String],
|
|
91
|
+
request: TelegramTypedCommandRequest,
|
|
92
|
+
timeout: TimeInterval
|
|
93
|
+
) async throws -> String {
|
|
94
|
+
guard let input = request.inputJSON.data(using: .utf8),
|
|
95
|
+
input.count <= 16 * 1024,
|
|
96
|
+
let object = try JSONSerialization.jsonObject(with: input) as? [String: Any] else {
|
|
97
|
+
throw TelegramProcessGatewayError.invalidResponse
|
|
98
|
+
}
|
|
99
|
+
let payload = try JSONSerialization.data(withJSONObject: ["name": request.name, "input": object], options: [.sortedKeys])
|
|
100
|
+
guard payload.count <= 32 * 1024, let stdin = String(data: payload, encoding: .utf8) else {
|
|
101
|
+
throw TelegramProcessGatewayError.invalidResponse
|
|
102
|
+
}
|
|
103
|
+
return try await withCheckedThrowingContinuation { continuation in
|
|
104
|
+
processRunner(arguments, stdin, timeout) { result in
|
|
105
|
+
guard result.code == 0, !result.timedOut, !result.truncated, !result.emptyOutput else {
|
|
106
|
+
continuation.resume(throwing: TelegramProcessGatewayError.processFailed(
|
|
107
|
+
result.timedOut ? "timeout" : result.truncated ? "output_limit" : "exit_\(result.code)"
|
|
108
|
+
))
|
|
109
|
+
return
|
|
110
|
+
}
|
|
111
|
+
continuation.resume(returning: result.output)
|
|
112
|
+
}
|
|
113
|
+
}
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
final class TelegramAuditLedger: @unchecked Sendable {
|
|
118
|
+
private struct Row: Encodable {
|
|
119
|
+
let schema = "sks.telegram-audit.v1"
|
|
120
|
+
let at: String
|
|
121
|
+
let actor: String
|
|
122
|
+
let action: String
|
|
123
|
+
let command: String?
|
|
124
|
+
let outcome: String
|
|
125
|
+
let detail: String?
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
private let url: URL
|
|
129
|
+
private let maximumBytes: Int64
|
|
130
|
+
private let lock = NSLock()
|
|
131
|
+
|
|
132
|
+
init(url: URL, maximumBytes: Int64 = 4 * 1024 * 1024) {
|
|
133
|
+
self.url = url
|
|
134
|
+
self.maximumBytes = max(64 * 1024, min(maximumBytes, 16 * 1024 * 1024))
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
func record(_ event: TelegramNativeAuditEvent) throws {
|
|
138
|
+
try lock.withTelegramAuditLock {
|
|
139
|
+
let directory = url.deletingLastPathComponent()
|
|
140
|
+
try FileManager.default.createDirectory(
|
|
141
|
+
at: directory,
|
|
142
|
+
withIntermediateDirectories: true,
|
|
143
|
+
attributes: [.posixPermissions: 0o700]
|
|
144
|
+
)
|
|
145
|
+
let descriptor = open(url.path, O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW | O_CLOEXEC, 0o600)
|
|
146
|
+
guard descriptor >= 0 else { throw TelegramProcessGatewayError.auditLedgerUnsafe }
|
|
147
|
+
defer { close(descriptor) }
|
|
148
|
+
var metadata = stat()
|
|
149
|
+
guard fstat(descriptor, &metadata) == 0,
|
|
150
|
+
(metadata.st_mode & S_IFMT) == S_IFREG,
|
|
151
|
+
metadata.st_uid == getuid(),
|
|
152
|
+
(metadata.st_mode & 0o077) == 0 else {
|
|
153
|
+
throw TelegramProcessGatewayError.auditLedgerUnsafe
|
|
154
|
+
}
|
|
155
|
+
guard flock(descriptor, LOCK_EX) == 0 else { throw TelegramProcessGatewayError.auditLedgerWriteFailed }
|
|
156
|
+
defer { flock(descriptor, LOCK_UN) }
|
|
157
|
+
if metadata.st_size >= maximumBytes {
|
|
158
|
+
guard ftruncate(descriptor, 0) == 0 else { throw TelegramProcessGatewayError.auditLedgerWriteFailed }
|
|
159
|
+
}
|
|
160
|
+
let row = Row(
|
|
161
|
+
at: telegramGatewayISODate(), actor: event.actor, action: event.action,
|
|
162
|
+
command: event.command, outcome: event.outcome,
|
|
163
|
+
detail: event.detail.map { String($0.prefix(512)) }
|
|
164
|
+
)
|
|
165
|
+
var data = try JSONEncoder().encode(row)
|
|
166
|
+
data.append(0x0a)
|
|
167
|
+
let wrote = data.withUnsafeBytes { buffer -> Int in
|
|
168
|
+
guard let base = buffer.baseAddress else { return -1 }
|
|
169
|
+
return Darwin.write(descriptor, base, buffer.count)
|
|
170
|
+
}
|
|
171
|
+
guard wrote == data.count, fsync(descriptor) == 0 else {
|
|
172
|
+
throw TelegramProcessGatewayError.auditLedgerWriteFailed
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
/// Small lifecycle surface for AppDelegate. The existing menu-bar process owns
|
|
179
|
+
/// this object; it creates no daemon, listener, tunnel, or config file.
|
|
180
|
+
final class TelegramMenuBarService {
|
|
181
|
+
private let runtime: TelegramMenuBarRuntime
|
|
182
|
+
|
|
183
|
+
init(runtime: TelegramMenuBarRuntime) { self.runtime = runtime }
|
|
184
|
+
|
|
185
|
+
@discardableResult
|
|
186
|
+
func start() -> Task<TelegramLivenessReceipt, Error> {
|
|
187
|
+
Task { try await runtime.start() }
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
@discardableResult
|
|
191
|
+
func restart() -> Task<TelegramLivenessReceipt, Error> {
|
|
192
|
+
Task { try await runtime.restart() }
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
@discardableResult
|
|
196
|
+
func stop() -> Task<Void, Never> {
|
|
197
|
+
Task { await runtime.stop() }
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
/// App termination is synchronous. Wait only long enough for the actor to
|
|
201
|
+
/// cancel polling and persist the final `running=false` receipt.
|
|
202
|
+
@discardableResult
|
|
203
|
+
func stopAndWait(timeout: TimeInterval = 2) -> Bool {
|
|
204
|
+
let signal = DispatchSemaphore(value: 0)
|
|
205
|
+
Task.detached { [runtime] in
|
|
206
|
+
await runtime.stop()
|
|
207
|
+
signal.signal()
|
|
208
|
+
}
|
|
209
|
+
return signal.wait(timeout: .now() + max(0.1, min(timeout, 5))) == .success
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
enum TelegramRuntimeFactory {
|
|
214
|
+
static func make(processClient: ProcessClient, home: URL = FileManager.default.homeDirectoryForCurrentUser) -> TelegramMenuBarService {
|
|
215
|
+
let install = home.appendingPathComponent(".codex/sks-menubar", isDirectory: true)
|
|
216
|
+
let ledger = TelegramAuditLedger(url: install.appendingPathComponent("logs/telegram-audit.jsonl"))
|
|
217
|
+
let runtime = TelegramMenuBarRuntime(
|
|
218
|
+
access: TelegramPrivateFileStore(homeDirectory: home),
|
|
219
|
+
gateway: TelegramProcessCommandGateway(processClient: processClient),
|
|
220
|
+
receiptURL: install.appendingPathComponent("telegram-liveness.json")
|
|
221
|
+
) { event in try ledger.record(event) }
|
|
222
|
+
return TelegramMenuBarService(runtime: runtime)
|
|
223
|
+
}
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
private extension NSLock {
|
|
227
|
+
func withTelegramAuditLock<T>(_ body: () throws -> T) rethrows -> T {
|
|
228
|
+
lock()
|
|
229
|
+
defer { unlock() }
|
|
230
|
+
return try body()
|
|
231
|
+
}
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
private func telegramGatewayISODate() -> String { ISO8601DateFormatter().string(from: Date()) }
|
|
235
|
+
|
|
236
|
+
private func telegramGatewayPublicError(_ error: Error) -> String {
|
|
237
|
+
String(String(describing: error).prefix(512))
|
|
238
|
+
}
|
|
@@ -0,0 +1,56 @@
|
|
|
1
|
+
import Darwin
|
|
2
|
+
import Foundation
|
|
3
|
+
|
|
4
|
+
enum TelegramSelfHealAction: String, Sendable {
|
|
5
|
+
case restartPoll = "restart_poll"
|
|
6
|
+
case revalidateToken = "revalidate_token"
|
|
7
|
+
case operatorRemoveWebhook = "operator_remove_webhook"
|
|
8
|
+
case operatorRepairAudit = "operator_repair_audit"
|
|
9
|
+
case none
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
func telegramSelfHealAction(_ receipt: TelegramLivenessReceipt) -> TelegramSelfHealAction {
|
|
13
|
+
if receipt.audit_healthy == false { return .operatorRepairAudit }
|
|
14
|
+
if !receipt.token_configured || !receipt.bot_identity_valid { return .revalidateToken }
|
|
15
|
+
if receipt.poller.last_error?.range(of: "409|webhook", options: .regularExpression) != nil {
|
|
16
|
+
return .operatorRemoveWebhook
|
|
17
|
+
}
|
|
18
|
+
if !receipt.running || !receipt.poller.running || receipt.poller.consecutive_failures > 0 { return .restartPoll }
|
|
19
|
+
return .none
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
final class TelegramLivenessWriter: @unchecked Sendable {
|
|
23
|
+
let url: URL
|
|
24
|
+
init(url: URL) { self.url = url }
|
|
25
|
+
|
|
26
|
+
func read() -> TelegramLivenessReceipt? {
|
|
27
|
+
guard let attributes = try? FileManager.default.attributesOfItem(atPath: url.path),
|
|
28
|
+
let kind = attributes[.type] as? FileAttributeType, kind == .typeRegular,
|
|
29
|
+
let owner = attributes[.ownerAccountID] as? NSNumber, owner.uint32Value == getuid(),
|
|
30
|
+
let permissions = attributes[.posixPermissions] as? NSNumber,
|
|
31
|
+
permissions.intValue & 0o077 == 0,
|
|
32
|
+
let data = try? Data(contentsOf: url), data.count <= 64 * 1024 else { return nil }
|
|
33
|
+
return try? JSONDecoder().decode(TelegramLivenessReceipt.self, from: data)
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
func write(_ receipt: TelegramLivenessReceipt) throws {
|
|
37
|
+
let directory = url.deletingLastPathComponent()
|
|
38
|
+
try FileManager.default.createDirectory(
|
|
39
|
+
at: directory,
|
|
40
|
+
withIntermediateDirectories: true,
|
|
41
|
+
attributes: [.posixPermissions: 0o700]
|
|
42
|
+
)
|
|
43
|
+
let temporary = directory.appendingPathComponent(".\(url.lastPathComponent).\(UUID().uuidString).tmp")
|
|
44
|
+
let data = try JSONEncoder().encode(receipt)
|
|
45
|
+
try data.write(to: temporary, options: .withoutOverwriting)
|
|
46
|
+
try FileManager.default.setAttributes([.posixPermissions: 0o600], ofItemAtPath: temporary.path)
|
|
47
|
+
do {
|
|
48
|
+
_ = try FileManager.default.replaceItemAt(url, withItemAt: temporary)
|
|
49
|
+
} catch CocoaError.fileNoSuchFile {
|
|
50
|
+
try FileManager.default.moveItem(at: temporary, to: url)
|
|
51
|
+
} catch {
|
|
52
|
+
try? FileManager.default.removeItem(at: temporary)
|
|
53
|
+
throw error
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
}
|
|
@@ -0,0 +1,56 @@
|
|
|
1
|
+
import Foundation
|
|
2
|
+
|
|
3
|
+
func telegramCommandRequest(_ text: String) -> TelegramTypedCommandRequest? {
|
|
4
|
+
let text = text.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
5
|
+
let pattern = #"^/sks\s+([a-z][a-z0-9-]{0,63})(?:\s+([\s\S]+))?$"#
|
|
6
|
+
guard let expression = try? NSRegularExpression(pattern: pattern),
|
|
7
|
+
let match = expression.firstMatch(in: text, range: NSRange(text.startIndex..., in: text)),
|
|
8
|
+
let nameRange = Range(match.range(at: 1), in: text) else { return nil }
|
|
9
|
+
let name = String(text[nameRange])
|
|
10
|
+
guard match.range(at: 2).location != NSNotFound,
|
|
11
|
+
let inputRange = Range(match.range(at: 2), in: text) else {
|
|
12
|
+
return TelegramTypedCommandRequest(name: name, inputJSON: "{}")
|
|
13
|
+
}
|
|
14
|
+
let raw = String(text[inputRange])
|
|
15
|
+
guard raw.utf8.count <= 16 * 1024,
|
|
16
|
+
let data = raw.data(using: .utf8),
|
|
17
|
+
let object = try? JSONSerialization.jsonObject(with: data),
|
|
18
|
+
object is [String: Any],
|
|
19
|
+
let normalized = try? JSONSerialization.data(withJSONObject: object, options: [.sortedKeys]),
|
|
20
|
+
let json = String(data: normalized, encoding: .utf8) else { return nil }
|
|
21
|
+
return TelegramTypedCommandRequest(name: name, inputJSON: json)
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
func telegramPairingCode(text: String, chatType: String) -> String? {
|
|
25
|
+
guard chatType == "private" else { return nil }
|
|
26
|
+
return telegramFirstCapture(#"^/start\s+([A-Za-z0-9_-]{6,64})$"#, text)
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
func telegramConfirmationNonce(_ text: String) -> String? {
|
|
30
|
+
telegramFirstCapture(#"^/confirm\s+([A-Za-z0-9_-]{16,64})$"#, text)
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
private func telegramFirstCapture(_ pattern: String, _ text: String) -> String? {
|
|
34
|
+
guard let expression = try? NSRegularExpression(pattern: pattern),
|
|
35
|
+
let match = expression.firstMatch(in: text, range: NSRange(text.startIndex..., in: text)),
|
|
36
|
+
let range = Range(match.range(at: 1), in: text) else { return nil }
|
|
37
|
+
return String(text[range])
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
func telegramISODate(_ date: Date = Date()) -> String {
|
|
41
|
+
ISO8601DateFormatter().string(from: date)
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
func telegramPublicError(_ value: String?, secret: String? = nil) -> String {
|
|
45
|
+
var raw = value ?? "telegram_error"
|
|
46
|
+
if let secret, !secret.isEmpty { raw = raw.replacingOccurrences(of: secret, with: "[redacted]") }
|
|
47
|
+
let botPattern = try? NSRegularExpression(pattern: #"/bot[^/\s]+/"#, options: [.caseInsensitive])
|
|
48
|
+
let redacted = botPattern?.stringByReplacingMatches(in: raw, range: NSRange(raw.startIndex..., in: raw), withTemplate: "/bot[redacted]/") ?? raw
|
|
49
|
+
return String(redacted.prefix(512))
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
func telegramRedactedActor(chatID: Int64, senderID: Int64) -> String {
|
|
53
|
+
var hash: UInt64 = 1469598103934665603
|
|
54
|
+
for byte in "\(chatID):\(senderID)".utf8 { hash = (hash ^ UInt64(byte)) &* 1099511628211 }
|
|
55
|
+
return String(format: "actor:%012llx", hash & 0xffffffffffff)
|
|
56
|
+
}
|