@easysociable/cli 0.1.1 → 0.1.3

package/content-engine/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/content-engine/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
+  })
+}