@mdfriday/foundry 26.3.7 → 26.3.9

package/dist/internal/application/container.d.ts

@@ -0,0 +1,9 @@
+import { WorkspaceFactory } from '@internal/domain/workspace';
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { HttpClient as IdentityHttpClient } from '@internal/domain/identity';
+import { IdentityAppService } from '@internal/application/identity';
+export declare function createWorkspaceFactory(): WorkspaceFactory;
+export declare function createWorkspaceAppService(): WorkspaceAppService;
+export declare function createIdentityService(workspacePath?: string): Promise<IdentityAppService>;
+export declare function createIdentityServiceForObsidian(workspacePath: string, httpClient: IdentityHttpClient): Promise<IdentityAppService>;
+export declare function createPublishAppService(): any;

package/dist/internal/application/index.d.ts

@@ -0,0 +1,4 @@
+export { WorkspaceAppService } from './workspace';
+export { PublishAppService } from './publish';
+export { IdentityAppService } from './identity';
+export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createPublishAppService, } from './container';

package/dist/internal/application/publish.d.ts

@@ -1,11 +1,6 @@
-import { PublisherFactory } from '@internal/domain/publish';
+import { PublisherFactory, AnyPublishConfig } from '@internal/domain/publish';
 import { WorkspaceAppService } from './workspace';
