@anymux/connect 0.1.0

package/src/models/GitHostBrowserModel.ts

@@ -0,0 +1,89 @@
+import { makeAutoObservable, flow } from 'mobx';
+import type { IGitHost, PullRequest, Issue } from '@anymux/file-system';
+
+export type HostTab = 'prs' | 'issues';
+
+const PAGE_SIZE = 25;
+
+export class GitHostBrowserModel {
+  gitHost: IGitHost;
+
+  activeTab: HostTab = 'prs';
+  prs: PullRequest[] = [];
+  issues: Issue[] = [];
+  hasMorePrs = false;
+  hasMoreIssues = false;
+  page = 0;
+  loading = false;
+  error: string | null = null;
+
+  constructor(gitHost: IGitHost) {
+    this.gitHost = gitHost;
+    makeAutoObservable(this, { gitHost: false });
+  }
+
+  get currentItems() {
+    return this.activeTab === 'prs' ? this.prs : this.issues;
+  }
+
+  get hasMore() {
+    return this.activeTab === 'prs' ? this.hasMorePrs : this.hasMoreIssues;
+  }
+
+  get showPagination() {
+    return this.page > 0 || this.hasMore;
+  }
+
+  setActiveTab(tab: HostTab) {
+    this.activeTab = tab;
+    this.page = 0;
+    this.loadData();
+  }
+
+  nextPage() {
+    if (!this.hasMore) return;
+    this.page += 1;
+    this.loadData();
+  }
+
+  prevPage() {
+    if (this.page <= 0) return;
+    this.page -= 1;
+    this.loadData();
+  }
+
+  retry() {
+    this.error = null;
+    this.page = 0;
+    this.loadData();
+  }
+
+  loadData = flow(function* loadData(this: GitHostBrowserModel) {
+    this.loading = true;
+    this.error = null;
+
+    try {
+      if (this.activeTab === 'prs') {
+        const data: PullRequest[] = yield this.gitHost.listPullRequests({
+          state: 'all',
+          maxResults: PAGE_SIZE * (this.page + 1),
+        });
+        const start = this.page * PAGE_SIZE;
+        this.prs = data.slice(start, start + PAGE_SIZE);
+        this.hasMorePrs = data.length > start + PAGE_SIZE;
+      } else {
+        const data: Issue[] = yield this.gitHost.listIssues({
+          state: 'all',
+          maxResults: PAGE_SIZE * (this.page + 1),
+        });
+        const start = this.page * PAGE_SIZE;
+        this.issues = data.slice(start, start + PAGE_SIZE);
+        this.hasMoreIssues = data.length > start + PAGE_SIZE;
+      }
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : 'Failed to load data';
+    } finally {
+      this.loading = false;
+    }
+  });
+}

package/src/models/GitRepoBrowserModel.ts

