@flextudio/scenario 0.1.0

package/node_modules/json-schema-traverse/spec/index.spec.js

@@ -0,0 +1,171 @@
+'use strict';
+
+var traverse = require('../index');
+var assert = require('assert');
+
+describe('json-schema-traverse', function() {
+  var calls;
+
+  beforeEach(function() {
+    calls = [];
+  });
+
+  it('should traverse all keywords containing schemas recursively', function() {
+    var schema = require('./fixtures/schema').schema;
+    var expectedCalls = require('./fixtures/schema').expectedCalls;
+
+    traverse(schema, {cb: callback});
+    assert.deepStrictEqual(calls, expectedCalls);
+  });
+
+  describe('Legacy v0.3.1 API', function() {
+    it('should traverse all keywords containing schemas recursively', function() {
+      var schema = require('./fixtures/schema').schema;
+      var expectedCalls = require('./fixtures/schema').expectedCalls;
+
+      traverse(schema, callback);
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+
+    it('should work when an options object is provided', function() {
+      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
+      var schema = require('./fixtures/schema').schema;
+      var expectedCalls = require('./fixtures/schema').expectedCalls;
+
+      traverse(schema, {}, callback);
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+  });
+
+
+  describe('allKeys option', function() {
+    var schema = {
+      someObject: {
+        minimum: 1,
+        maximum: 2
+      }
+    };
+
+    it('should traverse objects with allKeys: true option', function() {
+      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
+      var expectedCalls = [
+        [schema, '', schema, undefined, undefined, undefined, undefined],
+        [schema.someObject, '/someObject', schema, '', 'someObject', schema, undefined]
+      ];
+
+      traverse(schema, {allKeys: true, cb: callback});
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+
+
+    it('should NOT traverse objects with allKeys: false option', function() {
+      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
+      var expectedCalls = [
+        [schema, '', schema, undefined, undefined, undefined, undefined]
+      ];
+
+      traverse(schema, {allKeys: false, cb: callback});
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+
+
+    it('should NOT traverse objects without allKeys option', function() {
+      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
+      var expectedCalls = [
+        [schema, '', schema, undefined, undefined, undefined, undefined]
+      ];
+
+      traverse(schema, {cb: callback});
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+
+
+    it('should NOT travers objects in standard keywords which value is not a schema', function() {
+      var schema2 = {
+        const: {foo: 'bar'},
+        enum: ['a', 'b'],
+        required: ['foo'],
+        another: {
+
+        },
+        patternProperties: {}, // will not traverse - no properties
+        dependencies: true, // will not traverse - invalid
+        properties: {
+          smaller: {
+            type: 'number'
+          },
+          larger: {
+            type: 'number',
+            minimum: {$data: '1/smaller'}
+          }
+        }
+      };
+
+      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
+      var expectedCalls = [
+        [schema2, '', schema2, undefined, undefined, undefined, undefined],
+        [schema2.another, '/another', schema2, '', 'another', schema2, undefined],
+        [schema2.properties.smaller, '/properties/smaller', schema2, '', 'properties', schema2, 'smaller'],
+        [schema2.properties.larger, '/properties/larger', schema2, '', 'properties', schema2, 'larger'],
+      ];
+
+      traverse(schema2, {allKeys: true, cb: callback});
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+  });
+
+  describe('pre and post', function() {
+    var schema = {
+      type: 'object',
+      properties: {
+        name: {type: 'string'},
+        age: {type: 'number'}
+      }
+    };
+
+    it('should traverse schema in pre-order', function() {
+      traverse(schema, {cb: {pre}});
+      var expectedCalls = [
+        ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
+        ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
+        ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
+      ];
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+
+    it('should traverse schema in post-order', function() {
+      traverse(schema, {cb: {post}});
+      var expectedCalls = [
+        ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
+        ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
+        ['post', schema, '', schema, undefined, undefined, undefined, undefined],
+      ];
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+
+    it('should traverse schema in pre- and post-order at the same time', function() {
+      traverse(schema, {cb: {pre, post}});
+      var expectedCalls = [
+        ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
+        ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
+        ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
+        ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
+        ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
+        ['post', schema, '', schema, undefined, undefined, undefined, undefined],
+      ];
+      assert.deepStrictEqual(calls, expectedCalls);
+    });
+  });
+
+  function callback() {
+    calls.push(Array.prototype.slice.call(arguments));
+  }
+
+  function pre() {
+    calls.push(['pre'].concat(Array.prototype.slice.call(arguments)));
+  }
+
+  function post() {
+    calls.push(['post'].concat(Array.prototype.slice.call(arguments)));
+  }
+});

package/node_modules/require-from-string/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var Module = require('module');
+var path = require('path');
+
+module.exports = function requireFromString(code, filename, opts) {
+	if (typeof filename === 'object') {
+		opts = filename;
+		filename = undefined;
+	}
+
+	opts = opts || {};
+	filename = filename || '';
+
+	opts.appendPaths = opts.appendPaths || [];
+	opts.prependPaths = opts.prependPaths || [];
+
+	if (typeof code !== 'string') {
+		throw new Error('code must be a string, not ' + typeof code);
+	}
+
+	var paths = Module._nodeModulePaths(path.dirname(filename));
+
+	var parent = module.parent;
+	var m = new Module(filename, parent);
+	m.filename = filename;
+	m.paths = [].concat(opts.prependPaths).concat(paths).concat(opts.appendPaths);
+	m._compile(code, filename);
+
+	var exports = m.exports;
+	parent && parent.children && parent.children.splice(parent.children.indexOf(m), 1);
+
+	return exports;
+};

package/node_modules/require-from-string/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Vsevolod Strukchinsky <floatdrop@gmail.com> (github.com/floatdrop)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/require-from-string/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "require-from-string",
+  "version": "2.0.2",
+  "description": "Require module from string",
+  "license": "MIT",
+  "repository": "floatdrop/require-from-string",
+  "author": {
+    "name": "Vsevolod Strukchinsky",
+    "email": "floatdrop@gmail.com",
+    "url": "github.com/floatdrop"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    ""
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "*"
+  }
+}

package/node_modules/require-from-string/readme.md

@@ -0,0 +1,56 @@
+# require-from-string [![Build Status](https://travis-ci.org/floatdrop/require-from-string.svg?branch=master)](https://travis-ci.org/floatdrop/require-from-string)
+
+Load module from string in Node.
+
+## Install
+
+```
+$ npm install --save require-from-string
+```
+
+
+## Usage
+
+```js
+var requireFromString = require('require-from-string');
+
+requireFromString('module.exports = 1');
+//=> 1
+```
+
+
+## API
+
+### requireFromString(code, [filename], [options])
+
+#### code
+
+*Required*  
+Type: `string`
+
+Module code.
+
+#### filename
+Type: `string`  
+Default: `''`
+
+Optional filename.
+
+
+#### options
+Type: `object`
+
+##### appendPaths
+Type: `Array`
+
+List of `paths`, that will be appended to module `paths`. Useful, when you want
+to be able require modules from these paths.
+
+##### prependPaths
+Type: `Array`
+
+Same as `appendPaths`, but paths will be prepended.
+
+## License
+
+MIT © [Vsevolod Strukchinsky](http://github.com/floatdrop)

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@flextudio/scenario",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "flextudio meta-contract v1 시나리오 검증·카탈로그·세션 CLI + Claude Code Skill. MCP 서버 없이 SKILL.md 인라인 스키마로 시나리오를 만들고 자체 검증한다. otel 없는 클린 배포본. (벤치용 gen·otel 은 bench/cli_bench 로 분리)",
+  "bin": {
+    "flex-scenario": "bin/flex-scenario.mjs",
+    "fscn": "bin/flex-scenario.mjs"
+  },
+  "files": [
+    "bin",
+    "skill",
+    "commands",
+    "scripts",
+    "contract-data",
+    "README.md"
+  ],
+  "scripts": {
+    "prepack": "node scripts/prepack.mjs",
+    "postpack": "node scripts/postpack.mjs",
+    "postinstall": "node scripts/postinstall.mjs"
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "dependencies": {
+    "@flextudio/contract-core": "*",
+    "ajv": "^8.17.1"
+  },
+  "bundleDependencies": [
+    "@flextudio/contract-core",
+    "ajv",
+    "fast-deep-equal",
+    "fast-uri",
+    "json-schema-traverse",
+    "require-from-string"
+  ],
+  "keywords": [
+    "flextudio",
+    "scenario",
+    "meta-contract",
+    "claude-code",
+    "skill",
+    "cli"
+  ],
+  "license": "Apache-2.0",
+  "author": "flextudio",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/api-call.mjs

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+import { getAccessToken, runLogin, API_ORIGIN } from "./auth.mjs";
+
+const ENDPOINT = `${API_ORIGIN}/api/v1/cli/scenarios`;
+
+function parseArgs(args) {
+  const opts = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--file" || a === "-f") opts.file = args[(i += 1)];
+  }
+  return opts;
+}
+
+export async function runApiCall(args = [], retry = true) {
+  const { file } = parseArgs(args);
+  if (!file) {
+    process.stderr.write("usage: flex-scenario create --file <scenario.json>\n");
+    process.exit(2);
+  }
+
+  let fileBytes;
+  try {
+    fileBytes = readFileSync(file);
+  } catch (e) {
+    process.stderr.write(`시나리오 파일 읽기 실패: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  const token = await getAccessToken();
+  const url = new URL(ENDPOINT);
+
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/octet-stream",
+      },
+      body: fileBytes,
+    });
+    if (res.status === 401 && retry) {
+      process.stderr.write("Token rejected. Re-authenticating...\n");
+      await runLogin();
+      return runApiCall(args, false);
+    }
+    const text = await res.text();
+    process.stdout.write(`HTTP ${res.status} ${res.statusText}\n`);
+    process.stdout.write(text + (text.endsWith("\n") ? "" : "\n"));
+    if (!res.ok) process.exitCode = 1;
+  } catch (e) {
+    process.stderr.write(`호출 실패: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runApiCall(process.argv.slice(2)).then(() => process.exit(process.exitCode ?? 0));
+}

package/scripts/auth.mjs

@@ -0,0 +1,262 @@
+// auth.mjs — (mock) 로그인 / 로그아웃 목업 (하나의 파일).
+//
+//   login : http 서버를 임시 포트에 띄우고, 요청 1건을 받으면 그 입력값을 출력한 뒤
+//           서버를 닫고 끝낸다. (OAuth 로컬 콜백 흐름 흉내 — 실제 인증 없음)
+//           입력 추출: ?value= (query) → ?token= (query) → 요청 body → path
+//           curl "http://127.0.0.1:<port>/?value=내값"  처럼 한 번 보내면 된다.
+//   logout: "로그아웃" 출력 후 종료.
+
+import http from "node:http";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+
+import { TOKEN_PATH } from "./install-paths.mjs";
+
+const ISSUER = process.env.FLEX_OIDC_ISSUER || "https://flextudio.com/oauth";
+export const API_ORIGIN = new URL(ISSUER).origin;
+const CLIENT_ID = "flex-local-skill";
+
+const CALLBACK_HOST = "127.0.0.1";
+const CALLBACK_PORT = 53682;
+const REDIRECT_URI = `http://${CALLBACK_HOST}:${CALLBACK_PORT}/callback`;
+
+const SCOPE = "openid email profile offline_access";
+
+function base64Url(buffer) {
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+function sha256(input) {
+  return crypto.createHash("sha256").update(input).digest();
+}
+
+function randomString(bytes = 32) {
+  return base64Url(crypto.randomBytes(bytes));
+}
+
+async function discover() {
+  const response = await fetch(`${ISSUER}/.well-known/openid-configuration`);
+  if (!response.ok) throw new Error(`OIDC discovery failed: ${response.status}`);
+  return response.json();
+}
+
+function openBrowser(url) {
+  if (process.platform === "darwin") {
+    execFile("open", [url]);
+  } else if (process.platform === "win32") {
+    execFile("cmd", ["/c", "start", "", url]);
+  } else {
+    execFile("xdg-open", [url]);
+  }
+}
+
+function waitForCallback(expectedState) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      try {
+        const url = new URL(req.url || "", REDIRECT_URI);
+
+        if (url.pathname !== "/callback") {
+          res.statusCode = 404;
+          res.end("Not found");
+          return;
+        }
+
+        const error = url.searchParams.get("error");
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+
+        if (error) throw new Error(error);
+        if (!code) throw new Error("Missing authorization code");
+        if (state !== expectedState) throw new Error("Invalid OAuth state");
+
+        res.statusCode = 200;
+        res.setHeader("content-type", "text/html");
+        res.end("<h2>Flex authentication complete</h2><p>You can close this window.</p>");
+
+        server.close(() => resolve(code));
+      } catch (error) {
+        res.statusCode = 400;
+        res.end("Authentication failed.");
+        server.close(() => reject(error));
+      }
+    });
+
+    server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+      console.log(`Waiting for OAuth callback on ${REDIRECT_URI}`);
+    });
+  });
+}
+
+async function exchangeCode(tokenEndpoint, code, codeVerifier) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: CLIENT_ID,
+    code,
+    redirect_uri: REDIRECT_URI,
+    code_verifier: codeVerifier,
+  });
+
+  const response = await fetch(tokenEndpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body,
+  });
+
+  const json = await response.json();
+  if (!response.ok) throw new Error(`Token exchange failed: ${JSON.stringify(json)}`);
+  return json;
+}
+
+async function refreshToken(tokenEndpoint, refreshTokenValue) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: CLIENT_ID,
+    refresh_token: refreshTokenValue,
+  });
+
+  const response = await fetch(tokenEndpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body,
+  });
+
+  const json = await response.json();
+  if (!response.ok) throw new Error(`Token refresh failed: ${JSON.stringify(json)}`);
+  return json;
+}
+
+async function saveToken(token) {
+  await fs.mkdir(path.dirname(TOKEN_PATH), { recursive: true, mode: 0o700 });
+
+  const expiresAt = Date.now() + token.expires_in * 1000;
+
+  await fs.writeFile(
+    TOKEN_PATH,
+    JSON.stringify({ ...token, expires_at: expiresAt }, null, 2),
+    { encoding: "utf8", mode: 0o600 }
+  );
+  await fs.chmod(TOKEN_PATH, 0o600);
+}
+
+async function revokeToken(tokenValue, tokenTypeHint = "refresh_token") {
+  const metadata = await discover();
+
+  if (!metadata.revocation_endpoint) {
+    return;
+  }
+
+  const body = new URLSearchParams({
+    token: tokenValue,
+    token_type_hint: tokenTypeHint,
+    client_id: CLIENT_ID,
+  });
+
+  await fetch(metadata.revocation_endpoint, {
+    method: "POST",
+    headers: {
+      "content-type": "application/x-www-form-urlencoded",
+    },
+    body,
+  });
+}
+
+export async function getAccessToken() {
+  const metadata = await discover();
+
+  let token;
+
+  try {
+    token = JSON.parse(await fs.readFile(TOKEN_PATH, "utf8"));
+  } catch {
+    await runLogin();
+    token = JSON.parse(await fs.readFile(TOKEN_PATH, "utf8"));
+  }
+
+  const expiresSoon = Date.now() > token.expires_at - 60_000;
+
+  if (!expiresSoon) return token.access_token;
+
+  if (!token.refresh_token) {
+    await runLogin();
+    const updated = JSON.parse(await fs.readFile(TOKEN_PATH, "utf8"));
+    return updated.access_token;
+  }
+
+  let refreshed;
+  try {
+    refreshed = await refreshToken(metadata.token_endpoint, token.refresh_token);
+  } catch {
+    await runLogin();
+    const relogged = JSON.parse(await fs.readFile(TOKEN_PATH, "utf8"));
+    return relogged.access_token;
+  }
+
+  await saveToken({
+    ...token,
+    ...refreshed,
+    refresh_token: refreshed.refresh_token || token.refresh_token,
+  });
+
+  const updated = JSON.parse(await fs.readFile(TOKEN_PATH, "utf8"));
+  return updated.access_token;
+}
+
+export async function runLogin() {
+  const metadata = await discover();
+
+  const codeVerifier = randomString(64);
+  const codeChallenge = base64Url(sha256(codeVerifier));
+  const state = randomString(24);
+
+  const authUrl = new URL(metadata.authorization_endpoint);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", CLIENT_ID);
+  authUrl.searchParams.set("redirect_uri", REDIRECT_URI);
+  authUrl.searchParams.set("scope", SCOPE);
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+
+  const callbackPromise = waitForCallback(state);
+
+  console.log("Opening Flex IDE login...");
+  openBrowser(authUrl.toString());
+
+  const code = await callbackPromise;
+  const token = await exchangeCode(metadata.token_endpoint, code, codeVerifier);
+
+  await saveToken(token);
+
+  console.log("Flex authentication successful.");
+}
+
+export async function runLogout() {
+  let token;
+  try {
+    token = JSON.parse(await fs.readFile(TOKEN_PATH, "utf8"));
+  } catch {
+    console.log("No local Flex token.");
+    return;
+  }
+
+  try {
+    if (token.refresh_token) {
+      await revokeToken(token.refresh_token, "refresh_token");
+    }
+  } catch {
+    console.log("Token revocation skipped (server unreachable).");
+  }
+
+  await fs.rm(TOKEN_PATH, { force: true });
+  console.log("Logged out from Flex local skill.");
+}
+
+// 직접 실행도 가능: node scripts/auth.mjs login | logout
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const sub = process.argv[2];
+  const fn = sub === "logout" ? runLogout : runLogin;
+  fn().then(() => process.exit(0));
+}