@things-factory/erp-systemever 10.1.117 → 10.1.118

package/server/systemever-connector.ts

@@ -0,0 +1,88 @@
+import integration from '@things-factory/integration-base'
+import { SystemEverQueryError } from './systemever-query-policy.js'
+const { ConnectionManager, HeadlessConnector, lookupDomainEnvVar } = integration
+
+/** Domain-isolated cookie reuse; one initial login and at most one login retry. */
+class SystemEverConnector extends HeadlessConnector {
+  get taskPrefixes() { return ['systemever-query'] }
+  get description() { return 'SystemEver read-only browser connection' }
+  get parameterSpec() {
+    return super.parameterSpec.filter(parameter => ![
+      'username', 'password', 'loginPagePath', 'loginApiUrl', 'forceLogin', 'retries'
+    ].includes(parameter.name))
+  }
+
+  async connect(connection: any) {
+    try {
+      const endpoint = new URL(connection.endpoint)
+      if (endpoint.origin !== 'https://mfg.systemevererp.com' || endpoint.username || endpoint.password ||
+          endpoint.pathname !== '/' || endpoint.search || endpoint.hash) {
+        throw new SystemEverQueryError('systemever-query-invalid-connection')
+      }
+      const [username, password] = await Promise.all([
+        lookupDomainEnvVar(connection.domain, 'ErpConnection::systemever::username'),
+        lookupDomainEnvVar(connection.domain, 'ErpConnection::systemever::password')
+      ])
+      if (!username || !password) {
+        throw new SystemEverQueryError('systemever-query-missing-credentials')
+      }
+      connection.params = { ...connection.params, username, password, retries: 2, forceLogin: false,
+        loginPagePath: '/Home/Oauth2OpenIdSignIn', loginApiUrl: null }
+      await super.connect(connection)
+    } catch (error) {
+      if (error instanceof SystemEverQueryError) throw error
+      throw new SystemEverQueryError('systemever-query-connection-failed')
+    }
+  }
+
+  protected isCookieValid(cookies: any[]) {
+    const now = Date.now() / 1000
+    return Array.isArray(cookies) && cookies.some(cookie => cookie.expires === -1 || cookie.expires > now)
+  }
+
+  async setupPage(page: any, uri: string, timeout: number) {
+    await super.setupPage(page, uri, timeout)
+    // Vendor console/request messages may contain session values. Do not forward them to logs.
+    page.removeAllListeners('console')
+    page.removeAllListeners('requestfailed')
+  }
+
+  async applyCookiesAndVerifySession(page: any, cookies: any[], loginInfo: any) {
+    await page.setCookie(...cookies)
+    await page.reload({ waitUntil: 'networkidle2', timeout: loginInfo.timeout })
+    const loggedIn = await page.evaluate(() => !!(window as any).Home?._base?.ConnInfo?.LoginSeq)
+    if (!loggedIn) await this.performLogin(page, '', loginInfo)
+  }
+
+  async performLogin(page: any, _uri: string, loginInfo: any) {
+    if (!loginInfo.username || !loginInfo.password) {
+      throw new SystemEverQueryError('systemever-query-missing-credentials')
+    }
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        await page.goto('https://mfg.systemevererp.com/Home/Oauth2OpenIdSignIn', {
+          waitUntil: 'networkidle2', timeout: loginInfo.timeout
+        })
+        if (new URL(page.url()).origin !== 'https://mfg.systemevererp.com') {
+          throw new SystemEverQueryError('systemever-query-login-origin-mismatch')
+        }
+        const selectors = loginInfo.loginSelectors
+        const username = await this.resolveShadowDom(page, selectors.shadowDomSelectors, selectors.usernameSelector)
+        const password = await this.resolveShadowDom(page, selectors.shadowDomSelectors, selectors.passwordSelector)
+        const submit = await this.resolveShadowDom(page, selectors.shadowDomSelectors, selectors.submitSelector)
+        if (!username || !password || !submit) throw new Error('login-form-missing')
+        await username.type(loginInfo.username)
+        await password.type(loginInfo.password)
+        await submit.click()
+        await page.waitForFunction(() => !!(window as any).Home?._base?.ConnInfo?.LoginSeq, {
+          timeout: loginInfo.timeout
+        })
+        return
+      } catch {
+        if (attempt === 1) throw new SystemEverQueryError('systemever-query-login-failed')
+      }
+    }
+  }
+}
+
+ConnectionManager.registerConnector('systemever-connector', new SystemEverConnector())

