@auto-wiz/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./steps/stepValidation";
+export * from "./storage/flowStorage";
+export * from "./runner";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./steps/stepValidation";
+export * from "./storage/flowStorage";
+export * from "./runner";

package/dist/runner.d.ts

@@ -0,0 +1,28 @@
+import type { Flow, Step } from "./types";
+export interface ExecutionResult {
+    success: boolean;
+    error?: string;
+    extractedData?: any;
+    usedSelector?: string;
+}
+export interface RunResult {
+    success: boolean;
+    error?: string;
+    failedStepIndex?: number;
+    extractedData?: Record<string, any>;
+}
+export interface RunnerOptions {
+    timeout?: number;
+    stopOnError?: boolean;
+}
+/**
+ * Abstract Flow Runner Interface
+ *
+ * TContext: The environment-specific context required to run the flow.
+ * - DOM: void (runs in global window)
+ * - Playwright: Page (runs on a specific page instance)
+ */
+export interface FlowRunner<TContext = any> {
+    run(flow: Flow, context: TContext, options?: RunnerOptions): Promise<RunResult>;
+    runStep(step: Step, context: TContext, options?: RunnerOptions): Promise<ExecutionResult>;
+}

package/dist/runner.js

@@ -0,0 +1 @@
+export {};

package/dist/steps/stepValidation.d.ts

@@ -0,0 +1,25 @@
+import type { Step } from "../types";
+/**
+ * Step validation 유틸리티
+ * Step의 유효성 검증 및 오류 메시지 생성
+ */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Step의 기본 구조 검증
+ */
+export declare function validateStep(step: Step): ValidationResult;
+/**
+ * Step 배열의 모든 Step 검증
+ */
+export declare function validateSteps(steps: Step[]): ValidationResult;
+/**
+ * Step이 실행 가능한지 확인
+ */
+export declare function isExecutableStep(step: Step): boolean;
+/**
+ * Step 타입별 필수 필드 확인
+ */
+export declare function hasRequiredFields(step: Step): boolean;

package/dist/steps/stepValidation.js

