@easysociable/cli 0.1.0 → 0.1.2

package/skills/easysociable-content/scripts/validate-run.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { validateContentPack, validateRunLayout } from './contracts.mjs'
+import { validateExportDirectory } from './export-contracts.mjs'
+
+function parseArgs(argv) {
+  const options = { run: '', exportDir: '', requirePack: false, requireExport: false, requirePageTemplateId: false, json: false }
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--run') options.run = argv[++i] ?? ''
+    else if (arg === '--export') options.exportDir = argv[++i] ?? ''
+    else if (arg === '--require-pack') options.requirePack = true
+    else if (arg === '--require-export') options.requireExport = true
+    else if (arg === '--require-page-template-id') options.requirePageTemplateId = true
+    else if (arg === '--json') options.json = true
+    else if (arg === '--help' || arg === '-h') options.help = true
+    else throw new Error(`Unknown argument: ${arg}`)
+  }
+  return options
+}
+
+function output(value, json) {
+  process.stdout.write(json ? `${JSON.stringify(value, null, 2)}\n` : `${value.message ?? value}\n`)
+}
+
+try {
+  const options = parseArgs(process.argv.slice(2))
+  if (options.help) {
+    output({ usage: 'node validate-run.mjs --run <run-dir> [--require-pack] [--require-export] [--export <export-dir>] [--json]' }, false)
+    process.exit(0)
+  }
+  if (!options.run) {
+    output({ code: 'RUN_REQUIRED', message: 'Pass --run <run-dir>.', valid: false }, options.json)
+    process.exitCode = 2
+  }
+  else {
+    const runDir = resolve(options.run)
+    const layout = validateRunLayout(runDir, { requirePack: options.requirePack })
+    const packs = []
+    for (const name of layout.files.packs) {
+      const platform = name.replace(/^pack-/, '').replace(/\.json$/i, '')
+      try {
+        const pack = JSON.parse(readFileSync(join(runDir, name), 'utf8'))
+        packs.push({ file: name, pages: Array.isArray(pack.pages) ? pack.pages.length : 0, ...validateContentPack(pack, {
+          requirePageTemplateId: options.requirePageTemplateId,
+          platform,
+        }) })
+      }
+      catch (error) {
+        packs.push({ file: name, pages: 0, valid: false, errors: [`invalid JSON (${error instanceof Error ? error.message : String(error)})`], warnings: [] })
+      }
+    }
+    const packErrors = packs.flatMap((item) => item.errors.map((e) => `${item.file}: ${e}`))
+    let exportReport
+    const needsExport = options.requireExport || layout.frontmatter.status === 'exported'
+    if (needsExport) {
+      let exportDir = options.exportDir
+      if (!exportDir) {
+        const engineRoot = resolve(runDir, '..', '..')
+        const engineConfig = join(engineRoot, 'engine.json')
+        if (existsSync(engineConfig)) {
+          try {
+            const engine = JSON.parse(readFileSync(engineConfig, 'utf8'))
+            const base = join(engineRoot, engine.paths.exports, layout.frontmatter.slug)
+            const nested = layout.frontmatter.platform ? join(base, layout.frontmatter.platform) : ''
+            exportDir = nested && existsSync(nested) ? nested : base
+          }
+          catch (error) {
+            exportReport = { valid: false, errors: [`engine.json: invalid JSON (${error instanceof Error ? error.message : String(error)})`], warnings: [] }
+          }
+        }
+        else exportReport = { valid: false, errors: ['engine.json: required to derive export path'], warnings: [] }
+      }
+      if (!exportReport) {
+        const expectedPages = packs.find(item => item.pages > 0)?.pages ?? 1
+        exportReport = validateExportDirectory(resolve(exportDir), { expectedPages })
+        exportReport.export = resolve(exportDir)
+      }
+    }
+    const exportErrors = exportReport?.errors?.map(error => `export: ${error}`) ?? []
+    const valid = layout.valid && packErrors.length === 0 && exportErrors.length === 0
+    output({
+      valid,
+      action: 'validated',
+      run: runDir,
+      layout,
+      packs,
+      export: exportReport,
+      errors: [...layout.errors, ...packErrors, ...exportErrors],
+      warnings: [...layout.warnings, ...packs.flatMap((item) => item.warnings.map((w) => `${item.file}: ${w}`)), ...(exportReport?.warnings ?? [])],
+    }, options.json)
+    if (!valid) process.exitCode = 2
+  }
+}
+catch (error) {
+  output({ code: 'RUN_VALIDATE_FAILED', message: error instanceof Error ? error.message : String(error), valid: false }, true)
+  process.exitCode = 1
+}