-import { Project } from '@internal/domain/workspace';
-export interface PublishOptions {
-    force?: boolean;
-    incremental?: boolean;
-    config?: any;
-}
+import { Workspace, Project } from '@internal/domain/workspace';
 export type PublishProgressCallback = (progress: {
     phase: 'scanning' | 'uploading' | 'deploying' | 'complete';
     percentage: number;
@@ -19,10 +14,14 @@ export declare class PublishAppService {
     private publisherFactory;
     private workspaceService;
     constructor(publisherFactory: PublisherFactory, workspaceService: WorkspaceAppService);
-    publish(project: Project, method: 'ftp' | 'netlify' | 'mdfriday', options?: PublishOptions, onProgress?: PublishProgressCallback): Promise<any>;
-    testConnection(project: Project, method: 'ftp' | 'netlify' | 'mdfriday'): Promise<{
+    publish(project: Project, config: AnyPublishConfig, options?: {
+        force?: boolean;
+        incremental?: boolean;
+    }, onProgress?: PublishProgressCallback): Promise<any>;
+    testConnection(project: Project, config: AnyPublishConfig): Promise<{
         success: boolean;
         error?: string;
     }>;
+    prepareFinalConfig(workspace: Workspace, project: Project, method: 'ftp' | 'netlify' | 'mdfriday'): Promise<AnyPublishConfig>;
     private getMethodConfig;
 }

package/dist/internal/application/workspace.d.ts

@@ -26,4 +26,15 @@ export declare class WorkspaceAppService {
     saveProject(project: Project): Promise<void>;
     findProjectRoot(startPath: string): Promise<string | null>;
     createIdentityStorage(workspace: Workspace): import("../domain/identity").IdentityStorageProvider;
+    setupProjectBaseURLStructure(project: Project): Promise<{
+        serverRoot: string;
+        baseURL: string;
+        symlinkCreated: boolean;
+    }>;
+    cleanProjectBaseURLStructure(project: Project): Promise<void>;
+    ensureProjectBaseURLStructure(project: Project): Promise<{
+        serverRoot: string;
+        baseURL: string;
+        recreated: boolean;
+    }>;
 }

package/dist/internal/domain/workspace/entity/project.d.ts

@@ -80,4 +80,23 @@ export declare class Project {
     getSupportedLanguagesFromLinks(): string[];
     isLinkedProject(): boolean;
     getLinkDirs(): string[];
+    getBaseURL(): Promise<string>;
+    setBaseURL(baseURL: string): Promise<void>;
+    parseBaseURLPath(baseURL: string): {
+        isRoot: boolean;
+        pathParts: string[];
+        parentParts: string[];
+        finalDirName: string;
+        relativeToPublic: string;
+    };
+    getBaseURLStructure(): {
+        baseURL: string;
+        createdAt: number;
+        pathParts: string[];
+    } | null;
+    updateBaseURLStructure(info: {
+        baseURL: string;
+        createdAt: number;
+        pathParts: string[];
+    } | null): void;
 }

package/dist/internal/domain/workspace/factory/workspace-factory.d.ts

@@ -32,6 +32,7 @@ export declare class WorkspaceFactory {
         contentDir?: string;
         staticDir?: string;
         publishDir?: string;
+        baseURL?: string;
     }): Promise<Project>;
     deleteProject(workspace: Workspace, projectIdOrName: string, options?: {
         deleteFiles?: boolean;
@@ -53,5 +54,16 @@ export declare class WorkspaceFactory {
     deleteSnapshot(project: Project, snapshotId: string): Promise<void>;
     getSnapshot(project: Project, snapshotId: string): Promise<SnapshotMetadata>;
     createIdentityStorage(workspace: Workspace): IdentityStorageProvider;
+    setupBaseURLStructure(project: Project): Promise<{
+        serverRoot: string;
+        baseURL: string;
+        symlinkCreated: boolean;
+    }>;
+    cleanBaseURLStructure(project: Project): Promise<void>;
+    ensureBaseURLStructure(project: Project): Promise<{
+        serverRoot: string;
+        baseURL: string;
+        recreated: boolean;
+    }>;
     private createSampleContent;
 }

package/dist/internal/domain/workspace/repository/file-system.d.ts

@@ -53,6 +53,7 @@ export interface FileSystemRepository {
     unlink(path: string): Promise<void>;
     access(path: string): Promise<void>;
     resolvePath(path: string): Promise<string>;
+    remove(targetPath: string, recursive?: boolean): Promise<void>;
     basename(path: string): string;
     dirname(path: string): string;
     join(...paths: string[]): string;

package/dist/internal/domain/workspace/value-object/project-metadata.d.ts

@@ -37,6 +37,11 @@ export declare class ProjectMetadata {
     readonly contentLinks: ContentLink[];
     readonly staticLink: StaticLink | null;
     readonly fileLink: FileLink | null;
+    readonly baseURLStructure: {
+        baseURL: string;
+        createdAt: number;
+        pathParts: string[];
+    } | null;
     private constructor();
     static create(data: {
         id: string;
@@ -57,6 +62,11 @@ export declare class ProjectMetadata {
         contentLinks: ContentLink[];
         staticLink: StaticLink | null;
         fileLink: FileLink | null;
+        baseURLStructure: {
+            baseURL: string;
+            createdAt: number;
+            pathParts: string[];
+        } | null;
     }>): ProjectMetadata;
     toJSON(): any;
 }

package/dist/internal/interfaces/cli/commands/publish.d.ts

@@ -5,16 +5,6 @@ export interface PublishOptions {
     project?: string;
     force?: boolean;
     verbose?: boolean;
-    host?: string;
-    port?: number;
-    username?: string;
-    password?: string;
-    remotePath?: string;
-    secure?: boolean;
-    siteId?: string;
-    token?: string;
-    type?: 'share' | 'sub' | 'custom' | 'enterprise';
-    licenseKey?: string;
 }
 export declare class PublishCommand implements Command {
     private publishService;
@@ -23,5 +13,5 @@ export declare class PublishCommand implements Command {
     description: string;
     constructor(publishService: PublishAppService, workspaceAppService: WorkspaceAppService);
     execute(args: string[], options: PublishOptions): Promise<CommandResult>;
-    private parseConfigOverride;
+    private executeTest;
 }

package/dist/internal/interfaces/cli/container.d.ts

@@ -1,7 +1 @@
-import { WorkspaceFactory } from '@internal/domain/workspace';
-import { WorkspaceAppService } from '@internal/application/workspace';
-import { IdentityAppService } from '@internal/application/identity';
-export declare function createWorkspaceFactory(): WorkspaceFactory;
-export declare function createWorkspaceAppService(): WorkspaceAppService;
-export declare function createIdentityService(projectPath?: string): Promise<IdentityAppService>;
-export declare function createPublishAppService(): any;
+export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createIdentityServiceForObsidian, createPublishAppService, } from '@internal/application/container';

package/dist/internal/interfaces/cli/types.d.ts

@@ -23,6 +23,7 @@ export interface ProjectCreateOptions {
     path?: string;
     source?: string;
     sourceFile?: string;
+    baseUrl?: string;
     noSample?: boolean;
     interactive?: boolean;
 }
@@ -47,6 +48,4 @@ export interface ServeOptions {
     livereloadPort?: number;
     publish?: 'ftp' | 'netlify' | 'mdfriday';
     publishDelay?: number;
-    type?: 'share' | 'sub' | 'custom' | 'enterprise';
-    licenseKey?: string;
 }

package/dist/internal/interfaces/obsidian/auth.d.ts

@@ -1,4 +1,5 @@
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
+import { IdentityAppService } from '@internal/application/identity';
+import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianAuthStatus {
     isAuthenticated: boolean;
     email?: string;
@@ -16,11 +17,10 @@ export interface ObsidianAuthResult<T = void> {
     error?: string;
 }
 export declare class ObsidianAuthService {
-    private httpClient;
-    constructor(httpClient?: HttpClient);
+    private identityService;
+    constructor(identityService: IdentityAppService);
     getStatus(): Promise<ObsidianAuthResult<ObsidianAuthStatus>>;
     getConfig(): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
     updateConfig(config: ObsidianServerConfig): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
-    private getIdentityService;
 }
-export declare function createObsidianAuthService(httpClient?: HttpClient): ObsidianAuthService;
+export declare function createObsidianAuthService(workspacePath: string, httpClient: HttpClient): Promise<ObsidianAuthService>;

package/dist/internal/interfaces/obsidian/container.d.ts

@@ -1,4 +1,4 @@
-import { WorkspaceFactory } from '@internal/domain/workspace';
-import { WorkspaceAppService } from '@internal/application/workspace';
-export declare function createWorkspaceFactory(): WorkspaceFactory;
-export declare function createWorkspaceAppService(): WorkspaceAppService;
+import { HttpClient } from "@internal/domain/identity";
+import { IdentityAppService } from "@internal/application";
+export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createIdentityServiceForObsidian, createPublishAppService, } from '@internal/application/container';
+export declare function getIdentityService(workspacePath: string, httpClient: HttpClient): Promise<IdentityAppService>;

package/dist/internal/interfaces/obsidian/domain.d.ts

@@ -1,4 +1,5 @@
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
+import { IdentityAppService } from '@internal/application/identity';
+import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianDomainInfo {
     subdomain: string;
     fullDomain: string;
@@ -46,14 +47,13 @@ export interface ObsidianDomainResult<T = void> {
     error?: string;
 }
 export declare class ObsidianDomainService {
-    private httpClient;
-    constructor(httpClient?: HttpClient);
+    private identityService;
+    constructor(identityService: IdentityAppService);
     getDomainInfo(): Promise<ObsidianDomainResult<ObsidianDomainInfo>>;
     checkSubdomain(subdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainCheckResult>>;
     updateSubdomain(newSubdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainUpdateResult>>;
     checkCustomDomain(domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainCheckResult>>;
     addCustomDomain(domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainAddResult>>;
     checkHttpsStatus(domain: string): Promise<ObsidianDomainResult<ObsidianHttpsStatusResult>>;
-    private getIdentityService;
 }
-export declare function createObsidianDomainService(httpClient?: HttpClient): ObsidianDomainService;
+export declare function createObsidianDomainService(workspacePath: string, httpClient: HttpClient): Promise<ObsidianDomainService>;

package/dist/internal/interfaces/obsidian/index.d.ts

@@ -8,4 +8,6 @@ export { ObsidianLicenseService, createObsidianLicenseService, ObsidianLicenseIn
 export { ObsidianAuthService, createObsidianAuthService, ObsidianAuthStatus, ObsidianServerConfig, ObsidianAuthResult, } from './auth';
 export { ObsidianDomainService, createObsidianDomainService, ObsidianDomainInfo, ObsidianSubdomainCheckResult, ObsidianSubdomainUpdateResult, ObsidianCustomDomainCheckResult, ObsidianCustomDomainAddResult, ObsidianHttpsCertificate, ObsidianHttpsStatusResult, ObsidianDomainResult, } from './domain';
 export { createWorkspaceAppService, createWorkspaceFactory, } from './container';
-export type { HttpClient, HttpResponse } from '@internal/domain/publish/repository/http-client';
+export type { HttpClient as PublishHttpClient, HttpResponse as PublishHttpResponse } from '@internal/domain/publish/repository/http-client';
+export type { HttpClient as IdentityHttpClient, HttpResponse as IdentityHttpResponse } from '@internal/domain/identity';
+export type { AnyPublishConfig, FTPConfig, NetlifyConfig, MDFridayConfig, } from '@internal/domain/publish';

package/dist/internal/interfaces/obsidian/license.d.ts

@@ -1,5 +1,5 @@
-import { WorkspaceAppService } from '@internal/application/workspace';
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
+import { IdentityAppService } from '@internal/application/identity';
+import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianLicenseInfo {
     key: string;
     plan: string;
@@ -60,9 +60,8 @@ export interface ObsidianLicenseResult<T = any> {
     error?: string;
 }
 export declare class ObsidianLicenseService {
-    private workspaceAppService;
-    private httpClient;
-    constructor(workspaceAppService: WorkspaceAppService, httpClient?: HttpClient);
+    private identityService;
+    constructor(identityService: IdentityAppService);
     requestTrial(email: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
     loginWithLicense(licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
     activateLicense(licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
@@ -70,7 +69,6 @@ export declare class ObsidianLicenseService {
     getLicenseUsage(): Promise<ObsidianLicenseResult<ObsidianLicenseUsage>>;
     resetUsage(force: boolean): Promise<ObsidianLicenseResult<any>>;
     hasActiveLicense(): Promise<boolean>;
-    private getIdentityService;
     private buildLicenseInfo;
 }
-export declare function createObsidianLicenseService(httpClient?: HttpClient): ObsidianLicenseService;
+export declare function createObsidianLicenseService(workspacePath: string, httpClient: HttpClient): Promise<ObsidianLicenseService>;

package/dist/internal/interfaces/obsidian/publish.d.ts

@@ -1,13 +1,14 @@
 import { PublishAppService } from '@internal/application/publish';
 import { WorkspaceAppService } from '@internal/application/workspace';
+import { AnyPublishConfig } from '@internal/domain/publish';
 import { HttpClient } from '@internal/domain/publish/repository/http-client';
 export type ObsidianPublishMethod = 'ftp' | 'netlify' | 'mdfriday';
 export interface ObsidianPublishOptions {
     workspacePath: string;
     projectName: string;
     method: ObsidianPublishMethod;
+    config: AnyPublishConfig;
     force?: boolean;
-    config?: any;
 }
 export interface ObsidianPublishProgress {
     phase: 'scanning' | 'uploading' | 'deploying' | 'complete';
@@ -38,6 +39,6 @@ export declare class ObsidianPublishService {
     private workspaceAppService;
     constructor(publishAppService: PublishAppService, workspaceAppService: WorkspaceAppService);
     publish(options: ObsidianPublishOptions, onProgress?: (progress: ObsidianPublishProgress) => void): Promise<ObsidianPublishResult>;
-    testConnection(workspacePath: string, projectName: string, method: ObsidianPublishMethod): Promise<ObsidianTestConnectionResult>;
+    testConnection(workspacePath: string, projectName: string, config: AnyPublishConfig): Promise<ObsidianTestConnectionResult>;
 }
 export declare function createObsidianPublishService(httpClient: HttpClient): ObsidianPublishService;

package/dist/internal/interfaces/obsidian/serve.d.ts

@@ -2,6 +2,7 @@ import { WorkspaceAppService } from '@internal/application/workspace';
 import { PublishAppService } from '@internal/application/publish';
 import { HttpClient } from '@internal/domain/publish/repository/http-client';
 import { MarkdownRenderer } from '@internal/domain/markdown';
+import { AnyPublishConfig } from '@internal/domain/publish';
 export interface ObsidianServeOptions {
     workspacePath: string;
     projectName: string;
@@ -9,11 +10,10 @@ export interface ObsidianServeOptions {
     host?: string;
     livereloadPort?: number;
     livereload?: boolean;
-    publish?: 'ftp' | 'netlify' | 'mdfriday';
-    publishDelay?: number;
     publishConfig?: {
-        type?: string;
-        licenseKey?: string;
+        method: 'ftp' | 'netlify' | 'mdfriday';
+        config: AnyPublishConfig;
+        delay?: number;
     };
     markdown?: MarkdownRenderer;
 }
@@ -24,6 +24,8 @@ export interface ObsidianServeResult {
         url: string;
         port: number;
         host: string;
+        baseURL?: string;
+        serverRoot?: string;
         livereloadPort?: number;
         autoPublish?: string;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdfriday/foundry",
-  "version": "26.3.7",
+  "version": "26.3.9",
   "description": "The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",