@@ -0,0 +1,134 @@
+/**
+ * Step의 기본 구조 검증
+ */
+export function validateStep(step) {
+    if (!step || typeof step !== "object") {
+        return { valid: false, error: "Step must be an object" };
+    }
+    if (!step.type) {
+        return { valid: false, error: "Step type is required" };
+    }
+    // 타입별 검증
+    switch (step.type) {
+        case "click":
+            return validateClickStep(step);
+        case "type":
+            return validateTypeStep(step);
+        case "select":
+            return validateSelectStep(step);
+        case "extract":
+            return validateExtractStep(step);
+        case "navigate":
+            return validateNavigateStep(step);
+        case "waitFor":
+            return validateWaitForStep(step);
+        default:
+            return { valid: false, error: `Unknown step type: ${step.type}` };
+    }
+}
+function validateClickStep(step) {
+    if (step.type !== "click") {
+        return { valid: false, error: "Invalid step type for click validation" };
+    }
+    if (!step.selector) {
+        return { valid: false, error: "Click step requires selector" };
+    }
+    return { valid: true };
+}
+function validateTypeStep(step) {
+    if (step.type !== "type") {
+        return { valid: false, error: "Invalid step type for type validation" };
+    }
+    if (!step.selector) {
+        return { valid: false, error: "Type step requires selector" };
+    }
+    if (step.text === undefined && step.originalText === undefined) {
+        return { valid: false, error: "Type step requires text or originalText" };
+    }
+    return { valid: true };
+}
+function validateSelectStep(step) {
+    if (step.type !== "select") {
+        return { valid: false, error: "Invalid step type for select validation" };
+    }
+    if (!step.selector) {
+        return { valid: false, error: "Select step requires selector" };
+    }
+    if (step.value === undefined) {
+        return { valid: false, error: "Select step requires value" };
+    }
+    return { valid: true };
+}
+function validateExtractStep(step) {
+    if (step.type !== "extract") {
+        return { valid: false, error: "Invalid step type for extract validation" };
+    }
+    if (!step.selector) {
+        return { valid: false, error: "Extract step requires selector" };
+    }
+    return { valid: true };
+}
+function validateNavigateStep(step) {
+    if (step.type !== "navigate") {
+        return { valid: false, error: "Invalid step type for navigate validation" };
+    }
+    if (!step.url) {
+        return { valid: false, error: "Navigate step requires URL" };
+    }
+    // URL 형식 검증
+    try {
+        new URL(step.url);
+    }
+    catch {
+        return { valid: false, error: `Invalid URL: ${step.url}` };
+    }
+    return { valid: true };
+}
+function validateWaitForStep(step) {
+    if (step.type !== "waitFor") {
+        return { valid: false, error: "Invalid step type for waitFor validation" };
+    }
+    if (!step.selector && step.timeoutMs === undefined) {
+        return {
+            valid: false,
+            error: "WaitFor step requires selector or timeoutMs",
+        };
+    }
+    if (step.timeoutMs !== undefined) {
+        if (typeof step.timeoutMs !== "number" || step.timeoutMs < 0) {
+            return { valid: false, error: "Timeout must be a positive number" };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Step 배열의 모든 Step 검증
+ */
+export function validateSteps(steps) {
+    if (!Array.isArray(steps)) {
+        return { valid: false, error: "Steps must be an array" };
+    }
+    for (let i = 0; i < steps.length; i++) {
+        const result = validateStep(steps[i]);
+        if (!result.valid) {
+            return {
+                valid: false,
+                error: `Step ${i + 1}: ${result.error}`,
+            };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Step이 실행 가능한지 확인
+ */
+export function isExecutableStep(step) {
+    return validateStep(step).valid;
+}
+/**
+ * Step 타입별 필수 필드 확인
+ */
+export function hasRequiredFields(step) {
+    const validation = validateStep(step);
+    return validation.valid;
+}

package/dist/storage/flowStorage.d.ts

@@ -0,0 +1,51 @@
+import type { Flow, Step } from "../types";
+export interface StorageAdapter {
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+}
+declare class ExtensionStorageAdapter implements StorageAdapter {
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+}
+declare class MemoryStorageAdapter implements StorageAdapter {
+    private storage;
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+}
+/**
+ * 스토리지 어댑터 설정 (라이브러리 사용 시 필수)
+ */
+export declare function setStorageAdapter(adapter: StorageAdapter): void;
+/**
+ * Flow 가져오기
+ */
+export declare function getFlow(): Promise<Flow | null>;
+/**
+ * Flow 저장하기
+ */
+export declare function saveFlow(flow: Flow): Promise<void>;
+/**
+ * Flow 초기화 (비우기)
+ */
+export declare function clearFlow(): Promise<void>;
+/**
+ * Flow에 Step 추가
+ */
+export declare function addStep(step: Step): Promise<Flow>;
+/**
+ * Flow에서 마지막 Step 제거
+ */
+export declare function removeLastStep(): Promise<Flow>;
+/**
+ * Flow에서 특정 Step 제거
+ */
+export declare function removeStep(index: number): Promise<Flow>;
+/**
+ * Flow의 특정 Step 업데이트
+ */
+export declare function updateStep(index: number, step: Step): Promise<Flow>;
+/**
+ * Flow 업데이트 (전체 교체)
+ */
+export declare function updateFlow(updates: Partial<Flow>): Promise<Flow>;
+export { ExtensionStorageAdapter, MemoryStorageAdapter };

package/dist/storage/flowStorage.js

@@ -0,0 +1,157 @@
+const FLOW_STORAGE_KEY = "flow";
+// 기본 브라우저 확장 프로그램 스토리지 어댑터
+class ExtensionStorageAdapter {
+    async get(key) {
+        if (typeof browser !== "undefined" && browser.storage) {
+            const result = await browser.storage.local.get(key);
+            return result[key];
+        }
+        return null;
+    }
+    async set(key, value) {
+        if (typeof browser !== "undefined" && browser.storage) {
+            await browser.storage.local.set({ [key]: value });
+        }
+    }
+}
+// 메모리 스토리지 어댑터 (테스트 또는 비-확장 프로그램 환경용)
+class MemoryStorageAdapter {
+    constructor() {
+        Object.defineProperty(this, "storage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    async get(key) {
+        return this.storage[key] || null;
+    }
+    async set(key, value) {
+        this.storage[key] = value;
+    }
+}
+let storageAdapter = new ExtensionStorageAdapter();
+/**
+ * 스토리지 어댑터 설정 (라이브러리 사용 시 필수)
+ */
+export function setStorageAdapter(adapter) {
+    storageAdapter = adapter;
+}
+/**
+ * Flow 가져오기
+ */
+export async function getFlow() {
+    try {
+        const flow = await storageAdapter.get(FLOW_STORAGE_KEY);
+        return flow || null;
+    }
+    catch (error) {
+        console.error("Failed to get flow from storage:", error);
+        return null;
+    }
+}
+/**
+ * Flow 저장하기
+ */
+export async function saveFlow(flow) {
+    try {
+        await storageAdapter.set(FLOW_STORAGE_KEY, flow);
+    }
+    catch (error) {
+        console.error("Failed to save flow to storage:", error);
+        throw error;
+    }
+}
+/**
+ * Flow 초기화 (비우기)
+ */
+export async function clearFlow() {
+    try {
+        const emptyFlow = {
+            id: crypto.randomUUID(),
+            title: "New Flow",
+            steps: [],
+            createdAt: Date.now(),
+        };
+        await saveFlow(emptyFlow);
+    }
+    catch (error) {
+        console.error("Failed to clear flow:", error);
+        throw error;
+    }
+}
+/**
+ * Flow에 Step 추가
+ */
+export async function addStep(step) {
+    const flow = (await getFlow()) || {
+        id: crypto.randomUUID(),
+        title: "New Flow",
+        steps: [],
+        createdAt: Date.now(),
+    };
+    flow.steps.push(step);
+    if (!flow.startUrl && step.url) {
+        flow.startUrl = step.url;
+    }
+    await saveFlow(flow);
+    return flow;
+}
+/**
+ * Flow에서 마지막 Step 제거
+ */
+export async function removeLastStep() {
+    const flow = await getFlow();
+    if (!flow || flow.steps.length === 0) {
+        return {
+            id: crypto.randomUUID(),
+            title: "New Flow",
+            steps: [],
+            createdAt: Date.now(),
+        };
+    }
+    flow.steps.pop();
+    await saveFlow(flow);
+    return flow;
+}
+/**
+ * Flow에서 특정 Step 제거
+ */
+export async function removeStep(index) {
+    const flow = await getFlow();
+    if (!flow || index < 0 || index >= flow.steps.length) {
+        throw new Error(`Invalid step index: ${index}`);
+    }
+    flow.steps.splice(index, 1);
+    await saveFlow(flow);
+    return flow;
+}
+/**
+ * Flow의 특정 Step 업데이트
+ */
+export async function updateStep(index, step) {
+    const flow = await getFlow();
+    if (!flow || index < 0 || index >= flow.steps.length) {
+        throw new Error(`Invalid step index: ${index}`);
+    }
+    flow.steps[index] = step;
+    await saveFlow(flow);
+    return flow;
+}
+/**
+ * Flow 업데이트 (전체 교체)
+ */
+export async function updateFlow(updates) {
+    const flow = (await getFlow()) || {
+        id: crypto.randomUUID(),
+        title: "New Flow",
+        steps: [],
+        createdAt: Date.now(),
+    };
+    const updatedFlow = { ...flow, ...updates };
+    await saveFlow(updatedFlow);
+    return updatedFlow;
+}
+// Export adapters for external use/testing
+export { ExtensionStorageAdapter, MemoryStorageAdapter };

package/dist/types.d.ts

@@ -0,0 +1,163 @@
+/**
+ * ElementLocator: 다중 selector 전략 (Playwright/Maestro 스타일)
+ * 우선순위 기반으로 여러 selector를 시도하여 안정성 향상
+ */
+export interface ElementLocator {
+    /** Primary selector (가장 신뢰할 수 있는) */
+    primary: string;
+    /** Fallback selectors (우선순위 순서대로) */
+    fallbacks: string[];
+    /** 요소 메타데이터 (fuzzy matching용) */
+    metadata?: {
+        text?: string;
+        role?: string;
+        tagName?: string;
+        testId?: string;
+        ariaLabel?: string;
+        placeholder?: string;
+        title?: string;
+    };
+}
+type CoreStep = {
+    type: "click";
+    selector: string;
+    locator?: ElementLocator;
+    url?: string;
+    screenshot?: string;
+    timeoutMs?: number;
+} | {
+    type: "type";
+    selector: string;
+    locator?: ElementLocator;
+    text: string;
+    originalText?: string;
+    submit?: boolean;
+    url?: string;
+    screenshot?: string;
+    timeoutMs?: number;
+} | {
+    type: "select";
+    selector: string;
+    locator?: ElementLocator;
+    value: string;
+    url?: string;
+    screenshot?: string;
+    timeoutMs?: number;
+} | {
+    type: "extract";
+    selector: string;
+    locator?: ElementLocator;
+    prop?: "innerText" | "value";
+    url?: string;
+    screenshot?: string;
+    timeoutMs?: number;
+} | {
+    type: "waitFor";
+    selector?: string;
+    locator?: ElementLocator;
+    timeoutMs?: number;
+    url?: string;
+    screenshot?: string;
+} | {
+    type: "screenshot";
+    selector: string;
+    locator?: ElementLocator;
+    url?: string;
+    screenshot: string;
+    timeoutMs?: number;
+} | {
+    type: "navigate";
+    url: string;
+} | {
+    type: "waitForNavigation";
+    timeoutMs?: number;
+};
+export type Step = CoreStep & {
+    _frameId?: number;
+    _frameUrl?: string;
+};
+export interface Flow {
+    id: string;
+    title: string;
+    steps: Step[];
+    createdAt: number;
+    startUrl?: string;
+}
+export type RecordStepMessage = {
+    type: "REC_STEP";
+    step: Step;
+};
+export type TogglePickerMessage = {
+    type: "TOGGLE_PICKER";
+    on: boolean;
+};
+export type RunFlowMessage = {
+    type: "RUN_FLOW";
+};
+export type SendToBackendMessage = {
+    type: "SEND_TO_BACKEND";
+    endpoint: string;
+};
+export type FlowUpdatedMessage = {
+    type: "FLOW_UPDATED";
+    flow: Flow;
+};
+export type SentOkMessage = {
+    type: "SENT_OK";
+};
+export type StepExecutingMessage = {
+    type: "STEP_EXECUTING";
+    step: Step;
+    stepIndex: number;
+    totalSteps: number;
+    currentUrl?: string;
+};
+export type StepCompletedMessage = {
+    type: "STEP_COMPLETED";
+    step: Step;
+    stepIndex: number;
+    success: boolean;
+    error?: string;
+    extractedData?: any;
+};
+export type FlowFailedMessage = {
+    type: "FLOW_FAILED";
+    error: string;
+    failedStepIndex: number;
+    failedStep: Step;
+};
+export type ElementScreenshotMessage = {
+    type: "ELEMENT_SCREENSHOT";
+    stepIndex: number;
+    screenshot: string;
+    elementInfo: {
+        tagName: string;
+        selector: string;
+        text?: string;
+    };
+};
+export type StartRecordMessage = {
+    type: "START_RECORD";
+};
+export type StopRecordMessage = {
+    type: "STOP_RECORD";
+};
+export type StopRunMessage = {
+    type: "STOP_RUN";
+};
+export type PlayEventsToContentMessage = {
+    type: "PLAY_EVENTS";
+    events: any[];
+};
+export type RecordStateUpdatedMessage = {
+    type: "RECORD_STATE";
+    recording: boolean;
+};
+export type GetRecordStateMessage = {
+    type: "GET_RECORD_STATE";
+};
+export type UndoLastStepMessage = {
+    type: "UNDO_LAST_STEP";
+};
+export type Message = RecordStepMessage | TogglePickerMessage | RunFlowMessage | SendToBackendMessage | FlowUpdatedMessage | SentOkMessage | StepExecutingMessage | StepCompletedMessage | FlowFailedMessage | ElementScreenshotMessage | StartRecordMessage | StopRecordMessage | StopRunMessage | PlayEventsToContentMessage | RecordStateUpdatedMessage | GetRecordStateMessage | UndoLastStepMessage;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/urls/urlUtils.d.ts

@@ -0,0 +1,49 @@
+/**
+ * URL 유틸리티 함수들
+ * URL 비교, 정규화, 파싱 등의 기능 제공
+ */
+/**
+ * URL 정규화
+ * - 트레일링 슬래시 제거
+ * - 해시(fragment) 제거
+ * - 쿼리 파라미터 정렬
+ */
+export declare function normalizeUrl(url: string): string;
+/**
+ * 두 URL이 같은 페이지를 가리키는지 확인
+ * (해시와 쿼리 파라미터 순서 무시)
+ */
+export declare function isSameUrl(url1: string, url2: string): boolean;
+/**
+ * 두 URL의 origin이 같은지 확인
+ */
+export declare function isSameOrigin(url1: string, url2: string): boolean;
+/**
+ * 상대 URL을 절대 URL로 변환
+ */
+export declare function resolveUrl(relativeUrl: string, baseUrl: string): string;
+/**
+ * URL에서 도메인 추출
+ */
+export declare function getDomain(url: string): string;
+/**
+ * URL에서 경로 추출
+ */
+export declare function getPath(url: string): string;
+/**
+ * URL에서 쿼리 파라미터 추출
+ */
+export declare function getQueryParams(url: string): Record<string, string>;
+/**
+ * URL이 유효한지 검증
+ */
+export declare function isValidUrl(url: string): boolean;
+/**
+ * HTTP/HTTPS URL인지 확인
+ */
+export declare function isHttpUrl(url: string): boolean;
+/**
+ * URL이 현재 페이지와 같은 페이지인지 확인
+ * (해시만 다른 경우 같은 페이지로 간주)
+ */
+export declare function isSamePage(url1: string, url2: string): boolean;

package/dist/urls/urlUtils.js

@@ -0,0 +1,144 @@
+/**
+ * URL 유틸리티 함수들
+ * URL 비교, 정규화, 파싱 등의 기능 제공
+ */
+/**
+ * URL 정규화
+ * - 트레일링 슬래시 제거
+ * - 해시(fragment) 제거
+ * - 쿼리 파라미터 정렬
+ */
+export function normalizeUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        // 트레일링 슬래시 제거 (루트 경로 제외)
+        if (urlObj.pathname !== "/" && urlObj.pathname.endsWith("/")) {
+            urlObj.pathname = urlObj.pathname.slice(0, -1);
+        }
+        // 쿼리 파라미터 정렬
+        const params = Array.from(urlObj.searchParams.entries()).sort(([a], [b]) => a.localeCompare(b));
+        urlObj.search = new URLSearchParams(params).toString();
+        // 해시 제거 (fragment는 페이지 내 이동만 하므로)
+        urlObj.hash = "";
+        return urlObj.toString();
+    }
+    catch (error) {
+        console.error("Invalid URL:", url, error);
+        return url;
+    }
+}
+/**
+ * 두 URL이 같은 페이지를 가리키는지 확인
+ * (해시와 쿼리 파라미터 순서 무시)
+ */
+export function isSameUrl(url1, url2) {
+    try {
+        return normalizeUrl(url1) === normalizeUrl(url2);
+    }
+    catch (error) {
+        return url1 === url2;
+    }
+}
+/**
+ * 두 URL의 origin이 같은지 확인
+ */
+export function isSameOrigin(url1, url2) {
+    try {
+        const origin1 = new URL(url1).origin;
+        const origin2 = new URL(url2).origin;
+        return origin1 === origin2;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * 상대 URL을 절대 URL로 변환
+ */
+export function resolveUrl(relativeUrl, baseUrl) {
+    try {
+        return new URL(relativeUrl, baseUrl).toString();
+    }
+    catch (error) {
+        console.error("Failed to resolve URL:", relativeUrl, baseUrl, error);
+        return relativeUrl;
+    }
+}
+/**
+ * URL에서 도메인 추출
+ */
+export function getDomain(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch (error) {
+        return "";
+    }
+}
+/**
+ * URL에서 경로 추출
+ */
+export function getPath(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch (error) {
+        return "";
+    }
+}
+/**
+ * URL에서 쿼리 파라미터 추출
+ */
+export function getQueryParams(url) {
+    try {
+        const urlObj = new URL(url);
+        const params = {};
+        urlObj.searchParams.forEach((value, key) => {
+            params[key] = value;
+        });
+        return params;
+    }
+    catch (error) {
+        return {};
+    }
+}
+/**
+ * URL이 유효한지 검증
+ */
+export function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * HTTP/HTTPS URL인지 확인
+ */
+export function isHttpUrl(url) {
+    try {
+        const protocol = new URL(url).protocol;
+        return protocol === "http:" || protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * URL이 현재 페이지와 같은 페이지인지 확인
+ * (해시만 다른 경우 같은 페이지로 간주)
+ */
+export function isSamePage(url1, url2) {
+    try {
+        const obj1 = new URL(url1);
+        const obj2 = new URL(url2);
+        return (obj1.origin === obj2.origin &&
+            obj1.pathname === obj2.pathname &&
+            obj1.search === obj2.search);
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@auto-wiz/core",
+  "version": "1.0.0",
+  "license": "MIT",
+  "author": "JaeSang",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JaeSang1998/automation-wizard.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "wxt": "^0.19.0"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}