@online5880/opensession 0.1.0

package/README.md

@@ -0,0 +1,30 @@
+# @online5880/opensession
+
+MVP CLI for session continuity with Supabase.
+
+## Commands
+
+- `init --url --anon-key [--project-key] [--actor]`
+- `login --actor`
+- `start --project-key [--project-name] [--actor]`
+- `resume --session-id [--actor]`
+- `status [--project-key]`
+- `log [--session-id] [--limit]`
+
+## Quick start
+
+```bash
+npm install
+node src/cli.js init --url "$SUPABASE_URL" --anon-key "$SUPABASE_ANON_KEY" --project-key demo --actor mane
+node src/cli.js start --project-key demo
+node src/cli.js status
+node src/cli.js log
+```
+
+Apply `sql/schema.sql` in Supabase SQL editor before using the CLI.
+
+## npx 실행
+
+```bash
+npx @online5880/opensession init
+```

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@online5880/opensession",
+  "version": "0.1.0",
+  "description": "Session continuity bridge CLI with Supabase backend",
+  "type": "module",
+  "bin": {
+    "opensession": "src/cli.js"
+  },
+  "scripts": {
+    "start": "node src/cli.js",
+    "lint": "sh -c 'for f in src/*.js; do node --check \"$f\"; done'"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.52.1",
+    "commander": "^14.0.1"
+  }
+}

package/sql/schema.sql

@@ -0,0 +1,27 @@
+create table if not exists projects (
+  id uuid primary key default gen_random_uuid(),
+  project_key text unique not null,
+  name text not null,
+  created_at timestamptz not null default now()
+);
+
+create table if not exists sessions (
+  id uuid primary key default gen_random_uuid(),
+  project_id uuid not null references projects(id) on delete cascade,
+  actor text not null,
+  status text not null default 'active',
+  started_at timestamptz not null default now(),
+  ended_at timestamptz
+);
+
+create index if not exists sessions_project_status_idx on sessions(project_id, status);
+
+create table if not exists session_events (
+  id uuid primary key default gen_random_uuid(),
+  session_id uuid not null references sessions(id) on delete cascade,
+  type text not null,
+  payload jsonb not null default '{}'::jsonb,
+  created_at timestamptz not null default now()
+);
+
+create index if not exists session_events_session_created_idx on session_events(session_id, created_at);

