@artinstack/migrator 0.1.17 → 0.1.18

package/README.md

@@ -4,6 +4,15 @@ Stateless content normalizer and migration framework for transforming **WordPres
 
 Portable parsers and JSON export are useful without any specific host. Job orchestration, credentials, and UI are implemented separately via `MigrationSink`.
 
+## Used by [ArtInStack](https://www.artinstack.com) (as an optional host)
+
+**MIT-licensed OSS** — use the CLI, export normalized JSON, or implement `MigrationSink` for **any** CMS or product. No ArtInStack account required.
+
+[ArtInStack](https://www.artinstack.com) is one production integration: the creative operating system for photographers and studios (websites, portfolios, client delivery, commerce, and courses). The platform’s import UI runs this package under the hood.
+
+- **Any host** — parsers, normalizer DTOs, conflict analysis, `MigrationSink` contract, and `artinstack-migrate` CLI (dry-run, filesystem export, custom sinks).
+- **ArtInStack product** — workspace owners use **Settings → Import Site**: scan WordPress WXR, preview entities, confirm import, review reports. [Customer docs](https://www.artinstack.com/docs/platform-migration/platform-migration-overview) cover export formats, SEO redirects, and cutover.
+
 See [docs/architecture.md](./docs/architecture.md) for the high-level blueprint: data flow, DTOs, sink contract, and source mappings.
 
 ## Package layout
@@ -192,7 +201,7 @@ pnpm dev          # watch build
 | CLI + filesystem JSON export | Yes | No |
 | `MigrationSink` interface | Yes | Implementation |
 | Map `data-wp-widget` stubs → platform blocks; populate slider heroes from hints | No | Yes |
-| Jobs, worker, credentials, UI | No | Yes |
+| Jobs, worker, credentials, UI | No | Your host — [example: ArtInStack Import Site](https://www.artinstack.com/docs/platform-migration/platform-migration-overview) |
 
 ## License
 

package/dist/{chunk-RLMYUUNK.js → chunk-PZADAGBA.js}

@@ -607,9 +607,11 @@ var SMUGMUG_OAUTH_ENDPOINTS = {
   authorize: "https://api.smugmug.com/services/oauth/1.0a/authorize",
   accessToken: "https://api.smugmug.com/services/oauth/1.0a/getAccessToken"
 };
-var smugMugCredentialsSchema = z.object({
+var smugMugConsumerCredentialsSchema = z.object({
   consumerKey: z.string().min(1),
-  consumerSecret: z.string().min(1),
+  consumerSecret: z.string().min(1)
+});
+var smugMugCredentialsSchema = smugMugConsumerCredentialsSchema.extend({
   accessToken: z.string().min(1),
   accessTokenSecret: z.string().min(1)
 });
@@ -680,23 +682,28 @@ function signSmugMugOAuthRequest(input) {
     oauthPercentEncode(normalizeRequestUrl(url)),
     oauthPercentEncode(parameterString)
   ].join("&");
-  const signingKey = `${oauthPercentEncode(input.credentials.consumerSecret)}&${oauthPercentEncode(input.credentials.accessTokenSecret)}`;
+  const tokenSecret = input.credentials.accessTokenSecret ?? "";
+  const signingKey = `${oauthPercentEncode(input.credentials.consumerSecret)}&${oauthPercentEncode(tokenSecret)}`;
   return createHmac("sha1", signingKey).update(signatureBase).digest("base64");
 }
-function buildOAuthParams(credentials, nonce, timestamp) {
-  return {
+function buildOAuthParams(credentials, nonce, timestamp, extras) {
+  const params = {
     oauth_consumer_key: credentials.consumerKey,
-    oauth_token: credentials.accessToken,
     oauth_signature_method: "HMAC-SHA1",
     oauth_timestamp: timestamp,
     oauth_nonce: nonce,
-    oauth_version: "1.0"
+    oauth_version: "1.0",
+    ...extras ?? {}
   };
+  if (credentials.accessToken) {
+    params.oauth_token = credentials.accessToken;
+  }
+  return params;
 }
 function buildSmugMugAuthorizationHeader(input) {
   const nonce = input.nonce ?? randomBytes(16).toString("hex");
   const timestamp = input.timestamp ?? String(Math.floor(Date.now() / 1e3));
-  const oauthParams = buildOAuthParams(input.credentials, nonce, timestamp);
+  const oauthParams = buildOAuthParams(input.credentials, nonce, timestamp, input.oauthExtras);
   const signature = signSmugMugOAuthRequest({
     method: input.method,
     url: input.url,
@@ -708,6 +715,141 @@ function buildSmugMugAuthorizationHeader(input) {
   const headerValue = Object.keys(headerParams).sort().map((key) => `${oauthPercentEncode(key)}="${oauthPercentEncode(headerParams[key])}"`).join(", ");
   return `OAuth ${headerValue}`;
 }
+function parseSmugMugOAuthFormBody(body) {
+  const params = new URLSearchParams(body.trim());
+  const out = {};
+  params.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+function requireOAuthFormField(fields, name) {
+  const value = fields[name]?.trim();
+  if (!value) {
+    throw new Error(`SmugMug OAuth response missing ${name}`);
+  }
+  return value;
+}
+async function postSmugMugOAuthTokenEndpoint(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const authorization = buildSmugMugAuthorizationHeader({
+    method: "POST",
+    url: input.url,
+    credentials: input.credentials,
+    oauthExtras: input.oauthExtras,
+    nonce: input.nonce,
+    timestamp: input.timestamp
+  });
+  const response = await fetchImpl(input.url, {
+    method: "POST",
+    headers: {
+      Accept: "application/x-www-form-urlencoded",
+      Authorization: authorization
+    }
+  });
+  const body = await response.text();
+  if (!response.ok) {
+    throw new Error(
+      `SmugMug OAuth HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`
+    );
+  }
+  return parseSmugMugOAuthFormBody(body);
+}
+async function getSmugMugRequestToken(input) {
+  const consumer = smugMugConsumerCredentialsSchema.parse(input.consumer);
+  const callbackUrl = input.callbackUrl.trim();
+  if (!callbackUrl) {
+    throw new Error('SmugMug OAuth callbackUrl is required (use a URL or "oob")');
+  }
+  const fields = await postSmugMugOAuthTokenEndpoint({
+    url: SMUGMUG_OAUTH_ENDPOINTS.requestToken,
+    credentials: {
+      consumerKey: consumer.consumerKey,
+      consumerSecret: consumer.consumerSecret,
+      accessTokenSecret: ""
+    },
+    oauthExtras: { oauth_callback: callbackUrl },
+    fetchImpl: input.fetchImpl,
+    nonce: input.nonce,
+    timestamp: input.timestamp
+  });
+  return {
+    token: requireOAuthFormField(fields, "oauth_token"),
+    tokenSecret: requireOAuthFormField(fields, "oauth_token_secret"),
+    callbackConfirmed: fields.oauth_callback_confirmed === "true"
+  };
+}
+function buildSmugMugAuthorizeUrl(options) {
+  const requestToken = options.requestToken.trim();
+  if (!requestToken) {
+    throw new Error("SmugMug authorize URL requires requestToken");
+  }
+  const url = new URL(SMUGMUG_OAUTH_ENDPOINTS.authorize);
+  url.searchParams.set("oauth_token", requestToken);
+  url.searchParams.set("Access", options.access ?? "Full");
+  url.searchParams.set("Permissions", options.permissions ?? "Modify");
+  if (options.allowThirdPartyLogin !== void 0) {
+    url.searchParams.set("allowThirdPartyLogin", options.allowThirdPartyLogin ? "1" : "0");
+  }
+  if (options.showSignUpButton !== void 0) {
+    url.searchParams.set("showSignUpButton", options.showSignUpButton ? "true" : "false");
+  }
+  if (options.username?.trim()) {
+    url.searchParams.set("username", options.username.trim());
+  }
+  return url.toString();
+}
+async function getSmugMugAccessToken(input) {
+  const consumer = smugMugConsumerCredentialsSchema.parse(input.consumer);
+  const token = input.requestToken.token.trim();
+  const tokenSecret = input.requestToken.tokenSecret;
+  const verifier = input.verifier.trim();
+  if (!token || tokenSecret === void 0 || tokenSecret === null) {
+    throw new Error("SmugMug access-token exchange requires request token + secret");
+  }
+  if (!verifier) {
+    throw new Error("SmugMug access-token exchange requires oauth_verifier");
+  }
+  const fields = await postSmugMugOAuthTokenEndpoint({
+    url: SMUGMUG_OAUTH_ENDPOINTS.accessToken,
+    credentials: {
+      consumerKey: consumer.consumerKey,
+      consumerSecret: consumer.consumerSecret,
+      accessToken: token,
+      accessTokenSecret: tokenSecret
+    },
+    oauthExtras: { oauth_verifier: verifier },
+    fetchImpl: input.fetchImpl,
+    nonce: input.nonce,
+    timestamp: input.timestamp
+  });
+  return {
+    token: requireOAuthFormField(fields, "oauth_token"),
+    tokenSecret: requireOAuthFormField(fields, "oauth_token_secret")
+  };
+}
+async function createSmugMugOAuthSession(input) {
+  const request = await getSmugMugRequestToken({
+    consumer: {
+      consumerKey: input.consumerKey,
+      consumerSecret: input.consumerSecret
+    },
+    callbackUrl: input.callbackUrl,
+    fetchImpl: input.fetchImpl,
+    nonce: input.nonce,
+    timestamp: input.timestamp
+  });
+  return {
+    requestToken: request.token,
+    requestTokenSecret: request.tokenSecret,
+    authorizeUrl: buildSmugMugAuthorizeUrl({
+      requestToken: request.token,
+      access: input.access,
+      permissions: input.permissions
+    }),
+    callbackConfirmed: request.callbackConfirmed
+  };
+}
 function readSmugMugCredentialsFromEnv(env = process.env) {
   return smugMugCredentialsSchema.parse({
     consumerKey: env.SMUGMUG_CONSUMER_KEY,
@@ -2557,9 +2699,15 @@ export {
   wordpressAdapter,
   SMUGMUG_API_BASE,
   SMUGMUG_OAUTH_ENDPOINTS,
+  smugMugConsumerCredentialsSchema,
   smugMugCredentialsSchema,
   signSmugMugOAuthRequest,
   buildSmugMugAuthorizationHeader,
+  parseSmugMugOAuthFormBody,
+  getSmugMugRequestToken,
+  buildSmugMugAuthorizeUrl,
+  getSmugMugAccessToken,
+  createSmugMugOAuthSession,
   readSmugMugCredentialsFromEnv,
   SmugMugApiClient,
   smugmugAdapter,
@@ -2569,4 +2717,4 @@ export {
   wixAdapter,
   getAdapter
 };
-//# sourceMappingURL=chunk-RLMYUUNK.js.map
+//# sourceMappingURL=chunk-PZADAGBA.js.map