package/server/systemever-query-policy.ts

@@ -0,0 +1,47 @@
+/** ADR-0110: only verified read methods belong in the headless query task. */
+const screens = Object.freeze({
+  'work-order': Object.freeze({
+    pgmSeq: 500880,
+    serviceSeq: 501041,
+    methods: Object.freeze([
+      Object.freeze({ name: 'ConfirmQuery', methodSeq: 6 }),
+      Object.freeze({ name: 'Query', methodSeq: 1 })
+    ])
+  })
+})
+
+export class SystemEverQueryError extends Error {
+  readonly code: string
+
+  constructor(code: string, cause?: unknown) {
+    // Do not include input values: they may contain credentials or script text. A cause is named, not quoted —
+    // its message may carry the same values — and kept whole on `cause` for whoever reads the log.
+    const named = cause && typeof cause === 'object' ? String((cause as any).code || (cause as any).name || '') : ''
+    super(named ? `${code} (cause: ${named})` : code, cause === undefined ? undefined : { cause })
+    this.name = 'SystemEverQueryError'
+    this.code = code
+  }
+}
+
+export interface SystemEverQueryPlan {
+  screen: keyof typeof screens
+  pgmSeq: number
+  serviceSeq: number
+  methods: readonly { readonly name: string; readonly methodSeq: number }[]
+}
+
+/** No caller-provided service, method, URL or executable code is accepted. */
+export function planSystemEverQuery(input: unknown): SystemEverQueryPlan {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new SystemEverQueryError('systemever-query-invalid-params')
+  }
+  const params = input as Record<string, unknown>
+  if (Object.keys(params).some(key => key !== 'screen')) {
+    throw new SystemEverQueryError('systemever-query-unsupported-param')
+  }
+  if (typeof params.screen !== 'string' || !Object.hasOwn(screens, params.screen)) {
+    throw new SystemEverQueryError('systemever-query-unknown-screen')
+  }
+  const screen = params.screen as keyof typeof screens
+  return Object.freeze({ screen, ...screens[screen] })
+}

package/server/systemever-query-response.ts

@@ -0,0 +1,29 @@
+import { SystemEverQueryError } from './systemever-query-policy.js'
+
+/** Decode a single named query block; never interpret a missing block as an empty result. */
+export function decodeSystemEverQueryBlock(
+  response: unknown,
+  tableName: string,
+  requiredColumns: readonly string[]
+): Record<string, unknown>[] {
+  const tables = (response as any)?.JSonData?.Tables
+  if (!Array.isArray(tables)) throw new SystemEverQueryError('systemever-query-invalid-response')
+  const matches = tables.filter(table => table?.TableName === tableName)
+  if (matches.length !== 1) throw new SystemEverQueryError('systemever-query-block-mismatch')
+  const { Columns: columns, Rows: rows } = matches[0]
+  if (
+    !Array.isArray(columns) ||
+    columns.some(column => typeof column !== 'string' || !column) ||
+    new Set(columns).size !== columns.length ||
+    !Array.isArray(rows)
+  ) throw new SystemEverQueryError('systemever-query-invalid-table')
+  if (requiredColumns.some(column => !columns.includes(column))) {
+    throw new SystemEverQueryError('systemever-query-missing-columns')
+  }
+  return rows.map(row => {
+    if (!Array.isArray(row) || row.length !== columns.length) {
+      throw new SystemEverQueryError('systemever-query-invalid-row')
+    }
+    return Object.fromEntries(columns.map((column, index) => [column, row[index]]))
+  })
+}

package/server/systemever-query-runner.ts