package/src/cli.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import {
+  appendEvent,
+  ensureProject,
+  getClient,
+  getSession,
+  getSessionEvents,
+  listActiveSessions,
+  startSession
+} from './supabase.js';
+import { getConfigPath, mergeConfig, readConfig, writeConfig } from './config.js';
+
+const program = new Command();
+
+program
+  .name('opensession')
+  .description('Session continuity bridge CLI for Supabase')
+  .version('0.1.0');
+
+program
+  .command('init')
+  .description('Initialize CLI config')
+  .requiredOption('--url <url>', 'Supabase project URL')
+  .requiredOption('--anon-key <anonKey>', 'Supabase anon key')
+  .option('--project-key <projectKey>', 'Default project key')
+  .option('--actor <actor>', 'Default actor/username')
+  .action(async (options) => {
+    const current = await readConfig();
+    const next = mergeConfig(current, {
+      supabaseUrl: options.url,
+      supabaseAnonKey: options.anonKey,
+      defaultProjectKey: options.projectKey ?? current.defaultProjectKey,
+      actor: options.actor ?? current.actor
+    });
+
+    const path = await writeConfig(next);
+    console.log(`Config saved: ${path}`);
+  });
+
+program
+  .command('login')
+  .description('Save actor identity used in session events')
+  .requiredOption('--actor <actor>', 'Actor/username')
+  .action(async (options) => {
+    const current = await readConfig();
+    const next = mergeConfig(current, { actor: options.actor });
+    await writeConfig(next);
+    console.log(`Logged in as ${options.actor}`);
+  });
+
+program
+  .command('start')
+  .description('Start a new session and emit a start event')
+  .requiredOption('--project-key <projectKey>', 'Project key')
+  .option('--project-name <projectName>', 'Project display name')
+  .option('--actor <actor>', 'Actor override')
+  .action(async (options) => {
+    const config = await readConfig();
+    const client = getClient(config);
+    const actor = options.actor ?? config.actor ?? 'anonymous';
+
+    const project = await ensureProject(client, options.projectKey, options.projectName);
+    const session = await startSession(client, project.id, actor);
+
+    await writeConfig(
+      mergeConfig(config, {
+        defaultProjectKey: options.projectKey,
+        lastSessionId: session.id
+      })
+    );
+
+    console.log(`Session started: ${session.id}`);
+    console.log(`Project: ${project.project_key}`);
+    console.log(`Actor: ${session.actor}`);
+  });
+
+program
+  .command('resume')
+  .description('Resume an existing session by emitting a resumed event')
+  .requiredOption('--session-id <sessionId>', 'Session id to resume')
+  .option('--actor <actor>', 'Actor override')
+  .action(async (options) => {
+    const config = await readConfig();
+    const client = getClient(config);
+    const actor = options.actor ?? config.actor ?? 'anonymous';
+    const session = await getSession(client, options.sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${options.sessionId}`);
+    }
+
+    const event = await appendEvent(client, session.id, 'resumed', { actor });
+    await writeConfig(mergeConfig(config, { lastSessionId: session.id }));
+
+    console.log(`Session resumed: ${session.id}`);
+    console.log(`Event: ${event.id}`);
+  });
+
+program
+  .command('status')
+  .description('Show active sessions for a project')
+  .option('--project-key <projectKey>', 'Project key (defaults to configured project key)')
+  .action(async (options) => {
+    const config = await readConfig();
+    const client = getClient(config);
+    const projectKey = options.projectKey ?? config.defaultProjectKey;
+
+    if (!projectKey) {
+      throw new Error('Missing project key. Pass --project-key or run start first.');
+    }
+
+    const project = await ensureProject(client, projectKey, projectKey);
+    const active = await listActiveSessions(client, project.id);
+
+    console.log(`Project: ${project.project_key}`);
+
+    if (active.length === 0) {
+      console.log('No active sessions');
+      return;
+    }
+
+    for (const session of active) {
+      console.log(`- ${session.id} | actor=${session.actor} | started=${session.started_at}`);
+    }
+  });
+
+program
+  .command('log')
+  .description('Show session event log')
+  .option('--session-id <sessionId>', 'Session id (defaults to last session)')
+  .option('--limit <limit>', 'Number of events', '50')
+  .action(async (options) => {
+    const config = await readConfig();
+    const client = getClient(config);
+    const sessionId = options.sessionId ?? config.lastSessionId;
+
+    if (!sessionId) {
+      throw new Error('Missing session id. Pass --session-id or run start/resume first.');
+    }
+
+    const events = await getSessionEvents(client, sessionId, Number.parseInt(options.limit, 10));
+
+    if (events.length === 0) {
+      console.log(`No events for session ${sessionId}`);
+      return;
+    }
+
+    for (const event of events) {
+      console.log(`${event.created_at} | ${event.type} | ${JSON.stringify(event.payload)}`);
+    }
+  });
+
+program
+  .command('config-path')
+  .description('Print local config path')
+  .action(() => {
+    console.log(getConfigPath());
+  });
+
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+  }
+}
+
+await main();

package/src/config.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.opensession');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+export async function readConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {};
+    }
+    throw error;
+  }
+}
+
+export async function writeConfig(config) {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  return CONFIG_PATH;
+}
+
+export function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+export function mergeConfig(base, patch) {
+  return { ...base, ...patch };
+}

package/src/supabase.js

@@ -0,0 +1,119 @@
+import { createClient } from '@supabase/supabase-js';
+
+export function getClient(config) {
+  if (!config.supabaseUrl || !config.supabaseAnonKey) {
+    throw new Error('Supabase is not configured. Run `opensession init --url <url> --anon-key <key>`.');
+  }
+
+  return createClient(config.supabaseUrl, config.supabaseAnonKey, {
+    auth: { persistSession: false }
+  });
+}
+
+export async function ensureProject(client, projectKey, projectName) {
+  const { data: existing, error: lookupError } = await client
+    .from('projects')
+    .select('id,project_key,name')
+    .eq('project_key', projectKey)
+    .maybeSingle();
+
+  if (lookupError) {
+    throw lookupError;
+  }
+
+  if (existing) {
+    return existing;
+  }
+
+  const { data: created, error: insertError } = await client
+    .from('projects')
+    .insert({ project_key: projectKey, name: projectName ?? projectKey })
+    .select('id,project_key,name')
+    .single();
+
+  if (insertError) {
+    throw insertError;
+  }
+
+  return created;
+}
+
+export async function startSession(client, projectId, actor) {
+  const { data: session, error: sessionError } = await client
+    .from('sessions')
+    .insert({ project_id: projectId, actor, status: 'active', started_at: new Date().toISOString() })
+    .select('id,project_id,actor,status,started_at')
+    .single();
+
+  if (sessionError) {
+    throw sessionError;
+  }
+
+  const { error: eventError } = await client
+    .from('session_events')
+    .insert({ session_id: session.id, type: 'started', payload: { actor } });
+
+  if (eventError) {
+    throw eventError;
+  }
+
+  return session;
+}
+
+export async function appendEvent(client, sessionId, type, payload = {}) {
+  const { data, error } = await client
+    .from('session_events')
+    .insert({ session_id: sessionId, type, payload })
+    .select('id,session_id,type,payload,created_at')
+    .single();
+
+  if (error) {
+    throw error;
+  }
+
+  return data;
+}
+
+export async function getSession(client, sessionId) {
+  const { data, error } = await client
+    .from('sessions')
+    .select('id,project_id,actor,status,started_at,ended_at')
+    .eq('id', sessionId)
+    .maybeSingle();
+
+  if (error) {
+    throw error;
+  }
+
+  return data;
+}
+
+export async function listActiveSessions(client, projectId) {
+  const { data, error } = await client
+    .from('sessions')
+    .select('id,project_id,actor,status,started_at,ended_at')
+    .eq('project_id', projectId)
+    .eq('status', 'active')
+    .order('started_at', { ascending: false });
+
+  if (error) {
+    throw error;
+  }
+
+  return data;
+}
+
+export async function getSessionEvents(client, sessionId, limit = 50) {
+  const { data, error } = await client
+    .from('session_events')
+    .select('id,session_id,type,payload,created_at')
+    .eq('session_id', sessionId)
+    .order('created_at', { ascending: true })
+    .limit(limit);
+
+  if (error) {
+    throw error;
+  }
+
+  return data;
+}