@alwith/module-drive 0.0.0-stage → 0.1.0-rc.23

package/package.json

@@ -1,6 +1,119 @@
 {
   "name": "@alwith/module-drive",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-rc.23",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "files": [
+    "dist",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "README.md",
+    "desktop-provenance.json",
+    "rust/Cargo.toml",
+    "rust/src"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./tauri": {
+      "types": "./dist/tauri.d.ts",
+      "import": "./dist/tauri.js"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./content": {
+      "types": "./dist/content.d.ts",
+      "import": "./dist/content.js"
+    }
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build-npm.ts",
+    "test": "bun test src",
+    "bindings": "cargo run --manifest-path ../../Cargo.toml -p alwith-drive-impl --bin export -- src/contract.ts",
+    "prepack": "bun run build && bun ../../scripts/verify-module-package.ts drive"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "@milkdown/core": "^7.22.2",
+    "@milkdown/ctx": "^7.22.2",
+    "@milkdown/prose": "^7.22.2",
+    "@milkdown/utils": "^7.22.2",
+    "@milkdown/plugin-collab": "^7.22.2",
+    "yjs": "^13.6.33",
+    "y-prosemirror": "^1.3.7",
+    "y-protocols": "^1.0.7",
+    "y-websocket": "^3.1.0",
+    "lucide-react": "^1.54.0",
+    "@alwith/module-editor": "^0.1.0-rc.8"
+  },
+  "devDependencies": {
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@milkdown/core": "^7.22.2",
+    "@milkdown/ctx": "^7.22.2",
+    "@milkdown/prose": "^7.22.2",
+    "@milkdown/utils": "^7.22.2",
+    "@milkdown/plugin-collab": "^7.22.2",
+    "yjs": "^13.6.33",
+    "y-prosemirror": "^1.3.7",
+    "y-protocols": "^1.0.7",
+    "y-websocket": "^3.1.0",
+    "lucide-react": "^1.54.0",
+    "@alwith/module-editor": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "@milkdown/core": {
+      "optional": true
+    },
+    "@milkdown/ctx": {
+      "optional": true
+    },
+    "@milkdown/prose": {
+      "optional": true
+    },
+    "@milkdown/utils": {
+      "optional": true
+    },
+    "@milkdown/plugin-collab": {
+      "optional": true
+    },
+    "yjs": {
+      "optional": true
+    },
+    "y-prosemirror": {
+      "optional": true
+    },
+    "y-protocols": {
+      "optional": true
+    },
+    "y-websocket": {
+      "optional": true
+    },
+    "lucide-react": {
+      "optional": true
+    },
+    "@alwith/module-editor": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@alwith/native-kit": "0.1.0"
+  }
+}