package/skills/easysociable-content/scripts/validate.test.mjs

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { validateContentPack } from './contracts.mjs'
+import { validateExportDirectory } from './export-contracts.mjs'
+
+const root = new URL('.', import.meta.url).pathname
+const validatePack = join(root, 'validate-pack.mjs')
+const validateRun = join(root, 'validate-run.mjs')
+const fixture = mkdtempSync(join(tmpdir(), 'easysociable-validate-'))
+
+function run(script, args) {
+  return spawnSync(process.execPath, [script, ...args, '--json'], { encoding: 'utf8' })
+}
+
+function ideaMd({ platform = 'tiktok', status = 'pack-ready' } = {}) {
+  return `---
+run_id: RUN-demo
+status: ${status}
+created: 2026-08-28
+---
+
+# Idea
+
+- **one_liner:** Demo
+- **primary_platform:** ${platform}
+- **platforms:** ${platform}
+- **swipe_id:** none
+- **atoms:** none
+- **claim_id:** none
+`
+}
+
+const tiktokPack = {
+  schemaVersion: 'content-pack.v1',
+  platform: 'tiktok',
+  title: 'Demo',
+  pages: [
+    { role: 'hook', pageTemplateId: 'tpl_hook', slots: { text_0: 'a' } },
+    { role: 'value', pageTemplateId: 'tpl_value', slots: { text_0: 'b' } },
+    { role: 'value', pageTemplateId: 'tpl_value', slots: { text_0: 'c' } },
+    { role: 'cta', pageTemplateId: 'tpl_cta', slots: { text_0: 'd' } },
+  ],
+}
+
+try {
+  const ok = validateContentPack(tiktokPack)
+  assert.equal(ok.valid, true)
+
+  const short = validateContentPack({ ...tiktokPack, pages: tiktokPack.pages.slice(0, 3) })
+  assert.equal(short.valid, false)
+
+  const forbidden = validateContentPack({ ...tiktokPack, deck_template_id: 'x' })
+  assert.equal(forbidden.valid, false)
+
+  const badSlot = validateContentPack({ ...tiktokPack, pages: [{ ...tiktokPack.pages[0], slots: { text_0: [] } }, ...tiktokPack.pages.slice(1)] })
+  assert.equal(badSlot.valid, false)
+
+  const missingTemplate = validateContentPack({ ...tiktokPack, pages: [{ role: 'hook', slots: {} }, ...tiktokPack.pages.slice(1)] })
+  assert.equal(missingTemplate.valid, false)
+
+  const packFile = join(fixture, 'pack-tiktok.json')
+  writeFileSync(packFile, JSON.stringify(tiktokPack), 'utf8')
+  const packCli = run(validatePack, ['--file', packFile, '--platform', 'tiktok'])
+  assert.equal(packCli.status, 0)
+
+  const runDir = join(fixture, 'demo-run')
+  mkdirSync(runDir)
+  writeFileSync(join(runDir, 'idea.md'), ideaMd(), 'utf8')
+  writeFileSync(join(runDir, 'draft.md'), '# Draft\n', 'utf8')
+  writeFileSync(join(runDir, 'pack-tiktok.json'), JSON.stringify(tiktokPack), 'utf8')
+
+  const runCli = run(validateRun, ['--run', runDir, '--require-pack'])
+  assert.equal(runCli.status, 0)
+  const runReport = JSON.parse(runCli.stdout)
+  assert.equal(runReport.valid, true)
+
+  rmSync(join(runDir, 'pack-tiktok.json'))
+  const missingPack = run(validateRun, ['--run', runDir, '--require-pack'])
+  assert.equal(missingPack.status, 2)
+
+  const exportDir = join(fixture, 'exported')
+  mkdirSync(exportDir)
+  writeFileSync(join(exportDir, '01.png'), Buffer.from('89504e470d0a1a0a', 'hex'))
+  writeFileSync(join(exportDir, 'manifest.json'), JSON.stringify({ schema: 'template-export.v1', artifacts: [{ pageIndex: 0 }] }))
+  assert.equal(validateExportDirectory(exportDir, { expectedPages: 1 }).valid, true)
+
+  const exportedRun = join(fixture, 'exported-run')
+  mkdirSync(exportedRun)
+  writeFileSync(join(exportedRun, 'idea.md'), ideaMd({ platform: 'x', status: 'exported' }), 'utf8')
+  writeFileSync(join(exportedRun, 'draft.md'), '# Draft\n', 'utf8')
+  const exportedCli = run(validateRun, ['--run', exportedRun, '--export', exportDir, '--require-export'])
+  assert.equal(exportedCli.status, 0, exportedCli.stdout)
+
+  console.log('Content Skill validate smoke passed.')
+}
+finally {
+  rmSync(fixture, { recursive: true, force: true })
+}

