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.
Files changed (122) hide show
  1. package/README.md +47 -23
  2. package/config/skills-hash-ledger.v1.json +1 -1
  3. package/crates/sks-core/Cargo.lock +1 -1
  4. package/crates/sks-core/Cargo.toml +1 -1
  5. package/dist/bin/fast-inline.js +55 -13
  6. package/dist/bin/sks-dispatch.js +1 -1
  7. package/dist/cli/command-manifest-lite.js +4 -0
  8. package/dist/cli/command-registry.js +4 -0
  9. package/dist/cli/install-helpers-codex-lb-chain.js +187 -0
  10. package/dist/cli/install-helpers-codex-lb-config.js +74 -8
  11. package/dist/cli/install-helpers.js +89 -44
  12. package/dist/commands/codex-lb.js +117 -19
  13. package/dist/commands/doctor.js +697 -37
  14. package/dist/config/skills-manifest.json +3 -2
  15. package/dist/core/agents/agent-runner-codex-exec.js +5 -3
  16. package/dist/core/codex/codex-config-guard.js +238 -52
  17. package/dist/core/codex-adapter.js +5 -3
  18. package/dist/core/codex-app/menubar/constants.js +10 -1
  19. package/dist/core/codex-app/menubar/global-install.js +288 -0
  20. package/dist/core/codex-app/menubar/installer.js +79 -14
  21. package/dist/core/codex-app/menubar/launch-agent.js +267 -45
  22. package/dist/core/codex-app/menubar/paths.js +3 -0
  23. package/dist/core/codex-app/menubar/rollback.js +55 -7
  24. package/dist/core/codex-app/menubar/status.js +75 -4
  25. package/dist/core/codex-control/codex-0139-image-path-real-probe.js +3 -1
  26. package/dist/core/codex-control/codex-0139-web-search-probe.js +3 -1
  27. package/dist/core/codex-control/codex-app-server-runtime-env.js +13 -4
  28. package/dist/core/codex-control/codex-app-server-v2-client.js +3 -3
  29. package/dist/core/codex-exec-output-schema.js +4 -1
  30. package/dist/core/codex-lb/codex-lb-env.js +63 -72
  31. package/dist/core/codex-lb/codex-lb-setup.js +15 -2
  32. package/dist/core/codex-lb/desktop-center-credentials.js +517 -58
  33. package/dist/core/codex-lb/desktop-controller.js +153 -24
  34. package/dist/core/codex-lb/routing-truth.js +327 -0
  35. package/dist/core/codex-native/core-skill-manifest.js +1 -1
  36. package/dist/core/commands/basic-cli.js +7 -1
  37. package/dist/core/commands/qa-loop-command.js +3 -1
  38. package/dist/core/commands/telegram-command.js +241 -0
  39. package/dist/core/config-adopt/config-adopt-command.js +35 -0
  40. package/dist/core/config-adopt/config-adopt.js +346 -0
  41. package/dist/core/config-adopt/index.js +3 -0
  42. package/dist/core/doctor/command-alias-cleanup.js +4 -1
  43. package/dist/core/doctor/current-project-guidance-nested.js +37 -6
  44. package/dist/core/doctor/current-project-guidance.js +11 -6
  45. package/dist/core/doctor/doctor-readiness-matrix.js +14 -0
  46. package/dist/core/doctor/retired-managed-residue-private.js +1 -1
  47. package/dist/core/doctor/sks-menubar-doctor.js +4 -0
  48. package/dist/core/feature-fixtures.js +8 -0
  49. package/dist/core/hooks-runtime/hook-context.js +9 -0
  50. package/dist/core/hooks-runtime/managed-skill-admission.js +54 -4
  51. package/dist/core/hooks-runtime/official-subagent-lifecycle.js +69 -1
  52. package/dist/core/hooks-runtime/subagent-skill-availability-contract.js +2 -2
  53. package/dist/core/hooks-runtime/subagent-skill-availability-evidence.js +3 -3
  54. package/dist/core/hooks-runtime/subagent-skill-availability-guards.js +43 -5
  55. package/dist/core/hooks-runtime/subagent-skill-availability.js +64 -30
  56. package/dist/core/hooks-runtime/subagent-stop-hook.js +15 -2
  57. package/dist/core/hooks-runtime.js +148 -4
  58. package/dist/core/imagegen/imagegen-capability.js +46 -0
  59. package/dist/core/imagegen/require-imagegen.js +2 -2
  60. package/dist/core/init/skills.js +17 -3
  61. package/dist/core/install/installed-package-smoke.js +8 -2
  62. package/dist/core/naruto/hardware-capacity-probe.js +9 -3
  63. package/dist/core/naruto/naruto-concurrency-governor.js +68 -24
  64. package/dist/core/perf/import-graph-budget.js +0 -1
  65. package/dist/core/product-design-app-server.js +13 -1
  66. package/dist/core/release/package-size-budget.js +2 -2
  67. package/dist/core/release/release-pack-receipt.js +1 -2
  68. package/dist/core/routes/dollar-manifest-lite.js +1 -1
  69. package/dist/core/routes.js +1 -1
  70. package/dist/core/security/private-credential-file.js +209 -0
  71. package/dist/core/subagents/agent-catalog.js +17 -32
  72. package/dist/core/subagents/naruto-help-contract.js +5 -5
  73. package/dist/core/subagents/official-subagent-config.js +16 -6
  74. package/dist/core/subagents/official-subagent-preparation.js +34 -15
  75. package/dist/core/subagents/official-subagent-prompt.js +4 -4
  76. package/dist/core/subagents/official-subagent-runner.js +27 -4
  77. package/dist/core/subagents/thread-budget.js +19 -12
  78. package/dist/core/subagents/wave-lifecycle.js +18 -6
  79. package/dist/core/telegram/access.js +54 -0
  80. package/dist/core/telegram/client.js +144 -0
  81. package/dist/core/telegram/confirmation.js +37 -0
  82. package/dist/core/telegram/doctor.js +151 -0
  83. package/dist/core/telegram/index.js +9 -0
  84. package/dist/core/telegram/keychain.js +265 -0
  85. package/dist/core/telegram/liveness.js +109 -0
  86. package/dist/core/telegram/poller.js +90 -0
  87. package/dist/core/telegram/redaction.js +15 -0
  88. package/dist/core/telegram/types.js +1 -0
  89. package/dist/core/update/update-diagnostics.js +52 -0
  90. package/dist/core/update/update-migration-state.js +5 -1
  91. package/dist/core/update/update-operation.js +2 -1
  92. package/dist/core/update/update-stage-diagnostics.js +38 -0
  93. package/dist/core/update/update-status.js +2 -9
  94. package/dist/core/update-check.js +147 -31
  95. package/dist/core/version.js +1 -1
  96. package/dist/core/zellij/zellij-launcher.js +23 -4
  97. package/dist/native/sks-menubar/Sources/AppDelegate.swift +13 -0
  98. package/dist/native/sks-menubar/Sources/AppIdentity.swift +7 -0
  99. package/dist/native/sks-menubar/Sources/OperationCoordinator.swift +3 -2
  100. package/dist/native/sks-menubar/Sources/ProvidersConnectTest.swift +115 -0
  101. package/dist/native/sks-menubar/Sources/ProvidersFastMode.swift +17 -0
  102. package/dist/native/sks-menubar/Sources/ProvidersRoutingTruth.swift +190 -0
  103. package/dist/native/sks-menubar/Sources/ProvidersViewController.swift +100 -59
  104. package/dist/native/sks-menubar/Sources/SingletonInstanceGuard.swift +328 -0
  105. package/dist/native/sks-menubar/Sources/TelegramPrivateFileStore.swift +320 -0
  106. package/dist/native/sks-menubar/Sources/TelegramPrivateFileSupport.swift +303 -0
  107. package/dist/native/sks-menubar/Sources/TelegramProcessGateway.swift +238 -0
  108. package/dist/native/sks-menubar/Sources/TelegramRuntimeSupport.swift +56 -0
  109. package/dist/native/sks-menubar/Sources/TelegramSupport.swift +56 -0
  110. package/dist/native/sks-menubar/Sources/TelegramTransport.swift +474 -0
  111. package/dist/native/sks-menubar/Sources/main.swift +15 -1
  112. package/dist/native/sks-menubar/Tests/OperationCoordinatorTests.swift +4 -3
  113. package/dist/native/sks-menubar/Tests/ProvidersViewControllerTests.swift +129 -0
  114. package/dist/native/sks-menubar/Tests/SingletonInstanceGuardTests.swift +183 -0
  115. package/dist/native/sks-menubar/Tests/TelegramRuntimeSmokeTests.swift +267 -0
  116. package/dist/native/sks-menubar/Tests/TelegramRuntimeTests.swift +222 -0
  117. package/dist/scripts/codex-lb-fast-mode-truth-check.js +1 -1
  118. package/dist/scripts/codex-lb-fast-ui-preservation-check.js +1 -1
  119. package/dist/scripts/current-command-surface-check.js +2 -4
  120. package/dist/scripts/official-subagent-workflow-check.js +1 -1
  121. package/dist/scripts/packlist-performance-check.js +1 -2
  122. 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, &current) == 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
+ }