From 738829af2a714558d50fb773f146219648ee0fb5 Mon Sep 17 00:00:00 2001
From: daviirodrig <30713947+daviirodrig@users.noreply.github.com>
Date: Tue, 26 May 2026 18:45:13 -0300
Subject: [PATCH 1/2] feat: platform-aware daemon labels, Linux systemd
 autostart, and credential store

Adds a platform abstraction layer so macOS and Linux each get correct
labels, paths, and behavior without scattering cfg blocks everywhere.

- platform/: mod.rs with pure TargetOs/PlatformLabels (testable without
  a real OS), macos.rs wrapping the existing LaunchAgent logic, linux.rs
  implementing systemd --user install/restart/remove
- daemon.rs: DaemonStatus gains plataforma, autostart_nome, service_path,
  instalacao_manual; delegates fully to platform module (no more cfg in daemon)
- Cargo.toml: target-specific keyring (apple-native / sync-secret-service)
  and libc (macOS only); eliminates unused-import warnings on Linux
- secrets.rs: error messages and BackupCredentialStatus.store_nome use the
  platform label ("Keychain" / "Secret Service")
- domain.rs: ApiCapabilities gains data_root + data_root_label; filled by
  storage.bootstrap() with the real filesystem path (~-expanded)
- UI: SettingsView, Shell, BackupView all drive text from API data instead
  of hardcoded macOS strings; App.tsx forwards data_root_label
- 4 platform unit tests covering label correctness per OS
---
 Cargo.lock                                    |  25 +++
 apps/web/src/App.tsx                          |   5 +-
 apps/web/src/features/backup/BackupView.tsx   |   4 +-
 .../src/features/settings/SettingsView.tsx    |  26 ++-
 apps/web/src/features/shell/Shell.tsx         |  16 +-
 apps/web/src/lib/types.ts                     |  14 +-
 crates/server/Cargo.toml                      |   9 +-
 crates/server/src/daemon.rs                   | 151 +++------------
 crates/server/src/domain.rs                   |   5 +
 crates/server/src/lib.rs                      |   1 +
 crates/server/src/platform/linux.rs           | 103 ++++++++++
 crates/server/src/platform/macos.rs           | 110 +++++++++++
 crates/server/src/platform/mod.rs             | 180 ++++++++++++++++++
 crates/server/src/secrets.rs                  |  41 +++-
 crates/server/src/storage.rs                  |  10 +-
 15 files changed, 546 insertions(+), 154 deletions(-)
 create mode 100644 crates/server/src/platform/linux.rs
 create mode 100644 crates/server/src/platform/macos.rs
 create mode 100644 crates/server/src/platform/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index bce6323..a817eb7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1201,6 +1201,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "dbus-secret-service"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "708b509edf7889e53d7efb0ffadd994cc6c2345ccb62f55cfd6b0682165e4fa6"
+dependencies = [
+ "dbus",
+ "zeroize",
+]
+
 [[package]]
 name = "der"
 version = "0.7.10"