package/skills/easysociable-content/scripts/workbench.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+import { spawn, spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, copyFileSync } from 'node:fs'
+import net from 'node:net'
+import { pathToFileURL } from 'node:url'
+import { join, resolve } from 'node:path'
+import { WORKBENCH_FILES, WORKBENCH_SRC } from './starter.mjs'
+
+export const WORKBENCH_PORT = 8765
+export const WORKBENCH_URL = `http://127.0.0.1:${WORKBENCH_PORT}/workbench/`
+
+function output(value, json) {
+  process.stdout.write(json ? `${JSON.stringify(value, null, 2)}\n` : `${value.message ?? value}\n`)
+}
+
+export function python3Bin() {
+  const result = spawnSync('python3', ['--version'], { encoding: 'utf8' })
+  if (result.status === 0) return 'python3'
+  return ''
+}
+
+export function portInUse(port = WORKBENCH_PORT) {
+  return new Promise((resolvePort) => {
+    const socket = net.connect({ port, host: '127.0.0.1' }, () => {
+      socket.end()
+      resolvePort(true)
+    })
+    socket.on('error', () => resolvePort(false))
+  })
+}
+
+export function ensureWorkbench(engine) {
+  const destDir = join(engine, 'workbench')
+  mkdirSync(destDir, { recursive: true })
+  const copied = []
+  const skipped = []
+  for (const name of WORKBENCH_FILES) {
+    const dest = join(destDir, name)
+    if (existsSync(dest)) {
+      skipped.push(name)
+      continue
+    }
+    copyFileSync(join(WORKBENCH_SRC, name), dest)
+    copied.push(name)
+  }
+  return { destDir, copied, skipped }
+}
+
+export function buildWorkbench(engine) {
+  const python = python3Bin()
+  if (!python) {
+    return { ok: false, code: 'PYTHON3_REQUIRED', message: 'python3 is required for the workbench. Install Python 3 and retry.' }
+  }
+  const script = join(engine, 'workbench', 'build.py')
+  if (!existsSync(script)) {
+    return { ok: false, code: 'WORKBENCH_MISSING', message: 'workbench/build.py is missing. Re-run setup --apply.' }
+  }
+  const result = spawnSync(python, [script], { encoding: 'utf8', cwd: engine })
+  if (result.status !== 0) {
+    return { ok: false, code: 'WORKBENCH_BUILD_FAILED', message: result.stderr.trim() || result.stdout.trim() || 'workbench build failed' }
+  }
+  return { ok: true, message: result.stdout.trim() }
+}
+
+export async function startWorkbench(engine, { noOpen = false } = {}) {
+  const python = python3Bin()
+  if (!python) {
+    return { ok: false, code: 'PYTHON3_REQUIRED', message: 'python3 is required for the workbench. Install Python 3 and retry.' }
+  }
+  ensureWorkbench(engine)
+  const built = buildWorkbench(engine)
+  if (!built.ok) return built
+  const url = WORKBENCH_URL
+  if (await portInUse()) {
+    if (!noOpen && process.env.EASYSOCIABLE_NO_OPEN !== 'true') openUrl(url)
+    return { ok: true, alreadyRunning: true, url, build: built.message }
+  }
+  const args = [join(engine, 'workbench', 'serve.py')]
+  if (noOpen) args.push('--no-open')
+  const child = spawn(python, args, { cwd: engine, detached: true, stdio: 'ignore' })
+  child.unref()
+  return { ok: true, alreadyRunning: false, url, pid: child.pid, build: built.message }
+}
+
+function openUrl(url) {
+  const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open'
+  const args = process.platform === 'win32' ? ['/c', 'start', url] : [url]
+  spawn(command, args, { stdio: 'ignore', detached: true }).unref()
+}
+
+function parseArgs(argv) {
+  const options = { engine: '', command: '', noOpen: false, json: false }
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--engine') options.engine = argv[++i] ?? ''
+    else if (arg === '--no-open') options.noOpen = true
+    else if (arg === '--json') options.json = true
+    else if (arg === '--help' || arg === '-h') options.help = true
+    else if (!arg.startsWith('--') && !options.command) options.command = arg
+    else throw new Error(`Unknown argument: ${arg}`)
+  }
+  return options
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2))
+  if (options.help) {
+    output({ usage: 'node workbench.mjs build|start --engine <Content Engine> [--no-open] [--json]' }, false)
+    return
+  }
+  if (!options.engine) throw new Error('--engine is required')
+  const engine = resolve(options.engine)
+  if (options.command === 'build') {
+    ensureWorkbench(engine)
+    const built = buildWorkbench(engine)
+    output(built, options.json)
+    if (!built.ok) process.exitCode = 2
+    return
+  }
+  if (options.command === 'start' || options.command === '') {
+    const started = await startWorkbench(engine, { noOpen: options.noOpen })
+    output(started, options.json)
+    if (!started.ok) process.exitCode = 2
+    return
+  }
+  throw new Error('Command must be build or start')
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  main().catch((error) => {
+    output({ code: 'WORKBENCH_FAILED', message: error instanceof Error ? error.message : String(error) }, true)
+    process.exitCode = 1
+  })
+}