@@ -0,0 +1,285 @@
+import { makeAutoObservable, flow } from 'mobx';
+import type {
+  IGitRepo,
+  IGitHost,
+  GitBranch,
+  GitTag,
+  GitCommit,
+  GitDiffEntry,
+  IFileSystem,
+  PullRequest,
+  Issue,
+} from '@anymux/file-system';
+
+export type SidebarTab = 'files' | 'branches' | 'commits' | 'prs' | 'issues';
+
+const HOST_PAGE_SIZE = 25;
+const COMMITS_PAGE_SIZE = 25;
+
+export class GitRepoBrowserModel {
+  // --- Core repo state ---
+  branches: GitBranch[] = [];
+  tags: GitTag[] = [];
+  currentRef = '';
+  fileSystem: IFileSystem | null = null;
+  loading = true;
+  error: string | null = null;
+
+  // --- Tab state ---
+  activeTab: SidebarTab = 'files';
+
+  // --- Commits state ---
+  commits: GitCommit[] = [];
+  commitsLoading = false;
+  commitsPage = 0;
+  hasMoreCommits = false;
+
+  // --- Diff state ---
+  selectedCommitSha: string | undefined = undefined;
+  diffEntries: GitDiffEntry[] = [];
+  diffLoading = false;
+
+  // --- Host data (PRs / Issues) ---
+  prs: PullRequest[] = [];
+  issues: Issue[] = [];
+  hostLoading = false;
+  hostError: string | null = null;
+  prPage = 0;
+  issuePage = 0;
+  hasMorePrs = false;
+  hasMoreIssues = false;
+
+  constructor(
+    private gitRepo: IGitRepo,
+    private _gitHost: IGitHost | undefined,
+    private createFileSystem: (branch: string) => Promise<IFileSystem>,
+    private onError?: (err: { message: string }) => void,
+  ) {
+    makeAutoObservable(this, {
+      // Mark constructor deps as non-observable (they are stable references)
+    });
+  }
+
+  /** Update the gitHost adapter (e.g. when loaded asynchronously after construction) */
+  setGitHost(host: IGitHost): void {
+    this._gitHost = host;
+  }
+
+  // --- Computed ---
+
+  get headSha(): string | undefined {
+    return this.branches.find((b) => b.name === this.currentRef)?.sha;
+  }
+
+  get hasGitHost(): boolean {
+    return !!this._gitHost;
+  }
+
+  // --- Actions ---
+
+  setActiveTab(tab: SidebarTab): void {
+    this.activeTab = tab;
+
+    // Trigger data loading for the newly active tab
+    if (tab === 'commits' && this.currentRef) {
+      this.loadCommits();
+    } else if (tab === 'prs' && this._gitHost) {
+      this.loadPRs();
+    } else if (tab === 'issues' && this._gitHost) {
+      this.loadIssues();
+    }
+  }
+
+  // --- Async flows ---
+
+  initialize = flow(function* (this: GitRepoBrowserModel) {
+    this.loading = true;
+    this.error = null;
+
+    try {
+      const [branchList, tagList]: [GitBranch[], GitTag[]] = yield Promise.all([
+        this.gitRepo.listBranches(),
+        this.gitRepo.listTags().catch(() => [] as GitTag[]),
+      ]);
+
+      this.branches = branchList;
+      this.tags = tagList;
+
+      // Pick default branch
+      const defaultBranch = branchList.find((b) => b.isDefault);
+      const initialRef = defaultBranch?.name ?? branchList[0]?.name ?? 'main';
+      this.currentRef = initialRef;
+
+      // Create file system for the default branch
+      const fs: IFileSystem = yield this.createFileSystem(initialRef);
+      this.fileSystem = fs;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Failed to load repository';
+      this.error = msg;
+      this.onError?.({ message: msg });
+    } finally {
+      this.loading = false;
+    }
+  });
+
+  switchRef = flow(function* (this: GitRepoBrowserModel, ref: string) {
+    if (ref === this.currentRef) return;
+
+    this.currentRef = ref;
+    this.loading = true;
+    this.error = null;
+    this.selectedCommitSha = undefined;
+    this.diffEntries = [];
+    this.commitsPage = 0;
+
+    try {
+      const fs: IFileSystem = yield this.createFileSystem(ref);
+      this.fileSystem = fs;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Failed to switch ref';
+      this.error = msg;
+      this.onError?.({ message: msg });
+    } finally {
+      this.loading = false;
+    }
+
+    // Reload commits if the commits tab is active
+    if (this.activeTab === 'commits') {
+      this.loadCommits();
+    }
+  });
+
+  loadCommits = flow(function* (this: GitRepoBrowserModel) {
+    if (!this.currentRef) return;
+
+    this.commitsLoading = true;
+    try {
+      const fetchCount = COMMITS_PAGE_SIZE * (this.commitsPage + 1);
+      const commitList: GitCommit[] = yield this.gitRepo.listCommits({
+        ref: this.currentRef,
+        maxCount: fetchCount + 1, // Fetch one extra to detect if more exist
+      });
+      const start = this.commitsPage * COMMITS_PAGE_SIZE;
+      this.commits = commitList.slice(start, start + COMMITS_PAGE_SIZE);
+      this.hasMoreCommits = commitList.length > start + COMMITS_PAGE_SIZE;
+    } catch (err) {
+      console.error('[GitRepoBrowserModel] Failed to load commits:', err);
+      this.commits = [];
+      this.hasMoreCommits = false;
+    } finally {
+      this.commitsLoading = false;
+    }
+  });
+
+  selectCommit = flow(function* (this: GitRepoBrowserModel, commit: GitCommit) {
+    this.selectedCommitSha = commit.sha;
+
+    if (commit.parents.length === 0) {
+      this.diffEntries = [];
+      return;
+    }
+
+    this.diffLoading = true;
+    try {
+      const entries: GitDiffEntry[] = yield this.gitRepo.diff(
+        commit.parents[0]!,
+        commit.sha,
+      );
+      this.diffEntries = entries;
+    } catch {
+      this.diffEntries = [];
+    } finally {
+      this.diffLoading = false;
+    }
+  });
+
+  loadPRs = flow(function* (this: GitRepoBrowserModel) {
+    if (!this._gitHost) return;
+
+    this.hostLoading = true;
+    this.hostError = null;
+    try {
+      const data: PullRequest[] = yield this._gitHost.listPullRequests({
+        state: 'all',
+        maxResults: HOST_PAGE_SIZE * (this.prPage + 1),
+      });
+      const start = this.prPage * HOST_PAGE_SIZE;
+      this.prs = data.slice(start, start + HOST_PAGE_SIZE);
+      this.hasMorePrs = data.length > start + HOST_PAGE_SIZE;
+    } catch (err) {
+      this.hostError = err instanceof Error ? err.message : 'Failed to load';
+    } finally {
+      this.hostLoading = false;
+    }
+  });
+
+  loadIssues = flow(function* (this: GitRepoBrowserModel) {
+    if (!this._gitHost) return;
+
+    this.hostLoading = true;
+    this.hostError = null;
+    try {
+      const data: Issue[] = yield this._gitHost.listIssues({
+        state: 'all',
+        maxResults: HOST_PAGE_SIZE * (this.issuePage + 1),
+      });
+      const start = this.issuePage * HOST_PAGE_SIZE;
+      this.issues = data.slice(start, start + HOST_PAGE_SIZE);
+      this.hasMoreIssues = data.length > start + HOST_PAGE_SIZE;
+    } catch (err) {
+      this.hostError = err instanceof Error ? err.message : 'Failed to load';
+    } finally {
+      this.hostLoading = false;
+    }
+  });
+
+  // --- Pagination helpers ---
+
+  nextCommitsPage(): void {
+    this.commitsPage += 1;
+    this.loadCommits();
+  }
+
+  prevCommitsPage(): void {
+    this.commitsPage = Math.max(0, this.commitsPage - 1);
+    this.loadCommits();
+  }
+
+  nextPrPage(): void {
+    this.prPage += 1;
+    this.loadPRs();
+  }
+
+  prevPrPage(): void {
+    this.prPage = Math.max(0, this.prPage - 1);
+    this.loadPRs();
+  }
+
+  nextIssuePage(): void {
+    this.issuePage += 1;
+    this.loadIssues();
+  }
+
+  prevIssuePage(): void {
+    this.issuePage = Math.max(0, this.issuePage - 1);
+    this.loadIssues();
+  }
+
+  retryPRs(): void {
+    this.hostError = null;
+    this.prPage = 0;
+    this.loadPRs();
+  }
+
+  retryIssues(): void {
+    this.hostError = null;
+    this.issuePage = 0;
+    this.loadIssues();
+  }
+
+  // --- Branch selection from BranchList tab ---
+
+  selectBranch(branch: GitBranch): void {
+    this.switchRef(branch.name);
+  }
+}