@@ -0,0 +1,79 @@
+import { planSystemEverQuery, SystemEverQueryError } from './systemever-query-policy.js'
+import { workOrderQueryData } from './systemever-work-order-query.js'
+import { decodeSystemEverQueryBlock } from './systemever-query-response.js'
+import { WORK_ORDER_COLUMNS } from './systemever-work-order.js'
+
+/** Reject invalid task inputs before acquiring a browser or authenticating. */
+export function prepareSystemEverQuery(input: unknown) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new SystemEverQueryError('systemever-query-invalid-params')
+  }
+  const params = input as Record<string, any>
+  if (Object.keys(params).some(key => !['screen', 'dateFrom', 'dateTo', 'bizUnit'].includes(key))) {
+    throw new SystemEverQueryError('systemever-query-unsupported-param')
+  }
+  const plan = planSystemEverQuery({ screen: params.screen })
+  const data = workOrderQueryData(params as any)
+  return { plan, data }
+}
+
+/** Runs only the fixed vendor query methods inside an authenticated Puppeteer page. */
+export async function runSystemEverQuery(page: any, input: unknown) {
+  const { plan, data } = prepareSystemEverQuery(input)
+  try {
+    if (new URL(page.url()).origin !== 'https://mfg.systemevererp.com') {
+      throw new SystemEverQueryError('systemever-query-unexpected-origin')
+    }
+    const result = await page.evaluate(async ({ data, methods }) => {
+      const home = (window as any).Home
+      if (!home?._base?.ConnInfo?.LoginSeq) return { code: 'systemever-query-session-expired' }
+      home.OpenPageSeq(500880)
+      let token: string | undefined
+      const deadline = Date.now() + 30000
+      while (!token && Date.now() < deadline) {
+        const frame = document.querySelector<HTMLIFrameElement>('iframe[id="500880_iframe"]')
+        token = frame?.contentDocument?.querySelector<HTMLInputElement>('#__PageVerificationToken')?.value
+        if (!token) await new Promise(resolve => setTimeout(resolve, 100))
+      }
+      if (!token) return { code: 'systemever-query-frame-timeout' }
+      let response: any
+      for (const method of methods) {
+        const message = new home.Const.Message()
+        message.Seq = home._base.ConnInfo.LoginSeq
+        message.PageToken = token
+        message.Action = 228002
+        message.ActionType = 0
+        message.PgmMethodName = 'Query'
+        message.ServiceSeq = 501041
+        message.MethodSeq = method.methodSeq
+        Object.assign(message.Option, { PgmSeq: 500880, Timeout: 180, PgmMethodSeq: 2, XmlFlags: '2' })
+        message.JSonData = structuredClone(data)
+        response = await new Promise<any>(resolve => {
+          const timer = setTimeout(() => resolve(null), 190000)
+          const finish = (value: any) => { clearTimeout(timer); resolve(value) }
+          try { home.Util.Ajax('', message, 'POST', finish, () => finish(null), 'json', true) }
+          catch { finish(null) }
+        })
+        if (!response) return { code: 'systemever-query-request-failed' }
+        if (Number(response.ExeMsg?.ErrorSeq || 0) !== 0 || response.ExeMsg?.IsSystemError === true ||
+            (response.ExeMsg?.ErrStatus != null && Number(response.ExeMsg.ErrStatus) !== 0)) {
+          return { code: 'systemever-query-vendor-error' }
+        }
+        if (method.methodSeq === 6 && response.JSonData?.Tables?.some((table: any) => {
+          const status = table.Columns?.indexOf('Status') ?? -1
+          return status >= 0 && table.Rows?.some((row: any[]) => Number(row[status] || 0) !== 0)
+        })) return { code: 'systemever-query-vendor-error' }
+      }
+      // Project only tabular data: no session values or vendor object methods leave the page.
+      return { response: { JSonData: { Tables: response.JSonData?.Tables?.map((table: any) => ({
+        TableName: table.TableName, Columns: table.Columns, Rows: table.Rows
+      })) } } }
+    }, { data, methods: plan.methods })
+    if (result.code) throw new SystemEverQueryError(result.code)
+    return decodeSystemEverQueryBlock(result.response, 'DataBlock1', WORK_ORDER_COLUMNS)
+  } catch (error) {
+    if (error instanceof SystemEverQueryError) throw error
+    // Browser exceptions can contain URLs, scripts and authentication values.
+    throw new SystemEverQueryError('systemever-query-browser-failed')
+  }
+}