@@ -2656,6 +2666,7 @@ version = "3.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c"
 dependencies = [
+ "dbus-secret-service",
  "log",
  "security-framework 2.11.1",
  "security-framework 3.7.0",
@@ -6347,6 +6358,20 @@ name = "zeroize"
 version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
 
 [[package]]
 name = "zerotrie"
diff --git a/apps/web/src/App.tsx b/apps/web/src/App.tsx
index 8b409eb..0f20b6e 100644
--- a/apps/web/src/App.tsx
+++ b/apps/web/src/App.tsx
@@ -55,11 +55,14 @@ export function App() {
     setOpenProject(null)
   }
 
+  const dataRootLabel = workspace.capacidades?.data_root_label || undefined
+
   return (
     <Shell
       screen={screen}
       projectTitle={projectCard?.titulo}
       config={workspace.config}
+      dataRootLabel={dataRootLabel}
       onNavigate={navigate}
       onSnapshotError={(text) => message('erro', text)}
     >
@@ -86,7 +89,7 @@ export function App() {
       {screen === 'ideias' && (
         <IdeasView config={workspace.config} ideas={workspace.ideias} onIdeas={setIdeas} onMessage={message} />
       )}
-      {screen === 'backup' && <BackupView config={workspace.config} onMessage={message} />}
+      {screen === 'backup' && <BackupView config={workspace.config} dataRootLabel={dataRootLabel} onMessage={message} />}
       {screen === 'arquivo' && (
         <ArchiveView board={workspace.board} ideas={workspace.ideias} onRefresh={refresh} onMessage={message} />
       )}
diff --git a/apps/web/src/features/backup/BackupView.tsx b/apps/web/src/features/backup/BackupView.tsx
index 55a7e3e..9a18c53 100644
--- a/apps/web/src/features/backup/BackupView.tsx
+++ b/apps/web/src/features/backup/BackupView.tsx
@@ -7,9 +7,11 @@ import type { Config, Snapshot } from '../../lib/types'
 
 export function BackupView({
   config,
+  dataRootLabel,
   onMessage,
 }: {
   config: Config
+  dataRootLabel?: string
   onMessage: (type: 'ok' | 'erro', text: string) => void
 }) {
   const [snapshots, setSnapshots] = useState<Snapshot[]>([])
@@ -45,7 +47,7 @@ export function BackupView({
         />
       </header>
       <p className="panel-copy">
-        cada snapshot envia a pasta integral <code>~/Documents/PROJECTUS</code>: configurações, kanbans, ideias,
+        cada snapshot envia a pasta integral <code>{dataRootLabel ?? '~/Documents/PROJECTUS'}</code>: configurações, kanbans, ideias,
         Arquivo, históricos e anexos.
       </p>
       {!config.r2.configurado ? (
diff --git a/apps/web/src/features/settings/SettingsView.tsx b/apps/web/src/features/settings/SettingsView.tsx
index 1ef7390..034e71e 100644
--- a/apps/web/src/features/settings/SettingsView.tsx
+++ b/apps/web/src/features/settings/SettingsView.tsx
@@ -86,13 +86,16 @@ export function SettingsView({
     setDirty(true)
   }
 
+  const credentialStore = credentialStatus?.store_nome ?? 'cofre do sistema'
+
   const saveCredentials = async () => {
     try {
       await api.saveCredentials({ access_key_id: accessKey.trim(), secret_access_key: secretKey.trim() })
       setAccessKey('')
       setSecretKey('')
-      setCredentialStatus(await api.credentialStatus())
-      onMessage('ok', 'credenciais R2 fixadas no Keychain')
+      const updated = await api.credentialStatus()
+      setCredentialStatus(updated)
+      onMessage('ok', `credenciais R2 fixadas no ${updated.store_nome}`)
     } catch (error) {
       onMessage('erro', error instanceof Error ? error.message : 'não foi possível salvar credenciais')
     }
@@ -300,10 +303,10 @@ export function SettingsView({
               value={secretKey}
               onChange={(event) => setSecretKey(event.target.value)}
             />
-            <small className="hint">logo abaixo, "Secret Access Key". Salva no Keychain do macOS.</small>
+            <small className="hint">logo abaixo, "Secret Access Key". Salva no {credentialStore}.</small>
           </label>
           <div className={credentialStatus?.fixadas ? 'credential-state credential-state--ok' : 'credential-state'}>
-            <strong>KEYCHAIN</strong>
+            <strong>{credentialStore.toUpperCase()}</strong>
             <span>
               {credentialStatus?.fixadas
                 ? `credenciais fixadas (${credentialStatus.access_key_id_mascarada})`
@@ -316,7 +319,7 @@ export function SettingsView({
             disabled={!accessKey.trim() || !secretKey.trim() || dirty || saving || !validR2Endpoint}
             onClick={() => void saveCredentials()}
           >
-            fixar credenciais no Keychain
+            fixar credenciais no {credentialStore}
           </button>
         </section>
         <section className="panel">
@@ -334,10 +337,12 @@ export function SettingsView({
           </p>
           <p className="panel-copy">
             {daemon?.instalado
-              ? 'autostart instalado.'
+              ? `autostart instalado via ${daemon.autostart_nome}.`
               : daemon?.instalacao_disponivel
-                ? 'autostart ainda não instalado.'
-                : 'para manter o backend ativo com a janela fechada, execute ./scripts/instalar-autostart.sh.'}
+                ? `autostart ainda não instalado.`
+                : daemon?.suportado === false
+                  ? 'autostart não disponível nesta plataforma.'
+                  : `para manter o backend ativo com a janela fechada, use o botão instalar${daemon?.instalacao_manual ? ` ou ${daemon.instalacao_manual}` : ''}.`}
           </p>
           {!daemon?.instalado && daemon?.instalacao_disponivel && (
             <button
@@ -345,8 +350,9 @@ export function SettingsView({
               type="button"
               onClick={async () => {
                 try {
-                  setDaemon(await api.installDaemon())
-                  onMessage('ok', 'autostart instalado no macOS')
+                  const updated = await api.installDaemon()
+                  setDaemon(updated)
+                  onMessage('ok', `autostart instalado via ${updated.autostart_nome}`)
                 } catch (error) {
                   onMessage('erro', error instanceof Error ? error.message : 'não foi possível instalar')
                 }
diff --git a/apps/web/src/features/shell/Shell.tsx b/apps/web/src/features/shell/Shell.tsx
index 40833a2..572e524 100644
--- a/apps/web/src/features/shell/Shell.tsx
+++ b/apps/web/src/features/shell/Shell.tsx
@@ -14,6 +14,7 @@ export function Shell({
   screen,
   projectTitle,
   config,
+  dataRootLabel,
   onNavigate,
   onSnapshotError,
   children,
@@ -21,6 +22,7 @@ export function Shell({
   screen: Screen
   projectTitle?: string
   config: Config
+  dataRootLabel?: string
   onNavigate: (screen: Screen) => void
   onSnapshotError: (message: string) => void
   children: ReactNode
@@ -71,8 +73,18 @@ export function Shell({
           </ul>
           <footer>
             <span className="eyebrow">dados</span>
-            <div>~/Documents/</div>
-            <strong>PROJECTUS</strong>
+            {(() => {
+              const label = dataRootLabel ?? '~/Documents/PROJECTUS'
+              const slash = label.lastIndexOf('/')
+              const parent = slash >= 0 ? label.slice(0, slash + 1) : label + '/'
+              const base = slash >= 0 ? label.slice(slash + 1) : 'PROJECTUS'
+              return (
+                <>
+                  <div>{parent}</div>
+                  <strong>{base}</strong>
+                </>
+              )
+            })()}
             <span className="eyebrow rail__section">backup</span>
             <div className={config.r2.configurado ? 'status status--ok' : 'status'}>
               {config.r2.configurado ? 'OK' : 'OFF'} / R2
diff --git a/apps/web/src/lib/types.ts b/apps/web/src/lib/types.ts
index f5b4c66..cf5642f 100644
--- a/apps/web/src/lib/types.ts
+++ b/apps/web/src/lib/types.ts
@@ -80,7 +80,13 @@ export type ArchivedItem = {
   arquivado_em: string
 }
 export type ArchiveIndex = { revision: number; itens: ArchivedItem[] }
-export type ApiCapabilities = { api_version: number; arquivo: boolean; config_autosave: boolean }
+export type ApiCapabilities = {
+  api_version: number
+  arquivo: boolean
+  config_autosave: boolean
+  data_root: string
+  data_root_label: string
+}
 export type Bootstrap = { config: Config; board: Board; ideias: Ideas; capacidades?: ApiCapabilities }
 export type DocumentResponse<T> = { dados: T; markdown: string }
 export type Snapshot = {
@@ -94,13 +100,17 @@ export type RemoteHistory = { snapshots: Snapshot[] }
 export type BackupCredentialStatus = {
   fixadas: boolean
   access_key_id_mascarada: string | null
+  store_nome: string
 }
 export type DaemonStatus = {
   suportado: boolean
   instalado: boolean
   instalacao_disponivel: boolean
-  plist: string | null
+  service_path: string | null
   executavel: string
+  plataforma: string
+  autostart_nome: string
+  instalacao_manual: string | null
 }
 export type EntityCard = ProjectCard | TaskCard
 export type LiveEvent = {
diff --git a/crates/server/Cargo.toml b/crates/server/Cargo.toml
index 031f084..717b242 100644
--- a/crates/server/Cargo.toml
+++ b/crates/server/Cargo.toml
@@ -16,8 +16,6 @@ futures-core = "0.3"
 hex = "0.4"
 if-addrs = "0.13"
 image = { version = "0.25", default-features = false, features = ["jpeg", "png", "gif", "webp", "bmp"] }
-keyring = { version = "3", features = ["apple-native"] }
-libc = "0.2"
 mime_guess = "2"
 rand = "0.9"
 serde = { version = "1", features = ["derive"] }
@@ -34,5 +32,12 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 url = "2"
 walkdir = "2"
 
+[target.'cfg(target_os = "macos")'.dependencies]
+keyring = { version = "3", features = ["apple-native"] }
+libc = "0.2"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+keyring = { version = "3", features = ["sync-secret-service"] }
+
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/server/src/daemon.rs b/crates/server/src/daemon.rs
index 798755e..32140ea 100644
--- a/crates/server/src/daemon.rs
+++ b/crates/server/src/daemon.rs
@@ -1,149 +1,42 @@
-use std::{fs, path::PathBuf, process::Command};
-
-use anyhow::{Context, Result, bail};
+use anyhow::Result;
 use serde::Serialize;
 
-const LABEL: &str = "com.projectus.server";
+use crate::platform;
 
 #[derive(Debug, Serialize)]
 pub struct DaemonStatus {
     pub suportado: bool,
     pub instalado: bool,
     pub instalacao_disponivel: bool,
-    pub plist: Option<String>,
+    pub service_path: Option<String>,
     pub executavel: String,
+    pub plataforma: String,
+    pub autostart_nome: String,
+    pub instalacao_manual: Option<String>,
 }
 
-pub fn status() -> Result<DaemonStatus> {
-    let executable = std::env::current_exe()?.to_string_lossy().to_string();
-    let standalone = is_standalone_server();
-    #[cfg(target_os = "macos")]
-    {
-        let plist = plist_path()?;
-        return Ok(DaemonStatus {
-            suportado: true,
-            instalado: plist.exists(),
-            instalacao_disponivel: standalone,
-            plist: Some(plist.to_string_lossy().to_string()),
-            executavel: executable,
-        });
-    }
-    #[cfg(not(target_os = "macos"))]
+fn build_status(info: platform::AutostartInfo) -> Result<DaemonStatus> {
+    let executavel = std::env::current_exe()?.to_string_lossy().to_string();
     Ok(DaemonStatus {
-        suportado: false,
-        instalado: false,
-        instalacao_disponivel: false,
-        plist: None,
-        executavel: executable,
+        suportado: info.suportado,
+        instalado: info.instalado,
+        instalacao_disponivel: info.instalacao_disponivel,
+        service_path: info.service_path,
+        executavel,
+        plataforma: info.plataforma,
+        autostart_nome: info.autostart_nome,
+        instalacao_manual: info.instalacao_manual,
     })
 }
 
-pub fn install() -> Result<DaemonStatus> {
-    #[cfg(not(target_os = "macos"))]
-    bail!("autostart está disponível apenas no macOS");
-    #[cfg(target_os = "macos")]
-    {
-        if !is_standalone_server() {
-            bail!("execute scripts/instalar-autostart.sh para instalar o servidor persistente");
-        }
-        let executable = std::env::current_exe()?.to_string_lossy().to_string();
-        let working_directory = std::env::current_dir()?.to_string_lossy().to_string();
-        let web_dist = installed_web_dist()
-            .map(|path| {
-                format!(
-                    "<key>EnvironmentVariables</key><dict>\n<key>PROJECTUS_WEB_DIST</key><string>{}</string>\n</dict>\n",
-                    path.display()
-                )
-            })
-            .unwrap_or_default();
-        let plist = plist_path()?;
-        if let Some(parent) = plist.parent() {
-            fs::create_dir_all(parent)?;
-        }
-        let logs = dirs::data_local_dir()
-            .unwrap_or_else(|| PathBuf::from("/tmp"))
-            .join("PROJECTUS");
-        fs::create_dir_all(&logs)?;
-        let body = format!(
-            r#"<?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>{LABEL}</string>
-<key>ProgramArguments</key><array><string>{executable}</string></array>
-<key>WorkingDirectory</key><string>{working_directory}</string>
-{web_dist}<key>RunAtLoad</key><true/>
-<key>KeepAlive</key><true/>
-<key>StandardOutPath</key><string>{}/server.log</string>
-<key>StandardErrorPath</key><string>{}/server.err.log</string>
-</dict></plist>
-"#,
-            logs.display(),
-            logs.display()
-        );
-        fs::write(&plist, body)?;
-        let domain = format!("gui/{}", unsafe { libc::geteuid() });
-        let _ = Command::new("launchctl")
-            .args(["bootout", &domain, plist.to_string_lossy().as_ref()])
-            .output();
-        let output = Command::new("launchctl")
-            .args(["bootstrap", &domain, plist.to_string_lossy().as_ref()])
-            .output()
-            .context("não foi possível chamar launchctl")?;
-        if !output.status.success() {
-            bail!(
-                "launchctl falhou: {}",
-                String::from_utf8_lossy(&output.stderr)
-            );
-        }
-        status()
-    }
-}
-
-pub fn restart() -> Result<DaemonStatus> {
-    #[cfg(not(target_os = "macos"))]
-    bail!("reinício automático está disponível apenas no macOS");
-    #[cfg(target_os = "macos")]
-    {
-        let current = status()?;
-        if !current.instalado || !is_standalone_server() {
-            bail!("o servidor persistente não está instalado; instale o autostart primeiro");
-        }
-
-        // Returning before exiting lets the frontend start polling while launchd restarts this process.
-        std::thread::spawn(|| {
-            std::thread::sleep(std::time::Duration::from_millis(250));
-            std::process::exit(0);
-        });
-        Ok(current)
-    }
-}
-
-#[cfg(target_os = "macos")]
-fn installed_web_dist() -> Option<PathBuf> {
-    std::env::var_os("PROJECTUS_WEB_DIST")
-        .map(PathBuf::from)
-        .filter(|path| path.exists())
-        .or_else(|| {
-            std::env::current_exe()
-                .ok()
-                .and_then(|path| path.ancestors().nth(3).map(PathBuf::from))
-                .map(|root| root.join("apps/web/dist"))
-                .filter(|path| path.exists())
-        })
+pub fn status() -> Result<DaemonStatus> {
+    build_status(platform::autostart_info()?)
 }
 
-fn is_standalone_server() -> bool {
-    std::env::current_exe()
-        .ok()
-        .and_then(|path| path.file_stem().map(|name| name.to_owned()))
-        .and_then(|name| name.to_str().map(str::to_owned))
-        .is_some_and(|name| name == "projectus-server")
+pub fn install() -> Result<DaemonStatus> {
+    build_status(platform::autostart_install()?)
 }
 
-#[cfg(target_os = "macos")]
-fn plist_path() -> Result<PathBuf> {
-    Ok(dirs::home_dir()
-        .ok_or_else(|| anyhow::anyhow!("pasta pessoal não encontrada"))?
-        .join("Library/LaunchAgents")
-        .join(format!("{LABEL}.plist")))
+pub fn restart() -> Result<DaemonStatus> {
+    build_status(platform::autostart_restart()?)
 }
diff --git a/crates/server/src/domain.rs b/crates/server/src/domain.rs
index 5435574..7a913a4 100644
--- a/crates/server/src/domain.rs
+++ b/crates/server/src/domain.rs
@@ -301,6 +301,8 @@ pub struct ApiCapabilities {
     pub api_version: u32,
     pub arquivo: bool,
     pub config_autosave: bool,
+    pub data_root: String,
+    pub data_root_label: String,
 }
 
 impl Default for ApiCapabilities {
@@ -309,6 +311,8 @@ impl Default for ApiCapabilities {
             api_version: API_VERSION,
             arquivo: true,
             config_autosave: true,
+            data_root: String::new(),
+            data_root_label: String::new(),
         }
     }
 }
@@ -337,6 +341,7 @@ pub struct BackupCredentials {
 pub struct BackupCredentialStatus {
     pub fixadas: bool,
     pub access_key_id_mascarada: Option<String>,
+    pub store_nome: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/server/src/lib.rs b/crates/server/src/lib.rs
index 0ba2f73..88044e0 100644
--- a/crates/server/src/lib.rs
+++ b/crates/server/src/lib.rs
@@ -3,6 +3,7 @@ pub mod daemon;
 pub mod domain;
 pub mod http;
 pub mod lan;
+pub mod platform;
 pub mod scheduler;
 pub mod secrets;
 pub mod storage;
diff --git a/crates/server/src/platform/linux.rs b/crates/server/src/platform/linux.rs
new file mode 100644
index 0000000..8d6f916
--- /dev/null
+++ b/crates/server/src/platform/linux.rs
@@ -0,0 +1,103 @@
+use std::{fs, path::PathBuf, process::Command};
+
+use anyhow::{Context, Result, bail};
+
+use super::{AutostartInfo, TargetOs, is_standalone_server, manual_install_hint, platform_labels};
+
+pub fn autostart_info() -> Result<AutostartInfo> {
+    let standalone = is_standalone_server();
+    let service_path = service_file_path()?;
+    let instalado = service_path.exists() && is_service_active();
+    let labels = platform_labels(TargetOs::Linux);
+    Ok(AutostartInfo {
+        suportado: true,
+        instalado,
+        instalacao_disponivel: standalone,
+        service_path: Some(service_path.to_string_lossy().to_string()),
+        plataforma: labels.os_label.to_owned(),
+        autostart_nome: labels.autostart_label.to_owned(),
+        instalacao_manual: Some(manual_install_hint(TargetOs::Linux)),
+    })
+}
+
+pub fn autostart_install() -> Result<AutostartInfo> {
+    if !is_standalone_server() {
+        bail!("execute scripts/instalar-autostart-linux.sh para instalar o servidor persistente");
+    }
+    let executable = std::env::current_exe()?.to_string_lossy().to_string();
+    let working_directory = std::env::current_dir()?.to_string_lossy().to_string();
+    let web_dist = std::env::var("PROJECTUS_WEB_DIST")
+        .unwrap_or_else(|_| format!("{working_directory}/apps/web/dist"));
+
+    let service_path = service_file_path()?;
+    if let Some(parent) = service_path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    let unit = format!(
+        "[Unit]\nDescription=PROJECTUS local server\nAfter=network-online.target\n\n\
+         [Service]\nType=simple\nWorkingDirectory={working_directory}\n\
+         ExecStart={executable}\nEnvironment=PROJECTUS_WEB_DIST={web_dist}\n\
+         Restart=on-failure\nRestartSec=3\n\n\
+         [Install]\nWantedBy=default.target\n"
+    );
+    fs::write(&service_path, unit)?;
+
+    let reload = Command::new("systemctl")
+        .args(["--user", "daemon-reload"])
+        .output()
+        .context("não foi possível chamar systemctl")?;
+    if !reload.status.success() {
+        bail!(
+            "systemd user indisponível; rode manualmente ou habilite linger com: sudo loginctl enable-linger \"$USER\""
+        );
+    }
+
+    let enable = Command::new("systemctl")
+        .args(["--user", "enable", "--now", "projectus.service"])
+        .output()
+        .context("systemctl enable falhou")?;
+    if !enable.status.success() {
+        bail!(
+            "systemctl enable falhou: {}",
+            String::from_utf8_lossy(&enable.stderr)
+        );
+    }
+
+    autostart_info()
+}
+
+pub fn autostart_restart() -> Result<AutostartInfo> {
+    let current = autostart_info()?;
+    if !current.instalado || !is_standalone_server() {
+        bail!("o servidor persistente não está instalado; instale o autostart primeiro");
+    }
+    let output = Command::new("systemctl")
+        .args(["--user", "restart", "projectus.service"])
+        .output()
+        .context("não foi possível reiniciar via systemctl")?;
+    if !output.status.success() {
+        bail!(
+            "systemctl restart falhou: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+    autostart_info()
+}
+
+fn service_file_path() -> Result<PathBuf> {
+    let config_dir = dirs::config_dir()
+        .ok_or_else(|| anyhow::anyhow!("diretório de configuração não encontrado"))?;
+    Ok(config_dir
+        .join("systemd")
+        .join("user")
+        .join("projectus.service"))
+}
+
+fn is_service_active() -> bool {
+    Command::new("systemctl")
+        .args(["--user", "is-active", "--quiet", "projectus.service"])
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+}
diff --git a/crates/server/src/platform/macos.rs b/crates/server/src/platform/macos.rs
new file mode 100644
index 0000000..f74ec2a
--- /dev/null
+++ b/crates/server/src/platform/macos.rs
@@ -0,0 +1,110 @@
+use std::{fs, path::PathBuf, process::Command};
+
+use anyhow::{Context, Result, bail};
+
+use super::{AutostartInfo, TargetOs, is_standalone_server, manual_install_hint, platform_labels};
+
+const LABEL: &str = "com.projectus.server";
+
+pub fn autostart_info() -> Result<AutostartInfo> {
+    let standalone = is_standalone_server();
+    let plist = plist_path()?;
+    let labels = platform_labels(TargetOs::Macos);
+    Ok(AutostartInfo {
+        suportado: true,
+        instalado: plist.exists(),
+        instalacao_disponivel: standalone,
+        service_path: Some(plist.to_string_lossy().to_string()),
+        plataforma: labels.os_label.to_owned(),
+        autostart_nome: labels.autostart_label.to_owned(),
+        instalacao_manual: Some(manual_install_hint(TargetOs::Macos)),
+    })
+}
+
+pub fn autostart_install() -> Result<AutostartInfo> {
+    if !is_standalone_server() {
+        bail!("execute scripts/instalar-autostart-macos.sh para instalar o servidor persistente");
+    }
+    let executable = std::env::current_exe()?.to_string_lossy().to_string();
+    let working_directory = std::env::current_dir()?.to_string_lossy().to_string();
+    let web_dist = installed_web_dist()
+        .map(|path| {
+            format!(
+                "<key>EnvironmentVariables</key><dict>\n<key>PROJECTUS_WEB_DIST</key><string>{}</string>\n</dict>\n",
+                path.display()
+            )
+        })
+        .unwrap_or_default();
+    let plist = plist_path()?;
+    if let Some(parent) = plist.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let logs = dirs::data_local_dir()
+        .unwrap_or_else(|| PathBuf::from("/tmp"))
+        .join("PROJECTUS");
+    fs::create_dir_all(&logs)?;
+    let body = format!(
+        r#"<?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>{LABEL}</string>
+<key>ProgramArguments</key><array><string>{executable}</string></array>
+<key>WorkingDirectory</key><string>{working_directory}</string>
+{web_dist}<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><true/>
+<key>StandardOutPath</key><string>{}/server.log</string>
+<key>StandardErrorPath</key><string>{}/server.err.log</string>
+</dict></plist>
+"#,
+        logs.display(),
+        logs.display()
+    );
+    fs::write(&plist, body)?;
+    let domain = format!("gui/{}", unsafe { libc::geteuid() });
+    let _ = Command::new("launchctl")
+        .args(["bootout", &domain, plist.to_string_lossy().as_ref()])
+        .output();
+    let output = Command::new("launchctl")
+        .args(["bootstrap", &domain, plist.to_string_lossy().as_ref()])
+        .output()
+        .context("não foi possível chamar launchctl")?;
+    if !output.status.success() {
+        bail!(
+            "launchctl falhou: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+    autostart_info()
+}
+
+pub fn autostart_restart() -> Result<AutostartInfo> {
+    let current = autostart_info()?;
+    if !current.instalado || !is_standalone_server() {
+        bail!("o servidor persistente não está instalado; instale o autostart primeiro");
+    }
+    std::thread::spawn(|| {
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        std::process::exit(0);
+    });
+    Ok(current)
+}
+
+fn installed_web_dist() -> Option<PathBuf> {
+    std::env::var_os("PROJECTUS_WEB_DIST")
+        .map(PathBuf::from)
+        .filter(|path| path.exists())
+        .or_else(|| {
+            std::env::current_exe()
+                .ok()
+                .and_then(|path| path.ancestors().nth(3).map(PathBuf::from))
+                .map(|root| root.join("apps/web/dist"))
+                .filter(|path| path.exists())
+        })
+}
+
+fn plist_path() -> Result<PathBuf> {
+    Ok(dirs::home_dir()
+        .ok_or_else(|| anyhow::anyhow!("pasta pessoal não encontrada"))?
+        .join("Library/LaunchAgents")
+        .join(format!("{LABEL}.plist")))
+}
diff --git a/crates/server/src/platform/mod.rs b/crates/server/src/platform/mod.rs
new file mode 100644
index 0000000..f1c8c12
--- /dev/null
+++ b/crates/server/src/platform/mod.rs
@@ -0,0 +1,180 @@
+#[cfg(target_os = "macos")]
+mod macos;
+#[cfg(target_os = "linux")]
+pub mod linux;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TargetOs {
+    Macos,
+    Linux,
+    Other,
+}
+
+#[derive(Debug, Clone)]
+pub struct PlatformLabels {
+    pub os_label: &'static str,
+    pub credential_store_label: &'static str,
+    pub autostart_label: &'static str,
+}
+
+pub struct AutostartInfo {
+    pub suportado: bool,
+    pub instalado: bool,
+    pub instalacao_disponivel: bool,
+    pub service_path: Option<String>,
+    pub plataforma: String,
+    pub autostart_nome: String,
+    pub instalacao_manual: Option<String>,
+}
+
+pub fn platform_labels(os: TargetOs) -> PlatformLabels {
+    match os {
+        TargetOs::Macos => PlatformLabels {
+            os_label: "macOS",
+            credential_store_label: "Keychain",
+            autostart_label: "LaunchAgent",
+        },
+        TargetOs::Linux => PlatformLabels {
+            os_label: "Linux",
+            credential_store_label: "Secret Service",
+            autostart_label: "systemd user service",
+        },
+        TargetOs::Other => PlatformLabels {
+            os_label: "sistema atual",
+            credential_store_label: "cofre do sistema",
+            autostart_label: "autostart",
+        },
+    }
+}
+
+pub fn current_os() -> TargetOs {
+    #[cfg(target_os = "macos")]
+    return TargetOs::Macos;
+    #[cfg(target_os = "linux")]
+    return TargetOs::Linux;
+    #[allow(unreachable_code)]
+    TargetOs::Other
+}
+
+pub fn credential_store_label() -> &'static str {
+    platform_labels(current_os()).credential_store_label
+}
+
+pub fn manual_install_hint(os: TargetOs) -> String {
+    match os {
+        TargetOs::Macos => "./scripts/instalar-autostart-macos.sh".to_owned(),
+        TargetOs::Linux => "./scripts/instalar-autostart-linux.sh".to_owned(),
+        TargetOs::Other => String::new(),
+    }
+}
+
+pub fn is_standalone_server() -> bool {
+    std::env::current_exe()
+        .ok()
+        .and_then(|path| path.file_stem().map(|n| n.to_owned()))
+        .and_then(|n| n.to_str().map(str::to_owned))
+        .is_some_and(|n| n == "projectus-server")
+}
+
+#[cfg(target_os = "macos")]
+pub fn autostart_info() -> anyhow::Result<AutostartInfo> {
+    macos::autostart_info()
+}
+
+#[cfg(target_os = "linux")]
+pub fn autostart_info() -> anyhow::Result<AutostartInfo> {
+    linux::autostart_info()
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "linux")))]
+pub fn autostart_info() -> anyhow::Result<AutostartInfo> {
+    let labels = platform_labels(TargetOs::Other);
+    Ok(AutostartInfo {
+        suportado: false,
+        instalado: false,
+        instalacao_disponivel: false,
+        service_path: None,
+        plataforma: labels.os_label.to_owned(),
+        autostart_nome: labels.autostart_label.to_owned(),
+        instalacao_manual: None,
+    })
+}
+
+#[cfg(target_os = "macos")]
+pub fn autostart_install() -> anyhow::Result<AutostartInfo> {
+    macos::autostart_install()
+}
+
+#[cfg(target_os = "linux")]
+pub fn autostart_install() -> anyhow::Result<AutostartInfo> {
+    linux::autostart_install()
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "linux")))]
+pub fn autostart_install() -> anyhow::Result<AutostartInfo> {
+    anyhow::bail!("autostart não disponível nesta plataforma")
+}
+
+#[cfg(target_os = "macos")]
+pub fn autostart_restart() -> anyhow::Result<AutostartInfo> {
+    macos::autostart_restart()
+}
+
+#[cfg(target_os = "linux")]
+pub fn autostart_restart() -> anyhow::Result<AutostartInfo> {
+    linux::autostart_restart()
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "linux")))]
+pub fn autostart_restart() -> anyhow::Result<AutostartInfo> {
+    anyhow::bail!("reinício automático não disponível nesta plataforma")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn daemon_status_on_linux_reports_systemd_user_service() {
+        let labels = platform_labels(TargetOs::Linux);
+        assert_eq!(labels.autostart_label, "systemd user service");
+        assert_eq!(labels.os_label, "Linux");
+    }
+
+    #[test]
+    fn daemon_status_on_macos_reports_launch_agent() {
+        let labels = platform_labels(TargetOs::Macos);
+        assert_eq!(labels.autostart_label, "LaunchAgent");
+        assert_eq!(labels.os_label, "macOS");
+    }
+
+    #[test]
+    fn credential_store_label_matches_platform() {
+        assert_eq!(
+            platform_labels(TargetOs::Macos).credential_store_label,
+            "Keychain"
+        );
+        assert_eq!(
+            platform_labels(TargetOs::Linux).credential_store_label,
+            "Secret Service"
+        );
+        assert_eq!(
+            platform_labels(TargetOs::Other).credential_store_label,
+            "cofre do sistema"
+        );
+    }
+
+    #[test]
+    fn manual_install_message_mentions_correct_script() {
+        let linux_hint = manual_install_hint(TargetOs::Linux);
+        assert!(
+            linux_hint.contains("linux"),
+            "Linux hint should reference linux script: {linux_hint}"
+        );
+        let macos_hint = manual_install_hint(TargetOs::Macos);
+        assert!(
+            macos_hint.contains("macos") || macos_hint.contains("instalar-autostart"),
+            "macOS hint should reference autostart script: {macos_hint}"
+        );
+    }
+}
diff --git a/crates/server/src/secrets.rs b/crates/server/src/secrets.rs
index 83dd80d..96c5c11 100644
--- a/crates/server/src/secrets.rs
+++ b/crates/server/src/secrets.rs
@@ -1,7 +1,10 @@
 use anyhow::{Context, Result, bail};
 use keyring::Entry;
 
-use crate::domain::{BackupCredentialStatus, BackupCredentials};
+use crate::{
+    domain::{BackupCredentialStatus, BackupCredentials},
+    platform,
+};
 
 const SERVICE: &str = "com.projectus.r2";
 const ACCESS_USER: &str = "access-key-id";
@@ -11,14 +14,27 @@ pub fn save(credentials: &BackupCredentials) -> Result<()> {
     if credentials.access_key_id.trim().is_empty()
         || credentials.secret_access_key.trim().is_empty()
     {
-        bail!("informe as duas credenciais R2 para fixar no Keychain");
+        bail!(
+            "informe as duas credenciais R2 para fixar no {}",
+            platform::credential_store_label()
+        );
     }
     Entry::new(SERVICE, ACCESS_USER)?
         .set_password(&credentials.access_key_id)
-        .context("não foi possível salvar a access key no Keychain")?;
+        .with_context(|| {
+            format!(
+                "não foi possível salvar a access key no {}",
+                platform::credential_store_label()
+            )
+        })?;
     Entry::new(SERVICE, SECRET_USER)?
         .set_password(&credentials.secret_access_key)
-        .context("não foi possível salvar a secret key no Keychain")?;
+        .with_context(|| {
+            format!(
+                "não foi possível salvar a secret key no {}",
+                platform::credential_store_label()
+            )
+        })?;
     Ok(())
 }
 
@@ -26,14 +42,25 @@ pub fn load() -> Result<BackupCredentials> {
     Ok(BackupCredentials {
         access_key_id: Entry::new(SERVICE, ACCESS_USER)?
             .get_password()
-            .context("credencial R2 não encontrada no Keychain")?,
+            .with_context(|| {
+                format!(
+                    "credencial R2 não encontrada no {}",
+                    platform::credential_store_label()
+                )
+            })?,
         secret_access_key: Entry::new(SERVICE, SECRET_USER)?
             .get_password()
-            .context("segredo R2 não encontrado no Keychain")?,
+            .with_context(|| {
+                format!(
+                    "segredo R2 não encontrado no {}",
+                    platform::credential_store_label()
+                )
+            })?,
     })
 }
 
 pub fn status() -> BackupCredentialStatus {
+    let store_nome = platform::credential_store_label().to_owned();
     match load() {
         Ok(credentials) => {
             let suffix: String = credentials
@@ -48,11 +75,13 @@ pub fn status() -> BackupCredentialStatus {
             BackupCredentialStatus {
                 fixadas: true,
                 access_key_id_mascarada: Some(format!("****{suffix}")),
+                store_nome,
             }
         }
         Err(_) => BackupCredentialStatus {
             fixadas: false,
             access_key_id_mascarada: None,
+            store_nome,
         },
     }
 }
diff --git a/crates/server/src/storage.rs b/crates/server/src/storage.rs
index 88f0a60..23107f9 100644
--- a/crates/server/src/storage.rs
+++ b/crates/server/src/storage.rs
@@ -91,11 +91,19 @@ impl Storage {
 
     pub fn bootstrap(&self) -> StoreResult<Bootstrap> {
         let _guard = self.writes.lock().expect("storage mutex poisoned");
+        let data_root = self.root.to_string_lossy().to_string();
+        let data_root_label = dirs::home_dir()
+            .and_then(|home| self.root.strip_prefix(&home).ok().map(|rel| format!("~/{}", rel.display())))
+            .unwrap_or_else(|| data_root.clone());
         Ok(Bootstrap {
             config: self.read_config_inner()?,
             board: self.read_board_inner()?,
             ideias: self.read_ideas_inner()?,
-            capacidades: ApiCapabilities::default(),
+            capacidades: ApiCapabilities {
+                data_root,
+                data_root_label,
+                ..ApiCapabilities::default()
+            },
         })
     }
 

From c69fa30a37687e381634cfeeca417a19ba8a2de3 Mon Sep 17 00:00:00 2001
From: daviirodrig <30713947+daviirodrig@users.noreply.github.com>
Date: Tue, 26 May 2026 18:45:26 -0300
Subject: [PATCH 2/2] feat: Linux build scripts, cross-platform autostart
 dispatchers, and CI matrix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Scripts:
- instalar-autostart.sh / remover-autostart.sh become bash dispatchers
  (Darwin → macos, Linux → linux, else error); old zsh logic moved to
  *-macos.sh variants intact
- instalar-autostart-linux.sh: writes ~/.config/systemd/user/projectus.service,
  runs systemctl --user enable --now; hints about loginctl enable-linger
- remover-autostart-linux.sh: systemctl disable --now + rm + daemon-reload
- instalar.sh: early exit on Linux with a useful message pointing to build:linux
- build-linux.sh: pnpm build + cargo release + tauri deb,appimage
- check-tauri-linux-deps.sh: pkg-config probe for webkit2gtk-4.1 / gtk+-3.0 /
  openssl; prints Arch and Debian/Ubuntu install commands on failure; macOS no-op

package.json: adds build:linux, instalar:macos, desktop:check scripts

CI (.github/workflows/ci.yml):
- web job on ubuntu-latest: typecheck, test, build
- rust-linux on ubuntu-latest: libdbus-1-dev, cargo test + release build
- rust-macos on macos-latest: cargo test + release build
---
 .github/workflows/ci.yml            | 47 +++++++++++++++++++++++++++++
 package.json                        |  5 ++-
 scripts/build-linux.sh              | 21 +++++++++++++
 scripts/check-tauri-linux-deps.sh   | 31 +++++++++++++++++++
 scripts/instalar-autostart-linux.sh | 42 ++++++++++++++++++++++++++
 scripts/instalar-autostart-macos.sh | 32 ++++++++++++++++++++
 scripts/instalar-autostart.sh       | 36 +++++-----------------
 scripts/instalar.sh                 |  6 ++++
 scripts/remover-autostart-linux.sh  |  9 ++++++
 scripts/remover-autostart-macos.sh  |  7 +++++
 scripts/remover-autostart.sh        | 13 +++++---
 11 files changed, 214 insertions(+), 35 deletions(-)
 create mode 100644 .github/workflows/ci.yml
 create mode 100755 scripts/build-linux.sh
 create mode 100755 scripts/check-tauri-linux-deps.sh
 create mode 100755 scripts/instalar-autostart-linux.sh
 create mode 100755 scripts/instalar-autostart-macos.sh
 create mode 100755 scripts/remover-autostart-linux.sh
 create mode 100755 scripts/remover-autostart-macos.sh

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..98825dd
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,47 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  web:
+    name: web (Ubuntu)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm typecheck
+      - run: pnpm test -- --run
+      - run: pnpm build
+
+  rust-linux:
+    name: rust (Linux)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: install keyring deps
+        run: sudo apt-get install -y libdbus-1-dev
+      - run: cargo test --workspace
+      - run: cargo build -p projectus-server --release
+
+  rust-macos:
+    name: rust (macOS)
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test --workspace
+      - run: cargo build -p projectus-server --release
diff --git a/package.json b/package.json
index 8d13f93..87aeaea 100644
--- a/package.json
+++ b/package.json
@@ -13,6 +13,9 @@
     "server:dev": "cargo run -p projectus-server",
     "server:test": "cargo test --workspace",
     "instalar": "./scripts/instalar.sh",
-    "instalador": "./scripts/instalar.sh"
+    "instalar:macos": "./scripts/instalar-autostart-macos.sh",
+    "instalador": "./scripts/instalar.sh",
+    "build:linux": "./scripts/build-linux.sh",
+    "desktop:check": "./scripts/check-tauri-linux-deps.sh"
   }
 }
diff --git a/scripts/build-linux.sh b/scripts/build-linux.sh
new file mode 100755
index 0000000..3ffe6e5
--- /dev/null
+++ b/scripts/build-linux.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+echo ">> build web..."
+pnpm --dir "$ROOT" build
+
+echo ">> build server..."
+cargo build --release -p projectus-server --manifest-path "$ROOT/Cargo.toml"
+
+echo ">> build desktop (AppImage + deb)..."
+"$ROOT/scripts/check-tauri-linux-deps.sh"
+pnpm --filter @projectus/desktop tauri build --bundles deb,appimage
+
+echo ""
+echo "Artefatos:"
+ls "$ROOT/target/release/bundle/" 2>/dev/null || true
+echo ""
+echo "Para rodar apenas o servidor:"
+echo "  PROJECTUS_WEB_DIST=$ROOT/apps/web/dist $ROOT/target/release/projectus-server"
diff --git a/scripts/check-tauri-linux-deps.sh b/scripts/check-tauri-linux-deps.sh
new file mode 100755
index 0000000..de3b472
--- /dev/null
+++ b/scripts/check-tauri-linux-deps.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "$(uname -s)" != "Linux" ]]; then
+  exit 0
+fi
+
+MISSING=()
+check() {
+  pkg-config --exists "$1" 2>/dev/null || MISSING+=("$1")
+}
+
+command -v pkg-config >/dev/null 2>&1 || { echo "ERR / pkg-config não encontrado; instale antes de continuar." >&2; exit 1; }
+
+check webkit2gtk-4.1
+check gtk+-3.0
+check openssl
+
+if [[ ${#MISSING[@]} -eq 0 ]]; then
+  echo "OK / todas as dependências Tauri encontradas."
+  exit 0
+fi
+
+echo "ERR / dependências ausentes: ${MISSING[*]}" >&2
+echo "" >&2
+echo "Arch Linux:" >&2
+echo "  sudo pacman -S webkit2gtk-4.1 gtk3 openssl pkg-config libayatana-appindicator" >&2
+echo "" >&2
+echo "Debian/Ubuntu:" >&2
+echo "  sudo apt install libwebkit2gtk-4.1-dev libgtk-3-dev libssl-dev pkg-config libayatana-appindicator3-dev librsvg2-dev" >&2
+exit 1
diff --git a/scripts/instalar-autostart-linux.sh b/scripts/instalar-autostart-linux.sh
new file mode 100755
index 0000000..9959425
--- /dev/null
+++ b/scripts/instalar-autostart-linux.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+BIN="$ROOT/target/release/projectus-server"
+SERVICE_DIR="$HOME/.config/systemd/user"
+SERVICE_FILE="$SERVICE_DIR/projectus.service"
+
+if [[ ! -f "$BIN" ]]; then
+  echo ">> compilando projectus-server..."
+  pnpm --dir "$ROOT" build
+  cargo build --release -p projectus-server --manifest-path "$ROOT/Cargo.toml"
+fi
+
+mkdir -p "$SERVICE_DIR"
+
+cat > "$SERVICE_FILE" <<EOF
+[Unit]
+Description=PROJECTUS local server
+After=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=$ROOT
+ExecStart=$BIN
+Environment=PROJECTUS_WEB_DIST=$ROOT/apps/web/dist
+Restart=on-failure
+RestartSec=3
+
+[Install]
+WantedBy=default.target
+EOF
+
+systemctl --user daemon-reload
+systemctl --user enable --now projectus.service
+echo "PROJECTUS server instalado: $SERVICE_FILE"
+echo ""
+echo "Para verificar: systemctl --user status projectus.service"
+echo "Para remover:   ./scripts/remover-autostart-linux.sh"
+echo ""
+echo "Nota: para iniciar com o sistema sem sessão ativa, habilite linger:"
+echo "  sudo loginctl enable-linger \"\$USER\""
diff --git a/scripts/instalar-autostart-macos.sh b/scripts/instalar-autostart-macos.sh
new file mode 100755
index 0000000..7ae4e43
--- /dev/null
+++ b/scripts/instalar-autostart-macos.sh
@@ -0,0 +1,32 @@
+#!/bin/zsh
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+BIN="$ROOT/target/release/projectus-server"
+PLIST="$HOME/Library/LaunchAgents/com.projectus.server.plist"
+LOG_DIR="$HOME/Library/Logs/PROJECTUS"
+
+pnpm --dir "$ROOT" build
+cargo build --release -p projectus-server --manifest-path "$ROOT/Cargo.toml"
+mkdir -p "${PLIST:h}" "$LOG_DIR"
+
+cat > "$PLIST" <<EOF
+<?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>com.projectus.server</string>
+<key>ProgramArguments</key><array><string>$BIN</string></array>
+<key>WorkingDirectory</key><string>$ROOT</string>
+<key>EnvironmentVariables</key><dict>
+<key>PROJECTUS_WEB_DIST</key><string>$ROOT/apps/web/dist</string>
+</dict>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><true/>
+<key>StandardOutPath</key><string>$LOG_DIR/server.log</string>
+<key>StandardErrorPath</key><string>$LOG_DIR/server.err.log</string>
+</dict></plist>
+EOF
+
+launchctl bootout "gui/$UID" "$PLIST" 2>/dev/null || true
+launchctl bootstrap "gui/$UID" "$PLIST"
+echo "PROJECTUS server instalado: $PLIST"
diff --git a/scripts/instalar-autostart.sh b/scripts/instalar-autostart.sh
index 7ae4e43..bd6886f 100755
--- a/scripts/instalar-autostart.sh
+++ b/scripts/instalar-autostart.sh
@@ -1,32 +1,10 @@
-#!/bin/zsh
+#!/usr/bin/env bash
 set -euo pipefail
 
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-BIN="$ROOT/target/release/projectus-server"
-PLIST="$HOME/Library/LaunchAgents/com.projectus.server.plist"
-LOG_DIR="$HOME/Library/Logs/PROJECTUS"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-pnpm --dir "$ROOT" build
-cargo build --release -p projectus-server --manifest-path "$ROOT/Cargo.toml"
-mkdir -p "${PLIST:h}" "$LOG_DIR"
-
-cat > "$PLIST" <<EOF
-<?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>com.projectus.server</string>
-<key>ProgramArguments</key><array><string>$BIN</string></array>
-<key>WorkingDirectory</key><string>$ROOT</string>
-<key>EnvironmentVariables</key><dict>
-<key>PROJECTUS_WEB_DIST</key><string>$ROOT/apps/web/dist</string>
-</dict>
-<key>RunAtLoad</key><true/>
-<key>KeepAlive</key><true/>
-<key>StandardOutPath</key><string>$LOG_DIR/server.log</string>
-<key>StandardErrorPath</key><string>$LOG_DIR/server.err.log</string>
-</dict></plist>
-EOF
-
-launchctl bootout "gui/$UID" "$PLIST" 2>/dev/null || true
-launchctl bootstrap "gui/$UID" "$PLIST"
-echo "PROJECTUS server instalado: $PLIST"
+case "$(uname -s)" in
+  Darwin) exec "$SCRIPT_DIR/instalar-autostart-macos.sh" "$@" ;;
+  Linux)  exec "$SCRIPT_DIR/instalar-autostart-linux.sh" "$@" ;;
+  *)      echo "Autostart não suportado em $(uname -s)" >&2; exit 1 ;;
+esac
diff --git a/scripts/instalar.sh b/scripts/instalar.sh
index 86fa86e..2293946 100755
--- a/scripts/instalar.sh
+++ b/scripts/instalar.sh
@@ -12,6 +12,12 @@ set -euo pipefail
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$ROOT"
 
+if [[ "$(uname -s)" == "Linux" ]]; then
+  echo "DMG é macOS. No Linux, use: pnpm build:linux" >&2
+  echo "  ou para só o servidor: cargo build --release -p projectus-server" >&2
+  exit 1
+fi
+
 OPEN_FINDER=1
 INSTALL_DAEMON=0
 for arg in "$@"; do
diff --git a/scripts/remover-autostart-linux.sh b/scripts/remover-autostart-linux.sh
new file mode 100755
index 0000000..10c4b71
--- /dev/null
+++ b/scripts/remover-autostart-linux.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SERVICE_FILE="$HOME/.config/systemd/user/projectus.service"
+
+systemctl --user disable --now projectus.service 2>/dev/null || true
+rm -f "$SERVICE_FILE"
+systemctl --user daemon-reload
+echo "Autostart Linux removido."
diff --git a/scripts/remover-autostart-macos.sh b/scripts/remover-autostart-macos.sh
new file mode 100755
index 0000000..3bba504
--- /dev/null
+++ b/scripts/remover-autostart-macos.sh
@@ -0,0 +1,7 @@
+#!/bin/zsh
+set -euo pipefail
+
+PLIST="$HOME/Library/LaunchAgents/com.projectus.server.plist"
+launchctl bootout "gui/$UID" "$PLIST" 2>/dev/null || true
+rm -f "$PLIST"
+echo "Autostart removido."
diff --git a/scripts/remover-autostart.sh b/scripts/remover-autostart.sh
index 3bba504..813e8c1 100755
--- a/scripts/remover-autostart.sh
+++ b/scripts/remover-autostart.sh
@@ -1,7 +1,10 @@
-#!/bin/zsh
+#!/usr/bin/env bash
 set -euo pipefail
 
-PLIST="$HOME/Library/LaunchAgents/com.projectus.server.plist"
-launchctl bootout "gui/$UID" "$PLIST" 2>/dev/null || true
-rm -f "$PLIST"
-echo "Autostart removido."
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+case "$(uname -s)" in
+  Darwin) exec "$SCRIPT_DIR/remover-autostart-macos.sh" "$@" ;;
+  Linux)  exec "$SCRIPT_DIR/remover-autostart-linux.sh" "$@" ;;
+  *)      echo "Autostart não suportado em $(uname -s)" >&2; exit 1 ;;
+esac