sneakoscope 8.0.2 → 8.0.3

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "8.0.2",
+  "package_version": "8.0.3",
   "skills": [
     {
       "canonical_name": "sks",
@@ -326,8 +326,9 @@
     {
       "canonical_name": "sks-naruto",
       "type": "core",
-      "content_sha256": "f8e808622e222b4ad7dcb2907e5f06a890db83139ae443ec6c8c33781dfa3e37",
+      "content_sha256": "34222c72e4e1ead3584907f4d905444b7de820283ee7348018f110d5e6b04461",
       "hash_history": [
+        "f8e808622e222b4ad7dcb2907e5f06a890db83139ae443ec6c8c33781dfa3e37",
         "49b5e3dcc1b537b49c2cf09e5b875cb16acb05c622b22798e265e64dacd8ac90"
       ],
       "deprecated_aliases": []

package/dist/core/agents/agent-runner-codex-exec.js

@@ -5,6 +5,7 @@ import { agentWorkerEnv, validateAgentWorkerResult } from './agent-worker-pipeli
 import { fastModeEnv, resolveFastModePolicy } from './fast-mode-policy.js';
 import { buildCodexExecArgs } from '../codex/codex-cli-syntax-builder.js';
 import { codexLbRecoveryBlockedProcessResult, withCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
+import { prepareCodexAppServerRuntimeEnv } from '../codex-control/codex-app-server-runtime-env.js';
 export function buildCodexExecAgentArgs(agent, prompt, opts = {}) {
     const resultFile = opts.resultFile || defaultCodexResultFile(agent, opts);
     const sandbox = opts.workspaceWrite ? 'workspace-write' : 'read-only';
@@ -74,15 +75,16 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
     const allowedCommandsFile = path.join(opts.agentRoot || opts.cwd || process.cwd(), 'agent-allowed-commands.json');
     const workerEnv = agentWorkerEnv(agent, allowedCommandsFile);
     const effectiveEnv = { ...process.env, ...(opts.env || {}) };
-    const proxyEnv = managedProxyEnvForChild(effectiveEnv);
+    const runtimeEnv = await prepareCodexAppServerRuntimeEnv({ env: effectiveEnv });
+    const proxyEnv = managedProxyEnvForChild(runtimeEnv);
     const execute = opts.runProcessImpl || runProcess;
     const guarded = await withCodexLbCliLaunchRecovery({
         root: opts.cwd || process.cwd(),
-        env: effectiveEnv,
+        env: runtimeEnv,
         cliArgs: command.args.slice(0, -1),
         ...(typeof opts.recoveryFetch === 'function' ? { fetchImpl: opts.recoveryFetch } : {}),
         ...(opts.recoveryTimeoutMs === undefined ? {} : { timeoutMs: opts.recoveryTimeoutMs })
-    }, () => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
+    }, () => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...runtimeEnv, ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
     const result = guarded.launched
         ? guarded.value
         : codexLbRecoveryBlockedProcessResult(guarded.toolOutputRecovery);

package/dist/core/codex/codex-config-guard.js

@@ -5,6 +5,7 @@ import { appendJsonl, ensureDir, nowIso, readText, sha256, writeTextAtomic } fro
 import { diffCodexAppUiSnapshots, snapshotCodexAppUiState } from '../codex-app/codex-app-ui-state-snapshot.js';
 import { cleanupCodexConfigBackups, validateCodexConfigRoundTrip } from './codex-config-toml.js';
 import { escapeRegExp } from '../text/regex.js';
+export const SKS_MANAGED_CODEX_CONFIG_MARKER = '# SKS-MANAGED-CODEX-CONFIG';
 const FAST_FEATURE_KEYS = [
     'fast_mode',
     'hooks',
@@ -23,18 +24,6 @@ export async function writeCodexConfigGuarded(input) {
     const root = path.resolve(input.root || process.cwd());
     const cause = input.cause || 'codex-config';
     const before = input.before === undefined ? String(await readText(configPath, '')) : String(input.before || '');
-    if (isUnmanagedProjectCodexConfig(root, configPath, before) && input.ownershipVerified !== true) {
-        const result = { ok: false, status: 'blocked_unmanaged_project_config', config_path: configPath, backup_path: null, changed: false };
-        await recordCodexConfigGuard(root, input.reportPath, {
-            cause,
-            config_path: configPath,
-            ok: false,
-            status: result.status,
-            blocker: 'user_owned_file_without_sks_marker',
-            changed: false
-        });
-        return result;
-    }
     const beforeSmoke = codexConfigParseSmoke(before);
     const beforeValidation = validateCodexConfigRoundTrip(before);
     if (before.trim() && (!beforeSmoke.ok || beforeValidation.parse_error)) {
@@ -62,6 +51,21 @@ export async function writeCodexConfigGuarded(input) {
     next = preserved.text;
     if (input.removeTopLevelModeLocks === true)
         next = removeLegacyTopLevelCodexModeLocks(next);
+    const expectedBefore = normalizeText(before);
+    const unmanagedProjectConfig = isUnmanagedProjectCodexConfig(root, configPath, before)
+        && input.ownershipVerified !== true;
+    if (unmanagedProjectConfig && next !== expectedBefore) {
+        const result = { ok: false, status: 'blocked_unmanaged_project_config', config_path: configPath, backup_path: null, changed: false };
+        await recordCodexConfigGuard(root, input.reportPath, {
+            cause,
+            config_path: configPath,
+            ok: false,
+            status: result.status,
+            blocker: 'user_owned_file_without_sks_marker',
+            changed: false
+        });
+        return result;
+    }
     const forbiddenTopLevel = topLevelModeLocks(next);
     const nextSmoke = codexConfigParseSmoke(next);
     const nextValidation = validateCodexConfigRoundTrip(next);
@@ -80,17 +84,19 @@ export async function writeCodexConfigGuarded(input) {
         });
         return result;
     }
-    const expectedBefore = normalizeText(before);
     if (next === expectedBefore) {
-        if (input.verifyUnchangedBeforeWrite === true) {
+        const verifyWithoutWrite = input.verifyUnchangedBeforeWrite === true || unmanagedProjectConfig;
+        if (verifyWithoutWrite) {
             const observed = await readConfigCommitSnapshot(configPath);
-            const expectedExists = input.expectedBeforeExists ?? true;
+            const expectedExists = unmanagedProjectConfig ? true : (input.expectedBeforeExists ?? true);
             if (!configCommitSnapshotMatches(observed, expectedExists, before, input.expectedBeforeMode)) {
-                return recordConcurrentConfigChange({
+                return recordConfigCommitFailure({
                     root,
                     reportPath: input.reportPath,
                     cause,
                     configPath,
+                    status: 'concurrent_change_detected',
+                    changed: false,
                     before,
                     expectedExists,
                     ...(input.expectedBeforeMode === undefined
@@ -106,11 +112,11 @@ export async function writeCodexConfigGuarded(input) {
         else {
             await writeTextAtomic(configPath, next, { mode: 0o600 });
         }
-        const expectedAfterExists = input.verifyUnchangedBeforeWrite === true
-            ? (input.expectedBeforeExists ?? true)
+        const expectedAfterExists = verifyWithoutWrite
+            ? (unmanagedProjectConfig ? true : (input.expectedBeforeExists ?? true))
             : true;
         const expectedAfterMode = expectedAfterExists
-            ? input.verifyUnchangedBeforeWrite === true
+            ? verifyWithoutWrite
                 ? (input.expectedBeforeMode === undefined ? null : Number(input.expectedBeforeMode) & 0o777)
                 : 0o600
             : null;
@@ -125,7 +131,7 @@ export async function writeCodexConfigGuarded(input) {
             expected_after: {
                 exists: expectedAfterExists,
                 text: expectedAfterExists
-                    ? (input.verifyUnchangedBeforeWrite === true ? before : next)
+                    ? (verifyWithoutWrite ? before : next)
                     : '',
                 mode: expectedAfterMode
             }
@@ -157,11 +163,13 @@ export async function writeCodexConfigGuarded(input) {
             backupTag: input.backupTag || cause
         });
         if (!commit.ok) {
-            return recordConcurrentConfigChange({
+            return recordConfigCommitFailure({
                 root,
                 reportPath: input.reportPath,
                 cause,
                 configPath,
+                status: commit.failure,
+                changed: commit.changed,
                 before,
                 expectedExists,
                 ...(input.expectedBeforeMode === undefined
@@ -226,13 +234,13 @@ function configCommitSnapshotMatches(observed, expectedExists, expectedText, exp
             || expectedMode === undefined
             || observed.mode === (Number(expectedMode) & 0o777));
 }
-async function recordConcurrentConfigChange(input) {
+async function recordConfigCommitFailure(input) {
     const result = {
         ok: false,
-        status: 'concurrent_change_detected',
+        status: input.status,
         config_path: input.configPath,
         backup_path: input.backupPath,
-        changed: false,
+        changed: input.changed,
         repaired_keys: input.repairedKeys,
         forbidden_top_level: input.forbiddenTopLevel
     };
@@ -251,7 +259,7 @@ async function recordConcurrentConfigChange(input) {
         observed_sha256: input.observed.ok ? sha256(input.observed.text) : null,
         observed_status: input.observed.status,
         backup_path: input.backupPath,
-        changed: false
+        changed: input.changed
     });
     return result;
 }
@@ -264,48 +272,168 @@ async function commitCodexConfigIfUnchanged(input) {
         await writeTextAtomic(candidatePath, input.next, { mode: 0o600 });
         const observed = await readConfigCommitSnapshot(input.configPath);
         if (!configCommitSnapshotMatches(observed, input.expectedExists, input.before, input.expectedBeforeMode)) {
-            return { ok: false, backupPath, observed };
+            return {
+                ok: false,
+                failure: 'concurrent_change_detected',
+                changed: false,
+                backupPath,
+                observed
+            };
         }
+        const claimedBeforeMode = input.expectedBeforeMode === undefined
+            ? (observed.ok && observed.exists ? observed.mode : undefined)
+            : Number(input.expectedBeforeMode) & 0o777;
         if (input.expectedExists) {
             backupPath = `${input.configPath}.sks-${safeBackupTag(input.backupTag)}-${token}.bak`;
             try {
                 await fsp.rename(input.configPath, backupPath);
             }
             catch {
-                return { ok: false, backupPath: null, observed: await readConfigCommitSnapshot(input.configPath) };
+                return {
+                    ok: false,
+                    failure: 'concurrent_change_detected',
+                    changed: false,
+                    backupPath: null,
+                    observed: await readConfigCommitSnapshot(input.configPath)
+                };
             }
             const claimed = await readConfigCommitSnapshot(backupPath);
-            if (!configCommitSnapshotMatches(claimed, true, input.before, input.expectedBeforeMode)) {
-                await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
-                return { ok: false, backupPath, observed: claimed };
-            }
-            try {
-                await fsp.chmod(backupPath, 0o600);
-                const now = new Date();
-                await fsp.utimes(backupPath, now, now);
-            }
-            catch {
-                await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
-                return { ok: false, backupPath, observed: await readConfigCommitSnapshot(input.configPath) };
+            if (!configCommitSnapshotMatches(claimed, true, input.before, claimedBeforeMode)) {
+                const rollback = await rollbackCodexConfigCommit({
+                    candidatePath,
+                    configPath: input.configPath,
+                    backupPath,
+                    before: input.before,
+                    expectedExists: input.expectedExists,
+                    expectedBeforeMode: claimedBeforeMode
+                });
+                return {
+                    ok: false,
+                    failure: rollback.restored ? 'concurrent_change_detected' : 'postwrite_verification_failed',
+                    changed: !rollback.restored,
+                    backupPath: rollback.backupPath,
+                    observed: rollback.observed
+                };
             }
             const afterClaim = await readConfigCommitSnapshot(input.configPath);
             if (!afterClaim.ok || afterClaim.exists) {
-                if (!afterClaim.exists)
-                    await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
-                return { ok: false, backupPath, observed: await readConfigCommitSnapshot(input.configPath) };
+                const rollback = await rollbackCodexConfigCommit({
+                    candidatePath,
+                    configPath: input.configPath,
+                    backupPath,
+                    before: input.before,
+                    expectedExists: input.expectedExists,
+                    expectedBeforeMode: claimedBeforeMode
+                });
+                return {
+                    ok: false,
+                    failure: 'concurrent_change_detected',
+                    changed: !rollback.restored,
+                    backupPath: rollback.backupPath,
+                    observed: rollback.observed
+                };
             }
         }
         try {
             await fsp.link(candidatePath, input.configPath);
         }
         catch {
-            if (backupPath) {
-                const claimed = await readConfigCommitSnapshot(backupPath);
-                await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
+            const rollback = await rollbackCodexConfigCommit({
+                candidatePath,
+                configPath: input.configPath,
+                backupPath,
+                before: input.before,
+                expectedExists: input.expectedExists,
+                expectedBeforeMode: claimedBeforeMode
+            });
+            return {
+                ok: false,
+                failure: 'concurrent_change_detected',
+                changed: !rollback.restored,
+                backupPath: rollback.backupPath,
+                observed: rollback.observed
+            };
+        }
+        try {
+            await fsp.chmod(input.configPath, 0o600);
+        }
+        catch {
+            const rollback = await rollbackCodexConfigCommit({
+                candidatePath,
+                configPath: input.configPath,
+                backupPath,
+                before: input.before,
+                expectedExists: input.expectedExists,
+                expectedBeforeMode: claimedBeforeMode
+            });
+            return {
+                ok: false,
+                failure: 'postwrite_verification_failed',
+                changed: !rollback.restored,
+                backupPath: rollback.backupPath,
+                observed: rollback.observed
+            };
+        }
+        const committed = await readConfigCommitSnapshot(input.configPath);
+        if (!configCommitSnapshotMatches(committed, true, input.next, 0o600)) {
+            const rollback = await rollbackCodexConfigCommit({
+                candidatePath,
+                configPath: input.configPath,
+                backupPath,
+                before: input.before,
+                expectedExists: input.expectedExists,
+                expectedBeforeMode: claimedBeforeMode
+            });
+            return {
+                ok: false,
+                failure: 'postwrite_verification_failed',
+                changed: !rollback.restored,
+                backupPath: rollback.backupPath,
+                observed: rollback.observed
+            };
+        }
+        if (backupPath) {
+            try {
+                await fsp.chmod(backupPath, 0o600);
+                const now = new Date();
+                await fsp.utimes(backupPath, now, now);
+            }
+            catch {
+                const rollback = await rollbackCodexConfigCommit({
+                    candidatePath,
+                    configPath: input.configPath,
+                    backupPath,
+                    before: input.before,
+                    expectedExists: input.expectedExists,
+                    expectedBeforeMode: claimedBeforeMode
+                });
+                return {
+                    ok: false,
+                    failure: 'postwrite_verification_failed',
+                    changed: !rollback.restored,
+                    backupPath: rollback.backupPath,
+                    observed: rollback.observed
+                };
+            }
+            const hardenedBackup = await readConfigCommitSnapshot(backupPath);
+            if (!configCommitSnapshotMatches(hardenedBackup, true, input.before, 0o600)) {
+                const rollback = await rollbackCodexConfigCommit({
+                    candidatePath,
+                    configPath: input.configPath,
+                    backupPath,
+                    before: input.before,
+                    expectedExists: input.expectedExists,
+                    expectedBeforeMode: claimedBeforeMode
+                });
+                return {
+                    ok: false,
+                    failure: 'postwrite_verification_failed',
+                    changed: !rollback.restored,
+                    backupPath: rollback.backupPath,
+                    observed: rollback.observed
+                };
             }
-            return { ok: false, backupPath, observed: await readConfigCommitSnapshot(input.configPath) };
         }
-        await fsp.chmod(input.configPath, 0o600).catch(() => undefined);
         await cleanupCodexConfigBackups(input.configPath, { keepPerTag: 3, maxAgeMs: 30 * 24 * 60 * 60 * 1000 }).catch(() => undefined);
         return { ok: true, backupPath };
     }
@@ -313,10 +441,65 @@ async function commitCodexConfigIfUnchanged(input) {
         await fsp.rm(candidatePath, { force: true }).catch(() => undefined);
     }
 }
-async function restoreClaimedConfigIfAbsent(backupPath, configPath, claimed) {
-    if (!claimed.ok || !claimed.exists || claimed.status !== 'regular')
-        return;
-    await fsp.link(backupPath, configPath).catch(() => undefined);
+async function rollbackCodexConfigCommit(input) {
+    let config = await readConfigCommitSnapshot(input.configPath);
+    if (config.exists) {
+        try {
+            const [candidateStat, configStat] = await Promise.all([
+                fsp.lstat(input.candidatePath),
+                fsp.lstat(input.configPath)
+            ]);
+            if (candidateStat.dev !== configStat.dev || candidateStat.ino !== configStat.ino) {
+                return { restored: false, backupPath: input.backupPath, observed: config };
+            }
+        }
+        catch {
+            return { restored: false, backupPath: input.backupPath, observed: config };
+        }
+        try {
+            await fsp.unlink(input.configPath);
+        }
+        catch {
+            return {
+                restored: false,
+                backupPath: input.backupPath,
+                observed: await readConfigCommitSnapshot(input.configPath)
+            };
+        }
+        config = await readConfigCommitSnapshot(input.configPath);
+    }
+    let remainingBackupPath = input.backupPath;
+    const restoreMode = input.expectedBeforeMode === undefined
+        ? undefined
+        : Number(input.expectedBeforeMode) & 0o777;
+    if (input.expectedExists) {
+        if (!input.backupPath || !config.ok || config.exists) {
+            return { restored: false, backupPath: remainingBackupPath, observed: config };
+        }
+        const backup = await readConfigCommitSnapshot(input.backupPath);
+        if (!backup.ok || !backup.exists || sha256(backup.text) !== sha256(input.before)) {
+            return { restored: false, backupPath: remainingBackupPath, observed: backup };
+        }
+        try {
+            await fsp.rename(input.backupPath, input.configPath);
+            remainingBackupPath = null;
+            if (restoreMode !== undefined)
+                await fsp.chmod(input.configPath, restoreMode);
+        }
+        catch {
+            return {
+                restored: false,
+                backupPath: remainingBackupPath,
+                observed: await readConfigCommitSnapshot(input.configPath)
+            };
+        }
+    }
+    const observed = await readConfigCommitSnapshot(input.configPath);
+    return {
+        restored: configCommitSnapshotMatches(observed, input.expectedExists, input.before, restoreMode),
+        backupPath: remainingBackupPath,
+        observed
+    };
 }
 function safeBackupTag(value) {
     return String(value || 'codex-config').replace(/[^A-Za-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 96) || 'codex-config';
@@ -384,12 +567,15 @@ export function isProjectCodexConfig(root, configPath) {
 }
 export function hasSksManagedCodexConfigMarker(text) {
     const source = String(text || '');
-    return /^\s*#\s*SKS-MANAGED-CODEX-CONFIG\b/im.test(source)
+    return hasExplicitSksManagedCodexConfigMarker(source)
         || /(?:SKS managed|Sneakoscope|sneakoscope|sks_|agents\.native_agent|agents\.implementation_worker|multi_agent)/i.test(source)
         || /^\s*model_provider\s*=\s*["']codex-lb["']\s*(?:#.*)?$/mi.test(source)
         || /^\s*default_profile\s*=\s*["']sks-fast-high["']\s*(?:#.*)?$/mi.test(source)
         || /^\s*\[(?:user\.fast_mode|model_providers\.(?:"codex-lb"|codex-lb)|profiles\.(?:"sks-fast-high"|sks-fast-high))\]\s*(?:#.*)?$/mi.test(source);
 }
+export function hasExplicitSksManagedCodexConfigMarker(text) {
+    return /^\s*#\s*SKS-MANAGED-CODEX-CONFIG\b/im.test(String(text || ''));
+}
 export function isUnmanagedProjectCodexConfig(root, configPath, text) {
     return isProjectCodexConfig(root, configPath)
         && String(text || '').trim().length > 0

package/dist/core/codex-adapter.js

@@ -4,6 +4,7 @@ import { preserveCodexModelArgs } from './codex-model-guard.js';
 import { managedProxyEnvForChild } from './codex/managed-proxy-env.js';
 import { resolveCodexRuntime } from './codex-runtime/resolve-codex-runtime.js';
 import { codexLbRecoveryBlockedProcessResult, withCodexLbCliLaunchRecovery } from './codex-control/codex-lb-launch-recovery.js';
+import { prepareCodexAppServerRuntimeEnv } from './codex-control/codex-app-server-runtime-env.js';
 export async function findCodexBinary() {
     const resolved = await resolveCodexRuntime({
         explicitPath: process.env.DCODEX_CODEX_BIN || null,
@@ -40,13 +41,14 @@ export function buildCodexExecArgs({ root, prompt, outputFile, json = true, prof
     args.push(prompt);
     return args;
 }
-export async function runCodexExec({ root, recoveryRoot = root, prompt, outputFile, json = true, profile = null, extraArgs = [], onStdout, onStderr, logDir = null, stdoutFile = null, stderrFile = null, maxBufferBytes = 256 * 1024, timeoutMs = null, env = process.env, codexBin = null, findCodexBinaryImpl = findCodexBinary, runProcessImpl = runProcess, recoveryFetch = undefined, recoveryTimeoutMs = undefined }) {
+export async function runCodexExec({ root, recoveryRoot = root, prompt, outputFile, json = true, profile = null, extraArgs = [], onStdout, onStderr, logDir = null, stdoutFile = null, stderrFile = null, maxBufferBytes = 256 * 1024, timeoutMs = null, env = process.env, codexBin = null, findCodexBinaryImpl = findCodexBinary, runProcessImpl = runProcess, prepareCodexRuntimeEnvImpl = prepareCodexAppServerRuntimeEnv, recoveryFetch = undefined, recoveryTimeoutMs = undefined }) {
     const args = buildCodexExecArgs({ root, prompt, outputFile, json, profile, extraArgs });
     const effectiveTimeoutMs = Number(timeoutMs || process.env.SKS_CODEX_TIMEOUT_MS || process.env.DCODEX_CODEX_TIMEOUT_MS || 30 * 60 * 1000);
     const recoveryArgs = args.slice(1, -1);
+    const runtimeEnv = await prepareCodexRuntimeEnvImpl({ env });
     const guarded = await withCodexLbCliLaunchRecovery({
         root: recoveryRoot,
-        env,
+        env: runtimeEnv,
         cliArgs: recoveryArgs,
         ...(typeof recoveryFetch === 'function' ? { fetchImpl: recoveryFetch } : {}),
         ...(recoveryTimeoutMs === undefined ? {} : { timeoutMs: recoveryTimeoutMs })
@@ -65,7 +67,7 @@ export async function runCodexExec({ root, recoveryRoot = root, prompt, outputFi
         }
         return runProcessImpl(bin, args, {
             cwd: root,
-            env: { ...env, ...managedProxyEnvForChild(env) },
+            env: { ...runtimeEnv, ...managedProxyEnvForChild(runtimeEnv) },
             onStdout,
             onStderr,
             timeoutMs: effectiveTimeoutMs,

package/dist/core/codex-app/menubar/constants.js

@@ -21,7 +21,9 @@ export const NATIVE_SOURCE_FILES = [
     'UpdatesViewController.swift',
     'MCPServersViewController.swift',
     'ProvidersViewController.swift',
+    'ProvidersConnectTest.swift',
     'ProvidersRoutingTruth.swift',
+    'ProvidersFastMode.swift',
     'ProvidersOpenRouter.swift',
     'ProvidersRoleModels.swift',
     'ProvidersMultiProvider.swift',
@@ -33,9 +35,16 @@ export const NATIVE_SOURCE_FILES = [
     'ProcessExecutionState.swift',
     'ProcessIdentityGuard.swift',
     'SecureProcessEnvelope.swift',
+    'TelegramPrivateFileSupport.swift',
+    'TelegramPrivateFileStore.swift',
+    'TelegramSupport.swift',
+    'TelegramRuntimeSupport.swift',
+    'TelegramTransport.swift',
+    'TelegramProcessGateway.swift',
     'NotificationCoordinator.swift',
     'AlertFactory.swift',
-    'AppIdentity.swift'
+    'AppIdentity.swift',
+    'SingletonInstanceGuard.swift'
 ];
 export const NATIVE_RESOURCE_FILES = [
     'AppIcon.icns',