@odyssey365/cli 0.0.0-stage → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +296 -2
- package/dist/args.js +348 -0
- package/dist/config.js +124 -0
- package/dist/files.js +58 -0
- package/dist/guide.js +113 -0
- package/dist/index.js +502 -0
- package/dist/oauth.js +258 -0
- package/dist/output.js +84 -0
- package/dist/rpc.js +176 -0
- package/dist/session.js +247 -0
- package/dist/tools.js +159 -0
- package/dist/watch-agent.js +45 -0
- package/dist/watch-events.js +78 -0
- package/dist/watch.js +181 -0
- package/examples/watch-agent/README.md +124 -0
- package/examples/watch-agent/config.example.json +20 -0
- package/examples/watch-agent/dispatcher.mjs +1443 -0
- package/examples/watch-agent/gitignore.template +6 -0
- package/examples/watch-agent/package.json +12 -0
- package/examples/watch-agent/test/dispatcher.test.mjs +763 -0
- package/examples/watch-agent/test/supervisor.test.mjs +126 -0
- package/package.json +50 -4
- package/prompts/watch-agent.md +250 -0
package/dist/index.js
ADDED
|
@@ -0,0 +1,502 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* Odyssey CLI — MCP 커넥터의 CLI 판.
|
|
4
|
+
*
|
|
5
|
+
* MCP 커넥터는 연결 하나 = 계정 하나라, 개인 계정과 운영(admin) 계정을 한 세션에서 오갈 수 없었다.
|
|
6
|
+
* CLI 는 같은 서버(`mcp_streamable`)의 같은 도구를 부르되 **호출마다 프로필(계정)을 고른다**:
|
|
7
|
+
*
|
|
8
|
+
* odyssey login # 개인 계정 → 프로필 default
|
|
9
|
+
* odyssey login -p admin # 운영 계정 → 프로필 admin
|
|
10
|
+
* odyssey list_todos --status inProgress
|
|
11
|
+
* odyssey -p admin list_snapshots
|
|
12
|
+
*
|
|
13
|
+
* 도구 정의는 서버가 정본이다(tools/list). CLI 는 이름·스키마를 받아 플래그를 맞출 뿐이라
|
|
14
|
+
* 서버에 도구가 늘면 CLI 배포 없이 바로 쓸 수 있다.
|
|
15
|
+
*
|
|
16
|
+
* 이력: document/90-process/work-log/261010 Odyssey CLI 다계정 프로필 MCP CLI판.md
|
|
17
|
+
*/
|
|
18
|
+
import { readFileSync } from 'node:fs';
|
|
19
|
+
import { dirname, join, resolve as resolvePath } from 'node:path';
|
|
20
|
+
import { fileURLToPath } from 'node:url';
|
|
21
|
+
import { createInterface } from 'node:readline';
|
|
22
|
+
import { AuthRequiredError, DEFAULT_PROFILE, DEFAULT_SERVER, UsageError, assertProfileName, credentialsPath, loadCredentials, normalizeServer, updateCredentials, } from './config.js';
|
|
23
|
+
import { extractGlobals, parseToolArgs, takeFlag } from './args.js';
|
|
24
|
+
import { discover, fetchUserInfo, interactiveLogin, registerClient, revokeTokenRemote } from './oauth.js';
|
|
25
|
+
import { NetworkError } from './rpc.js';
|
|
26
|
+
import { envServer, OdysseyClient, resolveTarget, selectedProfileName } from './session.js';
|
|
27
|
+
import { findTool, getTools, renderToolDetail, renderToolList, toolListJson } from './tools.js';
|
|
28
|
+
import { printToolResult, writeJson } from './output.js';
|
|
29
|
+
import { inlineImageFiles } from './files.js';
|
|
30
|
+
import { renderAgentGuide, renderSkill, renderSnippet } from './guide.js';
|
|
31
|
+
import { cmdWatch, WATCH_HELP } from './watch.js';
|
|
32
|
+
import { cmdWatchAgent, WATCH_AGENT_HELP } from './watch-agent.js';
|
|
33
|
+
const __dirname = dirname(fileURLToPath(import.meta.url));
|
|
34
|
+
const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')).version;
|
|
35
|
+
const HELP = `Odyssey CLI v${VERSION} — Odyssey 계정의 할일·메모·보드·스냅샷을 터미널과 AI 에이전트에서 다룬다.
|
|
36
|
+
|
|
37
|
+
AI 에이전트라면 먼저: odyssey agent-guide (사용법·로그인된 계정·서버 사용 지침)
|
|
38
|
+
|
|
39
|
+
사용법
|
|
40
|
+
odyssey <도구> [--파라미터 값 ...] 도구 실행 (예: odyssey list_todos --status inProgress)
|
|
41
|
+
odyssey tools [검색어] 도구 목록
|
|
42
|
+
odyssey describe <도구> 도구 설명·파라미터
|
|
43
|
+
|
|
44
|
+
계정
|
|
45
|
+
odyssey login [-p 이름] 브라우저로 로그인해 프로필에 저장
|
|
46
|
+
--no-browser(URL만 출력) · --with-key(API 키, 표준입력) · --default
|
|
47
|
+
odyssey logout [-p 이름] [--all] 로그아웃(서버 토큰 회수 + 로컬 삭제)
|
|
48
|
+
odyssey whoami [-p 이름] 프로필의 계정·연결 확인
|
|
49
|
+
odyssey profiles 로그인된 프로필 목록
|
|
50
|
+
odyssey use <이름> 기본 프로필 바꾸기
|
|
51
|
+
|
|
52
|
+
실시간 감시
|
|
53
|
+
odyssey watch-agent init <폴더> 감시 에이전트 예제를 새 폴더에 준비(설정·검사 포함)
|
|
54
|
+
odyssey watch [--tag 태그 ...] 내 할일(태그)·내 댓글 변화를 한 줄에 JSON 하나씩(NDJSON) 흘린다
|
|
55
|
+
자세히: odyssey watch --help
|
|
56
|
+
|
|
57
|
+
AI 에이전트
|
|
58
|
+
odyssey agent-guide 에이전트용 설명서(사용법 + 계정 + 서버 사용 지침 실시간)
|
|
59
|
+
odyssey agent-guide --skill Claude Code·Codex 스킬 파일(SKILL.md) 내용
|
|
60
|
+
odyssey agent-guide --snippet AGENTS.md·CLAUDE.md·GEMINI.md 에 붙일 짧은 절
|
|
61
|
+
odyssey agent-guide --watch-agent 감시 에이전트(watch → 세션 깨우기, 답글은 세션이)를 만들게 하는 프롬프트
|
|
62
|
+
|
|
63
|
+
전역 옵션
|
|
64
|
+
-p, --profile <이름> 이번 실행의 계정. 기본: ODYSSEY_PROFILE → odyssey use 값 → default
|
|
65
|
+
-o, --output <형식> json(기본) · text(요약 텍스트) · raw(MCP 결과 전체)
|
|
66
|
+
--json <JSON> 파라미터를 JSON 객체로 한 번에 (플래그가 그 위에 덮인다)
|
|
67
|
+
--input <파일|-> 파라미터 JSON 을 파일·표준입력에서
|
|
68
|
+
--refresh-tools 도구 목록 캐시를 새로 받기
|
|
69
|
+
--server <URL> 서버 (기본 ${DEFAULT_SERVER})
|
|
70
|
+
|
|
71
|
+
파라미터 적는 법
|
|
72
|
+
--key 값 · --key=값 · --flag · --no-flag · 반복 --tags a --tags b · 점 경로 --deadline.endTime <ISO>
|
|
73
|
+
JSON 값 --checklist '[{"title":"a"}]' · null --deadline null
|
|
74
|
+
필수 파라미터가 하나면 위치 인자로: odyssey get_todo <todoId>
|
|
75
|
+
도구 파라미터가 전역 옵션과 겹치면 -- 뒤에 적는다
|
|
76
|
+
|
|
77
|
+
환경변수
|
|
78
|
+
ODYSSEY_PROFILE · ODYSSEY_TOKEN(저장 없이 토큰 직접: odk_ API 키 / oat_ 토큰) · ODYSSEY_MCP_URL
|
|
79
|
+
ODYSSEY_CONFIG_DIR(기본 ~/.odyssey/cli) · ODYSSEY_OUTPUT_DIR(이미지 저장) · ODYSSEY_TIMEOUT_MS · ODYSSEY_PRETTY=1
|
|
80
|
+
|
|
81
|
+
출력: 결과는 stdout(JSON — 파이프면 한 줄), 안내·오류는 stderr.
|
|
82
|
+
종료 코드: 0 성공 · 1 도구 오류 · 2 사용법 · 3 로그인 필요 · 4 네트워크
|
|
83
|
+
`;
|
|
84
|
+
function err(line) {
|
|
85
|
+
process.stderr.write(line + '\n');
|
|
86
|
+
}
|
|
87
|
+
function profileFlag(name) {
|
|
88
|
+
return name === DEFAULT_PROFILE ? '' : ` -p ${name}`;
|
|
89
|
+
}
|
|
90
|
+
async function readStdin() {
|
|
91
|
+
const chunks = [];
|
|
92
|
+
for await (const c of process.stdin)
|
|
93
|
+
chunks.push(c);
|
|
94
|
+
return Buffer.concat(chunks).toString('utf-8');
|
|
95
|
+
}
|
|
96
|
+
/** 화면에 찍지 않고 한 줄 입력받는다(API 키). */
|
|
97
|
+
async function promptHidden(question) {
|
|
98
|
+
const rl = createInterface({ input: process.stdin, output: process.stderr, terminal: true });
|
|
99
|
+
const anyRl = rl;
|
|
100
|
+
let muted = false;
|
|
101
|
+
const orig = anyRl._writeToOutput.bind(rl);
|
|
102
|
+
anyRl._writeToOutput = (s) => {
|
|
103
|
+
if (!muted)
|
|
104
|
+
orig(s);
|
|
105
|
+
};
|
|
106
|
+
return new Promise((resolve) => {
|
|
107
|
+
rl.question(question, (answer) => {
|
|
108
|
+
rl.close();
|
|
109
|
+
process.stderr.write('\n');
|
|
110
|
+
resolve(answer.trim());
|
|
111
|
+
});
|
|
112
|
+
muted = true;
|
|
113
|
+
});
|
|
114
|
+
}
|
|
115
|
+
async function readInputObject(g) {
|
|
116
|
+
let raw;
|
|
117
|
+
let label = '';
|
|
118
|
+
if (g.inputFile !== undefined) {
|
|
119
|
+
raw = g.inputFile === '-' ? await readStdin() : readFileSync(g.inputFile, 'utf-8');
|
|
120
|
+
label = `--input ${g.inputFile}`;
|
|
121
|
+
}
|
|
122
|
+
let base = {};
|
|
123
|
+
const parse = (text, from) => {
|
|
124
|
+
let v;
|
|
125
|
+
try {
|
|
126
|
+
v = JSON.parse(text);
|
|
127
|
+
}
|
|
128
|
+
catch (e) {
|
|
129
|
+
throw new UsageError(`${from} 의 JSON 을 읽지 못했습니다: ${e.message}`);
|
|
130
|
+
}
|
|
131
|
+
if (!v || typeof v !== 'object' || Array.isArray(v)) {
|
|
132
|
+
throw new UsageError(`${from} 는 JSON 객체여야 합니다.`);
|
|
133
|
+
}
|
|
134
|
+
return v;
|
|
135
|
+
};
|
|
136
|
+
if (raw !== undefined)
|
|
137
|
+
base = parse(raw, label);
|
|
138
|
+
if (g.inputJson !== undefined)
|
|
139
|
+
base = { ...base, ...parse(g.inputJson, '--json') };
|
|
140
|
+
return base;
|
|
141
|
+
}
|
|
142
|
+
// ── 계정 명령 ────────────────────────────────────────────────────────────────
|
|
143
|
+
async function cmdLogin(g, args) {
|
|
144
|
+
const withKey = takeFlag(args, '--with-key');
|
|
145
|
+
const noBrowser = takeFlag(args, '--no-browser');
|
|
146
|
+
const makeDefault = takeFlag(args, '--default');
|
|
147
|
+
if (args.length)
|
|
148
|
+
throw new UsageError(`login 이 모르는 인자: ${args.join(' ')}`);
|
|
149
|
+
const name = g.profile ?? process.env.ODYSSEY_PROFILE?.trim() ?? DEFAULT_PROFILE;
|
|
150
|
+
assertProfileName(name);
|
|
151
|
+
const before = loadCredentials();
|
|
152
|
+
const previous = before.profiles[name];
|
|
153
|
+
const server = normalizeServer(g.server ?? envServer() ?? previous?.server ?? DEFAULT_SERVER);
|
|
154
|
+
let credential;
|
|
155
|
+
let account;
|
|
156
|
+
if (withKey) {
|
|
157
|
+
const key = process.stdin.isTTY ? await promptHidden('API 키(odk_…): ') : (await readStdin()).trim();
|
|
158
|
+
if (!key)
|
|
159
|
+
throw new UsageError('API 키가 비어 있습니다. Odyssey 앱 › 설정 › MCP 연동에서 발급하세요.');
|
|
160
|
+
credential = { type: 'apiKey', apiKey: key };
|
|
161
|
+
const probe = new OdysseyClient({ profileName: name, server, profile: { server, credential, savedAt: '' } }, VERSION);
|
|
162
|
+
await probe.ping();
|
|
163
|
+
}
|
|
164
|
+
else {
|
|
165
|
+
err(`프로필 "${name}" 로그인 — ${server}`);
|
|
166
|
+
const meta = await discover(server);
|
|
167
|
+
const clientId = await registerClient(server, meta, VERSION);
|
|
168
|
+
const tokens = await interactiveLogin({
|
|
169
|
+
server,
|
|
170
|
+
meta,
|
|
171
|
+
clientId,
|
|
172
|
+
launchBrowser: !noBrowser,
|
|
173
|
+
onAuthorizeUrl: (url) => {
|
|
174
|
+
err(noBrowser ? '아래 주소를 이 컴퓨터의 브라우저에서 여세요:' : '브라우저에서 로그인하세요. 열리지 않으면 아래 주소를 여세요:');
|
|
175
|
+
err(url);
|
|
176
|
+
err('로그인을 기다리는 중… (10분)');
|
|
177
|
+
},
|
|
178
|
+
});
|
|
179
|
+
credential = {
|
|
180
|
+
type: 'oauth',
|
|
181
|
+
clientId,
|
|
182
|
+
accessToken: tokens.access_token,
|
|
183
|
+
...(tokens.refresh_token ? { refreshToken: tokens.refresh_token } : {}),
|
|
184
|
+
...(tokens.expires_in ? { expiresAt: new Date(Date.now() + tokens.expires_in * 1000).toISOString() } : {}),
|
|
185
|
+
...(tokens.scope ? { scope: tokens.scope } : {}),
|
|
186
|
+
};
|
|
187
|
+
account = (await fetchUserInfo(server, meta, tokens.access_token)) ?? undefined;
|
|
188
|
+
}
|
|
189
|
+
const isDefault = updateCredentials((file) => {
|
|
190
|
+
file.profiles[name] = { server, credential, ...(account ? { account } : {}), savedAt: new Date().toISOString() };
|
|
191
|
+
if (makeDefault || !file.defaultProfile || !file.profiles[file.defaultProfile])
|
|
192
|
+
file.defaultProfile = name;
|
|
193
|
+
return file.defaultProfile === name;
|
|
194
|
+
});
|
|
195
|
+
// 같은 프로필 이름에 다른 계정이 들어왔으면 알린다(운영 계정 자리에 개인 계정을 넣는 실수).
|
|
196
|
+
if (previous?.account && account && previous.account.uid !== account.uid) {
|
|
197
|
+
err(`주의: 프로필 "${name}" 은 원래 ${previous.account.email ?? previous.account.uid} 였습니다 — 이제 ${account.email ?? account.uid} 입니다.`);
|
|
198
|
+
}
|
|
199
|
+
const who = account ? `${account.email ?? '(이메일 없음)'} · uid ${account.uid}` : 'API 키';
|
|
200
|
+
process.stdout.write(`✓ 프로필 "${name}" 로그인: ${who}${isDefault ? ' (기본 프로필)' : ''}\n`);
|
|
201
|
+
if (!isDefault)
|
|
202
|
+
process.stdout.write(` 사용: odyssey -p ${name} <도구> · 기본으로: odyssey use ${name}\n`);
|
|
203
|
+
return 0;
|
|
204
|
+
}
|
|
205
|
+
async function cmdLogout(g, args) {
|
|
206
|
+
const all = takeFlag(args, '--all');
|
|
207
|
+
if (args.length)
|
|
208
|
+
throw new UsageError(`logout 이 모르는 인자: ${args.join(' ')}`);
|
|
209
|
+
const file = loadCredentials();
|
|
210
|
+
const names = all ? Object.keys(file.profiles) : [selectedProfileName(g)];
|
|
211
|
+
if (names.length === 0) {
|
|
212
|
+
err('로그인된 프로필이 없습니다.');
|
|
213
|
+
return 0;
|
|
214
|
+
}
|
|
215
|
+
for (const name of names) {
|
|
216
|
+
const p = file.profiles[name];
|
|
217
|
+
if (!p) {
|
|
218
|
+
err(`프로필 "${name}" 은 로그인되어 있지 않습니다.`);
|
|
219
|
+
continue;
|
|
220
|
+
}
|
|
221
|
+
let remote = '';
|
|
222
|
+
if (p.credential.type === 'oauth') {
|
|
223
|
+
try {
|
|
224
|
+
const meta = await discover(p.server);
|
|
225
|
+
// 리프레시를 회수하면 서버가 짝 액세스 토큰도 함께 회수한다.
|
|
226
|
+
const token = p.credential.refreshToken ?? p.credential.accessToken;
|
|
227
|
+
const revoked = await revokeTokenRemote(p.server, meta, p.credential.clientId, token);
|
|
228
|
+
remote = revoked ? ' · 서버 토큰 회수됨' : ' · 서버가 회수를 지원하지 않아 로컬에서만 지웠습니다';
|
|
229
|
+
}
|
|
230
|
+
catch (e) {
|
|
231
|
+
remote = ` · 서버 토큰 회수 실패(${e.message}) — 로컬에서만 지웠습니다`;
|
|
232
|
+
}
|
|
233
|
+
}
|
|
234
|
+
else {
|
|
235
|
+
remote = ' · API 키는 앱 › 설정 › MCP 연동에서 폐기하세요';
|
|
236
|
+
}
|
|
237
|
+
updateCredentials((f) => {
|
|
238
|
+
delete f.profiles[name];
|
|
239
|
+
if (f.defaultProfile === name)
|
|
240
|
+
delete f.defaultProfile;
|
|
241
|
+
});
|
|
242
|
+
process.stdout.write(`✓ 프로필 "${name}" 로그아웃${remote}\n`);
|
|
243
|
+
}
|
|
244
|
+
return 0;
|
|
245
|
+
}
|
|
246
|
+
async function cmdWhoami(g, args) {
|
|
247
|
+
if (args.length)
|
|
248
|
+
throw new UsageError(`whoami 가 모르는 인자: ${args.join(' ')}`);
|
|
249
|
+
const target = resolveTarget(g);
|
|
250
|
+
const client = new OdysseyClient(target, VERSION);
|
|
251
|
+
const cred = target.profile?.credential;
|
|
252
|
+
let account = target.profile?.account;
|
|
253
|
+
if (cred?.type === 'oauth') {
|
|
254
|
+
const info = await client.userInfo();
|
|
255
|
+
if (!info)
|
|
256
|
+
throw new AuthRequiredError(`프로필 "${target.profileName}" 의 로그인이 풀렸습니다. 다시 로그인: odyssey login${profileFlag(target.profileName)}`);
|
|
257
|
+
account = info;
|
|
258
|
+
}
|
|
259
|
+
else {
|
|
260
|
+
await client.ping();
|
|
261
|
+
}
|
|
262
|
+
const after = target.profile?.credential;
|
|
263
|
+
writeJson({
|
|
264
|
+
profile: target.profileName,
|
|
265
|
+
server: target.server,
|
|
266
|
+
auth: target.envToken ? 'env' : cred?.type,
|
|
267
|
+
uid: account?.uid ?? null,
|
|
268
|
+
email: account?.email ?? null,
|
|
269
|
+
...(after?.type === 'oauth' && after.expiresAt ? { accessTokenExpiresAt: after.expiresAt } : {}),
|
|
270
|
+
ok: true,
|
|
271
|
+
});
|
|
272
|
+
return 0;
|
|
273
|
+
}
|
|
274
|
+
function cmdProfiles(g, args) {
|
|
275
|
+
if (args.length)
|
|
276
|
+
throw new UsageError(`profiles 가 모르는 인자: ${args.join(' ')}`);
|
|
277
|
+
const file = loadCredentials();
|
|
278
|
+
const entries = Object.entries(file.profiles);
|
|
279
|
+
if (g.output === 'json') {
|
|
280
|
+
writeJson(entries.map(([name, p]) => ({
|
|
281
|
+
name,
|
|
282
|
+
default: file.defaultProfile === name,
|
|
283
|
+
server: p.server,
|
|
284
|
+
auth: p.credential.type,
|
|
285
|
+
uid: p.account?.uid ?? null,
|
|
286
|
+
email: p.account?.email ?? null,
|
|
287
|
+
})));
|
|
288
|
+
return 0;
|
|
289
|
+
}
|
|
290
|
+
if (entries.length === 0) {
|
|
291
|
+
process.stdout.write('로그인된 프로필이 없습니다. 먼저: odyssey login\n');
|
|
292
|
+
return 0;
|
|
293
|
+
}
|
|
294
|
+
const width = Math.max(...entries.map(([n]) => n.length));
|
|
295
|
+
for (const [name, p] of entries) {
|
|
296
|
+
const mark = file.defaultProfile === name ? '*' : ' ';
|
|
297
|
+
const who = p.account ? `${p.account.email ?? '(이메일 없음)'} ${p.account.uid}` : '(API 키)';
|
|
298
|
+
const server = normalizeServer(p.server) === DEFAULT_SERVER ? '' : ` ${p.server}`;
|
|
299
|
+
process.stdout.write(`${mark} ${name.padEnd(width)} ${who}${server}\n`);
|
|
300
|
+
}
|
|
301
|
+
process.stdout.write(`\n* = 기본 프로필 · 자격증명: ${credentialsPath()}\n`);
|
|
302
|
+
return 0;
|
|
303
|
+
}
|
|
304
|
+
function cmdUse(_g, args) {
|
|
305
|
+
const name = args[0];
|
|
306
|
+
if (!name || args.length > 1)
|
|
307
|
+
throw new UsageError('사용법: odyssey use <프로필>');
|
|
308
|
+
assertProfileName(name);
|
|
309
|
+
updateCredentials((file) => {
|
|
310
|
+
if (!file.profiles[name]) {
|
|
311
|
+
throw new AuthRequiredError(`프로필 "${name}" 에 로그인되어 있지 않습니다. 먼저: odyssey login${profileFlag(name)}`);
|
|
312
|
+
}
|
|
313
|
+
file.defaultProfile = name;
|
|
314
|
+
});
|
|
315
|
+
process.stdout.write(`✓ 기본 프로필: ${name}\n`);
|
|
316
|
+
return 0;
|
|
317
|
+
}
|
|
318
|
+
// ── 에이전트 설명서 ──────────────────────────────────────────────────────────
|
|
319
|
+
async function cmdAgentGuide(g, args) {
|
|
320
|
+
const skill = takeFlag(args, '--skill');
|
|
321
|
+
const snippet = takeFlag(args, '--snippet');
|
|
322
|
+
const watchAgent = takeFlag(args, '--watch-agent');
|
|
323
|
+
if (args.length || [skill, snippet, watchAgent].filter(Boolean).length > 1) {
|
|
324
|
+
throw new UsageError('사용법: odyssey agent-guide [--skill | --snippet | --watch-agent]');
|
|
325
|
+
}
|
|
326
|
+
// 감시 에이전트(디스패처)를 코딩 에이전트에게 만들게 하는 프롬프트 — 패키지의 prompts/watch-agent.md 그대로.
|
|
327
|
+
// 이력: document/90-process/work-log/261016 Odyssey CLI 감시 에이전트 만들기 프롬프트 watch-agent.md
|
|
328
|
+
// document/90-process/work-log/261018 컴패니언 백그라운드 끊김 이어 하기 CompanionAppPresence 감시 에이전트 A.md(A안 — 배달만)
|
|
329
|
+
if (watchAgent) {
|
|
330
|
+
process.stdout.write(readFileSync(join(__dirname, '..', 'prompts', 'watch-agent.md'), 'utf-8'));
|
|
331
|
+
return 0;
|
|
332
|
+
}
|
|
333
|
+
if (skill || snippet) {
|
|
334
|
+
process.stdout.write(skill ? renderSkill() : renderSnippet());
|
|
335
|
+
return 0;
|
|
336
|
+
}
|
|
337
|
+
const file = loadCredentials();
|
|
338
|
+
const profiles = Object.entries(file.profiles).map(([name, p]) => ({
|
|
339
|
+
name,
|
|
340
|
+
isDefault: file.defaultProfile === name,
|
|
341
|
+
auth: p.credential.type,
|
|
342
|
+
...(p.account?.email ? { email: p.account.email } : {}),
|
|
343
|
+
...(p.account?.uid ? { uid: p.account.uid } : {}),
|
|
344
|
+
}));
|
|
345
|
+
const envToken = !!(process.env.ODYSSEY_TOKEN ?? process.env.ODYSSEY_API_KEY ?? '').trim();
|
|
346
|
+
// 서버 사용 지침 — 로그인 전이거나 연결이 안 돼도 설명서는 낸다(그 사실을 적어서).
|
|
347
|
+
let server = normalizeServer(g.server ?? envServer() ?? DEFAULT_SERVER);
|
|
348
|
+
let instructionsFrom = null;
|
|
349
|
+
let serverInstructions;
|
|
350
|
+
let serverInstructionsError;
|
|
351
|
+
try {
|
|
352
|
+
const target = resolveTarget(g);
|
|
353
|
+
server = target.server;
|
|
354
|
+
instructionsFrom = target.profileName;
|
|
355
|
+
serverInstructions = (await new OdysseyClient(target, VERSION).serverInfo()).instructions;
|
|
356
|
+
if (!serverInstructions)
|
|
357
|
+
serverInstructionsError = '서버가 지침을 보내지 않았다';
|
|
358
|
+
}
|
|
359
|
+
catch (e) {
|
|
360
|
+
serverInstructionsError =
|
|
361
|
+
e instanceof AuthRequiredError ? '로그인 전' : e instanceof NetworkError ? '서버에 연결하지 못함' : e.message;
|
|
362
|
+
}
|
|
363
|
+
process.stdout.write(renderAgentGuide({
|
|
364
|
+
version: VERSION,
|
|
365
|
+
server,
|
|
366
|
+
profiles,
|
|
367
|
+
envToken,
|
|
368
|
+
instructionsFrom,
|
|
369
|
+
...(serverInstructions ? { serverInstructions } : {}),
|
|
370
|
+
...(serverInstructionsError ? { serverInstructionsError } : {}),
|
|
371
|
+
}));
|
|
372
|
+
return 0;
|
|
373
|
+
}
|
|
374
|
+
// ── 도구 명령 ────────────────────────────────────────────────────────────────
|
|
375
|
+
async function cmdTools(g, args) {
|
|
376
|
+
if (args.length > 1)
|
|
377
|
+
throw new UsageError('사용법: odyssey tools [검색어]');
|
|
378
|
+
const client = new OdysseyClient(resolveTarget(g), VERSION);
|
|
379
|
+
const tools = await getTools(client, { refresh: g.refreshTools });
|
|
380
|
+
if (g.output === 'json' || g.output === 'raw') {
|
|
381
|
+
writeJson(g.output === 'raw' ? tools : toolListJson(tools));
|
|
382
|
+
}
|
|
383
|
+
else {
|
|
384
|
+
process.stdout.write(renderToolList(tools, args[0]) + '\n');
|
|
385
|
+
}
|
|
386
|
+
return 0;
|
|
387
|
+
}
|
|
388
|
+
async function cmdDescribe(g, args) {
|
|
389
|
+
if (args.length !== 1)
|
|
390
|
+
throw new UsageError('사용법: odyssey describe <도구>');
|
|
391
|
+
const client = new OdysseyClient(resolveTarget(g), VERSION);
|
|
392
|
+
const tool = await findTool(client, args[0], { refresh: g.refreshTools });
|
|
393
|
+
if (g.output === 'json' || g.output === 'raw')
|
|
394
|
+
writeJson(tool);
|
|
395
|
+
else
|
|
396
|
+
process.stdout.write(renderToolDetail(tool) + '\n');
|
|
397
|
+
return 0;
|
|
398
|
+
}
|
|
399
|
+
async function cmdCall(g, toolName, tokens) {
|
|
400
|
+
const client = new OdysseyClient(resolveTarget(g), VERSION);
|
|
401
|
+
const tool = await findTool(client, toolName, { refresh: g.refreshTools });
|
|
402
|
+
const base = await readInputObject(g);
|
|
403
|
+
const { args, positionals } = parseToolArgs(tokens, tool.inputSchema, base);
|
|
404
|
+
if (positionals.length) {
|
|
405
|
+
const req = tool.inputSchema?.required ?? [];
|
|
406
|
+
throw new UsageError(`${tool.name} 에 위치 인자 ${positionals.map((p) => JSON.stringify(p)).join(' ')} 를 둘 자리가 없습니다.` +
|
|
407
|
+
(req.length ? ` 필수 파라미터: ${req.map((k) => `--${k}`).join(' ')}` : '') +
|
|
408
|
+
`\n자세히: odyssey describe ${tool.name}`);
|
|
409
|
+
}
|
|
410
|
+
// 필수 누락은 서버의 zod 오류 덤프 대신 여기서 바로 알린다(최상위만 — 안쪽은 서버가 본다).
|
|
411
|
+
const missing = (tool.inputSchema?.required ?? []).filter((k) => args[k] === undefined);
|
|
412
|
+
if (missing.length) {
|
|
413
|
+
throw new UsageError(`${tool.name} 에 필수 파라미터가 빠졌습니다: ${missing.map((k) => `--${k}`).join(' ')}` +
|
|
414
|
+
(missing.length === 1 && (tool.inputSchema?.required ?? []).length === 1 ? ' (위치 인자로도 됩니다)' : '') +
|
|
415
|
+
`\n자세히: odyssey describe ${tool.name}`);
|
|
416
|
+
}
|
|
417
|
+
// 사진 칸의 로컬 파일(image.file)을 바이트로 바꿔 싣는다 — 상대 경로는 --input 파일 옆 기준.
|
|
418
|
+
const baseDir = g.inputFile && g.inputFile !== '-' ? dirname(resolvePath(g.inputFile)) : process.cwd();
|
|
419
|
+
inlineImageFiles(args, baseDir);
|
|
420
|
+
const result = await client.callTool(tool.name, args);
|
|
421
|
+
return printToolResult(result, g.output ?? 'json', tool.name);
|
|
422
|
+
}
|
|
423
|
+
// ── 진입 ─────────────────────────────────────────────────────────────────────
|
|
424
|
+
const ACCOUNT_COMMANDS = new Set(['login', 'logout', 'whoami', 'profiles', 'use', 'agent-guide', 'watch', 'watch-agent']);
|
|
425
|
+
async function main(argv) {
|
|
426
|
+
const { globals: g, rest } = extractGlobals(argv);
|
|
427
|
+
if (g.profile !== undefined)
|
|
428
|
+
assertProfileName(g.profile);
|
|
429
|
+
const [command, ...args] = rest;
|
|
430
|
+
if (g.version && !command) {
|
|
431
|
+
process.stdout.write(`${VERSION}\n`);
|
|
432
|
+
return 0;
|
|
433
|
+
}
|
|
434
|
+
if (!command || command === 'help') {
|
|
435
|
+
if (command === 'help' && args[0])
|
|
436
|
+
return cmdDescribe(g, [args[0]]);
|
|
437
|
+
process.stdout.write(HELP);
|
|
438
|
+
return command || g.help ? 0 : 2;
|
|
439
|
+
}
|
|
440
|
+
if (g.help && command === 'watch') {
|
|
441
|
+
process.stdout.write(`${WATCH_HELP}\n`);
|
|
442
|
+
return 0;
|
|
443
|
+
}
|
|
444
|
+
if (g.help && command === 'watch-agent') {
|
|
445
|
+
process.stdout.write(`${WATCH_AGENT_HELP}\n`);
|
|
446
|
+
return 0;
|
|
447
|
+
}
|
|
448
|
+
if (g.help) {
|
|
449
|
+
// odyssey <도구> --help → 그 도구 설명
|
|
450
|
+
if (!ACCOUNT_COMMANDS.has(command) && command !== 'tools' && command !== 'describe' && command !== 'call') {
|
|
451
|
+
return cmdDescribe(g, [command]);
|
|
452
|
+
}
|
|
453
|
+
process.stdout.write(HELP);
|
|
454
|
+
return 0;
|
|
455
|
+
}
|
|
456
|
+
switch (command) {
|
|
457
|
+
case 'login':
|
|
458
|
+
return cmdLogin(g, args);
|
|
459
|
+
case 'logout':
|
|
460
|
+
return cmdLogout(g, args);
|
|
461
|
+
case 'whoami':
|
|
462
|
+
return cmdWhoami(g, args);
|
|
463
|
+
case 'profiles':
|
|
464
|
+
return cmdProfiles(g, args);
|
|
465
|
+
case 'use':
|
|
466
|
+
return cmdUse(g, args);
|
|
467
|
+
case 'agent-guide':
|
|
468
|
+
return cmdAgentGuide(g, args);
|
|
469
|
+
case 'watch':
|
|
470
|
+
return cmdWatch(g, args, VERSION);
|
|
471
|
+
case 'watch-agent':
|
|
472
|
+
return cmdWatchAgent(g, args);
|
|
473
|
+
case 'tools':
|
|
474
|
+
return cmdTools(g, args);
|
|
475
|
+
case 'describe':
|
|
476
|
+
return cmdDescribe(g, args);
|
|
477
|
+
case 'call': {
|
|
478
|
+
const [toolName, ...tokens] = args;
|
|
479
|
+
if (!toolName)
|
|
480
|
+
throw new UsageError('사용법: odyssey call <도구> [--파라미터 값 ...]');
|
|
481
|
+
return cmdCall(g, toolName, tokens);
|
|
482
|
+
}
|
|
483
|
+
default:
|
|
484
|
+
return cmdCall(g, command, args);
|
|
485
|
+
}
|
|
486
|
+
}
|
|
487
|
+
main(process.argv.slice(2))
|
|
488
|
+
.then((code) => {
|
|
489
|
+
process.exitCode = code;
|
|
490
|
+
})
|
|
491
|
+
.catch((e) => {
|
|
492
|
+
const message = e instanceof Error ? e.message : String(e);
|
|
493
|
+
err(`odyssey: ${message}`);
|
|
494
|
+
if (e instanceof UsageError)
|
|
495
|
+
process.exitCode = 2;
|
|
496
|
+
else if (e instanceof AuthRequiredError)
|
|
497
|
+
process.exitCode = 3;
|
|
498
|
+
else if (e instanceof NetworkError)
|
|
499
|
+
process.exitCode = 4;
|
|
500
|
+
else
|
|
501
|
+
process.exitCode = 1;
|
|
502
|
+
});
|