package/src/models/ObjectStorageBrowserModel.ts

@@ -0,0 +1,131 @@
+import { makeAutoObservable, flow } from 'mobx';
+import type { IObjectStorage } from '@anymux/file-system';
+
+const OBJ_PAGE_SIZE = 100;
+
+export interface DisplayObject {
+  key: string;
+  size?: number;
+  lastModified?: Date;
+  isPrefix: boolean;
+}
+
+export class ObjectStorageBrowserModel {
+  storage: IObjectStorage;
+  bucket: string;
+
+  prefix = '';
+  objects: DisplayObject[] = [];
+  loading = false;
+  error: string | null = null;
+  continuationToken: string | undefined = undefined;
+  tokenHistory: (string | undefined)[] = [];
+  page = 0;
+  hasMore = false;
+
+  constructor(storage: IObjectStorage, bucket: string) {
+    this.storage = storage;
+    this.bucket = bucket;
+    makeAutoObservable(this, { storage: false });
+  }
+
+  get breadcrumbs(): Array<{ label: string; prefix: string }> {
+    return this.prefix
+      .split('/')
+      .filter(Boolean)
+      .reduce<Array<{ label: string; prefix: string }>>((acc, part, i) => {
+        const prev = acc[i - 1]?.prefix || '';
+        acc.push({ label: part, prefix: prev + part + '/' });
+        return acc;
+      }, []);
+  }
+
+  displayName(key: string): string {
+    return key.slice(this.prefix.length).replace(/\/$/, '');
+  }
+
+  loadObjects = flow(function* loadObjects(this: ObjectStorageBrowserModel, token?: string) {
+    this.loading = true;
+    this.error = null;
+
+    try {
+      const result = yield this.storage.listObjects(this.bucket, {
+        prefix: this.prefix || undefined,
+        delimiter: '/',
+        maxKeys: OBJ_PAGE_SIZE,
+        continuationToken: token,
+      });
+
+      const prefixItems: DisplayObject[] = result.commonPrefixes.map((p: string) => ({
+        key: p,
+        isPrefix: true,
+      }));
+
+      const objectItems: DisplayObject[] = result.objects.map((obj: any) => ({
+        key: obj.key,
+        size: obj.metadata.size,
+        lastModified: obj.metadata.lastModified,
+        isPrefix: false,
+      }));
+
+      this.objects = [...prefixItems, ...objectItems];
+      this.hasMore = result.isTruncated;
+      this.continuationToken = result.nextContinuationToken;
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : 'Failed to load objects';
+    } finally {
+      this.loading = false;
+    }
+  });
+
+  initialize = flow(function* initialize(this: ObjectStorageBrowserModel) {
+    this.page = 0;
+    this.tokenHistory = [];
+    this.continuationToken = undefined;
+    yield this.loadObjects();
+  });
+
+  navigateToPrefix(newPrefix: string) {
+    this.prefix = newPrefix;
+    this.page = 0;
+    this.tokenHistory = [];
+    this.continuationToken = undefined;
+    this.loadObjects();
+  }
+
+  navigateUp() {
+    const parts = this.prefix.replace(/\/$/, '').split('/');
+    parts.pop();
+    this.navigateToPrefix(parts.length > 0 ? parts.join('/') + '/' : '');
+  }
+
+  nextPage() {
+    if (!this.hasMore || !this.continuationToken) return;
+    this.tokenHistory = [...this.tokenHistory, this.continuationToken];
+    this.page += 1;
+    this.loadObjects(this.continuationToken);
+  }
+
+  prevPage() {
+    if (this.page <= 0) return;
+    const newHistory = [...this.tokenHistory];
+    newHistory.pop();
+    const prevToken = newHistory.length > 0 ? newHistory[newHistory.length - 1] : undefined;
+    this.tokenHistory = newHistory;
+    this.page -= 1;
+    this.loadObjects(prevToken);
+  }
+
+  download = flow(function* download(this: ObjectStorageBrowserModel, key: string) {
+    try {
+      const url: string = yield this.storage.getPresignedUrl(this.bucket, key);
+      window.open(url, '_blank');
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : 'Failed to generate download URL';
+    }
+  });
+
+  refresh() {
+    this.loadObjects();
+  }
+}