package/server/systemever-query-task.ts

@@ -0,0 +1,62 @@
+import integration from '@things-factory/integration-base'
+import { prepareSystemEverQuery, runSystemEverQuery } from './systemever-query-runner.js'
+import { SystemEverQueryError } from './systemever-query-policy.js'
+const { ConnectionManager, TaskRegistry } = integration
+
+/**
+ * The least time between two queries of one screen over one connection in one domain — a person does not press
+ * 조회 more often than this, and a schedule must not either (ADR-0110, ruling 2026-10-05, condition 3).
+ */
+export const SYSTEMEVER_QUERY_FLOOR_MS = 60_000
+
+/** When each (domain, connection, screen) last started a query, in this process. */
+export const lastQueryStartedAt = new Map<string, number>()
+
+/** Refusals that are not ours to rename: they already say what happened and where (e.g. integration-runtime-off). */
+function isNamedPlatformRefusal(error: unknown): boolean {
+  const code = (error as any)?.code
+  return typeof code === 'string' && code.startsWith('integration-')
+}
+
+async function SystemEverQuery(step: any, { domain }: any) {
+  try {
+    prepareSystemEverQuery(step.params)
+    const key = `${domain?.id}:${step.connection}:${step.params?.screen}`
+    const now = Date.now()
+    const last = lastQueryStartedAt.get(key)
+    if (last !== undefined && now - last < SYSTEMEVER_QUERY_FLOOR_MS) {
+      throw new SystemEverQueryError('systemever-query-too-frequent')
+    }
+    lastQueryStartedAt.set(key, now)
+    const entity = await ConnectionManager.getConnectionEntityByName(domain, step.connection)
+    if (!entity || entity.type !== 'systemever-connector' ||
+        new URL(entity.endpoint).origin !== 'https://mfg.systemevererp.com') {
+      throw new SystemEverQueryError('systemever-query-invalid-connection')
+    }
+    const instance = await ConnectionManager.getConnectionInstanceByName(domain, step.connection)
+    const connection = { ...instance, type: entity.type, name: entity.name, domain }
+    const data = await ConnectionManager.withSession(connection, async page => {
+      try {
+        return await runSystemEverQuery(page, step.params)
+      } catch (error) {
+        if (!(error instanceof SystemEverQueryError) || error.code !== 'systemever-query-session-expired') throw error
+        const recovered = await connection.reAuthenticateSession()
+        try { return await runSystemEverQuery(recovered.page, step.params) }
+        finally { await connection.releasePage(recovered.page) }
+      }
+    })
+    return { data }
+  } catch (error) {
+    if (error instanceof SystemEverQueryError || isNamedPlatformRefusal(error)) throw error
+    throw new SystemEverQueryError('systemever-query-connection-failed', error)
+  }
+}
+
+SystemEverQuery.parameterSpec = [
+  { type: 'select', name: 'screen', label: 'screen', property: { options: [{ display: '작업지시조회', value: 'work-order' }] } },
+  { type: 'string', name: 'dateFrom', label: 'date-from' },
+  { type: 'string', name: 'dateTo', label: 'date-to' },
+  { type: 'string', name: 'bizUnit', label: 'business-unit' }
+]
+
+TaskRegistry.registerTaskHandler('systemever-query', SystemEverQuery)

package/server/systemever-schedule-task.ts