package/rust/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+autobins = false
+autotests = false
+name = "alwith-drive"
+version = "0.1.0-rc.22"
+edition = "2024"
+publish = false
+[workspace]
+[dependencies]
+alwith-native-client = { path = "../../native-kit/rust" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+specta = { version = "2.0.0-rc.27", features = ["derive"] }
+tokio = { version = "1", features = ["sync"] }

package/rust/src/contract.rs

@@ -0,0 +1,366 @@
+use crate::sync::*;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+pub const CONTRACT_VERSION: u32 = 1;
+
+#[derive(Deserialize, Type, Serialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum AccessRequestType {
+    FileAccess,
+    ProjectJoin,
+}
+
+#[derive(Serialize, Type, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum AccessRequestOutcome {
+    Submitted,
+    AlreadyPending,
+}
+
+#[derive(Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct Snapshot {
+    pub version: u32,
+    pub generation: u32,
+    pub sequence: u32,
+    pub configured: bool,
+    pub running: bool,
+    pub base_url: String,
+    pub local_root: String,
+    pub web_base_url: Option<String>,
+    pub status: Option<StatusSnapshot>,
+    pub roots: Vec<RootInfo>,
+    pub pending_deletes: Vec<PendingDeletes>,
+    pub files: Vec<FileStateEvent>,
+    pub projects: Vec<ProjectProgress>,
+    pub error: Option<String>,
+}
+
+#[derive(Clone, Serialize, Deserialize, Type)]
+#[serde(tag = "type", content = "data", rename_all = "camelCase")]
+pub enum Payload {
+    Snapshot(Snapshot),
+    Status(StatusSnapshot),
+    File(FileStateEvent),
+    Project(ProjectProgress),
+    Conflict(ConflictRecord),
+    ReadOnly(ReadOnlyChange),
+    Changed(Vec<String>),
+    Reconcile,
+    Comment(CommentEvent),
+    Error(String),
+}
+
+#[derive(Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct DriveEvent {
+    pub version: u32,
+    pub generation: u32,
+    pub sequence: u32,
+    pub payload: Payload,
+}
+
+#[derive(Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CommentEvent {
+    pub file_id: RemoteId,
+    pub comment_id: RemoteId,
+    pub action: String,
+    pub actor_id: Option<RemoteId>,
+    pub at: Option<String>,
+}
+
+#[derive(Serialize, Type, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Configuration {
+    pub device_id: Option<String>,
+    pub user_name: Option<String>,
+    pub user_id: Option<String>,
+    pub client_config: Option<ClientConfig>,
+}
+
+#[derive(Serialize, Type, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CollabSession {
+    pub file_id: RemoteId,
+    pub server_url: String,
+    pub room: String,
+    pub token: String,
+    pub can_write: bool,
+}
+
+#[derive(Serialize, Type, Deserialize)]
+pub struct McpHeader {
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(Serialize, Type, Deserialize)]
+pub struct McpSessionConfig {
+    pub url: String,
+    pub headers: Vec<McpHeader>,
+}
+
+#[derive(Deserialize, Type, Serialize)]
+#[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
+pub enum DriveRequest {
+    Preferences,
+    ArchivePrivateSessions,
+    SetArchivePrivate {
+        session_id: String,
+        private: bool,
+    },
+    SetPreferences {
+        session_archive: bool,
+        knowledge_inject: bool,
+    },
+    ArchiveSession {
+        expected_generation: u32,
+        session_id: String,
+        cwd: String,
+        title: String,
+        updated_at: String,
+        content: String,
+    },
+    Configuration,
+    Reconfigure {
+        local_root: String,
+        user_name: String,
+    },
+    RefreshClientConfig,
+    McpSessionConfig,
+    RetryUpload {
+        project_id: RemoteId,
+        path: String,
+    },
+    CloudFolders {
+        project_id: RemoteId,
+    },
+    FileRemoteId {
+        path: String,
+    },
+    CommentContext {
+        path: String,
+    },
+    Comments {
+        file_id: RemoteId,
+    },
+    CommentCreate {
+        file_id: RemoteId,
+        request: CreateCommentRequest,
+    },
+    CommentUpdate {
+        comment_id: RemoteId,
+        body: String,
+    },
+    CommentDelete {
+        comment_id: RemoteId,
+    },
+    CommentApply {
+        comment_id: RemoteId,
+    },
+    CommentWatch {
+        owner_id: String,
+        file_ids: Vec<RemoteId>,
+    },
+    CollabSession {
+        path: String,
+        owner_id: String,
+    },
+    CollabEnd {
+        path: String,
+        owner_id: String,
+    },
+    CondensePreflight {
+        project_id: RemoteId,
+        scope_path: Option<String>,
+    },
+    CondenseStart {
+        project_id: RemoteId,
+        scope_path: Option<String>,
+    },
+    Job {
+        job_id: RemoteId,
+    },
+    ProposedCondense {
+        project_id: RemoteId,
+    },
+    ApproveJob {
+        job_id: RemoteId,
+    },
+    CancelJob {
+        job_id: RemoteId,
+    },
+    KnowledgeContext {
+        cwd: String,
+    },
+    SkillMirrors,
+    ArchiveStatus,
+    SyncProject {
+        project_id: RemoteId,
+    },
+    Snapshot,
+    MoveBetweenProjects {
+        source: String,
+        destination: String,
+    },
+    Login {
+        base_url: String,
+        token: String,
+        local_root: String,
+    },
+    SsoConfig {
+        base_url: String,
+    },
+    SsoLogin {
+        base_url: String,
+        local_root: String,
+    },
+    ResolveRootOwnership {
+        generation: u32,
+        accept: bool,
+    },
+    Logout,
+    Start,
+    Stop,
+    MaxAutoDownloadMb,
+    SetMaxAutoDownloadMb {
+        megabytes: u64,
+    },
+    Pause {
+        paused: bool,
+    },
+    Sync,
+    Roots,
+    Pin {
+        project_id: RemoteId,
+        pinned: bool,
+    },
+    Land {
+        project_id: RemoteId,
+    },
+    File {
+        path: String,
+    },
+    Download {
+        project_id: RemoteId,
+        path: String,
+    },
+    ConfirmDeletes {
+        project_id: RemoteId,
+    },
+    CancelDeletes {
+        project_id: RemoteId,
+    },
+    Templates,
+    Departments,
+    CreateProject {
+        request: CreateProjectFromTemplateRequest,
+    },
+    Shared,
+    FailedUploads,
+    RetryUploads,
+    Reconcile {
+        project_id: Option<RemoteId>,
+    },
+    RecheckCloudOnly,
+    DiskUsage {
+        limit: u32,
+    },
+    CleanupScan,
+    Cleanup {
+        paths: Vec<String>,
+    },
+    OwnershipGuard,
+    SyncAllPersonal {
+        enabled: bool,
+    },
+    GrantTarget {
+        path: String,
+    },
+    Grants {
+        target: GrantTarget,
+    },
+    SetGrant {
+        target: GrantTarget,
+        request: SetGrantRequest,
+    },
+    RemoveGrant {
+        target: GrantTarget,
+        subject_type: String,
+        subject_id: RemoteId,
+    },
+    SearchUsers {
+        query: String,
+    },
+    SearchDepartments {
+        query: String,
+    },
+    RequestAccess {
+        request_type: AccessRequestType,
+        target_id: RemoteId,
+        message: Option<String>,
+    },
+    SaveVersion {
+        path: String,
+    },
+    LocalPath {
+        file_id: RemoteId,
+    },
+}
+
+#[derive(Serialize, Type, Deserialize)]
+#[serde(tag = "type", content = "data", rename_all = "camelCase")]
+pub enum DriveResponse {
+    RootOwnershipConfirmation {
+        generation: u32,
+        #[serde(rename = "localRoot")]
+        local_root: String,
+    },
+    ArchivePrivateSessions(Vec<String>),
+    Preferences(Preferences),
+    Configuration(Configuration),
+    ClientConfig(ClientConfig),
+    McpSessionConfig(Option<McpSessionConfig>),
+    CloudFolders(Vec<crate::sync::CloudFolder>),
+    CommentContext(Option<CommentContext>),
+    Comments(Vec<FileComment>),
+    Comment(FileComment),
+    CollabSession(Option<CollabSession>),
+    Unsynced(UnsyncedSummary),
+    Job(Job),
+    Jobs(Vec<Job>),
+    Text(Option<String>),
+    SkillMirrors(Vec<SkillMirror>),
+    ArchiveStatus(ArchiveStatus),
+    Count(u32),
+    MaxAutoDownloadMb(u64),
+    Snapshot(Snapshot),
+    SsoConfig(SsoConfig),
+    Roots(Vec<RootInfo>),
+    Root(RootInfo),
+    File(Option<FileStateEvent>),
+    Templates(Vec<ProjectTemplate>),
+    Departments(Vec<Department>),
+    Shared(Vec<SharedItem>),
+    FailedUploads(Vec<FailedUpload>),
+    DiskUsage(DiskUsage),
+    Cleanup(CleanupReport),
+    OwnershipGuard(OwnershipGuard),
+    GrantTarget(Option<GrantTarget>),
+    Grants(GrantList),
+    GrantWrite(GrantWriteOutcome),
+    Users(Vec<UserBrief>),
+    AccessRequest(AccessRequestOutcome),
+    Id(Option<RemoteId>),
+    Path(Option<String>),
+    Done,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct Preferences {
+    pub session_archive: bool,
+    pub knowledge_inject: bool,
+}

package/rust/src/lib.rs

@@ -0,0 +1,5 @@
+//! Public Drive wire types and native service transport.
+pub mod contract;
+pub mod ownership;
+pub mod service;
+pub mod sync;

package/rust/src/ownership.rs

@@ -0,0 +1,4 @@
+use std::path::{Path, PathBuf};
+pub fn canonical_target(path: &Path) -> Result<PathBuf, String> {
+    alwith_native_client::Library::module("drive")?.call("drive.canonical_target", serde_json::json!({"path":path}))
+}

package/rust/src/service.rs

@@ -0,0 +1,140 @@
+use crate::contract::{DriveEvent, DriveRequest, DriveResponse, Snapshot};
+use alwith_native_client::{EventReader, Handle};
+use serde_json::{Value, json};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use tokio::sync::broadcast;
+pub type UrlOpener = Arc<dyn Fn(&str) -> Result<(), String> + Send + Sync>;
+pub struct ServiceOptions {
+    pub data_directory: PathBuf,
+    pub ownership_directory: PathBuf,
+    pub default_root: PathBuf,
+    pub reserved_roots: Vec<PathBuf>,
+    pub device_name: String,
+    pub client_version: String,
+    pub open_url: UrlOpener,
+}
+pub struct DriveService {
+    handle: Handle,
+    events: broadcast::Sender<DriveEvent>,
+    _reader: EventReader,
+}
+struct Transaction {
+    handle: Handle,
+    id: String,
+    finished: bool,
+}
+impl Drop for Transaction {
+    fn drop(&mut self) {
+        if !self.finished {
+            self.handle
+                .call::<()>("transaction_cancel", json!({"transaction_id":self.id}))
+                .expect("Native Drive transaction cancellation failed");
+        }
+    }
+}
+impl DriveService {
+    pub fn new(options: ServiceOptions) -> Result<Self, String> {
+        let handle = Handle::open(
+            "drive",
+            json!({"data_directory":options.data_directory,"ownership_directory":options.ownership_directory,"default_root":options.default_root,"reserved_roots":options.reserved_roots,"device_name":options.device_name,"client_version":options.client_version}),
+        )?;
+        let (events, _) = broadcast::channel(1024);
+        let sender = events.clone();
+        let replies = handle.clone();
+        let reader = EventReader::start::<Value>(handle.clone(), "next", "shutdown", move |event| {
+            let event = event.expect("Native Drive event stream failed");
+            match event["type"].as_str() {
+                Some("event") => {
+                    let _ = sender
+                        .send(serde_json::from_value(event["event"].clone()).expect("Invalid Drive event contract"));
+                }
+                Some("open_url") => {
+                    let url = event["url"].as_str().expect("Invalid Drive URL request");
+                    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| (options.open_url)(url)))
+                        .unwrap_or_else(|_| Err("Host URL opener panicked".into()));
+                    if let Err(error) =
+                        replies.call::<()>("reply", json!({"request_id":event["request_id"],"result":result}))
+                    {
+                        eprintln!("Native Drive URL response failed: {error}");
+                    }
+                }
+                _ => panic!("Unknown Drive host event"),
+            }
+        })?;
+        Ok(Self { handle, events, _reader: reader })
+    }
+    pub fn with_existing_default_root(self) -> Self {
+        self.handle.call::<()>("adopt_existing_default_root", json!({})).expect("Native Drive root adoption failed");
+        self
+    }
+    pub async fn set_skills_directory(&self, directory: PathBuf) -> Result<(), String> {
+        self.handle.call_async("set_skills_directory", json!({"directory":directory})).await
+    }
+    pub fn snapshot(&self) -> Snapshot {
+        self.handle.call("snapshot", json!({})).expect("Native Drive snapshot failed")
+    }
+    pub fn subscribe(&self) -> broadcast::Receiver<DriveEvent> {
+        self.events.subscribe()
+    }
+    pub async fn execute(&self, request: DriveRequest) -> Result<DriveResponse, String> {
+        self.handle.call_async("execute", json!({"request":request})).await
+    }
+    pub async fn move_between_projects(&self, source: &Path, destination: &Path) -> Result<bool, String> {
+        self.handle.call_async("move_between_projects", json!({"source":source,"destination":destination})).await
+    }
+    pub async fn with_move_to_filesystem<T, F>(
+        &self, sources: &[PathBuf], directory: &Path, operation: F,
+    ) -> Result<T, String>
+    where
+        F: std::future::Future<Output = Result<T, String>>,
+    {
+        self.transaction(
+            json!({"writes":[],"removed":[],"collaborative":null,"move_target":[sources,directory]}),
+            operation,
+        )
+        .await
+    }
+    pub async fn move_to_cloud_directory(
+        &self, sources: &[PathBuf], directory: &Path,
+    ) -> Result<(usize, Option<String>), String> {
+        self.handle.call_async("move_to_cloud_directory", json!({"sources":sources,"directory":directory})).await
+    }
+    pub async fn shutdown(&self) -> Result<(), String> {
+        self.handle.call_async("shutdown", json!({})).await
+    }
+    async fn transaction<T>(
+        &self, params: Value, operation: impl std::future::Future<Output = Result<T, String>>,
+    ) -> Result<T, String> {
+        // Allocate synchronously before the first await so cancellation always owns a revocable handle.
+        let id = self.handle.call("transaction_open", params)?;
+        let mut transaction = Transaction { handle: self.handle.clone(), id, finished: false };
+        self.handle.call_async::<()>("transaction_wait", json!({"transaction_id":transaction.id})).await?;
+        let result = operation.await;
+        let outcome = result.as_ref().map(|_| ()).map_err(Clone::clone);
+        // Finishing synchronously prevents cancellation between commit and handle retirement.
+        let finish =
+            self.handle.call::<()>("transaction_finish", json!({"transaction_id":transaction.id,"result":outcome}));
+        transaction.finished = true;
+        finish?;
+        result
+    }
+    pub async fn with_filesystem<T, F>(
+        &self, writes: &[PathBuf], removed: &[PathBuf], operation: F,
+    ) -> Result<T, String>
+    where
+        F: std::future::Future<Output = Result<T, String>>,
+    {
+        self.transaction(json!({"writes":writes,"removed":removed,"collaborative":null}), operation).await
+    }
+    pub async fn with_collaborative_filesystem<T, F>(
+        &self, path: &Path, owner_id: &str, operation: F,
+    ) -> Result<T, String>
+    where
+        F: std::future::Future<Output = Result<T, String>>,
+    {
+        self.transaction(json!({"writes":[],"removed":[],"collaborative":[path,owner_id]}), operation).await
+    }
+}