forkit-connect 0.1.22 → 0.1.23

package/dist/cli.js

@@ -13,6 +13,7 @@ const daemon_1 = require("./v1/daemon");
 const service_1 = require("./v1/service");
 const discovery_1 = require("./v1/discovery");
 const heartbeat_1 = require("./v1/heartbeat");
+const startup_1 = require("./v1/startup");
 const runtime_activity_1 = require("./v1/runtime-activity");
 const runtime_editor_activity_1 = require("./v1/runtime-editor-activity");
 const runtime_observation_runner_1 = require("./v1/runtime-observation-runner");
@@ -81,6 +82,7 @@ const PUBLIC_COMMANDS = [
     ['login', 'Link this device to your Forkit.dev account'],
     ['logout', 'Remove the stored Forkit.dev session from this device'],
     ['status', 'Show account, scope, daemon, and queue status'],
+    ['startup', 'Enable, disable, or inspect CLI startup on login'],
     ['changes', 'View all collected local changes and queued sync items'],
     ['start', 'Open the interactive launcher or start foreground sync'],
     ['stop', 'Stop the local Connect daemon'],
@@ -117,14 +119,28 @@ const ADVANCED_COMMAND_GROUPS = [
     ['notify', 'Notification preview and delivery controls'],
 ];
 function usage() {
-    printCliHeader('CLI', 'Precise local review, runtime detection, and registration handoff.');
-    console.log(cliKeyLine('usage', 'forkit-connect <command> [options]'));
-    console.log(cliKeyLine('scope', 'forkit-connect workspace <list|select|create|status>'));
+    printCliHeader('CLI', 'Local AI discovery, review, and registration from your terminal.');
+    console.log(cliKeyLine('command', 'forkit-connect <command> [options]'));
+    console.log(cliKeyLine('always on', 'forkit-connect startup enable'));
+    console.log(cliKeyLine('review', 'forkit-connect inbox'));
     console.log(cliKeyLine('runtime', 'forkit-connect runtime <register|review|status>'));
-    printCliSection('Core');
-    for (const [command, description] of PUBLIC_COMMANDS) {
-        console.log(cliKeyLine(command, description));
-    }
+    printCliSection('Start Here');
+    console.log(cliKeyLine('login', 'Connect this device to your Forkit.dev account'));
+    console.log(cliKeyLine('scan', 'Detect local models, runtimes, and agents'));
+    console.log(cliKeyLine('inbox', 'Review what needs action'));
+    console.log(cliKeyLine('startup', 'Keep Connect running from sign-in'));
+    printCliSection('Daily');
+    console.log(cliKeyLine('status', 'See account, queue, and daemon state'));
+    console.log(cliKeyLine('start', 'Open the interactive local console'));
+    console.log(cliKeyLine('sync', 'Flush queued local metadata'));
+    console.log(cliKeyLine('stop', 'Stop the background daemon'));
+    printCliSection('Governed');
+    console.log(cliKeyLine('workspace', 'Optional workspace and project scope'));
+    console.log(cliKeyLine('register', 'Register ready local models'));
+    console.log(cliKeyLine('runtime', 'Register or review local runtimes'));
+    printCliSection('Safety');
+    console.log(cliKeyLine('ignore', 'Deny one detected local model on this device'));
+    console.log(cliKeyLine('doctor', 'Check notifications, storage, and runtime wiring'));
     printCliSection('Flags');
     console.log(cliKeyLine('--json', 'Machine-readable output when supported'));
     console.log(cliKeyLine('--all-ready', 'Register every ready local model in the current scope'));
@@ -2130,6 +2146,7 @@ function printPublicStatusOverview(status) {
     console.log(cliKeyLine('device', status.device_paired ? 'paired' : 'approval pending'));
     console.log(cliKeyLine('scope', formatCliScopeLabel(status.workspace_id, status.project_id)));
     console.log(cliKeyLine('daemon', status.daemon_status));
+    console.log(cliKeyLine('background', status.daemon_status === 'running' ? 'always on' : 'start required'));
     console.log(cliKeyLine('privacy', status.privacy_mode));
     console.log(cliKeyLine('inventory', joinCliSummary([
         formatCliCompactCount(status.models_discovered, 'model'),
@@ -2150,6 +2167,47 @@ function printPublicStatusOverview(status) {
         console.log(cliKeyLine('warning', 'Local governed scope exists, but login is still required.'));
     }
 }
+function formatStartupSummary(status) {
+    if (!status.supported)
+        return 'not supported';
+    if (status.enabled === true)
+        return 'enabled';
+    if (status.enabled === false)
+        return 'disabled';
+    return 'unknown';
+}
+function printStartupStatusLine(status) {
+    console.log(cliKeyLine('startup', formatStartupSummary(status)));
+}
+function printPublicStartupStatus(status) {
+    const enabled = status.enabled === true;
+    const platform = status.mode === 'launch_agent'
+        ? 'macOS LaunchAgent'
+        : status.mode === 'registry_run'
+            ? 'Windows sign-in registry'
+            : status.mode === 'systemd_user'
+                ? 'Linux user service'
+                : 'not available';
+    printCliHeader('Startup', 'Keep Forkit Connect running from sign-in without a tray app.');
+    console.log(cliKeyLine('auto start', enabled ? 'on' : status.enabled === false ? 'off' : 'unknown'));
+    console.log(cliKeyLine('behavior', enabled
+        ? 'Forkit Connect launches its background daemon when you sign in.'
+        : 'Forkit Connect starts only when you run it manually.'));
+    console.log(cliKeyLine('platform', platform));
+    console.log(cliKeyLine('next', enabled ? 'forkit-connect startup disable' : 'forkit-connect startup enable'));
+    if (hasFlag('--advanced-help') && status.configPath) {
+        console.log(cliKeyLine('config', status.configPath));
+    }
+}
+function getNotificationReadiness() {
+    if (process.platform === 'darwin') {
+        return 'Forkit Connect click-through ready';
+    }
+    if (process.platform === 'win32') {
+        return 'native Windows toasts ready';
+    }
+    return 'native desktop alerts when a GUI session is available';
+}
 function getOtherReadyCount(readyToConnectCount, draftFirstCount) {
     return Math.max(0, readyToConnectCount - draftFirstCount);
 }
@@ -2630,6 +2688,7 @@ async function run() {
     const runPublicConnectStatus = async () => {
         const sessionState = await checkBackendSessionState(service);
         const secureStorage = service.getCredentialStoreStatus();
+        const startupStatus = (0, startup_1.getCliStartupStatus)();
         if (service.readSessionRef()) {
             await withTimeout(service.refreshEffectiveBinding(), STATUS_BINDING_TIMEOUT_MS, undefined);
         }
@@ -2655,6 +2714,10 @@ async function run() {
                 session_truth: accountTrusted ? 'account_verified_or_offline' : 'local_scope_cached_login_required',
                 local_scope_cached: !accountTrusted && localScopeCached,
                 binding_truth: accountTrusted ? 'account_binding_active' : 'account_login_required',
+                startup_on_login: startupStatus,
+                notifications: {
+                    readiness: getNotificationReadiness(),
+                },
                 secure_storage: {
                     backend: secureStorage.backend,
                     available: secureStorage.available,
@@ -2670,8 +2733,28 @@ async function run() {
         if (!secureStorage.available || secureStorage.plaintextFallbackActive) {
             console.log(cliKeyLine('secure note', secureStorage.detail));
         }
+        console.log(cliKeyLine('notifications', getNotificationReadiness()));
+        printStartupStatusLine(startupStatus);
         printPublicStatusGuidance(displayOverview, sessionState);
     };
+    const runPublicStartupStatus = () => {
+        const startupStatus = (0, startup_1.getCliStartupStatus)();
+        if (hasFlag('--json')) {
+            printJson(startupStatus);
+            return;
+        }
+        printPublicStartupStatus(startupStatus);
+    };
+    const runPublicStartupEnable = () => {
+        const startupStatus = (0, startup_1.enableCliStartup)(process.execPath, __filename);
+        printPublicStartupStatus(startupStatus);
+        console.log('[forkit-connect] CLI startup on login is enabled. The background daemon will come up when your session starts.');
+    };
+    const runPublicStartupDisable = () => {
+        const startupStatus = (0, startup_1.disableCliStartup)();
+        printPublicStartupStatus(startupStatus);
+        console.log('[forkit-connect] CLI startup on login is disabled. Use forkit-connect stop if you also want to stop the daemon right now.');
+    };
     const runPublicConnectInbox = async () => {
         const forceRefresh = hasFlag('--refresh');
         const inbox = service.getSmartRegistrationInbox({
@@ -4934,6 +5017,24 @@ async function run() {
         await runPublicConnectStatus();
         return;
     }
+    if (command === 'startup') {
+        const subcommand = args[1] || 'status';
+        if (subcommand === 'status') {
+            runPublicStartupStatus();
+            return;
+        }
+        if (subcommand === 'enable') {
+            runPublicStartupEnable();
+            return;
+        }
+        if (subcommand === 'disable') {
+            runPublicStartupDisable();
+            return;
+        }
+        showUsage();
+        process.exitCode = 1;
+        return;
+    }
     if (command === 'changes') {
         runPublicCollectedChanges();
         return;

package/dist/v1/native-shell.d.ts

@@ -0,0 +1,23 @@
+import { type ReleaseCheckResult } from './update';
+export interface NativeShellStatus {
+    supported: boolean;
+    installed: boolean;
+    platform: 'macos' | 'windows' | 'linux';
+    installationPath: string | null;
+    trayAvailable: boolean;
+    startupAvailable: boolean;
+    directInstallerAvailable: boolean;
+    downloadUrl: string | null;
+    releaseNotesUrl: string | null;
+    note: string;
+}
+export interface NativeShellOpenResult {
+    ok: boolean;
+    opened: 'installed' | 'download';
+    installationPath: string | null;
+    downloadUrl: string | null;
+    message: string;
+}
+export declare function getNativeShellStatus(updateCheck?: ReleaseCheckResult): Promise<NativeShellStatus>;
+export declare function openNativeShell(updateCheck?: ReleaseCheckResult): Promise<NativeShellOpenResult>;
+//# sourceMappingURL=native-shell.d.ts.map

package/dist/v1/native-shell.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeShellStatus = getNativeShellStatus;
+exports.openNativeShell = openNativeShell;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const update_1 = require("./update");
+const CONNECT_DESKTOP_FALLBACK_URL = 'https://www.forkit.dev/connect';
+function normalizePlatform() {
+    if (process.platform === 'darwin')
+        return 'macos';
+    if (process.platform === 'win32')
+        return 'windows';
+    return 'linux';
+}
+function getCandidatePaths(platform) {
+    const home = node_os_1.default.homedir();
+    if (platform === 'macos') {
+        return [
+            '/Applications/Forkit Connect.app',
+            node_path_1.default.join(home, 'Applications', 'Forkit Connect.app'),
+        ];
+    }
+    if (platform === 'windows') {
+        const localAppData = process.env.LOCALAPPDATA || node_path_1.default.join(home, 'AppData', 'Local');
+        const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+        const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
+        return [
+            node_path_1.default.join(localAppData, 'Programs', 'Forkit Connect', 'Forkit Connect.exe'),
+            node_path_1.default.join(programFiles, 'Forkit Connect', 'Forkit Connect.exe'),
+            node_path_1.default.join(programFilesX86, 'Forkit Connect', 'Forkit Connect.exe'),
+        ];
+    }
+    return [
+        node_path_1.default.join(home, '.local', 'bin', 'forkit-connect-desktop'),
+        node_path_1.default.join(home, '.local', 'share', 'Forkit Connect', 'Forkit Connect.AppImage'),
+        '/usr/local/bin/forkit-connect-desktop',
+        '/opt/Forkit Connect/forkit-connect-desktop',
+    ];
+}
+function findInstalledPath(platform) {
+    for (const candidate of getCandidatePaths(platform)) {
+        try {
+            if (node_fs_1.default.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function parseVersion(version) {
+    const cleaned = String(version || '').trim().replace(/^v/i, '').split('-')[0] || '0.0.0';
+    const [major, minor, patch] = cleaned.split('.').map((value) => Number.parseInt(value || '0', 10));
+    return [major || 0, minor || 0, patch || 0];
+}
+function compareVersions(left, right) {
+    const [leftMajor, leftMinor, leftPatch] = parseVersion(left);
+    const [rightMajor, rightMinor, rightPatch] = parseVersion(right);
+    if (leftMajor !== rightMajor)
+        return leftMajor - rightMajor;
+    if (leftMinor !== rightMinor)
+        return leftMinor - rightMinor;
+    return leftPatch - rightPatch;
+}
+function buildDownloadUrl(updateCheck) {
+    if (!updateCheck.ok) {
+        return CONNECT_DESKTOP_FALLBACK_URL;
+    }
+    if (compareVersions(updateCheck.manifest.latestVersion, updateCheck.currentVersion) < 0) {
+        return CONNECT_DESKTOP_FALLBACK_URL;
+    }
+    return updateCheck.downloadUrl || updateCheck.manifest.releaseNotesUrl || CONNECT_DESKTOP_FALLBACK_URL;
+}
+function hasDirectInstaller(updateCheck) {
+    if (!updateCheck.ok)
+        return false;
+    if (compareVersions(updateCheck.manifest.latestVersion, updateCheck.currentVersion) < 0) {
+        return false;
+    }
+    return Boolean(updateCheck.downloadUrl);
+}
+function isInstallerOnlyRelease(updateCheck) {
+    if (!updateCheck.ok)
+        return false;
+    const manifest = updateCheck.manifest;
+    const integrity = manifest.integrity;
+    if (!integrity || typeof integrity !== 'object')
+        return false;
+    return integrity.installerOnly === true;
+}
+async function getNativeShellStatus(updateCheck) {
+    const platform = normalizePlatform();
+    const installationPath = findInstalledPath(platform);
+    const installed = Boolean(installationPath);
+    const resolvedUpdateCheck = updateCheck ?? await (0, update_1.checkForUpdates)();
+    const directInstallerAvailable = hasDirectInstaller(resolvedUpdateCheck);
+    const installerOnlyRelease = isInstallerOnlyRelease(resolvedUpdateCheck);
+    const downloadUrl = buildDownloadUrl(resolvedUpdateCheck);
+    const releaseNotesUrl = resolvedUpdateCheck.ok ? resolvedUpdateCheck.manifest.releaseNotesUrl : CONNECT_DESKTOP_FALLBACK_URL;
+    return {
+        supported: true,
+        installed,
+        platform,
+        installationPath,
+        trayAvailable: installed,
+        startupAvailable: installed,
+        directInstallerAvailable,
+        downloadUrl,
+        releaseNotesUrl,
+        note: installed
+            ? 'Desktop app installed. Tray or menu-bar controls and launch at sign-in are handled there.'
+            : installerOnlyRelease
+                ? 'Install the desktop app to get tray or menu-bar controls and launch at sign-in. In-app updates are not published for this release yet.'
+                : directInstallerAvailable
+                    ? 'Install the desktop app to get tray or menu-bar controls, launch at sign-in, and in-app updates.'
+                    : 'The desktop app installer is not published for this platform yet. Use the Connect downloads page for the current release.',
+    };
+}
+function spawnDetached(command, args, cwd) {
+    const child = (0, node_child_process_1.spawn)(command, args, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        ...(cwd ? { cwd } : {}),
+    });
+    child.unref();
+}
+function openInstalledShell(status) {
+    if (!status.installationPath) {
+        throw new Error('native_shell_missing');
+    }
+    if (status.platform === 'macos') {
+        spawnDetached('open', [status.installationPath]);
+        return;
+    }
+    if (status.platform === 'windows') {
+        spawnDetached(status.installationPath, [], node_path_1.default.dirname(status.installationPath));
+        return;
+    }
+    spawnDetached(status.installationPath, [], node_path_1.default.dirname(status.installationPath));
+}
+async function openNativeShell(updateCheck) {
+    const status = await getNativeShellStatus(updateCheck);
+    if (status.installed) {
+        openInstalledShell(status);
+        return {
+            ok: true,
+            opened: 'installed',
+            installationPath: status.installationPath,
+            downloadUrl: status.downloadUrl,
+            message: 'Opening the native Forkit Connect shell.',
+        };
+    }
+    return {
+        ok: false,
+        opened: 'download',
+        installationPath: null,
+        downloadUrl: status.downloadUrl,
+        message: 'Install the Forkit Connect desktop app to enable tray or menu-bar controls and launch at sign-in.',
+    };
+}
+//# sourceMappingURL=native-shell.js.map

package/dist/v1/service.js

@@ -173,6 +173,33 @@ function notificationTargetUrl(candidate) {
     }
     return `${base}/?${params.toString()}`;
 }
+function notificationTargetCommand(candidate) {
+    const targetArgs = (() => {
+        if (!candidate) {
+            return ['inbox'];
+        }
+        if (candidate.suggested_action === 'reconnect_account' || candidate.type === 'credential_reconnect_needed') {
+            return ['login'];
+        }
+        if (candidate.suggested_action === 'sync_c2' || candidate.type === 'c2_sync_pending') {
+            return ['sync'];
+        }
+        if (candidate.suggested_action === 'view_pulse_history') {
+            return ['changes'];
+        }
+        return ['inbox'];
+    })();
+    const currentScriptPath = process.argv[1] && node_path_1.default.isAbsolute(process.argv[1])
+        ? process.argv[1]
+        : process.argv[1]
+            ? node_path_1.default.resolve(process.cwd(), process.argv[1])
+            : null;
+    if (currentScriptPath && node_fs_1.default.existsSync(currentScriptPath)) {
+        const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+        return [quote(process.execPath), quote(currentScriptPath), ...targetArgs.map(quote)].join(' ');
+    }
+    return `forkit-connect ${targetArgs.join(' ')}`;
+}
 function hasLinuxGuiSession() {
     return Boolean(normalizeSessionReference(process.env.DISPLAY)
         || normalizeSessionReference(process.env.WAYLAND_DISPLAY)
@@ -186,6 +213,129 @@ function resolveTerminalNotifierPath() {
     const resolved = String(notifierPath.stdout || '').trim();
     return resolved || null;
 }
+function resolveBundledTerminalNotifierBinary() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const notifierPackageJson = require.resolve('node-notifier/package.json');
+        const candidate = node_path_1.default.join(node_path_1.default.dirname(notifierPackageJson), 'vendor', 'mac.noindex', 'terminal-notifier.app', 'Contents', 'MacOS', 'terminal-notifier');
+        return node_fs_1.default.existsSync(candidate) ? candidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveBrandedNotifierIconSource() {
+    const candidate = node_path_1.default.resolve(__dirname, '..', '..', 'assets', 'connect-notifier-512.png');
+    return node_fs_1.default.existsSync(candidate) ? candidate : null;
+}
+function ensureBrandedMacNotifierIcon(helperApp) {
+    const sourcePng = resolveBrandedNotifierIconSource();
+    if (!sourcePng) {
+        return;
+    }
+    const resourcesDir = node_path_1.default.join(helperApp, 'Contents', 'Resources');
+    const iconTarget = node_path_1.default.join(resourcesDir, 'Terminal.icns');
+    const iconMarker = node_path_1.default.join(resourcesDir, '.forkit-notifier-icon-v1');
+    if (node_fs_1.default.existsSync(iconMarker) && node_fs_1.default.existsSync(iconTarget)) {
+        return;
+    }
+    const iconsetDir = node_path_1.default.join(resourcesDir, 'ForkitConnect.iconset');
+    node_fs_1.default.rmSync(iconsetDir, { recursive: true, force: true });
+    node_fs_1.default.mkdirSync(iconsetDir, { recursive: true });
+    const variants = [
+        { file: 'icon_16x16.png', size: 16 },
+        { file: 'icon_16x16@2x.png', size: 32 },
+        { file: 'icon_32x32.png', size: 32 },
+        { file: 'icon_32x32@2x.png', size: 64 },
+        { file: 'icon_128x128.png', size: 128 },
+        { file: 'icon_128x128@2x.png', size: 256 },
+        { file: 'icon_256x256.png', size: 256 },
+        { file: 'icon_256x256@2x.png', size: 512 },
+        { file: 'icon_512x512.png', size: 512 },
+    ];
+    try {
+        for (const variant of variants) {
+            const outputPath = node_path_1.default.join(iconsetDir, variant.file);
+            const result = (0, node_child_process_1.spawnSync)('/usr/bin/sips', ['-z', String(variant.size), String(variant.size), sourcePng, '--out', outputPath], {
+                stdio: 'ignore',
+            });
+            if (result.status !== 0) {
+                throw new Error('icon_resize_failed');
+            }
+        }
+        node_fs_1.default.copyFileSync(sourcePng, node_path_1.default.join(iconsetDir, 'icon_512x512@2x.png'));
+        const buildResult = (0, node_child_process_1.spawnSync)('/usr/bin/iconutil', ['-c', 'icns', iconsetDir, '-o', iconTarget], {
+            stdio: 'ignore',
+        });
+        if (buildResult.status !== 0) {
+            throw new Error('iconutil_failed');
+        }
+        node_fs_1.default.writeFileSync(iconMarker, 'forkit-connect-notifier-icon-v1\n', 'utf8');
+    }
+    catch {
+        return;
+    }
+    finally {
+        node_fs_1.default.rmSync(iconsetDir, { recursive: true, force: true });
+    }
+}
+function notificationExecuteCommand(candidate) {
+    if (process.platform !== 'darwin') {
+        return null;
+    }
+    const targetCommand = notificationTargetCommand(candidate);
+    const escapedCommand = `${targetCommand}; exec "\${SHELL:-/bin/zsh}" -l`
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"');
+    return [
+        '/usr/bin/osascript',
+        `-e 'tell application "Terminal" to activate'`,
+        `-e 'tell application "Terminal" to do script "${escapedCommand}"'`,
+    ].join(' ');
+}
+function resolveBrandedMacNotifierBinary() {
+    if (process.platform !== 'darwin') {
+        return null;
+    }
+    const bundledBinary = resolveBundledTerminalNotifierBinary();
+    if (!bundledBinary) {
+        return null;
+    }
+    const sourceApp = node_path_1.default.resolve(bundledBinary, '..', '..', '..');
+    const helperApp = node_path_1.default.join(node_os_1.default.homedir(), '.forkit-connect', 'vendor', 'Forkit Connect.app');
+    const helperBinary = node_path_1.default.join(helperApp, 'Contents', 'MacOS', 'terminal-notifier');
+    const helperPlist = node_path_1.default.join(helperApp, 'Contents', 'Info.plist');
+    const isAlreadyBranded = () => {
+        if (!node_fs_1.default.existsSync(helperBinary) || !node_fs_1.default.existsSync(helperPlist)) {
+            return false;
+        }
+        try {
+            const result = (0, node_child_process_1.spawnSync)('plutil', ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', helperPlist], {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return result.status === 0 && String(result.stdout || '').trim() === 'dev.forkit.connect.notifications';
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!isAlreadyBranded()) {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(helperApp), { recursive: true });
+        node_fs_1.default.rmSync(helperApp, { recursive: true, force: true });
+        node_fs_1.default.cpSync(sourceApp, helperApp, { recursive: true });
+        const replacements = [
+            ['CFBundleIdentifier', 'dev.forkit.connect.notifications'],
+            ['CFBundleName', 'Forkit Connect'],
+            ['CFBundleDisplayName', 'Forkit Connect'],
+        ];
+        for (const [key, value] of replacements) {
+            (0, node_child_process_1.spawnSync)('plutil', ['-replace', key, '-string', value, helperPlist], { stdio: 'ignore' });
+        }
+    }
+    ensureBrandedMacNotifierIcon(helperApp);
+    return node_fs_1.default.existsSync(helperBinary) ? helperBinary : null;
+}
 function defaultNotificationSender(title, message, candidate) {
     if (process.platform === 'linux') {
         if (!hasLinuxGuiSession()) {
@@ -210,15 +360,21 @@ function defaultNotificationSender(title, message, candidate) {
         }
     }
     if (process.platform === 'darwin') {
-        const targetUrl = notificationTargetUrl(candidate);
-        const resolvedNotifier = resolveTerminalNotifierPath();
+        const resolvedNotifier = resolveBrandedMacNotifierBinary() ?? resolveTerminalNotifierPath();
         if (resolvedNotifier) {
-            const openCommand = `/usr/bin/open '${targetUrl.replace(/'/g, "'\\''")}'`;
-            const result = (0, node_child_process_1.spawnSync)(resolvedNotifier, [
+            const executeCommand = notificationExecuteCommand(candidate);
+            const args = [
                 '-title', title,
+                '-subtitle', 'Forkit Connect',
                 '-message', message,
-                '-execute', openCommand,
                 '-group', 'forkit-connect',
+                '-sender', 'dev.forkit.connect.notifications',
+            ];
+            if (executeCommand) {
+                args.push('-execute', executeCommand);
+            }
+            const result = (0, node_child_process_1.spawnSync)(resolvedNotifier, [
+                ...args,
             ], { stdio: 'ignore' });
             if (result.status === 0) {
                 return true;
@@ -8925,13 +9081,13 @@ class ConnectV1Service {
                 : `Unavailable at ${ollama.endpoint}: ${ollama.error ?? 'unknown_error'}`,
         });
         if (process.platform === 'darwin') {
-            const notifierPath = resolveTerminalNotifierPath();
+            const notifierPath = resolveBrandedMacNotifierBinary() ?? resolveTerminalNotifierPath();
             checks.push({
                 name: 'desktop_notifications',
                 status: notifierPath ? 'PASS' : 'WARN',
                 details: notifierPath
-                    ? `terminal-notifier available at ${notifierPath}`
-                    : 'terminal-notifier is not installed. Notifications will be recorded locally but click-through will not work on macOS.',
+                    ? 'Forkit Connect native notifications are ready with click-through support.'
+                    : 'Forkit Connect notifications are not ready yet on this Mac.',
             });
         }
         const sessionRefSource = this.getSessionRefSource();

package/dist/v1/startup.d.ts

@@ -0,0 +1,12 @@
+export interface CliStartupStatus {
+    supported: boolean;
+    platform: 'macos' | 'windows' | 'linux';
+    enabled: boolean | null;
+    mode: 'launch_agent' | 'registry_run' | 'systemd_user' | 'unsupported';
+    configPath: string | null;
+    note: string;
+}
+export declare function getCliStartupStatus(): CliStartupStatus;
+export declare function enableCliStartup(processExecPath: string, cliPath: string): CliStartupStatus;
+export declare function disableCliStartup(): CliStartupStatus;
+//# sourceMappingURL=startup.d.ts.map

package/dist/v1/startup.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCliStartupStatus = getCliStartupStatus;
+exports.enableCliStartup = enableCliStartup;
+exports.disableCliStartup = disableCliStartup;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function normalizePlatform() {
+    if (process.platform === 'darwin')
+        return 'macos';
+    if (process.platform === 'win32')
+        return 'windows';
+    return 'linux';
+}
+function macLabel() {
+    return 'dev.forkit.connect.cli';
+}
+function macPlistPath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), 'Library', 'LaunchAgents', `${macLabel()}.plist`);
+}
+function linuxServiceName() {
+    return 'forkit-connect.service';
+}
+function linuxServicePath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), '.config', 'systemd', 'user', linuxServiceName());
+}
+function windowsRegistryKey() {
+    return 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
+}
+function windowsRegistryValueName() {
+    return 'ForkitConnectCLI';
+}
+function launchctlGuiTarget() {
+    return `gui/${process.getuid?.() ?? 0}`;
+}
+function quoteWindows(value) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function startupCommand(processExecPath, cliPath) {
+    return {
+        executable: processExecPath,
+        args: [cliPath, 'daemon', 'run-loop'],
+        display: `${quoteWindows(processExecPath)} ${quoteWindows(cliPath)} daemon run-loop`,
+    };
+}
+function writeMacPlist(processExecPath, cliPath) {
+    const command = startupCommand(processExecPath, cliPath);
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>${macLabel()}</string>
+    <key>ProgramArguments</key>
+    <array>
+      <string>${command.executable}</string>
+      <string>${command.args[0]}</string>
+      <string>${command.args[1]}</string>
+      <string>${command.args[2]}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>WorkingDirectory</key>
+    <string>${process.cwd()}</string>
+  </dict>
+</plist>
+`;
+    const plistPath = macPlistPath();
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(plistPath), { recursive: true });
+    node_fs_1.default.writeFileSync(plistPath, plist, 'utf8');
+    return plistPath;
+}
+function writeLinuxService(processExecPath, cliPath) {
+    const command = startupCommand(processExecPath, cliPath);
+    const unit = `[Unit]
+Description=Forkit Connect CLI background daemon
+After=default.target
+
+[Service]
+Type=simple
+ExecStart=${command.executable} ${command.args.join(' ')}
+Restart=always
+RestartSec=3
+WorkingDirectory=${process.cwd()}
+
+[Install]
+WantedBy=default.target
+`;
+    const servicePath = linuxServicePath();
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(servicePath), { recursive: true });
+    node_fs_1.default.writeFileSync(servicePath, unit, 'utf8');
+    return servicePath;
+}
+function getMacStatus() {
+    const plistPath = macPlistPath();
+    const exists = node_fs_1.default.existsSync(plistPath);
+    return {
+        supported: true,
+        platform: 'macos',
+        enabled: exists,
+        mode: 'launch_agent',
+        configPath: plistPath,
+        note: exists
+            ? 'Forkit Connect CLI will start at sign-in through a LaunchAgent.'
+            : 'Forkit Connect CLI is not set to start at sign-in on this Mac.',
+    };
+}
+function getWindowsStatus() {
+    const query = (0, node_child_process_1.spawnSync)('reg', ['query', windowsRegistryKey(), '/v', windowsRegistryValueName()], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const enabled = query.status === 0;
+    return {
+        supported: true,
+        platform: 'windows',
+        enabled,
+        mode: 'registry_run',
+        configPath: windowsRegistryKey(),
+        note: enabled
+            ? 'Forkit Connect CLI will start after sign-in through the Windows Run registry.'
+            : 'Forkit Connect CLI is not set to start after sign-in on Windows.',
+    };
+}
+function getLinuxStatus() {
+    const servicePath = linuxServicePath();
+    const exists = node_fs_1.default.existsSync(servicePath);
+    return {
+        supported: true,
+        platform: 'linux',
+        enabled: exists,
+        mode: 'systemd_user',
+        configPath: servicePath,
+        note: exists
+            ? 'Forkit Connect CLI will start in the user session through systemd.'
+            : 'Forkit Connect CLI is not set to start in the user session on Linux.',
+    };
+}
+function getCliStartupStatus() {
+    const platform = normalizePlatform();
+    if (platform === 'macos')
+        return getMacStatus();
+    if (platform === 'windows')
+        return getWindowsStatus();
+    if (platform === 'linux')
+        return getLinuxStatus();
+    return {
+        supported: false,
+        platform,
+        enabled: null,
+        mode: 'unsupported',
+        configPath: null,
+        note: 'Startup management is not available on this platform.',
+    };
+}
+function enableCliStartup(processExecPath, cliPath) {
+    const platform = normalizePlatform();
+    if (platform === 'macos') {
+        const plistPath = writeMacPlist(processExecPath, cliPath);
+        (0, node_child_process_1.spawnSync)('launchctl', ['bootout', launchctlGuiTarget(), plistPath], { stdio: 'ignore' });
+        const bootstrap = (0, node_child_process_1.spawnSync)('launchctl', ['bootstrap', launchctlGuiTarget(), plistPath], { stdio: 'ignore' });
+        if (bootstrap.status !== 0) {
+            throw new Error('cli_startup_enable_failed_macos');
+        }
+        (0, node_child_process_1.spawnSync)('launchctl', ['kickstart', '-k', `${launchctlGuiTarget()}/${macLabel()}`], { stdio: 'ignore' });
+        return getMacStatus();
+    }
+    if (platform === 'windows') {
+        const command = startupCommand(processExecPath, cliPath);
+        const add = (0, node_child_process_1.spawnSync)('reg', [
+            'add',
+            windowsRegistryKey(),
+            '/v',
+            windowsRegistryValueName(),
+            '/t',
+            'REG_SZ',
+            '/d',
+            command.display,
+            '/f',
+        ], { stdio: 'ignore' });
+        if (add.status !== 0) {
+            throw new Error('cli_startup_enable_failed_windows');
+        }
+        return getWindowsStatus();
+    }
+    if (platform === 'linux') {
+        const servicePath = writeLinuxService(processExecPath, cliPath);
+        const reload = (0, node_child_process_1.spawnSync)('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+        const enable = (0, node_child_process_1.spawnSync)('systemctl', ['--user', 'enable', '--now', linuxServiceName()], { stdio: 'ignore' });
+        if (reload.status !== 0 || enable.status !== 0 || !node_fs_1.default.existsSync(servicePath)) {
+            throw new Error('cli_startup_enable_failed_linux');
+        }
+        return getLinuxStatus();
+    }
+    throw new Error('cli_startup_unsupported');
+}
+function disableCliStartup() {
+    const platform = normalizePlatform();
+    if (platform === 'macos') {
+        const plistPath = macPlistPath();
+        (0, node_child_process_1.spawnSync)('launchctl', ['bootout', launchctlGuiTarget(), plistPath], { stdio: 'ignore' });
+        if (node_fs_1.default.existsSync(plistPath)) {
+            node_fs_1.default.rmSync(plistPath, { force: true });
+        }
+        return getMacStatus();
+    }
+    if (platform === 'windows') {
+        (0, node_child_process_1.spawnSync)('reg', ['delete', windowsRegistryKey(), '/v', windowsRegistryValueName(), '/f'], { stdio: 'ignore' });
+        return getWindowsStatus();
+    }
+    if (platform === 'linux') {
+        (0, node_child_process_1.spawnSync)('systemctl', ['--user', 'disable', '--now', linuxServiceName()], { stdio: 'ignore' });
+        (0, node_child_process_1.spawnSync)('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+        const servicePath = linuxServicePath();
+        if (node_fs_1.default.existsSync(servicePath)) {
+            node_fs_1.default.rmSync(servicePath, { force: true });
+        }
+        return getLinuxStatus();
+    }
+    throw new Error('cli_startup_unsupported');
+}
+//# sourceMappingURL=startup.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forkit-connect",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Forkit Connect Local Engine - The Global AI Governance Fabric",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
   },
   "files": [
     "dist",
+    "assets",
     "README.md",
     "QUICKSTART.md"
   ],
@@ -33,6 +34,7 @@
     "better-sqlite3": "^12.10.0",
     "cors": "^2.8.6",
     "express": "^4.19.2",
+    "node-notifier": "^10.0.1",
     "ps-list": "^8.1.1",
     "uuid": "^10.0.0",
     "ws": "^8.16.0",