@@ -0,0 +1,37 @@
+import integration from '@things-factory/integration-base'
+import utils from '@things-factory/utils'
+
+import { SystemEverQueryError } from './systemever-query-policy.js'
+import { toScheduleEntries } from './systemever-work-order.js'
+
+const { TaskRegistry } = integration
+const { access } = utils
+
+/**
+ * **SystemEver work-order rows → contract schedule entries**, as a scenario step (ADR-0110 addition 1 amended).
+ *
+ * `systemever-query` returns the 작업지시조회 rows with SystemEver's column names; this step maps them with the same
+ * `toScheduleEntries` the adapter would use, so the plant task that comes next receives only the contract's
+ * `ProductionScheduleEntry` and knows nothing of SystemEver. Orders it cannot map are passed on as `skipped`,
+ * each with its reason — none is dropped without a word.
+ */
+async function SystemEverWorkOrdersToSchedule(step: any, { data }: any) {
+  const { accessor, timeZone } = step.params || {}
+  const rows = accessor ? access(accessor, data) : undefined
+  if (!Array.isArray(rows)) throw new SystemEverQueryError('systemever-schedule-invalid-rows')
+  if (typeof timeZone !== 'string' || !timeZone.trim()) throw new SystemEverQueryError('systemever-schedule-invalid-time-zone')
+
+  try {
+    return { data: toScheduleEntries(rows, { timeZone }) }
+  } catch (error) {
+    /* toScheduleEntries throws only for the zone: missing or unknown. */
+    throw new SystemEverQueryError('systemever-schedule-invalid-time-zone', error)
+  }
+}
+
+SystemEverWorkOrdersToSchedule.parameterSpec = [
+  { type: 'scenario-step-input', name: 'accessor', label: 'accessor' },
+  { type: 'string', name: 'timeZone', label: 'time-zone' }
+]
+
+TaskRegistry.registerTaskHandler('systemever-work-orders-to-schedule', SystemEverWorkOrdersToSchedule)

package/server/systemever-work-order-query.ts

@@ -0,0 +1,157 @@
+import { SystemEverQueryError } from './systemever-query-policy.js'
+
+// Captured from a read-only work-order query on 2026-10-05. No session values.
+const template = {
+  "TableName": "DataBlock1",
+  "Columns": [
+    "WorkingTag",
+    "IDX_NO",
+    "DataSeq",
+    "Status",
+    "Selected",
+    "IsChangedMst",
+    "TABLE_NAME",
+    "IsSum",
+    "ItemClassSSeq",
+    "ItemClassSName",
+    "ItemClassLSeq",
+    "ItemClassLName",
+    "ItemClassMSeq",
+    "BizUnit",
+    "BizUnitName",
+    "WorkDateFr",
+    "WorkDateTo",
+    "WorkOrderNo",
+    "ProgStatus",
+    "ProgStatusName",
+    "WorkCenterSeq",
+    "WorkCenterName",
+    "DeptSeq",
+    "DeptName",
+    "ProcSeq",
+    "ProcName",
+    "WorkType",
+    "WorkTypeName",
+    "GoodItemName",
+    "GoodItemNo",
+    "GoodItemSpec",
+    "WorkOrderDateFr",
+    "WorkOrderDateTo",
+    "FileSeq",
+    "ProdPlanNo",
+    "OrderNo",
+    "CustSeq",
+    "CustName",
+    "WHSeq",
+    "WHName",
+    "PoNo"
+  ],
+  "ColumnsType": [
+    0,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "Rows": [
+    [
+      "A",
+      1,
+      1,
+      0,
+      1,
+      "0",
+      "DataBlock1",
+      "0",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "1",
+      "본사",
+      "20261005",
+      "20261012",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      0,
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      ""
+    ]
+  ]
+}
+
+export function workOrderQueryData(params: { dateFrom: string; dateTo: string; bizUnit: string }) {
+  for (const value of [params.dateFrom, params.dateTo]) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value) ||
+        !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value) {
+      throw new SystemEverQueryError('systemever-query-invalid-date')
+    }
+  }
+  if (params.dateFrom > params.dateTo) throw new SystemEverQueryError('systemever-query-invalid-date-range')
+  if (typeof params.bizUnit !== 'string' || !/^\d+$/.test(params.bizUnit)) {
+    throw new SystemEverQueryError('systemever-query-invalid-biz-unit')
+  }
+  const table = structuredClone(template)
+  const row = table.Rows[0]
+  row[table.Columns.indexOf('WorkDateFr')] = params.dateFrom.replaceAll('-', '')
+  row[table.Columns.indexOf('WorkDateTo')] = params.dateTo.replaceAll('-', '')
+  row[table.Columns.indexOf('BizUnit')] = params.bizUnit
+  row[table.Columns.indexOf('BizUnitName')] = ''
+  return { Tables: [table], IsSendXml: true, DataBlock1: 'DataBlock1' }
+}