package/src/models/RepoPickerModel.ts

@@ -0,0 +1,132 @@
+import { makeAutoObservable, flow, computed } from 'mobx';
+import { match } from 'ts-pattern';
+
+export interface RepoInfo {
+  fullName: string;
+  description: string | null;
+  language: string | null;
+  isPrivate: boolean;
+}
+
+export class RepoPickerModel {
+  serviceId: string;
+  accessToken: string;
+
+  repos: RepoInfo[] = [];
+  loading = true;
+  error: string | null = null;
+  search = '';
+
+  constructor(serviceId: string, accessToken: string) {
+    this.serviceId = serviceId;
+    this.accessToken = accessToken;
+    makeAutoObservable(this, {});
+  }
+
+  get filtered(): RepoInfo[] {
+    const q = this.search.toLowerCase();
+    if (!q) return this.repos;
+    return this.repos.filter((r) => r.fullName.toLowerCase().includes(q));
+  }
+
+  setSearch(value: string) {
+    this.search = value;
+  }
+
+  loadRepos = flow(function* loadRepos(this: RepoPickerModel) {
+    this.loading = true;
+    this.error = null;
+    try {
+      const data: RepoInfo[] = yield fetchRepos(this.serviceId, this.accessToken);
+      this.repos = data;
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : 'Failed to fetch repos';
+    } finally {
+      this.loading = false;
+    }
+  });
+}
+
+// --- Fetch helpers ---
+
+async function fetchRepos(serviceId: string, token: string): Promise<RepoInfo[]> {
+  return match(serviceId)
+    .with('github', () => fetchGitHubRepos(token))
+    .with('gitlab', () => fetchGitLabRepos(token))
+    .with('bitbucket', () => fetchBitbucketRepos(token))
+    .with('gitea', () => fetchGiteaRepos(token))
+    .otherwise(() => { throw new Error(`Repo picker not supported for: ${serviceId}`); });
+}
+
+async function fetchGitHubRepos(token: string): Promise<RepoInfo[]> {
+  const res = await fetch('https://api.github.com/user/repos?sort=updated&per_page=50', {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!res.ok) throw new Error(`GitHub API error: ${res.status}`);
+  const data: Array<{ full_name: string; description: string | null; language: string | null; private: boolean }> = await res.json();
+  return data.map((r) => ({
+    fullName: r.full_name,
+    description: r.description,
+    language: r.language,
+    isPrivate: r.private,
+  }));
+}
+
+async function fetchGitLabRepos(token: string): Promise<RepoInfo[]> {
+  const res = await fetch('https://gitlab.com/api/v4/projects?membership=true&order_by=updated_at&per_page=50', {
+    headers: { 'PRIVATE-TOKEN': token },
+  });
+  if (!res.ok) throw new Error(`GitLab API error: ${res.status}`);
+  const data: Array<{ path_with_namespace: string; description: string | null; visibility: string }> = await res.json();
+  return data.map((r) => ({
+    fullName: r.path_with_namespace,
+    description: r.description,
+    language: null,
+    isPrivate: r.visibility === 'private',
+  }));
+}
+
+async function fetchBitbucketRepos(token: string): Promise<RepoInfo[]> {
+  const res = await fetch('https://api.bitbucket.org/2.0/repositories?role=member&pagelen=50', {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!res.ok) throw new Error(`Bitbucket API error: ${res.status}`);
+  const data: { values: Array<{ full_name: string; description: string; language: string; is_private: boolean }> } = await res.json();
+  return data.values.map((r) => ({
+    fullName: r.full_name,
+    description: r.description || null,
+    language: r.language || null,
+    isPrivate: r.is_private,
+  }));
+}
+
+async function fetchGiteaRepos(token: string): Promise<RepoInfo[]> {
+  const creds = JSON.parse(token);
+  const headers: HeadersInit = {
+    'Accept': 'application/json',
+  };
+  // Use token auth if available, otherwise Basic auth
+  if (creds.token) {
+    headers['Authorization'] = `token ${creds.token}`;
+  } else if (creds.username && creds.password) {
+    headers['Authorization'] = 'Basic ' + btoa(`${creds.username}:${creds.password}`);
+  }
+  // Route through CORS proxy when in browser
+  const proxyUrl = typeof window !== 'undefined' ? window.location.origin : undefined;
+  let url: string;
+  if (proxyUrl) {
+    url = `${proxyUrl}/api/gitea/api/v1/user/repos?limit=50`;
+    headers['x-gitea-url'] = creds.url;
+  } else {
+    url = `${creds.url}/api/v1/user/repos?limit=50`;
+  }
+  const res = await fetch(url, { headers });
+  if (!res.ok) throw new Error(`Gitea API error: ${res.status}`);
+  const data: Array<{ full_name: string; description: string; language: string; private: boolean }> = await res.json();
+  return data.map((r) => ({
+    fullName: r.full_name,
+    description: r.description || null,
+    language: r.language || null,
+    isPrivate: r.private,
+  }));
+}

package/src/registry/service-registry.ts

@@ -0,0 +1,46 @@
+import type { CapabilityId, ServiceDefinition } from '../types/service';
+import { googleService } from './services/google';
+import { dropboxService } from './services/dropbox';
+import { githubService } from './services/github';
+import { s3Service } from './services/s3';
+import { webdavService } from './services/webdav';
+import { gitlabService } from './services/gitlab';
+import { bitbucketService } from './services/bitbucket';
+import { giteaService } from './services/gitea';
+import { browserFsService } from './services/browser-fs';
+import { indexeddbService } from './services/indexeddb';
+import { boxService } from './services/box';
+
+const services = new Map<string, ServiceDefinition>();
+
+function register(service: ServiceDefinition) {
+  services.set(service.id, service);
+}
+
+register(googleService);
+register(dropboxService);
+register(githubService);
+register(s3Service);
+register(webdavService);
+register(gitlabService);
+register(bitbucketService);
+register(giteaService);
+register(browserFsService);
+register(indexeddbService);
+register(boxService);
+
+export const serviceRegistry = {
+  get(id: string): ServiceDefinition | undefined {
+    return services.get(id);
+  },
+
+  getAll(): ServiceDefinition[] {
+    return Array.from(services.values());
+  },
+
+  getByCapability(capability: CapabilityId): ServiceDefinition[] {
+    return Array.from(services.values()).filter((s) =>
+      s.capabilities.some((c) => c.id === capability && c.supported)
+    );
+  },
+};

package/src/registry/services/apple.ts

@@ -0,0 +1,22 @@
+import type { ServiceDefinition } from '../../types/service';
+
+export const appleService: ServiceDefinition = {
+  id: 'apple',
+  name: 'Apple',
+  icon: 'Apple',
+  color: '#000000',
+  authProvider: 'apple',
+  grantsUrl: 'https://appleid.apple.com/account/manage/security',
+  capabilities: [
+    { id: 'file-system', supported: false },
+    { id: 'object-storage', supported: false },
+    { id: 'git-repo', supported: false },
+    { id: 'git-host', supported: false },
+    { id: 'media', supported: false },
+    { id: 'contacts', supported: false },
+    { id: 'calendar', supported: false },
+  ],
+  // Apple currently only provides identity/auth.
+  // Future: CalDAV for calendar, CardDAV for contacts, iCloud Drive for file-system
+  scopes: {},
+};